@szabadkai/graphite 0.1.0

package/README.md

@@ -0,0 +1,427 @@
+# Graphite
+
+A local-first semantic code graph for TypeScript and JavaScript. Index your project once, then query its structure — who calls what, where things are defined, how files depend on each other — from the CLI, an MCP-enabled AI assistant, or the VS Code sidebar.
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Usage: CLI](#usage-cli)
+- [Usage: MCP Server (AI Assistants)](#usage-mcp-server-ai-assistants)
+- [Usage: VS Code Extension](#usage-vs-code-extension)
+- [Query Reference](#query-reference)
+- [Configuration](#configuration)
+- [Architecture](#architecture)
+- [Supported Languages](#supported-languages)
+- [Limitations](#limitations)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Installation
+
+```bash
+# Install locally in your project
+npm install graphite
+
+# Or run without installing
+npx graphite index
+```
+
+For the VS Code extension, install from the `vscode-extension/` directory:
+
+```bash
+cd vscode-extension
+npm install && npm run compile
+# Then press F5 in VS Code to launch the Extension Development Host
+```
+
+---
+
+## Quick Start
+
+```bash
+# 1. Index your project (creates .graphite/index.db)
+npx graphite index
+
+# 2. Find where a function is defined
+npx graphite query find_definition processPayment
+
+# 3. Find who calls it
+npx graphite query find_callers processPayment
+
+# 4. Start the MCP server for AI assistants
+npx graphite serve
+```
+
+---
+
+## Usage: CLI
+
+The CLI has four commands: `index`, `query`, `status`, and `serve`.
+
+### Global Options
+
+| Flag | Description |
+|------|-------------|
+| `--project-root <path>` | Project root (default: current directory) |
+| `--json` | Output raw JSON instead of human-readable tables |
+| `--verbose` | Show timing information |
+
+### `graphite index`
+
+Index (or re-index) the current project. Uses content hashing for incremental updates — unchanged files are skipped.
+
+```bash
+# Index the current directory
+graphite index
+
+# Index a specific project
+graphite index --project-root /path/to/project
+
+# Get JSON output for scripting
+graphite index --json
+```
+
+Output example:
+```
+Indexed 142/142 files (38 new, 12 updated, 2 deleted, 90 skipped, 0 failed)
+```
+
+### `graphite status`
+
+Show the current state of the index.
+
+```bash
+graphite status
+```
+
+Output example:
+```
+Graphite Status
+  Files   142
+  Nodes   Function:89, Class:23, Method:67, Interface:12, TypeAlias:8, Variable:34
+  Edges   CONTAINS:156, IMPORTS:78, EXPORTS:102, CALLS:213, EXTENDS:5, IMPLEMENTS:8
+```
+
+### `graphite query <tool> [args...]`
+
+Run any of the 10 query tools. The first positional argument after the tool name is the primary argument (usually a symbol name or file path). The second is an optional secondary argument.
+
+```bash
+# Find a symbol's definition
+graphite query find_definition UserService
+
+# Search symbols by prefix
+graphite query search_symbols handle
+
+# Get the structure of a file
+graphite query get_file_structure src/services/auth.ts
+
+# Get a file's exports
+graphite query get_exports src/utils/index.ts
+
+# Find callers of a function (with depth)
+graphite query find_callers processPayment --depth 3
+
+# Find callees of a function
+graphite query find_callees handleRequest --depth 2
+
+# Find implementations of an interface
+graphite query find_implementations EventHandler
+
+# Analyze blast radius of changing a symbol
+graphite query analyze_impact createUser --max-depth 5
+
+# Find the import path between two files
+graphite query find_dependency_path src/app.ts src/db/client.ts
+
+# Get overall graph statistics
+graphite query get_graph_stats
+```
+
+#### Query Options
+
+| Flag | Applies to | Description |
+|------|-----------|-------------|
+| `--depth <n>` | `find_callers`, `find_callees` | Traversal depth (default: 1) |
+| `--max-results <n>` | `find_callers`, `find_callees`, `search_symbols` | Max results (default: 50) |
+| `--max-depth <n>` | `analyze_impact` | Max reverse-traversal depth (default: 5) |
+
+### `graphite serve`
+
+Start the MCP server on stdio. This is what AI assistants connect to.
+
+```bash
+graphite serve
+graphite serve --project-root /path/to/project
+```
+
+The server auto-indexes the project on the first tool call if no index exists.
+
+---
+
+## Usage: MCP Server (AI Assistants)
+
+Graphite exposes all 10 query tools as an MCP server. Any MCP-compatible client can use it.
+
+### GitHub Copilot (VS Code)
+
+**Option A: Install the VS Code extension** (recommended)
+
+The Graphite VS Code extension automatically registers the MCP server with Copilot. Install the extension and it works out of the box — Copilot can immediately use all 10 tools.
+
+**Option B: Manual configuration**
+
+Add to your VS Code `settings.json`:
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "graphite": {
+        "type": "stdio",
+        "command": "npx",
+        "args": ["graphite", "serve", "--project-root", "${workspaceFolder}"]
+      }
+    }
+  }
+}
+```
+
+Or add a `.vscode/mcp.json` to your project:
+
+```json
+{
+  "servers": {
+    "graphite": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["graphite", "serve"]
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or the equivalent on your OS:
+
+```json
+{
+  "mcpServers": {
+    "graphite": {
+      "command": "npx",
+      "args": ["graphite", "serve", "--project-root", "/absolute/path/to/your/project"]
+    }
+  }
+}
+```
+
+### Claude Code (CLI)
+
+```bash
+claude mcp add graphite -- npx graphite serve --project-root /path/to/project
+```
+
+### Cursor
+
+Add to Cursor's MCP config (Settings → MCP):
+
+```json
+{
+  "mcpServers": {
+    "graphite": {
+      "command": "npx",
+      "args": ["graphite", "serve", "--project-root", "/path/to/project"]
+    }
+  }
+}
+```
+
+### Any MCP Client
+
+Graphite uses stdio transport. Spawn the process and communicate via stdin/stdout:
+
+```bash
+npx graphite serve --project-root /path/to/project
+```
+
+---
+
+## Usage: VS Code Extension
+
+The extension lives in `vscode-extension/` and provides a graphical interface to the code graph.
+
+### Sidebar Panels
+
+Open the **Graphite** sidebar (type-hierarchy icon in the activity bar):
+
+- **File Structure** — Shows all symbols in the current file (functions, classes with methods, interfaces, types, enums, variables). Click any symbol to jump to it. Updates automatically when you switch files.
+- **Callers** — Shows functions that call the selected symbol. Use right-click → "Find Callers" to populate.
+- **Callees** — Shows functions called by the selected symbol. Use right-click → "Find Callees" to populate.
+
+### Commands
+
+Open the Command Palette (`Cmd+Shift+P`) and type "Graphite":
+
+| Command | What it does |
+|---------|--------------|
+| **Graphite: Index Project** | Manually trigger a full re-index |
+| **Graphite: Show Index Status** | Opens a document showing file/node/edge counts |
+| **Graphite: Find Callers** | Finds callers of the word under cursor, shows in sidebar |
+| **Graphite: Find Callees** | Finds callees of the word under cursor, shows in sidebar |
+| **Graphite: Find Definition** | Jumps to definition (or shows a picker if multiple) |
+| **Graphite: Find Implementations** | Shows implementations of an interface/class |
+| **Graphite: Analyze Impact** | Opens blast radius analysis for the word under cursor |
+| **Graphite: Refresh Explorer** | Refreshes all sidebar panels |
+
+### Context Menu
+
+Right-click in any TypeScript/JavaScript file to access:
+
+- Find Callers
+- Find Callees
+- Find Implementations
+- Analyze Impact
+
+### Auto-Indexing
+
+By default, the extension indexes the project on activation and re-indexes when you save a `.ts`/`.js` file. Disable with:
+
+```json
+{
+  "graphite.autoIndex": false
+}
+```
+
+### Copilot Integration
+
+When the extension is active in VS Code 1.99+, it automatically registers the Graphite MCP server with GitHub Copilot. Copilot can then use all 10 tools in chat without any manual MCP configuration.
+
+### Extension Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `graphite.autoIndex` | `true` | Auto-index on activation and file changes |
+| `graphite.maxDepth` | `3` | Default depth for caller/callee traversal |
+| `graphite.maxResults` | `50` | Maximum results for queries |
+
+---
+
+## Query Reference
+
+| Tool | Description | Required Args | Optional Args |
+|------|-------------|--------------|---------------|
+| `find_definition` | Locate where a symbol is defined | `symbol` | `type` |
+| `search_symbols` | Prefix search across all symbols | `query` | `type`, `max_results` |
+| `get_file_structure` | All symbols in a file, grouped by type | `file_path` | — |
+| `get_exports` | Public exports of a file or module | `file_or_module` | — |
+| `find_callers` | Who calls this function (multi-hop) | `symbol` | `depth`, `max_results` |
+| `find_callees` | What does this function call (multi-hop) | `symbol` | `depth`, `max_results` |
+| `get_graph_stats` | Summary stats for the entire graph | — | — |
+| `find_implementations` | Classes implementing an interface/extending a class | `symbol` | — |
+| `analyze_impact` | Blast radius: all affected files/symbols | `symbol` | `max_depth` |
+| `find_dependency_path` | Shortest import chain between two files | `source_file`, `target_file` | — |
+
+---
+
+## Configuration
+
+### `.graphiteignore`
+
+Place a `.graphiteignore` file in your project root (same syntax as `.gitignore`) to exclude additional paths from indexing:
+
+```
+# Skip generated code
+src/generated/**
+*.d.ts
+
+# Skip test fixtures
+test/fixtures/**
+```
+
+The indexer always skips: `node_modules`, `.git`, `.graphite`, `dist`, `build`, `coverage`.
+
+### `tsconfig.json` Path Aliases
+
+Graphite reads your `tsconfig.json` and respects `compilerOptions.paths` and `baseUrl` for import resolution:
+
+```json
+{
+  "compilerOptions": {
+    "baseUrl": "src",
+    "paths": {
+      "@utils/*": ["utils/*"],
+      "@services/*": ["services/*"]
+    }
+  }
+}
+```
+
+Imports like `import { foo } from '@utils/helpers'` will resolve correctly.
+
+---
+
+## Architecture
+
+```
+src/
+  indexer/        Tree-sitter parsing, AST extraction, cross-file stitching
+  storage/        SQLite schema, migrations, read/write layers
+  query/          10 query functions (callers, callees, impact, etc.)
+  cli/            Commander.js CLI with 4 commands
+  mcp/            MCP server, tool registry, LLM response formatting
+
+vscode-extension/
+  src/            VS Code extension: sidebar, commands, MCP registration
+```
+
+- **Indexer**: tree-sitter parses TS/JS → extracts functions, classes, imports, exports → resolves cross-file calls and inheritance → stores as nodes + edges in SQLite
+- **Storage**: SQLite with WAL mode, FTS5 for symbol search, prepared statements for performance
+- **Query**: SQL queries using recursive CTEs for multi-hop traversal
+- **MCP**: Stdio transport, auto-index on first call, response truncation for LLMs
+
+---
+
+## Supported Languages
+
+| Language | Extensions |
+|----------|-----------|
+| TypeScript | `.ts`, `.tsx` |
+| JavaScript | `.js`, `.jsx`, `.mjs`, `.cjs` |
+
+---
+
+## Limitations
+
+- TypeScript and JavaScript only (no Python/Go/Rust yet)
+- No real-time file watcher (re-index on save via VS Code extension, or run `graphite index` manually)
+- Local projects only (no remote/SSH indexing)
+- Dynamic `import()` expressions are not resolved
+- CommonJS `module.exports =` patterns have limited support
+
+---
+
+## Contributing
+
+```bash
+git clone <repo>
+cd graphite
+npm install
+npm run build
+npm test
+```
+
+- See [docs/PRD.md](docs/PRD.md) for the product requirements
+- See [docs/TASKS.md](docs/TASKS.md) for the task list and architecture notes
+- Run benchmarks: `npm run benchmark:indexer`
+
+---
+
+## License
+
+MIT

package/dist/cli/formatters.d.ts

@@ -0,0 +1,3 @@
+export declare function formatKeyValueBlock(title: string, entries: Array<[string, string | number]>): string;
+export declare function formatList(title: string, lines: string[]): string;
+export declare function formatTable(title: string, rows: unknown[]): string;

package/dist/cli/formatters.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatKeyValueBlock = formatKeyValueBlock;
+exports.formatList = formatList;
+exports.formatTable = formatTable;
+function formatKeyValueBlock(title, entries) {
+    const lines = [title];
+    for (const [key, value] of entries) {
+        lines.push(`  ${key}: ${value}`);
+    }
+    return lines.join("\n");
+}
+function formatList(title, lines) {
+    return [title, ...lines.map((line) => `  - ${line}`)].join("\n");
+}
+// M7: Human-readable table output for query results
+function formatTable(title, rows) {
+    if (rows.length === 0) {
+        return `${title}\n  (no results)`;
+    }
+    // Pick display columns from the first row
+    const sample = rows[0];
+    const displayKeys = Object.keys(sample).filter((key) => {
+        const value = sample[key];
+        return typeof value !== "object" || value === null;
+    });
+    if (displayKeys.length === 0) {
+        // Fallback to JSON
+        return formatList(title, rows.map((row) => JSON.stringify(row)));
+    }
+    // Compute column widths
+    const widths = new Map();
+    for (const key of displayKeys) {
+        widths.set(key, key.length);
+    }
+    for (const row of rows) {
+        const record = row;
+        for (const key of displayKeys) {
+            const value = String(record[key] ?? "");
+            const current = widths.get(key) ?? 0;
+            widths.set(key, Math.max(current, Math.min(value.length, 60)));
+        }
+    }
+    const header = displayKeys.map((key) => key.padEnd(widths.get(key) ?? 0)).join("  ");
+    const separator = displayKeys.map((key) => "-".repeat(widths.get(key) ?? 0)).join("  ");
+    const dataLines = rows.slice(0, 50).map((row) => {
+        const record = row;
+        return displayKeys
+            .map((key) => {
+            const value = String(record[key] ?? "");
+            return value.slice(0, 60).padEnd(widths.get(key) ?? 0);
+        })
+            .join("  ");
+    });
+    const lines = [title, `  ${header}`, `  ${separator}`, ...dataLines.map((line) => `  ${line}`)];
+    if (rows.length > 50) {
+        lines.push(`  ... and ${rows.length - 50} more`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=formatters.js.map

package/dist/cli/formatters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.js","sourceRoot":"","sources":["../../src/cli/formatters.ts"],"names":[],"mappings":"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"}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCli(argv: string[]): Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const index_1 = require("../index");
+const formatters_1 = require("./formatters");
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function createProgram() {
+    const program = new commander_1.Command();
+    program
+        .name("graphite")
+        .description("Local-first semantic code index and query CLI")
+        .version("0.1.0")
+        .option("--json", "output JSON", false)
+        .option("--project-root <path>", "project root path", process.cwd())
+        .option("--verbose", "verbose output", false);
+    program
+        .command("index")
+        .description("Index a project")
+        .action(() => {
+        const options = program.opts();
+        const manager = (0, index_1.connectDatabase)({ projectRoot: options.projectRoot });
+        try {
+            // M9: Use verbose flag for timing info
+            const start = Date.now();
+            const summary = (0, index_1.indexProject)({ projectRoot: options.projectRoot, db: manager.db });
+            const elapsed = Date.now() - start;
+            if (options.json) {
+                printJson(summary);
+            }
+            else {
+                process.stdout.write(`${(0, index_1.printIndexSummary)(summary)}\n`);
+                if (options.verbose) {
+                    process.stdout.write(`Completed in ${elapsed}ms\n`);
+                }
+            }
+        }
+        finally {
+            manager.close();
+        }
+    });
+    program
+        .command("status")
+        .description("Show graph status")
+        .action(() => {
+        const options = program.opts();
+        const manager = (0, index_1.connectDatabase)({ projectRoot: options.projectRoot });
+        try {
+            const stats = (0, index_1.getGraphStats)(manager.db);
+            if (options.json) {
+                printJson(stats);
+            }
+            else {
+                process.stdout.write(`${(0, formatters_1.formatKeyValueBlock)("Graphite Status", [
+                    ["Files", stats.totalFiles],
+                    ["Nodes", stats.nodeCountByType.map((item) => `${item.type}:${item.count}`).join(", ")],
+                    ["Edges", stats.edgeCountByType.map((item) => `${item.type}:${item.count}`).join(", ")]
+                ])}\n`);
+            }
+        }
+        finally {
+            manager.close();
+        }
+    });
+    // M10: Add --depth and --max-results options to query command
+    program
+        .command("query")
+        .description("Run a query tool")
+        .argument("<tool>", "tool name")
+        .argument("[arg1]", "first argument")
+        .argument("[arg2]", "second argument")
+        .option("--depth <n>", "traversal depth for caller/callee queries", parseInt)
+        .option("--max-results <n>", "maximum results to return", parseInt)
+        .option("--max-depth <n>", "max depth for impact analysis", parseInt)
+        .action((tool, arg1, arg2, cmdOpts) => {
+        const options = program.opts();
+        const manager = (0, index_1.connectDatabase)({ projectRoot: options.projectRoot });
+        let result;
+        try {
+            const requireArg = (name, value) => {
+                if (!value || value.trim().length === 0) {
+                    throw new Error(`Missing required query argument: ${name}`);
+                }
+                return value;
+            };
+            // M9: Verbose timing
+            const start = Date.now();
+            switch (tool) {
+                case "find_definition":
+                    result = (0, index_1.findDefinition)(manager.db, requireArg("symbol", arg1), arg2);
+                    break;
+                case "search_symbols":
+                    result = (0, index_1.searchSymbols)(manager.db, requireArg("query", arg1), {
+                        type: arg2,
+                        maxResults: cmdOpts.maxResults
+                    });
+                    break;
+                case "get_file_structure":
+                    result = (0, index_1.getFileStructure)(manager.db, requireArg("file_path", arg1));
+                    break;
+                case "get_exports":
+                    result = (0, index_1.getExports)(manager.db, requireArg("file_or_module", arg1));
+                    break;
+                case "find_callers":
+                    result = (0, index_1.findCallers)(manager.db, requireArg("symbol", arg1), {
+                        depth: cmdOpts.depth,
+                        maxResults: cmdOpts.maxResults
+                    });
+                    break;
+                case "find_callees":
+                    result = (0, index_1.findCallees)(manager.db, requireArg("symbol", arg1), {
+                        depth: cmdOpts.depth,
+                        maxResults: cmdOpts.maxResults
+                    });
+                    break;
+                case "get_graph_stats":
+                    result = (0, index_1.getGraphStats)(manager.db);
+                    break;
+                case "find_implementations":
+                    result = (0, index_1.findImplementations)(manager.db, requireArg("symbol", arg1));
+                    break;
+                case "analyze_impact":
+                    result = (0, index_1.analyzeImpact)(manager.db, requireArg("symbol", arg1), {
+                        maxDepth: cmdOpts.maxDepth
+                    });
+                    break;
+                case "find_dependency_path":
+                    result = (0, index_1.findDependencyPath)(manager.db, requireArg("source_file", arg1), requireArg("target_file", arg2));
+                    break;
+                default:
+                    throw new Error(`Unknown query tool: ${tool}`);
+            }
+            const elapsed = Date.now() - start;
+            if (options.json) {
+                printJson(result);
+            }
+            else {
+                // M7: Human-readable table output instead of raw JSON
+                if (Array.isArray(result)) {
+                    process.stdout.write(`${(0, formatters_1.formatTable)(`Query: ${tool}`, result)}\n`);
+                }
+                else if (typeof result === "object" && result !== null) {
+                    const entries = Object.entries(result).map(([key, value]) => [key, typeof value === "object" ? JSON.stringify(value) : String(value)]);
+                    process.stdout.write(`${(0, formatters_1.formatKeyValueBlock)(`Query: ${tool}`, entries)}\n`);
+                }
+                else {
+                    process.stdout.write(`${(0, formatters_1.formatList)(`Query: ${tool}`, [String(result)])}\n`);
+                }
+                if (options.verbose) {
+                    process.stdout.write(`Completed in ${elapsed}ms\n`);
+                }
+            }
+        }
+        finally {
+            manager.close();
+        }
+    });
+    program
+        .command("serve")
+        .description("Start MCP server")
+        .action(async () => {
+        const options = program.opts();
+        const mcpServer = (0, index_1.createGraphiteMcpServer)({
+            projectRoot: options.projectRoot
+        });
+        await mcpServer.start();
+        await new Promise(() => {
+            // Keep process alive while stdio transport is active.
+        });
+    });
+    return program;
+}
+async function runCli(argv) {
+    await createProgram().parseAsync(argv);
+}
+if (require.main === module) {
+    runCli(process.argv).catch((error) => {
+        const message = error instanceof Error ? error.message : "Unknown CLI error";
+        process.stderr.write(`${message}\n`);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=index.js.map