Egonex-AI/Understand-Anything

This system is a codebase analysis plugin and interactive dashboard designed to automatically build and maintain a knowledge graph of software projects. It ingests source code, design files, and configuration artifacts to extract structural, semantic, and domain-level insights using deterministic parsing and LLM-assisted analysis. The system provides a secure, token-gated web interface for visualizing these graphs, exploring code relationships, and reviewing changes, while supporting incremental updates to keep the knowledge base synchronized with the codebase.

The core plugin system now includes built-in parsers for Dockerfiles, .env files, GraphQL schemas, JSON/JSONC, Makefiles, Markdown, Protocol Buffers, shell scripts, SQL, Terraform, TOML, and YAML. These parsers extract structural information such as build stages and ports (Docker), environment variables (.env), type definitions and endpoints (GraphQL), top-level sections and references (JSON), build targets (Makefile), document headings and local links (Markdown), message and service definitions (Protobuf), function definitions and source references (Shell), database objects (SQL), infrastructure resources and variables (Terraform), configuration sections (TOML), and top-level keys or array entries (YAML). A central registration function wires all 12 parsers into the plugin registry, ensuring these file types are recognized and analyzed for structure rather than falling through to a generic handler.

understand-anything-plugin/packages/core/src/plugins/parsers · high confidence

The plugin now includes a pre-built \tree-sitter-swift.wasm\ artifact, enabling Swift code parsing in WebAssembly-based environments. This change addresses the lack of WASM support in the upstream \tree-sitter-swift\ npm package by vendoring a compatible grammar built from commit \d42e9bb\ of \alex-pinkus/tree-sitter-swift\. Users can now analyze Swift source files in browser or WASM contexts without requiring native prebuilds or external C dependencies.

understand-anything-plugin/packages/tree-sitter-swift-wasm · high confidence

The plugin now automatically updates its internal knowledge graph after code commits without requiring user confirmation. This is achieved through new hook definitions in \hooks.json\ that trigger a \PostToolUse\ handler (\post-tool-use-auto-update.mjs\) when a git commit is detected, and a \SessionStart\ check for stale graphs. The handler reads commit context from stdin, verifies that auto-update is enabled in the project's config, and instructs the agent to execute the detailed incremental update protocol defined in the new \auto-update-prompt.md\. This prompt outlines a multi-phase process (pre-flight, targeted file analysis, merge, architecture/tour updates, and atomic save) to keep the knowledge graph synchronized with the codebase efficiently.

understand-anything-plugin/hooks · high confidence

The dashboard now supports internationalization (i18n) for all user-facing strings, including navigation, filters, code viewer, and guided tours. Users can now see the interface in English, Simplified Chinese, Traditional Chinese, Japanese, Korean, and Russian, with the system automatically resolving the locale based on browser settings or explicit selection.

understand-anything-plugin/packages/dashboard/src/locales · high confidence

The dashboard application is now available, featuring a token-gated entry point that validates access via a session token (or bypasses it in demo mode). It loads and validates knowledge and domain graphs, surfacing validation issues and warnings when graphs are stale or dirty. The UI supports responsive layouts for mobile devices, customizable themes with a 'dark luxury' aesthetic, and keyboard shortcuts for navigation. Users can filter nodes by type and category, toggle diff modes to see changes, and explore code via a lazy-loaded viewer.

understand-anything-plugin/packages/dashboard/src · high confidence

The dashboard now includes a new theming system that allows users to switch between five visual presets (Dark Gold, Dark Ocean, Dark Forest, Dark Rose, and Light Minimal) and customize accent colors within each preset. The system also supports changing the heading font style (serif, sans, or mono). Theme preferences are automatically saved to the browser's local storage and restored on subsequent visits, ensuring a consistent look across sessions.

understand-anything-plugin/packages/dashboard/src/themes · high confidence

The plugin now includes a comprehensive, config-driven registry for analyzing a much wider variety of code and non-code files. This update adds built-in language configurations for 16 additional programming languages (including C, C++, C\#, Dart, Kotlin, Swift, and Lua) and 26 non-code formats (such as Docker, Kubernetes, Terraform, GitHub Actions, and various data formats like CSV and JSON Schema). It also introduces framework detection configurations for popular stacks like React, Next.js, Spring Boot, Django, and Rails, enabling the tool to recognize specific entry points, test patterns, and architectural layers within these ecosystems.

understand-anything-plugin/packages/core/src/languages/configs · high confidence

The core plugin layer now uses a \PluginRegistry\ to map file extensions to analyzer plugins, replacing hardcoded lookups with a \LanguageRegistry\ for extensible language support. A new \discovery.ts\ module provides \parsePluginConfig\ and \serializePluginConfig\ to manage plugin enablement and language lists via JSON configuration, defaulting to the tree-sitter plugin. The \TreeSitterPlugin\ implementation now accepts \LanguageConfig\ objects to dynamically load WASM grammars and registers built-in extractors for TypeScript, JavaScript, Python, Go, Rust, Java, Ruby, PHP, C/C++, C\#, Dart, Kotlin, Swift, and Scala. Structural analysis is enhanced with a new \symbol-evidence\ system that tracks runtime method installers (e.g., Ruby \attr\, Python \setattr\, JS \defineProperty\) and declaration coverage gaps, while \symbol-scopes\ provides precise lexical scope resolution for class expressions and local bindings. The registry also exposes \extractCallGraph\ and \analyzeFileFull\ for unified structural and call-graph analysis.

understand-anything-plugin/packages/core/src/plugins · high confidence

The core plugin now uses dedicated \LanguageRegistry\ and \FrameworkRegistry\ classes to manage language and framework configurations. This change enables detection based on file extensions, specific filenames (e.g., \Makefile\), and manifest file contents (e.g., scanning \requirements.txt\ for keywords). It also introduces a \FrameworkConfig\ schema that allows frameworks to be detected via manifest files and keywords, supporting a more robust, config-driven analysis approach for non-code languages.

understand-anything-plugin/packages/core/src/languages · high confidence

The core package now includes a change-classifier that automatically determines whether a codebase update requires a full rebuild, an architecture re-analysis, or a partial update based on the volume and type of structural changes. It also adds a semantic search engine powered by vector embeddings and cosine similarity, allowing users to query the knowledge graph using natural language concepts rather than just exact names. Additionally, the core now exports an ignore-filter and generator to manage file exclusions via .understandignore patterns, and extends the graph schema with new node and edge types for domain, knowledge, and design (Figma) contexts.

understand-anything-plugin/packages/core/src · high confidence

Adds the /understand-domain skill, which extracts business domains, flows, and process steps from a codebase to generate an interactive domain flow graph in the dashboard. The skill operates in two modes: it derives knowledge from an existing knowledge graph (\.ua/knowledge-graph.json\ or legacy \.understand-anything/\) for efficiency, or performs a lightweight scan using the new \extract-domain-context.py\ script to build raw context (file tree, entry points, exports) when no graph exists. The implementation includes robust environment handling, such as redirecting output to the main repository root when inside a git worktree, resolving the plugin root across various installation methods (symlinks, standard installs), and supporting both new \.ua/\ and legacy \.understand-anything/\ data directories.

understand-anything-plugin/skills/understand-domain · high confidence

Users can now analyze Figma design files to generate an interactive design knowledge graph. This new skill fetches pages, screens, components, and design tokens via the Figma REST API, enriches them with LLM analysis, and outputs a structured graph to the project's data directory (\.ua/\ or legacy \.understand-anything/\). It supports incremental updates by skipping re-analysis if the Figma file version is unchanged, while still refreshing expiring screen thumbnails to keep the dashboard visuals current.

understand-anything-plugin/skills/understand-figma · high confidence

Adds a new skill that detects and analyzes Karpathy-pattern LLM wikis (structured with raw sources, wiki markdown, and schema files) to generate an interactive knowledge graph. The skill includes Python scripts to parse the wiki structure, extract entities and relationships, and merge LLM-generated analysis into a final graph, along with a detailed instruction set for orchestrating the detection, scanning, analysis, and saving phases.

understand-anything-plugin/skills/understand-knowledge · high confidence

This change introduces the core logic for ingesting and analyzing Figma design files. It adds a deterministic parser that converts Figma documents into a structured graph of pages, screens, components, and instances, while correctly mapping published component keys and capturing screen dimensions. The integration also extracts design tokens by bridging local style references to published keys, attributes token usage to the nearest structural ancestor (handling nested styled layers), and applies screen thumbnails for visual previews. A merge utility combines this manifest with external analysis data to produce a validated 'kind:design' knowledge graph with organized layers and a guided tour. The implementation includes a secure API source that retrieves data via environment-based tokens without leaking secrets, and a barrel export for the new Figma module.

understand-anything-plugin/packages/core/src/figma · high confidence

This change introduces the foundational analysis engine for the Understand Anything plugin, adding several new modules to the core analyzer package. The GraphBuilder constructs a knowledge graph from source files, structural analysis, and non-code assets, creating typed nodes (files, functions, classes, services, etc.) and edges (imports, calls, contains). The LLM analyzer handles prompting and parsing for file-level analysis and project summaries, normalizing complexity and handling markdown-wrapped JSON. A language-agnostic lesson system detects programming concepts and generates LLM prompts for language-specific explanations. Heuristic and LLM-driven layer detection organizes files into architectural layers (API, Service, Data, UI, etc.). Node ID normalization ensures consistent, prefix-based identifiers across the graph, and a tour generator creates guided codebase walkthroughs using both LLM and topological-sort strategies. Comprehensive test coverage is added for the GraphBuilder and LLM analyzer.

understand-anything-plugin/packages/core/src/analyzer · high confidence

Added \scripts/benchmark-large-repo.mjs\ to run deterministic performance benchmarks on large repositories, producing JSON and Markdown reports with resource usage metrics (CPU, memory) captured via a dedicated stage worker. Included \scripts/generate-large-graph.mjs\ to create synthetic knowledge graphs (default 3,000 nodes) for testing, with a \--messy\ flag to inject data quality issues (null fields, type aliases, missing references) that validate the dashboard's robustness pipeline. These scripts support performance testing and validation workflows by providing reproducible large-scale data and measurement tools.

scripts · high confidence

The core package now includes a new persistence module that saves and loads knowledge graphs, metadata, fingerprints, and configuration to JSON files within a project-specific data directory. This implementation introduces a security improvement by sanitizing absolute file paths in graph nodes before writing them to disk, ensuring that sensitive directory structures (such as home directories) are not leaked into stored files. It also supports a legacy directory name (\.understand-anything\) for existing projects while using a new shorter name (\.ua\) for fresh projects, with automatic fallback to the legacy name if detected. The module provides functions for saving and loading domain graphs, knowledge graphs, analysis metadata, file fingerprints, and project configuration, with optional validation during graph loading to ensure data integrity.

understand-anything-plugin/packages/core/src/persistence · high confidence

The understand-anything-plugin/src directory now contains the core implementation files for the plugin, including context-builder.ts, diff-analyzer.ts, explain-builder.ts, onboard-builder.ts, understand-chat.ts, and index.ts. These files provide the functionality to build chat contexts from knowledge graphs, analyze code diffs for impact, generate explanations for specific components, create onboarding guides, and construct chat prompts for LLM consumption.

understand-anything-plugin/src · high confidence

The core plugin now includes dedicated extractors for TypeScript, Python, Go, Rust, Java, Ruby, PHP, C/C++, C\#, Dart, Kotlin, Swift, and Scala. Each extractor uses tree-sitter to parse source files and produce a standardized structural analysis (functions, classes, imports, exports) and a call graph, enabling the Understand Anything plugin to understand the architecture and dependencies of codebases in these languages.

understand-anything-plugin/packages/core/src/plugins/extractors · high confidence

The dashboard has been redesigned with a dark luxury theme and introduces several new capabilities for exploring knowledge graphs. Users can now view domain-level overviews and drill into specific domains to see associated flows and steps via the new DomainGraphView. A new CodeViewer component allows users to inspect source code and rendered markdown for graph nodes. The interface now supports a diff mode to highlight changed and affected nodes, and includes a FilterPanel to filter the graph by node type, complexity, layers, and edge categories. Navigation is enhanced with a Breadcrumb component and a FileExplorer for file-based navigation. The graph rendering uses ELK for layout and supports container nodes for grouping.

understand-anything-plugin/packages/dashboard/src/components · high confidence

The repository is now structured as a pnpm monorepo with workspace definitions, TypeScript strict-mode configuration, and ESLint rules for TypeScript. A new .gitignore prevents sensitive or build artifacts from being committed, and install scripts for Windows (PowerShell) and Unix (Bash) are provided to support multiple AI coding platforms. Documentation files including CLAUDE.md, CONTRIBUTING.md, LICENSE, SECURITY.md, and CODE\_OF\_CONDUCT.md have been added to standardize development workflows and community guidelines.

(repo-wide) · high confidence

Users can now inspect generated knowledge graphs without needing Claude Code, an LLM, or an API key. A new standalone viewer package allows running the interactive dashboard directly from GitHub release assets using npx (e.g., \npx \<release-tarball\> /path/to/project\). The viewer serves the dashboard read-only from the local disk, binding to 127.0.0.1 and gating access with a one-time token, requiring only Node.js \>= 18.

understand-anything-plugin/packages/viewer · high confidence

The dashboard now supports localized UI text via a new I18n context, allowing users to see interface elements in their preferred language. It also includes a source code viewer that lets users preview files referenced in the knowledge graph, with strict path validation to prevent directory traversal. Additionally, the dashboard server now requires an access token (configurable via the UNDERSTAND\_ACCESS\_TOKEN environment variable) to serve graph data and source files, enhancing security for the auto-opened dashboard URL.

understand-anything-plugin/packages/dashboard · high confidence

The dashboard's rendering performance and layout engine have been significantly improved. Filtering operations (nodes and edges) are now O(1) per item by using precomputed indices, eliminating the previous quadratic slowdown on large graphs. The layout system has migrated from Dagre to ELK for structural views, with a new repair pipeline to handle invalid graph inputs. Additionally, expensive force-layout simulations are now offloaded to Web Workers to keep the main thread responsive, and community detection uses a memory-safe Louvain implementation.

understand-anything-plugin/packages/dashboard/src/utils · high confidence

The homepage now supports a custom domain (understand-anything.com) and features a new brand identity, including a custom 'U' favicon and alignment with the Understand Anything visual style.

homepage/public · high confidence

The homepage has been rebuilt as a static site using the Astro framework, replacing the previous implementation. This change updates the site's domain to understand-anything.com and introduces a new project structure with TypeScript support, allowing for local development and static site generation via pnpm commands.

homepage · high confidence

The homepage has been completely refreshed with a new visual identity aligned to the Egonex brand, including a redesigned navigation bar, hero section, and footer. New content sections have been added to explain the product's value proposition (Problem), showcase the interactive dashboard (Showcase), highlight key capabilities (Features), and provide installation instructions (Install). The page now also embeds a live demo iframe and a community walkthrough video from Better Stack, replacing previous static media.

homepage/src · high confidence

The vendored tree-sitter-dart WASM grammar has been rebuilt to use the newer dylink.0 custom section format. This change ensures the grammar loads correctly with web-tree-sitter 0.26.x, resolving previous failures where the older upstream WASM artifact was rejected due to an outdated dylink section name.

understand-anything-plugin/packages/tree-sitter-dart-wasm · high confidence

The /understand skill now uses dedicated, bundled scripts (build-fingerprints.mjs, compute-batches.mjs, extract-import-map.mjs, extract-structure.mjs, finalize-incremental.mjs, generate-ignore.mjs, merge-batch-graphs.py) instead of LLM-generated regex or prose-based resolvers. This change ensures deterministic structural extraction, import resolution, batch computation, and incremental graph finalization, fixing silent auto-update breakages and improving reliability across platforms (including Windows path handling and symlinked plugin roots).

understand-anything-plugin/skills/understand · high confidence

Added end-to-end tests for the standalone viewer; Added performance benchmarking scripts for dashboard aggregation and layout; Added regression tests for dashboard node/edge filtering, graph freshness, and navigation cache; Added test coverage for dashboard graph utilities; Added tests for installer platform table consistency; Added tests for large-repo benchmark determinism and report schema validation; Added tests for the PostToolUse auto-update hook; Added tests for the Understand skill's batch computation, import map extraction, and incremental symbol validation; Added tests for title-case infra file detection and wiki link resolution; Added unit tests for multi-language structural extractors; Added unit tests for plugin context builders, graph merging, and worktree handling; Expanded test coverage for core analysis and configuration logic.

This change introduces the foundational dependency manifests for the Understand-Anything monorepo, establishing the workspace structure and specifying the versions for all core libraries. It defines the root \package.json\ with pnpm workspaces and dev dependencies (ESLint, TypeScript, Vitest), and configures the \homepage\ package with Astro 6.1.6. The \@understand-anything/core\ package is set up with tree-sitter grammars for multiple languages (C, C++, C\#, Go, Java, JavaScript, PHP, Python, Ruby, Rust, Scala, TypeScript, Kotlin), plus Fuse.js, Zod, and web-tree-sitter. The \@understand-anything/dashboard\ package depends on React 19, Vite 6, Tailwind CSS 4, Zustand, and graph visualization libraries (Dagre, ELKJS, D3-force, Graphology). Additionally, vendored WASM grammar packages for Dart and Swift are introduced to support web-tree-sitter.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 44 → 50 (+5.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 60 → 61 (+0.7)
• Architecture 92 → 88 (-4.0)
• Maturity 75 → 62 (-13.8)
• Readiness 22 → 42 (+19.2)
• Security 58 → 54 (-3.9)
• Accessibility 55 (new)
• Performance 60 (new)

• Change coupling: en.ts ↔ ja.ts (understand-anything-plugin/packages/dashboard/src/locales/en.ts)
• Change coupling: en.ts ↔ ko.ts (understand-anything-plugin/packages/dashboard/src/locales/en.ts)
• Change coupling: en.ts ↔ zh-TW.ts (understand-anything-plugin/packages/dashboard/src/locales/en.ts)
• Change coupling: en.ts ↔ zh.ts (understand-anything-plugin/packages/dashboard/src/locales/en.ts)
• Change coupling: ja.ts ↔ ko.ts (understand-anything-plugin/packages/dashboard/src/locales/ja.ts)
• Change coupling: ja.ts ↔ zh-TW.ts (understand-anything-plugin/packages/dashboard/src/locales/ja.ts)
• Change coupling: ja.ts ↔ zh.ts (understand-anything-plugin/packages/dashboard/src/locales/ja.ts)
• Change coupling: ko.ts ↔ zh-TW.ts (understand-anything-plugin/packages/dashboard/src/locales/ko.ts)
• Change coupling: ko.ts ↔ zh.ts (understand-anything-plugin/packages/dashboard/src/locales/ko.ts)
• Change coupling: zh-TW.ts ↔ zh.ts (understand-anything-plugin/packages/dashboard/src/locales/zh-TW.ts)
• Consequences/trade-offs are absent despite a concrete goal and architecture (docs/superpowers/plans/2026-03-27-token-reduction-impl.md)
• Context injection task is cut at 'readm' by the scanner clip marker; consequences/trade-offs are not visible (docs/superpowers/plans/2026-03-18-multi-platform-simple-implementation.md)
• Context/problem and consequences/trade-offs are absent from the visible text (docs/superpowers/plans/2026-03-15-homepage-implementation.md)
• Context/problem and consequences/trade-offs are absent; only a task-by-task scaffolding plan is present (docs/superpowers/plans/2026-03-14-phase1-implementation.md)
• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (tests/skill/understand/test_merge_batch_graphs.py)
• Duplicated block (10 lines × 2) (tests/skill/understand/test_merge_batch_graphs.py)
• Duplicated block (11 lines × 2) (tests/skill/understand/test_merge_batch_graphs.py)
• …and 82 more

• App.Dashboard (cognitive 33) (understand-anything-plugin/packages/dashboard/src/App.tsx)
• App.Dashboard (cyclomatic 30) (understand-anything-plugin/packages/dashboard/src/App.tsx)
• App.DashboardContent (cognitive 41) (understand-anything-plugin/packages/dashboard/src/App.tsx)
• App.DashboardContent (cyclomatic 52) (understand-anything-plugin/packages/dashboard/src/App.tsx)
• CSharpExtractor.extractCallGraph (cognitive 20) (understand-anything-plugin/packages/core/src/plugins/extractors/csharp-extractor.ts)
• CodeViewer.CodeViewer (cognitive 25) (understand-anything-plugin/packages/dashboard/src/components/CodeViewer.tsx)
• CodeViewer.CodeViewer (cyclomatic 30) (understand-anything-plugin/packages/dashboard/src/components/CodeViewer.tsx)
• ContainerNode.ContainerNodeComponent (cyclomatic 16) (understand-anything-plugin/packages/dashboard/src/components/ContainerNode.tsx)
• CppExtractor.extractClassOrStruct (cognitive 61) (understand-anything-plugin/packages/core/src/plugins/extractors/cpp-extractor.ts)
• CppExtractor.extractClassOrStruct (cyclomatic 21) (understand-anything-plugin/packages/core/src/plugins/extractors/cpp-extractor.ts)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical vulnerability: [GHSA redacted] (pnpm-lock.yaml)
• CustomNode.CustomNodeComponent (cognitive 16) (understand-anything-plugin/packages/dashboard/src/components/CustomNode.tsx)
• DartExtractor.extractCallGraph (cognitive 31) (understand-anything-plugin/packages/core/src/plugins/extractors/dart-extractor.ts)
• DartExtractor.extractCallGraph (cyclomatic 18) (understand-anything-plugin/packages/core/src/plugins/extractors/dart-extractor.ts)
• DartExtractor.extractCalleeName (cognitive 19) (understand-anything-plugin/packages/core/src/plugins/extractors/dart-extractor.ts)
• DockerfileParser.extractStages (cognitive 22) (understand-anything-plugin/packages/core/src/plugins/parsers/dockerfile-parser.ts)
• Documentation: no project overview (README.md)
• ExportMenu.ExportMenu (cognitive 26) (understand-anything-plugin/packages/dashboard/src/components/ExportMenu.tsx)
• ExportMenu.ExportMenu (cyclomatic 25) (understand-anything-plugin/packages/dashboard/src/components/ExportMenu.tsx)
• …and 306 more

• 81 commits — 24 feature/other, 57 fixes

• tests/skill — 32 commits
• understand-anything-plugin/skills — 13 commits
• understand-anything-plugin/packages — 12 commits
• (repo) — 10 commits
• docs/incremental — 5 commits
• .claude-plugin/plugin.json — 3 commits
• tests/benchmark — 3 commits
• (root) — 2 commits
• understand-anything-plugin/hooks — 1 commit

• fix: Merge pull request #634 from SulimanAbdulrazzaq/fix/auto-update-generated-artifacts
• fix: Merge pull request #682 from Egonex-AI/fix/incremental-correctness-token-cost
• fix: Merge pull request #683 from Egonex-AI/fix/incremental-symbol-loss-680
• fix: Merge pull request #685 from FumasterLin/fix/kimi-kimi-code-skills-dir
• fix: Merge pull request #686 from dajiaohuang/fix/extract-structure-unreadable-files
• fix: Merge pull request #687 from dajiaohuang/fix/install-ps1-kimi-skills-path
• fix: Merge pull request #689 from ZHCHJ888/fix/swift-test-coverage
• fix: fix(batching): use JSON changed-file handoff
• fix: fix(core): account for parameter-property declaration coverage
• fix: fix(core): apply assignment evidence to TSX and JSX grammars
• fix: fix(core): classify updates from before and after inventories
• fix: fix(core): distinguish unbound class expression scopes
• fix: fix(core): retain class expression and Ruby alias evidence
• fix: fix(core): retain receiver ownership in structural extraction
• fix: fix(fingerprints): classify non-code edits conservatively
• fix: fix(fingerprints): detect callable receiver changes
• fix: fix(fingerprints): reanalyze changed unresolved receiver identities
• fix: fix(graph): accept data-file coverage nodes
• fix: fix(graph): reconcile refreshed import edges
• fix: fix(graph): refresh incremental project metadata
• …and 61 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Egonex-AI/Understand-Anything was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.