# Egonex-AI Understand Anything Dependencies: Complete Monorepo Package Guide

> Explore the dependencies for Egonex-AI Understand Anything monorepo. Discover how Core, Skill, and Dashboard packages work together with pnpm workspaces and advanced libraries.

- Repository: [Egonex/Understand-Anything](https://github.com/Egonex-AI/Understand-Anything)
- Tags: api-reference
- Published: 2026-06-26

---

**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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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:

```typescript
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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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:

```typescript
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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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:

```tsx
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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/packages/dashboard/package.json)) combines **React**, **@xyflow/react**, and layout engines (**dagre**, **elkjs**) to visualize knowledge graphs
- The **root** [`package.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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`](https://github.com/Egonex-AI/Understand-Anything/blob/main/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.