promptgraph-mcp 2.7.1 → 2.8.1

package/commands/marketplace.js

@@ -25,7 +25,7 @@ export default async function handler(args, bin) {
     error('marketplace TUI requires an interactive terminal');
     process.exit(1);
   }
-  const { browseMarketplace, browseBundles, installSkill, installBundle } = await import('../marketplace.js');
+  const { browseMarketplace, browseBundles, installSkill, installBundle, installBundleBg, validateAndPruneMarketplace } = 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');
@@ -81,30 +81,32 @@ export default async function handler(args, bin) {
   const { loadConfig: _lcR, saveConfig: _scR, SKILLS_STORE_DIR: _ssR } = await import('../config.js');
   const { getDb: _getDbR } = await import('../db.js');
 
-  const { validateAndPruneMarketplace } = await import('../marketplace.js');
-
   await runTUI(
     Array.isArray(skills) ? skills : [],
     bundlesWithCounts,
-    async (item) => {
+    async (item, onStatus) => {
       if (item.type === 'bundle') {
-        const r = await installBundle(item.id);
-        if (r?.error) throw new Error(r.error);
-        installedSet.add(item.id);
-        // Update skill count on the bundle object to reflect real survivors
-        const { getCachedCount: getCount } = await import('../bundle-counts.js');
-        const cached = getCount(item.repo_url);
-        if (cached !== null) item.skillCount = cached;
+        const r = await installBundleBg(item.id, async (err, result) => {
+          if (err) { onStatus(false, err.message?.slice(0, 60) || 'Install failed'); return; }
+          installedSet.add(item.id);
+          const { getCachedCount } = await import('../bundle-counts.js');
+          const cached = getCachedCount(item.repo_url);
+          if (cached !== null) item.skillCount = cached;
+          validateAndPruneMarketplace();
+          onStatus(true, `Installed ${item.name}`);
+        });
+        if (r?.error) {
+          if (!r.dedup) onStatus(false, r.error.slice(0, 60));
+          return;
+        }
+        onStatus(null, `Queued ${item.name}…`);
       } else {
         const r = await installSkill(item.code || item.id);
-        if (r?.error) throw new Error(r.error);
+        if (r?.error) { onStatus(false, r.error.slice(0, 60)); return; }
         installedSet.add(item.id);
         if (item.code) installedSet.add(item.code);
-      }
-      // After every install, prune invalid files marketplace-wide
-      const pruneResult = validateAndPruneMarketplace();
-      if (pruneResult.removed.length > 0) {
-        console.log(`Pruned ${pruneResult.removed.length} invalid files from marketplace.`);
+        validateAndPruneMarketplace();
+        onStatus(true, `Installed ${item.name}`);
       }
     },
     installedSet,

package/github-import.js

@@ -617,3 +617,129 @@ export async function importFromGitHub(repoUrl) {
   await indexSource(skillsDir, repoSource);
   console.log(`Done! Imported from ${repoName}/${label}`);
 }
+
+// ── light version (no git clone) ───────────────────────────────────────────────
+
+const SKIP_DOCS_RE = /^(readme|license|changelog|contributing|code.?of.?conduct|security|authors|credits|install|faq|index|overview|summary|todo|notes|template|copying|warranty|funding|roadmap|claude|bugs?\b|feature.?request)/i;
+
+export async function importFromGitHubLight(repoUrl) {
+  if (!repoUrl) throw new Error('Missing repoUrl');
+
+  const url = repoUrl.startsWith('http') ? repoUrl : `https://github.com/${repoUrl}`;
+  const ownerRepo = url.replace(/^https?:\/\/github\.com\//, '').replace(/\.git$/, '');
+  const repoName = ownerRepo.replace('/', '-');
+  const destBase = path.join(SKILLS_STORE_DIR, 'github', repoName);
+
+  const ok = await repoExists(ownerRepo);
+  if (!ok) throw new Error(`Repository not found (404): ${url}`);
+
+  const detected = await detectSkillsDirFromAPI(ownerRepo);
+  const subdir = detected?.subdir || null;
+
+  let branch = 'main';
+  try {
+    const repoJson = await httpsGet(`https://api.github.com/repos/${ownerRepo}`);
+    branch = JSON.parse(repoJson).default_branch || 'main';
+  } catch {}
+
+  let mdFiles;
+  if (subdir) {
+    const treeJson = await httpsGet(`https://api.github.com/repos/${ownerRepo}/git/trees/HEAD?recursive=1`);
+    const tree = JSON.parse(treeJson);
+    const prefix = subdir + '/';
+    mdFiles = (tree.tree || [])
+      .filter(f => f.type === 'blob' && f.path.startsWith(prefix) && f.path.endsWith('.md'))
+      .map(f => ({
+        relativePath: f.path.replace(prefix, ''),
+        fullPath: f.path,
+        download_url: `https://raw.githubusercontent.com/${ownerRepo}/${branch}/${f.path}`,
+      }));
+  } else {
+    const json = await httpsGet(`https://api.github.com/repos/${ownerRepo}/contents`);
+    const entries = JSON.parse(json);
+    mdFiles = entries
+      .filter(e => e.type === 'file' && e.name.endsWith('.md'))
+      .map(e => ({
+        relativePath: e.name,
+        fullPath: e.name,
+        download_url: e.download_url,
+      }));
+  }
+
+  if (mdFiles.length === 0) throw new Error(`No .md files found in ${ownerRepo}`);
+
+  const beforeFilter = mdFiles.length;
+  mdFiles = mdFiles.filter(f => !SKIP_DOCS_RE.test(f.relativePath.replace(/\.md$/i, '')));
+  if (mdFiles.length === 0) throw new Error(`All ${beforeFilter} .md files filtered as docs (README, LICENSE, etc.)`);
+
+  if (fs.existsSync(destBase)) fs.rmSync(destBase, { recursive: true, force: true });
+  fs.mkdirSync(destBase, { recursive: true });
+
+  let downloaded = 0;
+  for (const file of mdFiles) {
+    const destPath = path.join(destBase, file.fullPath);
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    try {
+      const content = await streamDownload(file.download_url);
+      fs.writeFileSync(destPath, content);
+      downloaded++;
+    } catch {
+      // skip failed downloads
+    }
+  }
+
+  if (downloaded === 0) {
+    fs.rmSync(destBase, { recursive: true, force: true });
+    throw new Error('Failed to download any files');
+  }
+
+  const allMd = globSync(`${destBase}/**/*.md`);
+  let removed = 0;
+  for (const fp of allMd) {
+    if (!isSkillFile(fp)) { try { fs.unlinkSync(fp); removed++; } catch {} }
+  }
+  if (removed > 0) removeEmptyDirs(destBase);
+
+  const remaining = globSync(`${destBase}/**/*.md`);
+  let removedV = 0;
+  for (const fp of remaining) {
+    const v = validateSkill(fp);
+    if (!v.ok) { try { fs.unlinkSync(fp); removedV++; } catch {} }
+  }
+  if (removedV > 0) removeEmptyDirs(destBase);
+
+  await classifierCleanup(destBase);
+
+  const realCount = globSync(`${destBase}/**/*.md`).length;
+  const cacheKey = url.replace(/\.git$/, '');
+  const cachePath = path.join(PROMPTGRAPH_DIR, 'skill-counts.json');
+  try {
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8') || '{}');
+    cache[cacheKey] = { count: realCount, ts: Date.now() };
+    fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+  } catch {}
+
+  if (realCount < 1) {
+    fs.rmSync(destBase, { recursive: true, force: true });
+    throw new Error('No valid skills in repo — all files were filtered out');
+  }
+
+  const { dir: localDir, label: localLabel } = detectSkillsDirLocal(destBase);
+  const skillsDir = subdir ? path.join(destBase, subdir) : localDir;
+  const label = subdir || localLabel;
+  const mdFilesInSkills = globSync(`${skillsDir}/**/*.md`);
+
+  const config = loadConfig();
+  const repoSource = `github:${repoName}`;
+  if (!config.sources.find(s => s.dir === skillsDir)) {
+    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();
+  await indexSource(skillsDir, repoSource);
+  console.log(`Done! Imported from ${repoName}/${label} (${realCount} skills, no git clone)`);
+}

package/marketplace.js

@@ -8,7 +8,7 @@ import { getDb } from './db.js';
 import { globSync } from 'glob';
 import { validateSkill, validateBundle } from './validator.js';
 import { loadConfig, saveConfig, PROMPTGRAPH_DIR, SKILLS_STORE_DIR } from './config.js';
-import { importFromGitHub, validateRepoSkills } from './github-import.js';
+import { importFromGitHubLight, validateRepoSkills } from './github-import.js';
 import { isSkillFile } from './parser.js';
 
 const REGISTRY_URL = 'https://raw.githubusercontent.com/NeiP4n/promptgraph-registry/main/registry.json';
@@ -353,67 +353,126 @@ function ensureMarketplaceSource() {
   }
 }
 
-export async function installBundle(bundleId) {
+// ── helpers extracted from installBundle ─────────────────────────────────────
+
+async function _findBundle(bundleId) {
+  const text = await fetchText(REGISTRY_URL);
+  const registry = JSON.parse(text);
+  const q = String(bundleId).trim().toLowerCase();
+  const validSkills = (registry.skills || []).filter(s => validateRegistryEntry(s).ok);
+  const bundle = (registry.bundles || []).filter(b => validateRegistryEntry(b).ok).find(b =>
+    (b.code || codeFor(b.id)).toLowerCase() === q || b.id?.toLowerCase() === q || b.name?.toLowerCase() === q
+  );
+  if (!bundle) return { error: `No bundle matching "${bundleId}"` };
+  return { bundle, validSkills };
+}
+
+async function _execRepoInstall(bundle) {
   try {
-    const text = await fetchText(REGISTRY_URL);
-    const registry = JSON.parse(text);
-    const q = String(bundleId).trim().toLowerCase();
-    const validSkills = (registry.skills || []).filter(s => validateRegistryEntry(s).ok);
-    const bundle = (registry.bundles || []).filter(b => validateRegistryEntry(b).ok).find(b =>
-      (b.code || codeFor(b.id)).toLowerCase() === q || b.id?.toLowerCase() === q || b.name?.toLowerCase() === q
-    );
-    if (!bundle) return { error: `No bundle matching "${bundleId}"` };
-
-    if (bundle.repo_url) {
-      try {
-        await importFromGitHub(bundle.repo_url);
-      } catch (e) {
-        if (e.message && e.message.includes('No valid skills')) {
-          markDeadRepo(bundle.repo_url);
-        }
-        throw e;
-      }
-      // Update skill count cache with real on-disk count (post-filters)
-      const real = localSkillCount(bundle.repo_url);
-      if (real !== null) {
-        const cache = readSkillCountCache();
-        cache[bundle.repo_url] = { count: real, ts: Date.now() };
-        writeSkillCountCache(cache);
-      }
-      return { success: true, bundle: bundle.name, type: 'repo_import', repo_url: bundle.repo_url };
-    }
+    await importFromGitHubLight(bundle.repo_url);
+  } catch (e) {
+    if (e.message && e.message.includes('No valid skills')) markDeadRepo(bundle.repo_url);
+    throw e;
+  }
+  const real = localSkillCount(bundle.repo_url);
+  if (real !== null) {
+    const cache = readSkillCountCache();
+    cache[bundle.repo_url] = { count: real, ts: Date.now() };
+    writeSkillCountCache(cache);
+  }
+  return { success: true, bundle: bundle.name, type: 'repo_import', repo_url: bundle.repo_url };
+}
 
-    fs.mkdirSync(SKILLS_DIR, { recursive: true });
-    ensureMarketplaceSource();
-    const installed = [];
-    const failed = [];
-
-    const delay = (ms) => new Promise(r => setTimeout(r, ms));
-    for (const skillId of bundle.skills || []) {
-      const skill = validSkills.find(s => s.id === skillId);
-      if (!skill?.raw_url) { failed.push(skillId); continue; }
-      try {
-        if (installed.length > 0) await delay(300); // rate limit: 300ms between requests
-        const content = await fetchText(skill.raw_url);
-        const dest = path.join(SKILLS_DIR, `${skillId}.md`);
-        const resolvedDest = path.resolve(dest);
-        if (!resolvedDest.startsWith(path.resolve(SKILLS_DIR))) {
-          failed.push(skillId); continue;
-        }
-        const v = writeSkillAtomic(dest, content);
-        if (!v.ok) { failed.push(skillId); continue; }
-        installed.push(skillId);
-      } catch {
-        failed.push(skillId);
-      }
-    }
+async function _execSkillsInstall(bundle, validSkills) {
+  fs.mkdirSync(SKILLS_DIR, { recursive: true });
+  ensureMarketplaceSource();
+  const installed = [];
+  const failed = [];
+  const delay = (ms) => new Promise(r => setTimeout(r, ms));
+  for (const skillId of bundle.skills || []) {
+    const skill = validSkills.find(s => s.id === skillId);
+    if (!skill?.raw_url) { failed.push(skillId); continue; }
+    try {
+      if (installed.length > 0) await delay(300);
+      const content = await fetchText(skill.raw_url);
+      const dest = path.join(SKILLS_DIR, `${skillId}.md`);
+      const resolvedDest = path.resolve(dest);
+      if (!resolvedDest.startsWith(path.resolve(SKILLS_DIR))) { failed.push(skillId); continue; }
+      const v = writeSkillAtomic(dest, content);
+      if (!v.ok) { failed.push(skillId); continue; }
+      installed.push(skillId);
+    } catch { failed.push(skillId); }
+  }
+  return { success: true, bundle: bundle.name, installed, failed, dir: SKILLS_DIR };
+}
 
-    return { success: true, bundle: bundle.name, installed, failed, dir: SKILLS_DIR };
+export async function installBundle(bundleId) {
+  try {
+    const found = await _findBundle(bundleId);
+    if (found.error) return { error: found.error };
+    const { bundle, validSkills } = found;
+    return bundle.repo_url
+      ? await _execRepoInstall(bundle)
+      : await _execSkillsInstall(bundle, validSkills);
   } catch (e) {
     return { error: e.message };
   }
 }
 
+// ── Background install queue ──────────────────────────────────────────────────
+// Allows the TUI to queue multiple installs without blocking.
+
+const _bgQueue = [];
+let _bgRunning = false;
+let _bgCurrentId = null;
+const _bgPendingKeys = new Set();
+
+async function _bgProcess() {
+  if (_bgRunning) return;
+  _bgRunning = true;
+  while (_bgQueue.length > 0) {
+    const { bundle, validSkills, onDone, _dedupKey } = _bgQueue.shift();
+    if (_dedupKey) _bgPendingKeys.delete(_dedupKey);
+    _bgCurrentId = bundle.id;
+    try {
+      const result = bundle.repo_url
+        ? await _execRepoInstall(bundle)
+        : await _execSkillsInstall(bundle, validSkills);
+      await onDone?.(null, result);
+    } catch (e) {
+      await onDone?.(e, null);
+    } finally {
+      _bgCurrentId = null;
+    }
+  }
+  _bgRunning = false;
+}
+
+// Install a bundle in the background, returning immediately.
+// The actual work is serialized through an internal queue.
+// onDone(err, result) is called when the queue finishes processing this bundle.
+export async function installBundleBg(bundleId, onDone) {
+  const q = String(bundleId).trim().toLowerCase();
+  // Synchronous dedup check BEFORE any await — prevents race on double-Enter
+  if (_bgPendingKeys.has(q)) {
+    return { dedup: true, error: `"${bundleId}" is already queued or installing` };
+  }
+  _bgPendingKeys.add(q);
+
+  const found = await _findBundle(bundleId);
+  if (found.error) { _bgPendingKeys.delete(q); return found; }
+  const { bundle, validSkills } = found;
+
+  if (_bgCurrentId === bundle.id || _bgQueue.some(e => e.bundle.id === bundle.id)) {
+    _bgPendingKeys.delete(q);
+    return { dedup: true, error: `"${bundle.name}" is already queued or installing` };
+  }
+
+  _bgQueue.push({ bundle, validSkills, onDone, _dedupKey: q });
+  _bgProcess();
+  return { queued: true, id: bundle.id, name: bundle.name };
+}
+
 function ghPublish(filePath, desc) {
   try {
     const result = spawnSync('gh', ['gist', 'create', filePath, '--desc', desc, '--public'], { encoding: 'utf8' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptgraph-mcp",
-  "version": "2.7.1",
+  "version": "2.8.1",
   "files": [
     "*.js",
     "commands/",

package/tui.js

@@ -116,12 +116,12 @@ function render(state, installedSet = new Set()) {
   write(searchLabel + searchVal + CLEAR_EOL + '\n');
 
   // Row 4: separator (with optional status inline or spinner)
-  if (state.installing) {
-    const frame = SPINNER_FRAMES[Math.floor(Date.now() / 120) % SPINNER_FRAMES.length];
-    write(dim('─'.repeat(4)) + magenta(` ${frame} Installing… `) + CLEAR_EOL + '\n');
-  } else if (status) {
-    const msg = status.ok ? green(' ✓ ' + status.msg) : red(' ✗ ' + status.msg);
-    write(dim('─'.repeat(4)) + msg + CLEAR_EOL + '\n');
+  if (status) {
+    let line;
+    if (status.ok === true) line = green(' ✓ ' + status.msg);
+    else if (status.ok === false) line = red(' ✗ ' + status.msg);
+    else line = cyan(' ⟳ ' + (status.msg || ''));
+    write(dim('─'.repeat(4)) + line + CLEAR_EOL + '\n');
   } else {
     write(dim('─'.repeat(cols)) + CLEAR_EOL + '\n');
   }
@@ -248,7 +248,6 @@ export async function runTUI(allSkills, allBundles, installFn, installedSet = ne
     scroll: 0,
     items: allItems,
     status: null,
-    installing: false,
   };
 
   function refresh(q, t) {
@@ -391,21 +390,13 @@ export async function runTUI(allSkills, allBundles, installFn, installedSet = ne
 
     if (key.name === 'return' || key.name === 'i') {
       const sel = state.items[state.cursor];
-      if (!sel || state.installing) return;
-      state.installing = true;
-      // Live spinner — keeps rendering during long installs
-      const spinInterval = setInterval(() => render(state, installedSet), 120);
-      render(state, installedSet);
-      try {
-        await installFn(sel);
-        clearInterval(spinInterval);
-        setStatus(true, `Installed ${sel.id}`);
-      } catch (e) {
-        clearInterval(spinInterval);
-        setStatus(false, e.message.slice(0, 60));
-      } finally {
-        state.installing = false;
-      }
+      if (!sel) return;
+      // Fire install in background — TUI stays responsive for queuing more
+      installFn(sel, (ok, msg) => {
+        setStatus(ok, msg);
+      }).catch(e => {
+        setStatus(false, e.message?.slice(0, 60) || 'Install failed');
+      });
       return;
     }