edhindex 1.0.0 → 1.0.2

package/package.json

@@ -1,21 +1,52 @@
 {
   "name": "edhindex",
-  "version": "1.0.0",
-  "description": "Local-first hybrid code search engine with MCP",
+  "version": "1.0.2",
+  "description": "Local-first hybrid code search engine with knowledge graph — BM25 + vector + rerank, tree-sitter parsing, MCP server",
+  "keywords": [
+    "code-search",
+    "code-index",
+    "semantic-search",
+    "hybrid-search",
+    "knowledge-graph",
+    "mcp",
+    "tree-sitter",
+    "codebase-search",
+    "local-first",
+    "offline"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/krishnasfdcc-a11y/edhIndex.git"
+  },
+  "homepage": "https://github.com/krishnasfdcc-a11y/edhIndex#readme",
+  "bugs": {
+    "url": "https://github.com/krishnasfdcc-a11y/edhIndex/issues"
+  },
+  "license": "MIT",
+  "author": "edhdev (https://github.com/krishnasfdcc-a11y)",
+  "engines": {
+    "node": ">=18"
+  },
   "type": "module",
   "bin": {
-    "edhindex": "./dist/cli/index.js"
+    "edhindex": "dist/cli/index.js"
   },
   "exports": {
     ".": "./dist/index.js"
   },
+  "files": [
+    "dist",
+    "src"
+  ],
   "scripts": {
+    "postinstall": "npx tsc || true",
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "start": "node dist/cli/index.js",
     "dev": "npx tsx src/cli/index.ts"
   },
   "dependencies": {
-    "@huggingface/transformers": "^3.8.1",
+    "@huggingface/transformers": "^4.2.0",
     "@lancedb/lancedb": "^0.31.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.11.1",

package/src/cli/commands/graph.ts

@@ -0,0 +1,30 @@
+import { join } from 'node:path';
+import { existsSync, writeFileSync } from 'node:fs';
+import { MetadataStore } from '../../storage/metadata.js';
+import { buildGraphData } from '../../graph/build.js';
+import { generateSVG } from '../../graph/svg.js';
+import chalk from 'chalk';
+
+export async function graphCommand(rootPath: string, outputPath?: string) {
+  const indexDir = join(rootPath, '.edhindex');
+  if (!existsSync(indexDir)) {
+    console.log(chalk.yellow('No EDHIndex index found. Run "edhindex start" first.'));
+    return;
+  }
+
+  const store = new MetadataStore(indexDir);
+  const { nodes, edges, fileCount, edgeCount } = buildGraphData(store);
+  store.close();
+
+  if (fileCount === 0) {
+    console.log(chalk.yellow('No indexed files found.'));
+    return;
+  }
+
+  const svg = generateSVG(rootPath, nodes, edges);
+  const outFile = outputPath || join(rootPath, 'edhindex-graph.svg');
+  writeFileSync(outFile, svg, 'utf-8');
+
+  console.log(chalk.green(`Graph generated: ${outFile}`));
+  console.log(chalk.dim(`${fileCount} files, ${edgeCount} dependencies`));
+}

package/src/cli/commands/init.ts

@@ -1,9 +1,42 @@
 import { join } from 'node:path';
 import { existsSync, mkdirSync } from 'node:fs';
-import { loadConfig, saveConfig, defaultConfig } from '../../config/index.js';
+import { loadConfig, saveConfig, defaultConfig, MODEL_CONFIGS, type ModelTier } from '../../config/index.js';
+import { promptAndWriteMCPConfigs } from '../../mcp-config.js';
+import { createInterface } from 'node:readline';
 import { logger } from '../../logging.js';
 import chalk from 'chalk';
 
+function isInteractive(): boolean {
+  return process.stdin.isTTY && process.stdout.isTTY;
+}
+
+function askModel(): Promise<ModelTier> {
+  return new Promise((resolve) => {
+    if (!isInteractive()) {
+      resolve('balanced');
+      return;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const tiers: ModelTier[] = ['light', 'balanced', 'max'];
+    const lines = tiers.map((t, i) => {
+      const c = MODEL_CONFIGS[t];
+      return `  ${i + 1}. ${c.displayName} (${c.dimensions}d, ${c.size})`;
+    });
+    rl.question(
+      `\n${chalk.bold('Embedding Model')}\nWhich embedding model do you want to use?\n${lines.join('\n')}\n\nChoose (1-3) [2]: `,
+      (answer) => {
+        rl.close();
+        const idx = parseInt(answer.trim(), 10);
+        if (idx >= 1 && idx <= 3) {
+          resolve(tiers[idx - 1]);
+        } else {
+          resolve('balanced');
+        }
+      }
+    );
+  });
+}
+
 export async function initCommand(rootPath: string) {
   const indexDir = join(rootPath, '.edhindex');
 
@@ -16,10 +49,15 @@ export async function initCommand(rootPath: string) {
 
   mkdirSync(indexDir, { recursive: true });
   const config = defaultConfig();
+  config.model = await askModel();
   saveConfig(indexDir, config);
 
   console.log(chalk.green('EDHIndex initialized.'));
-  console.log(`Index directory: ${indexDir}`);
-  console.log(`Configuration: model=${config.model}, languages=[${config.languages.join(', ')}]`);
+  const mc = MODEL_CONFIGS[config.model];
+  console.log(`Model: ${mc.displayName} (${mc.dimensions}d, ${mc.size})`);
+  console.log(`Languages: ${config.languages.join(', ')}`);
+
+  await promptAndWriteMCPConfigs(rootPath);
+
   console.log(chalk.dim('Run "edhindex start" to build the index and start the MCP server.'));
 }

package/src/cli/commands/knowledge-graph.ts

@@ -0,0 +1,85 @@
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { GraphService } from '../../graph/service.js';
+import { startGraphServer, writeViewerFile } from '../../graph/serve.js';
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+
+export async function kgCommand(rootPath: string, flags: { rebuild?: boolean; stats?: boolean; serve?: boolean; write?: boolean; port?: string }) {
+  const indexDir = join(rootPath, '.edhindex');
+  if (!existsSync(indexDir)) {
+    console.log(chalk.yellow('No index found. Run "edhindex start" first.'));
+    return;
+  }
+
+  if (flags.write) {
+    console.log(chalk.dim('Writing graph viewer...'));
+    const outFile = join(rootPath, '.edhindex', 'knowledge-graph.html');
+    writeViewerFile(rootPath, outFile);
+    console.log(chalk.green(`\n  Viewer written: ${outFile}`));
+    console.log(chalk.dim('\n  Open in VS Code:'));
+    console.log(chalk.dim('    1. File > Open File... > select the file'));
+    console.log(chalk.dim('    2. Or drag into VS Code and click "Preview"'));
+    console.log(chalk.dim('    3. Or right-click → "Open with Live Server"'));
+    console.log(chalk.dim('\n  Or open in browser:'));
+    console.log(chalk.dim(`    file://${outFile}`));
+    return;
+  }
+
+  if (flags.serve) {
+    const port = flags.port ? parseInt(flags.port, 10) : 0;
+    console.log(chalk.dim('Starting graph server...'));
+    const { port: actualPort, close } = await startGraphServer(rootPath, port);
+    const url = `http://127.0.0.1:${actualPort}`;
+    console.log(chalk.green(`\n  Knowledge Graph: ${url}`));
+    console.log(chalk.dim('\n  Press Ctrl+C to stop.\n'));
+
+    // Try to open browser
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    try {
+      const child = spawn(cmd, [url], { detached: true, stdio: 'ignore' });
+      child.unref();
+    } catch { /* browser open not critical */ }
+
+    // Keep alive
+    process.on('SIGINT', () => { close(); process.exit(0); });
+    process.on('SIGTERM', () => { close(); process.exit(0); });
+    await new Promise(() => {}); // hang
+    return;
+  }
+
+  try {
+    const svc = new GraphService(rootPath);
+
+    if (flags.rebuild) {
+      console.log(chalk.dim('Building knowledge graph...'));
+      svc.build();
+    }
+
+    const stats = svc.getStats();
+    svc.close();
+
+    console.log(chalk.bold('\nKnowledge Graph'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(`  Nodes: ${chalk.cyan(stats.nodeCount)}`);
+    console.log(`  Edges: ${chalk.cyan(stats.edgeCount)}`);
+
+    if (Object.keys(stats.typeCounts).length > 0) {
+      console.log(chalk.dim('\n  By type:'));
+      for (const [type, count] of Object.entries(stats.typeCounts).sort((a, b) => b[1] - a[1])) {
+        console.log(`    ${type.padEnd(14)} ${count}`);
+      }
+    }
+
+    console.log(chalk.dim('\n  Commands:'));
+    console.log(chalk.dim('    edhindex kg serve     — Interactive graph in browser'));
+    console.log(chalk.dim('    edhindex graph        — Static SVG graph'));
+
+    console.log(chalk.dim('\n  MCP tools:'));
+    console.log(chalk.dim('    get_graph             — Full graph data'));
+    console.log(chalk.dim('    get_node              — Node details + neighbors'));
+    console.log(chalk.dim('    search_graph          — Search nodes by name'));
+  } catch (e) {
+    console.error(chalk.red('Failed:'), e instanceof Error ? e.message : e);
+  }
+}

package/src/cli/commands/reset.ts

@@ -0,0 +1,40 @@
+import { join } from 'node:path';
+import { existsSync, rmSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import chalk from 'chalk';
+
+function isInteractive(): boolean {
+  return process.stdin.isTTY && process.stdout.isTTY;
+}
+
+function confirm(message: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    if (!isInteractive()) {
+      resolve(false);
+      return;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === 'y');
+    });
+  });
+}
+
+export async function resetCommand(rootPath: string) {
+  const indexDir = join(rootPath, '.edhindex');
+
+  if (!existsSync(indexDir)) {
+    console.log(chalk.yellow('No EDHIndex index found in this directory.'));
+    return;
+  }
+
+  const ok = await confirm(chalk.red('Delete the entire EDHIndex index (config + vectors + metadata)?'));
+  if (!ok) {
+    console.log(chalk.dim('Cancelled.'));
+    return;
+  }
+
+  rmSync(indexDir, { recursive: true, force: true });
+  console.log(chalk.green(`Deleted: ${indexDir}`));
+}

package/src/cli/commands/start.ts

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { loadConfig, MODEL_CONFIGS } from '../../config/index.js';
 import { logger, setLogLevel, LogLevel, getLogLevel } from '../../logging.js';
 import { emitProgress, onProgress } from '../../progress.js';
@@ -12,6 +12,10 @@ import { Indexer } from '../../indexer/indexer.js';
 import { SearchEngine } from '../../retrieval/search.js';
 import { createMCPServer } from '../../mcp/server.js';
 import { FileWatcher } from '../../watcher/index.js';
+import { buildGraphData } from '../../graph/build.js';
+import { generateSVG } from '../../graph/svg.js';
+import { GraphBuilder } from '../../graph/builder.js';
+import { GraphStore } from '../../graph/storage.js';
 import cliProgress from 'cli-progress';
 import chalk from 'chalk';
 
@@ -32,23 +36,23 @@ export async function startCommand(rootPath: string) {
   };
   setLogLevel(logLevelMap[config.logLevel] || LogLevel.Info);
 
-  console.log(chalk.bold('EDHIndex v1.0.0'));
-  console.log(`Workspace: ${rootPath}`);
-  console.log(`Model: ${modelCfg.displayName} (${modelCfg.dimensions}d)`);
-  console.log(`Languages: ${config.languages.join(', ')}`);
-  console.log('');
+  console.error(chalk.bold('EDHIndex v1.0.0'));
+  console.error(`Workspace: ${rootPath}`);
+  console.error(`Model: ${modelCfg.displayName} (${modelCfg.dimensions}d)`);
+  console.error(`Languages: ${config.languages.join(', ')}`);
+  console.error('');
 
   // Check index version
   const version = loadVersion(indexDir);
   if (needsRebuild(version, config.model)) {
     if (version) {
-      console.log(chalk.yellow('Index version mismatch — full rebuild required.'));
-      console.log(chalk.dim(`  Expected model: ${config.model}, existing: ${version.embeddingModel}`));
+      console.error(chalk.yellow('Index version mismatch — full rebuild required.'));
+      console.error(chalk.dim(`  Expected model: ${config.model}, existing: ${version.embeddingModel}`));
     } else {
-      console.log(chalk.dim('No existing index found — building from scratch.'));
+      console.error(chalk.dim('No existing index found — building from scratch.'));
     }
   } else {
-    console.log(chalk.dim('Existing index is compatible — incremental update.'));
+    console.error(chalk.dim('Existing index is compatible — incremental update.'));
   }
 
   // Setup progress bar
@@ -66,7 +70,7 @@ export async function startCommand(rootPath: string) {
   });
 
   // Initialize stores
-  console.log(chalk.dim('Initializing storage...'));
+  console.error(chalk.dim('Initializing storage...'));
   const metadataStore = new MetadataStore(indexDir);
   const ftsStore = new FTSStore(indexDir);
 
@@ -76,13 +80,13 @@ export async function startCommand(rootPath: string) {
 
   // Initialize embedding provider
   const embedder = new TransformersEmbeddingProvider(config.model);
-  console.log(chalk.dim(`Loading embedding model (${modelCfg.displayName})...`));
+  console.error(chalk.dim(`Loading embedding model (${modelCfg.displayName})...`));
   await embedder.load();
 
   // Initialize reranker if enabled
   let reranker: TransformersReranker | null = null;
   if (config.rerank) {
-    console.log(chalk.dim('Loading reranker model...'));
+    console.error(chalk.dim('Loading reranker model...'));
     reranker = new TransformersReranker();
     await reranker.load();
   }
@@ -150,7 +154,7 @@ export async function startCommand(rootPath: string) {
   const doFullRebuild = needsRebuild(version, config.model) || existingFileHashes.size === 0;
 
   // Index
-  console.log('');
+  console.error('');
   progressBar = new cliProgress.SingleBar({
     format: '{phase} | {bar} | {percentage}% | {value}/{total}',
     barCompleteChar: '\u2588',
@@ -160,20 +164,20 @@ export async function startCommand(rootPath: string) {
 
   if (doFullRebuild) {
     progressBar.start(100, 0, { phase: 'Scanning' });
-    console.log(chalk.dim('Running full index...'));
+    console.error(chalk.dim('Running full index...'));
     const chunks = await indexer.runFullIndex();
     progressBar.stop();
-    console.log(chalk.green(`Indexed ${chunks.length} chunks.`));
+    console.error(chalk.green(`Indexed ${chunks.length} chunks.`));
 
     // Save version
     const newVersion = getExpectedVersion(config.model);
     saveVersion(indexDir, newVersion);
   } else {
     progressBar.start(100, 0, { phase: 'Scanning' });
-    console.log(chalk.dim('Running incremental index...'));
+    console.error(chalk.dim('Running incremental index...'));
     const result = await indexer.runIncremental(existingFileHashes, existingChunkHashes);
     progressBar.stop();
-    console.log(chalk.green(`Indexed ${result.chunks.length} chunks, removed ${result.removed.length} files.`));
+    console.error(chalk.green(`Indexed ${result.chunks.length} chunks, removed ${result.removed.length} files.`));
 
     // Update version
     const existingVersion = version!;
@@ -227,11 +231,40 @@ export async function startCommand(rootPath: string) {
       }
     });
     await watcher.start();
-    console.log(chalk.green('File watcher started.'));
+    console.error(chalk.green('File watcher started.'));
+  }
+
+  // Generate dependency graph SVG
+  try {
+    const { nodes, edges, fileCount, edgeCount } = buildGraphData(metadataStore);
+    if (fileCount > 0) {
+      const svg = generateSVG(rootPath, nodes, edges);
+      writeFileSync(join(rootPath, 'edhindex-graph.svg'), svg, 'utf-8');
+      logger.verbose(`SVG graph: ${fileCount} files, ${edgeCount} edges`);
+    }
+  } catch (e) {
+    logger.debug('Failed to generate graph SVG:', e);
+  }
+
+  // Build knowledge graph
+  if (config.graphEnabled) {
+    try {
+      logger.info('Building knowledge graph...');
+      const graphStore = new GraphStore(indexDir);
+      const builder = new GraphBuilder(rootPath, metadataStore, graphStore);
+      builder.buildFull();
+      const { nodeCount, edgeCount } = { nodeCount: graphStore.getNodeCount(), edgeCount: graphStore.getEdgeCount() };
+      graphStore.close();
+      console.error(chalk.dim(`\n  Knowledge Graph: ${nodeCount} nodes, ${edgeCount} edges`));
+      console.error(chalk.dim(`  View in browser:  edhindex kg --serve`));
+      console.error(chalk.dim(`  View in VS Code:  edhindex kg --write`));
+    } catch (e) {
+      logger.debug('Failed to build knowledge graph:', e);
+    }
   }
 
   // Start MCP server
-  console.log(chalk.green('Starting MCP server on stdio...'));
+  console.error(chalk.green('Starting MCP server on stdio...'));
   const mcpServer = createMCPServer(searchEngine, rootPath);
 
   const transport = await import('@modelcontextprotocol/sdk/server/stdio.js');
@@ -240,7 +273,7 @@ export async function startCommand(rootPath: string) {
 
   // Handle shutdown
   const shutdown = async () => {
-    console.log(chalk.yellow('\nShutting down...'));
+    console.error(chalk.yellow('\nShutting down...'));
     if (watcher) await watcher.stop();
     vectorStore.close();
     metadataStore.close();

package/src/cli/index.ts

@@ -9,6 +9,9 @@ import { statusCommand } from './commands/status.js';
 import { configCommand } from './commands/config_cmd.js';
 import { modelsCommand } from './commands/models.js';
 import { doctorCommand } from './commands/doctor_cmd.js';
+import { resetCommand } from './commands/reset.js';
+import { graphCommand } from './commands/graph.js';
+import { kgCommand } from './commands/knowledge-graph.js';
 import { setLogLevel, LogLevel } from '../logging.js';
 
 const program = new Command();
@@ -96,4 +99,34 @@ program
     await doctorCommand(rootPath, indexDir);
   });
 
+program
+  .command('reset')
+  .description('Delete the index and all stored data')
+  .action(async () => {
+    const rootPath = process.cwd();
+    await resetCommand(rootPath);
+  });
+
+program
+  .command('graph')
+  .description('Generate a dependency graph (SVG)')
+  .option('-o, --output <path>', 'Output file path')
+  .action(async (opts: { output?: string }) => {
+    const rootPath = process.cwd();
+    await graphCommand(rootPath, opts.output);
+  });
+
+program
+  .command('kg')
+  .description('Knowledge graph — build, stats, serve, write, and query')
+  .option('-r, --rebuild', 'Rebuild graph from index')
+  .option('-s, --stats', 'Show graph statistics')
+  .option('--serve', 'Start interactive graph viewer (opens browser)')
+  .option('-w, --write', 'Write graph viewer to .edhindex/knowledge-graph.html')
+  .option('-p, --port <number>', 'Port for graph viewer (default: random)')
+  .action(async (opts: { rebuild?: boolean; stats?: boolean; serve?: boolean; write?: boolean; port?: string }) => {
+    const rootPath = process.cwd();
+    await kgCommand(rootPath, opts);
+  });
+
 program.parse(process.argv);

package/src/config/index.ts

@@ -4,6 +4,7 @@ import { logger } from '../logging.js';
 
 export type ModelTier = 'light' | 'balanced' | 'max';
 export type LogLevelConfig = 'silent' | 'info' | 'verbose' | 'debug';
+export type GraphLayoutConfig = 'force' | 'hierarchical' | 'circular' | 'grid';
 
 export interface Config {
   model: ModelTier;
@@ -12,6 +13,12 @@ export interface Config {
   rerank: boolean;
   maxResults: number;
   logLevel: LogLevelConfig;
+  graphEnabled: boolean;
+  graphLayout: GraphLayoutConfig;
+  graphAnimations: boolean;
+  graphShowFolders: boolean;
+  graphShowFiles: boolean;
+  graphShowFunctions: boolean;
 }
 
 const DEFAULT_CONFIG: Config = {
@@ -21,6 +28,12 @@ const DEFAULT_CONFIG: Config = {
   rerank: true,
   maxResults: 10,
   logLevel: 'info',
+  graphEnabled: true,
+  graphLayout: 'force',
+  graphAnimations: true,
+  graphShowFolders: true,
+  graphShowFiles: true,
+  graphShowFunctions: true,
 };
 
 export function defaultConfig(): Config {

package/src/graph/build.ts

@@ -0,0 +1,45 @@
+import { MetadataStore } from '../storage/metadata.js';
+import { FileNode, parseImportPaths, resolveImport } from './svg.js';
+
+export interface GraphData {
+  nodes: FileNode[];
+  edges: { source: string; target: string }[];
+  fileCount: number;
+  edgeCount: number;
+}
+
+export function buildGraphData(store: MetadataStore): GraphData {
+  const files = store.getAllFilesWithImports();
+
+  const nodeMap = new Map<string, FileNode>();
+  for (const row of files) {
+    if (!nodeMap.has(row.file)) {
+      nodeMap.set(row.file, {
+        id: row.file,
+        label: row.file,
+        language: row.language,
+        chunkCount: row.chunkCount,
+        imports: parseImportPaths(row.imports),
+      });
+    }
+  }
+
+  const edgeSet = new Set<string>();
+  const indexedFiles = new Set(nodeMap.keys());
+  for (const node of nodeMap.values()) {
+    for (const imp of node.imports) {
+      const resolved = resolveImport(node.id, imp, indexedFiles);
+      if (resolved && resolved !== node.id) {
+        edgeSet.add(`${node.id}|${resolved}`);
+      }
+    }
+  }
+
+  const nodes = [...nodeMap.values()];
+  const edges = [...edgeSet].map((e) => {
+    const [source, target] = e.split('|');
+    return { source, target };
+  });
+
+  return { nodes, edges, fileCount: nodes.length, edgeCount: edges.length };
+}