Which Frameworks Are Detected by Understand-Anything? Complete Framework Registry Guide

Understand-Anything automatically detects ten major web and server-side frameworks—including React, Django, Spring, and Next.js—by scanning manifest files like package.json and requirements.txt for framework-specific signatures defined in its built-in registry.

Understand-Anything is an AI-powered code analysis tool that identifies the technology stack of any project by inspecting dependency manifests. To answer which frameworks are detected by Understand-Anything, we need to examine the built-in framework registry located in the core language package, which currently supports ten popular frameworks across JavaScript, Python, Java, Go, and Ruby ecosystems.

Complete List of Built-In Frameworks

As of the latest main branch, Understand-Anything recognizes exactly ten frameworks. Each framework is defined by a configuration file in packages/core/src/languages/frameworks/ and registered via builtinFrameworkConfigs in packages/core/src/languages/frameworks/index.ts.

The following frameworks are automatically detected:

• Vue.js (vue) – Detected via vue dependency in package.json. Source: frameworks/vue.ts
• React (react) – Detected via react import or dependency. Source: frameworks/react.ts
• Next.js (nextjs) – Detected via next dependency. Source: frameworks/nextjs.ts
• Express (express) – Node.js web framework detected via express dependency. Source: frameworks/express.ts
• Django (django) – Python framework detected via django in requirements.txt. Source: frameworks/django.ts
• Flask (flask) – Python microframework detected via flask dependency. Source: frameworks/flask.ts
• FastAPI (fastapi) – Python framework detected via fastapi import. Source: frameworks/fastapi.ts
• Spring (spring) – Java framework detected via Spring Boot dependencies. Source: frameworks/spring.ts
• Ruby on Rails (rails) – Ruby framework detected via rails in Gemfile. Source: frameworks/rails.ts
• Gin (gin) – Go web framework detected via github.com/gin-gonic/gin import. Source: frameworks/gin.ts

How Framework Detection Works

The framework detection workflow lives in packages/core/src/languages/framework-registry.ts and operates through a four-stage pipeline:

1. Registry Initialization

At startup, the FrameworkRegistry class is populated with all built-in framework configurations exported from packages/core/src/languages/frameworks/. Each configuration defines the framework's ID, display name, and detection patterns.

2. Manifest Inspection

The FrameworkRegistry.detectFrameworks(manifests) method receives a map of manifest file names to their contents. For each built-in configuration, the system checks whether any identifier listed in the config's detect field appears in the manifest content. For example, a package.json containing "react" will trigger detection for the React framework.

3. Deduplication

Detected frameworks are automatically de-duplicated to prevent duplicate entries when multiple manifests reference the same framework. The result is returned as an array of FrameworkConfig objects.

4. Result Propagation

The detected framework IDs are stored on the project graph at project.frameworks and subsequently surfaced in the onboarding summary, context builder, and LLM prompts throughout the analysis pipeline.

Accessing Detected Frameworks

You can access framework detection results through both the CLI and programmatic APIs.

CLI Output

When running the analysis command, detected frameworks appear in the terminal output and generated documentation:

understand --full

The output includes a line similar to:

| **Frameworks** | React, Express |

Programmatic Usage (TypeScript)

Import the registry directly to detect frameworks in custom scripts:

import { FrameworkRegistry } from "@understand-anything/core/languages/framework-registry.js";
import { readFileSync } from "fs";

// Load a manifest file as a string
const pkgJson = readFileSync("package.json", "utf-8");

// Initialize registry with built-in configs
const registry = FrameworkRegistry.create();

// Detect frameworks
const detected = registry.detectFrameworks({ "package.json": pkgJson });

console.log("Detected frameworks:", detected.map(c => c.id));
// Output: ["react", "express"]

Inside Skills

Framework data is available within skill implementations via the context builder:

import { ContextBuilder } from "@understand-anything/skill";

export async function mySkill(context) {
  const ctx = await ContextBuilder.build(context);
  console.log("Project uses:", ctx.frameworks.join(", "));
  // Access: ctx.frameworks returns string[] of framework IDs
}

Summary

• Understand-Anything detects ten specific frameworks defined in packages/core/src/languages/frameworks/
• Detection relies on scanning manifest files (package.json, requirements.txt, Cargo.toml, etc.) for framework-specific signatures
• The FrameworkRegistry.detectFrameworks() method handles the inspection and deduplication logic
• Detected frameworks are stored in project.frameworks and propagated to the context builder and LLM prompts
• Because the framework list is hard-coded via builtinFrameworkConfigs, the detection set is currently limited to the built-in definitions

Frequently Asked Questions

Can Understand-Anything detect frameworks not in the built-in list?

No. According to the source code analysis, the set of recognizable frameworks is fixed by the configuration files in packages/core/src/languages/frameworks/. Because the registry only loads frameworks defined in builtinFrameworkConfigs (exported from frameworks/index.ts), it cannot detect custom or niche frameworks without modifying the core source files.

How does Understand-Anything distinguish between Flask and FastAPI in the same project?

The framework registry treats each detection independently. If your requirements.txt contains both flask and fastapi, the detectFrameworks method will identify both signatures and return an array containing both framework configurations. Both IDs will be stored in project.frameworks and de-duplicated if duplicates occur across multiple manifest files.

Where is the framework detection logic implemented?

The core detection logic resides in packages/core/src/languages/framework-registry.ts, specifically within the FrameworkRegistry class. The method detectFrameworks(manifests) iterates through the built-in configurations and checks for framework-specific strings in the provided manifest contents. Unit tests confirming this behavior are located at packages/core/src/__tests__/framework-registry.test.ts.

Does Understand-Anything scan source code files for framework imports, or only manifest files?

The detection primarily operates on manifest files (dependency declarations). While the detect field in framework configurations could theoretically contain import patterns, the standard implementation focuses on package.json, requirements.txt, Cargo.toml, and similar dependency manifests. The detectFrameworks method receives a map of manifest file names to their string contents, making manifest-based detection the primary mechanism.

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