promptgraph-mcp 2.2.7 → 2.2.9

package/github-import.js

@@ -1,43 +1,121 @@
 import { spawnSync } from 'child_process';
 import path from 'path';
-import os from 'os';
 import fs from 'fs';
 import https from 'https';
 import { globSync } from 'glob';
 import { indexAll, indexSource } from './indexer.js';
 import { loadConfig, saveConfig, SKILLS_STORE_DIR } from './config.js';
 
-function repoExists(repoUrl) {
-  const owner_repo = repoUrl.startsWith('http')
-    ? repoUrl.replace(/^https?:\/\/github\.com\//, '').replace(/\.git$/, '')
-    : repoUrl;
+const SKILL_DIRS = ['skills', 'commands', 'prompts', 'agents', 'skills-store', 'slash-commands', 'custom-commands', 'templates'];
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function httpsGet(url) {
+  return new Promise((res, rej) => {
+    const req = https.get(url, { headers: { 'User-Agent': 'promptgraph-mcp' } }, r => {
+      if (r.statusCode >= 300 && r.statusCode < 400 && r.headers.location)
+        return httpsGet(r.headers.location).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));
+    });
+    req.on('error', rej);
+  });
+}
+
+function repoExists(ownerRepo) {
   return new Promise(resolve => {
     const req = https.request(
-      { host: 'github.com', path: `/${owner_repo}`, method: 'HEAD', headers: { 'User-Agent': 'promptgraph-mcp' } },
-      res => resolve(res.statusCode < 400)
+      { host: 'github.com', path: `/${ownerRepo}`, method: 'HEAD', headers: { 'User-Agent': 'promptgraph-mcp' } },
+      r => resolve(r.statusCode < 400)
     );
     req.on('error', () => resolve(false));
     req.end();
   });
 }
 
-// Directories likely to contain skills — checked in priority order
-const SKILL_DIRS = ['skills', 'commands', 'prompts', 'agents', 'skills-store', 'slash-commands', 'custom-commands', 'templates'];
+// Ask GitHub API which skill subdir exists (without cloning anything)
+async function detectSkillsDirFromAPI(ownerRepo) {
+  try {
+    const json = await httpsGet(`https://api.github.com/repos/${ownerRepo}/contents`);
+    const entries = JSON.parse(json);
+    const dirs = new Set(entries.filter(e => e.type === 'dir').map(e => e.name.toLowerCase()));
+    for (const d of SKILL_DIRS) {
+      if (dirs.has(d)) return d;
+    }
+  } catch {}
+  return null; // use repo root
+}
+
+function git(args, cwd, stdio = 'inherit') {
+  return spawnSync('git', args, { cwd, stdio });
+}
+
+// Clone only the skills subdir via sparse-checkout
+function sparseClone(url, dest, subdir) {
+  fs.mkdirSync(dest, { recursive: true });
+
+  // 1. init + add remote
+  if (git(['init'], dest, 'pipe').status !== 0) return false;
+  if (git(['remote', 'add', 'origin', url], dest, 'pipe').status !== 0) return false;
+
+  // 2. sparse-checkout config
+  git(['sparse-checkout', 'init', '--cone'], dest, 'pipe');
+  git(['sparse-checkout', 'set', subdir], dest, 'pipe');
+
+  // 3. fetch + checkout (depth=1)
+  const fetch = git(['fetch', '--depth=1', 'origin'], dest);
+  if (fetch.status !== 0) return false;
+
+  // Try HEAD, then main, then master
+  for (const branch of ['HEAD', 'main', 'master']) {
+    const r = git(['checkout', branch === 'HEAD' ? 'FETCH_HEAD' : branch], dest, 'pipe');
+    if (r.status === 0) return true;
+  }
+  return false;
+}
+
+// Update sparse repo — fetch + reset
+function sparseUpdate(dest, subdir) {
+  const fetch = git(['fetch', '--depth=1', 'origin'], dest);
+  if (fetch.status !== 0) return false;
 
-// Find the best subdirectory to index in the cloned repo.
-// Returns the subdir path if a known skills dir exists with 2+ .md files,
-// otherwise returns the repo root (full scan with isSkillFile filtering).
-function detectSkillsDir(repoRoot) {
+  // Ensure sparse-checkout still set correctly
+  git(['sparse-checkout', 'set', subdir], dest, 'pipe');
+
+  for (const ref of ['origin/HEAD', 'origin/main', 'origin/master']) {
+    const r = git(['reset', '--hard', ref], dest, 'pipe');
+    if (r.status === 0) return true;
+  }
+  return false;
+}
+
+// Fallback: full clone (when no subdir found)
+function fullClone(url, dest) {
+  if (fs.existsSync(dest)) {
+    const fetch = git(['fetch', '--depth=1', 'origin'], dest);
+    if (fetch.status !== 0) return false;
+    for (const ref of ['origin/HEAD', 'origin/main', 'origin/master']) {
+      if (git(['reset', '--hard', ref], dest, 'pipe').status === 0) return true;
+    }
+    return false;
+  }
+  return git(['clone', '--depth=1', url, dest]).status === 0;
+}
+
+// After clone: detect actual skills dir on disk
+function detectSkillsDirLocal(repoRoot) {
   for (const dir of SKILL_DIRS) {
     const candidate = path.join(repoRoot, dir);
     if (fs.existsSync(candidate)) {
       const files = globSync(`${candidate}/**/*.md`);
-      if (files.length >= 2) return { dir: candidate, auto: true, label: dir };
+      if (files.length >= 2) return { dir: candidate, label: dir, sparse: true };
     }
   }
-  return { dir: repoRoot, auto: false, label: '(root)' };
+  return { dir: repoRoot, label: '(root)', sparse: false };
 }
 
+// ── main export ───────────────────────────────────────────────────────────────
+
 export async function importFromGitHub(repoUrl) {
   if (!repoUrl) {
     console.error('Usage: promptgraph-mcp import <github-url-or-owner/repo>');
@@ -45,58 +123,76 @@ export async function importFromGitHub(repoUrl) {
   }
 
   const url = repoUrl.startsWith('http') ? repoUrl : `https://github.com/${repoUrl}`;
-  const repoName = url.split('/').slice(-2).join('-').replace('.git', '');
+  const ownerRepo = url.replace(/^https?:\/\/github\.com\//, '').replace(/\.git$/, '');
+  const repoName = ownerRepo.replace('/', '-');
   const dest = path.join(SKILLS_STORE_DIR, 'github', repoName);
 
-  if (!fs.existsSync(dest)) {
-    const exists = await repoExists(repoUrl);
+  const isNew = !fs.existsSync(dest);
+
+  if (isNew) {
+    const exists = await repoExists(ownerRepo);
     if (!exists) throw new Error(`Repository not found (404): ${url}`);
   }
 
   fs.mkdirSync(path.dirname(dest), { recursive: true });
 
-  if (fs.existsSync(dest)) {
-    console.log(`Updating ${repoName}...`);
-    // fetch + reset handles force-pushes and unrelated histories without re-cloning
-    const fetch = spawnSync('git', ['-C', dest, 'fetch', '--depth=1', 'origin'], { stdio: 'inherit' });
-    if (fetch.status !== 0) throw new Error(`git fetch failed for ${repoName}`);
-    const reset = spawnSync('git', ['-C', dest, 'reset', '--hard', 'origin/HEAD'], { stdio: 'pipe' });
-    if (reset.status !== 0) {
-      // fallback: try origin/main then origin/master
-      const main = spawnSync('git', ['-C', dest, 'reset', '--hard', 'origin/main'], { stdio: 'pipe' });
-      if (main.status !== 0) {
-        const master = spawnSync('git', ['-C', dest, 'reset', '--hard', 'origin/master'], { stdio: 'inherit' });
-        if (master.status !== 0) throw new Error(`git reset failed for ${repoName}`);
+  let skillsSubdir = null;
+  let cloneOk = false;
+
+  if (isNew) {
+    // Detect skills dir via API before cloning
+    console.log(`Detecting skills directory for ${ownerRepo}...`);
+    skillsSubdir = await detectSkillsDirFromAPI(ownerRepo);
+
+    if (skillsSubdir) {
+      console.log(`Sparse-cloning ${url} (${skillsSubdir}/ only)...`);
+      cloneOk = sparseClone(url, dest, skillsSubdir);
+      if (!cloneOk) {
+        // Sparse failed — fall back to full clone
+        console.log('Sparse-checkout failed, falling back to full clone...');
+        fs.rmSync(dest, { recursive: true, force: true });
+        cloneOk = fullClone(url, dest);
+        skillsSubdir = null;
       }
+    } else {
+      console.log(`Cloning ${url}...`);
+      cloneOk = fullClone(url, dest);
     }
+
+    if (!cloneOk) throw new Error(`Clone failed for ${url}`);
   } else {
-    console.log(`Cloning ${url}...`);
-    const cloneResult = spawnSync('git', ['clone', '--depth=1', url, dest], { stdio: 'inherit' });
-    if (cloneResult.status !== 0) throw new Error(`git clone failed for ${url}`);
+    console.log(`Updating ${repoName}...`);
+    // Detect existing sparse subdir
+    const isSparse = git(['sparse-checkout', 'list'], dest, 'pipe').status === 0;
+    const sparseList = isSparse
+      ? spawnSync('git', ['sparse-checkout', 'list'], { cwd: dest, encoding: 'utf8' }).stdout.trim()
+      : '';
+    skillsSubdir = sparseList.split('\n').find(l => SKILL_DIRS.includes(l.trim())) || null;
+
+    cloneOk = skillsSubdir
+      ? sparseUpdate(dest, skillsSubdir)
+      : fullClone(url, dest);
+    if (!cloneOk) throw new Error(`Update failed for ${repoName}`);
   }
 
-  const { dir: skillsDir, auto, label } = detectSkillsDir(dest);
+  const { dir: skillsDir, label } = detectSkillsDirLocal(dest);
   const mdFiles = globSync(`${skillsDir}/**/*.md`);
 
-  if (auto) {
-    console.log(`Auto-detected skills directory: ${label}/ (${mdFiles.length} .md files)`);
+  if (skillsSubdir) {
+    console.log(`Sparse-checkout: ${label}/ only (${mdFiles.length} .md files, no other repo files)`);
   } else {
-    console.log(`No skills/ dir found — scanning root (${mdFiles.length} .md files, non-skill files will be filtered)`);
+    console.log(`Full clone: scanning ${label} (${mdFiles.length} .md files)`);
   }
 
-  if (mdFiles.length < 1) {
-    console.warn('Warning: no .md files found');
-  }
+  if (mdFiles.length < 1) console.warn('Warning: no .md files found');
 
   const config = loadConfig();
   const repoSource = `github:${repoName}`;
   if (!config.sources.find(s => s.dir === skillsDir)) {
-    // Remove any old entry pointing at the full repo root if we now have a subdir
     const oldIdx = config.sources.findIndex(s => s.source === repoSource);
     if (oldIdx !== -1) config.sources.splice(oldIdx, 1);
     config.sources.push({ dir: skillsDir, source: repoSource });
     saveConfig(config);
-    console.log(`Indexing from: ${skillsDir}`);
   }
 
   console.log();

package/index.js

@@ -34,6 +34,7 @@ function showHelp() {
     ['import <owner/repo>', 'Import skills from GitHub'],
     ['status',              'Show installed skills, repos, and bundles'],
     ['marketplace',         'Interactive TUI: browse + search + install skills & bundles'],
+    ['bundle update [id]',  'Update all (or one) installed GitHub bundles'],
     ['validate <file.md>',  'Validate a skill before publishing'],
     ['doctor',              'Clean orphaned chunks/edges/ratings'],
     ['update',              'Update to the latest version from npm'],
@@ -329,6 +330,75 @@ if (args[0] === 'search') {
 }
 
 if (args[0] === 'bundle') {
+  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]; // optional: pg bundle update <id>
+    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$/, ''); // get repo root
+      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)}... `);
+
+      // Get current HEAD hash
+      const before = spawnSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).stdout.trim();
+
+      // Fetch + reset (same as install)
+      const fetch = spawnSync('git', ['-C', repoRoot, 'fetch', '--depth=1', 'origin'], { stdio: 'pipe' });
+      if (fetch.status !== 0) {
+        console.log(chalk.red('fetch failed'));
+        failed++;
+        continue;
+      }
+      const reset = spawnSync('git', ['-C', repoRoot, 'reset', '--hard', 'origin/HEAD'], { stdio: 'pipe' });
+      if (reset.status !== 0) {
+        spawnSync('git', ['-C', repoRoot, 'reset', '--hard', 'origin/main'], { stdio: 'pipe' });
+      }
+
+      const after = spawnSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).stdout.trim();
+
+      if (before === after) {
+        console.log(chalk.gray('already up to date'));
+        unchanged++;
+        continue;
+      }
+
+      // Count changed .md files
+      const diff = spawnSync('git', ['-C', repoRoot, 'diff', '--name-only', before, after], { encoding: 'utf8' });
+      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)})`));
+
+      // Reindex only this source — incremental hash check skips unchanged files
+      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]);

package/package.json

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