Egonex-AI Understand-Anything Supported Frameworks: 12 Language Groups and Layer Detection

Egonex-AI Understand-Anything automatically detects frameworks across 12 programming languages—including TypeScript, Python, Java, and Rust—to partition codebases into architectural layers that drive contextual explanations and impact analysis.

The repository Egonex-AI/Understand-Anything implements an I² (Infrastructure-Integration) framework detection step that parses dependency files like package.json, requirements.txt, and Gemfile to map package names to framework identifiers. This detection logic resides in the project-scanner agent and determines how the system categorizes code into presentation, API, and data layers. The framework identifiers are stored in the project.frameworks array and consumed by downstream modules to build knowledge graphs and generate explanations.

Supported Frameworks Across 12 Languages

Understand-Anything supports framework detection across 12 major programming languages, with specific package mappings defined in language-specific markdown files under understand-anything-plugin/skills/understand/languages/. The following table lists the officially supported frameworks by language:

Language	Detected Frameworks
TypeScript	Angular, Next.js, NestJS, Express
JavaScript	Vue, Express, Next.js, Svelte
Python	Django, FastAPI, Flask
Ruby	Rails, RSpec, Grape
PHP	Laravel, Symfony, Slim, CodeIgniter
Java	Spring Boot, Quarkus, Micronaut, Hibernate
Kotlin	Ktor, Exposed, Koin
Go	Gin, Echo, Fiber
Rust	Actix-web, Axum, Rocket
Swift	UIKit, SwiftUI, Vapor, Combine, Core Data
C#	ASP.NET Core, Blazor, xUnit
C++	Qt, Catch2, Google Test, gRPC

Each entry is defined in its respective language file (e.g., typescript.md, python.md) and specifies the dependency patterns that trigger detection.

How Framework Detection Drives Layer Detection

The framework identifiers populated during the I² detection step directly influence how the context-builder and explain-builder modules partition the codebase into architectural layers.

Graph Construction

The project-scanner agent constructs a knowledge graph where nodes represent files, functions, or classes. Detected frameworks are stored in the project.frameworks array according to the JSON schema defined in understand-anything-plugin/agents/project-scanner.md. This array serves as the semantic foundation for layer assignment.

Layer Heuristics

The system uses the layers collection to group nodes by architectural purpose. Framework detection guides these heuristics through specific mapping rules:

• UI frameworks (React, Vue, Angular, SwiftUI, Svelte) → Nodes are placed into the Presentation or UI layer
• Server-side frameworks (NestJS, Express, Django, Flask, Spring Boot, Gin, FastAPI) → Nodes become part of the API or Backend layer
• Data-oriented frameworks (Hibernate, Prisma, TypeORM, Sequelize, gRPC) → Nodes are grouped into the Data layer

The mapping logic in onboard-builder.ts and explain-builder.ts checks whether a node's id appears in a layer's nodeIds list to determine membership.

Cross-Layer Impact Analysis

When code changes touch files belonging to different framework-driven layers, the diff-analyzer module reports a "cross-layer impact" in diff-analyzer.ts. This analysis lists each affected layer by name, enabling developers to understand architectural ripple effects across the stack.

Layer-Specific Explanations

The final explanation output includes an "Architectural Layer" heading derived from the framework mapping. As implemented in explain-builder.ts, the system inserts the layer name and description (e.g., "API Layer" for Express routes) to provide architectural context for code explanations.

Implementation Code Examples

The following TypeScript examples demonstrate how framework detection and layer assignment are implemented in the Understand-Anything codebase.

Detecting frameworks during project scanning:

// Example: Detecting a framework during project scanning
const frameworks = [] as string[];
if (packageJson.dependencies?.['@angular/core']) frameworks.push('Angular');
if (packageJson.dependencies?.['next']) frameworks.push('Next.js');
// ... (similar checks for each language)
// Result stored in the project metadata
project.frameworks = frameworks;

Assigning nodes to layers based on detected frameworks:

// Example: Assigning nodes to a layer based on a detected framework
const uiLayer = {
  id: 'layer:ui',
  name: 'UI Layer',
  description: 'All front‑end components (React, Vue, Angular, etc.)',
  nodeIds: []
};
graph.nodes.forEach(node => {
  if (node.path.match(/\/src\/components\//) && project.frameworks.includes('React')) {
    uiLayer.nodeIds.push(node.id);
  }
});
graph.layers.push(uiLayer);

Rendering layer information in explanations:

// Example: Rendering layer info in an explanation
if (layer) {
  lines.push(`## Architectural Layer: ${layer.name}`);

  lines.push(layer.description);
}

Summary

• Egonex-AI Understand-Anything supports framework detection across 12 programming languages, from TypeScript and Python to Rust and C++.
• The I² framework detection step parses dependency files and populates the project.frameworks array with identifiers like "Django", "Spring Boot", or "React".
• Framework detection drives layer heuristics that partition code into UI, API, and Data layers based on the specific frameworks detected.
• The diff-analyzer uses these layers to report cross-layer impacts, while the explain-builder includes architectural layer context in generated explanations.
• Implementation files include project-scanner.md for detection rules, onboard-builder.ts for layer building, and explain-builder.ts for rendering layer contexts.

Frequently Asked Questions

What file types does the project scanner analyze for framework detection?

The project scanner analyzes standard dependency manifests including package.json for JavaScript/TypeScript, requirements.txt for Python, Gemfile for Ruby, pom.xml or build.gradle for Java, and similar language-specific configuration files. These files are parsed during the I² detection step to identify imported frameworks.

How does Understand-Anything handle projects using multiple frameworks?

When multiple frameworks are detected, the project.frameworks array contains all identified identifiers. The layer heuristics in context-builder.ts and explain-builder.ts can assign nodes to multiple layers or composite layers. For example, a full-stack Next.js application might have nodes assigned to both the UI layer (for frontend components) and the API layer (for API routes).

Can developers customize which frameworks are detected or how they map to layers?

The framework definitions are stored in the language-specific markdown files under understand-anything-plugin/skills/understand/languages/. While the current implementation uses predefined mappings, the modular structure allows for extension by adding new framework entries to these files and updating the layer heuristics in onboard-builder.ts to recognize additional framework identifiers.

What is the difference between the I² framework detection and the layer detection in Understand-Anything?

I² (Infrastructure-Integration) framework detection is the initial parsing phase that identifies which frameworks are present in the codebase by examining dependency files. Layer detection is the subsequent graph analysis phase that uses these framework identifiers to categorize code nodes into architectural layers (Presentation, API, Data) based on heuristic rules defined in the builder modules.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}