promptgraph-mcp 1.0.3 → 1.2.0

package/README.md

@@ -128,7 +128,8 @@ promptgraph-mcp reindex   # Re-index all skills
 |---|---|---|
 | Skills in context | All 40+ | 1 (router) |
 | Tokens per session | ~20,000–50,000 | ~150 + 1 skill |
-| Scales to | ~50 skills | 5,000+ skills |
+
+> **Note:** Search is currently linear O(N) over all chunks. Works well up to ~1,000 skills. ANN index (HNSW/LanceDB) planned for larger collections.
 
 ## File Structure
 

package/chunker.js

@@ -0,0 +1,17 @@
+const CHUNK_SIZE = 400;
+const CHUNK_OVERLAP = 80;
+
+export function chunkText(text) {
+  const words = text.split(/\s+/);
+  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;
+  }
+
+  return chunks.length > 0 ? chunks : [text];
+}

package/db.js

@@ -1,32 +1,44 @@
-import Database from 'better-sqlite3';
-import path from 'path';
-import os from 'os';
-import fs from 'fs';
-
-const DB_PATH = path.join(os.homedir(), '.claude', '.promptgraph', 'promptgraph.db');
-
-export function getDb() {
-  fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
-  const db = new Database(DB_PATH);
-  db.pragma('journal_mode = WAL');
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS skills (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      name TEXT UNIQUE NOT NULL,
-      description TEXT,
-      path TEXT NOT NULL,
-      source TEXT NOT NULL,
-      content TEXT NOT NULL,
-      embedding TEXT
-    );
-
-    CREATE TABLE IF NOT EXISTS edges (
-      from_skill TEXT NOT NULL,
-      to_skill TEXT NOT NULL,
-      PRIMARY KEY (from_skill, to_skill)
-    );
-  `);
-
-  return db;
-}
+import Database from 'better-sqlite3';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+
+const DB_PATH = path.join(os.homedir(), '.claude', '.promptgraph', 'promptgraph.db');
+
+export function getDb() {
+  fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
+  const db = new Database(DB_PATH);
+  db.pragma('journal_mode = WAL');
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS skills (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      description TEXT,
+      path TEXT NOT NULL,
+      source TEXT NOT NULL,
+      content TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS chunks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      skill_id TEXT NOT NULL,
+      chunk_index INTEGER NOT NULL,
+      text TEXT NOT NULL,
+      embedding TEXT NOT NULL,
+      UNIQUE(skill_id, chunk_index)
+    );
+
+    CREATE TABLE IF NOT EXISTS edges (
+      from_skill TEXT NOT NULL,
+      to_skill TEXT NOT NULL,
+      PRIMARY KEY (from_skill, to_skill)
+    );
+  `);
+
+  return db;
+}
+
+export function skillId(source, name) {
+  return `${source}::${name}`;
+}

package/github-import.js

@@ -0,0 +1,49 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { globSync } from 'glob';
+import { indexAll } from './indexer.js';
+import { loadConfig, saveConfig } from './config.js';
+
+const SKILLS_DIR = path.join(os.homedir(), '.claude', 'skills-store');
+
+export async function importFromGitHub(repoUrl) {
+  if (!repoUrl) {
+    console.error('Usage: promptgraph-mcp import <github-url-or-owner/repo>');
+    process.exit(1);
+  }
+
+  const url = repoUrl.startsWith('http') ? repoUrl : `https://github.com/${repoUrl}`;
+  const repoName = url.split('/').slice(-2).join('-').replace('.git', '');
+  const dest = path.join(SKILLS_DIR, 'github', repoName);
+
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+
+  if (fs.existsSync(dest)) {
+    console.log(`Updating ${repoName}...`);
+    execSync(`git -C "${dest}" pull --depth=1`, { stdio: 'inherit' });
+  } else {
+    console.log(`Cloning ${url}...`);
+    execSync(`git clone --depth=1 ${url} "${dest}"`, { stdio: 'inherit' });
+  }
+
+  const mdFiles = globSync(`${dest}/**/*.md`);
+  console.log(`Found ${mdFiles.length} .md files`);
+
+  if (mdFiles.length < 2) {
+    console.warn('Warning: repo has fewer than 2 .md files — may be empty');
+  }
+
+  const config = loadConfig();
+  const githubDir = path.join(SKILLS_DIR, 'github');
+  if (!config.sources.find(s => s.dir === githubDir)) {
+    config.sources.push({ dir: githubDir, source: 'github' });
+    saveConfig(config);
+    console.log('Added github dir to config');
+  }
+
+  console.log('\nReindexing...');
+  await indexAll();
+  console.log(`Done! Imported ${mdFiles.length} files from ${repoName}`);
+}

package/index.js

@@ -6,6 +6,8 @@ import { search, getContext, getCallers, getCallees, getImpact, listAll } from '
 import { indexAll } from './indexer.js';
 import { startWatcher } from './watcher.js';
 import { promptConfig } from './config.js';
+import { importFromGitHub } from './github-import.js';
+import { detectPlatforms, PLATFORMS } from './platform.js';
 
 const args = process.argv.slice(2);
 
@@ -14,10 +16,14 @@ if (args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
 PromptGraph — semantic skill router for Claude Code
 
 Usage:
-  promptgraph-mcp init      First-time setup + index all skills
-  promptgraph-mcp reindex   Re-index all skills
-  promptgraph-mcp           Start MCP server (used by Claude)
-  promptgraph-mcp help      Show this help
+  promptgraph-mcp init                  First-time setup + index all skills
+  promptgraph-mcp reindex               Re-index all skills
+  promptgraph-mcp import <owner/repo>   Import skills from GitHub repo
+  promptgraph-mcp setup <platform>      Register MCP in platform config
+  promptgraph-mcp                       Start MCP server (used by Claude)
+  promptgraph-mcp help                  Show this help
+
+Platforms: claude-code, claude-desktop, cline, codex, cursor, windsurf
 
 GitHub: https://github.com/NeiP4n/promptgraph
 npm:    https://npmjs.com/package/promptgraph-mcp
@@ -25,6 +31,27 @@ npm:    https://npmjs.com/package/promptgraph-mcp
   process.exit(0);
 }
 
+if (args[0] === 'import') {
+  await importFromGitHub(args[1]);
+  process.exit(0);
+}
+
+if (args[0] === 'setup') {
+  const platformId = args[1];
+  if (!platformId) {
+    const detected = detectPlatforms();
+    console.log('Detected platforms:');
+    detected.forEach(p => console.log(`  - ${p.id}: ${p.name}`));
+    console.log('\nUsage: promptgraph-mcp setup <platform-id>');
+  } else {
+    const platform = PLATFORMS[platformId];
+    if (!platform) { console.error(`Unknown platform: ${platformId}`); process.exit(1); }
+    platform.addMcp(platform);
+    console.log(`✓ Registered promptgraph MCP in ${platform.name} (${platform.configPath})`);
+  }
+  process.exit(0);
+}
+
 if (args[0] === 'init') {
   const config = await promptConfig();
   console.log('\nIndexing skills...');

package/indexer.js

@@ -1,65 +1,63 @@
-import { globSync } from 'glob';
-import { parseSkillFile } from './parser.js';
-import { embed } from './embedder.js';
-import { getDb } from './db.js';
-import { loadConfig } from './config.js';
-
-export async function indexAll() {
-  const config = loadConfig();
-  const db = getDb();
-
-  const upsert = db.prepare(`
-    INSERT INTO skills (name, description, path, source, content, embedding)
-    VALUES (@name, @description, @path, @source, @content, @embedding)
-    ON CONFLICT(name) DO UPDATE SET
-      description = excluded.description,
-      path = excluded.path,
-      source = excluded.source,
-      content = excluded.content,
-      embedding = excluded.embedding
-  `);
-  const upsertEdge = db.prepare(`INSERT OR IGNORE INTO edges (from_skill, to_skill) VALUES (?, ?)`);
-  db.prepare('DELETE FROM edges').run();
-
-  let count = 0;
-  for (const { dir, source } of config.sources) {
-    const files = globSync(`${dir}/**/*.md`);
-    for (const file of files) {
-      try {
-        const skill = parseSkillFile(file, source);
-        const embedding = await embed(skill.name + ' ' + skill.description + ' ' + skill.content.slice(0, 500));
-        upsert.run({ ...skill, embedding: JSON.stringify(embedding) });
-        for (const called of skill.calls) {
-          upsertEdge.run(skill.name, called);
-        }
-        count++;
-        process.stdout.write(`\r  Indexed: ${count} skills`);
-      } catch (e) {
-        console.error(`\n  Error indexing ${file}: ${e.message}`);
-      }
-    }
-  }
-  console.log(`\n  Done. ${count} skills indexed.`);
-}
-
-export async function indexFile(filePath, source) {
-  const db = getDb();
-  const skill = parseSkillFile(filePath, source);
-  const embedding = await embed(skill.name + ' ' + skill.description + ' ' + skill.content.slice(0, 500));
-  db.prepare(`
-    INSERT INTO skills (name, description, path, source, content, embedding)
-    VALUES (@name, @description, @path, @source, @content, @embedding)
-    ON CONFLICT(name) DO UPDATE SET
-      description = excluded.description,
-      path = excluded.path,
-      source = excluded.source,
-      content = excluded.content,
-      embedding = excluded.embedding
-  `).run({ ...skill, embedding: JSON.stringify(embedding) });
-
-  db.prepare('DELETE FROM edges WHERE from_skill = ?').run(skill.name);
-  const upsertEdge = db.prepare('INSERT OR IGNORE INTO edges (from_skill, to_skill) VALUES (?, ?)');
-  for (const called of skill.calls) {
-    upsertEdge.run(skill.name, called);
-  }
-}
+import { globSync } from 'glob';
+import { parseSkillFile } from './parser.js';
+import { embed } from './embedder.js';
+import { getDb, skillId } from './db.js';
+import { loadConfig } from './config.js';
+import { chunkText } from './chunker.js';
+
+async function indexSkill(db, skill) {
+  const id = skillId(skill.source, skill.name);
+
+  db.prepare(`
+    INSERT INTO skills (id, name, description, path, source, content)
+    VALUES (@id, @name, @description, @path, @source, @content)
+    ON CONFLICT(id) DO UPDATE SET
+      name = excluded.name,
+      description = excluded.description,
+      path = excluded.path,
+      content = excluded.content
+  `).run({ id, name: skill.name, description: skill.description, path: skill.path, source: skill.source, content: skill.content });
+
+  db.prepare('DELETE FROM chunks WHERE skill_id = ?').run(id);
+
+  const chunks = chunkText(skill.name + ' ' + skill.description + '\n' + skill.content);
+  const upsertChunk = db.prepare(`INSERT OR REPLACE INTO chunks (skill_id, chunk_index, text, embedding) VALUES (?, ?, ?, ?)`);
+  for (let i = 0; i < chunks.length; i++) {
+    const vec = await embed(chunks[i]);
+    upsertChunk.run(id, i, chunks[i], JSON.stringify(vec));
+  }
+
+  db.prepare('DELETE FROM edges WHERE from_skill = ?').run(id);
+  const upsertEdge = db.prepare('INSERT OR IGNORE INTO edges (from_skill, to_skill) VALUES (?, ?)');
+  for (const called of skill.calls) {
+    upsertEdge.run(id, called);
+  }
+}
+
+export async function indexAll() {
+  const config = loadConfig();
+  const db = getDb();
+  db.prepare('DELETE FROM edges').run();
+
+  let count = 0;
+  for (const { dir, source } of config.sources) {
+    const files = globSync(`${dir}/**/*.md`);
+    for (const file of files) {
+      try {
+        const skill = parseSkillFile(file, source);
+        await indexSkill(db, skill);
+        count++;
+        process.stdout.write(`\r  Indexed: ${count} skills`);
+      } catch (e) {
+        console.error(`\n  Error indexing ${file}: ${e.message}`);
+      }
+    }
+  }
+  console.log(`\n  Done. ${count} skills indexed.`);
+}
+
+export async function indexFile(filePath, source) {
+  const db = getDb();
+  const skill = parseSkillFile(filePath, source);
+  await indexSkill(db, skill);
+}

package/package.json

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

package/parser.js

@@ -1,47 +1,36 @@
-import fs from 'fs';
-import path from 'path';
-
-const SKILL_REF_RE = /\/([a-z0-9][a-z0-9-]+)/g;
-const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---/;
-
-export function parseSkillFile(filePath, source) {
-  const raw = fs.readFileSync(filePath, 'utf8');
-
-  let name = null;
-  let description = null;
-  let content = raw;
-
-  const fm = raw.match(FRONTMATTER_RE);
-  if (fm) {
-    try {
-      const nameMatch = fm[1].match(/^name:\s*(.+)$/m);
-      const descMatch = fm[1].match(/^description:\s*(.+)$/m);
-      if (nameMatch) name = nameMatch[1].trim().replace(/^["']|["']$/g, '');
-      if (descMatch) description = descMatch[1].trim().replace(/^["']|["']$/g, '');
-    } catch {}
-  }
-
-  name = name || path.basename(filePath, '.md');
-  description = description || extractFirstParagraph(raw);
-
-  const calls = new Set();
-  for (const match of raw.matchAll(SKILL_REF_RE)) {
-    const ref = match[1];
-    if (ref !== name && ref.length > 2) calls.add(ref);
-  }
-
-  return {
-    name,
-    description,
-    path: filePath,
-    source,
-    content: raw,
-    calls: [...calls],
-  };
-}
-
-function extractFirstParagraph(content) {
-  const lines = content.replace(FRONTMATTER_RE, '').split('\n')
-    .filter(l => l.trim() && !l.startsWith('#') && !l.startsWith('---'));
-  return lines[0]?.trim().slice(0, 200) || '';
-}
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+
+const SKILL_REF_RE = /\/([a-z0-9][a-z0-9-]+)/g;
+
+export function parseSkillFile(filePath, source) {
+  const raw = fs.readFileSync(filePath, 'utf8');
+
+  let name, description, content;
+
+  try {
+    const { data, content: body } = matter(raw);
+    name = data.name;
+    description = data.description;
+    content = body;
+  } catch {
+    content = raw;
+  }
+
+  name = (name && String(name).trim()) || path.basename(filePath, '.md');
+  description = (description && String(description).trim()) || extractFirstParagraph(content || raw);
+
+  const calls = new Set();
+  for (const match of raw.matchAll(SKILL_REF_RE)) {
+    const ref = match[1];
+    if (ref !== name && ref.length > 2) calls.add(ref);
+  }
+
+  return { name, description, path: filePath, source, content: raw, calls: [...calls] };
+}
+
+function extractFirstParagraph(content) {
+  const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#') && !l.startsWith('---'));
+  return lines[0]?.trim().slice(0, 200) || '';
+}

package/platform.js

@@ -0,0 +1,98 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+
+const HOME = os.homedir();
+
+export const PLATFORMS = {
+  'claude-code': {
+    name: 'Claude Code',
+    configPath: path.join(HOME, '.claude', 'settings.json'),
+    addMcp: (config, serverPath) => {
+      const json = readJson(config.configPath);
+      json.mcpServers = json.mcpServers || {};
+      json.mcpServers.promptgraph = { command: 'npx', args: ['promptgraph-mcp'] };
+      writeJson(config.configPath, json);
+    },
+  },
+  'claude-desktop': {
+    name: 'Claude Desktop',
+    configPath: getClaudeDesktopConfig(),
+    addMcp: (config, serverPath) => {
+      const json = readJson(config.configPath);
+      json.mcpServers = json.mcpServers || {};
+      json.mcpServers.promptgraph = { command: 'npx', args: ['promptgraph-mcp'] };
+      writeJson(config.configPath, json);
+    },
+  },
+  'cline': {
+    name: 'Cline (VS Code)',
+    configPath: path.join(HOME, '.vscode', 'mcp.json'),
+    addMcp: (config, serverPath) => {
+      const json = readJson(config.configPath) || { servers: {} };
+      json.servers = json.servers || {};
+      json.servers.promptgraph = { command: 'npx', args: ['promptgraph-mcp'] };
+      fs.mkdirSync(path.dirname(config.configPath), { recursive: true });
+      writeJson(config.configPath, json);
+    },
+  },
+  'codex': {
+    name: 'OpenAI Codex CLI',
+    configPath: path.join(HOME, '.codex', 'config.json'),
+    addMcp: (config, serverPath) => {
+      const json = readJson(config.configPath) || {};
+      json.mcpServers = json.mcpServers || {};
+      json.mcpServers.promptgraph = { command: 'npx', args: ['promptgraph-mcp'] };
+      fs.mkdirSync(path.dirname(config.configPath), { recursive: true });
+      writeJson(config.configPath, json);
+    },
+  },
+  'cursor': {
+    name: 'Cursor',
+    configPath: path.join(HOME, '.cursor', 'mcp.json'),
+    addMcp: (config, serverPath) => {
+      const json = readJson(config.configPath) || { mcpServers: {} };
+      json.mcpServers.promptgraph = { command: 'npx', args: ['promptgraph-mcp'] };
+      fs.mkdirSync(path.dirname(config.configPath), { recursive: true });
+      writeJson(config.configPath, json);
+    },
+  },
+  'windsurf': {
+    name: 'Windsurf',
+    configPath: path.join(HOME, '.codeium', 'windsurf', 'mcp_config.json'),
+    addMcp: (config, serverPath) => {
+      const json = readJson(config.configPath) || { mcpServers: {} };
+      json.mcpServers.promptgraph = { command: 'npx', args: ['promptgraph-mcp'] };
+      fs.mkdirSync(path.dirname(config.configPath), { recursive: true });
+      writeJson(config.configPath, json);
+    },
+  },
+};
+
+export function detectPlatforms() {
+  return Object.entries(PLATFORMS)
+    .filter(([, p]) => p.configPath && fs.existsSync(path.dirname(p.configPath)))
+    .map(([id, p]) => ({ id, ...p }));
+}
+
+function getClaudeDesktopConfig() {
+  if (process.platform === 'win32') {
+    const base = process.env.LOCALAPPDATA || '';
+    const packages = path.join(base, 'Packages');
+    if (fs.existsSync(packages)) {
+      const claudeDir = fs.readdirSync(packages).find(d => d.startsWith('Claude_'));
+      if (claudeDir) return path.join(packages, claudeDir, 'LocalCache', 'Roaming', 'Claude', 'claude_desktop_config.json');
+    }
+  }
+  if (process.platform === 'darwin') return path.join(HOME, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  return path.join(HOME, '.config', 'Claude', 'claude_desktop_config.json');
+}
+
+function readJson(filePath) {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return {}; }
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}

package/search.js

@@ -1,58 +1,66 @@
-import { embed, cosineSimilarity } from './embedder.js';
-import { getDb } from './db.js';
-
-export async function search(query, topK = 5) {
-  const db = getDb();
-  const queryVec = await embed(query);
-  const skills = db.prepare('SELECT name, description, path, source, embedding FROM skills').all();
-
-  return skills
-    .map(skill => ({
-      name: skill.name,
-      description: skill.description,
-      path: skill.path,
-      source: skill.source,
-      score: cosineSimilarity(queryVec, JSON.parse(skill.embedding)),
-    }))
-    .sort((a, b) => b.score - a.score)
-    .slice(0, topK);
-}
-
-export function getContext(name) {
-  const db = getDb();
-  const skill = db.prepare('SELECT * FROM skills WHERE name = ?').get(name);
-  if (!skill) return null;
-  const callees = db.prepare('SELECT to_skill FROM edges WHERE from_skill = ?').all(name).map(r => r.to_skill);
-  const callers = db.prepare('SELECT from_skill FROM edges WHERE to_skill = ?').all(name).map(r => r.from_skill);
-  return { ...skill, embedding: undefined, callees, callers };
-}
-
-export function getCallers(name) {
-  const db = getDb();
-  return db.prepare('SELECT from_skill FROM edges WHERE to_skill = ?').all(name).map(r => r.from_skill);
-}
-
-export function getCallees(name) {
-  const db = getDb();
-  return db.prepare('SELECT to_skill FROM edges WHERE from_skill = ?').all(name).map(r => r.to_skill);
-}
-
-export function getImpact(name) {
-  const db = getDb();
-  const visited = new Set();
-  const queue = [name];
-  while (queue.length) {
-    const cur = queue.shift();
-    if (visited.has(cur)) continue;
-    visited.add(cur);
-    const callers = db.prepare('SELECT from_skill FROM edges WHERE to_skill = ?').all(cur).map(r => r.from_skill);
-    queue.push(...callers);
-  }
-  visited.delete(name);
-  return [...visited];
-}
-
-export function listAll() {
-  const db = getDb();
-  return db.prepare('SELECT name, description, source FROM skills ORDER BY name').all();
-}
+import { embed, cosineSimilarity } from './embedder.js';
+import { getDb } from './db.js';
+
+export async function search(query, topK = 5) {
+  const db = getDb();
+  const queryVec = await embed(query);
+
+  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, topK)
+    .map(([id]) => id);
+
+  return topIds.map(id => {
+    const skill = db.prepare('SELECT id, name, description, path, source FROM skills WHERE id = ?').get(id);
+    return { ...skill, score: bestBySkill.get(id) };
+  });
+}
+
+export function getContext(id) {
+  const db = getDb();
+  const skill = db.prepare('SELECT * FROM skills WHERE id = ?').get(id)
+    || db.prepare("SELECT * FROM skills WHERE name = ? ORDER BY id LIMIT 1").get(id);
+  if (!skill) return null;
+  const callees = db.prepare('SELECT to_skill FROM edges WHERE from_skill = ?').all(skill.id).map(r => r.to_skill);
+  const callers = db.prepare('SELECT from_skill FROM edges WHERE to_skill = ?').all(skill.id).map(r => r.from_skill);
+  return { ...skill, callees, callers };
+}
+
+export function getCallers(id) {
+  const db = getDb();
+  return db.prepare('SELECT from_skill FROM edges WHERE to_skill = ?').all(id).map(r => r.from_skill);
+}
+
+export function getCallees(id) {
+  const db = getDb();
+  return db.prepare('SELECT to_skill FROM edges WHERE from_skill = ?').all(id).map(r => r.to_skill);
+}
+
+export function getImpact(id) {
+  const db = getDb();
+  const visited = new Set();
+  const queue = [id];
+  while (queue.length) {
+    const cur = queue.shift();
+    if (visited.has(cur)) continue;
+    visited.add(cur);
+    const callers = db.prepare('SELECT from_skill FROM edges WHERE to_skill = ?').all(cur).map(r => r.from_skill);
+    queue.push(...callers);
+  }
+  visited.delete(id);
+  return [...visited];
+}
+
+export function listAll() {
+  const db = getDb();
+  return db.prepare('SELECT id, name, description, source FROM skills ORDER BY source, name').all();
+}