promptgraph-mcp 2.5.0 → 2.6.1

package/README.md

@@ -14,13 +14,17 @@ Instead of loading every `.md` skill into your context, Claude calls `pg_search`
 ```
 pg_search("refactor without breaking tests")
   → embed query (BGE-Small-EN, 384-dim)
-  → flat cosine similarity over in-memory index
-  → return top skill path + snippet
-  → Claude reads only that file
+  → ANN index (HNSW by default, flat fallback) — topK×4 candidates
+  → BM25 (FTS5) — topK×4 candidates
+  → hybrid merge (embedWeight × cosine + bm25Weight × BM25)
+  → term-overlap reranker (TF frequency + header-position boost)
+  → return topK skill paths + snippets
+  → Claude reads only the files it needs
 ```
 
-**Index:** SQLite + Float32 BLOB embeddings, flat cosine search in-memory.
-No external vector DB, no API key, no cloud.
+**Index:** SQLite + Float32 BLOB embeddings + HNSW approximate nearest neighbor (configurable: `PG_VECTOR_STORE=flat` for brute-force cosine). No external vector DB, no API key, no cloud.
+
+**Reranker:** lightweight term-overlap scorer (binary overlap + TF frequency + header-position boost). Not a cross-encoder — disable via `PG_RERANKER=0`.
 
 **File watcher:** `chokidar` detects `.md` changes and reindexes automatically (MCP server mode only).
 
@@ -34,16 +38,27 @@ No external vector DB, no API key, no cloud.
 | 88 skills reindexed (unchanged, hash match) | **< 1 s** |
 | `pg reindex --fast` (3000 files, keyword only) | **~30 s** |
 | `pg reindex` full embed (3000 files) | **~30 min** |
-| Semantic search query | **< 50 ms** |
+| Semantic search query (HNSW) | **< 50 ms** |
+| Semantic search query (flat, brute-force) | **< 200 ms** |
 | Model size (BGE-Small-EN-v1.5, one-time download) | **23 MB** |
 | Embedding dimensions | **384** |
-| Max chunks per skill | **2** |
+| Max chunks per skill | **8** (configurable: `PG_MAX_CHUNKS`) |
 | Embedding batch size | **256** |
 
 > ONNX model initialization (~2–3 min) happens once on first use and is cached in `~/.claude/.promptgraph/model-cache/`.
 
 ---
 
+## Environment Variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `PG_VECTOR_STORE` | `hnsw` | Vector index: `hnsw` (ANN, faster at scale) or `flat` (brute-force cosine) |
+| `PG_RERANKER` | `1` | Enable term-overlap reranker after hybrid search (set `0` to disable) |
+| `PG_MAX_CHUNKS` | `8` | Max semantic chunks per skill (higher = more detail per long file, more embedding cost) |
+
+---
+
 ## Quick Start
 
 ```bash
@@ -154,9 +169,15 @@ Claude uses these automatically when the MCP server is running:
 
 ## Search modes
 
-Search falls back to FTS5 automatically if no embeddings exist. When embeddings are
-available, results are a hybrid of semantic similarity (embedding cosine) and keyword
-relevance (BM25) — giving you the best of both approaches.
+Search runs a multi-stage pipeline:
+
+1. **ANN retrieval** — HNSW approximate nearest neighbor (default) or flat brute-force cosine (`PG_VECTOR_STORE=flat`)
+2. **BM25 keyword** — SQLite FTS5
+3. **Hybrid fusion** — weighted sum (embedding × embedWeight + BM25 × bm25Weight, adaptive per query)
+4. **Reranker** — term-overlap rescoring with TF frequency and header-position boost (disable via `PG_RERANKER=0`)
+5. **Rating boost** — success/fail history adjusts final ranking
+
+Falls back to FTS5 only if no embeddings exist.
 
 ---
 

package/api.js

@@ -39,7 +39,8 @@ export async function index(sourceDir, sourceName) {
     const path = await import('path');
     const { createHash } = await import('crypto');
     const { parseSkillFile, isSkillFile } = await import('./parser.js');
-    const { embedBatch, BATCH_SIZE } = await import('./embedder.js');
+    const { embedBatch } = await import('./embedder.js');
+    const { BATCH_SIZE } = await import('./config.js');
     const { skillId, vecToBlob } = await import('./db.js');
     const { chunkText } = await import('./chunker.js');
 
@@ -105,7 +106,8 @@ export async function update() {
     const path = await import('path');
     const { createHash } = await import('crypto');
     const { parseSkillFile, isSkillFile } = await import('./parser.js');
-    const { embedBatch, BATCH_SIZE } = await import('./embedder.js');
+    const { embedBatch } = await import('./embedder.js');
+    const { BATCH_SIZE } = await import('./config.js');
     const { skillId, vecToBlob } = await import('./db.js');
     const { chunkText } = await import('./chunker.js');
     const { indexBatch } = await import('./indexer.js');

package/bundle-counts.js

@@ -20,12 +20,13 @@ function httpsGet(url) {
   const headers = { 'User-Agent': 'promptgraph-mcp' };
   if (token && url.startsWith('https://api.github.com/')) headers['Authorization'] = `Bearer ${token}`;
   return new Promise((res, rej) => {
-    const req = https.get(url, { headers }, r => {
+    const req = https.get(url, { headers, timeout: 15000 }, r => {
       if (r.statusCode === 403 || r.statusCode === 429) return rej(new Error(`Rate limited`));
       if (r.statusCode !== 200) { r.resume(); return rej(new Error(`HTTP ${r.statusCode}`)); }
-      let d = ''; r.setEncoding('utf8'); r.on('data', c => d += c); r.on('end', () => res(d));
+      const chunks = []; r.setEncoding('utf8'); r.on('data', c => chunks.push(c)); r.on('end', () => res(chunks.join('')));
     });
     req.on('error', rej);
+    req.on('timeout', () => { req.destroy(new Error('timeout')); });
   });
 }
 

package/chunker.js

@@ -1,6 +1,6 @@
 const CHUNK_SIZE = 800;
 const CHUNK_OVERLAP = 100;
-const MAX_CHUNKS = 2;
+const MAX_CHUNKS = parseInt(process.env.PG_MAX_CHUNKS, 10) || 32;
 
 export function chunkText(text) {
   // Split on markdown h1/h2/h3 headers to preserve semantic boundaries

package/commands/bundle.js

@@ -0,0 +1,150 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { spawnSync } from 'child_process';
+
+export default async function handler(args, bin) {
+  if (args[1] === 'update') {
+    const { loadConfig: _lcUpd, SKILLS_STORE_DIR: _ssDir } = await import('../config.js');
+    const { indexSource } = await import('../indexer.js');
+    const cfg = _lcUpd();
+    const githubSources = cfg.sources.filter(s => s.source.startsWith('github:'));
+
+    if (!githubSources.length) { info('No GitHub bundles installed.'); process.exit(0); }
+
+    const targetId = args[2];
+    const toUpdate = targetId
+      ? githubSources.filter(s => s.source.toLowerCase().includes(targetId.toLowerCase()))
+      : githubSources;
+
+    if (!toUpdate.length) { error(`No installed bundle matching "${targetId}"`); process.exit(1); }
+
+    let updated = 0, unchanged = 0, failed = 0;
+
+    for (const src of toUpdate) {
+      const repoName = src.source.replace('github:', '');
+      const dest = src.dir.replace(/[/\\]skills$|[/\\]commands$|[/\\]prompts$/, '');
+      const repoRoot = fs.existsSync(path.join(dest, '.git')) ? dest : src.dir;
+
+      if (!fs.existsSync(path.join(repoRoot, '.git'))) {
+        console.log(chalk.gray(`  skip ${repoName} (not a git repo)`));
+        continue;
+      }
+
+      process.stdout.write(`  Checking ${chalk.white(repoName)}... `);
+
+      const before = spawnSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD'], { encoding: 'utf8', timeout: 30000 }).stdout.trim();
+
+      const fetch = spawnSync('git', ['-C', repoRoot, 'fetch', '--depth=1', 'origin'], { stdio: 'pipe', timeout: 60000 });
+      if (fetch.status !== 0) {
+        console.log(chalk.red('fetch failed'));
+        failed++;
+        continue;
+      }
+      const reset = spawnSync('git', ['-C', repoRoot, 'reset', '--hard', 'origin/HEAD'], { stdio: 'pipe', timeout: 30000 });
+      if (reset.status !== 0) {
+        spawnSync('git', ['-C', repoRoot, 'reset', '--hard', 'origin/main'], { stdio: 'pipe', timeout: 30000 });
+      }
+
+      const after = spawnSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD'], { encoding: 'utf8', timeout: 30000 }).stdout.trim();
+
+      if (before === after) {
+        console.log(chalk.gray('already up to date'));
+        unchanged++;
+        continue;
+      }
+
+      const diff = spawnSync('git', ['-C', repoRoot, 'diff', '--name-only', before, after], { encoding: 'utf8', timeout: 15000 });
+      const changedMd = (diff.stdout || '').split('\n').filter(f => f.endsWith('.md')).length;
+      console.log(chalk.green(`${changedMd} files changed`) + chalk.gray(` (${before.slice(0,7)} → ${after.slice(0,7)})`));
+
+      await indexSource(src.dir, src.source);
+      updated++;
+    }
+
+    console.log();
+    if (updated)   success(`Updated ${updated} bundle(s)`);
+    if (unchanged) info(chalk.gray(`${unchanged} already up to date`));
+    if (failed)    error(`${failed} failed`);
+    process.exit(failed > 0 ? 1 : 0);
+  }
+
+  if (args[1] === 'install') {
+    const { installBundle } = await import('../marketplace.js');
+    const result = await installBundle(args[2]);
+    if (result?.error) { error(result.error); process.exit(1); }
+    success(result.type === 'repo_import' ? `Imported from ${result.repo_url}` : `Installed ${result.installed?.length || 0} skills`);
+    process.exit(0);
+  }
+  if (args[1] === 'add-repo') {
+    const doPush = args[args.length - 1] === '--push';
+    const repoArg = doPush ? args[2] : args[2];
+    if (!repoArg || !repoArg.includes('/')) { error('Usage: pg bundle add-repo <owner/repo> [--push]'); process.exit(1); }
+    const repo = repoArg.replace('https://github.com/', '').replace('.git', '');
+
+    const { detectSkillsDirFromAPI: _detectDir } = await import('../github-import.js');
+    process.stdout.write(chalk.gray(`  Checking ${repo} for skill subdirectory... `));
+    const detected = await _detectDir(repo);
+    if (!detected) {
+      console.log(chalk.red('none found'));
+      error(
+        `Cannot publish: no skill subdirectory found in ${repo}\n` +
+        `  Expected: skills/, prompts/, commands/, agents/, or any folder with .md files\n` +
+        `  Visit: https://github.com/${repo}`
+      );
+      process.exit(1);
+    }
+    console.log(chalk.green(`found: ${detected.label}/`));
+    const name = repo.split('/')[1].replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+    const id = repo.replace('/', '-').toLowerCase();
+    const bundle = {
+      id, name, repo_url: repo, author: repo.split('/')[0],
+      description: `Skills from ${repo}`,
+      tags: ['community'],
+      stars: 0
+    };
+    const json = JSON.stringify(bundle, null, 2);
+
+    if (doPush) {
+      const registryDir = path.join(os.tmpdir(), 'pg-push-registry');
+      const gitEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0' };
+      const git = (gArgs, opts = {}) => { const r = spawnSync('git', gArgs, { ...opts, env: gitEnv, stdio: 'pipe', timeout: 60000 }); if (r.status !== 0) { error(r.stderr?.toString() || r.stdout?.toString() || 'git error'); process.exit(1); } return r; };
+      if (fs.existsSync(registryDir)) {
+        git(['-C', registryDir, 'pull']);
+      } else {
+        git(['clone', '--depth=1', 'https://github.com/NeiP4n/promptgraph-registry.git', registryDir]);
+      }
+      const regFile = path.join(registryDir, 'registry.json');
+      const reg = JSON.parse(fs.readFileSync(regFile, 'utf8'));
+      if (reg.bundles.find(b => b.id === id)) { error(`Bundle "${id}" already exists`); process.exit(1); }
+      reg.bundles.push(bundle);
+      reg.updated = new Date().toISOString().slice(0, 10);
+      fs.writeFileSync(regFile, JSON.stringify(reg, null, 2) + '\n');
+      fs.writeFileSync(path.join(registryDir, 'bundles', `${id}.json`), json + '\n');
+      git(['-C', registryDir, 'config', 'user.email', 'pg-bot@promptgraph.ai']);
+      git(['-C', registryDir, 'config', 'user.name', 'PromptGraph Bot']);
+      git(['-C', registryDir, 'add', '-A']);
+      git(['-C', registryDir, 'commit', '-m', `bundle: ${name} (${repo})`]);
+      git(['-C', registryDir, 'push']);
+      success(`Bundle "${id}" pushed to registry`);
+    } else {
+      const tmp = path.join(os.tmpdir(), `pg-bundle-${id}.json`);
+      fs.writeFileSync(tmp, json);
+      const { publishBundle } = await import('../marketplace.js');
+      const result = await publishBundle(tmp);
+      fs.unlinkSync(tmp);
+      if (result?.error) { error(result.error); process.exit(1); }
+      if (result.gh_not_installed) {
+        console.log('\n' + result.instructions);
+        console.log(chalk.gray('\nBundle JSON:\n') + chalk.white(json));
+      } else {
+        success(`Bundle proposed! Submit: ${result.submit_url}`);
+      }
+    }
+    process.exit(0);
+  }
+  error('Usage: pg bundle install <id>  |  pg bundle add-repo <owner/repo> [--push]');
+  process.exit(1);
+}

package/commands/doctor.js

@@ -0,0 +1,15 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+
+export default async function handler(args, bin) {
+  const { runDoctor } = await import('../doctor.js');
+  const spin = (await import('../cli.js')).spinner('Checking database...');
+  spin.start();
+  const r = runDoctor();
+  spin.stop();
+  success('Database checked');
+  info(`Removed: ${r.orphanChunks} chunks, ${r.orphanRatings} ratings, ${r.orphanFromEdges + r.danglingEdges} edges`);
+  if (r.duplicatePaths > 0) info(chalk.yellow(`Warning: ${r.duplicatePaths} duplicate paths`));
+  info(chalk.gray(`Now: ${r.totalSkills} skills, ${r.totalChunks} chunks, ${r.totalEdges} edges`));
+  process.exit(0);
+}

package/commands/import.js

@@ -0,0 +1,7 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+
+export default async function handler(args, bin) {
+  const { importFromGitHub } = await import('../github-import.js');
+  await importFromGitHub(args[1]);
+  process.exit(0);
+}

package/commands/init.js

@@ -0,0 +1,37 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+import boxen from 'boxen';
+
+export default async function handler(args, bin) {
+  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();
+  console.log(
+    boxen(
+      chalk.white.bold('Add to Claude Code settings.json:') + '\n\n' +
+      chalk.gray(JSON.stringify({ mcpServers: { promptgraph: { command: 'npx', args: ['promptgraph-mcp'] } } }, null, 2)),
+      { padding: 1, borderStyle: 'round', borderColor: '#7C3AED', dimBorder: true }
+    )
+  );
+  process.exit(0);
+}

package/commands/marketplace.js

@@ -0,0 +1,114 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+
+export default async function handler(args, bin) {
+  if (!process.stdout.isTTY) {
+    error('marketplace TUI requires an interactive terminal');
+    process.exit(1);
+  }
+  const { browseMarketplace, browseBundles, installSkill, installBundle } = await import('../marketplace.js');
+  const { loadConfig: _lcMkt } = await import('../config.js');
+  const { getDb: _getDbMkt } = await import('../db.js');
+  const { spinner: spin2 } = await import('../cli.js');
+  const sp = spin2('Fetching marketplace...');
+  sp.start();
+  const [skills, bundles] = await Promise.all([browseMarketplace(1000), browseBundles(1000)]);
+  sp.stop();
+
+  if (skills?.error) { error(skills.error); process.exit(1); }
+
+  const { getCachedCount, refreshCountsInBackground } = await import('../bundle-counts.js');
+  const bundlesWithCounts = (Array.isArray(bundles) ? bundles : []).map(b => {
+    if (!b.repo_url) return b;
+    const cached = getCachedCount(b.repo_url);
+    return cached !== null ? { ...b, skillCount: cached } : b;
+  });
+  refreshCountsInBackground(bundlesWithCounts);
+
+  const installedSet = new Set();
+  try {
+    const cfg = _lcMkt();
+    const db = _getDbMkt();
+    const { SKILLS_STORE_DIR } = await import('../config.js');
+    const githubDir = path.join(SKILLS_STORE_DIR, 'github');
+
+    for (const b of (Array.isArray(bundles) ? bundles : [])) {
+      if (b.repo_url) {
+        const owner = b.repo_url.split('/')[0];
+        const repo  = b.repo_url.split('/')[1];
+        const clonedName = `${owner}-${repo}`;
+        const clonedDir  = path.join(githubDir, clonedName);
+        const dirExists  = fs.existsSync(clonedDir) &&
+          fs.readdirSync(clonedDir).length > 0;
+        if (dirExists) installedSet.add(b.id);
+      } else if (Array.isArray(b.skills)) {
+        const allOnDisk = b.skills.every(sid => {
+          const row = db.prepare('SELECT path FROM skills WHERE id = ?').get(sid);
+          return row && fs.existsSync(row.path);
+        });
+        if (b.skills.length > 0 && allOnDisk) installedSet.add(b.id);
+      }
+    }
+
+    for (const row of db.prepare('SELECT id, path FROM skills WHERE source = ?').all('marketplace')) {
+      if (fs.existsSync(row.path)) installedSet.add(row.id);
+    }
+  } catch {}
+
+  const { runTUI } = await import('../tui.js');
+  const { loadConfig: _lcR, saveConfig: _scR, SKILLS_STORE_DIR: _ssR } = await import('../config.js');
+  const { getDb: _getDbR } = await import('../db.js');
+
+  await runTUI(
+    Array.isArray(skills) ? skills : [],
+    bundlesWithCounts,
+    async (item) => {
+      if (item.type === 'bundle') {
+        const r = await installBundle(item.id);
+        if (r?.error) throw new Error(r.error);
+        installedSet.add(item.id);
+      } else {
+        const r = await installSkill(item.code || item.id);
+        if (r?.error) throw new Error(r.error);
+        installedSet.add(item.id);
+        if (item.code) installedSet.add(item.code);
+      }
+    },
+    installedSet,
+    async (item) => {
+      const cfg = _lcR();
+      const db  = _getDbR();
+      if (item.type === 'bundle' && item.repo_url) {
+        const owner = item.repo_url.split('/')[0];
+        const repo  = item.repo_url.split('/')[1];
+        const clonedName = `${owner}-${repo}`;
+        const clonedDir  = path.join(_ssR, 'github', clonedName);
+        if (fs.existsSync(clonedDir)) fs.rmSync(clonedDir, { recursive: true, force: true });
+        const src = `github:${clonedName}`;
+        cfg.sources = cfg.sources.filter(s => s.source !== src && !s.dir.startsWith(clonedDir));
+        _scR(cfg);
+        db.prepare('DELETE FROM skills WHERE source = ?').run(src);
+        db.prepare('DELETE FROM chunks WHERE skill_id NOT IN (SELECT id FROM skills)').run();
+      } else if (item.type === 'bundle') {
+        const mktDir = path.join(_ssR, 'marketplace');
+        for (const sid of (item.skills || [])) {
+          const row = db.prepare('SELECT path FROM skills WHERE id = ?').get(sid);
+          if (row?.path && fs.existsSync(row.path)) fs.unlinkSync(row.path);
+          db.prepare('DELETE FROM skills WHERE id = ?').run(sid);
+          db.prepare('DELETE FROM chunks WHERE skill_id = ?').run(sid);
+        }
+      } else {
+        const row = db.prepare('SELECT path FROM skills WHERE id = ?').get(item.id);
+        if (row?.path && fs.existsSync(row.path)) fs.unlinkSync(row.path);
+        db.prepare('DELETE FROM skills WHERE id = ?').run(item.id);
+        db.prepare('DELETE FROM chunks WHERE skill_id = ?').run(item.id);
+      }
+      installedSet.delete(item.id);
+      if (item.code) installedSet.delete(item.code);
+    }
+  );
+  process.exit(0);
+}

package/commands/reindex.js

@@ -0,0 +1,10 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+
+export default async function handler(args, bin) {
+  const { indexAll } = await import('../indexer.js');
+  const fast = args.includes('--fast');
+  if (fast) info(chalk.yellow('Fast mode — skipping embeddings (keyword search only)'));
+  await indexAll({ fast });
+  process.exit(0);
+}

package/commands/search.js

@@ -0,0 +1,55 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+import { VALID_TRUST_LEVELS, TRUST_LEVEL_BOOST } from '../marketplace.js';
+
+export default async function handler(args, bin) {
+  const trustFilter = args.find(a => a.startsWith('--trust='));
+  const filteredArgs = args.filter(a => !a.startsWith('--trust='));
+  const query = filteredArgs.slice(1).join(' ');
+  if (!query) { error('Usage: ' + bin + ' search <query> [--trust=verified]'); process.exit(1); }
+
+  if (trustFilter) {
+    const level = trustFilter.split('=')[1];
+    if (!VALID_TRUST_LEVELS.includes(level)) {
+      error('Invalid trust level. Valid: ' + VALID_TRUST_LEVELS.join(', '));
+      process.exit(1);
+    }
+  }
+
+  const { search: searchSkills } = await import('../search.js');
+  const { getDb } = await import('../db.js');
+  const { getByTrustLevel } = await import('../marketplace.js');
+  const spin = (await import('../cli.js')).spinner('Searching...');
+  spin.start();
+  let results = await searchSkills(query, 10);
+  spin.stop();
+
+  // Apply trust filter after search
+  if (trustFilter) {
+    const level = trustFilter.split('=')[1];
+    const entries = await getByTrustLevel(level);
+    const allowed = new Set(entries.map(e => e.id));
+    results = results.filter(r => allowed.has(r.id));
+  }
+
+  // Enrich results with trust level
+  const db = getDb();
+  const enriched = results.map(s => {
+    const re = db.prepare('SELECT trust_level FROM registry_entries WHERE id = ?').get(s.id);
+    return { ...s, trustLevel: re ? re.trust_level : 'unknown' };
+  });
+
+  if (!enriched.length) { info('No results for: ' + query); process.exit(0); }
+  const purple = chalk.hex('#7C3AED');
+  console.log();
+  enriched.forEach((s, i) => {
+    const score = chalk.dim((s.score * 100).toFixed(0) + '%');
+    const trustBadge = s.trustLevel !== 'unknown' && s.trustLevel !== 'community'
+      ? ' ' + purple(s.trustLevel) : '';
+    console.log('  ' + chalk.dim(String(i + 1) + '.') + ' ' + chalk.bold.white(s.name) + trustBadge + '  ' + score);
+    console.log('     ' + chalk.dim(s.description || ''));
+    console.log('     ' + purple(s.source) + '  ' + chalk.dim(s.path));
+    console.log();
+  });
+  process.exit(0);
+}

package/commands/setup.js

@@ -0,0 +1,19 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+
+export default async function handler(args, bin) {
+  const { detectPlatforms, PLATFORMS } = await import('../platform.js');
+  const platformId = args[1];
+  if (!platformId) {
+    section('Detected platforms');
+    detectPlatforms().forEach(p => info(`${chalk.white(p.id.padEnd(16))} ${chalk.gray(p.name)}`));
+    console.log(chalk.gray('\n  Usage: promptgraph-mcp setup <platform-id>\n'));
+  } else {
+    const platform = PLATFORMS[platformId];
+    if (!platform) { error(`Unknown platform: ${platformId}`); process.exit(1); }
+    platform.addMcp(platform);
+    success(`Registered in ${chalk.white(platform.name)}`);
+    info(chalk.gray(platform.configPath));
+  }
+  process.exit(0);
+}

package/commands/status.js

@@ -0,0 +1,110 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import boxen from 'boxen';
+
+export default async function handler(args, bin) {
+  const { loadConfig: _lc } = await import('../config.js');
+  const { getDb } = await import('../db.js');
+  const { fetchText } = await import('../marketplace.js');
+  const purple = chalk.hex('#7C3AED');
+  const cfg = _lc();
+  const db = getDb();
+
+  const sourceCounts = new Map();
+  for (const row of db.prepare('SELECT source, COUNT(*) as n FROM skills GROUP BY source').all()) {
+    sourceCounts.set(row.source, row.n);
+  }
+  const totalSkills = db.prepare('SELECT COUNT(*) as n FROM skills').get().n;
+  const totalBundles = cfg.sources.filter(s => s.source.startsWith('github:')).length;
+
+  let marketSkills = 0, marketBundles = 0;
+  try {
+    const REGISTRY_URL = 'https://raw.githubusercontent.com/NeiP4n/promptgraph-registry/main/registry.json';
+    const reg = JSON.parse(await fetchText(REGISTRY_URL));
+    marketSkills = reg.skills?.length || 0;
+    marketBundles = reg.bundles?.length || 0;
+  } catch {}
+
+  console.log();
+  console.log('  ' + purple.bold('◆ PromptGraph Status'));
+  console.log('  ' + chalk.gray('─'.repeat(56)));
+  console.log();
+
+  const skillsLine = chalk.bold.white(`${totalSkills} skills`) +
+    (marketSkills ? chalk.gray(` / ${marketSkills} in registry`) : '');
+  const bundlesLine = chalk.bold.white(`${totalBundles} repos`) +
+    (marketBundles ? chalk.gray(` / ${marketBundles} in marketplace`) : '');
+  console.log('  ' + skillsLine + chalk.gray('   ·   ') + bundlesLine);
+  console.log();
+
+  const githubSources = cfg.sources.filter(s => s.source.startsWith('github:'));
+  const localSources  = cfg.sources.filter(s => !s.source.startsWith('github:'));
+
+  if (localSources.length) {
+    console.log('  ' + purple('📁  Local'));
+    for (const s of localSources) {
+      const n = sourceCounts.get(s.source) || 0;
+      const exists = fs.existsSync(s.dir);
+      const label = exists ? chalk.white(s.source) : chalk.gray(s.source + ' (missing)');
+      console.log('    ' + label + chalk.gray(`  ${n} skills  ·  ${s.dir}`));
+    }
+    console.log();
+  }
+
+  if (githubSources.length) {
+    console.log('  ' + purple('🌐  GitHub repos'));
+    for (const s of githubSources) {
+      const n = sourceCounts.get(s.source) || 0;
+      const repoName = s.source.replace('github:', '');
+      const exists = fs.existsSync(s.dir);
+      const label = exists ? chalk.white(repoName) : chalk.gray(repoName + ' (not cloned)');
+      console.log('    ' + label + chalk.gray(`  ${n} skills`));
+      console.log('      ' + chalk.dim(s.dir));
+    }
+    console.log();
+  }
+
+  const marketplaceDir = path.join(os.homedir(), '.claude', 'skills-store', 'marketplace');
+  const installedBundles = fs.existsSync(marketplaceDir)
+    ? fs.readdirSync(marketplaceDir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name)
+    : [];
+
+  if (installedBundles.length) {
+    let registryBundles = [];
+    try {
+      const REGISTRY_URL = 'https://raw.githubusercontent.com/NeiP4n/promptgraph-registry/main/registry.json';
+      const text = await fetchText(REGISTRY_URL);
+      registryBundles = JSON.parse(text).bundles || [];
+    } catch {}
+
+    console.log('  ' + purple('📦  Installed marketplace bundles'));
+    for (const b of installedBundles) {
+      const bundle = registryBundles.find(rb => rb.id === b);
+      const name = bundle ? chalk.white.bold(bundle.name || b) : chalk.white(b);
+      const cat  = bundle?.category ? chalk.dim(` [${bundle.category}]`) : '';
+      const n    = sourceCounts.get('marketplace') || 0;
+      console.log(`    ${name}${cat}  ${chalk.gray(n + ' skills')}`);
+    }
+    console.log();
+  }
+
+  const emptyRepos = githubSources.filter(s => (sourceCounts.get(s.source) || 0) === 0 && fs.existsSync(s.dir));
+  if (emptyRepos.length) {
+    console.log('  ' + chalk.yellow(`⚠  ${emptyRepos.length} repo(s) not indexed`) + chalk.gray('  →  run: ') + chalk.cyan(`${bin} reindex`));
+    console.log();
+  }
+
+  console.log(
+    boxen(
+      chalk.dim('full reindex   ') + chalk.cyan(`${bin} reindex`) + '\n' +
+      chalk.dim('install bundle ') + chalk.cyan(`${bin} bundle install <id>`) + '\n' +
+      chalk.dim('browse market  ') + 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);
+}

package/commands/train.js

@@ -0,0 +1,18 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+
+export default async function handler(args, bin) {
+  const { train: trainModel } = await import('../src/filter/train.js');
+  const spin = (await import('../cli.js')).spinner('Training classifier...');
+  spin.start();
+  try {
+    const model = await trainModel();
+    spin.stop();
+    success(`Classifier trained (${model.counts.good} good, ${model.counts.bad} bad examples)`);
+  } catch (e) {
+    spin.stop();
+    error(`Training failed: ${e.message}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}