graph-indexer 1.0.0 → 1.0.1

package/core-engine.mjs

@@ -3,16 +3,16 @@
  * @description In-Memory Graph Indexer Core Engine.
  * @author MaquinaTech <https://github.com/MaquinaTech>
  * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license GPL-3.0-only
- * * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * @license MIT
+ * Copyright (c) 2026 MaquinaTech. All rights reserved.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions: The above copyright
+ * notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
  */
 import fs from 'fs';
 
@@ -140,12 +140,21 @@ export class MemoryGraphIndex {
             const deps = this.graph.dependencies[chunk.file_path] || [];
             const cleanDeps = deps.map(d => d.split('/').pop().split('.')[0]);
 
-            const enrichedContext = `${chunk.name} ${chunk.docstring || ''} ${cleanDeps.join(' ')} ${(chunk.calls || []).join(' ')} ${chunk.code_snippet}`;
-            this._indexLexical(chunk.id, enrichedContext);
+            const enrichedContext = [
+                chunk.name,
+                chunk.docstring || '',
+                cleanDeps.join(' '),
+                (chunk.calls || []).join(' '),
+                (chunk.params || []).join(' '),
+                chunk.return_type || '',
+                chunk.class_context ? `${chunk.class_context}.${chunk.name}` : '',
+                chunk.code_snippet
+            ].join(' ');
+            this._indexLexical(chunk.id, enrichedContext, chunk.file_path);
         }
     }
 
-    _indexLexical(chunkId, text) {
+    _indexLexical(chunkId, text, filePath = '') {
         const tokens = tokenize(text);
         if (tokens.length === 0) return;
 
@@ -160,6 +169,19 @@ export class MemoryGraphIndex {
             this.df.set(term, (this.df.get(term) || 0) + 1);
         }
 
+        // 🥇 FILENAME TOKEN BOOST: Add file path tokens with fixed TF weight 1.0 (not sublinear)
+        // Splits on /, -, _, ., CamelCase so "authStore.ts" → ["auth", "store", "ts", "authstore"]
+        if (filePath) {
+            const fileTokens = tokenize(filePath.replace(/[\/\-_.]/g, ' '));
+            for (const token of fileTokens) {
+                if (!tfMap.has(token)) {
+                    // Only add if not already from the body (avoids double-counting)
+                    tfMap.set(token, 1.0);
+                    this.df.set(token, (this.df.get(token) || 0) + 1);
+                }
+            }
+        }
+
         this.tf.set(chunkId, tfMap);
         this.docCount++;
     }
@@ -310,23 +332,71 @@ export class MemoryGraphIndex {
         const vectorResults = queryVector ? this._searchVector(queryVector, minScore) : [];
         const rrfScores = new Map();
         const K = this.rrfK;
-        const allResults = [...vectorResults, ...lexicalResults];
 
         const queryLower = queryText.toLowerCase();
-        for (const { id, rank } of allResults) {
-            let baseScore = 1 / (K + rank);
+
+        // 🥇 FILENAME PATH BOOST: when Ollama offline (no vectors), boost chunks from
+        // files whose path contains a token from the query (e.g. "auth middleware" → authStore.ts)
+        const vectorEmpty = vectorResults.length === 0;
+        const queryFileTokens = vectorEmpty
+            ? queryLower.split(/[\s\W_]+/).filter(t => t.length >= 3)
+            : [];
+
+        // Weighted RRF: lexical weight 1.5×, vector weight 1.0×
+        // Keeps semantic lift without drowning precise TF-IDF matches.
+        const LEXICAL_WEIGHT = 1.5;
+        const VECTOR_WEIGHT = 1.0;
+
+        const allResults = [
+            ...vectorResults.map(r => ({ ...r, _w: VECTOR_WEIGHT })),
+            ...lexicalResults.map(r => ({ ...r, _w: LEXICAL_WEIGHT })),
+        ];
+
+        for (const { id, rank, _w } of allResults) {
+            let baseScore = (_w ?? 1.0) / (K + rank);
             const chunk = this.chunks.get(id);
             if (!chunk) continue;
 
-            // Generic: demote test/spec files when the query is not about tests
-            if (/\.(test|spec)\.|[/\\]__tests__[/\\]|_test\./.test(chunk.file_path)) {
-                if (!queryLower.includes('test') && !queryLower.includes('spec')) baseScore *= 0.6;
+            // Generic: demote test/spec files when the query is not about tests.
+            // Catches: foo.test.js, foo.spec.js, __tests__/foo.js, foo_test.go,
+            //          test/foo.js, tests/foo.js, spec/foo.js (plain test dirs).
+            if (/\.(test|spec)\.|[/\\]__tests__[/\\]|_test\.|^tests?[/\\]|[/\\]tests?[/\\]|[/\\]spec[/\\]/.test(chunk.file_path)) {
+                if (!queryLower.includes('test') && !queryLower.includes('spec')) baseScore *= 0.25;
+            }
+            // Demote example/sample/demo/docs directories — prefer canonical lib/src definitions
+            if (/^examples?[/\\]|[/\\]examples?[/\\]|^samples?[/\\]|[/\\]samples?[/\\]|^demos?[/\\]|[/\\]demos?[/\\]|^docs?_?src[/\\]|[/\\]docs?_?src[/\\]|^docs?[/\\]|[/\\]tutorials?[/\\]/.test(chunk.file_path)) {
+                baseScore *= 0.5;
             }
             // Prefer definitions (functions/classes/impls) over pure usage/expression sites
             if (chunk.node_type === 'expression_statement' || chunk.node_type === 'call_expression') {
                 baseScore *= 0.8;
             }
 
+            // Filename path boost when no vectors available.
+            // Also checks if any query token is a prefix of a path segment (≥4 chars),
+            // so "initialise" matches "init.js", "decorator" matches "decorators/", etc.
+            if (vectorEmpty && queryFileTokens.length > 0) {
+                const filePathLower = chunk.file_path.toLowerCase();
+                const hasExact = queryFileTokens.some(t => filePathLower.includes(t));
+                const hasPrefix = !hasExact && queryFileTokens.some(t =>
+                    t.length >= 4 && filePathLower.split(/[/\\._-]/).some(seg => seg.startsWith(t.slice(0, 5)))
+                );
+                if (hasExact) baseScore *= 1.5;
+                else if (hasPrefix) baseScore *= 1.25;
+            }
+
+            // Name-exact-token boost (applies in both lexical and hybrid mode):
+            // If the chunk name exactly matches any significant query token (≥4 chars),
+            // give it an extra 1.4× lift. This promotes WriteJSON over WriteContentType
+            // when the query contains "JSON", and GET/POST/Handle over GetPostForm.
+            if (chunk.name) {
+                const nameLower = chunk.name.toLowerCase();
+                const queryTokensAll = queryLower.split(/[\s\W_]+/).filter(t => t.length >= 4);
+                if (queryTokensAll.some(t => nameLower === t || nameLower.endsWith('.' + t))) {
+                    baseScore *= 1.4;
+                }
+            }
+
             rrfScores.set(id, (rrfScores.get(id) || 0) + baseScore);
         }
 
@@ -364,7 +434,8 @@ export class MemoryGraphIndex {
             id: c.id, file_path: c.file_path, node_type: c.node_type,
             name: c.name, docstring: c.docstring || '', code_snippet: c.code_snippet,
             content_hash: c.content_hash, start_line: c.start_line, end_line: c.end_line,
-            calls: c.calls || []
+            calls: c.calls || [],
+            params: c.params || [], return_type: c.return_type || '', class_context: c.class_context || ''
         }));
         // Embeddings go to a compact binary sidecar — NOT in the JSON payload
         const payload = JSON.stringify({ chunks: chunksData, graph: this.graph });

package/indexer.mjs

@@ -4,16 +4,16 @@
  * @description In-Memory Graph Indexer — Bootstrap Engine. Reads .ts/.tsx/.js/.jsx files → Tree-sitter AST → Local Embeddings → code-index.json. Zero external dependencies (only Tree-sitter). No ChromaDB.
  * @author MaquinaTech <https://github.com/MaquinaTech>
  * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license GPL-3.0-only
- * * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * @license MIT
+ * Copyright (c) 2026 MaquinaTech. All rights reserved.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions: The above copyright
+ * notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
  */
 import fs from 'fs';
 import path from 'path';
@@ -76,7 +76,7 @@ async function main() {
             const parser = getParserForFile(ext);
             if (!parser) continue;
 
-            let tree = parser.parse(content);
+            let tree = parser.parse((offset) => offset < content.length ? content.slice(offset, offset + 4096) : null);
             const rawImports = extractImportsFromAST(tree.rootNode, ext);
             const imports = resolveLocalImports(rawImports, relPath, PROJECT_ROOT);
             indexData.graph.dependencies[relPath] = imports;

package/init.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+/**
+ * @file init.mjs
+ * @description graph-indexer init CLI — auto-configures all detected IDEs/agents.
+ * @author MaquinaTech <https://github.com/MaquinaTech>
+ * @copyright (c) 2026 MaquinaTech. All rights reserved.
+ * @license MIT
+ * Copyright (c) 2026 MaquinaTech. All rights reserved.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions: The above copyright
+ * notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const isDryRun = process.argv.includes('--dry-run');
+const PROJECT_ROOT = process.cwd();
+
+// ─── MCP Server config block ──────────────────────────────────────────────────
+
+const SERVER_CONFIG = {
+    command: 'node',
+    args: [path.join(PROJECT_ROOT, 'node_modules', 'graph-indexer', 'mcp-server.mjs')],
+    env: { MCP_PROJECT_ROOT: PROJECT_ROOT }
+};
+
+// ─── Utilities ────────────────────────────────────────────────────────────────
+
+function log(msg) { process.stdout.write(msg + '\n'); }
+
+function writeFile(filePath, content) {
+    if (isDryRun) {
+        log(`  [dry-run] Would write: ${filePath}`);
+        return;
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+
+function readJsonSafe(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+    } catch { /* malformed JSON — start fresh */ }
+    return null;
+}
+
+/** Deep-merge src into dst without duplicating top-level keys. */
+function mergeJson(dst, src) {
+    for (const [k, v] of Object.entries(src)) {
+        if (dst[k] && typeof dst[k] === 'object' && !Array.isArray(dst[k]) && typeof v === 'object' && !Array.isArray(v)) {
+            mergeJson(dst[k], v);
+        } else {
+            dst[k] = v;
+        }
+    }
+    return dst;
+}
+
+// ─── IDE Detectors & Configurators ───────────────────────────────────────────
+
+function configureVSCode() {
+    const vscodeDir = path.join(PROJECT_ROOT, '.vscode');
+    const configPath = path.join(vscodeDir, 'mcp.json');
+
+    const existing = readJsonSafe(configPath) || {};
+    if (!existing.servers) existing.servers = {};
+    if (existing.servers['graph-indexer']) return false; // already configured
+
+    existing.servers['graph-indexer'] = SERVER_CONFIG;
+    writeFile(configPath, JSON.stringify(existing, null, 2) + '\n');
+    return true;
+}
+
+function configureCursor() {
+    // Check both project-level and global Cursor config
+    const candidates = [
+        path.join(PROJECT_ROOT, '.cursor', 'mcp.json'),
+        path.join(os.homedir(), '.cursor', 'mcp.json'),
+    ];
+    const detected = candidates.some(p => fs.existsSync(path.dirname(p)));
+
+    // Prefer project-level config
+    const configPath = candidates[0];
+    const existing = readJsonSafe(configPath) || {};
+    if (!existing.mcpServers) existing.mcpServers = {};
+    if (existing.mcpServers['graph-indexer']) return false;
+
+    existing.mcpServers['graph-indexer'] = SERVER_CONFIG;
+    writeFile(configPath, JSON.stringify(existing, null, 2) + '\n');
+    return true;
+}
+
+function configureClaudeDesktop() {
+    let configPath;
+    if (process.platform === 'win32') {
+        configPath = path.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json');
+    } else {
+        configPath = path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+
+    if (!fs.existsSync(path.dirname(configPath))) return false; // Claude not installed
+
+    const existing = readJsonSafe(configPath) || {};
+    if (!existing.mcpServers) existing.mcpServers = {};
+    if (existing.mcpServers['graph-indexer']) return false;
+
+    existing.mcpServers['graph-indexer'] = SERVER_CONFIG;
+    writeFile(configPath, JSON.stringify(existing, null, 2) + '\n');
+    return true;
+}
+
+function configureClaudeCode() {
+    // Claude Code stores MCP config in .mcp.json or .claude/settings.json at project root
+    const candidates = [
+        path.join(PROJECT_ROOT, '.claude', 'settings.json'),
+        path.join(PROJECT_ROOT, '.mcp.json'),
+    ];
+
+    // Prefer .claude/settings.json if directory exists, else .mcp.json
+    const hasClaudeDir = fs.existsSync(path.join(PROJECT_ROOT, '.claude'));
+    const configPath = hasClaudeDir ? candidates[0] : candidates[1];
+
+    const existing = readJsonSafe(configPath) || {};
+    const serverKey = hasClaudeDir ? 'mcpServers' : 'mcpServers';
+    if (!existing[serverKey]) existing[serverKey] = {};
+    if (existing[serverKey]['graph-indexer']) return false;
+
+    existing[serverKey]['graph-indexer'] = SERVER_CONFIG;
+    writeFile(configPath, JSON.stringify(existing, null, 2) + '\n');
+    return true;
+}
+
+// ─── package.json scripts ─────────────────────────────────────────────────────
+
+function addPackageScripts() {
+    const pkgPath = path.join(PROJECT_ROOT, 'package.json');
+    if (!fs.existsSync(pkgPath)) return false;
+
+    const pkg = readJsonSafe(pkgPath);
+    if (!pkg) return false;
+
+    const scripts = pkg.scripts || {};
+    const toAdd = {
+        'mcp:index': 'idx-index --repo .',
+        'mcp:watch': 'idx-watch',
+        'mcp:start': 'idx-mcp',
+    };
+
+    let changed = false;
+    for (const [k, v] of Object.entries(toAdd)) {
+        if (!scripts[k]) { scripts[k] = v; changed = true; }
+    }
+
+    if (changed) {
+        pkg.scripts = scripts;
+        writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    }
+    return changed;
+}
+
+// ─── .gitignore ──────────────────────────────────────────────────────────────
+
+function updateGitignore() {
+    const gitignorePath = path.join(PROJECT_ROOT, '.gitignore');
+    const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf-8') : '';
+
+    const entries = ['code-index.json', 'code-index.embeddings.bin'];
+    const toAdd = entries.filter(e => !existing.includes(e));
+    if (toAdd.length === 0) return false;
+
+    const newContent = existing.trimEnd() + '\n\n# graph-indexer runtime artifacts\n' + toAdd.join('\n') + '\n';
+    writeFile(gitignorePath, newContent);
+    return true;
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+log('\n🔧 graph-indexer init' + (isDryRun ? ' [dry-run]' : '') + '\n');
+log(`📂 Project: ${PROJECT_ROOT}\n`);
+
+const configured = [];
+const skipped = [];
+
+// IDE configuration
+const ides = [
+    { name: 'VS Code', fn: configureVSCode },
+    { name: 'Cursor', fn: configureCursor },
+    { name: 'Claude Desktop', fn: configureClaudeDesktop },
+    { name: 'Claude Code', fn: configureClaudeCode },
+];
+
+log('🔍 Detecting IDEs / agents...\n');
+for (const { name, fn } of ides) {
+    try {
+        const result = fn();
+        if (result === false) {
+            skipped.push(name + ' (already configured or not installed)');
+        } else {
+            configured.push(name);
+        }
+    } catch (e) {
+        skipped.push(name + ' (error: ' + e.message + ')');
+    }
+}
+
+// Package scripts
+const scriptsAdded = addPackageScripts();
+if (scriptsAdded) configured.push('package.json scripts (mcp:index, mcp:watch, mcp:start)');
+else skipped.push('package.json scripts (already present)');
+
+// .gitignore
+const gitignoreUpdated = updateGitignore();
+if (gitignoreUpdated) configured.push('.gitignore (code-index.json, code-index.embeddings.bin)');
+else skipped.push('.gitignore (already contains index entries)');
+
+// ─── Summary ─────────────────────────────────────────────────────────────────
+
+log('\n✅ Configured:\n');
+if (configured.length) configured.forEach(c => log('  • ' + c));
+else log('  (nothing new to configure)');
+
+if (skipped.length) {
+    log('\n⏭️  Skipped:\n');
+    skipped.forEach(s => log('  • ' + s));
+}
+
+log('\n📋 Next steps:\n');
+log('  1. Run `npm run mcp:index` to index this project');
+log('  2. Restart your IDE to activate MCP servers');
+log('  3. Run `npm run mcp:start` if your IDE needs the server started manually');
+log('\n');

package/mcp-server.mjs

@@ -4,16 +4,16 @@
  * @description MCP Server to expose in-memory graph index with hybrid search capabilities. Connects to local Ollama instance for embedding generation. Zero external dependencies.
  * @author MaquinaTech <https://github.com/MaquinaTech>
  * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license GPL-3.0-only
- * * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * @license MIT
+ * Copyright (c) 2026 MaquinaTech. All rights reserved.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions: The above copyright
+ * notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
  */
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -127,7 +127,7 @@ server.resource(
 
 server.tool(
     "search_code",
-    "Hybrid semantic + lexical search (RRF). Returns compact signature cards for all results and fills remaining token budget with code bodies. Use get_chunk(id) to expand any result.",
+    "CRITICAL: ALWAYS USE THIS TOOL FIRST to find code. DO NOT use native file search or grep. High-precision AST search returning exact chunks and topology. Use natural language query.",
     {
         query: z.string().describe("What logic to search for. Example: 'JWT authentication in middleware'"),
         exact_tokens: z.string().optional().describe("Exact variable or function name to boost in results"),
@@ -205,7 +205,7 @@ server.tool(
 
 server.tool(
     "get_chunk",
-    "Returns the full source body of a specific indexed code chunk by ID. Use AFTER search_code when you need more than the signature.",
+    "CRITICAL: Use this INSTEAD of reading full files to get the body of a function or class. Requires the chunk_id returned by search_code.",
     { chunk_id: z.string().describe("The chunk ID shown in search_code results (e.g. \"abc123def456\").") },
     async ({ chunk_id }) => {
         try {
@@ -250,7 +250,7 @@ server.tool(
 
             if (!parser) return { content: [{ type: "text", text: "Language not supported for AST parsing." }] };
 
-            const tree = parser.parse(content);
+            const tree = parser.parse((offset) => offset < content.length ? content.slice(offset, offset + 4096) : null);
             const skeleton = extractFileSkeleton(tree.rootNode, content);
 
             return { content: [{ type: "text", text: `# Skeleton: ${file_path}\n\n${skeleton || "_No semantic signatures found_"}` }] };
@@ -290,6 +290,83 @@ server.tool(
     }
 );
 
+server.tool(
+    "list_index_stats",
+    "Returns the current state of the graph-indexer index: chunk count, file count, embedding status, daemon status, and index freshness. Call this first if search results seem wrong or stale.",
+    {},
+    async () => {
+        try {
+            const chunkCount = db.chunks.size;
+            const fileSet = new Set();
+            for (const chunk of db.chunks.values()) fileSet.add(chunk.file_path);
+            const fileCount = fileSet.size;
+
+            const hasEmbeddings = db.vectors.size > 0;
+            const embeddingsEnabled = process.env.INDEXER_EMBEDDINGS !== 'off';
+
+            let indexAge = 'unknown';
+            try {
+                const stat = fs.statSync(INDEX_PATH);
+                const ageMs = Date.now() - stat.mtimeMs;
+                const ageSec = Math.floor(ageMs / 1000);
+                if (ageSec < 60) indexAge = `${ageSec}s ago`;
+                else if (ageSec < 3600) indexAge = `${Math.floor(ageSec / 60)}m ago`;
+                else indexAge = `${Math.floor(ageSec / 3600)}h ago`;
+            } catch { /* file not found */ }
+
+            let daemonStatus = 'unknown';
+            try {
+                if (fs.existsSync(PID_FILE)) {
+                    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8'), 10);
+                    process.kill(pid, 0);
+                    daemonStatus = `running (PID: ${pid})`;
+                } else {
+                    daemonStatus = 'not running';
+                }
+            } catch { daemonStatus = 'not running (stale PID)'; }
+
+            // Extension distribution
+            const extCounts = new Map();
+            for (const chunk of db.chunks.values()) {
+                const ext = chunk.file_path.split('.').pop() || 'unknown';
+                extCounts.set(ext, (extCounts.get(ext) || 0) + 1);
+            }
+
+            const searchMode = !embeddingsEnabled
+                ? '🔤 Lexical only (INDEXER_EMBEDDINGS=off)'
+                : hasEmbeddings
+                    ? '🧠 Hybrid (semantic + lexical RRF)'
+                    : '🔤 Lexical only (Ollama unavailable or not yet indexed)';
+
+            const lines = [
+                `# 📊 graph-indexer Index Stats`,
+                ``,
+                `| Metric | Value |`,
+                `| :--- | :--- |`,
+                `| **Chunks** | ${chunkCount} |`,
+                `| **Files indexed** | ${fileCount} |`,
+                `| **Embeddings loaded** | ${db.vectors.size} |`,
+                `| **Search mode** | ${searchMode} |`,
+                `| **Daemon** | ${daemonStatus} |`,
+                `| **Index age** | ${indexAge} |`,
+                ``,
+                `## Extension Breakdown`,
+                ...Array.from(extCounts.entries())
+                    .sort((a, b) => b[1] - a[1])
+                    .map(([ext, count]) => `- .${ext}: ${count} chunks`),
+            ];
+
+            if (chunkCount === 0) {
+                lines.push(``, `⚠️ Index is empty. Run \`npm run mcp:index\` to build it.`);
+            }
+
+            return { content: [{ type: "text", text: lines.join('\n') }] };
+        } catch (err) {
+            return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+        }
+    }
+);
+
 const transport = new StdioServerTransport();
 await server.connect(transport);
 process.stderr.write("✅ graph-indexer MCP server running (v1.0.0).\n");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "graph-indexer",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "Zero-DB, Air-gapped, In-Memory Graph Indexer MCP Server with Hybrid RRF Search and Cross-Language Topology",
     "type": "module",
     "main": "core-engine.mjs",
@@ -8,6 +8,7 @@
         ".": "./core-engine.mjs"
     },
     "bin": {
+        "graph-indexer": "init.mjs",
         "idx-index": "indexer.mjs",
         "idx-watch": "watch-daemon.mjs",
         "idx-mcp": "mcp-server.mjs"
@@ -24,7 +25,14 @@
     },
     "scripts": {
         "start": "node ./mcp-server.mjs",
-        "test": "node tests/eval-harness.mjs --index ./code-index.json",
+        "test": "node test/run.mjs",
+        "test:setup": "node test/setup.mjs",
+        "test:run": "node test/run.mjs",
+        "test:embeddings": "OLLAMA_HOST=http://localhost:11435 node test/run-embeddings.mjs",
+        "test:embeddings:skip": "OLLAMA_HOST=http://localhost:11435 node test/run-embeddings.mjs --skip-indexing",
+        "test:suite": "node test/run.mjs --suite",
+        "test:json": "node test/run.mjs --json",
+        "test:reset": "rm -rf test/fixtures && node test/setup.mjs",
         "mcp:index": "node indexer.mjs --repo .",
         "mcp:watch": "node watch-daemon.mjs",
         "mcp:start": "node mcp-server.mjs"
@@ -34,11 +42,15 @@
         "chokidar": "5.0.0",
         "ignore": "5.3.2",
         "tree-sitter": "0.21.1",
+        "tree-sitter-c-sharp": "^0.21.3",
         "tree-sitter-css": "0.21.1",
         "tree-sitter-go": "0.21.0",
+        "tree-sitter-java": "^0.21.0",
         "tree-sitter-javascript": "0.21.4",
+        "tree-sitter-kotlin": "^0.3.8",
         "tree-sitter-php": "0.23.1",
         "tree-sitter-python": "0.21.0",
+        "tree-sitter-ruby": "^0.23.1",
         "tree-sitter-rust": "0.21.0",
         "tree-sitter-typescript": "0.21.2",
         "zod": "3.23.8"
@@ -60,7 +72,7 @@
         "url": "https://github.com/MaquinaTech",
         "email": "nicolopezdelerma@gmail.com"
     },
-    "license": "GPL-3.0-only",
+    "license": "MIT",
     "engines": {
         "node": ">=18.0.0"
     },
@@ -78,4 +90,4 @@
     "optionalDependencies": {
         "hnswlib-node": "^3.0.0"
     }
-}
+}