@veewo/gitnexus 1.3.4

package/dist/storage/repo-manager.js

@@ -0,0 +1,257 @@
+/**
+ * Repository Manager
+ *
+ * Manages GitNexus index storage in .gitnexus/ at repo root.
+ * Also maintains a global registry at ~/.gitnexus/registry.json
+ * so the MCP server can discover indexed repos from any cwd.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const REPO_ALIAS_REGEX = /^[a-zA-Z0-9._-]{3,64}$/;
+function normalizeRepoAlias(repoAlias) {
+    if (!repoAlias)
+        return undefined;
+    const trimmed = repoAlias.trim();
+    if (!trimmed)
+        return undefined;
+    if (!REPO_ALIAS_REGEX.test(trimmed)) {
+        throw new Error('Invalid repo alias. Use ^[a-zA-Z0-9._-]{3,64}$');
+    }
+    return trimmed;
+}
+const GITNEXUS_DIR = '.gitnexus';
+// ─── Local Storage Helpers ─────────────────────────────────────────────
+/**
+ * Get the .gitnexus storage path for a repository
+ */
+export const getStoragePath = (repoPath) => {
+    return path.join(path.resolve(repoPath), GITNEXUS_DIR);
+};
+/**
+ * Get paths to key storage files
+ */
+export const getStoragePaths = (repoPath) => {
+    const storagePath = getStoragePath(repoPath);
+    return {
+        storagePath,
+        kuzuPath: path.join(storagePath, 'kuzu'),
+        metaPath: path.join(storagePath, 'meta.json'),
+    };
+};
+/**
+ * Load metadata from an indexed repo
+ */
+export const loadMeta = async (storagePath) => {
+    try {
+        const metaPath = path.join(storagePath, 'meta.json');
+        const raw = await fs.readFile(metaPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Save metadata to storage
+ */
+export const saveMeta = async (storagePath, meta) => {
+    await fs.mkdir(storagePath, { recursive: true });
+    const metaPath = path.join(storagePath, 'meta.json');
+    await fs.writeFile(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+};
+/**
+ * Check if a path has a GitNexus index
+ */
+export const hasIndex = async (repoPath) => {
+    const { metaPath } = getStoragePaths(repoPath);
+    try {
+        await fs.access(metaPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Load an indexed repo from a path
+ */
+export const loadRepo = async (repoPath) => {
+    const paths = getStoragePaths(repoPath);
+    const meta = await loadMeta(paths.storagePath);
+    if (!meta)
+        return null;
+    return {
+        repoPath: path.resolve(repoPath),
+        ...paths,
+        meta,
+    };
+};
+/**
+ * Find .gitnexus by walking up from a starting path
+ */
+export const findRepo = async (startPath) => {
+    let current = path.resolve(startPath);
+    const root = path.parse(current).root;
+    while (current !== root) {
+        const repo = await loadRepo(current);
+        if (repo)
+            return repo;
+        current = path.dirname(current);
+    }
+    return null;
+};
+/**
+ * Add .gitnexus to .gitignore if not already present
+ */
+export const addToGitignore = async (repoPath) => {
+    const gitignorePath = path.join(repoPath, '.gitignore');
+    try {
+        const content = await fs.readFile(gitignorePath, 'utf-8');
+        if (content.includes(GITNEXUS_DIR))
+            return;
+        const newContent = content.endsWith('\n')
+            ? `${content}${GITNEXUS_DIR}\n`
+            : `${content}\n${GITNEXUS_DIR}\n`;
+        await fs.writeFile(gitignorePath, newContent, 'utf-8');
+    }
+    catch {
+        // .gitignore doesn't exist, create it
+        await fs.writeFile(gitignorePath, `${GITNEXUS_DIR}\n`, 'utf-8');
+    }
+};
+// ─── Global Registry (~/.gitnexus/registry.json) ───────────────────────
+/**
+ * Get the path to the global GitNexus directory
+ */
+export const getGlobalDir = () => {
+    if (process.env.GITNEXUS_HOME && process.env.GITNEXUS_HOME.trim()) {
+        return path.resolve(process.env.GITNEXUS_HOME);
+    }
+    return path.join(os.homedir(), '.gitnexus');
+};
+/**
+ * Get the path to the global registry file
+ */
+export const getGlobalRegistryPath = () => {
+    return path.join(getGlobalDir(), 'registry.json');
+};
+/**
+ * Read the global registry. Returns empty array if not found.
+ */
+export const readRegistry = async () => {
+    try {
+        const raw = await fs.readFile(getGlobalRegistryPath(), 'utf-8');
+        const data = JSON.parse(raw);
+        return Array.isArray(data) ? data : [];
+    }
+    catch {
+        return [];
+    }
+};
+/**
+ * Write the global registry to disk
+ */
+const writeRegistry = async (entries) => {
+    const dir = getGlobalDir();
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(getGlobalRegistryPath(), JSON.stringify(entries, null, 2), 'utf-8');
+};
+/**
+ * Register (add or update) a repo in the global registry.
+ * Called after `gitnexus analyze` completes.
+ */
+export const registerRepo = async (repoPath, meta, options) => {
+    const resolved = path.resolve(repoPath);
+    const sourceName = path.basename(resolved);
+    const alias = normalizeRepoAlias(options?.repoAlias);
+    const name = alias || sourceName;
+    const { storagePath } = getStoragePaths(resolved);
+    const entries = await readRegistry();
+    if (alias) {
+        const aliasConflict = entries.find((e) => e.name === alias && path.resolve(e.path) !== resolved);
+        if (aliasConflict) {
+            throw new Error(`Repo alias "${alias}" is already registered for ${aliasConflict.path}`);
+        }
+    }
+    const existing = entries.findIndex((e) => path.resolve(e.path) === resolved);
+    const entry = {
+        name,
+        path: resolved,
+        storagePath,
+        indexedAt: meta.indexedAt,
+        lastCommit: meta.lastCommit,
+        sourceName,
+        alias,
+        stats: meta.stats,
+    };
+    if (existing >= 0) {
+        entries[existing] = entry;
+    }
+    else {
+        entries.push(entry);
+    }
+    await writeRegistry(entries);
+    return entry;
+};
+/**
+ * Remove a repo from the global registry.
+ * Called after `gitnexus clean`.
+ */
+export const unregisterRepo = async (repoPath) => {
+    const resolved = path.resolve(repoPath);
+    const entries = await readRegistry();
+    const filtered = entries.filter((e) => path.resolve(e.path) !== resolved);
+    await writeRegistry(filtered);
+};
+/**
+ * List all registered repos from the global registry.
+ * Optionally validates that each entry's .gitnexus/ still exists.
+ */
+export const listRegisteredRepos = async (opts) => {
+    const entries = await readRegistry();
+    if (!opts?.validate)
+        return entries;
+    // Validate each entry still has a .gitnexus/ directory
+    const valid = [];
+    for (const entry of entries) {
+        try {
+            await fs.access(path.join(entry.storagePath, 'meta.json'));
+            valid.push(entry);
+        }
+        catch {
+            // Index no longer exists — skip
+        }
+    }
+    // If we pruned any entries, save the cleaned registry
+    if (valid.length !== entries.length) {
+        await writeRegistry(valid);
+    }
+    return valid;
+};
+/**
+ * Get the path to the global CLI config file
+ */
+export const getGlobalConfigPath = () => {
+    return path.join(getGlobalDir(), 'config.json');
+};
+/**
+ * Load CLI config from ~/.gitnexus/config.json
+ */
+export const loadCLIConfig = async () => {
+    try {
+        const raw = await fs.readFile(getGlobalConfigPath(), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+};
+/**
+ * Save CLI config to ~/.gitnexus/config.json
+ */
+export const saveCLIConfig = async (config) => {
+    const dir = getGlobalDir();
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(getGlobalConfigPath(), JSON.stringify(config, null, 2), 'utf-8');
+};

package/dist/types/pipeline.d.ts

@@ -0,0 +1,34 @@
+import { GraphNode, GraphRelationship, KnowledgeGraph } from '../core/graph/types.js';
+import { CommunityDetectionResult } from '../core/ingestion/community-processor.js';
+import { ProcessDetectionResult } from '../core/ingestion/process-processor.js';
+import type { ScopeSelectionDiagnostics } from '../core/ingestion/scope-filter.js';
+export type PipelinePhase = 'idle' | 'extracting' | 'structure' | 'parsing' | 'imports' | 'calls' | 'heritage' | 'communities' | 'processes' | 'enriching' | 'complete' | 'error';
+export interface PipelineProgress {
+    phase: PipelinePhase;
+    percent: number;
+    message: string;
+    detail?: string;
+    stats?: {
+        filesProcessed: number;
+        totalFiles: number;
+        nodesCreated: number;
+    };
+}
+export interface PipelineResult {
+    graph: KnowledgeGraph;
+    /** Absolute path to the repo root — used for lazy file reads during KuzuDB loading */
+    repoPath: string;
+    /** Total files scanned (for stats) */
+    totalFileCount: number;
+    communityResult?: CommunityDetectionResult;
+    processResult?: ProcessDetectionResult;
+    scopeDiagnostics?: ScopeSelectionDiagnostics;
+}
+export interface SerializablePipelineResult {
+    nodes: GraphNode[];
+    relationships: GraphRelationship[];
+    repoPath: string;
+    totalFileCount: number;
+}
+export declare const serializePipelineResult: (result: PipelineResult) => SerializablePipelineResult;
+export declare const deserializePipelineResult: (serialized: SerializablePipelineResult, createGraph: () => KnowledgeGraph) => PipelineResult;

package/dist/types/pipeline.js

@@ -0,0 +1,18 @@
+// Helper to convert PipelineResult to serializable format
+export const serializePipelineResult = (result) => ({
+    nodes: [...result.graph.iterNodes()],
+    relationships: [...result.graph.iterRelationships()],
+    repoPath: result.repoPath,
+    totalFileCount: result.totalFileCount,
+});
+// Helper to reconstruct from serializable format (used in main thread)
+export const deserializePipelineResult = (serialized, createGraph) => {
+    const graph = createGraph();
+    serialized.nodes.forEach(node => graph.addNode(node));
+    serialized.relationships.forEach(rel => graph.addRelationship(rel));
+    return {
+        graph,
+        repoPath: serialized.repoPath,
+        totalFileCount: serialized.totalFileCount,
+    };
+};

package/hooks/claude/gitnexus-hook.cjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+/**
+ * GitNexus Claude Code Hook
+ *
+ * PreToolUse handler — intercepts Grep/Glob/Bash searches
+ * and augments with graph context from the GitNexus index.
+ *
+ * NOTE: SessionStart hooks are broken on Windows (Claude Code bug).
+ * Session context is injected via CLAUDE.md / skills instead.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+/**
+ * Read JSON input from stdin synchronously.
+ */
+function readInput() {
+  try {
+    const data = fs.readFileSync(0, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Check if a directory (or ancestor) has a .gitnexus index.
+ */
+function findGitNexusIndex(startDir) {
+  let dir = startDir || process.cwd();
+  for (let i = 0; i < 5; i++) {
+    if (fs.existsSync(path.join(dir, '.gitnexus'))) {
+      return true;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+
+/**
+ * Extract search pattern from tool input.
+ */
+function extractPattern(toolName, toolInput) {
+  if (toolName === 'Grep') {
+    return toolInput.pattern || null;
+  }
+
+  if (toolName === 'Glob') {
+    const raw = toolInput.pattern || '';
+    const match = raw.match(/[*\/]([a-zA-Z][a-zA-Z0-9_-]{2,})/);
+    return match ? match[1] : null;
+  }
+
+  if (toolName === 'Bash') {
+    const cmd = toolInput.command || '';
+    if (!/\brg\b|\bgrep\b/.test(cmd)) return null;
+
+    const tokens = cmd.split(/\s+/);
+    let foundCmd = false;
+    let skipNext = false;
+    const flagsWithValues = new Set(['-e', '-f', '-m', '-A', '-B', '-C', '-g', '--glob', '-t', '--type', '--include', '--exclude']);
+
+    for (const token of tokens) {
+      if (skipNext) { skipNext = false; continue; }
+      if (!foundCmd) {
+        if (/\brg$|\bgrep$/.test(token)) foundCmd = true;
+        continue;
+      }
+      if (token.startsWith('-')) {
+        if (flagsWithValues.has(token)) skipNext = true;
+        continue;
+      }
+      const cleaned = token.replace(/['"]/g, '');
+      return cleaned.length >= 3 ? cleaned : null;
+    }
+    return null;
+  }
+
+  return null;
+}
+
+function main() {
+  try {
+    const input = readInput();
+    const hookEvent = input.hook_event_name || '';
+
+    if (hookEvent !== 'PreToolUse') return;
+
+    const cwd = input.cwd || process.cwd();
+    if (!findGitNexusIndex(cwd)) return;
+
+    const toolName = input.tool_name || '';
+    const toolInput = input.tool_input || {};
+
+    if (toolName !== 'Grep' && toolName !== 'Glob' && toolName !== 'Bash') return;
+
+    const pattern = extractPattern(toolName, toolInput);
+    if (!pattern || pattern.length < 3) return;
+
+    // Resolve CLI path relative to this hook script (same package)
+    // hooks/claude/gitnexus-hook.cjs → dist/cli/index.js
+    const cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');
+
+    // augment CLI writes result to stderr (KuzuDB's native module captures
+    // stdout fd at OS level, making it unusable in subprocess contexts).
+    const { spawnSync } = require('child_process');
+    let result = '';
+    try {
+      const child = spawnSync(
+        process.execPath,
+        [cliPath, 'augment', pattern],
+        { encoding: 'utf-8', timeout: 8000, cwd, stdio: ['pipe', 'pipe', 'pipe'] }
+      );
+      result = child.stderr || '';
+    } catch { /* graceful failure */ }
+
+    if (result && result.trim()) {
+      console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          additionalContext: result.trim()
+        }
+      }));
+    }
+  } catch (err) {
+    // Graceful failure — log to stderr for debugging
+    console.error('GitNexus hook error:', err.message);
+  }
+}
+
+main();

package/hooks/claude/pre-tool-use.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+# GitNexus PreToolUse hook for Claude Code
+# Intercepts Grep/Glob/Bash searches and augments with graph context.
+# Receives JSON on stdin with { tool_name, tool_input, cwd, ... }
+# Returns JSON with additionalContext for graph-enriched results.
+
+INPUT=$(cat)
+
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty' 2>/dev/null)
+
+# Extract search pattern based on tool type
+PATTERN=""
+
+case "$TOOL_NAME" in
+  Grep)
+    PATTERN=$(echo "$INPUT" | jq -r '.tool_input.pattern // empty' 2>/dev/null)
+    ;;
+  Glob)
+    # Glob patterns are file paths, not search terms — extract meaningful part
+    RAW=$(echo "$INPUT" | jq -r '.tool_input.pattern // empty' 2>/dev/null)
+    # Strip glob syntax to get the meaningful name (e.g., "**/*.ts" → skip, "auth*.ts" → "auth")
+    PATTERN=$(echo "$RAW" | sed -n 's/.*[*\/]\([a-zA-Z][a-zA-Z0-9_-]*\).*/\1/p')
+    ;;
+  Bash)
+    CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
+    # Only augment grep/rg commands
+    if echo "$CMD" | grep -qE '\brg\b|\bgrep\b'; then
+      # Extract pattern from rg/grep
+      if echo "$CMD" | grep -qE '\brg\b'; then
+        PATTERN=$(echo "$CMD" | sed -n "s/.*\brg\s\+\(--[^ ]*\s\+\)*['\"]\\?\([^'\";\| >]*\\).*/\2/p")
+      elif echo "$CMD" | grep -qE '\bgrep\b'; then
+        PATTERN=$(echo "$CMD" | sed -n "s/.*\bgrep\s\+\(-[^ ]*\s\+\)*['\"]\\?\([^'\";\| >]*\\).*/\2/p")
+      fi
+    fi
+    ;;
+  *)
+    # Not a search tool — skip
+    exit 0
+    ;;
+esac
+
+# Skip if pattern too short or empty
+if [ -z "$PATTERN" ] || [ ${#PATTERN} -lt 3 ]; then
+  exit 0
+fi
+
+# Check if we're in a GitNexus-indexed repo
+dir="${CWD:-$PWD}"
+found=false
+for i in 1 2 3 4 5; do
+  if [ -d "$dir/.gitnexus" ]; then
+    found=true
+    break
+  fi
+  parent="$(dirname "$dir")"
+  [ "$parent" = "$dir" ] && break
+  dir="$parent"
+done
+
+if [ "$found" = false ]; then
+  exit 0
+fi
+
+# Run gitnexus augment — must be fast (<500ms target)
+RESULT=$(cd "$CWD" && npx -y gitnexus augment "$PATTERN" 2>/dev/null)
+
+if [ -n "$RESULT" ]; then
+  ESCAPED=$(echo "$RESULT" | jq -Rs .)
+  jq -n --argjson ctx "$ESCAPED" '{
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      additionalContext: $ctx
+    }
+  }'
+else
+  exit 0
+fi

package/hooks/claude/session-start.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# GitNexus SessionStart hook for Claude Code
+# Fires on session startup. Stdout is injected into Claude's context.
+# Checks if the current directory has a GitNexus index.
+
+dir="$PWD"
+found=false
+for i in 1 2 3 4 5; do
+  if [ -d "$dir/.gitnexus" ]; then
+    found=true
+    break
+  fi
+  parent="$(dirname "$dir")"
+  [ "$parent" = "$dir" ] && break
+  dir="$parent"
+done
+
+if [ "$found" = false ]; then
+  exit 0
+fi
+
+# Inject GitNexus context — this stdout goes directly into Claude's context
+cat << 'EOF'
+## GitNexus Code Intelligence
+
+This codebase is indexed by GitNexus, providing a knowledge graph with execution flows, relationships, and semantic search.
+
+**Available MCP Tools:**
+- `query` — Process-grouped code intelligence (execution flows related to a concept)
+- `context` — 360-degree symbol view (categorized refs, process participation)
+- `impact` — Blast radius analysis (what breaks if you change a symbol)
+- `detect_changes` — Git-diff impact analysis (what do your changes affect)
+- `rename` — Multi-file coordinated rename with confidence tags
+- `cypher` — Raw graph queries
+- `list_repos` — Discover indexed repos
+
+**Quick Start:** READ `gitnexus://repo/{name}/context` for codebase overview, then use `query` to find execution flows.
+
+**Resources:** `gitnexus://repo/{name}/context` (overview), `/processes` (execution flows), `/schema` (for Cypher)
+EOF
+
+exit 0

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@veewo/gitnexus",
+  "version": "1.3.4",
+  "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
+  "author": "Abhigyan Patwari",
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "homepage": "https://github.com/abhigyanpatwari/GitNexus#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abhigyanpatwari/GitNexus.git",
+    "directory": "gitnexus"
+  },
+  "bugs": {
+    "url": "https://github.com/abhigyanpatwari/GitNexus/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "code-intelligence",
+    "knowledge-graph",
+    "cursor",
+    "claude",
+    "ai-agent",
+    "gitnexus",
+    "static-analysis",
+    "codebase-indexing"
+  ],
+  "type": "module",
+  "bin": {
+    "gitnexus": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "hooks",
+    "skills",
+    "vendor"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/cli/index.ts",
+    "prepare": "npm run build",
+    "test:benchmark": "npm run build && node --test dist/benchmark/*.test.js dist/cli/*.test.js",
+    "benchmark:quick": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/v1 --profile quick --target-path ../benchmarks/fixtures/unity-mini",
+    "benchmark:full": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/v1 --profile full --target-path ../benchmarks/fixtures/unity-mini",
+    "benchmark:neonspark:full": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v1 --profile full --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v1/sync-manifest.txt",
+    "benchmark:neonspark:quick": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v1 --profile quick --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v1/sync-manifest.txt",
+    "benchmark:neonspark:v2:full": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v2 --profile full --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
+    "benchmark:neonspark:v2:quick": "npm run build && node dist/cli/index.js benchmark-unity ../benchmarks/unity-baseline/neonspark-v2 --profile quick --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
+    "benchmark:agent-context:quick": "npm run build && node dist/cli/index.js benchmark-agent-context ../benchmarks/agent-context/neonspark-refactor-v1 --profile quick --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt",
+    "benchmark:agent-context:full": "npm run build && node dist/cli/index.js benchmark-agent-context ../benchmarks/agent-context/neonspark-refactor-v1 --profile full --target-path /Volumes/Shuttle/unity-projects/neonspark --repo-alias neonspark-v1-subset --scope-manifest ../benchmarks/unity-baseline/neonspark-v2/sync-manifest.txt"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^3.0.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "cli-progress": "^3.12.0",
+    "commander": "^12.0.0",
+    "cors": "^2.8.5",
+    "express": "^4.19.2",
+    "glob": "^11.0.0",
+    "graphology": "^0.25.4",
+    "graphology-indices": "^0.17.0",
+    "graphology-utils": "^2.3.0",
+    "kuzu": "^0.11.3",
+    "lru-cache": "^11.0.0",
+    "mnemonist": "^0.39.0",
+    "pandemonium": "^2.4.0",
+    "tree-sitter": "^0.21.0",
+    "tree-sitter-c": "^0.21.0",
+    "tree-sitter-c-sharp": "^0.21.0",
+    "tree-sitter-cpp": "^0.22.0",
+    "tree-sitter-go": "^0.21.0",
+    "tree-sitter-java": "^0.21.0",
+    "tree-sitter-javascript": "^0.21.0",
+    "tree-sitter-php": "^0.23.12",
+    "tree-sitter-python": "^0.21.0",
+    "tree-sitter-rust": "^0.21.0",
+    "tree-sitter-typescript": "^0.21.0",
+    "typescript": "^5.4.5",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.0.0",
+    "@types/uuid": "^10.0.0",
+    "tsx": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}