mindforge-cc 8.1.1 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/migrations/1.0.0-to-2.0.0.js

@@ -0,0 +1,115 @@
+/**
+ * MindForge Migration: v1.0.0 → v2.0.0 (The Autonomous Enterprise)
+ *
+ * Changes:
+ * 1. AUDIT.jsonl: Add `runtime` and `agent_id` for consistent v2 reporting.
+ * 2. token-usage.jsonl: Add `model_group` for the new analytics dashboard.
+ * 3. HANDOFF.json: Upgrade `plugin_api_version` to 2.0.0.
+ * 4. Hardening: Automatic backup/restore and smart skip logic.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  fromVersion: '1.0.0',
+  toVersion:   '2.0.0',
+  description: 'Additive schema upgrade: backfill runtime/agent_id in audit; model_group in tokens',
+
+  async run(paths) {
+    const backupDir = path.join(path.dirname(paths.handoff), '.backups', `v1-to-v2-${Date.now()}`);
+    
+    // ── Pre-flight: Create backup directory ───────────────────────────────────
+    if (!fs.existsSync(backupDir)) {
+      fs.mkdirSync(backupDir, { recursive: true });
+    }
+
+    const safeMigrate = (filePath, migrateFn) => {
+      if (!fs.existsSync(filePath)) return;
+      
+      const fileName = path.basename(filePath);
+      const backupPath = path.join(backupDir, fileName);
+      
+      try {
+        // Backup
+        fs.copyFileSync(filePath, backupPath);
+        
+        // Migrate
+        const original = fs.readFileSync(filePath, 'utf8');
+        const updated = migrateFn(original);
+        
+        if (original !== updated) {
+          fs.writeFileSync(filePath, updated);
+          console.log(`    • ${fileName}: migrated successfully (backup at .backups/)`);
+        } else {
+          console.log(`    • ${fileName}: already up to date`);
+        }
+      } catch (err) {
+        console.error(`    ❌ ${fileName}: migration failed. Restoring from backup...`);
+        if (fs.existsSync(backupPath)) {
+          fs.copyFileSync(backupPath, filePath);
+        }
+        throw err;
+      }
+    };
+
+    // ── 1. HANDOFF.json ───────────────────────────────────────────────────────
+    safeMigrate(paths.handoff, (raw) => {
+      const data = JSON.parse(raw);
+      if (data.plugin_api_version !== '2.0.0') {
+        data.plugin_api_version = '2.0.0';
+        return JSON.stringify(data, null, 2) + '\n';
+      }
+      return raw;
+    });
+
+    // ── 2. AUDIT.jsonl ────────────────────────────────────────────────────────
+    safeMigrate(paths.audit, (raw) => {
+      const lines = raw.split('\n').filter(Boolean);
+      let modified = 0;
+      
+      const updated = lines.map(line => {
+        try {
+          const entry = JSON.parse(line);
+          let changed = false;
+          if (!entry.runtime) { entry.runtime = 'unknown'; changed = true; }
+          if (!entry.agent_id) { entry.agent_id = 'migrated-v1'; changed = true; }
+          
+          if (changed) {
+            modified++;
+            return JSON.stringify(entry);
+          }
+          return line;
+        } catch {
+          return line;
+        }
+      });
+      
+      return modified > 0 ? updated.join('\n') + '\n' : raw;
+    });
+
+    // ── 3. token-usage.jsonl ──────────────────────────────────────────────────
+    const tokensFile = path.join(path.dirname(paths.handoff), 'token-usage.jsonl');
+    safeMigrate(tokensFile, (raw) => {
+      const lines = raw.split('\n').filter(Boolean);
+      let modified = 0;
+      
+      const updated = lines.map(line => {
+        try {
+          const entry = JSON.parse(line);
+          if (!entry.model_group) {
+            entry.model_group = 'unknown';
+            modified++;
+            return JSON.stringify(entry);
+          }
+          return line;
+        } catch {
+          return line;
+        }
+      });
+      
+      return modified > 0 ? updated.join('\n') + '\n' : raw;
+    });
+  },
+};

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/migrations/migrate.js

@@ -0,0 +1,155 @@
+/**
+ * MindForge — Migration Runner
+ * Safely upgrades .planning/ file schemas between MindForge versions.
+ * Philosophy: never lose data, always back up, always verify after.
+ */
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+// Re-export for use by self-update.js
+const { compareSemver } = require('../updater/version-comparator');
+module.exports.compareSemver = compareSemver;
+
+const PLANNING_DIR = path.join(process.cwd(), '.planning');
+
+const PATHS = {
+  handoff:    path.join(PLANNING_DIR, 'HANDOFF.json'),
+  state:      path.join(PLANNING_DIR, 'STATE.md'),
+  audit:      path.join(PLANNING_DIR, 'AUDIT.jsonl'),
+  mindforgemd: path.join(process.cwd(), 'MINDFORGE.md'),
+};
+
+/**
+ * Run all needed migrations from fromVersion to toVersion.
+ * Creates a backup first. Restores on failure.
+ * Returns { status, from, to, backupDir }
+ */
+async function runMigrations(fromVersion, toVersion) {
+  console.log(`\n  Migration: v${fromVersion} → v${toVersion}`);
+
+  if (!fs.existsSync(PLANNING_DIR)) {
+    console.log('  ℹ️  No .planning/ directory found — skipping migration');
+    return { status: 'no-planning-dir' };
+  }
+
+  if (compareSemver(fromVersion, toVersion) >= 0) {
+    console.log('  ✅  No migration needed');
+    return { status: 'no-migration-needed' };
+  }
+
+  // Determine which migrations to run
+  const allMigrations = [
+    require('./0.1.0-to-0.5.0'),
+    require('./0.5.0-to-0.6.0'),
+    require('./0.6.0-to-1.0.0'),
+  ];
+
+  // A migration should run if its DESTINATION VERSION falls within the range:
+  // (fromVersion, toVersion] — i.e., greater than fromVersion AND at most toVersion
+  const migrationsToRun = allMigrations.filter(m =>
+    compareSemver(m.toVersion, fromVersion) > 0 &&
+    compareSemver(m.toVersion, toVersion)   <= 0
+  );
+
+  if (migrationsToRun.length === 0) {
+    console.log('  ✅  No applicable migrations');
+    return { status: 'no-migrations' };
+  }
+
+  console.log(`  Migrations to run (${migrationsToRun.length}):`);
+  migrationsToRun.forEach(m => console.log(`    • v${m.fromVersion} → v${m.toVersion}: ${m.description}`));
+
+  // ── Create backup (abort if backup fails — never migrate without a backup) ──
+  const backupDir = path.join(PLANNING_DIR, `migration-backup-${Date.now()}`);
+  let backupCreated = false;
+  try {
+    fs.mkdirSync(backupDir, { recursive: true });
+    const filesToBackup = Object.values(PATHS).filter(p => fs.existsSync(p));
+
+    if (filesToBackup.length === 0) {
+      console.log('  ℹ️  No files to migrate');
+      fs.rmdirSync(backupDir);
+      return { status: 'no-files' };
+    }
+
+    for (const f of filesToBackup) {
+      fs.copyFileSync(f, path.join(backupDir, path.basename(f)));
+    }
+
+    // Verify backup: check every backed-up file exists and has content
+    const backed = fs.readdirSync(backupDir);
+    const allBacked = filesToBackup.every(f =>
+      backed.includes(path.basename(f)) &&
+      fs.statSync(path.join(backupDir, path.basename(f))).size > 0
+    );
+
+    if (!allBacked) throw new Error('Backup verification failed — some files missing or empty');
+
+    backupCreated = true;
+    console.log(`  📦 Backup: .planning/${path.basename(backupDir)} (${filesToBackup.length} files)`);
+
+  } catch (backupErr) {
+    // Abort cleanly — no migration is safer than a migration without backup
+    if (fs.existsSync(backupDir)) {
+      try {
+        fs.rmSync(backupDir, { recursive: true, force: true });
+      } catch (err) {
+        // Ignore backup cleanup failures if backup creation already failed
+      }
+    }
+    throw new Error(
+      `Migration aborted: cannot create backup (${backupErr.message}). ` +
+      'Free disk space and retry.'
+    );
+  }
+
+  // ── Execute migrations in order ───────────────────────────────────────────
+  for (const migration of migrationsToRun) {
+    console.log(`\n  Running: v${migration.fromVersion} → v${migration.toVersion}...`);
+    try {
+      await migration.run(PATHS);
+      console.log('  ✅  Complete');
+    } catch (migErr) {
+      console.error(`  ❌  Failed: ${migErr.message}`);
+      console.log('  Restoring from backup...');
+
+      // Restore all files from backup
+      for (const f of fs.readdirSync(backupDir)) {
+        const dst = Object.values(PATHS).find(p => path.basename(p) === f) ||
+                    path.join(PLANNING_DIR, f);
+        fs.copyFileSync(path.join(backupDir, f), dst);
+      }
+      console.log('  ✅  Restored from backup. No changes applied.');
+      throw new Error(`Migration failed at v${migration.toVersion}: ${migErr.message}`);
+    }
+  }
+
+  // ── Update schema_version in HANDOFF.json ────────────────────────────────
+  if (fs.existsSync(PATHS.handoff)) {
+    const handoff = JSON.parse(fs.readFileSync(PATHS.handoff, 'utf8'));
+    handoff.schema_version = toVersion;
+    handoff._migration_completed = new Date().toISOString();
+    fs.writeFileSync(PATHS.handoff, JSON.stringify(handoff, null, 2) + '\n');
+  }
+
+  console.log(`\n  ✅  All migrations complete: v${fromVersion} → v${toVersion}`);
+
+  // ── Post-migration: clean up in CI, retain in interactive ─────────────────
+  if (process.env.CI === 'true') {
+    try {
+      fs.rmSync(backupDir, { recursive: true, force: true });
+      console.log('  🗑️  CI mode: backup auto-deleted (disk space)');
+    } catch (err) {
+      // Silent failure on cleanup — migration succeeded, cleanup is optional
+    }
+  } else {
+    console.log(`  Backup retained: .planning/${path.basename(backupDir)}`);
+    console.log(`  Remove when satisfied: rm -rf .planning/${path.basename(backupDir)}\n`);
+  }
+
+  return { status: 'migrated', from: fromVersion, to: toVersion, backupDir };
+}
+
+module.exports.runMigrations = runMigrations;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/migrations/schema-versions.js

@@ -0,0 +1,76 @@
+/**
+ * MindForge — Schema Version Registry
+ * Documents every breaking schema change across all released versions.
+ * Used by the migration engine to determine what migrations are needed.
+ */
+'use strict';
+
+const SCHEMA_HISTORY = [
+  {
+    version: '0.1.0',
+    date: '2026-01-01',
+    description: 'Initial release',
+    handoff_fields_added: [
+      'schema_version', 'project', 'phase', 'plan', 'next_task',
+      'blockers', 'decisions_needed', 'context_refs', '_warning', 'updated_at',
+    ],
+    handoff_fields_removed: [],
+    audit_fields_added: ['id', 'timestamp', 'event', 'agent', 'phase'],
+    breaking: [],
+  },
+  {
+    version: '0.5.0',
+    date: '2026-01-15',
+    description: 'Intelligence layer — smart compaction adds structured fields',
+    handoff_fields_added: [
+      'decisions_made', 'discoveries', 'implicit_knowledge',
+      'quality_signals', 'compaction_level', 'compaction_timestamp',
+    ],
+    handoff_fields_removed: [],
+    audit_fields_added: [],
+    breaking: [
+      'compaction_protocol.md now requires Level 1/2/3 classification',
+    ],
+  },
+  {
+    version: '0.6.0',
+    date: '2026-02-01',
+    description: 'Distribution platform — adds per-developer and CI fields',
+    handoff_fields_added: [
+      'developer_id', 'session_id', 'recent_commits', 'recent_files',
+    ],
+    handoff_fields_removed: [],
+    audit_fields_added: ['session_id'],
+    breaking: [
+      'AUDIT.jsonl entries should now include session_id',
+      'INTEGRATIONS-CONFIG.md gains EMERGENCY_APPROVERS field',
+    ],
+  },
+  {
+    version: '1.0.0',
+    date: '2026-03-22',
+    description: 'First stable release — plugin system and stable interface contract',
+    handoff_fields_added: ['plugin_api_version'],
+    handoff_fields_removed: [],
+    audit_fields_added: [],
+    breaking: [
+      'VERIFY_PASS_RATE_WARNING_THRESHOLD in MINDFORGE.md is now 0.0-1.0 (was 0-100)',
+      'AUDIT.jsonl session_id is now required (was optional)',
+      'HANDOFF.json plugin_api_version field is now required for plugin compatibility',
+    ],
+  },
+  {
+    version: '2.0.0',
+    date: '2026-03-23',
+    description: 'v2.0.0 - The Autonomous Enterprise: multi-runtime and enhanced governance',
+    handoff_fields_added: [],
+    handoff_fields_removed: [],
+    audit_fields_added: ['runtime', 'agent_id'],
+    breaking: [
+      'Additive migration required to backfill audit/token fields',
+      'Plugin API version upgraded to 2.0.0',
+    ],
+  },
+];
+
+module.exports = { SCHEMA_HISTORY };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/migrations/v8-sqlite-migration.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+const vectorHub = require('../memory/vector-hub');
+
+/**
+ * MindForge v8 SQLite Migration Script
+ * Migrates legacy .json and .jsonl state into VectorHub.
+ */
+async function runMigration() {
+  console.log('[MIGRATION] Starting MindForge v8 (Celestial) SQLite migration...');
+  
+  await vectorHub.init();
+
+  // 1. Migrate Remediation Queue
+  const remPath = path.join(process.cwd(), '.mindforge', 'remediation-queue.json');
+  if (fs.existsSync(remPath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(remPath, 'utf8'));
+      console.log(`[MIGRATION] Migrating ${data.length} remediations...`);
+      for (const rem of data) {
+        await vectorHub.db.insertInto('remediations')
+          .values({
+            id: rem.remediation_id,
+            trace_id: rem.span_id, // Mapping span_id to trace_id for legacy compatibility
+            strategy: rem.strategy,
+            status: rem.status,
+            timestamp: rem.timestamp || new Date().toISOString(),
+            outcome: rem.status === 'SUCCESS' ? 'Legacy Success' : null
+          })
+          .onConflict(oc => oc.column('id').doNothing())
+          .execute();
+      }
+    } catch (err) {
+      console.warn(`[MIGRATION] Failed to migrate remediations: ${err.message}`);
+    }
+  }
+
+  // 2. Migrate Audit Traces (AUDIT.jsonl)
+  const auditPath = path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
+  if (fs.existsSync(auditPath)) {
+    try {
+      const lines = fs.readFileSync(auditPath, 'utf8').split('\n').filter(Boolean);
+      console.log(`[MIGRATION] Migrating ${lines.length} audit trace lines...`);
+      
+      for (const line of lines) {
+        const entry = JSON.parse(line);
+        if (entry.event === 'reasoning_trace' || entry.event === 'drift_remediation_event') {
+          await vectorHub.recordTrace({
+            id: entry.id,
+            trace_id: entry.trace_id || 'legacy_trace',
+            span_id: entry.span_id || null,
+            event: entry.event,
+            timestamp: entry.timestamp,
+            agent: entry.agent || null,
+            content: entry.thought || entry.strategy || null,
+            metadata: entry,
+            drift_score: entry.drift_score || 0
+          });
+        }
+      }
+    } catch (err) {
+      console.warn(`[MIGRATION] Failed to migrate audit traces: ${err.message}`);
+    }
+  }
+
+  // 3. Set Mesh Node Identity
+  await vectorHub.db.insertInto('mesh_config')
+    .values({ key: 'mesh_node_id', value: `mindforge-node-${Math.random().toString(36).substr(2, 6)}` })
+    .onConflict(oc => oc.column('key').doNothing())
+    .execute();
+
+  await vectorHub.db.insertInto('mesh_config')
+    .values({ key: 'v8_migration_complete', value: new Date().toISOString() })
+    .onConflict(oc => oc.column('key').doNothing())
+    .execute();
+
+  console.log('[MIGRATION] MindForge v8 Migration Successful.');
+  await vectorHub.close();
+}
+
+if (require.main === module) {
+  runMigration().catch(console.error);
+}
+
+module.exports = runMigration;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/mindforge-cc.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# MindForge Local Verification Wrapper
+# Usage: node bin/mindforge-cc.sh [args]
+
+node "$(dirname "$0")/install.js" "$@"

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/mindforge-cli.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * MindForge CLI Router — v2.0.0
+ * Standardizes command invocation for GitHub Actions and local development.
+ */
+
+'use strict';
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const ARGS = process.argv.slice(2);
+const COMMAND = ARGS[0];
+const COMMAND_ARGS = ARGS.slice(1);
+
+const ROOT = path.resolve(__dirname, '..');
+
+const COMMANDS = {
+  'security-scan': {
+    script: 'bin/validate-config.js',
+    description: 'Validate configuration and run security checks',
+    defaultArgs: ['MINDFORGE.md']
+  },
+  'health': {
+    script: 'bin/installer-core.js',
+    description: 'Verify project health and installation integrity',
+    defaultArgs: ['--check']
+  },
+  'headless': {
+    script: 'bin/autonomous/headless.js',
+    description: 'Run MindForge agent in headless mode'
+  },
+  'pr-review': {
+    script: 'bin/review/cross-review-engine.js',
+    description: 'Run standard PR review logic'
+  },
+  'cross-review': {
+    script: 'bin/review/cross-review-engine.js',
+    description: 'Run advanced cross-model review'
+  },
+  'classify': {
+    script: 'bin/change-classifier.js',
+    description: 'Classify changes into governance tiers'
+  },
+  'approve': {
+    script: 'bin/governance/approve.js',
+    description: 'Generate a governance approval signature to unblock Tier 3 gates'
+  },
+  'validate-skill': {
+    script: 'bin/skill-validator.js',
+    description: 'Run Level 1 & 2 validation on a SKILL.md file'
+  },
+  'install-skill': {
+    script: 'bin/skill-registry.js',
+    description: 'Install a skill to the correct tier folder (Tier 1/2/3)',
+    defaultArgs: ['install']
+  },
+  'register-skill': {
+    script: 'bin/skill-registry.js',
+    description: 'Register a skill in MANIFEST.md',
+    defaultArgs: ['register']
+  },
+  'audit-skill': {
+    script: 'bin/skill-registry.js',
+    description: 'Record skill life cycle events in audit log',
+    defaultArgs: ['audit']
+  },
+  'remember': {
+    script: 'bin/memory/cli.js',
+    description: 'Manage the MindForge long-term memory (knowledge graph)'
+  },
+  'test-memory': {
+    script: 'tests/memory.test.js',
+    description: 'Run the persistent memory test suite'
+  },
+  'learn-skill': {
+    script: 'bin/skills-builder/learn-cli.js',
+    description: 'Ingest source and generate a validated SKILL.md'
+  },
+  'marketplace': {
+    script: 'bin/skills-builder/marketplace-cli.js',
+    description: 'Search and install community skills from the marketplace'
+  },
+  'spawn': {
+    script: 'bin/spawn-agent.js',
+    description: 'Spawn a persona essence (e.g., mf-planner)',
+    defaultArgs: ['spawn']
+  },
+  'identity': {
+    script: 'bin/spawn-agent.js',
+    description: 'Invoke a specialized identity from /agents/',
+    defaultArgs: ['identity']
+  },
+  'temporal': {
+    script: 'bin/engine/temporal-cli.js',
+    description: 'Manage time-travel debugging and state history'
+  },
+  'hindsight': {
+    script: 'bin/engine/temporal-cli.js',
+    description: 'Inject a fix into a past point and regenerate state',
+    defaultArgs: ['inject']
+  },
+  'harvest': {
+    script: 'bin/autonomous/intent-harvester.js',
+    description: 'Proactively harvest semantic intent from the intelligence mesh'
+  },
+  'self-heal': {
+    script: 'bin/autonomous/mesh-self-healer.js',
+    description: 'Auto-detect and repair reasoning drifts in the active swarm'
+  },
+  'quantum-verify': {
+    script: 'bin/governance/quantum-crypto.js',
+    description: 'Verify framework integrity using post-quantum signatures',
+    defaultArgs: ['--verify', '.mindforge/engine/']
+  },
+  'sync-jira': {
+    script: 'bin/integrations/jira-sync.js',
+    description: 'Synchronize project state with Jira issues and milestones'
+  },
+  'sync-confluence': {
+    script: 'bin/integrations/confluence-sync.js',
+    description: 'Export architecture and roadmap to Confluence pages'
+  },
+  'metrics': {
+    script: 'bin/dashboard/metrics-aggregator.js',
+    description: 'Display real-time velocity and quality metrics'
+  },
+  'tokens': {
+    script: 'bin/models/cost-tracker.js',
+    description: 'Analyze token consumption and cost efficiency',
+    defaultArgs: ['--report']
+  },
+  'learning': {
+    script: 'bin/engine/learning-manager.js',
+    description: 'Consult or initialize the project agentic learning memory'
+  },
+  'record-learning': {
+    script: 'bin/engine/learning-manager.js',
+    description: 'Append a new Learning Entry to the Evolution Log',
+    defaultArgs: ['record']
+  }
+};
+
+if (!COMMAND || ARGS.includes('--help') || ARGS.includes('-h')) {
+  printUsage();
+  process.exit(0);
+}
+
+const target = COMMANDS[COMMAND];
+if (!target) {
+  console.error(`❌ Unknown command: ${COMMAND}`);
+  console.error('Available commands: ' + Object.keys(COMMANDS).join(', '));
+  process.exit(1);
+}
+
+const scriptPath = path.join(ROOT, target.script);
+const finalArgs = COMMAND_ARGS.length > 0 ? COMMAND_ARGS : (target.defaultArgs || []);
+
+console.log(`🚀 Executing: ${COMMAND} (${target.description})`);
+
+const result = spawnSync('node', [scriptPath, ...finalArgs], {
+  cwd: ROOT,
+  stdio: 'inherit',
+  env: { ...process.env, MINDFORGE_CLI: 'true' }
+});
+
+process.exit(result.status || 0);
+
+function printUsage() {
+  console.log('\n⚡ MindForge Enterprise CLI\n');
+  console.log('Usage: node bin/mindforge-cli.js <command> [options]\n');
+  console.log('Commands:');
+  for (const [name, cfg] of Object.entries(COMMANDS)) {
+    console.log(`  ${name.padEnd(15)} ${cfg.description}`);
+  }
+  console.log('\nExamples:');
+  console.log('  node bin/mindforge-cli.js security-scan');
+  console.log('  node bin/mindforge-cli.js headless --phase 1');
+  console.log('\n');
+}

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/anthropic-provider.js

@@ -0,0 +1,77 @@
+/**
+ * MindForge v2 — Anthropic Provider
+ */
+'use strict';
+
+const https = require('https');
+
+class AnthropicProvider {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+
+  async complete(params) {
+    const { model, systemPrompt, userMessage, maxTokens = 4096, temperature = 0.7 } = params;
+
+    const data = JSON.stringify({
+      model,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userMessage }],
+      max_tokens: maxTokens,
+      temperature,
+    });
+
+    return new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: 'api.anthropic.com',
+        path: '/v1/messages',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01',
+          'Content-Length': Buffer.byteLength(data),
+        },
+        timeout: 120_000,
+      }, res => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(body);
+            if (res.statusCode !== 200) {
+              return reject(Object.assign(new Error(json.error?.message || 'Anthropic API error'), { status: res.statusCode }));
+            }
+
+            const inputTokens = json.usage.input_tokens;
+            const outputTokens = json.usage.output_tokens;
+            
+            // Basic cost calculation (Sonnet 3.5 prices)
+            const cost = (inputTokens * 0.000003) + (outputTokens * 0.000015);
+
+            resolve({
+              model: json.model,
+              content: json.content[0].text,
+              input_tokens: inputTokens,
+              output_tokens: outputTokens,
+              cost_usd: cost,
+              provider: 'anthropic'
+            });
+          } catch (e) {
+            reject(new Error('Failed to parse Anthropic response: ' + e.message));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(Object.assign(new Error('Anthropic timeout'), { status: 408 }));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
+}
+
+module.exports = AnthropicProvider;