mindforge-cc 8.1.0 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/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/.mindforge/mirrors/mirror-sre-776a1cf9/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 };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/skills-builder/skill-generator.js

@@ -0,0 +1,258 @@
+/**
+ * MindForge v2 — Skill Generator
+ * Uses AI models to convert documentation into validated SKILL.md files.
+ *
+ * Pipeline:
+ *   1. Extract patterns (10 structured rules from source)
+ *   2. Generate trigger keywords (15-25 specific keywords)
+ *   3. Write full SKILL.md
+ *   4. Score with skill-scorer.js
+ *   5. Return result for user review
+ */
+'use strict';
+
+const fs          = require('fs');
+const path        = require('path');
+const ModelClient = require('../models/model-client');
+const Router      = require('../models/model-router');
+
+// ── Model selection ───────────────────────────────────────────────────────────
+// Default: RESEARCH_MODEL (Gemini 2.5 Pro with 1M context) for large docs
+// Fallback: EXECUTOR_MODEL when content < 50K chars
+function selectModel(contentLength) {
+  const settings = Router.getAllSettings();
+  if (contentLength > 50_000) {
+    return settings.RESEARCH_MODEL || 'gemini-1.5-pro';
+  }
+  return settings.EXECUTOR_MODEL || 'claude-3-5-sonnet';
+}
+
+// ── System prompts ────────────────────────────────────────────────────────────
+const PATTERN_EXTRACTION_SYSTEM = `You are an expert software engineer who specialises in
+reading technical documentation and extracting the most valuable engineering rules and patterns.
+
+Your goal: identify the 10 most important, actionable patterns from the provided documentation.
+
+Requirements for each pattern:
+1. The rule must be specific and actionable (not vague like "follow best practices")
+2. Include a concrete code example showing correct usage
+3. If there's a common mistake/anti-pattern, include it
+4. Rate importance as CRITICAL, HIGH, MEDIUM, or LOW
+
+Output ONLY valid JSON. No markdown, no preamble, no explanation.
+JSON format: [
+  {
+    "title": "Short title (≤ 60 chars)",
+    "rule": "Actionable rule statement (≤ 200 chars)",
+    "example_good": "// TypeScript/JavaScript code showing correct usage",
+    "example_bad": "// Code showing the anti-pattern (or null if none)",
+    "importance": "CRITICAL|HIGH|MEDIUM|LOW",
+    "applies_when": "Brief description of when this rule applies"
+  }
+]`;
+
+const TRIGGER_EXTRACTION_SYSTEM = `You are an expert at creating precise, specific keyword triggers
+for an AI skill loading system. The trigger system works by text-matching task descriptions and
+file paths against trigger keywords.
+
+Requirements for good triggers:
+- 2-4 words each (not single words — too broad)
+- Technology-specific (not generic like "database" or "api")
+- Cover: package names, import paths, file extensions, config file names, function names, concepts
+- Both noun and verb forms where helpful
+- A task description like "set up Prisma schema with relations" should match several triggers
+
+Output ONLY a JSON array of strings. No markdown, no preamble.
+["trigger keyword one", "trigger keyword two", ...]`;
+
+const SKILL_WRITING_SYSTEM = `You are writing a MindForge SKILL.md file — a structured knowledge
+document that an AI agent reads before working with a specific technology.
+
+Your writing style:
+- Precise and actionable (every rule starts with a verb: "Use", "Always", "Never", "Prefer")
+- Include working code examples (not pseudocode)
+- A developer should be able to follow these rules without reading the source docs
+- Include a self-check checklist they can use to verify their implementation
+
+Output ONLY the complete SKILL.md content. Start with the frontmatter. No preamble.`;
+
+// ── Pattern extraction ────────────────────────────────────────────────────────
+async function extractPatterns(content, model, sessionId) {
+  const truncated = content.length > 400_000
+    ? content.slice(0, 400_000) + '\n\n[Content truncated at 400K chars for processing]'
+    : content;
+
+  const result = await ModelClient.complete({
+    model,
+    systemPrompt: PATTERN_EXTRACTION_SYSTEM,
+    userMessage:  `Extract the 10 most important patterns from this documentation:\n\n${truncated}`,
+    maxTokens:    4096,
+    temperature:  0.1,
+    taskName:     'skill-learn-extract-patterns',
+    sessionId,
+  });
+
+  const text = result.content.trim().replace(/^```json\n?/, '').replace(/\n?```$/, '');
+  try {
+    const patterns = JSON.parse(text);
+    if (!Array.isArray(patterns)) throw new Error('Not an array');
+    return patterns.slice(0, 10); // Enforce max 10
+  } catch (err) {
+    throw new Error(`Pattern extraction returned invalid JSON: ${err.message}\n\nRaw: ${text.slice(0, 500)}`);
+  }
+}
+
+// ── Trigger extraction ────────────────────────────────────────────────────────
+async function extractTriggers(content, patterns, model, sessionId) {
+  const patternSummary = patterns
+    .map(p => `- ${p.title}: ${p.rule}`)
+    .join('\n');
+
+  const result = await ModelClient.complete({
+    model,
+    systemPrompt: TRIGGER_EXTRACTION_SYSTEM,
+    userMessage: `Technology documentation context:\n${content.slice(0, 5000)}\n\nKey patterns:\n${patternSummary}\n\nGenerate 15-25 specific trigger keywords for this technology/skill.`,
+    maxTokens:   1024,
+    temperature: 0.1,
+    taskName:    'skill-learn-extract-triggers',
+    sessionId,
+  });
+
+  const text = result.content.trim().replace(/^```json\n?/, '').replace(/\n?```$/, '');
+  try {
+    const triggers = JSON.parse(text);
+    if (!Array.isArray(triggers)) throw new Error('Not an array');
+    return triggers.slice(0, 30).filter(t => typeof t === 'string' && t.trim().length > 0);
+  } catch (err) {
+    throw new Error(`Trigger extraction returned invalid JSON: ${err.message}`);
+  }
+}
+
+// ── SKILL.md writer ───────────────────────────────────────────────────────────
+async function writeSkillMd(skillName, patterns, triggers, sourceMetadata, model, sessionId) {
+  const userMessage = `Write a complete MindForge SKILL.md for the skill named "${skillName}".
+
+Triggers (${triggers.length} keywords — include ALL of these in the triggers array):
+${JSON.stringify(triggers)}
+
+Key patterns to cover (include ALL 10 in the "Key Rules" section):
+${patterns.map((p, i) => `${i+1}. [${p.importance}] ${p.title}\n   Rule: ${p.rule}\n   Good: ${p.example_good || 'N/A'}\n   Bad: ${p.example_bad || 'N/A'}`).join('\n\n')}
+
+Source: ${sourceMetadata.url || sourceMetadata.path || sourceMetadata.name || 'session analysis'}
+
+Required SKILL.md structure:
+\`\`\`
+---
+name: ${skillName}
+version: 1.0.0
+status: stable
+triggers:
+  - [list all ${triggers.length} triggers here]
+description: [2-sentence description]
+---
+
+# ${skillName} Skill
+
+## Purpose
+[Why this skill exists — 2-3 sentences]
+
+## Key Rules
+
+[For each of the 10 patterns:]
+### [N]. [Title] ([importance])
+**Rule:** [Rule statement]
+\`\`\`typescript
+// ✅ Correct
+[good example code]
+
+// ❌ Avoid
+[bad example code or explanation]
+\`\`\`
+
+## Anti-Patterns to Avoid
+[List 5+ specific anti-patterns with explanations]
+
+## Complete Examples
+[3+ complete, working code examples showing real-world usage]
+
+## Self-Check Checklist
+Before completing any task involving [technology], verify:
+- [ ] [10+ specific checklist items]
+
+## Version History
+### v1.0.0
+- Initial skill — learned from [source]
+\`\`\``;
+
+  const result = await ModelClient.complete({
+    model,
+    systemPrompt: SKILL_WRITING_SYSTEM,
+    userMessage,
+    maxTokens:    8192,
+    temperature:  0.1,
+    taskName:     'skill-learn-write-skill',
+    sessionId,
+  });
+
+  return result.content.trim();
+}
+
+// ── Save to filesystem ────────────────────────────────────────────────────────
+function saveSkill(skillName, skillContent) {
+  // Sanitize skill name: only alphanumeric and hyphens
+  const safeName = skillName.replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').toLowerCase();
+  const skillDir = path.join(process.cwd(), '.mindforge', 'skills', safeName);
+
+  fs.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path.join(skillDir, 'SKILL.md');
+  fs.writeFileSync(skillPath, skillContent);
+  return { skillPath, skillDir, safeName };
+}
+
+// ── Main generate function ────────────────────────────────────────────────────
+/**
+ * Generate a SKILL.md from loaded source content.
+ *
+ * @param {object} params
+ * @param {string} params.skillName      - Name for the skill
+ * @param {string} params.content        - Source content (from source-loader.js)
+ * @param {object} params.sourceMetadata - Metadata about source
+ * @param {string} params.sessionId      - For cost tracking
+ * @returns {{ skillContent, patterns, triggers, skillPath, metadata }}
+ */
+async function generate(params) {
+  const { skillName, content, sourceMetadata, sessionId = 'skill-learn' } = params;
+
+  const model = selectModel(content.length);
+  console.log(`\n  🧠 Skill generator (${model}, ${content.length.toLocaleString()} chars)`);
+
+  // Step 1: Extract patterns
+  process.stdout.write('  Step 1/3 — Extracting patterns... ');
+  const patterns = await extractPatterns(content, model, sessionId);
+  console.log(`done (${patterns.length} patterns)`);
+
+  // Step 2: Extract triggers
+  process.stdout.write('  Step 2/3 — Generating triggers... ');
+  const triggers = await extractTriggers(content, patterns, model, sessionId);
+  console.log(`done (${triggers.length} triggers)`);
+
+  // Step 3: Write SKILL.md
+  process.stdout.write('  Step 3/3 — Writing SKILL.md... ');
+  const skillContent = await writeSkillMd(skillName, patterns, triggers, sourceMetadata, model, sessionId);
+  console.log('done');
+
+  // Step 4: Save
+  const { skillPath, safeName } = saveSkill(skillName, skillContent);
+
+  return {
+    skillContent,
+    skillPath,
+    skillName: safeName,
+    patterns,
+    triggers,
+    model,
+    metadata: { content_length: content.length, source: sourceMetadata },
+  };
+}
+
+module.exports = { generate, extractPatterns, extractTriggers, writeSkillMd, saveSkill, selectModel };