mindforge-cc 2.0.0-alpha.8 → 2.0.0

package/bin/skill-validator.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * MindForge Skill Validator — v1.0.0
+ * Validates SKILL.md files against schema and content requirements.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ARGS = process.argv.slice(2);
+const NO_COLOR = ARGS.includes('--no-color');
+
+const colors = {
+  reset:  NO_COLOR ? '' : '\x1b[0m',
+  red:    NO_COLOR ? '' : '\x1b[31m',
+  green:  NO_COLOR ? '' : '\x1b[32m',
+  yellow: NO_COLOR ? '' : '\x1b[33m',
+  cyan:   NO_COLOR ? '' : '\x1b[36m',
+  bold:   NO_COLOR ? '' : '\x1b[1m'
+};
+
+function main() {
+  const target = ARGS[0];
+  if (!target || ARGS.includes('--help') || ARGS.includes('-h')) {
+    console.log('\nUsage: mindforge-cc validate-skill <path-to-SKILL.md>\n');
+    process.exit(0);
+  }
+
+  const filePath = path.resolve(process.cwd(), target);
+  if (!fs.existsSync(filePath)) {
+    console.error(`${colors.red}❌ File not found: ${filePath}${colors.reset}`);
+    process.exit(1);
+  }
+
+  console.log(`\n${colors.bold}MindForge Skill Validator — ${path.basename(filePath)}${colors.reset}`);
+  console.log('─'.repeat(60));
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const results = { schema: [], content: [], quality: [], valid: true };
+
+  // ── Level 1: Schema ─────────────────────────────────────────────────────────
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    results.schema.push({ ok: false, msg: 'Missing frontmatter (--- delimiters)' });
+    results.valid = false;
+  } else {
+    results.schema.push({ ok: true, msg: 'Frontmatter delimiters present' });
+    const fmLines = fmMatch[1].split('\n');
+    const fm = {};
+    fmLines.forEach(line => {
+      const parts = line.split(':');
+      if (parts.length >= 2) fm[parts[0].trim()] = parts.slice(1).join(':').trim();
+    });
+
+    // name
+    if (!fm.name) {
+      results.schema.push({ ok: false, msg: 'Missing field: name' });
+      results.valid = false;
+    } else if (!/^[a-z][a-z0-9-]+$/.test(fm.name)) {
+      results.schema.push({ ok: false, msg: `Invalid name format: ${fm.name} (must be kebab-case)` });
+      results.valid = false;
+    } else {
+      results.schema.push({ ok: true, msg: `name: ${fm.name}` });
+    }
+
+    // version
+    if (!fm.version) {
+      results.schema.push({ ok: false, msg: 'Missing field: version' });
+      results.valid = false;
+    } else if (!/^\d+\.\d+\.\d+$/.test(fm.version)) {
+      results.schema.push({ ok: false, msg: `Invalid version: ${fm.version} (must be x.y.z)` });
+      results.valid = false;
+    } else {
+      results.schema.push({ ok: true, msg: `version: ${fm.version}` });
+    }
+
+    // status
+    const validStatuses = ['stable', 'beta', 'alpha', 'deprecated'];
+    if (!fm.status || !validStatuses.includes(fm.status)) {
+      results.schema.push({ ok: false, msg: `Invalid status: ${fm.status}` });
+      results.valid = false;
+    } else {
+      results.schema.push({ ok: true, msg: `status: ${fm.status}` });
+    }
+
+    // triggers
+    if (!fm.triggers) {
+      results.schema.push({ ok: false, msg: 'Missing field: triggers' });
+      results.valid = false;
+    } else {
+      const triggers = fm.triggers.split(',').map(t => t.trim()).filter(Boolean);
+      if (triggers.length < 5) {
+        results.schema.push({ ok: false, msg: `Too few triggers: ${triggers.length} (min: 5)` });
+        results.valid = false;
+      } else {
+        results.schema.push({ ok: true, msg: `triggers: ${triggers.length} keywords` });
+      }
+    }
+  }
+
+  // ── Level 2: Content ────────────────────────────────────────────────────────
+  results.content.push({
+    ok: content.length >= 1024 && content.length <= 200 * 1024,
+    msg: `File size: ${(content.length / 1024).toFixed(1)}KB (1KB-200KB)`
+  });
+
+  results.content.push({
+    ok: /##\s+(Mandatory actions|When this skill is active)/i.test(content),
+    msg: 'Mandatory actions section present'
+  });
+
+  results.content.push({
+    ok: /- \[ \]/.test(content),
+    msg: 'Self-check/checklist items found'
+  });
+
+  results.content.push({
+    ok: !/IGNORE ALL PREVIOUS/i.test(content),
+    msg: 'No injection patterns detected'
+  });
+
+  // ── Output ──────────────────────────────────────────────────────────────────
+  console.log(`${colors.cyan}${colors.bold}Schema validation:${colors.reset}`);
+  results.schema.forEach(r => console.log(`  ${r.ok ? colors.green + '✅' : colors.red + '❌'} ${r.msg}`));
+
+  console.log(`\n${colors.cyan}${colors.bold}Content validation:${colors.reset}`);
+  results.content.forEach(r => {
+    if (!r.ok) results.valid = false;
+    console.log(`  ${r.ok ? colors.green + '✅' : colors.red + '❌'} ${r.msg}`);
+  });
+
+  console.log('─'.repeat(60));
+  if (results.valid) {
+    console.log(`${colors.green}${colors.bold}Result: VALID${colors.reset}`);
+    process.exit(0);
+  } else {
+    console.log(`${colors.red}${colors.bold}Result: INVALID${colors.reset}`);
+    process.exit(1);
+  }
+}
+
+main();

package/bin/skills-builder/learn-cli.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * MindForge v2 — Learn Skill CLI
+ * Ingests content from a source and generates a validated SKILL.md.
+ */
+'use strict';
+
+const Loader    = require('./source-loader');
+const Generator = require('./skill-generator');
+const Scorer    = require('./skill-scorer');
+const Registrar = require('./skill-registrar');
+
+const ARGS = process.argv.slice(2);
+const SOURCE = ARGS[0];
+const NAME   = ARGS[1] || 'new-skill';
+
+if (!SOURCE) {
+  console.log('Usage: node bin/skills-builder/learn-cli.js <source-url-or-path> [skill-name]');
+  process.exit(1);
+}
+
+async function main() {
+  try {
+    console.log(`\n📚 Learning skill: ${NAME} from ${SOURCE}`);
+    
+    // 1. Load
+    const { content, metadata } = await Loader.load(SOURCE);
+    
+    // 2. Generate
+    const result = await Generator.generate({
+      skillName: NAME,
+      content,
+      sourceMetadata: metadata,
+      sessionId: 'cli-learn'
+    });
+    
+    // 3. Score
+    const scoreResult = Scorer.score(result.skillPath);
+    console.log(`\n✅ Skill generated: ${result.skillPath}`);
+    console.log(`⭐ Quality Score: ${scoreResult.quality_score}/100 (${scoreResult.threshold_status})`);
+    
+    // 4. Register if acceptable
+    if (scoreResult.can_register) {
+      Registrar.register(result.skillPath, 'project');
+      console.log('📝 Registered in MANIFEST.md');
+    } else {
+      console.log('⚠️ Score too low for automatic registration.');
+      scoreResult.improvement_suggestions.forEach(s => console.log(`  - ${s}`));
+    }
+    
+  } catch (err) {
+    console.error(`\n❌ Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/bin/skills-builder/marketplace-cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/**
+ * MindForge v2 — Marketplace CLI
+ * Searched and manages community skills via npm registry.
+ */
+'use strict';
+
+const Marketplace = require('./marketplace-client');
+
+const ARGS = process.argv.slice(2);
+const CMD  = ARGS[0];
+const QUERY = ARGS[1];
+
+if (!CMD) {
+  console.log('Usage: node bin/skills-builder/marketplace-cli.js <search|featured|trending|install> [query]');
+  process.exit(1);
+}
+
+async function main() {
+  try {
+    switch (CMD) {
+      case 'search':
+        const results = await Marketplace.search(QUERY);
+        console.table(results.map(r => ({
+          name: r.name,
+          version: r.version,
+          score: r.quality?.score || 'N/A',
+          description: r.description.slice(0, 50) + '...'
+        })));
+        break;
+        
+      case 'featured':
+      case 'trending':
+        const list = await Marketplace.getFeatured();
+        console.table(list);
+        break;
+        
+      case 'install':
+        if (!QUERY) throw new Error('Package name required for install');
+        await Marketplace.install(QUERY);
+        console.log(`✅ Successfully installed ${QUERY}`);
+        break;
+
+      default:
+        console.error(`Unknown command: ${CMD}`);
+        process.exit(1);
+    }
+  } catch (err) {
+    console.error(`\n❌ Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/bin/skills-builder/marketplace-client.js

@@ -0,0 +1,198 @@
+/**
+ * MindForge v2 — Marketplace Client
+ * Interface to the MindForge Community Skills Marketplace.
+ *
+ * The marketplace is a curated layer on top of the npm registry.
+ * Skills are npm packages with the `mindforge-skill-` prefix.
+ *
+ * For this implementation: uses npm registry API directly.
+ * A dedicated marketplace API (registry.mindforge.dev) would be used
+ * when it becomes available.
+ */
+'use strict';
+
+const https  = require('https');
+const path   = require('path');
+const fs     = require('fs');
+
+const SKILL_PREFIX       = 'mindforge-skill-';
+const NPM_REGISTRY       = 'https://registry.npmjs.org';
+const NPM_SEARCH_API     = 'https://registry.npmjs.org/-/v1/search';
+const MINDFORGEMD_PATH   = path.join(process.cwd(), 'MINDFORGE.md');
+
+// ── Config reader ─────────────────────────────────────────────────────────────
+function getConfig() {
+  const defaults = {
+    MARKETPLACE_REGISTRY: NPM_SEARCH_API,
+    MARKETPLACE_DAILY_FETCH_LIMIT: 50,
+  };
+  if (!fs.existsSync(MINDFORGEMD_PATH)) return defaults;
+  const content = fs.readFileSync(MINDFORGEMD_PATH, 'utf8');
+  for (const [key, defaultVal] of Object.entries(defaults)) {
+    const match = content.match(new RegExp(`^${key}=(.+)$`, 'm'));
+    if (match) defaults[key] = match[1].trim();
+  }
+  return defaults;
+}
+
+// ── HTTP helper ───────────────────────────────────────────────────────────────
+function httpsGet(url) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, {
+      headers: { 'User-Agent': 'MindForge-Marketplace/2.0', 'Accept': 'application/json' },
+      timeout: 15_000,
+    }, res => {
+      let body = '';
+      res.on('data', c => (body += c));
+      res.on('end', () => {
+        try { resolve(JSON.parse(body)); }
+        catch { reject(new Error(`Invalid JSON from ${url.slice(0, 80)}`)); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error(`Timeout: ${url}`)); });
+  });
+}
+
+// ── Search ────────────────────────────────────────────────────────────────────
+async function search(query, limit = 10) {
+  const encoded = encodeURIComponent(`${SKILL_PREFIX} ${query}`);
+  const url     = `${NPM_SEARCH_API}?text=${encoded}&size=${Math.min(limit, 50)}`;
+
+  const data = await httpsGet(url);
+  const objects = data.objects || [];
+
+  return objects
+    .filter(o => o.package?.name?.startsWith(SKILL_PREFIX))
+    .map(o => ({
+      name:         o.package.name,
+      display_name: o.package.name.replace(SKILL_PREFIX, '').replace(/-/g, ' '),
+      description:  o.package.description || '',
+      version:      o.package.version,
+      author:       o.package.publisher?.username || o.package.author?.name || 'unknown',
+      date:         o.package.date,
+      keywords:     o.package.keywords || [],
+      links:        o.package.links || {},
+      // Quality signals from npm (proxy until dedicated marketplace)
+      download_count: o.downloads?.weekly || null,
+    }));
+}
+
+// ── Featured skills ───────────────────────────────────────────────────────────
+const FEATURED_SKILLS = [
+  { name: `${SKILL_PREFIX}db-postgres-advanced`,    category: 'Database',   description: 'Advanced PostgreSQL patterns, indexes, partitioning, and query optimisation' },
+  { name: `${SKILL_PREFIX}api-graphql`,             category: 'API',        description: 'GraphQL schema design, N+1 prevention, pagination, and subscriptions' },
+  { name: `${SKILL_PREFIX}frontend-react-patterns`, category: 'Frontend',   description: 'React composition patterns, memo/callback, Suspense, and Server Components' },
+  { name: `${SKILL_PREFIX}infra-terraform`,         category: 'Infra',      description: 'Terraform module structure, state management, and production best practices' },
+  { name: `${SKILL_PREFIX}fintech-pci-compliance`,  category: 'Compliance', description: 'PCI DSS Level 1 implementation requirements for payment processing' },
+  { name: `${SKILL_PREFIX}healthtech-hipaa`,        category: 'Compliance', description: 'HIPAA Security Rule technical safeguards for PHI handling' },
+  { name: `${SKILL_PREFIX}ecommerce-stripe`,        category: 'Payments',   description: 'Stripe Elements, webhooks, idempotency, and subscription lifecycle' },
+];
+
+async function getFeatured() {
+  // Try to fetch actual data for each featured skill
+  const results = [];
+  for (const skill of FEATURED_SKILLS) {
+    try {
+      const url  = `${NPM_REGISTRY}/${encodeURIComponent(skill.name)}`;
+      const data = await httpsGet(url);
+      results.push({
+        ...skill,
+        version:     data['dist-tags']?.latest || '1.0.0',
+        date:        data.time?.modified,
+        exists:      true,
+      });
+    } catch {
+      // Skill not yet published — show as coming soon
+      results.push({ ...skill, exists: false, version: 'coming soon' });
+    }
+  }
+  return results;
+}
+
+// ── Trending ──────────────────────────────────────────────────────────────────
+async function getTrending(limit = 10) {
+  // Use npm search sorted by popularity
+  const url  = `${NPM_SEARCH_API}?text=${encodeURIComponent(SKILL_PREFIX)}&size=${limit}&ranking=popularity`;
+  const data = await httpsGet(url);
+  return (data.objects || [])
+    .filter(o => o.package?.name?.startsWith(SKILL_PREFIX))
+    .map(o => ({
+      name:        o.package.name,
+      description: o.package.description || '',
+      version:     o.package.version,
+      date:        o.package.date,
+      score:       o.score?.final || 0,
+    }))
+    .sort((a, b) => b.score - a.score);
+}
+
+// ── Install from marketplace ──────────────────────────────────────────────────
+async function install(skillName, tier = 'project') {
+  // Ensure the package name has the skill prefix
+  const packageName = skillName.startsWith(SKILL_PREFIX)
+    ? skillName
+    : `${SKILL_PREFIX}${skillName}`;
+
+  // Verify package exists on npm first
+  try {
+    const url  = `${NPM_REGISTRY}/${encodeURIComponent(packageName)}`;
+    await httpsGet(url);
+  } catch {
+    throw new Error(`Skill not found on marketplace: ${packageName}`);
+  }
+
+  // Use MindForge's existing install-skill command machinery
+  return {
+    install_command: `/mindforge:install-skill ${packageName} --tier ${tier}`,
+    package_name:    packageName,
+    message:         `Run the install command above, or execute: npm install ${packageName}`,
+  };
+}
+
+// ── Format results for display ────────────────────────────────────────────────
+function formatSearchResults(results, query) {
+  if (results.length === 0) {
+    return `🔍 No marketplace skills found for "${query}"\n\n` +
+      `Try broader terms, or create your own with:\n  /mindforge:learn [url|path]`;
+  }
+
+  const lines = [`🏪 Marketplace results for "${query}" (${results.length} found)\n`];
+  results.forEach((r, i) => {
+    const name = r.display_name || r.name.replace(SKILL_PREFIX, '').replace(/-/g, ' ');
+    lines.push(`  ${i + 1}. ${name} (${r.version})`);
+    lines.push(`     ${r.description.slice(0, 100)}`);
+    if (r.download_count) lines.push(`     ${r.download_count} downloads/week`);
+    lines.push('');
+  });
+  lines.push(`Install: /mindforge:marketplace install [name] [--tier project|org]`);
+  return lines.join('\n');
+}
+
+function formatFeatured(featured) {
+  const lines = ['🏪 MindForge Community Skills Marketplace\n  Featured Skills\n'];
+
+  const byCategory = {};
+  featured.forEach(s => {
+    if (!byCategory[s.category]) byCategory[s.category] = [];
+    byCategory[s.category].push(s);
+  });
+
+  for (const [cat, skills] of Object.entries(byCategory)) {
+    lines.push(`  ${cat}:`);
+    skills.forEach(s => {
+      const status = s.exists ? `v${s.version}` : '(coming soon)';
+      lines.push(`    ${s.name.replace(SKILL_PREFIX, '')} ${status}`);
+      lines.push(`      ${s.description.slice(0, 90)}`);
+    });
+    lines.push('');
+  }
+
+  lines.push('Commands:');
+  lines.push('  /mindforge:marketplace search [query]');
+  lines.push('  /mindforge:marketplace trending');
+  lines.push('  /mindforge:marketplace install [name]');
+  return lines.join('\n');
+}
+
+module.exports = { search, getFeatured, getTrending, install, formatSearchResults, formatFeatured };

package/bin/skills-builder/pattern-detector.js

@@ -0,0 +1,144 @@
+/**
+ * MindForge v2 — Pattern Detector
+ * Analyses phase SUMMARY files to find patterns that appeared
+ * across 2+ tasks and are worth capturing as skills.
+ *
+ * Used by the AUTO_CAPTURE_SKILLS=true hook in execute-phase.
+ */
+'use strict';
+
+const fs          = require('fs');
+const path        = require('path');
+const ModelClient = require('../models/model-client');
+const Router      = require('../models/model-router');
+
+const PLANNING_DIR = path.join(process.cwd(), '.planning');
+
+const PATTERN_DETECTION_SYSTEM = `You are an expert at analysing software development sessions
+to find reusable patterns worth capturing as team knowledge.
+
+You will receive SUMMARY files from a completed development phase.
+Find patterns that:
+1. Appeared in 2+ tasks (frequency = evidence of importance)
+2. Are technology-specific (not generic like "wrote tests" or "handled errors")
+3. Would be hard to know without having done this before
+4. Would meaningfully help future agents starting similar work
+
+For each pattern found, provide:
+- pattern_name: Short name (≤ 50 chars, kebab-case)
+- display_name: Human-readable name
+- frequency: Number of tasks where this pattern appeared
+- generality: "high"|"medium"|"low" (would this help in other projects?)
+- difficulty: "high"|"medium"|"low" (hard to get right without knowing it?)
+- evidence: List of which plan files show this pattern
+- summary: 2-3 sentence description of the pattern
+- suggested_skill_name: Kebab-case name for the skill (e.g., "prisma-relations")
+
+Return ONLY valid JSON. Array of pattern objects. Maximum 5 patterns.
+Minimum capture bar: frequency >= 2 OR (frequency == 1 AND difficulty == "high" AND generality != "low")`;
+
+async function detectPatterns(phaseNum, options = {}) {
+  const { sessionId = 'pattern-detect', minFrequency = 2 } = options;
+
+  const phaseDir = path.join(PLANNING_DIR, 'phases', String(phaseNum));
+  if (!fs.existsSync(phaseDir)) return { patterns: [], phase: phaseNum };
+
+  // Load all SUMMARY files
+  const summaryFiles = fs.readdirSync(phaseDir)
+    .filter(f => f.startsWith('SUMMARY-') && f.endsWith('.md'))
+    .sort();
+
+  if (summaryFiles.length < 2) {
+    return { patterns: [], phase: phaseNum, reason: 'Need at least 2 SUMMARY files for pattern detection' };
+  }
+
+  let combinedContent = `# Phase ${phaseNum} SUMMARY Analysis\n\n`;
+  for (const f of summaryFiles) {
+    const text = fs.readFileSync(path.join(phaseDir, f), 'utf8');
+    combinedContent += `## ${f}\n${text.slice(0, 8_000)}\n\n`;
+  }
+
+  // Also include HANDOFF.json implicit knowledge if available
+  const handoffPath = path.join(PLANNING_DIR, 'HANDOFF.json');
+  if (fs.existsSync(handoffPath)) {
+    try {
+      const handoff  = JSON.parse(fs.readFileSync(handoffPath, 'utf8'));
+      const implicit = (handoff.implicit_knowledge || []).filter(i => (i.confidence || 0) >= 0.7);
+      if (implicit.length > 0) {
+        combinedContent += `## Implicit Knowledge (from compaction)\n`;
+        implicit.forEach(i => { combinedContent += `- ${i.topic || ''}: ${i.content || i.text || ''}\n`; });
+      }
+    } catch { /* ignore */ }
+  }
+
+  const model = Router.getAllSettings()?.EXECUTOR_MODEL || 'claude-3-5-sonnet';
+  process.stdout.write(`  🔍 Detecting patterns in Phase ${phaseNum} (${summaryFiles.length} tasks)... `);
+
+  const result = await ModelClient.complete({
+    model,
+    systemPrompt: PATTERN_DETECTION_SYSTEM,
+    userMessage:  combinedContent.slice(0, 100_000),
+    maxTokens:    2048,
+    temperature:  0.1,
+    taskName:     `pattern-detect-phase${phaseNum}`,
+    sessionId,
+  });
+
+  console.log('done');
+
+  const text = result.content.trim().replace(/^```json\n?/, '').replace(/\n?```$/, '');
+  let patterns;
+  try {
+    patterns = JSON.parse(text);
+    if (!Array.isArray(patterns)) throw new Error('Not an array');
+  } catch (err) {
+    return { patterns: [], phase: phaseNum, error: `Pattern detection returned invalid JSON: ${err.message}` };
+  }
+
+  // Filter to minimum bar
+  const filtered = patterns
+    .filter(p => {
+      const freq       = p.frequency || 1;
+      const generality = p.generality || 'low';
+      const difficulty = p.difficulty || 'medium';
+      return freq >= minFrequency || (freq >= 1 && difficulty === 'high' && generality !== 'low');
+    })
+    .slice(0, 5);
+
+  return { patterns: filtered, phase: phaseNum, tasks_analysed: summaryFiles.length };
+}
+
+/**
+ * Format detected patterns for user presentation.
+ */
+function formatForPresentation(detectionResult) {
+  const { patterns, phase, tasks_analysed } = detectionResult;
+
+  if (!patterns || patterns.length === 0) {
+    return `\n🔍 Auto-capture: No reusable patterns found in Phase ${phase}\n` +
+      `   (${tasks_analysed} tasks analysed — need patterns appearing in 2+ tasks)\n`;
+  }
+
+  const lines = [
+    `\n🎯 Auto-capture: ${patterns.length} reusable pattern${patterns.length > 1 ? 's' : ''} found in Phase ${phase}`,
+    `   (${tasks_analysed} tasks analysed)\n`,
+  ];
+
+  patterns.forEach((p, i) => {
+    const stars  = p.generality === 'high' ? '★★★' : p.generality === 'medium' ? '★★' : '★';
+    const freq   = p.frequency > 1 ? `appeared in ${p.frequency} tasks` : `1 task (high difficulty)`;
+    lines.push(`  ${i + 1}. ${p.display_name || p.pattern_name} (${stars} ${p.generality} generality)`);
+    lines.push(`     ${freq}`);
+    lines.push(`     "${p.summary?.slice(0, 120) || ''}"`);
+    lines.push('');
+  });
+
+  const choices = patterns.length === 1
+    ? '[ y=save ] [ n=skip ]'
+    : `[ y=all ] [ ${patterns.map((_, i) => `${i+1}=only #${i+1}`).join(' ] [ ')} ] [ n=skip ]`;
+
+  lines.push(`Save as skills? ${choices}`);
+  return lines.join('\n');
+}
+
+module.exports = { detectPatterns, formatForPresentation };