mindforge-cc 8.2.0 → 9.0.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/skills-builder/marketplace-client.js

@@ -1,198 +0,0 @@
-/**
- * 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

@@ -1,144 +0,0 @@
-/**
- * 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

@@ -1,258 +0,0 @@
-/**
- * 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 };