thumbgate 1.4.3 → 1.4.5

package/scripts/skill-exporter.js

@@ -1,260 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Skill Exporter — compiles ThumbGate profiles/policy-bundles into
- * OpenAI Skill definitions and Codex Plugin manifests.
- * Vendor-neutral IR → target format compilation.
- */
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const ROOT = path.join(__dirname, '..');
-const SKILL_SPECS_DIR = path.join(ROOT, 'config', 'skill-specs');
-const POLICY_BUNDLES_DIR = path.join(ROOT, 'config', 'policy-bundles');
-const DIST_DIR = path.join(ROOT, 'dist', 'skills');
-const PKG = require(path.join(ROOT, 'package.json'));
-const { ensureDir } = require('./fs-utils');
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-}
-
-
-/**
- * Load a SkillSpec by name from config/skill-specs/.
- * @param {string} name - spec name (without .json)
- * @returns {object} parsed SkillSpec
- */
-function loadSkillSpec(name) {
-  const specPath = path.join(SKILL_SPECS_DIR, `${name}.json`);
-  if (!fs.existsSync(specPath)) {
-    throw new Error(`Skill spec not found: ${name} (looked at ${specPath})`);
-  }
-  return readJson(specPath);
-}
-
-/**
- * List all available skill specs in config/skill-specs/.
- * @returns {string[]} spec names (without .json extension)
- */
-function listAvailableSpecs() {
-  if (!fs.existsSync(SKILL_SPECS_DIR)) return [];
-  return fs.readdirSync(SKILL_SPECS_DIR)
-    .filter((f) => f.endsWith('.json'))
-    .map((f) => f.replace(/\.json$/, ''));
-}
-
-/**
- * Load a policy bundle by bundleId.
- * @param {string} bundleId
- * @returns {object} parsed policy bundle
- */
-function loadPolicyBundle(bundleId) {
-  const bundlePath = path.join(POLICY_BUNDLES_DIR, `${bundleId}.json`);
-  if (!fs.existsSync(bundlePath)) return null;
-  return readJson(bundlePath);
-}
-
-/**
- * Build instruction text from a policy bundle and escalation rules.
- * @param {object} bundle - parsed policy bundle
- * @param {string[]} escalationRules
- * @returns {string} instruction text
- */
-function buildInstructions(bundle, escalationRules) {
-  const lines = [];
-  lines.push(`Policy: ${bundle.description}`);
-  lines.push(`Default MCP Profile: ${bundle.defaultMcpProfile}`);
-  lines.push('');
-  lines.push('## Approval Gates');
-  lines.push(`Required risk levels for approval: ${bundle.approval.requiredRisks.join(', ')}`);
-  lines.push('');
-  lines.push('## Available Intents');
-  for (const intent of bundle.intents) {
-    const actions = intent.actions.map((a) => a.name).join(', ');
-    lines.push(`- ${intent.id} [${intent.risk}]: ${intent.description} (${actions})`);
-  }
-  if (escalationRules.length > 0) {
-    lines.push('');
-    lines.push('## Escalation Rules');
-    for (const rule of escalationRules) {
-      lines.push(`- ${rule}`);
-    }
-  }
-  return lines.join('\n');
-}
-
-/**
- * Compile a SkillSpec into an OpenAI Skill definition.
- * @param {object} spec - parsed SkillSpec
- * @returns {object} OpenAI Skill JSON
- */
-function compileToOpenAISkill(spec) {
-  const bundle = loadPolicyBundle(spec.policyBundle);
-  const instructions = bundle
-    ? buildInstructions(bundle, spec.escalationRules || [])
-    : `Skill: ${spec.description}`;
-
-  return {
-    name: spec.name,
-    description: spec.description,
-    model_class: spec.defaultModelClass,
-    instructions,
-    scripts: {
-      gate_check: `recall --scope ${(spec.memoryScope || []).join(',')} --enforce`,
-      recall_injection: `recall --query "{{context}}" --scope ${(spec.memoryScope || []).join(',')}`
-    },
-    assets: {
-      prevention_rules: `config/policy-bundles/${spec.policyBundle}.json`,
-      memory_scope: spec.memoryScope || [],
-      tools: spec.tools || []
-    }
-  };
-}
-
-/**
- * Compile a SkillSpec into a Codex Plugin manifest.
- * @param {object} spec - parsed SkillSpec
- * @returns {object} { pluginJson, mcpJson, agentsMd }
- */
-function compileToCodexPlugin(spec) {
-  const bundle = loadPolicyBundle(spec.policyBundle);
-  const instructions = bundle
-    ? buildInstructions(bundle, spec.escalationRules || [])
-    : `Skill: ${spec.description}`;
-
-  const pluginJson = {
-    name: spec.name,
-    version: PKG.version,
-    description: spec.description,
-    author: {
-      name: PKG.author,
-      url: 'https://github.com/IgorGanapolsky'
-    },
-    homepage: PKG.homepage,
-    repository: PKG.repository.url.replace(/\.git$/, ''),
-    license: PKG.license,
-    keywords: ['codex', 'codex-plugin', 'thumbgate', spec.name, ...(spec.memoryScope || [])],
-    mcpServers: './.mcp.json',
-    interface: {
-      displayName: `ThumbGate: ${spec.name}`,
-      shortDescription: spec.description,
-      longDescription: instructions,
-      developerName: PKG.author,
-      category: 'Developer Tools',
-      capabilities: ['Interactive', 'Write'],
-      websiteURL: PKG.homepage,
-      brandColor: '#0ea5e9'
-    }
-  };
-
-  const mcpJson = {
-    mcpServers: {
-      thumbgate: {
-        command: 'npx',
-        args: ['-y', `thumbgate@${PKG.version}`, 'serve'],
-        tools: spec.tools || []
-      }
-    }
-  };
-
-  const agentsMdLines = [
-    `# ${spec.name} — ThumbGate Codex Plugin`,
-    '',
-    '## Trigger',
-    'If user gives explicit positive/negative outcome feedback, capture it immediately.',
-    '',
-    '## Memory Scope',
-    ...(spec.memoryScope || []).map((s) => `- ${s}`),
-    '',
-    '## Gating Instructions',
-    instructions,
-    '',
-    '## Session Start',
-    '',
-    '```bash',
-    'npm run feedback:summary',
-    'npm run feedback:rules',
-    '```',
-    '',
-    'Use generated rules as hard guardrails to avoid repeated mistakes.'
-  ];
-
-  return {
-    pluginJson,
-    mcpJson,
-    agentsMd: agentsMdLines.join('\n')
-  };
-}
-
-/**
- * Export a skill spec to the given target formats.
- * @param {string} name - spec name
- * @param {string[]} targets - array of 'openai' and/or 'codex'
- * @returns {{ openai?: object, codex?: object, written: string[] }}
- */
-function exportSkill(name, targets = ['openai', 'codex']) {
-  const spec = loadSkillSpec(name);
-  const result = { written: [] };
-  const outDir = path.join(DIST_DIR, name);
-  ensureDir(outDir);
-
-  if (targets.includes('openai')) {
-    const openai = compileToOpenAISkill(spec);
-    result.openai = openai;
-    const openaiPath = path.join(outDir, 'openai-skill.json');
-    fs.writeFileSync(openaiPath, JSON.stringify(openai, null, 2) + '\n');
-    result.written.push(openaiPath);
-  }
-
-  if (targets.includes('codex')) {
-    const codex = compileToCodexPlugin(spec);
-    result.codex = codex;
-    const codexDir = path.join(outDir, 'codex');
-    ensureDir(path.join(codexDir, '.codex-plugin'));
-
-    const pluginPath = path.join(codexDir, '.codex-plugin', 'plugin.json');
-    fs.writeFileSync(pluginPath, JSON.stringify(codex.pluginJson, null, 2) + '\n');
-    result.written.push(pluginPath);
-
-    const mcpPath = path.join(codexDir, '.mcp.json');
-    fs.writeFileSync(mcpPath, JSON.stringify(codex.mcpJson, null, 2) + '\n');
-    result.written.push(mcpPath);
-
-    const agentsPath = path.join(codexDir, 'AGENTS.md');
-    fs.writeFileSync(agentsPath, codex.agentsMd + '\n');
-    result.written.push(agentsPath);
-  }
-
-  return result;
-}
-
-module.exports = { loadSkillSpec, compileToOpenAISkill, compileToCodexPlugin, exportSkill, listAvailableSpecs };
-
-/* istanbul ignore next — CLI entry */
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  const cmd = args[0] || 'list';
-  if (cmd === 'list') {
-    const specs = listAvailableSpecs();
-    console.log('Available skill specs:', specs.join(', '));
-  } else if (cmd === 'export') {
-    const name = args[1];
-    if (!name) { console.error('Usage: skill-exporter.js export <name>'); process.exit(1); }
-    const targets = args[2] ? args[2].split(',') : ['openai', 'codex'];
-    const result = exportSkill(name, targets);
-    console.log(`Exported ${name} → ${result.written.length} files`);
-    result.written.forEach((f) => console.log(`  ${f}`));
-  } else if (cmd === 'export-all') {
-    const specs = listAvailableSpecs();
-    for (const name of specs) {
-      const result = exportSkill(name);
-      console.log(`Exported ${name} → ${result.written.length} files`);
-    }
-  } else {
-    console.error(`Unknown command: ${cmd}`);
-    process.exit(1);
-  }
-}

package/scripts/skill-materializer.js

@@ -1,134 +0,0 @@
-#!/usr/bin/env node
-/**
- * Skill Materializer (EvoSkill Phase 2)
- * 
- * Takes a JSON proposal from Skill Proposer and 'materializes' 
- * a functional MCP tool definition + SKILL.md documentation.
- * 
- * Ensures every skill has a standardized entry point for the agent.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { discoverFeedbackDir } = require('./skill-generator');
-
-function materializeSkills(options = {}) {
-  const feedbackDir = options.feedbackDir || discoverFeedbackDir();
-  const proposalsDir = path.join(feedbackDir, 'skill-proposals');
-  const skillsOutDir = options.skillsOutDir || process.env.THUMBGATE_SKILLS_DIR || path.join(process.cwd(), 'skills');
-
-  if (!fs.existsSync(proposalsDir)) {
-    console.log('No proposals directory found.');
-    return;
-  }
-
-  const proposals = fs.readdirSync(proposalsDir)
-    .filter(f => f.endsWith('.json'))
-    .map(f => JSON.parse(fs.readFileSync(path.join(proposalsDir, f), 'utf-8')));
-
-  if (proposals.length === 0) {
-    console.log('No pending skill proposals.');
-    return;
-  }
-
-  if (!fs.existsSync(skillsOutDir)) fs.mkdirSync(skillsOutDir, { recursive: true });
-
-  const results = [];
-
-  for (const proposal of proposals) {
-    if (proposal.status !== 'pending') continue;
-
-    const skillName = proposal.suggestedSkill.name;
-    const skillDir = path.join(skillsOutDir, skillName);
-    if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
-
-    // Generate SKILL.md
-    const skillMd = generateSkillMarkdown(proposal);
-    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), skillMd);
-
-    // Generate functional tool code (template)
-    const toolCode = generateToolCode(proposal);
-    fs.writeFileSync(path.join(skillDir, 'tool.js'), toolCode);
-
-    // Update proposal status
-    proposal.status = 'materialized';
-    proposal.materializedAt = new Date().toISOString();
-    fs.writeFileSync(
-      path.join(proposalsDir, `${skillName}.json`), 
-      JSON.stringify(proposal, null, 2)
-    );
-
-    results.push(skillName);
-    console.log(`Materialized skill: ${skillName} -> ${skillDir}`);
-  }
-
-  return results;
-}
-
-function generateSkillMarkdown(proposal) {
-  const { suggestedSkill, problem, diagnosis } = proposal;
-  return `---
-name: ${suggestedSkill.name}
-description: ${suggestedSkill.description}
-diagnosis: ${diagnosis}
-status: materialized
----
-
-# ${suggestedSkill.name.toUpperCase()} Capability
-
-## Problem
-${problem}
-
-## Automated Diagnosis
-${diagnosis}
-
-## Usage
-The agent should call the \`${suggestedSkill.toolSpec.name}\` tool when tasks involve \`${suggestedSkill.tags.join(', ')}\`.
-`;
-}
-
-function generateToolCode(proposal) {
-  const { suggestedSkill } = proposal;
-  const toolName = suggestedSkill.toolSpec.name;
-  
-  return `/**
- * Automated Skill: ${suggestedSkill.name}
- * Generated: ${new Date().toISOString()}
- * 
- * This tool was materialized by the EvoSkill loop to address:
- * "${proposal.problem}"
- */
-
-const { execSync } = require('child_process');
-
-/**
- * ${suggestedSkill.toolSpec.description}
- */
-async function ${toolName}(args) {
-  const { context } = args;
-  
-  // LOGIC: Materialized code should implement the fix derived from the diagnosis.
-  // For now, we provide a structured wrapper that logs intent and applies
-  // the suggested corrective action.
-  
-  console.log(\`[EVOSKILL] Executing ${toolName} to resolve: ${proposal.problem}\`);
-  
-  // Corrective action placeholder - in a full loop, this would be LLM-generated code
-  // derived from the 'how-to-avoid' fields in memory-log.jsonl.
-  
-  return {
-    status: 'success',
-    appliedFix: \`Automated handling of ${proposal.problem} pattern.\`,
-    context: context
-  };
-}
-
-module.exports = { ${toolName} };
-`;
-}
-
-if (require.main === module) {
-  materializeSkills();
-}
-
-module.exports = { materializeSkills };

package/scripts/skill-packs.js

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const { registerPreventionRules } = require('./contextfs');
-const SKILL_PACKS_DIR = path.join(__dirname, '..', 'config', 'skill-packs');
-const BUILTIN_PACKS = {
-  'stripe-integration': { name: 'stripe-integration', description: 'Stripe API best practices', triggers: ['stripe', 'payment', 'checkout', 'subscription', 'webhook signature'], rules: ['ALWAYS use idempotency keys on PaymentIntent creation to prevent duplicate charges.', 'NEVER log or store raw card numbers — use Stripe tokens or PaymentMethod IDs.', 'ALWAYS verify webhook signatures with stripe.webhooks.constructEvent() before processing.', 'Use Checkout Sessions instead of raw PaymentIntents for new integrations.', 'ALWAYS handle payment_intent.succeeded AND payment_intent.payment_failed webhooks.'], packTemplate: { namespaces: ['memoryError', 'memoryLearning', 'rules'], maxItems: 8, maxChars: 6000, queryPrefix: 'stripe payment checkout webhook idempotency' } },
-  'railway-deploy': { name: 'railway-deploy', description: 'Railway deployment best practices', triggers: ['railway', 'deploy', 'dockerfile', 'health check'], rules: ['ALWAYS verify /health endpoint returns new version after deploy.', 'NEVER say "deployed" without curling the health endpoint and showing version match.', 'ALWAYS check Railway build logs for warnings even when deploy succeeds.', 'Use RAILWAY_VOLUME_MOUNT_PATH for persistent data.', 'ALWAYS wait 2-5 minutes after merge before verifying.'], packTemplate: { namespaces: ['memoryError', 'memoryLearning', 'rules'], maxItems: 8, maxChars: 6000, queryPrefix: 'railway deploy health version dockerfile' } },
-  'database-migration': { name: 'database-migration', description: 'Database migration best practices', triggers: ['migration', 'prisma', 'sqlite', 'schema', 'alter table'], rules: ['ALWAYS back up the database before running destructive migrations.', 'NEVER drop columns in production without verifying no code references them.', 'ALWAYS run migrations against a test database first.', 'Use reversible migrations — every up() should have a corresponding down().', 'ALWAYS check for pending migrations before deploying new code.'], packTemplate: { namespaces: ['memoryError', 'rules'], maxItems: 6, maxChars: 5000, queryPrefix: 'migration database schema prisma sqlite' } },
-};
-const registry = new Map(); for (const [id, p] of Object.entries(BUILTIN_PACKS)) registry.set(id, p);
-function ensurePacksDir() { if (!fs.existsSync(SKILL_PACKS_DIR)) fs.mkdirSync(SKILL_PACKS_DIR, { recursive: true }); }
-function registerSkillPack(pack) { if (!pack.name) throw new Error('Skill pack requires a name'); if (!Array.isArray(pack.rules) || pack.rules.length === 0) throw new Error('Skill pack requires at least one rule'); const n = { name: pack.name, description: pack.description || '', triggers: Array.isArray(pack.triggers) ? pack.triggers : [], rules: pack.rules, packTemplate: pack.packTemplate || null, registeredAt: new Date().toISOString() }; registry.set(n.name, n); ensurePacksDir(); fs.writeFileSync(path.join(SKILL_PACKS_DIR, `${n.name}.json`), JSON.stringify(n, null, 2) + '\n'); return n; }
-function loadSkillPacksFromDisk() { ensurePacksDir(); for (const f of fs.readdirSync(SKILL_PACKS_DIR).filter((x) => x.endsWith('.json'))) { try { const p = JSON.parse(fs.readFileSync(path.join(SKILL_PACKS_DIR, f), 'utf-8')); if (p.name) registry.set(p.name, p); } catch { /* skip */ } } }
-function listSkillPacks() { loadSkillPacksFromDisk(); return Array.from(registry.values()).map((p) => ({ name: p.name, description: p.description, triggers: p.triggers, ruleCount: p.rules.length, hasPackTemplate: !!p.packTemplate })); }
-function getSkillPack(name) { loadSkillPacksFromDisk(); return registry.get(name) || null; }
-function matchSkillPacks(query) { const tokens = String(query || '').toLowerCase().split(/\s+/).filter(Boolean); if (tokens.length === 0) return []; loadSkillPacksFromDisk(); const scored = []; for (const pack of registry.values()) { let score = 0; for (const trigger of pack.triggers) { for (const t of trigger.toLowerCase().split(/\s+/)) { if (tokens.some((qt) => qt.includes(t) || t.includes(qt))) score += 1; } } if (score > 0) scored.push({ pack, score }); } return scored.sort((a, b) => b.score - a.score).map((s) => s.pack); }
-function installSkillPackRules(name) { const pack = getSkillPack(name); if (!pack) throw new Error(`Skill pack not found: "${name}"`); return registerPreventionRules([`# Skill Pack: ${pack.name}`, '', pack.description || '', '', ...pack.rules.map((r, i) => `${i + 1}. ${r}`)].join('\n'), { skillPack: pack.name }); }
-// ---------------------------------------------------------------------------
-// L3 Resource Loading (ADK progressive disclosure)
-// ---------------------------------------------------------------------------
-
-const RESOURCES_DIR_NAME = 'references';
-
-/**
- * Load an L3 resource file for a skill pack.
- * Resources live in config/skill-packs/{pack-name}/references/{filename}.
- */
-function loadSkillResource(packName, resourceName) {
-  const resDir = path.join(SKILL_PACKS_DIR, packName, RESOURCES_DIR_NAME);
-  const resPath = path.join(resDir, resourceName);
-  if (!fs.existsSync(resPath)) return null;
-  return { name: resourceName, path: resPath, content: fs.readFileSync(resPath, 'utf-8'), sizeBytes: fs.statSync(resPath).size };
-}
-
-/**
- * List available L3 resources for a skill pack.
- */
-function listSkillResources(packName) {
-  const resDir = path.join(SKILL_PACKS_DIR, packName, RESOURCES_DIR_NAME);
-  if (!fs.existsSync(resDir)) return [];
-  return fs.readdirSync(resDir).filter((f) => !f.startsWith('.')).map((f) => {
-    const fp = path.join(resDir, f);
-    return { name: f, sizeBytes: fs.statSync(fp).size };
-  });
-}
-
-/**
- * Add an L3 resource file to a skill pack.
- */
-function addSkillResource(packName, resourceName, content) {
-  const resDir = path.join(SKILL_PACKS_DIR, packName, RESOURCES_DIR_NAME);
-  ensurePacksDir();
-  if (!fs.existsSync(resDir)) fs.mkdirSync(resDir, { recursive: true });
-  const resPath = path.join(resDir, resourceName);
-  fs.writeFileSync(resPath, content);
-  return { name: resourceName, path: resPath, sizeBytes: Buffer.byteLength(content) };
-}
-
-// ---------------------------------------------------------------------------
-// Skill Factory — agent-driven skill generation
-// ---------------------------------------------------------------------------
-
-/**
- * Auto-generate a skill pack from recurring failure patterns.
- * Uses distilled lessons to propose rules for a new domain.
- *
- * @param {Object} opts
- * @param {string} opts.domain - Domain name (e.g., 'graphql-api')
- * @param {Array} opts.lessons - Array of lesson strings from history distiller
- * @param {string} [opts.description] - Pack description
- * @param {Array} [opts.triggers] - Trigger keywords
- * @returns {Object} The created skill pack
- */
-function generateSkillPack({ domain, lessons, description, triggers } = {}) {
-  if (!domain) throw new Error('Skill factory requires a domain name');
-  if (!Array.isArray(lessons) || lessons.length === 0) throw new Error('Skill factory requires at least one lesson');
-
-  // Convert lessons into NEVER/ALWAYS rules
-  const rules = lessons.map((lesson) => {
-    const l = String(lesson).trim();
-    if (/^(NEVER|ALWAYS|DO NOT|MUST)/i.test(l)) return l;
-    if (/fail|error|broke|wrong|bug|crash/i.test(l)) return `NEVER ${l.replace(/^(avoid|don'?t|stop)\s*/i, '').trim()}`;
-    return `ALWAYS ${l.replace(/^(repeat|keep|continue)\s*/i, '').trim()}`;
-  });
-
-  // Infer triggers from domain + lesson content
-  const inferredTriggers = triggers || [domain, ...domain.split('-').filter((t) => t.length > 2)];
-
-  return registerSkillPack({
-    name: domain,
-    description: description || `Auto-generated skill pack for ${domain} from ${lessons.length} lessons`,
-    triggers: inferredTriggers,
-    rules,
-    packTemplate: { namespaces: ['memoryError', 'memoryLearning', 'rules'], maxItems: 8, maxChars: 6000, queryPrefix: inferredTriggers.join(' ') },
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Token-Efficient Progressive Disclosure Metrics
-// ---------------------------------------------------------------------------
-
-/**
- * Measure token cost of each disclosure level for a skill pack.
- * Helps agents decide which packs to load.
- */
-function measureSkillTokens(packName) {
-  const pack = getSkillPack(packName);
-  if (!pack) return null;
-
-  // L1: metadata only (~name + description + triggers)
-  const l1Text = `${pack.name}: ${pack.description} [${(pack.triggers || []).join(', ')}]`;
-  const l1Chars = l1Text.length;
-
-  // L2: full rules
-  const l2Text = pack.rules.join('\n');
-  const l2Chars = l2Text.length;
-
-  // L3: resources
-  const resources = listSkillResources(packName);
-  const l3Chars = resources.reduce((sum, r) => sum + r.sizeBytes, 0);
-
-  const totalChars = l1Chars + l2Chars + l3Chars;
-
-  return {
-    packName,
-    l1: { chars: l1Chars, estimatedTokens: Math.ceil(l1Chars / 4) },
-    l2: { chars: l2Chars, estimatedTokens: Math.ceil(l2Chars / 4), ruleCount: pack.rules.length },
-    l3: { chars: l3Chars, estimatedTokens: Math.ceil(l3Chars / 4), resourceCount: resources.length },
-    total: { chars: totalChars, estimatedTokens: Math.ceil(totalChars / 4) },
-    disclosureSavings: totalChars > 0 ? Math.round((1 - l1Chars / totalChars) * 100) : 0,
-  };
-}
-
-module.exports = { BUILTIN_PACKS, registerSkillPack, listSkillPacks, getSkillPack, matchSkillPacks, installSkillPackRules, SKILL_PACKS_DIR, loadSkillResource, listSkillResources, addSkillResource, generateSkillPack, measureSkillTokens };

package/scripts/skill-proposer.js

@@ -1,99 +0,0 @@
-#!/usr/bin/env node
-/**
- * Skill Proposer (EvoSkill Phase 1)
- * 
- * Analyzes recurring failure patterns in memory-log.jsonl.
- * Diagnoses the root cause using 'Reasoning' traces and proposes 
- * a new functional skill (tool) to solve the capability gap.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { 
-  parseFeedbackFile, 
-  clusterByTags, 
-  extractTags,
-  discoverFeedbackDir
-} = require('./skill-generator');
-
-function proposeSkills(options = {}) {
-  const feedbackDir = options.feedbackDir || discoverFeedbackDir();
-  const logPath = path.join(feedbackDir, 'memory-log.jsonl');
-  const proposalsDir = path.join(feedbackDir, 'skill-proposals');
-
-  const memories = parseFeedbackFile(logPath);
-  const mistakes = memories.filter(m => m.category === 'error' || m.title.startsWith('MISTAKE:'));
-  
-  if (mistakes.length === 0) {
-    console.log('No mistakes found in memory log.');
-    return [];
-  }
-
-  // Cluster by tags (EvoSkill refinement)
-  const clusters = clusterByTags(mistakes, 2);
-  const proposals = [];
-
-  for (const [tagKey, cluster] of clusters) {
-    if (cluster.entries.length < 2) continue; // Lower threshold for autonomous discovery
-
-    console.log(`Analyzing cluster: [${tagKey}] (${cluster.entries.length} evidences)`);
-
-    // Extract root cause from reasoning traces
-    const reasoningTraces = cluster.entries
-      .map(e => {
-        const match = e.content.match(/Reasoning: (.*)/);
-        return match ? match[1] : null;
-      })
-      .filter(Boolean);
-
-    const commonProblem = cluster.entries[0].title.replace('MISTAKE: ', '');
-    const tags = cluster.tags;
-
-    const proposal = {
-      id: `prop_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      status: 'pending',
-      problem: commonProblem,
-      diagnosis: reasoningTraces.length > 0 ? reasoningTraces[0] : 'Repeated execution failure in this domain.',
-      suggestedSkill: {
-        name: `solve-${tags[0]}-${tags[1] || 'logic'}`.toLowerCase().replace(/[^a-z-]/g, ''),
-        description: `Automated skill to handle ${tags.join(', ')} patterns efficiently.`,
-        tags,
-        // Propose a generic tool structure that the Materializer can flesh out
-        toolSpec: {
-          name: `handle_${tags[0].replace(/-/g, '_')}`,
-          description: `Fixes ${commonProblem}`,
-          parameters: {
-            type: 'object',
-            properties: {
-              context: { type: 'string', description: 'The current task context' }
-            }
-          }
-        }
-      },
-      evidenceIds: cluster.entries.map(e => e.id),
-      timestamp: new Date().toISOString()
-    };
-
-    proposals.push(proposal);
-    
-    if (!fs.existsSync(proposalsDir)) fs.mkdirSync(proposalsDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(proposalsDir, `${proposal.suggestedSkill.name}.json`), 
-      JSON.stringify(proposal, null, 2)
-    );
-  }
-
-  return proposals;
-}
-
-if (require.main === module) {
-  const props = proposeSkills();
-  if (props && props.length > 0) {
-    const feedbackDir = discoverFeedbackDir();
-    const proposalsDir = path.join(feedbackDir, 'skill-proposals');
-    console.log(`\nGenerated ${props.length} skill proposals in ${proposalsDir}`);
-    props.forEach(p => console.log(` - ${p.suggestedSkill.name}: ${p.problem}`));
-  }
-}
-
-module.exports = { proposeSkills };