promptgraph-mcp 1.5.26 → 1.8.0

package/README.md

@@ -11,13 +11,13 @@ PromptGraph is an MCP server that gives Claude Code a semantic skill index — v
 
 ## Why
 
-Claude Code dumps every file in `~/.claude/commands/` into the system prompt — every session, every message. At 40+ skills that's **20,000–50,000 wasted tokens before you say a word.**
+Claude Code loads skill metadata from `~/.claude/commands/` each session. With 40+ skills that's thousands of tokens in routing overhead before you say a word. More importantly, when Claude loads and executes a full skill file (typically 1,000–5,000 tokens each), the cost multiplies fast.
 
-PromptGraph replaces that with one tiny router skill (`~150 tokens`) and a local vector index. When you ask something, Claude calls `pg_search` → gets the right skill path → reads only that file.
+PromptGraph replaces that with one tiny router skill (`~150 tokens`) and a local vector index. Claude calls `pg_search` → gets the right skill path + a content snippet → reads only that file when needed.
 
 ```
-Before:  all 40 skills loaded  →  ~40,000 tokens wasted
-After:   1 router + 1 match    →  ~300 tokens total
+Before:  route across all 40 skills  →  40 × read overhead
+After:   1 pg_search call + snippet  →  read only what you need
 ```
 
 ---
@@ -31,7 +31,7 @@ After:   1 router + 1 match    →  ~300 tokens total
 - ⚡ **Local embeddings** — `fastembed` BGE-Small-EN, 23 MB, no API key needed
 - 👁️ **File watcher** — auto-reindexes when you add or edit skills
 - 🛡️ **Validator** — blocks malicious/junk skills before they reach your machine
-- 🌐 **MCP-native** — works with Claude Code, Claude Desktop, Cline, and any MCP client
+- 🌐 **MCP-native** — works with Claude Code, Claude Desktop, Cline, OpenCode, Cursor, Windsurf, and any MCP client
 
 ---
 
@@ -61,6 +61,22 @@ npx promptgraph-mcp init
 }
 ```
 
+### Add to OpenCode (`~/.config/opencode/opencode.json`)
+
+```json
+{
+  "mcp": {
+    "promptgraph": {
+      "type": "local",
+      "command": ["npx", "promptgraph-mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+> `pg setup` auto-detects OpenCode and writes this config for you.
+
 ### Move your skills out of `commands/`
 
 ```bash

package/ann.js

@@ -1,61 +1,60 @@
-import { LocalIndex } from 'vectra';
-import path from 'path';
-import os from 'os';
-import { getDb } from './db.js';
-
-const INDEX_PATH = path.join(os.homedir(), '.claude', '.promptgraph', 'hnsw-index');
-
-let _index = null;
+import { getDb, blobToVec } from './db.js';
+
+// In-memory flat index — no external dependency.
+// For typical skill counts (<5000) this is faster than vectra's disk-based HNSW
+// because all data fits in RAM and no I/O is needed per query.
+let _cache = null;
+let _cacheChunkCount = -1;
+
+function loadCache(db) {
+  const count = db.prepare('SELECT COUNT(*) as n FROM chunks').get().n;
+  if (_cache && count === _cacheChunkCount) return _cache;
+  const rows = db.prepare('SELECT skill_id, embedding FROM chunks').all();
+  _cache = rows.map(r => ({
+    skill_id: r.skill_id,
+    vec: new Float32Array(blobToVec(r.embedding)),
+  }));
+  _cacheChunkCount = count;
+  return _cache;
+}
 
-async function getIndex() {
-  if (_index) return _index;
-  _index = new LocalIndex(INDEX_PATH);
-  if (!await _index.isIndexCreated()) {
-    await _index.createIndex({ version: 1, deleteIfExists: true });
+function cosineSim(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
   }
-  return _index;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-8);
 }
 
+// Called after reindex — invalidate cache so next search reloads
 export async function buildAnnIndex() {
-  const index = await getIndex();
-  await index.createIndex({ version: 1, deleteIfExists: true });
-
+  _cache = null;
+  _cacheChunkCount = -1;
   const db = getDb();
-  const chunks = db.prepare('SELECT skill_id, chunk_index, embedding FROM chunks').all();
-
-  // Batch ALL inserts into a single disk write — vectra otherwise
-  // persists the whole index on every insertItem (O(N^2) I/O).
-  await index.beginUpdate();
-  try {
-    for (const chunk of chunks) {
-      const vec = JSON.parse(chunk.embedding);
-      await index.insertItem({
-        vector: vec,
-        metadata: { skill_id: chunk.skill_id, chunk_index: chunk.chunk_index },
-      });
-    }
-    await index.endUpdate();
-  } catch (e) {
-    try { index.cancelUpdate(); } catch {}
-    throw e;
-  }
-
-  _index = null; // force reload so queries see fresh index
-  console.error(`[PromptGraph] ANN index built: ${chunks.length} chunks`);
+  const count = db.prepare('SELECT COUNT(*) as n FROM chunks').get().n;
+  console.error(`[PromptGraph] In-memory index ready: ${count} chunks`);
 }
 
 export async function annSearch(queryVec, topK = 20) {
   try {
-    const index = await getIndex();
-    if (!await index.isIndexCreated()) return null;
-    const items = await index.listItems();
-    if (!items || items.length === 0) return null;
+    const db = getDb();
+    const cache = loadCache(db);
+    if (!cache.length) return null;
+
+    const qArr = new Float32Array(queryVec);
+    const bestBySkill = new Map();
+    for (const entry of cache) {
+      const score = cosineSim(qArr, entry.vec);
+      const prev = bestBySkill.get(entry.skill_id);
+      if (!prev || score > prev) bestBySkill.set(entry.skill_id, score);
+    }
 
-    const results = await index.queryItems(queryVec, topK);
-    return results.map(r => ({
-      skill_id: r.item.metadata.skill_id,
-      score: r.score,
-    }));
+    return [...bestBySkill.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, topK)
+      .map(([skill_id, score]) => ({ skill_id, score }));
   } catch {
     return null;
   }

package/chunker.js

@@ -2,15 +2,24 @@ const CHUNK_SIZE = 800;
 const CHUNK_OVERLAP = 100;
 
 export function chunkText(text) {
-  const words = text.split(/\s+/);
+  // Split on markdown h1/h2/h3 headers to preserve semantic boundaries
+  const sections = text.split(/(?=\n#{1,3} )/);
   const chunks = [];
-  let i = 0;
 
-  while (i < words.length) {
-    const chunk = words.slice(i, i + CHUNK_SIZE).join(' ');
-    chunks.push(chunk);
-    if (i + CHUNK_SIZE >= words.length) break;
-    i += CHUNK_SIZE - CHUNK_OVERLAP;
+  for (const section of sections) {
+    const words = section.split(/\s+/).filter(Boolean);
+    if (words.length === 0) continue;
+
+    if (words.length <= CHUNK_SIZE) {
+      chunks.push(section.trim());
+    } else {
+      let i = 0;
+      while (i < words.length) {
+        chunks.push(words.slice(i, i + CHUNK_SIZE).join(' '));
+        if (i + CHUNK_SIZE >= words.length) break;
+        i += CHUNK_SIZE - CHUNK_OVERLAP;
+      }
+    }
   }
 
   return chunks.length > 0 ? chunks : [text];

package/config.js

@@ -3,7 +3,9 @@ import path from 'path';
 import os from 'os';
 import readline from 'readline';
 
-const CONFIG_PATH = path.join(os.homedir(), '.claude', '.promptgraph', 'config.json');
+export const PROMPTGRAPH_DIR = path.join(os.homedir(), '.claude', '.promptgraph');
+export const SKILLS_STORE_DIR = path.join(os.homedir(), '.claude', 'skills-store');
+const CONFIG_PATH = path.join(PROMPTGRAPH_DIR, 'config.json');
 
 const DEFAULTS = {
   sources: [

package/db.js

@@ -1,9 +1,9 @@
 import Database from 'better-sqlite3';
 import path from 'path';
-import os from 'os';
 import fs from 'fs';
+import { PROMPTGRAPH_DIR } from './config.js';
 
-const DB_PATH = path.join(os.homedir(), '.claude', '.promptgraph', 'promptgraph.db');
+const DB_PATH = path.join(PROMPTGRAPH_DIR, 'promptgraph.db');
 
 let _db = null;
 
@@ -30,7 +30,7 @@ export function getDb() {
       skill_id TEXT NOT NULL,
       chunk_index INTEGER NOT NULL,
       text TEXT NOT NULL,
-      embedding TEXT NOT NULL,
+      embedding BLOB NOT NULL,
       UNIQUE(skill_id, chunk_index)
     );
 
@@ -54,9 +54,33 @@ export function getDb() {
     db.exec('ALTER TABLE skills ADD COLUMN hash TEXT');
   }
 
+  // migrate: convert JSON text embeddings to Float32 BLOB (one-time, ~10x smaller)
+  const textEmbeddings = db.prepare("SELECT COUNT(*) as n FROM chunks WHERE typeof(embedding) = 'text'").get();
+  if (textEmbeddings?.n > 0) {
+    const rows = db.prepare("SELECT rowid, embedding FROM chunks WHERE typeof(embedding) = 'text'").all();
+    const upd = db.prepare('UPDATE chunks SET embedding = ? WHERE rowid = ?');
+    db.transaction(() => {
+      for (const row of rows) {
+        const vec = JSON.parse(row.embedding);
+        upd.run(Buffer.from(new Float32Array(vec).buffer), row.rowid);
+      }
+    })();
+    console.error(`[PromptGraph] Migrated ${textEmbeddings.n} embeddings TEXT→BLOB`);
+  }
+
   return db;
 }
 
 export function skillId(source, name) {
   return `${source}::${name}`;
 }
+
+export function vecToBlob(vec) {
+  return Buffer.from(new Float32Array(vec).buffer);
+}
+
+export function blobToVec(blob) {
+  if (typeof blob === 'string') return JSON.parse(blob);
+  const buf = Buffer.isBuffer(blob) ? blob : Buffer.from(blob);
+  return Array.from(new Float32Array(buf.buffer, buf.byteOffset, buf.length / 4));
+}

package/index.js

@@ -12,7 +12,7 @@ const args = process.argv.slice(2);
 const rawBin = process.argv[1]?.split(/[\\/]/).pop()?.replace(/\.js$/, '');
 const bin = (rawBin && rawBin !== 'index') ? rawBin : 'pg';
 
-const KNOWN_COMMANDS = new Set(['init', 'reindex', 'import', 'setup', 'validate', 'marketplace', 'doctor', 'search', 'help', '--help', '-h']);
+const KNOWN_COMMANDS = new Set(['init', 'reindex', 'update', 'import', 'setup', 'validate', 'marketplace', 'doctor', 'search', 'help', '--help', '-h']);
 
 function showHelp() {
   console.log(
@@ -31,13 +31,14 @@ function showHelp() {
     ['marketplace [page]',  'Browse the community skill registry'],
     ['validate <file.md>',  'Validate a skill before publishing'],
     ['doctor',              'Clean orphaned chunks/edges/ratings'],
+    ['update',              'Update to the latest version from npm'],
     ['setup <platform>',    'Register MCP in platform config'],
     ['help',                'Show this help'],
   ];
   for (const [cmd, desc] of cmds) {
     console.log('  ' + chalk.hex('#7C3AED')((bin + ' ' + cmd).padEnd(28)) + chalk.gray(desc));
   }
-  console.log(chalk.gray('\nPlatforms: claude-code, claude-desktop, cline, codex, cursor, windsurf'));
+  console.log(chalk.gray('\nPlatforms: claude-code, claude-desktop, cline, codex, cursor, windsurf, opencode'));
   console.log(chalk.gray('\n  github.com/NeiP4n/promptgraph  ·  npmjs.com/package/promptgraph-mcp\n'));
 }
 
@@ -116,8 +117,14 @@ if (args[0] === 'marketplace' && (args[1] === 'bundles' || args[1] === 'bundle')
     console.log();
   });
 
-  console.log('  ' + chalk.gray('─'.repeat(54)));
-  console.log('  ' + chalk.gray('Installs all skills in the set. Run ') + chalk.cyan(`${bin} marketplace`) + chalk.gray(' for single skills.'));
+  console.log(
+    boxen(
+      chalk.dim('install bundle ') + chalk.white('install bundle ') + chalk.hex('#A78BFA')('engineering-essentials') + '\n' +
+      chalk.dim('browse skills  ') + chalk.cyan(`${bin} marketplace`) + '\n' +
+      chalk.dim('publish bundle ') + chalk.white('/pg-publish ') + chalk.hex('#A78BFA')('<bundle.json>'),
+      { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: '#4B5563', dimBorder: true }
+    )
+  );
   console.log();
   process.exit(0);
 }
@@ -190,10 +197,21 @@ if (args[0] === 'marketplace') {
     if (page > 1) nav.push(chalk.dim('‹ ') + chalk.cyan(`${bin} marketplace ${page - 1}`));
     if (page < totalPages) nav.push(chalk.cyan(`${bin} marketplace ${page + 1}`) + chalk.dim(' ›'));
     console.log('  ' + nav.join('     '));
+    console.log();
   }
-  console.log('  ' + chalk.dim('install   ') + chalk.cyan('tell your AI:') + ' ' + chalk.white('install ') + chalk.hex('#A78BFA')(slice[0].code || slice[0].id));
-  console.log('  ' + chalk.dim('bundles   ') + chalk.cyan(`${bin} marketplace bundles`));
-  console.log('  ' + chalk.dim('publish   ') + chalk.cyan('tell your AI:') + ' ' + chalk.white('/pg-publish <file>'));
+
+  const exCode = slice[0]?.code || slice[0]?.id || 'pg-xxxxxx';
+  console.log(
+    boxen(
+      chalk.dim('install skill  ') + chalk.white('install ') + chalk.hex('#A78BFA')(exCode) + '\n' +
+      chalk.dim('install bundle ') + chalk.white('install bundle ') + chalk.hex('#A78BFA')('engineering-essentials') + '\n' +
+      chalk.dim('from GitHub    ') + chalk.white('install ') + chalk.hex('#A78BFA')('https://github.com/owner/repo/blob/main/skill.md') + '\n' +
+      chalk.dim('publish skill  ') + chalk.white('/pg-publish ') + chalk.hex('#A78BFA')('<file.md>') + '\n' +
+      chalk.dim('publish bundle ') + chalk.white('/pg-publish ') + chalk.hex('#A78BFA')('<bundle.json>') + '\n' +
+      chalk.dim('view bundles   ') + chalk.cyan(`${bin} marketplace bundles`),
+      { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: '#4B5563', dimBorder: true }
+    )
+  );
   console.log();
   process.exit(0);
 }
@@ -261,6 +279,24 @@ if (args[0] === 'setup') {
 if (args[0] === 'init') {
   const { promptConfig } = await import('./config.js');
   const { indexAll } = await import('./indexer.js');
+  const os = await import('os');
+  const fs = await import('fs');
+  const path = await import('path');
+  const commandsDir = path.default.join(os.default.homedir(), '.claude', 'commands');
+  if (!fs.default.existsSync(commandsDir)) {
+    console.log(chalk.yellow('⚠') + '  ' + chalk.gray('~/.claude/commands/ not found — is Claude Code installed?'));
+    console.log(chalk.gray('   Install from: https://claude.ai/download\n'));
+  }
+  if (!args.includes('--yes') && !args.includes('-y')) {
+    const readline = await import('readline');
+    const rl = readline.default.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise(r => rl.question(
+      chalk.yellow('  ⚠') + chalk.gray('  First run downloads ~23 MB embedding model (BGE-Small-EN).\n  Proceed? [Y/n] '), r
+    ));
+    rl.close();
+    if (answer.trim().toLowerCase() === 'n') { info('Aborted.'); process.exit(0); }
+  }
+  console.log(chalk.gray('\n  Downloading embedding model (~23 MB, one-time)...\n'));
   const config = await promptConfig();
   await indexAll();
   console.log();
@@ -274,6 +310,43 @@ if (args[0] === 'init') {
   process.exit(0);
 }
 
+if (args[0] === 'update') {
+  const { spawnSync } = await import('child_process');
+  const { createRequire } = await import('module');
+  const req = createRequire(import.meta.url);
+  const currentVersion = req('./package.json').version;
+
+  // Check latest version on npm
+  const spin = (await import('./cli.js')).spinner('Checking latest version...');
+  spin.start();
+  let latest = null;
+  try {
+    const r = spawnSync('npm', ['view', 'promptgraph-mcp', 'version'], { encoding: 'utf8' });
+    latest = r.stdout?.trim();
+  } catch {}
+  spin.stop();
+
+  if (!latest) { error('Could not reach npm registry. Check your network.'); process.exit(1); }
+  if (latest === currentVersion) {
+    success(`Already on latest version ${chalk.white.bold('v' + currentVersion)}`);
+    process.exit(0);
+  }
+
+  info(`Current: ${chalk.gray('v' + currentVersion)}  →  Latest: ${chalk.white.bold('v' + latest)}`);
+  const updateSpin = (await import('./cli.js')).spinner(`Installing promptgraph-mcp@${latest}...`);
+  updateSpin.start();
+  const result = spawnSync('npm', ['install', '-g', `promptgraph-mcp@${latest}`], { encoding: 'utf8', stdio: 'pipe' });
+  updateSpin.stop();
+
+  if (result.status !== 0) {
+    error('Update failed:');
+    console.log(chalk.gray(result.stderr || result.stdout));
+    process.exit(1);
+  }
+  success(`Updated to ${chalk.white.bold('v' + latest)}`);
+  process.exit(0);
+}
+
 if (args[0] === 'reindex') {
   const { indexAll } = await import('./indexer.js');
   await indexAll();
@@ -285,8 +358,9 @@ const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
 const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
 const { CallToolRequestSchema, ListToolsRequestSchema } = await import('@modelcontextprotocol/sdk/types.js');
 const { search, getContext, getCallers, getCallees, getImpact, listAll } = await import('./search.js');
+const { loadConfig: _loadConfig, saveConfig: _saveConfig } = await import('./config.js');
 const { startWatcher } = await import('./watcher.js');
-const { browseMarketplace, installSkill, publishSkill, getTopRated, recordUse, recordSuccess, recordFail, browseBundles, installBundle } = await import('./marketplace.js');
+const { browseMarketplace, installSkill, installSkillFromUrl, publishSkill, publishBundle, getTopRated, recordUse, recordSuccess, recordFail, browseBundles, installBundle } = await import('./marketplace.js');
 
 const server = new Server(
   { name: 'promptgraph', version: '1.0.0' },
@@ -408,6 +482,45 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ['bundle_id'],
       },
     },
+    {
+      name: 'pg_config',
+      description: 'Get or update PromptGraph config. action="get" returns current sources. action="add_source" adds a directory.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['get', 'add_source', 'remove_source'] },
+          dir: { type: 'string', description: 'Directory path (for add_source)' },
+          source: { type: 'string', description: 'Source label (for add_source/remove_source)' },
+        },
+        required: ['action'],
+      },
+    },
+    {
+      name: 'pg_install_url',
+      description: 'Install a skill directly from a GitHub URL or raw URL. Validates before saving.',
+      inputSchema: {
+        type: 'object',
+        properties: { url: { type: 'string', description: 'GitHub blob URL or raw URL of a .md skill file' } },
+        required: ['url'],
+      },
+    },
+    {
+      name: 'pg_bundle_publish',
+      description: 'Publish a bundle definition to GitHub Gist and get a registry submission link. Pass a JSON object or path to a .json file.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          bundle: {
+            description: 'Bundle definition object { id, name, description, skills[], tags[] } OR file path to .json',
+            oneOf: [
+              { type: 'object' },
+              { type: 'string' },
+            ],
+          },
+        },
+        required: ['bundle'],
+      },
+    },
   ],
 }));
 
@@ -435,6 +548,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'pg_marketplace_publish': result = await publishSkill(args.file_path); break;
       case 'pg_bundle_browse': result = await browseBundles(args.top_k || 20); break;
       case 'pg_bundle_install': result = await installBundle(args.bundle_id); break;
+      case 'pg_install_url': result = await installSkillFromUrl(args.url); break;
+      case 'pg_bundle_publish': result = await publishBundle(args.bundle); break;
+      case 'pg_config': {
+        const cfg = _loadConfig();
+        if (args.action === 'get') {
+          result = { sources: cfg.sources };
+        } else if (args.action === 'add_source') {
+          if (!args.dir || !args.source) throw new Error('dir and source required for add_source');
+          if (cfg.sources.find(s => s.source === args.source)) throw new Error(`Source "${args.source}" already exists`);
+          cfg.sources.push({ dir: args.dir, source: args.source });
+          _saveConfig(cfg);
+          result = { ok: true, sources: cfg.sources };
+        } else if (args.action === 'remove_source') {
+          if (!args.source) throw new Error('source required for remove_source');
+          const before = cfg.sources.length;
+          cfg.sources = cfg.sources.filter(s => s.source !== args.source);
+          if (cfg.sources.length === before) throw new Error(`Source "${args.source}" not found`);
+          _saveConfig(cfg);
+          result = { ok: true, sources: cfg.sources };
+        } else {
+          throw new Error(`Unknown action: ${args.action}`);
+        }
+        break;
+      }
       default: throw new Error(`Unknown tool: ${name}`);
     }
     return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
@@ -448,3 +585,11 @@ startWatcher();
 const transport = new StdioServerTransport();
 await server.connect(transport);
 console.error('[PromptGraph] MCP server running');
+
+const { getDb: _getDb } = await import('./db.js');
+const shutdown = () => {
+  try { _getDb().close(); } catch {}
+  process.exit(0);
+};
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);

package/indexer.js

@@ -4,7 +4,7 @@ import fs from 'fs';
 import path from 'path';
 import { parseSkillFile, isSkillFile } from './parser.js';
 import { embedBatch, BATCH_SIZE } from './embedder.js';
-import { getDb, skillId } from './db.js';
+import { getDb, skillId, vecToBlob } from './db.js';
 import { loadConfig } from './config.js';
 import { chunkText } from './chunker.js';
 import { buildAnnIndex } from './ann.js';
@@ -54,7 +54,7 @@ async function indexBatch(db, skills) {
     }
     for (let i = 0; i < allChunks.length; i++) {
       const { id, chunkIndex, text } = allChunks[i];
-      upsertChunk.run(id, chunkIndex, text, JSON.stringify(embeddings[i]));
+      upsertChunk.run(id, chunkIndex, text, vecToBlob(embeddings[i]));
     }
   })();
 
@@ -161,9 +161,9 @@ export async function indexAll() {
         const eta = count > 0 ? Math.round((total - count) * (Date.now() - start) / count / 1000) : '?';
         progress(count, total, { skipped, eta, errors });
       }
-    } catch {
+    } catch (e) {
       errors++;
-      // Remove stale record if the file was previously indexed but now fails to parse
+      console.error(`[PromptGraph] Error indexing ${file}: ${e.message}`);
       try {
         const stale = db.prepare('SELECT id FROM skills WHERE path = ?').get(file);
         if (stale) {
@@ -181,9 +181,6 @@ export async function indexAll() {
     count += batch.length;
   }
 
-  // rebuild all edges for unchanged skills too (fixes edge loss bug)
-  rebuildEdgesForUnchanged(db);
-
   progress(total, total, { skipped, errors });
   progressDone();
   const spin = spinner('Building ANN index...');
@@ -195,13 +192,6 @@ export async function indexAll() {
   info(chalk.gray(`Time: ${elapsed}s`));
 }
 
-function rebuildEdgesForUnchanged(db) {
-  // For skills that were skipped (hash unchanged), their edges were not touched.
-  // This is correct — we only delete+rebuild edges for skills that were re-indexed.
-  // No action needed here: edges for unchanged skills remain intact.
-  // The global DELETE FROM edges at the start was the bug — it's now removed.
-}
-
 export async function indexFile(filePath, source) {
   const db = getDb();
   const skill = parseSkillFile(filePath, source);