thumbgate 1.4.2 → 1.4.4

package/scripts/self-healing-check.js

@@ -1,193 +0,0 @@
-#!/usr/bin/env node
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-const { diagnoseFailure } = require('./failure-diagnostics');
-const { appendDiagnosticRecord } = require('./feedback-loop');
-
-const PROJECT_ROOT = path.join(__dirname, '..');
-const DEFAULT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
-const DEFAULT_TESTS_TIMEOUT_MS = Number.parseInt(
-  process.env.THUMBGATE_SELF_HEAL_TEST_TIMEOUT_MS || '',
-  10,
-) || 60 * 60_000;
-
-const DEFAULT_CHECKS = [
-  { name: 'budget_status', command: ['npm', 'run', 'budget:status'], timeoutMs: 60_000 },
-  { name: 'tests', command: ['npm', 'test'], timeoutMs: DEFAULT_TESTS_TIMEOUT_MS },
-  { name: 'prove_adapters', command: ['npm', 'run', 'prove:adapters'], timeoutMs: 10 * 60_000, useTempProofDir: true },
-  { name: 'prove_automation', command: ['npm', 'run', 'prove:automation'], timeoutMs: 10 * 60_000, useTempProofDir: true },
-  { name: 'prove_data_pipeline', command: ['npm', 'run', 'prove:data-pipeline'], timeoutMs: 10 * 60_000, useTempProofDir: true },
-  { name: 'prove_tessl', command: ['npm', 'run', 'prove:tessl'], timeoutMs: 10 * 60_000, useTempProofDir: true },
-];
-
-function runCommand(command, {
-  cwd = PROJECT_ROOT,
-  timeoutMs = 5 * 60_000,
-  env = process.env,
-  maxBufferBytes = DEFAULT_MAX_BUFFER_BYTES,
-} = {}) {
-  const [cmd, ...args] = command;
-  const started = Date.now();
-  const result = spawnSync(cmd, args, {
-    cwd,
-    env,
-    encoding: 'utf-8',
-    timeout: timeoutMs,
-    maxBuffer: maxBufferBytes,
-    shell: false,
-  });
-
-  const durationMs = Date.now() - started;
-  const status = Number.isInteger(result.status) ? result.status : 1;
-  return {
-    exitCode: status,
-    durationMs,
-    stdout: result.stdout || '',
-    stderr: result.stderr || '',
-    error: result.error ? result.error.message : null,
-  };
-}
-
-function createCheckEnvironment(check) {
-  const environment = { ...process.env };
-  let cleanup = null;
-
-  if (check.useTempProofDir) {
-    const proofDir = fs.mkdtempSync(path.join(os.tmpdir(), `thumbgate-${check.name}-`));
-    environment.THUMBGATE_PROOF_DIR = proofDir;
-    if (check.name === 'prove_automation') {
-      environment.THUMBGATE_AUTOMATION_PROOF_DIR = proofDir;
-    }
-    cleanup = () => {
-      fs.rmSync(proofDir, { recursive: true, force: true });
-    };
-  }
-
-  return { env: environment, cleanup };
-}
-
-function collectHealthReport({
-  checks = DEFAULT_CHECKS,
-  runner = runCommand,
-  cwd = PROJECT_ROOT,
-  persistDiagnostics = false,
-} = {}) {
-  const startedAt = new Date();
-  const results = checks.map((check) => {
-    const { env, cleanup } = createCheckEnvironment(check);
-    let run;
-    try {
-      run = runner(check.command, { cwd, timeoutMs: check.timeoutMs, env });
-    } finally {
-      if (cleanup) {
-        cleanup();
-      }
-    }
-    const diagnosis = run.exitCode === 0
-      ? null
-      : diagnoseFailure({
-        step: check.name,
-        context: check.command.join(' '),
-        healthCheck: {
-          name: check.name,
-          exitCode: run.exitCode,
-          status: 'unhealthy',
-          outputTail: `${run.stdout}\n${run.stderr}`.trim().slice(-2000),
-        },
-        exitCode: run.exitCode,
-        error: run.error,
-        output: `${run.stdout}\n${run.stderr}`.trim(),
-      });
-    const persistedDiagnosis = persistDiagnostics && diagnosis
-      ? appendDiagnosticRecord({
-        source: 'self_heal_check',
-        step: check.name,
-        context: check.command.join(' '),
-        diagnosis,
-        metadata: {
-          command: check.command.join(' '),
-        },
-      })
-      : null;
-    return {
-      name: check.name,
-      command: check.command.join(' '),
-      status: run.exitCode === 0 ? 'healthy' : 'unhealthy',
-      exitCode: run.exitCode,
-      durationMs: run.durationMs,
-      error: run.error,
-      outputTail: `${run.stdout}\n${run.stderr}`.trim().slice(-2000),
-      diagnosis,
-      persistedDiagnosis,
-    };
-  });
-
-  const healthyCount = results.filter((x) => x.status === 'healthy').length;
-  const unhealthyCount = results.length - healthyCount;
-
-  return {
-    generatedAt: startedAt.toISOString(),
-    durationMs: Date.now() - startedAt.getTime(),
-    overall_status: unhealthyCount === 0 ? 'healthy' : 'unhealthy',
-    summary: {
-      total: results.length,
-      healthy: healthyCount,
-      unhealthy: unhealthyCount,
-    },
-    checks: results,
-  };
-}
-
-function reportToText(report) {
-  const lines = [];
-  lines.push(`Self-Healing Health Check @ ${report.generatedAt}`);
-  lines.push(`Overall: ${report.overall_status.toUpperCase()}`);
-  lines.push(`Checks: ${report.summary.healthy}/${report.summary.total} healthy`);
-  lines.push('');
-
-  report.checks.forEach((check) => {
-    const icon = check.status === 'healthy' ? '✅' : '❌';
-    lines.push(`${icon} ${check.name} (${check.durationMs}ms)`);
-    if (check.status !== 'healthy') {
-      lines.push(`   command: ${check.command}`);
-      if (check.error) lines.push(`   error: ${check.error}`);
-      if (check.diagnosis && check.diagnosis.rootCauseCategory) {
-        lines.push(`   diagnosis: ${check.diagnosis.rootCauseCategory}`);
-      }
-    }
-  });
-
-  return `${lines.join('\n')}\n`;
-}
-
-function runCli() {
-  const args = new Set(process.argv.slice(2));
-  const emitJson = args.has('--json');
-  const noFail = args.has('--no-fail');
-  const report = collectHealthReport({ persistDiagnostics: true });
-
-  if (emitJson) {
-    console.log(JSON.stringify(report, null, 2));
-  } else {
-    process.stdout.write(reportToText(report));
-  }
-
-  if (!noFail && report.overall_status !== 'healthy') {
-    process.exit(1);
-  }
-}
-
-module.exports = {
-  DEFAULT_CHECKS,
-  DEFAULT_TESTS_TIMEOUT_MS,
-  DEFAULT_MAX_BUFFER_BYTES,
-  runCommand,
-  collectHealthReport,
-  reportToText,
-};
-
-if (require.main === module) {
-  runCli();
-}

package/scripts/shieldcortex-memory-firewall-runner.mjs

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-
-import { readFileSync } from 'node:fs';
-
-async function main() {
-  try {
-    const raw = readFileSync(0, 'utf8');
-    const parsed = raw.trim() ? JSON.parse(raw) : {};
-    const { record = {}, options = {} } = parsed;
-
-    const { ShieldCortexGuardedMemoryBridge } = await import('shieldcortex');
-
-    const backend = {
-      name: 'thumbgate-ingress',
-      async save() {
-        return { id: 'memory-ingress-probe' };
-      },
-    };
-
-    const bridge = new ShieldCortexGuardedMemoryBridge(backend, {
-      mode: options.mode ?? 'strict',
-      sourceType: options.sourceType ?? 'hook',
-      sourceIdentifier: options.sourceIdentifier ?? 'feedback-loop',
-      blockOnThreat: true,
-    });
-
-    const result = await bridge.save(record);
-    const defence = result.defence || {};
-    const firewall = defence.firewall || {};
-
-    process.stdout.write(JSON.stringify({
-      available: true,
-      allowed: Boolean(result.allowed),
-      provider: 'shieldcortex',
-      mode: options.mode ?? 'strict',
-      reason: result.reason || firewall.reason || 'ShieldCortex decision completed.',
-      threatIndicators: Array.isArray(firewall.threatIndicators) ? firewall.threatIndicators : [],
-      blockedPatterns: Array.isArray(firewall.blockedPatterns) ? firewall.blockedPatterns : [],
-      firewallResult: firewall.result || null,
-      anomalyScore: firewall.anomalyScore ?? null,
-      sensitivityLevel: defence.sensitivity ? defence.sensitivity.level : null,
-      trustScore: defence.trust ? defence.trust.score : null,
-      auditId: defence.auditId ?? null,
-    }));
-  } catch (error) {
-    process.stdout.write(JSON.stringify({
-      available: false,
-      error: error.message,
-    }));
-  }
-}
-
-await main();

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 };