Egonex-AI Understand Anything Dependencies: Complete Monorepo Package Guide

Egonex-AI Understand Anything uses a pnpm workspace monorepo with three interconnected packages—Core, Skill, and Dashboard—where the Core engine bundles tree-sitter parsers for 10+ languages, the Skill package integrates graphology with Claude Code, and the Dashboard renders knowledge graphs using React and @xyflow/react.

The repository is organized as a static analysis toolchain that transforms codebases into navigable knowledge graphs. Understanding the dependency structure is essential for contributors extending language support or integrating the engine into custom workflows.

Core Engine Dependencies (@understand-anything/core)

The Core package provides the static analysis pipeline, language grammars, and graph schema. Located at understand-anything-plugin/packages/core/package.json, it ships with web-tree-sitter for WASM-based parsing and zod for runtime schema validation.

The package bundles tree-sitter grammars for multiple languages:

• @tree-sitter-grammars/tree-sitter-kotlin
• @understand-anything/tree-sitter-dart-wasm
• tree-sitter-c, tree-sitter-csharp, tree-sitter-go
• tree-sitter-java, tree-sitter-javascript, tree-sitter-php
• tree-sitter-python, tree-sitter-ruby, tree-sitter-rust
• tree-sitter-typescript

Additional runtime dependencies include fuse.js for fuzzy search, ignore for gitignore pattern matching, and yaml for configuration parsing. Development dependencies include Vitest, TypeScript, and @types/node.

The following example demonstrates consuming the Core search API:

import { search } from '@understand-anything/core/search';

const results = await search({
  query: 'async function',
  language: 'typescript',
  maxResults: 10,
});

console.log(results);

Skill Package Dependencies (@understand-anything/skill)

The Skill package acts as the Claude Code plugin entry point, wiring the Core engine into the Claude ecosystem. Defined in understand-anything-plugin/package.json, it minimally depends on @understand-anything/core and adds graph analysis capabilities through graphology and graphology-communities-louvain for community detection algorithms.

Development dependencies are limited to TypeScript, Vitest, and @types/node, keeping the runtime footprint small as the package primarily re-exports Core functionality with Claude-specific adapters.

The following example demonstrates building a knowledge graph in the Skill package:

import { buildGraph } from '@understand-anything/skill';
import { Graph } from 'graphology';

const graph = new Graph();
await buildGraph({ root: '/my/project', graph });
console.log('Graph node count:', graph.order);

Dashboard Dependencies (@understand-anything/dashboard)

The Dashboard is a React TypeScript application that visualizes the knowledge graph. Located at understand-anything-plugin/packages/dashboard/package.json, it consumes the Core APIs via the @understand-anything/core workspace dependency while managing UI state with zustand.

Key runtime dependencies include:

• react and react-dom for component rendering
• @xyflow/react for node-based graph editing and interaction
• @dagrejs/dagre and elkjs for hierarchical graph layout algorithms
• d3-force for force-directed simulations
• graphology and graphology-types for graph data structures
• react-markdown and prism-react-renderer for documentation rendering
• hast-util-to-jsx-runtime for HTML transformation

Build dependencies include Vite, TailwindCSS, @vitejs/plugin-react, and @tailwindcss/vite.

The following example demonstrates rendering the graph in the Dashboard:

import { GraphView } from '@understand-anything/dashboard';
import { useGraph } from '@understand-anything/core';

export default function App() {
  const graph = useGraph(); // hook from core
  return <GraphView graph={graph} />;
}

Root Workspace Configuration

The root package.json defines the pnpm workspace structure but ships no runtime dependencies. It orchestrates the monorepo using the workspace protocol (workspace:*) to link the three packages, ensuring that local changes in Core immediately propagate to Skill and Dashboard without publishing interim versions.

The root configuration also pins the pnpm version and defines global scripts for linting (ESLint), testing (Vitest), and type checking (TypeScript) that operate across the entire workspace.

Browser-Safe Architecture

The Core package exposes sub-path exports (./search, ./types, ./schema, ./languages) that allow the Dashboard to import only browser-compatible modules. This design prevents Node-only modules from leaking into the client bundle while the web-tree-sitter dependency provides WASM-based parsing compatible with browser environments.

The Core engine is deliberately structured so that the Dashboard can execute static analysis entirely in the browser without requiring a Node.js backend, as implemented in understand-anything-plugin/src/agents/project-scanner.ts.

Summary

• Egonex-AI Understand Anything uses a pnpm workspace monorepo with three packages: Core, Skill, and Dashboard
• The Core (understand-anything-plugin/packages/core/package.json) bundles tree-sitter parsers for 10+ languages, fuse.js, zod, and web-tree-sitter
• The Skill (understand-anything-plugin/package.json) depends on Core plus graphology for graph algorithms and Claude Code integration
• The Dashboard (understand-anything-plugin/packages/dashboard/package.json) combines React, @xyflow/react, and layout engines (dagre, elkjs) to visualize knowledge graphs
• The root package.json contains only dev tools and workspace scripts, with no runtime dependencies

Frequently Asked Questions

What package manager does Egonex-AI Understand Anything use?

The project uses pnpm with workspaces to manage the monorepo structure. According to the root package.json, the pnpm version is pinned, and individual packages reference each other using the workspace:* protocol to ensure local changes are reflected immediately across the Core, Skill, and Dashboard packages.

Which programming languages does the Core engine support?

The Core engine supports C, C#, Go, Java, JavaScript, Kotlin, PHP, Python, Ruby, Rust, TypeScript, and Dart through dedicated tree-sitter grammar packages. These are listed as runtime dependencies in understand-anything-plugin/packages/core/package.json, enabling the static analysis pipeline to parse these languages into abstract syntax trees for graph generation.

Can I use the Core package in browser applications?

Yes, the Core package is designed to be browser-safe through sub-path exports. The Dashboard imports specific modules like ./search, ./types, ./schema, and ./languages that exclude Node-only code, while the web-tree-sitter dependency provides WASM-based parsing compatible with browser environments as demonstrated in the Dashboard implementation.

How do the packages reference each other in the monorepo?

Packages use the workspace protocol (workspace:*) in their package.json files to reference local dependencies. For example, the Skill and Dashboard packages declare "@understand-anything/core": "workspace:*", ensuring they always use the local version of Core during development rather than fetching from a registry, as configured in the root workspace file.

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