Understand Anything

Understand Anything is a tool that transforms codebases, knowledge bases, or documentation into interactive knowledge graphs. It uses a multi-agent pipeline to analyze projects, building a graph of files, functions, classes, and dependencies. This allows developers to visually explore code, search semantically, and understand business logic through different representations.

Key capabilities include:

• Structural Graph Exploration: Navigate code as a graph where nodes (files, functions, classes) provide descriptions and connections.
• Business Logic Mapping: View code mapped to real-world business processes (domains, flows, and steps).
• Knowledge Base Analysis: Use /understand-knowledge on LLM-style wikis to generate force-directed graphs with community clustering.
• Guided Overviews: Automatically generated architectural tours ordered by dependencies.
• Semantic Search: Find code by name or meaning (e.g., "what parts handle authorization?").
• Impact Analysis: Visualize how changes might affect the system before committing.
• Layer Visualization: Automatic grouping by architectural layers (API, Service, Data, UI, Utility).

It is compatible with Claude Code, Codex, Cursor, Copilot, Gemini CLI, and others.

Understand Anything provides a suite of tools for visualizing and analyzing codebases and complex projects. The core feature set includes:

• Interactive Knowledge Graph: Visualize files, functions, and dependencies as an explorable graph with hierarchical drill-down and smart layout.
• Beyond Code Analysis: Analyze entire projects including Dockerfiles, Terraform, SQL, Markdown, and 26+ other file types mapped into a unified graph.
• Smart Filtering & Search: Filter by node type, complexity, layer, or edge category. Supports fuzzy and semantic search.
• Export & Share: Export knowledge graphs as high-quality PNG, SVG, or filtered JSON for documentation or presentations.
• Dependency Path Finder: Find the shortest path between any two components to understand system connections.
• Guided Tours & Onboarding: AI-generated walkthroughs and onboarding guides for new team members.

Understand Anything transforms codebases, knowledge bases, or documentation into interactive, searchable, and conversational knowledge graphs. Key capabilities include:

• Code Structure Exploration: Visualizes files, functions, and classes as interactive nodes with summaries and dependency paths.
• Business Logic Mapping: A domain view that maps code to real-world business processes using horizontal diagrams (domains, flows, and steps).
• Knowledge Base Analysis: Analyzes 'Karpathy-style' LLM Wikis (using index.md with wikilinks) to create interconnected thought maps.
• Guided Learning: Automatically generates architectural learning paths based on dependency order.
• Semantic Search: Supports fuzzy and semantic queries (e.g., "Which parts handle authentication?").
• Change Impact Analysis: Visualizes how code changes affect the rest of the system.
• Hierarchical Visualization: Automatically groups components into layers like API, Service, Data, UI, and System Tools.
• Adaptive UI: Adjusts detail levels based on user roles (Junior Developer, Project Manager, or Advanced User).

The GenericTreeSitterPlugin provides language-agnostic structural analysis. Instead of hardcoded logic, it uses the LanguageRegistry to fetch a LanguageConfig and then extracts nodes (functions, classes, imports, etc.) based on the nodeTypes defined in that config.

If a customAnalyzer is provided in the LanguageConfig, the plugin will bypass generic extraction and use that custom function to analyze the AST instead.

// Example of how the plugin uses the config
async analyzeFile(filePath: string, content: string): Promise<FileAnalysis> {
  const config = this.registry.getByExtension(path.extname(filePath));

  if (config.customAnalyzer) {
    return config.customAnalyzer(tree.rootNode);
  }

  const functions = this.extractNodes(tree, config.treeSitter.nodeTypes.function);
  const classes = this.extractNodes(tree, config.treeSitter.nodeTypes.class);
  // ...
}

The LanguageConfig object is the core definition for making the system language-agnostic. It defines how a specific language is parsed using Tree-sitter and what high-level concepts it contains.

Key fields include:

• id: Unique identifier for the language (e.g., python).
• displayName: Human-readable name.
• extensions: Array of file extensions associated with the language (e.g., ['.py', '.pyi']).
• treeSitter: Configuration for the Tree-sitter parser:
  • grammarPackage: The name of the grammar package.
  • wasmFile: The path to the .wasm file.
  • nodeTypes: Mapping of language constructs to Tree-sitter node names (e.g., function, class, import, export, typeAnnotation).
• concepts: An array of domain-specific terms used for prompting (e.g., ['decorators', 'generators']).
• filePatterns: (Optional) A record mapping configuration types to filenames (e.g., { config: 'pyproject.toml' }).

const config = {
  id: "python",
  displayName: "Python",
  extensions: [".py", ".pyi"],
  treeSitter: {
    grammarPackage: "tree-sitter-python",
    wasmFile: "tree-sitter-python.wasm",
    nodeTypes: {
      function: ["function_definition"],
      class: ["class_definition"],
      import: ["import_statement", "import_from_statement"],
      export: [],
      typeAnnotation: ["type"],
    },
  },
  concepts: ["decorators", "list comprehensions", "generators"],
};