graph-indexer 1.1.0 → 2.0.0

package/layout.mjs

@@ -0,0 +1,123 @@
+/**
+ * @file layout.mjs
+ * @description Single source of truth for graph-indexer's on-disk layout. All
+ *              machine-generated runtime state lives in one tidy `.graph-indexer/`
+ *              directory at the project root (index, vectors, SQLite db, enrichment
+ *              cache, daemon pid/log, resolved config) instead of littering the
+ *              root. Earlier versions wrote these artifacts straight into the root;
+ *              `migrateLegacyLayout` relocates them transparently on the next run.
+ *
+ *              Files that other tools must discover at conventional paths — the
+ *              agent prompt suite (CLAUDE.md, GRAPH_INDEXER_PROMPT.md, Cursor
+ *              rules) and IDE MCP configs (.vscode/mcp.json, .cursor/mcp.json, …) —
+ *              intentionally stay where those tools expect them.
+ * @author MaquinaTech <https://github.com/MaquinaTech>
+ * @copyright (c) 2026 MaquinaTech. All rights reserved.
+ * @license MIT
+ */
+import fs from 'fs';
+import path from 'path';
+
+export const DATA_DIR_NAME = '.graph-indexer';
+
+export const CONFIG_FILE_NAME = 'config.json';
+
+export function dataDir(root) {
+    return path.join(root, DATA_DIR_NAME);
+}
+
+export function ensureDataDir(root) {
+    const dir = dataDir(root);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+
+/**
+ * All generated artifact paths for a project root, derived from one stem so the
+ * indexer, daemon, MCP server and test harness can never drift apart.
+ * @returns {{dataDir,indexPath,embeddingPath,sqlitePath,enrichmentCachePath,pidFile,logFile,configPath}}
+ */
+export function artifactPaths(root) {
+    const dir = dataDir(root);
+    return {
+        dataDir: dir,
+        indexPath: path.join(dir, 'code-index.json'),
+        embeddingPath: path.join(dir, 'code-index.embeddings.bin'),
+        sqlitePath: path.join(dir, 'code-index.db'),
+        enrichmentCachePath: path.join(dir, 'code-index.enrichment.json'),
+        gitSignalsPath: path.join(dir, 'code-index.git.json'),
+        pidFile: path.join(dir, 'daemon.pid'),
+        logFile: path.join(dir, 'daemon.log'),
+        configPath: path.join(dir, CONFIG_FILE_NAME),
+    };
+}
+
+// ─── Legacy → current migration ─────────────────────────────────────────────────
+
+// Regenerable runtime artifacts that lived at the project root before v1.4.
+// Each [legacy-root-name, new-name-inside-data-dir]. When both copies exist the
+// stale root one is safe to drop — it is a derived cache, not user data.
+const LEGACY_ARTIFACTS = [
+    ['code-index.json', 'code-index.json'],
+    ['code-index.json.tmp', 'code-index.json.tmp'],
+    ['code-index.embeddings.bin', 'code-index.embeddings.bin'],
+    ['code-index.embeddings.bin.tmp', 'code-index.embeddings.bin.tmp'],
+    ['code-index.db', 'code-index.db'],
+    ['code-index.db-wal', 'code-index.db-wal'],
+    ['code-index.db-shm', 'code-index.db-shm'],
+    ['code-index.enrichment.json', 'code-index.enrichment.json'],
+    ['.idx-daemon.pid', 'daemon.pid'],
+    ['.idx-daemon.log', 'daemon.log'],
+];
+
+function relocate(src, dst) {
+    try { fs.renameSync(src, dst); return true; }
+    catch {
+        try { fs.copyFileSync(src, dst); fs.unlinkSync(src); return true; }
+        catch { return false; }
+    }
+}
+
+/**
+ * Relocate pre-v1.4 root artifacts into `.graph-indexer/`. Idempotent and
+ * non-destructive to live data: an artifact is only *moved* when the destination
+ * is absent; when a fresh copy already exists in the data dir, the orphaned root
+ * copy (a regenerable cache) is removed to declutter. The user-editable config
+ * (`.graph-indexer.json`) is only ever moved when no new config exists yet —
+ * never overwritten or deleted out from under the user.
+ *
+ * @returns {{moved:Array<{from:string,to:string}>, removed:string[], stoppedDaemon:boolean}}
+ */
+export function migrateLegacyLayout(root) {
+    const moved = [];
+    const removed = [];
+    const dir = dataDir(root);
+
+    for (const [legacyName, newName] of LEGACY_ARTIFACTS) {
+        const src = path.join(root, legacyName);
+        if (!fs.existsSync(src)) continue;
+        const dst = path.join(dir, newName);
+        if (fs.existsSync(dst)) {
+            try { fs.unlinkSync(src); removed.push(legacyName); } catch { /* keep on failure */ }
+        } else {
+            ensureDataDir(root);
+            if (relocate(src, dst)) moved.push({ from: legacyName, to: path.join(DATA_DIR_NAME, newName) });
+        }
+    }
+
+    const legacyCfg = path.join(root, '.graph-indexer.json');
+    const newCfg = path.join(dir, CONFIG_FILE_NAME);
+    if (fs.existsSync(legacyCfg) && !fs.existsSync(newCfg)) {
+        ensureDataDir(root);
+        if (relocate(legacyCfg, newCfg)) {
+            moved.push({ from: '.graph-indexer.json', to: path.join(DATA_DIR_NAME, CONFIG_FILE_NAME) });
+        }
+    }
+
+    return { moved, removed, stoppedDaemon: false };
+}
+
+export function hasLegacyLayout(root) {
+    if (fs.existsSync(path.join(root, '.graph-indexer.json'))) return true;
+    return LEGACY_ARTIFACTS.some(([legacyName]) => fs.existsSync(path.join(root, legacyName)));
+}

package/mcp/format.mjs

@@ -0,0 +1,61 @@
+/**
+ * @file mcp/format.mjs
+ * @description MCP rendering helpers: signature extraction, body pruning.
+ * @author MaquinaTech <https://github.com/MaquinaTech>
+ * @copyright (c) 2026 MaquinaTech. All rights reserved.
+ * @license MIT
+ */
+
+// ─── Rendering helpers ──────────────────────────────────────────────────────────
+
+export function extractSignatureLine(codeSnippet) {
+    if (!codeSnippet) return '';
+    const lines = codeSnippet.split('\n');
+    const sigLines = [];
+    for (let i = 0; i < Math.min(lines.length, 10); i++) {
+        sigLines.push(lines[i]);
+        const l = lines[i];
+        if (i > 0 && (l.trimEnd().endsWith('{') || l.includes('=>') || l.trimEnd().endsWith(':'))) break;
+    }
+    return sigLines.join('\n');
+}
+
+/**
+ * When no lexical token matches (e.g. the agent used a high-level description
+ * like "authentication bottleneck" that isn't in the code verbatim), fall back
+ * to preserving structural skeleton — control-flow lines and calls — rather than
+ * blindly truncating, so the caller still gets meaningful context.
+ */
+export function pruneBodyByQuery(codeSnippet, queryTokens, maxLines = 40) {
+    if (!codeSnippet) return '';
+    const lines = codeSnippet.split('\n');
+    if (lines.length <= maxLines) return codeSnippet;
+
+    const querySet = new Set(queryTokens.filter(t => t.length >= 3).map(t => t.toLowerCase()));
+    if (querySet.size === 0) return lines.slice(0, maxLines).join('\n') + '\n// …';
+
+    const SIG_LINES = Math.min(5, lines.length);
+    const TAIL_LINES = Math.min(3, lines.length);
+    const sigBlock = lines.slice(0, SIG_LINES);
+    const tailBlock = lines.slice(Math.max(lines.length - TAIL_LINES, SIG_LINES));
+
+    const bodyLines = lines.slice(SIG_LINES, lines.length - TAIL_LINES);
+    const relevant = bodyLines.filter(line => {
+        const ll = line.toLowerCase();
+        if (/^\s*(return|throw|raise|yield)\b/.test(ll)) return true;
+        return [...querySet].some(token => ll.includes(token));
+    });
+
+    if (relevant.length === 0) {
+        const budget = Math.max(4, maxLines - SIG_LINES - TAIL_LINES);
+        const structural = bodyLines.filter(line => {
+            const ll = line.trimStart().toLowerCase();
+            if (/^(if |else |for |while |switch |try |catch |finally |return |throw |raise |yield |await )/.test(ll)) return true;
+            if (/[a-zA-Z_]\w*\s*\(/.test(line) && line.trim().length > 4) return true;
+            return false;
+        }).slice(0, budget);
+        if (structural.length > 0) return [...sigBlock, ...structural, ...tailBlock].join('\n');
+        return lines.slice(0, maxLines).join('\n') + '\n// …';
+    }
+    return [...sigBlock, ...relevant, ...tailBlock].join('\n');
+}