@mseep/core 3.0.0

package/lib/wizard/integration-detector.js

@@ -0,0 +1,41 @@
+// lib/wizard/integration-detector.js
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * Detects installed integrations and tools.
+ *
+ * @param {{ cwd?: string, home?: string }} opts - override for testing
+ * @returns {{ superpowers: boolean, ruflo: boolean, claudeCode: boolean }}
+ */
+export function detectIntegrations({ cwd = process.cwd(), home = os.homedir() } = {}) {
+  return {
+    superpowers: _detectSuperpowers(home),
+    ruflo: _detectRuflo(cwd, home),
+    claudeCode: _detectClaudeCode(home),
+  };
+}
+
+function _detectSuperpowers(home) {
+  const pluginsDir = path.join(home, '.claude', 'plugins');
+  if (!fs.existsSync(pluginsDir)) return false;
+  try {
+    return fs.readdirSync(pluginsDir).some(d => d.toLowerCase().includes('superpowers'));
+  } catch { return false; }
+}
+
+function _detectRuflo(cwd, home) {
+  const candidates = [
+    path.join(cwd,  'ruflo.config.js'),
+    path.join(cwd,  'ruflo.config.ts'),
+    path.join(cwd,  'ruflo.config.json'),
+    path.join(cwd,  '.ruflo'),
+    path.join(home, '.ruflo'),
+  ];
+  return candidates.some(p => fs.existsSync(p));
+}
+
+function _detectClaudeCode(home) {
+  return fs.existsSync(path.join(home, '.claude'));
+}

package/lib/wizard/project-detector.js

@@ -0,0 +1,146 @@
+// lib/wizard/project-detector.js
+import fs from 'fs';
+import path from 'path';
+
+const FILE_SIGNALS = [
+  { file: 'go.mod',           lang: 'go' },
+  { file: 'Cargo.toml',       lang: 'rust' },
+  { file: 'pom.xml',          lang: 'java' },
+  { file: 'build.gradle',     lang: 'java' },
+  { file: 'build.gradle.kts', lang: 'kotlin' },
+  { file: 'pyproject.toml',   lang: 'python' },
+  { file: 'requirements.txt', lang: 'python' },
+  { file: 'composer.json',    lang: 'php' },
+];
+
+const EXT_SIGNALS = {
+  '.kt': 'kotlin', '.kts': 'kotlin',
+  '.java': 'java',
+  '.py': 'python',
+  '.ts': 'typescript', '.tsx': 'typescript',
+  '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript',
+  '.rs': 'rust',
+  '.go': 'go',
+  '.rb': 'ruby',
+  '.swift': 'swift',
+  '.dart': 'dart',
+  '.cs': 'csharp',
+  '.php': 'php',
+};
+
+const FRAMEWORK_SIGNALS = {
+  python: { fastapi: 'FastAPI', django: 'Django', flask: 'Flask', pytest: 'testing' },
+  javascript: { express: 'Express', next: 'Next.js', react: 'React', vue: 'Vue', '@nestjs': 'NestJS', '@sveltejs/kit': 'SvelteKit', svelte: 'Svelte' },
+  typescript: { express: 'Express', next: 'Next.js', react: 'React', vue: 'Vue', '@nestjs': 'NestJS', '@sveltejs/kit': 'SvelteKit', svelte: 'Svelte' },
+  java: { 'springframework': 'Spring Boot', micronaut: 'Micronaut' },
+  kotlin: { 'springframework': 'Spring Boot', ktor: 'Ktor' },
+  php: { 'laravel/framework': 'Laravel', 'symfony/': 'Symfony', 'cakephp/cakephp': 'CakePHP' },
+};
+
+/**
+ * Scans cwd for language and framework signals.
+ * @returns {{ languages: string[], frameworks: string[], signals: string[] }}
+ */
+export function detect(cwd = process.cwd()) {
+  const languages = new Set();
+  const frameworks = new Set();
+  const signals = [];
+
+  // Check root-level file signals
+  for (const { file, lang } of FILE_SIGNALS) {
+    if (fs.existsSync(path.join(cwd, file))) {
+      languages.add(lang);
+      signals.push(file);
+    }
+  }
+
+  // Check one level deep for file signals (monorepo subdirectories)
+  try {
+    for (const entry of fs.readdirSync(cwd, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      for (const { file, lang } of FILE_SIGNALS) {
+        const subPath = path.join(cwd, entry.name, file);
+        if (fs.existsSync(subPath)) {
+          languages.add(lang);
+          signals.push(`${entry.name}/${file}`);
+        }
+      }
+    }
+  } catch { /* skip */ }
+
+  // Scan cwd + one level deep for extension signals
+  try {
+    for (const entry of fs.readdirSync(cwd, { withFileTypes: true })) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      const ext = path.extname(entry.name).toLowerCase();
+      if (EXT_SIGNALS[ext]) languages.add(EXT_SIGNALS[ext]);
+      if (entry.isDirectory()) {
+        try {
+          for (const sub of fs.readdirSync(path.join(cwd, entry.name))) {
+            const subExt = path.extname(sub).toLowerCase();
+            if (EXT_SIGNALS[subExt]) languages.add(EXT_SIGNALS[subExt]);
+          }
+        } catch { /* skip */ }
+      }
+    }
+  } catch { /* skip */ }
+
+  // Collect package.json paths (root + one level deep for monorepos)
+  const pkgPaths = [];
+  const rootPkg = path.join(cwd, 'package.json');
+  if (fs.existsSync(rootPkg)) pkgPaths.push(rootPkg);
+  try {
+    for (const entry of fs.readdirSync(cwd, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      const subPkg = path.join(cwd, entry.name, 'package.json');
+      if (fs.existsSync(subPkg)) pkgPaths.push(subPkg);
+    }
+  } catch { /* skip */ }
+
+  // Detect frameworks from all package.json files
+  for (const pkgPath of pkgPaths) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      for (const lang of ['javascript', 'typescript']) {
+        if (!languages.has(lang)) continue;
+        for (const [dep, label] of Object.entries(FRAMEWORK_SIGNALS[lang] ?? {})) {
+          if (Object.keys(deps).some(d => d === dep || d.startsWith(dep + '/'))) frameworks.add(label);
+        }
+      }
+      if (Object.keys(deps).includes('typescript')) languages.add('typescript');
+    } catch { /* skip */ }
+  }
+
+  // Collect text-based manifest paths (root + one level deep for monorepos)
+  const MANIFEST_FILES = ['requirements.txt', 'pyproject.toml', 'pom.xml', 'build.gradle', 'build.gradle.kts', 'composer.json'];
+  const manifestPaths = [];
+  for (const f of MANIFEST_FILES) {
+    const rootFile = path.join(cwd, f);
+    if (fs.existsSync(rootFile)) manifestPaths.push({ filePath: rootFile, lang: null });
+  }
+  try {
+    for (const entry of fs.readdirSync(cwd, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      for (const f of MANIFEST_FILES) {
+        const subFile = path.join(cwd, entry.name, f);
+        if (fs.existsSync(subFile)) manifestPaths.push({ filePath: subFile, lang: null });
+      }
+    }
+  } catch { /* skip */ }
+
+  // Detect Python / JVM frameworks from all manifest files
+  for (const lang of ['python', 'java', 'kotlin', 'php']) {
+    if (!languages.has(lang)) continue;
+    for (const { filePath } of manifestPaths) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8').toLowerCase();
+        for (const [dep, label] of Object.entries(FRAMEWORK_SIGNALS[lang] ?? {})) {
+          if (content.includes(dep.toLowerCase())) frameworks.add(label);
+        }
+      } catch { /* skip */ }
+    }
+  }
+
+  return { languages: [...languages], frameworks: [...frameworks], signals };
+}

package/lib/wizard/prompt.js

@@ -0,0 +1,221 @@
+// lib/wizard/prompt.js
+import * as clack from '@clack/prompts';
+import pc from 'picocolors';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createInterface } from 'node:readline';
+
+// ── Navigation legend ───────────────────────────────────────────────────────
+
+function legend(...items) {
+  return '\n  ' + items
+    .map(([key, action]) => `${pc.cyan(key)} ${pc.dim(action)}`)
+    .join(pc.dim('  ·  '));
+}
+
+export const LEGENDS = {
+  select:      () => legend(['↑↓', 'navigate'], ['enter', 'select']),
+  multiselect: () => legend(['↑↓', 'navigate'], ['space', 'toggle'], ['a', 'all'], ['enter', 'submit']),
+  confirm:     () => legend(['←→', 'switch'], ['enter', 'confirm']),
+};
+
+// ── Clack-based wizard session ───────────────────────────────────────────────
+
+export function createWizardUI() {
+  return {
+    intro(text) { clack.intro(text); },
+    outro(text) { clack.outro(text); },
+
+    async confirm(message, initial = true) {
+      const result = await clack.confirm({
+        message: message + LEGENDS.confirm(),
+        initialValue: initial,
+      });
+      if (clack.isCancel(result)) { clack.outro('Setup cancelled.'); process.exit(0); }
+      return result;
+    },
+
+    async text(message, placeholder) {
+      const result = await clack.text({
+        message,
+        placeholder,
+      });
+      if (clack.isCancel(result)) { clack.outro('Setup cancelled.'); process.exit(0); }
+      return result;
+    },
+
+    async select(message, options) {
+      const result = await clack.select({
+        message: message + LEGENDS.select(),
+        options,
+      });
+      if (clack.isCancel(result)) { clack.outro('Setup cancelled.'); process.exit(0); }
+      return result;
+    },
+
+    async multiselect(message, options, opts = {}) {
+      const result = await clack.multiselect({
+        message: message + LEGENDS.multiselect(),
+        options,
+        required: false,
+        cursorAt: opts.initialValues?.[0],
+        ...opts,
+      });
+      if (clack.isCancel(result)) { clack.outro('Setup cancelled.'); process.exit(0); }
+      return result;
+    },
+
+    spinner() { return clack.spinner(); },
+    log: clack.log,
+    isCancel: clack.isCancel,
+  };
+}
+
+// ── Gitignore helper ────────────────────────────────────────────────────────
+
+const BOOKLIB_GITIGNORE_ENTRIES = [
+  '.booklib/index/',
+  '.booklib/bm25.json',
+  '.booklib/sources/',
+  '.booklib/context-map.json',
+  '.booklib/version-cache.json',
+];
+
+/**
+ * Ensures derived BookLib files are in .gitignore.
+ * Only appends entries that aren't already present.
+ * Creates .gitignore if it doesn't exist and a .git dir is present.
+ * @param {string} cwd - Project root directory.
+ * @returns {string[]} List of entries that were added (empty if none needed).
+ */
+export function ensureBooklibGitignore(cwd) {
+  const gitDir = path.join(cwd, '.git');
+  const gitignorePath = path.join(cwd, '.gitignore');
+
+  // Only touch .gitignore in git repos
+  if (!fs.existsSync(gitDir) && !fs.existsSync(gitignorePath)) return [];
+
+  const existing = fs.existsSync(gitignorePath)
+    ? fs.readFileSync(gitignorePath, 'utf8')
+    : '';
+
+  const missing = BOOKLIB_GITIGNORE_ENTRIES.filter(entry => !existing.includes(entry));
+  if (missing.length === 0) return [];
+
+  const block = '\n# BookLib (derived/cached — rebuilt by `booklib index`)\n'
+    + missing.join('\n') + '\n';
+
+  fs.appendFileSync(gitignorePath, block);
+  return missing;
+}
+
+// ── Legacy standalone functions (used outside wizard) ────────────────────────
+
+function readLine() {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const onSigint = () => { rl.close(); process.exit(130); };
+    process.once('SIGINT', onSigint);
+    rl.once('line', line => {
+      process.removeListener('SIGINT', onSigint);
+      rl.close();
+      resolve(line.trim());
+    });
+    rl.once('close', () => {
+      process.removeListener('SIGINT', onSigint);
+      resolve('');
+    });
+  });
+}
+
+export async function confirm(question, defaultY = true) {
+  process.stdout.write(`${question} [${defaultY ? 'Y/n' : 'y/N'}] `);
+  const answer = await readLine();
+  if (!answer) return defaultY;
+  return answer.toLowerCase().startsWith('y');
+}
+
+export async function multiSelect(question, choices) {
+  process.stdout.write(`\n${question}\n\n`);
+  choices.forEach((c, i) => {
+    const desc = c.description ? `  — ${c.description}` : '';
+    process.stdout.write(`  ${i + 1}. ${c.label}${desc}\n`);
+  });
+  process.stdout.write(`\n  [A] All (recommended)  [1,2,3...] pick  [S] Skip\n\n  > `);
+  const answer = await readLine();
+  if (!answer) return process.stdin.isTTY ? choices.map((_, i) => i) : [];
+  if (answer.toLowerCase() === 'a') return choices.map((_, i) => i);
+  if (answer.toLowerCase() === 's') return [];
+  return answer.split(',')
+    .map(n => parseInt(n.trim(), 10) - 1)
+    .filter(n => !isNaN(n) && n >= 0 && n < choices.length);
+}
+
+export function formatProgress(current, total, width = 30) {
+  const clamped = Math.min(current, total);
+  const filled = total > 0 ? Math.round((clamped / total) * width) : 0;
+  const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(Math.max(0, width - filled));
+  return `[${bar}] ${clamped}/${total}`;
+}
+
+export function progressBar(total) {
+  let current = 0;
+  function render() { process.stdout.write(`\r  ${formatProgress(current, total)}`); }
+  render();
+  return {
+    tick(n = 1) { current = Math.min(current + n, total); render(); },
+    done() { process.stdout.write('\n'); },
+  };
+}
+
+export async function readText(promptText) {
+  process.stdout.write(promptText);
+  return readLine();
+}
+
+export function sep(char = '\u2500', width = 45) {
+  return char.repeat(width);
+}
+
+export function createSession(opts = {}) {
+  const rl = createInterface({
+    input: opts.input ?? process.stdin,
+    output: opts.output ?? process.stdout,
+  });
+  function question(prompt) {
+    return new Promise(resolve => {
+      rl.question(prompt, answer => resolve(answer.trim()));
+    });
+  }
+  return {
+    async confirm(text, defaultY = true) {
+      const answer = await question(`${text} [${defaultY ? 'Y/n' : 'y/N'}] `);
+      if (!answer) return defaultY;
+      return answer.toLowerCase().startsWith('y');
+    },
+    async readText(prompt) { return question(prompt); },
+    async multiSelect(title, choices) {
+      process.stdout.write(`\n${title}\n\n`);
+      choices.forEach((c, i) => {
+        const desc = c.description ? `  — ${c.description}` : '';
+        process.stdout.write(`  ${i + 1}. ${c.label}${desc}\n`);
+      });
+      process.stdout.write(`\n  [A] All  [1,2,3...] pick  [S] Skip\n\n`);
+      const answer = await question('  > ');
+      if (!answer) return choices.map((_, i) => i);
+      if (answer.toLowerCase() === 'a') return choices.map((_, i) => i);
+      if (answer.toLowerCase() === 's') return [];
+      return answer.split(',')
+        .map(n => parseInt(n.trim(), 10) - 1)
+        .filter(n => !isNaN(n) && n >= 0 && n < choices.length);
+    },
+    async numberedInput(prompt, maxN) {
+      const answer = await question(prompt);
+      if (!answer) return [];
+      return answer.split(',')
+        .map(n => parseInt(n.trim(), 10) - 1)
+        .filter(n => !isNaN(n) && n >= 0 && n < maxN);
+    },
+    close() { rl.close(); },
+  };
+}

package/lib/wizard/registry-embeddings.js

@@ -0,0 +1,107 @@
+// lib/wizard/registry-embeddings.js
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { BookLibSearcher } from '../engine/searcher.js';
+
+const PACKAGE_ROOT = path.resolve(fileURLToPath(import.meta.url), '..', '..', '..');
+const CACHE_PATH   = path.join(os.homedir(), '.booklib', 'registry-embeddings.json');
+
+/**
+ * Extracts description from SKILL.md frontmatter.
+ * Exported for testing.
+ */
+export function extractDescription(content) {
+  // Try inline: description: some text on one line
+  const inline = content.match(/^description:\s+(?!>)(.+)$/m);
+  if (inline?.[1]?.trim()) return inline[1].trim();
+
+  // Try YAML folded scalar: description: >\n  line one\n  line two
+  const folded = content.match(/^description:\s*>\s*\n((?:[ \t]+[^\n]*\n?)+)/m);
+  if (folded) {
+    return folded[1]
+      .split('\n')
+      .map(l => l.trim())
+      .filter(Boolean)
+      .join(' ')
+      .slice(0, 200);
+  }
+
+  return null;
+}
+
+/**
+ * Returns unified skill catalog: bundled skills + community registry.
+ * Each entry: { name, description, source: 'bundled'|'registry', entry? }
+ */
+export function loadSkillCatalog() {
+  const skills = [];
+  const seen = new Set();
+
+  // 1. Bundled skills from package's skills/ directory
+  const skillsDir = path.join(PACKAGE_ROOT, 'skills');
+  try {
+    for (const name of fs.readdirSync(skillsDir)) {
+      const skillFile = path.join(skillsDir, name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+      const content = fs.readFileSync(skillFile, 'utf8');
+      const description = extractDescription(content);
+      if (description && !seen.has(name)) {
+        skills.push({ name, description, source: 'bundled' });
+        seen.add(name);
+      }
+    }
+  } catch { /* skip if skills dir missing */ }
+
+  // 2. Community registry
+  const registryPath = path.join(PACKAGE_ROOT, 'community', 'registry.json');
+  try {
+    const raw = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    const entries = Array.isArray(raw) ? raw : raw.skills ?? [];
+    for (const entry of entries) {
+      if (entry.name && entry.description && !seen.has(entry.name)) {
+        skills.push({ name: entry.name, description: entry.description, source: 'registry', entry });
+        seen.add(entry.name);
+      }
+    }
+  } catch { /* skip */ }
+
+  return skills;
+}
+
+/**
+ * Loads (or computes) embeddings for every skill in the catalog.
+ * Caches result to ~/.booklib/registry-embeddings.json.
+ *
+ * @param {Function} [onProgress] - (done: number, total: number) => void
+ * @returns {Promise<Map<string, number[]>>}
+ */
+export async function getEmbeddings(onProgress) {
+  const catalog = loadSkillCatalog();
+  const cached  = _loadCache();
+  const result  = new Map(Object.entries(cached));
+  const missing = catalog.filter(s => !result.has(s.name));
+
+  if (missing.length > 0) {
+    const searcher = new BookLibSearcher();
+    for (let i = 0; i < missing.length; i++) {
+      result.set(missing[i].name, await searcher.getEmbedding(missing[i].description));
+      onProgress?.(i + 1, missing.length);
+    }
+    _saveCache(Object.fromEntries(result));
+  }
+
+  return result;
+}
+
+function _loadCache() {
+  try { return JSON.parse(fs.readFileSync(CACHE_PATH, 'utf8')); } catch { return {}; }
+}
+
+function _saveCache(data) {
+  try {
+    fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(data));
+  } catch { /* best-effort */ }
+}

package/lib/wizard/skill-recommender.js

@@ -0,0 +1,69 @@
+// lib/wizard/skill-recommender.js
+import { BookLibSearcher } from '../engine/searcher.js';
+import { loadSkillCatalog, getEmbeddings } from './registry-embeddings.js';
+
+export const SKILL_LIMIT = 32;
+
+/**
+ * Cosine similarity between two vectors. Exported for testing.
+ */
+export function cosine(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na  += a[i] * a[i];
+    nb  += b[i] * b[i];
+  }
+  return dot / (Math.sqrt(na) * Math.sqrt(nb) || 1);
+}
+
+/**
+ * Filters and ranks pre-scored catalog by installed exclusion and slot limit.
+ * Exported for testing.
+ *
+ * @param {Array<{name, score}>} catalog - already scored entries
+ * @param {{ installedNames: string[], available: number }} opts
+ */
+export function filterAndRank(catalog, { installedNames = [], available = SKILL_LIMIT } = {}) {
+  const installed = new Set(installedNames.map(n => n.toLowerCase()));
+  return catalog
+    .filter(s => !installed.has(s.name.toLowerCase()))
+    .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
+    .slice(0, available);
+}
+
+/**
+ * Returns ranked skill recommendations.
+ *
+ * @param {string} query - Free-text user goal (may be empty)
+ * @param {object} opts
+ * @param {string[]} opts.languages - Detected project languages
+ * @param {string[]} opts.installedNames - Already-installed skill names to exclude
+ * @param {number}   opts.slotsUsed - Current installed slot count
+ * @param {Function} [opts.onEmbeddingProgress] - (done, total) => void
+ * @returns {Promise<Array<{name, description, source, score, entry?}>>}
+ */
+export async function recommend(query, {
+  languages = [],
+  installedNames = [],
+  slotsUsed = 0,
+  onEmbeddingProgress,
+} = {}) {
+  const catalog    = loadSkillCatalog();
+  const embeddings = await getEmbeddings(onEmbeddingProgress);
+  const available  = Math.max(0, SKILL_LIMIT - slotsUsed);
+
+  // Build query: user text + language hints
+  const queryText = [query, ...languages.map(l => `${l} programming`)].filter(Boolean).join('. ')
+    || 'software engineering best practices';
+
+  const searcher = new BookLibSearcher();
+  const queryVec = await searcher.getEmbedding(queryText);
+
+  const scored = catalog.map(s => ({
+    ...s,
+    score: embeddings.has(s.name) ? cosine(queryVec, embeddings.get(s.name)) : 0,
+  }));
+
+  return filterAndRank(scored, { installedNames, available });
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@mseep/core",
+  "version": "3.0.0",
+  "description": "Detects AI knowledge gaps in your codebase and fixes them \u2014 post-training API detection, team knowledge, and runtime context injection via MCP for Claude, Cursor, Copilot, and 10+ AI coding tools",
+  "author": "Stanislav Zhuravel <zhuravelstas@gmail.com>",
+  "bin": {
+    "skills": "bin/skills.cjs",
+    "booklib": "bin/booklib.js",
+    "booklib-mcp": "bin/booklib-mcp.js"
+  },
+  "type": "module",
+  "files": [
+    "bin/",
+    "lib/",
+    "hooks/",
+    "skills/",
+    "community/",
+    "commands/",
+    "agents/",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-coding",
+    "ai-agent",
+    "context-engineering",
+    "claude",
+    "claude-code",
+    "cursor",
+    "copilot",
+    "codex",
+    "knowledge-graph",
+    "rag",
+    "code-review",
+    "ai-context",
+    "mseep",
+    "mcp-server"
+  ],
+  "license": "MIT",
+  "homepage": "https://booklib-ai.github.io/booklib/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/booklib-ai/booklib.git"
+  },
+  "scripts": {
+    "test": "find tests -name '*.test.js' | xargs node --test"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "@huggingface/transformers": "^3.4.0",
+    "@modelcontextprotocol/sdk": "^1.6.0",
+    "gray-matter": "^4.0.3",
+    "minimatch": "^10.2.4",
+    "vectra": "^0.12.3"
+  },
+  "devDependencies": {
+    "puppeteer": "^24.39.1"
+  },
+  "overrides": {
+    "encoding-sniffer": "1.0.2",
+    "global-agent": "4.1.3",
+    "openai": "6.33.0"
+  },
+  "publisher": "mseep"
+}