promptgraph-mcp 1.5.2 → 1.5.4

package/cli.js

@@ -25,61 +25,76 @@ export function banner() {
     boxen(
       colors.primary.bold('PromptGraph') + '  ' + colors.muted('v' + getVersion()) + '\n' +
       colors.muted('Semantic skill router for Claude Code'),
-      {
-        padding: { top: 0, bottom: 0, left: 2, right: 2 },
-        borderStyle: 'round',
-        borderColor: '#7C3AED',
-        dimBorder: true,
-      }
+      { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: '#7C3AED', dimBorder: true }
     )
   );
 }
 
 export function spinner(text) {
-  return ora({
-    text: colors.muted(text),
-    spinner: 'dots',
-    color: 'magenta',
-  });
+  return ora({ text: colors.muted(text), spinner: 'dots', color: 'magenta' });
 }
 
 export function success(msg) {
-  console.log(colors.success('✓') + ' ' + msg);
+  console.log('\n' + colors.success('✓') + '  ' + msg);
 }
 
 export function error(msg) {
-  console.log(colors.error('✗') + ' ' + msg);
+  console.log(colors.error('✗') + '  ' + msg);
 }
 
 export function info(msg) {
-  console.log(colors.muted('·') + ' ' + msg);
+  console.log(colors.muted('  ' + msg));
 }
 
 export function section(title) {
   console.log('\n' + colors.primary.bold(title));
 }
 
-export function progress(current, total, extra = '') {
+let _progressActive = false;
+
+export function progress(current, total, { skipped = 0, eta = '?', errors = 0 } = {}) {
   const pct = Math.round(current / total * 100);
   const bar = buildBar(pct);
-  process.stdout.write(
-    `\r  ${bar} ${colors.white.bold(pct + '%')} ${colors.muted(current + '/' + total)} ${colors.muted(extra)}  `
-  );
+
+  const stats = [
+    colors.white.bold(String(pct).padStart(3) + '%'),
+    colors.muted(current + '/' + total),
+    skipped > 0 ? colors.muted('skip ' + skipped) : '',
+    errors > 0 ? colors.error('err ' + errors) : '',
+    eta !== '?' ? colors.muted('eta ' + formatTime(eta)) : '',
+  ].filter(Boolean).join('  ');
+
+  process.stdout.write('\r  ' + bar + '  ' + stats + '   ');
+  _progressActive = true;
+}
+
+export function progressDone() {
+  if (_progressActive) {
+    process.stdout.write('\n');
+    _progressActive = false;
+  }
 }
 
 function buildBar(pct) {
-  const width = 20;
+  const width = 24;
   const filled = Math.round(pct / 100 * width);
   const empty = width - filled;
   return colors.primary('█'.repeat(filled)) + colors.muted('░'.repeat(empty));
 }
 
+function formatTime(seconds) {
+  if (seconds < 60) return seconds + 's';
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  return m + 'm ' + s + 's';
+}
+
 export function table(rows) {
   if (!rows.length) { info('No results'); return; }
   const cols = Object.keys(rows[0]);
   const widths = cols.map(c => Math.max(c.length, ...rows.map(r => String(r[c] ?? '').length)));
   const header = cols.map((c, i) => colors.muted(c.toUpperCase().padEnd(widths[i]))).join('  ');
-  const divider = colors.muted(widths.map(w => '─'.repeat(w)).join('  '));
+  const divider = colors.muted(widths.map(w => '─'.repeat(w)).join('──'));
   console.log('\n' + header);
   console.log(divider);
   for (const row of rows) {

package/config.js

@@ -17,7 +17,8 @@ export function loadConfig() {
   if (fs.existsSync(CONFIG_PATH)) {
     return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
   }
-  return DEFAULTS;
+  // deep copy to avoid mutating DEFAULTS
+  return JSON.parse(JSON.stringify(DEFAULTS));
 }
 
 export function saveConfig(config) {

package/github-import.js

@@ -22,10 +22,13 @@ export async function importFromGitHub(repoUrl) {
 
   if (fs.existsSync(dest)) {
     console.log(`Updating ${repoName}...`);
-    execSync(`git -C "${dest}" pull --depth=1`, { stdio: 'inherit' });
+    execSync('git', { stdio: 'inherit', args: ['-C', dest, 'pull', '--depth=1'] });
   } else {
     console.log(`Cloning ${url}...`);
-    execSync(`git clone --depth=1 ${url} "${dest}"`, { stdio: 'inherit' });
+    // use spawnSync to avoid shell injection
+    const { spawnSync } = await import('child_process');
+    const result = spawnSync('git', ['clone', '--depth=1', url, dest], { stdio: 'inherit' });
+    if (result.status !== 0) throw new Error(`git clone failed for ${url}`);
   }
 
   const mdFiles = globSync(`${dest}/**/*.md`);

package/indexer.js

@@ -7,7 +7,7 @@ import { getDb, skillId } from './db.js';
 import { loadConfig } from './config.js';
 import { chunkText } from './chunker.js';
 import { buildAnnIndex } from './ann.js';
-import { progress, success, info, spinner } from './cli.js';
+import { progress, progressDone, success, info, spinner } from './cli.js';
 import chalk from 'chalk';
 
 function fileHash(filePath) {
@@ -31,7 +31,6 @@ async function indexBatch(db, skills) {
   const upsertChunk = db.prepare('INSERT OR REPLACE INTO chunks (skill_id, chunk_index, text, embedding) VALUES (?, ?, ?, ?)');
   const upsertEdge = db.prepare('INSERT OR IGNORE INTO edges (from_skill, to_skill) VALUES (?, ?)');
 
-  // collect all chunks across skills in batch
   const allChunks = [];
   for (const skill of skills) {
     const id = skillId(skill.source, skill.name);
@@ -41,7 +40,6 @@ async function indexBatch(db, skills) {
     }
   }
 
-  // embed all chunks in one batch call
   const texts = allChunks.map(c => c.text);
   const embeddings = await embedBatch(texts);
 
@@ -52,7 +50,6 @@ async function indexBatch(db, skills) {
       deleteChunks.run(id);
       deleteEdges.run(id);
       for (const calledName of skill.calls) {
-        // try to resolve to a real skill id, fallback to bare name
         const resolved = db.prepare("SELECT id FROM skills WHERE name = ? ORDER BY id LIMIT 1").get(calledName);
         upsertEdge.run(id, resolved ? resolved.id : calledName);
       }
@@ -68,54 +65,66 @@ async function indexBatch(db, skills) {
 export async function indexAll() {
   const config = loadConfig();
   const db = getDb();
-  db.prepare('DELETE FROM edges').run();
 
-  // pre-count total files
-  let total = 0;
+  // collect all files on disk
   const allFiles = [];
   for (const { dir, source } of config.sources) {
     const files = globSync(`${dir}/**/*.md`);
     files.forEach(f => allFiles.push({ file: f, source }));
-    total += files.length;
   }
+  const total = allFiles.length;
   info(`Found ${chalk.white.bold(total)} files`);
 
+  // reconcile: remove skills whose files no longer exist
+  const allIds = db.prepare('SELECT id, path FROM skills').all();
+  const existingPaths = new Set(allFiles.map(f => f.file));
+  let removed = 0;
+  for (const row of allIds) {
+    if (!existingPaths.has(row.path)) {
+      db.prepare('DELETE FROM skills WHERE id = ?').run(row.id);
+      db.prepare('DELETE FROM chunks WHERE skill_id = ?').run(row.id);
+      db.prepare('DELETE FROM edges WHERE from_skill = ? OR to_skill = ?').run(row.id, row.id);
+      db.prepare('DELETE FROM ratings WHERE skill_id = ?').run(row.id);
+      removed++;
+    }
+  }
+  if (removed > 0) info(`Removed ${chalk.yellow(removed)} deleted skills`);
+
   let count = 0;
   let errors = 0;
+  let skipped = 0;
   let batch = [];
   const start = Date.now();
-
   const getHash = db.prepare('SELECT hash FROM skills WHERE id = ?');
 
-  let skipped = 0;
   for (const { file, source } of allFiles) {
     try {
       if (!isSkillFile(file)) { skipped++; count++; continue; }
       const hash = fileHash(file);
       const parsed = parseSkillFile(file, source);
       const id = skillId(source, parsed.name);
+
       const existing = getHash.get(id);
       if (existing?.hash === hash) {
         skipped++;
         count++;
-        if (count % 50 === 0) {
+        if (count % 100 === 0) {
           const eta = count > 0 ? Math.round((total - count) * (Date.now() - start) / count / 1000) : '?';
-          progress(count, total, `skipped: ${skipped}  eta: ${eta}s`);
+          progress(count, total, { skipped, eta, errors });
         }
         continue;
       }
-      const skill = { ...parsed, hash };
-      batch.push(skill);
+
+      batch.push({ ...parsed, hash });
+
       if (batch.length >= BATCH_SIZE) {
         await indexBatch(db, batch);
         count += batch.length;
         batch = [];
-        const pct = Math.round(count / total * 100);
-        const elapsed = ((Date.now() - start) / 1000).toFixed(0);
         const eta = count > 0 ? Math.round((total - count) * (Date.now() - start) / count / 1000) : '?';
-        process.stdout.write(`\r  [${pct}%] ${count}/${total} skills | ${elapsed}s elapsed | ETA: ${eta}s | errors: ${errors}  `);
+        progress(count, total, { skipped, eta, errors });
       }
-    } catch (e) {
+    } catch {
       errors++;
     }
   }
@@ -125,19 +134,29 @@ export async function indexAll() {
     count += batch.length;
   }
 
-  progress(total, total, 'done');
-  console.log();
+  // 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...');
   spin.start();
   await buildAnnIndex();
   spin.stop();
-  success(`Indexed ${chalk.white.bold(count)} skills  ${chalk.gray(`(${errors} errors, ${skipped} skipped)`)}`);
+  success(`Indexed ${chalk.white.bold(count)} skills  ${chalk.gray(`(${errors} errors, ${skipped} skipped, ${removed} removed)`)}`);
   const elapsed = ((Date.now() - start) / 1000).toFixed(1);
   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);
-  await indexBatch(db, [skill]);
+  await indexBatch(db, [{ ...skill, hash: fileHash(filePath) }]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptgraph-mcp",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "main": "index.js",
   "type": "module",
   "bin": {

package/search.js

@@ -25,11 +25,12 @@ export async function search(query, topK = 5) {
       if (!prev || r.score > prev) bestBySkill.set(r.skill_id, r.score);
     }
     return [...bestBySkill.entries()]
-      .sort((a, b) => b[1] - a[1])
+      .map(([id, score]) => ({ id, score: applyRatingBoost(db, id, score) }))
+      .sort((a, b) => b.score - a.score)
       .slice(0, topK)
-      .map(([id, score]) => {
+      .map(({ id, score }) => {
         const skill = db.prepare('SELECT id, name, description, path, source FROM skills WHERE id = ?').get(id);
-        return skill ? { ...skill, score: applyRatingBoost(db, id, score) } : null;
+        return skill ? { ...skill, score } : null;
       })
       .filter(Boolean);
   }
@@ -43,12 +44,12 @@ export async function search(query, topK = 5) {
     if (!prev || score > prev) bestBySkill.set(chunk.skill_id, score);
   }
   return [...bestBySkill.entries()]
-    .sort((a, b) => b[1] - a[1])
+    .map(([id, score]) => ({ id, score: applyRatingBoost(db, id, score) }))
+    .sort((a, b) => b.score - a.score)
     .slice(0, topK)
-    // apply same rating boost as ANN path
-    .map(([id, score]) => {
+    .map(({ id, score }) => {
       const skill = db.prepare('SELECT id, name, description, path, source FROM skills WHERE id = ?').get(id);
-      return skill ? { ...skill, score: applyRatingBoost(db, id, score) } : null;
+      return skill ? { ...skill, score } : null;
     })
     .filter(Boolean);
 }
@@ -63,18 +64,29 @@ export function getContext(id) {
   return { ...skill, callees, callers };
 }
 
-export function getCallers(id) {
+function resolveId(db, nameOrId) {
+  // try exact id match first, then name match
+  const byId = db.prepare('SELECT id FROM skills WHERE id = ?').get(nameOrId);
+  if (byId) return byId.id;
+  const byName = db.prepare('SELECT id FROM skills WHERE name = ? ORDER BY id LIMIT 1').get(nameOrId);
+  return byName ? byName.id : nameOrId;
+}
+
+export function getCallers(nameOrId) {
   const db = getDb();
+  const id = resolveId(db, nameOrId);
   return db.prepare('SELECT from_skill FROM edges WHERE to_skill = ?').all(id).map(r => r.from_skill);
 }
 
-export function getCallees(id) {
+export function getCallees(nameOrId) {
   const db = getDb();
+  const id = resolveId(db, nameOrId);
   return db.prepare('SELECT to_skill FROM edges WHERE from_skill = ?').all(id).map(r => r.to_skill);
 }
 
-export function getImpact(id) {
+export function getImpact(nameOrId) {
   const db = getDb();
+  const id = resolveId(db, nameOrId);
   const visited = new Set();
   const queue = [id];
   while (queue.length) {

package/watcher.js

@@ -1,17 +1,17 @@
 import chokidar from 'chokidar';
 import path from 'path';
 import os from 'os';
+import fs from 'fs';
 import { indexFile } from './indexer.js';
 import { getDb, skillId } from './db.js';
-import { parseSkillFile } from './parser.js';
-
-const SOURCES = [
-  { dir: path.join(os.homedir(), '.claude', 'skills-store'), source: 'skills-store' },
-  { dir: path.join(os.homedir(), '.claude', 'skills'), source: 'skills' },
-];
+import { loadConfig } from './config.js';
+import matter from 'gray-matter';
 
 export function startWatcher() {
-  const paths = SOURCES.map(s => s.dir);
+  const config = loadConfig();
+  const paths = config.sources.map(s => s.dir).filter(d => fs.existsSync(d));
+
+  if (paths.length === 0) return;
 
   const watcher = chokidar.watch(paths, {
     ignored: /[/\\]\./,
@@ -20,40 +20,51 @@ export function startWatcher() {
     awaitWriteFinish: { stabilityThreshold: 500 },
   });
 
-  watcher.on('add', filePath => reindex(filePath));
-  watcher.on('change', filePath => reindex(filePath));
-  watcher.on('unlink', filePath => remove(filePath));
+  watcher.on('add', filePath => reindex(filePath, config));
+  watcher.on('change', filePath => reindex(filePath, config));
+  watcher.on('unlink', filePath => remove(filePath, config));
 
   console.error('[PromptGraph] Watcher started');
 }
 
-function getSource(filePath) {
-  for (const { dir, source } of SOURCES) {
+function getSource(filePath, config) {
+  for (const { dir, source } of config.sources) {
     if (filePath.startsWith(dir)) return source;
   }
   return 'unknown';
 }
 
-function remove(filePath) {
+function readName(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const { data } = matter(raw);
+    return (data.name && String(data.name).trim()) || path.basename(filePath, '.md');
+  } catch {
+    return path.basename(filePath, '.md');
+  }
+}
+
+function remove(filePath, config) {
   if (!filePath.endsWith('.md')) return;
   try {
-    const source = getSource(filePath);
-    const name = path.basename(filePath, '.md');
+    const source = getSource(filePath, config);
+    const name = readName(filePath);
     const id = skillId(source, name);
     const db = getDb();
     db.prepare('DELETE FROM skills WHERE id = ?').run(id);
     db.prepare('DELETE FROM chunks WHERE skill_id = ?').run(id);
     db.prepare('DELETE FROM edges WHERE from_skill = ? OR to_skill = ?').run(id, id);
+    db.prepare('DELETE FROM ratings WHERE skill_id = ?').run(id);
     console.error(`[PromptGraph] Removed: ${id}`);
   } catch (e) {
     console.error(`[PromptGraph] Error removing ${filePath}: ${e.message}`);
   }
 }
 
-async function reindex(filePath) {
+async function reindex(filePath, config) {
   if (!filePath.endsWith('.md')) return;
   try {
-    await indexFile(filePath, getSource(filePath));
+    await indexFile(filePath, getSource(filePath, config));
     console.error(`[PromptGraph] Reindexed: ${path.basename(filePath)}`);
   } catch (e) {
     console.error(`[PromptGraph] Error reindexing ${filePath}: ${e.message}`);