promptgraph-mcp 1.3.0 → 1.5.0

package/chunker.js

@@ -1,5 +1,5 @@
-const CHUNK_SIZE = 400;
-const CHUNK_OVERLAP = 80;
+const CHUNK_SIZE = 800;
+const CHUNK_OVERLAP = 100;
 
 export function chunkText(text) {
   const words = text.split(/\s+/);

package/cli.js

@@ -0,0 +1,95 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+
+export const colors = {
+  primary: chalk.hex('#7C3AED'),
+  success: chalk.hex('#10B981'),
+  warning: chalk.hex('#F59E0B'),
+  error: chalk.hex('#EF4444'),
+  muted: chalk.hex('#6B7280'),
+  white: chalk.white,
+  bold: chalk.bold,
+};
+
+export function banner() {
+  console.log(
+    boxen(
+      colors.primary.bold('PromptGraph') + '  ' + colors.muted('v' + (await 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,
+      }
+    )
+  );
+}
+
+async function getVersion() {
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    return require('./package.json').version;
+  } catch { return ''; }
+}
+
+export function spinner(text) {
+  return ora({
+    text: colors.muted(text),
+    spinner: 'dots',
+    color: 'magenta',
+  });
+}
+
+export function success(msg) {
+  console.log(colors.success('✓') + ' ' + msg);
+}
+
+export function error(msg) {
+  console.log(colors.error('✗') + ' ' + msg);
+}
+
+export function info(msg) {
+  console.log(colors.muted('·') + ' ' + msg);
+}
+
+export function section(title) {
+  console.log('\n' + colors.primary.bold(title));
+}
+
+export function progress(current, total, extra = '') {
+  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)}  `
+  );
+}
+
+function buildBar(pct) {
+  const width = 20;
+  const filled = Math.round(pct / 100 * width);
+  const empty = width - filled;
+  return colors.primary('█'.repeat(filled)) + colors.muted('░'.repeat(empty));
+}
+
+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('  '));
+  console.log('\n' + header);
+  console.log(divider);
+  for (const row of rows) {
+    const line = cols.map((c, i) => {
+      const val = String(row[c] ?? '');
+      if (c === 'score' || c === 'rating') return colors.primary(val.padEnd(widths[i]));
+      if (c === 'name') return colors.white.bold(val.padEnd(widths[i]));
+      return colors.muted(val.padEnd(widths[i]));
+    }).join('  ');
+    console.log(line);
+  }
+  console.log();
+}

package/db.js

@@ -17,7 +17,8 @@ export function getDb() {
       description TEXT,
       path TEXT NOT NULL,
       source TEXT NOT NULL,
-      content TEXT NOT NULL
+      content TEXT NOT NULL,
+      hash TEXT
     );
 
     CREATE TABLE IF NOT EXISTS chunks (
@@ -34,8 +35,21 @@ export function getDb() {
       to_skill TEXT NOT NULL,
       PRIMARY KEY (from_skill, to_skill)
     );
+
+    CREATE TABLE IF NOT EXISTS ratings (
+      skill_id TEXT PRIMARY KEY,
+      uses INTEGER DEFAULT 0,
+      success INTEGER DEFAULT 0,
+      fail INTEGER DEFAULT 0
+    );
   `);
 
+  // migrate: add hash column if missing
+  const cols = db.pragma('table_info(skills)').map(c => c.name);
+  if (!cols.includes('hash')) {
+    db.exec('ALTER TABLE skills ADD COLUMN hash TEXT');
+  }
+
   return db;
 }
 

package/embedder.js

@@ -1,32 +1,44 @@
-import { EmbeddingModel, FlagEmbedding } from 'fastembed';
-import path from 'path';
-import os from 'os';
-
-const CACHE_DIR = path.join(os.homedir(), '.claude', '.promptgraph', 'model-cache');
-
-let model = null;
-
-async function getModel() {
-  if (!model) {
-    model = await FlagEmbedding.init({
-      model: EmbeddingModel.BGESmallENV15,
-      cacheDir: CACHE_DIR,
-    });
-  }
-  return model;
-}
-
-export async function embed(text) {
-  const m = await getModel();
-  const results = [];
-  for await (const batch of m.embed([text])) {
-    results.push(...batch);
-  }
-  return Array.from(results[0]);
-}
-
-export function cosineSimilarity(a, b) {
-  let dot = 0;
-  for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
-  return dot;
-}
+import { EmbeddingModel, FlagEmbedding } from 'fastembed';
+import path from 'path';
+import os from 'os';
+
+const CACHE_DIR = path.join(os.homedir(), '.claude', '.promptgraph', 'model-cache');
+const BATCH_SIZE = 64;
+
+let model = null;
+
+async function getModel() {
+  if (!model) {
+    model = await FlagEmbedding.init({
+      model: EmbeddingModel.BGESmallENV15,
+      cacheDir: CACHE_DIR,
+    });
+  }
+  return model;
+}
+
+export async function embed(text) {
+  const m = await getModel();
+  const results = [];
+  for await (const batch of m.embed([text])) {
+    results.push(...batch);
+  }
+  return Array.from(results[0]);
+}
+
+export async function embedBatch(texts) {
+  const m = await getModel();
+  const all = [];
+  for await (const batch of m.embed(texts)) {
+    all.push(...batch);
+  }
+  return all.map(v => Array.from(v));
+}
+
+export function cosineSimilarity(a, b) {
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
+  return dot;
+}
+
+export { BATCH_SIZE };

package/index.js

@@ -8,26 +8,36 @@ import { startWatcher } from './watcher.js';
 import { promptConfig } from './config.js';
 import { importFromGitHub } from './github-import.js';
 import { detectPlatforms, PLATFORMS } from './platform.js';
+import { browseMarketplace, installSkill, publishSkill, getTopRated, recordUse, recordSuccess, recordFail } from './marketplace.js';
 
-const args = process.argv.slice(2);
-
-if (args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
-  console.log(`
-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 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
+import { colors, banner, success, error, info, section, table } from './cli.js';
+import boxen from 'boxen';
+import chalk from 'chalk';
 
-Platforms: claude-code, claude-desktop, cline, codex, cursor, windsurf
+const args = process.argv.slice(2);
 
-GitHub: https://github.com/NeiP4n/promptgraph
-npm:    https://npmjs.com/package/promptgraph-mcp
-  `);
+if (args[0] === 'help' || args[0] === '--help' || args[0] === '-h' || !args[0]) {
+  console.log(
+    boxen(
+      chalk.hex('#7C3AED').bold('PromptGraph') + '\n' +
+      chalk.gray('Semantic skill router for Claude Code'),
+      { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: '#7C3AED', dimBorder: true }
+    )
+  );
+  console.log(chalk.gray('\nUsage:\n'));
+  const cmds = [
+    ['init',                'First-time setup + index all skills'],
+    ['reindex',             'Re-index all skills'],
+    ['import <owner/repo>', 'Import skills from GitHub'],
+    ['setup <platform>',    'Register MCP in platform config'],
+    ['help',                'Show this help'],
+  ];
+  for (const [cmd, desc] of cmds) {
+    console.log('  ' + chalk.hex('#7C3AED')('promptgraph-mcp ' + cmd.padEnd(22)) + chalk.gray(desc));
+  }
+  console.log(chalk.gray('\nPlatforms: claude-code, claude-desktop, cline, codex, cursor, windsurf'));
+  console.log(chalk.gray('\n  github.com/NeiP4n/promptgraph  ·  npmjs.com/package/promptgraph-mcp\n'));
+  if (!args[0]) process.exit(0);
   process.exit(0);
 }
 
@@ -39,37 +49,34 @@ if (args[0] === 'import') {
 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>');
+    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) { console.error(`Unknown platform: ${platformId}`); process.exit(1); }
+    if (!platform) { error(`Unknown platform: ${platformId}`); process.exit(1); }
     platform.addMcp(platform);
-    console.log(`✓ Registered promptgraph MCP in ${platform.name} (${platform.configPath})`);
+    success(`Registered in ${chalk.white(platform.name)}`);
+    info(chalk.gray(platform.configPath));
   }
   process.exit(0);
 }
 
 if (args[0] === 'init') {
   const config = await promptConfig();
-  console.log('\nIndexing skills...');
   await indexAll();
-  console.log('\nDone! Add to Claude Code settings.json:');
-  console.log(JSON.stringify({
-    mcpServers: {
-      promptgraph: {
-        command: 'npx',
-        args: ['promptgraph-mcp'],
-      }
-    }
-  }, null, 2));
+  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);
 }
 
 if (args[0] === 'reindex') {
-  console.log('[PromptGraph] Reindexing...');
   await indexAll();
   process.exit(0);
 }
@@ -134,6 +141,52 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ['name'],
       },
     },
+    {
+      name: 'pg_rate',
+      description: 'Record skill usage outcome. Call after applying a skill: outcome="success" if it helped, "fail" if it did not.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          skill_id: { type: 'string' },
+          outcome: { type: 'string', enum: ['use', 'success', 'fail'] },
+        },
+        required: ['skill_id', 'outcome'],
+      },
+    },
+    {
+      name: 'pg_top_rated',
+      description: 'Get top rated skills by success rate.',
+      inputSchema: {
+        type: 'object',
+        properties: { top_k: { type: 'number' } },
+      },
+    },
+    {
+      name: 'pg_marketplace_browse',
+      description: 'Browse top skills from the PromptGraph marketplace.',
+      inputSchema: {
+        type: 'object',
+        properties: { top_k: { type: 'number' } },
+      },
+    },
+    {
+      name: 'pg_marketplace_install',
+      description: 'Install a skill from the marketplace by ID.',
+      inputSchema: {
+        type: 'object',
+        properties: { skill_id: { type: 'string' } },
+        required: ['skill_id'],
+      },
+    },
+    {
+      name: 'pg_marketplace_publish',
+      description: 'Publish a local skill file to the marketplace via GitHub Gist.',
+      inputSchema: {
+        type: 'object',
+        properties: { file_path: { type: 'string' } },
+        required: ['file_path'],
+      },
+    },
   ],
 }));
 
@@ -149,6 +202,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'pg_callers': result = getCallers(args.name); break;
       case 'pg_callees': result = getCallees(args.name); break;
       case 'pg_impact': result = getImpact(args.name); break;
+      case 'pg_rate':
+        if (args.outcome === 'use') recordUse(args.skill_id);
+        else if (args.outcome === 'success') recordSuccess(args.skill_id);
+        else if (args.outcome === 'fail') recordFail(args.skill_id);
+        result = { ok: true };
+        break;
+      case 'pg_top_rated': result = getTopRated(args.top_k || 10); break;
+      case 'pg_marketplace_browse': result = await browseMarketplace(args.top_k || 20); break;
+      case 'pg_marketplace_install': result = await installSkill(args.skill_id); break;
+      case 'pg_marketplace_publish': result = await publishSkill(args.file_path); break;
       default: throw new Error(`Unknown tool: ${name}`);
     }
     return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };

package/indexer.js

@@ -1,38 +1,66 @@
 import { globSync } from 'glob';
+import { createHash } from 'crypto';
+import fs from 'fs';
 import { parseSkillFile } from './parser.js';
-import { embed } from './embedder.js';
+import { embedBatch, BATCH_SIZE } from './embedder.js';
 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 chalk from 'chalk';
 
-async function indexSkill(db, skill) {
-  const id = skillId(skill.source, skill.name);
+function fileHash(filePath) {
+  const content = fs.readFileSync(filePath);
+  return createHash('md5').update(content).digest('hex');
+}
 
-  db.prepare(`
-    INSERT INTO skills (id, name, description, path, source, content)
-    VALUES (@id, @name, @description, @path, @source, @content)
+async function indexBatch(db, skills) {
+  const upsertSkill = db.prepare(`
+    INSERT INTO skills (id, name, description, path, source, content, hash)
+    VALUES (@id, @name, @description, @path, @source, @content, @hash)
     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);
+      content = excluded.content,
+      hash = excluded.hash
+  `);
+  const deleteChunks = db.prepare('DELETE FROM chunks WHERE skill_id = ?');
+  const deleteEdges = db.prepare('DELETE FROM edges WHERE from_skill = ?');
+  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 (?, ?)');
 
-  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));
+  // collect all chunks across skills in batch
+  const allChunks = [];
+  for (const skill of skills) {
+    const id = skillId(skill.source, skill.name);
+    const chunks = chunkText(skill.name + ' ' + skill.description + '\n' + skill.content);
+    for (let i = 0; i < chunks.length; i++) {
+      allChunks.push({ id, skill, chunkIndex: i, text: chunks[i] });
+    }
   }
 
-  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);
-  }
+  // embed all chunks in one batch call
+  const texts = allChunks.map(c => c.text);
+  const embeddings = await embedBatch(texts);
+
+  const txn = db.transaction(() => {
+    for (const skill of skills) {
+      const id = skillId(skill.source, skill.name);
+      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 (let i = 0; i < allChunks.length; i++) {
+      const { id, chunkIndex, text } = allChunks[i];
+      upsertChunk.run(id, chunkIndex, text, JSON.stringify(embeddings[i]));
+    }
+  });
+  txn();
 }
 
 export async function indexAll() {
@@ -40,27 +68,73 @@ export async function indexAll() {
   const db = getDb();
   db.prepare('DELETE FROM edges').run();
 
-  let count = 0;
+  // pre-count total files
+  let total = 0;
+  const allFiles = [];
   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);
+    files.forEach(f => allFiles.push({ file: f, source }));
+    total += files.length;
+  }
+  info(`Found ${chalk.white.bold(total)} files`);
+
+  let count = 0;
+  let errors = 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 {
+      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++;
-        process.stdout.write(`\r  Indexed: ${count} skills`);
-      } catch (e) {
-        console.error(`\n  Error indexing ${file}: ${e.message}`);
+        if (count % 50 === 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);
+      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}  `);
       }
+    } catch (e) {
+      errors++;
     }
   }
-  process.stdout.write('\r  Building ANN index...');
+
+  if (batch.length > 0) {
+    await indexBatch(db, batch);
+    count += batch.length;
+  }
+
+  progress(total, total, 'done');
+  console.log();
+  const spin = spinner('Building ANN index...');
+  spin.start();
   await buildAnnIndex();
-  console.log(`\n  Done. ${count} skills indexed.`);
+  spin.stop();
+  success(`Indexed ${chalk.white.bold(count)} skills  ${chalk.gray(`(${errors} errors, ${skipped} skipped)`)}`);
+  const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+  info(chalk.gray(`Time: ${elapsed}s`));
 }
 
 export async function indexFile(filePath, source) {
   const db = getDb();
   const skill = parseSkillFile(filePath, source);
-  await indexSkill(db, skill);
+  await indexBatch(db, [skill]);
 }

package/marketplace.js

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import { getDb } from './db.js';
+
+const REGISTRY_URL = 'https://raw.githubusercontent.com/NeiP4n/promptgraph-registry/main/registry.json';
+const SKILLS_DIR = path.join(os.homedir(), '.claude', 'skills-store', 'marketplace');
+
+export async function browseMarketplace(topK = 20) {
+  try {
+    const res = await fetch(REGISTRY_URL);
+    const registry = await res.json();
+    return registry.skills
+      .sort((a, b) => (b.stars || 0) - (a.stars || 0))
+      .slice(0, topK);
+  } catch {
+    return { error: 'Registry unavailable. Check https://github.com/NeiP4n/promptgraph-registry' };
+  }
+}
+
+export async function installSkill(skillId) {
+  try {
+    const res = await fetch(REGISTRY_URL);
+    const registry = await res.json();
+    const skill = registry.skills.find(s => s.id === skillId);
+    if (!skill) return { error: `Skill "${skillId}" not found in registry` };
+
+    fs.mkdirSync(SKILLS_DIR, { recursive: true });
+    const dest = path.join(SKILLS_DIR, `${skillId}.md`);
+
+    const content = await fetch(skill.raw_url);
+    const text = await content.text();
+    fs.writeFileSync(dest, text);
+
+    return { success: true, path: dest, name: skill.name };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+export async function publishSkill(filePath) {
+  if (!fs.existsSync(filePath)) return { error: `File not found: ${filePath}` };
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const name = path.basename(filePath, '.md');
+
+  try {
+    const result = execSync(
+      `gh gist create "${filePath}" --desc "PromptGraph skill: ${name}" --public`,
+      { encoding: 'utf8' }
+    ).trim();
+    return {
+      success: true,
+      url: result,
+      message: `Published! Submit to registry: https://github.com/NeiP4n/promptgraph-registry/issues/new`,
+    };
+  } catch {
+    return { error: 'gh CLI not found or not authenticated. Run: gh auth login' };
+  }
+}
+
+export function getTopRated(topK = 10) {
+  const db = getDb();
+  return db.prepare(`
+    SELECT s.id, s.name, s.description, s.source,
+           r.uses, r.success, r.fail,
+           CASE WHEN (r.success + r.fail) > 0
+                THEN ROUND(CAST(r.success AS FLOAT) / (r.success + r.fail), 2)
+                ELSE NULL END as rating
+    FROM skills s
+    LEFT JOIN ratings r ON s.id = r.skill_id
+    WHERE r.uses > 0
+    ORDER BY rating DESC, r.uses DESC
+    LIMIT ?
+  `).all(topK);
+}
+
+export function recordUse(skillId) {
+  const db = getDb();
+  db.prepare(`
+    INSERT INTO ratings (skill_id, uses, success, fail)
+    VALUES (?, 1, 0, 0)
+    ON CONFLICT(skill_id) DO UPDATE SET uses = uses + 1
+  `).run(skillId);
+}
+
+export function recordSuccess(skillId) {
+  const db = getDb();
+  db.prepare(`
+    INSERT INTO ratings (skill_id, uses, success, fail)
+    VALUES (?, 0, 1, 0)
+    ON CONFLICT(skill_id) DO UPDATE SET success = success + 1
+  `).run(skillId);
+}
+
+export function recordFail(skillId) {
+  const db = getDb();
+  db.prepare(`
+    INSERT INTO ratings (skill_id, uses, success, fail)
+    VALUES (?, 0, 0, 1)
+    ON CONFLICT(skill_id) DO UPDATE SET fail = fail + 1
+  `).run(skillId);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptgraph-mcp",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "main": "index.js",
   "type": "module",
   "bin": {
@@ -34,10 +34,13 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.10.0",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
     "chokidar": "^5.0.0",
     "fastembed": "^2.1.0",
     "glob": "^13.0.6",
     "gray-matter": "^4.0.3",
+    "ora": "^9.4.0",
     "vectra": "^0.15.0"
   }
 }

package/search.js

@@ -2,6 +2,15 @@ import { embed, cosineSimilarity } from './embedder.js';
 import { getDb } from './db.js';
 import { annSearch } from './ann.js';
 
+function applyRatingBoost(db, id, score) {
+  const r = db.prepare('SELECT success, fail FROM ratings WHERE skill_id = ?').get(id);
+  if (r && (r.success + r.fail) > 3) {
+    const rating = r.success / (r.success + r.fail);
+    return score * (0.85 + 0.15 * rating);
+  }
+  return score;
+}
+
 export async function search(query, topK = 5) {
   const db = getDb();
   const queryVec = await embed(query);
@@ -20,7 +29,7 @@ export async function search(query, topK = 5) {
       .slice(0, topK)
       .map(([id, score]) => {
         const skill = db.prepare('SELECT id, name, description, path, source FROM skills WHERE id = ?').get(id);
-        return skill ? { ...skill, score } : null;
+        return skill ? { ...skill, score: applyRatingBoost(db, id, score) } : null;
       })
       .filter(Boolean);
   }