promptgraph-mcp 2.5.0 → 2.6.1

package/commands/update.js

@@ -0,0 +1,49 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+
+export default async function handler(args, bin) {
+  const { spawnSync } = await import('child_process');
+  const { createRequire } = await import('module');
+  const https = (await import('https')).default;
+  const req = createRequire(import.meta.url);
+  const currentVersion = req('../package.json').version;
+
+  const spin = (await import('../cli.js')).spinner('Checking latest version...');
+  spin.start();
+  let latest = null;
+  try {
+    latest = await new Promise((res, rej) => {
+      const r = https.get('https://registry.npmjs.org/promptgraph-mcp/latest',
+        { headers: { Accept: 'application/json' }, timeout: 8000 },
+        (resp) => {
+          let d = ''; resp.setEncoding('utf8');
+          resp.on('data', c => d += c);
+          resp.on('end', () => { try { res(JSON.parse(d).version); } catch { rej(new Error('bad response')); } });
+        }
+      );
+      r.on('error', rej);
+      r.on('timeout', () => { r.destroy(new Error('timeout')); });
+    });
+  } catch {}
+  spin.stop();
+
+  if (!latest) { error('Could not reach npm registry. Check your network.'); process.exit(1); }
+  if (latest === currentVersion) {
+    success(`Already on latest version ${chalk.white.bold('v' + currentVersion)}`);
+    process.exit(0);
+  }
+
+  info(`Current: ${chalk.gray('v' + currentVersion)}  →  Latest: ${chalk.white.bold('v' + latest)}`);
+  const updateSpin = (await import('../cli.js')).spinner(`Installing promptgraph-mcp@latest (v${latest})...`);
+  updateSpin.start();
+  const result = spawnSync('npm', ['install', '-g', 'promptgraph-mcp@latest'], { encoding: 'utf8', stdio: 'pipe', shell: true });
+  updateSpin.stop();
+
+  if (result.status !== 0) {
+    error('Update failed:');
+    console.log(chalk.gray(result.stderr || result.stdout));
+    process.exit(1);
+  }
+  success(`Updated to ${chalk.white.bold('v' + latest)}`);
+  process.exit(0);
+}

package/commands/validate.js

@@ -0,0 +1,63 @@
+import { colors, banner, success, error, info, section, table } from '../cli.js';
+import chalk from 'chalk';
+import fs from 'fs';
+
+export default async function handler(args, bin) {
+  const { validateSkill } = await import('../validator.js');
+  const file = args[1];
+  if (!file) { error('Usage: ' + bin + ' validate <skill.md>'); process.exit(1); }
+
+  const raw = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : null;
+
+  if (raw) {
+    const { filterWithClassifier, isSkillFile: _isSkill } = await import('../parser.js');
+    const { hardFilter } = await import('../src/filter/hard-filter.js');
+    const { loadModel } = await import('../src/filter/train.js');
+    const { embed } = await import('../embedder.js');
+    const { classify } = await import('../src/filter/classifier.js');
+
+    const hfResult = hardFilter(file, raw);
+    const willIndex = _isSkill(file, raw);
+    const scoreLabel = willIndex ? chalk.green('✓ will be indexed') : chalk.red('✗ will be skipped by indexer');
+    console.log(chalk.bold('\n  Indexing check: ') + scoreLabel);
+
+    const signals = [];
+    if (!hfResult.pass) {
+      signals.push(chalk.red(`✗ hard filter: ${hfResult.reason}`));
+    } else {
+      signals.push(chalk.green('✓ hard filter passed'));
+    }
+
+    const centroids = loadModel();
+    if (centroids) {
+      try {
+        const vec = await embed(raw);
+        const decision = classify(vec, centroids, raw, file);
+        const pct = (decision.score * 100).toFixed(0);
+        if (decision.label === 'skill') signals.push(chalk.green(`✓ classifier: skill (${pct}%)`));
+        else if (decision.label === 'unsure') signals.push(chalk.yellow(`? classifier: unsure (${pct}%)`));
+        else signals.push(chalk.red(`✗ classifier: reject (${pct}%)`));
+      } catch {
+        signals.push(chalk.gray('  classifier: embed failed (skip)'));
+      }
+    } else {
+      signals.push(chalk.gray('  classifier: no model (run `pg train`)'));
+    }
+
+    if (signals.length) {
+      signals.forEach(s => console.log('    ' + s));
+    }
+    console.log();
+  }
+
+  const result = validateSkill(file);
+  result.warnings.forEach(w => console.log(chalk.yellow('⚠') + '  ' + chalk.gray(w)));
+  if (result.ok) {
+    success('Skill is valid — ready to publish');
+    process.exit(0);
+  } else {
+    error('Validation failed:');
+    result.errors.forEach(e => console.log('   ' + chalk.red('•') + ' ' + e));
+    process.exit(1);
+  }
+}

package/db.js

@@ -7,124 +7,138 @@ const DB_PATH = path.join(PROMPTGRAPH_DIR, '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(`
-    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,
-      hash TEXT
-    );
-
-    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 BLOB 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)
-    );
-
-    CREATE TABLE IF NOT EXISTS ratings (
-      skill_id TEXT PRIMARY KEY,
-      uses INTEGER DEFAULT 0,
-      success INTEGER DEFAULT 0,
-      fail INTEGER DEFAULT 0
-    );
-
-    CREATE VIRTUAL TABLE IF NOT EXISTS skills_fts USING fts5(
-      id UNINDEXED,
-      name,
-      description,
-      content,
-      content='skills',
-      content_rowid='rowid'
-    );
-  `);
-
-  // 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');
+const MIGRATIONS = [
+  {
+    version: 1, description: 'initial schema',
+    up: db => 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,
+        hash TEXT
+      );
+      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 BLOB 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)
+      );
+      CREATE TABLE IF NOT EXISTS ratings (
+        skill_id TEXT PRIMARY KEY,
+        uses INTEGER DEFAULT 0,
+        success INTEGER DEFAULT 0,
+        fail INTEGER DEFAULT 0
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS skills_fts USING fts5(
+        id UNINDEXED, name, description, content,
+        content='skills', content_rowid='rowid'
+      );
+    `),
+  },
+  {
+    version: 2, description: 'add hash column',
+    up: db => {
+      const cols = db.pragma('table_info(skills)').map(c => c.name);
+      if (!cols.includes('hash')) db.exec('ALTER TABLE skills ADD COLUMN hash TEXT');
+    },
+  },
+  {
+    version: 3, description: 'add registry metadata columns',
+    up: db => {
+      const cols = db.pragma('table_info(skills)').map(c => c.name);
+      for (const [col, def] of [
+        ['version', 'TEXT'],
+        ['author', 'TEXT'],
+        ['license', 'TEXT'],
+        ['updated_at', 'TEXT'],
+        ['downloads', 'INTEGER DEFAULT 0'],
+        ['verified', 'INTEGER DEFAULT 0'],
+        ['trust_level', "TEXT DEFAULT 'unknown'"],
+        ['rating', 'REAL DEFAULT 0'],
+        ['rating_count', 'INTEGER DEFAULT 0'],
+        ['popularity', 'REAL DEFAULT 0'],
+        ['last_update', 'TEXT'],
+      ]) {
+        if (!cols.includes(col)) db.exec(`ALTER TABLE skills ADD COLUMN ${col} ${def}`);
+      }
+    },
+  },
+  {
+    version: 4, description: 'registry_entries table',
+    up: db => db.exec(`
+      CREATE TABLE IF NOT EXISTS registry_entries (
+        id TEXT PRIMARY KEY,
+        trust_level TEXT DEFAULT 'unknown',
+        downloads INTEGER DEFAULT 0,
+        rating REAL DEFAULT 0,
+        rating_count INTEGER DEFAULT 0,
+        popularity REAL DEFAULT 0,
+        last_update TEXT
+      );
+    `),
+  },
+  {
+    version: 5, description: 'convert TEXT embeddings to Float32 BLOB',
+    up: db => {
+      const textEmbeddings = db.prepare("SELECT COUNT(*) as n FROM chunks WHERE typeof(embedding) = 'text'").get();
+      if (textEmbeddings?.n > 0) {
+        const rows = db.prepare("SELECT rowid, embedding FROM chunks WHERE typeof(embedding) = 'text'").all();
+        const upd = db.prepare('UPDATE chunks SET embedding = ? WHERE rowid = ?');
+        db.transaction(() => {
+          for (const row of rows) {
+            const vec = JSON.parse(row.embedding);
+            upd.run(Buffer.from(new Float32Array(vec).buffer), row.rowid);
+          }
+        })();
+        console.error(`[PromptGraph] Migrated ${textEmbeddings.n} embeddings TEXT→BLOB`);
+      }
+    },
+  },
+]
+
+function getSchemaVersion(db) {
+  try {
+    return db.prepare('SELECT MAX(version) as v FROM _schema_version').get().v || 0
+  } catch {
+    return 0
   }
+}
 
-  // migrate: add registry metadata columns
-  if (!cols.includes('version')) {
-    db.exec('ALTER TABLE skills ADD COLUMN version TEXT');
-  }
-  if (!cols.includes('author')) {
-    db.exec('ALTER TABLE skills ADD COLUMN author TEXT');
-  }
-  if (!cols.includes('license')) {
-    db.exec('ALTER TABLE skills ADD COLUMN license TEXT');
-  }
-  if (!cols.includes('updated_at')) {
-    db.exec('ALTER TABLE skills ADD COLUMN updated_at TEXT');
-  }
-  if (!cols.includes('downloads')) {
-    db.exec('ALTER TABLE skills ADD COLUMN downloads INTEGER DEFAULT 0');
-  }
-  if (!cols.includes('verified')) {
-    db.exec('ALTER TABLE skills ADD COLUMN verified INTEGER DEFAULT 0');
-  }
-  if (!cols.includes('trust_level')) {
-    db.exec('ALTER TABLE skills ADD COLUMN trust_level TEXT DEFAULT \'unknown\'');
-  }
-  if (!cols.includes('rating')) {
-    db.exec('ALTER TABLE skills ADD COLUMN rating REAL DEFAULT 0');
-  }
-  if (!cols.includes('rating_count')) {
-    db.exec('ALTER TABLE skills ADD COLUMN rating_count INTEGER DEFAULT 0');
-  }
-  if (!cols.includes('popularity')) {
-    db.exec('ALTER TABLE skills ADD COLUMN popularity REAL DEFAULT 0');
-  }
-  if (!cols.includes('last_update')) {
-    db.exec('ALTER TABLE skills ADD COLUMN last_update TEXT');
-  }
+function runMigrations(db) {
+  const current = getSchemaVersion(db)
+  const pending = MIGRATIONS.filter(m => m.version > current).sort((a, b) => a.version - b.version)
+  if (!pending.length) return
 
-  // migrate: registry entries metadata table
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS registry_entries (
-      id TEXT PRIMARY KEY,
-      trust_level TEXT DEFAULT 'unknown',
-      downloads INTEGER DEFAULT 0,
-      rating REAL DEFAULT 0,
-      rating_count INTEGER DEFAULT 0,
-      popularity REAL DEFAULT 0,
-      last_update TEXT
-    );
-  `);
+  db.exec(`CREATE TABLE IF NOT EXISTS _schema_version (version INTEGER PRIMARY KEY, description TEXT, applied_at TEXT)`)
 
-  // migrate: convert JSON text embeddings to Float32 BLOB (one-time, ~10x smaller)
-  const textEmbeddings = db.prepare("SELECT COUNT(*) as n FROM chunks WHERE typeof(embedding) = 'text'").get();
-  if (textEmbeddings?.n > 0) {
-    const rows = db.prepare("SELECT rowid, embedding FROM chunks WHERE typeof(embedding) = 'text'").all();
-    const upd = db.prepare('UPDATE chunks SET embedding = ? WHERE rowid = ?');
+  for (const migration of pending) {
     db.transaction(() => {
-      for (const row of rows) {
-        const vec = JSON.parse(row.embedding);
-        upd.run(Buffer.from(new Float32Array(vec).buffer), row.rowid);
-      }
-    })();
-    console.error(`[PromptGraph] Migrated ${textEmbeddings.n} embeddings TEXT→BLOB`);
+      migration.up(db)
+      db.prepare('INSERT INTO _schema_version (version, description, applied_at) VALUES (?, ?, ?)').run(
+        migration.version, migration.description, new Date().toISOString()
+      )
+    })()
+    console.error(`[PromptGraph] DB migrated to v${migration.version}: ${migration.description}`)
   }
+}
 
+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');
+  runMigrations(db);
   return db;
 }
 

package/github-import.js

@@ -25,21 +25,22 @@ function getRepoStats(ownerRepo) {
   return repoStats.get(ownerRepo)
 }
 
-function streamDownload(url, maxSize = MAX_DOWNLOAD_SIZE) {
+function streamDownload(url, maxSize = MAX_DOWNLOAD_SIZE, redirects = 0) {
+  if (redirects > 5) return Promise.reject(new Error('Too many redirects'))
   return new Promise((res, rej) => {
     const token = process.env.GITHUB_TOKEN;
     const headers = { 'User-Agent': 'promptgraph-mcp' };
     if (token && url.startsWith('https://raw.')) headers['Authorization'] = `Bearer ${token}`;
     const req = https.get(url, { headers }, r => {
       if (r.statusCode >= 300 && r.statusCode < 400 && r.headers.location)
-        return streamDownload(r.headers.location, maxSize).then(res, rej);
+        return streamDownload(r.headers.location, maxSize, redirects + 1).then(res, rej);
       if (r.statusCode !== 200) { r.resume(); return rej(new Error(`HTTP ${r.statusCode}`)); }
       const cl = parseInt(r.headers['content-length'], 10);
       if (!isNaN(cl) && cl > maxSize) {
         r.resume();
         return rej(new Error(`Content-Length ${cl} exceeds max ${maxSize}`));
       }
-      let d = ''
+      const chunks = []
       let total = 0
       r.setEncoding('utf8')
       r.on('data', c => {
@@ -48,15 +49,16 @@ function streamDownload(url, maxSize = MAX_DOWNLOAD_SIZE) {
           r.destroy()
           return rej(new Error(`Download exceeded ${maxSize} bytes`))
         }
-        d += c
+        chunks.push(c)
       })
-      r.on('end', () => res(d))
+      r.on('end', () => res(chunks.join('')))
     })
     req.on('error', rej)
   })
 }
 
-async function httpsGet(url) {
+async function httpsGet(url, redirects = 0) {
+  if (redirects > 5) return Promise.reject(new Error('Too many redirects'))
   await githubRateLimiter.acquire()
   const token = process.env.GITHUB_TOKEN;
   const headers = { 'User-Agent': 'promptgraph-mcp' };
@@ -64,9 +66,9 @@ async function httpsGet(url) {
   return new Promise((res, rej) => {
     const req = https.get(url, { headers }, r => {
       if (r.statusCode >= 300 && r.statusCode < 400 && r.headers.location)
-        return httpsGet(r.headers.location).then(res, rej);
+        return httpsGet(r.headers.location, redirects + 1).then(res, rej);
       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);
   });