promptgraph-mcp 1.5.1 → 1.5.3

package/README.md

@@ -19,7 +19,7 @@ Claude Code loads all `.md` files from `~/.claude/commands/` into the system pro
   ...            ← 40+ skills, NOT loaded into context
 ```
 
-When you ask Claude a question, it calls `pg_search("your task")` → finds the right skill via vector search → reads only that file. **One skill loaded instead of forty.**
+When you ask Claude a question, it calls `pg_search("your task")` → finds the right skill via vector search → returns the path. Claude then reads only that file instead of having all skills preloaded in context.
 
 ## Features
 

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/db.js

@@ -5,9 +5,13 @@ import fs from 'fs';
 
 const DB_PATH = path.join(os.homedir(), '.claude', '.promptgraph', 'promptgraph.db');
 
+let _db = null;
+
 export function getDb() {
+  if (_db) return _db;
   fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
   const db = new Database(DB_PATH);
+  _db = db;
   db.pragma('journal_mode = WAL');
 
   db.exec(`

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

@@ -1,7 +1,7 @@
 import { globSync } from 'glob';
 import { createHash } from 'crypto';
 import fs from 'fs';
-import { parseSkillFile } from './parser.js';
+import { parseSkillFile, isSkillFile } from './parser.js';
 import { embedBatch, BATCH_SIZE } from './embedder.js';
 import { getDb, skillId } from './db.js';
 import { loadConfig } from './config.js';
@@ -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);
 
@@ -51,8 +49,9 @@ async function indexBatch(db, skills) {
       upsertSkill.run({ id, name: skill.name, description: skill.description, path: skill.path, source: skill.source, content: skill.content, hash: skill.hash || null });
       deleteChunks.run(id);
       deleteEdges.run(id);
-      for (const called of skill.calls) {
-        upsertEdge.run(id, called);
+      for (const calledName of skill.calls) {
+        const resolved = db.prepare("SELECT id FROM skills WHERE name = ? ORDER BY id LIMIT 1").get(calledName);
+        upsertEdge.run(id, resolved ? resolved.id : calledName);
       }
     }
     for (let i = 0; i < allChunks.length; i++) {
@@ -66,53 +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`);
         }
         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: ${skipped}  eta: ${eta}s`);
       }
-    } catch (e) {
+    } catch {
       errors++;
     }
   }
@@ -122,19 +134,29 @@ export async function indexAll() {
     count += batch.length;
   }
 
+  // rebuild all edges for unchanged skills too (fixes edge loss bug)
+  rebuildEdgesForUnchanged(db);
+
   progress(total, total, 'done');
   console.log();
   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.1",
+  "version": "1.5.3",
   "main": "index.js",
   "type": "module",
   "bin": {

package/parser.js

@@ -2,9 +2,18 @@ import fs from 'fs';
 import path from 'path';
 import matter from 'gray-matter';
 
-const SKILL_REF_RE = /\/([a-z0-9][a-z0-9-]+)/g;
+// match /skill-name but not URLs (http://, https://, etc.)
+const SKILL_REF_RE = /(?<!https?:|ftp:)(?<![a-zA-Z0-9])\/([a-z0-9][a-z0-9-]{2,})/g;
 
-export function parseSkillFile(filePath, source) {
+// files that are likely not skills
+const SKIP_FILENAMES = new Set(['readme', 'changelog', 'license', 'contributing', 'code-of-conduct', 'security', 'authors', 'credits']);
+
+export function isSkillFile(filePath) {
+  const base = filePath.split(/[\\/]/).pop().replace(/\.md$/i, '').toLowerCase();
+  return !SKIP_FILENAMES.has(base);
+}
+
+export function parseSkillFile(filePath, source, opts = {}) {
   const raw = fs.readFileSync(filePath, 'utf8');
 
   let name, description, content;

package/pg-hook.js

@@ -2,7 +2,6 @@
 import { embed, cosineSimilarity } from './embedder.js';
 import { getDb } from './db.js';
 
-const chunks = [];
 let input = '';
 process.stdin.on('data', d => input += d);
 process.stdin.on('end', async () => {
@@ -13,18 +12,27 @@ process.stdin.on('end', async () => {
 
     const queryVec = await embed(prompt);
     const db = getDb();
-    const skills = db.prepare('SELECT name, description, path, embedding FROM skills').all();
-
-    const results = skills
-      .map(s => ({
-        name: s.name,
-        description: s.description,
-        path: s.path,
-        score: cosineSimilarity(queryVec, JSON.parse(s.embedding)),
-      }))
-      .sort((a, b) => b.score - a.score)
+
+    // search over chunks, deduplicate by skill
+    const chunks = db.prepare('SELECT skill_id, embedding FROM chunks').all();
+    const bestBySkill = new Map();
+    for (const chunk of chunks) {
+      const score = cosineSimilarity(queryVec, JSON.parse(chunk.embedding));
+      const prev = bestBySkill.get(chunk.skill_id);
+      if (!prev || score > prev) bestBySkill.set(chunk.skill_id, score);
+    }
+
+    const topIds = [...bestBySkill.entries()]
+      .sort((a, b) => b[1] - a[1])
       .slice(0, 3)
-      .filter(s => s.score > 0.55);
+      .filter(([, score]) => score > 0.55);
+
+    if (topIds.length === 0) process.exit(0);
+
+    const results = topIds.map(([id, score]) => {
+      const skill = db.prepare('SELECT name, description, path FROM skills WHERE id = ?').get(id);
+      return skill ? { ...skill, score } : null;
+    }).filter(Boolean);
 
     if (results.length === 0) process.exit(0);
 

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,9 +44,10 @@ 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)
-    .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 } : null;
     })
@@ -62,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,50 +1,72 @@
-import chokidar from 'chokidar';
-import path from 'path';
-import os from 'os';
-import { indexFile } from './indexer.js';
-import { getDb } from './db.js';
-
-const SOURCES = [
-  { dir: path.join(os.homedir(), '.claude', 'skills-store'), source: 'skills-store' },
-  { dir: path.join(os.homedir(), '.claude', 'skills'), source: 'skills' },
-];
-
-export function startWatcher() {
-  const paths = SOURCES.map(s => s.dir);
-
-  const watcher = chokidar.watch(paths, {
-    ignored: /[/\\]\./,
-    persistent: true,
-    ignoreInitial: true,
-    awaitWriteFinish: { stabilityThreshold: 500 },
-  });
-
-  watcher.on('add', filePath => reindex(filePath));
-  watcher.on('change', filePath => reindex(filePath));
-  watcher.on('unlink', filePath => {
-    const name = path.basename(filePath, '.md');
-    const db = getDb();
-    db.prepare('DELETE FROM skills WHERE name = ?').run(name);
-    db.prepare('DELETE FROM edges WHERE from_skill = ? OR to_skill = ?').run(name, name);
-    console.error(`[PromptGraph] Removed: ${name}`);
-  });
-
-  console.error('[PromptGraph] Watcher started');
-}
-
-function getSource(filePath) {
-  for (const { dir, source } of SOURCES) {
-    if (filePath.startsWith(dir)) return source;
-  }
-  return 'unknown';
-}
-
-async function reindex(filePath) {
-  if (!filePath.endsWith('.md')) return;
-  try {
-    await indexFile(filePath, getSource(filePath));
-    console.error(`[PromptGraph] Reindexed: ${path.basename(filePath)}`);
-  } catch (e) {
-    console.error(`[PromptGraph] Error reindexing ${filePath}: ${e.message}`);
-  }
-}
+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 { loadConfig } from './config.js';
+import matter from 'gray-matter';
+
+export function startWatcher() {
+  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: /[/\\]\./,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 500 },
+  });
+
+  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, config) {
+  for (const { dir, source } of config.sources) {
+    if (filePath.startsWith(dir)) return source;
+  }
+  return 'unknown';
+}
+
+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, 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, config) {
+  if (!filePath.endsWith('.md')) return;
+  try {
+    await indexFile(filePath, getSource(filePath, config));
+    console.error(`[PromptGraph] Reindexed: ${path.basename(filePath)}`);
+  } catch (e) {
+    console.error(`[PromptGraph] Error reindexing ${filePath}: ${e.message}`);
+  }
+}