mindforge-cc 1.0.4 → 2.0.0-alpha.4

package/bin/memory/knowledge-store.js

@@ -0,0 +1,319 @@
+/**
+ * MindForge v2 — Knowledge Store
+ * Append-only JSONL knowledge base with CRUD-like operations.
+ *
+ * Philosophy:
+ * - NEVER delete entries — deprecate instead (audit trail)
+ * - NEVER update entries in-place — append new version, deprecate old
+ * - All writes are atomic (append to JSONL is atomic on POSIX)
+ * - Reads are always full scan + in-memory filter (files stay small)
+ */
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const crypto = require('crypto');
+
+// ── Paths ─────────────────────────────────────────────────────────────────────
+let baseDir = process.cwd();
+let globalBaseDir = os.homedir();
+
+/**
+ * Configure the base directory for memory (useful for testing).
+ */
+function setBaseDir(dir) {
+  baseDir = dir;
+}
+
+/**
+ * Configure the global base directory (useful for testing).
+ */
+function setGlobalDir(dir) {
+  globalBaseDir = dir;
+}
+
+function getPaths() {
+  const memoryDir = path.join(baseDir, '.mindforge', 'memory');
+  const globalDir = path.join(globalBaseDir, '.mindforge');
+  return {
+    MEMORY_DIR:       memoryDir,
+    GLOBAL_DIR:       globalDir,
+    KB_PATH:          path.join(memoryDir, 'knowledge-base.jsonl'),
+    GLOBAL_KB_PATH:   path.join(globalDir, 'global-knowledge-base.jsonl'),
+    DECISION_PATH:    path.join(memoryDir, 'decision-library.jsonl'),
+    PATTERN_PATH:     path.join(memoryDir, 'pattern-library.jsonl'),
+    PREFERENCES_PATH: path.join(memoryDir, 'team-preferences.jsonl'),
+  };
+}
+
+/**
+ * Generates a UUID v4.
+ */
+function generateId() {
+  return crypto.randomUUID();
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function getFilePath(type) {
+  const paths = getPaths();
+  switch (type) {
+    case 'architectural_decision': return paths.DECISION_PATH;
+    case 'code_pattern':           return paths.PATTERN_PATH;
+    case 'team_preference':        return paths.PREFERENCES_PATH;
+    default:                       return paths.KB_PATH; // bug_pattern, domain_knowledge, all others
+  }
+}
+
+// ── Write operations ──────────────────────────────────────────────────────────
+
+/**
+ * Append a new knowledge entry.
+ * @param {object} entry - Entry data (without id, timestamp, times_referenced)
+ * @returns {string} The new entry's ID
+ */
+function add(entry) {
+  const paths = getPaths();
+  ensureDir(paths.MEMORY_DIR);
+
+  if (!entry.type)    throw new Error('Knowledge entry requires a "type" field');
+  if (!entry.topic)   throw new Error('Knowledge entry requires a "topic" field');
+  if (!entry.content) throw new Error('Knowledge entry requires a "content" field');
+
+  const id = entry.id || generateId();
+  const now = new Date().toISOString();
+
+  const full = {
+    id,
+    timestamp: now,
+    type:              entry.type,
+    topic:             entry.topic.slice(0, 80), // Enforce max topic length
+    content:           entry.content,
+    source:            entry.source || 'manual',
+    project:           entry.project || readProjectName(),
+    confidence:        Math.min(1.0, Math.max(0.0, entry.confidence ?? 0.7)),
+    tags:              Array.isArray(entry.tags) ? entry.tags : [],
+    linked_adrs:       Array.isArray(entry.linked_adrs) ? entry.linked_adrs : [],
+    times_referenced:  entry.times_referenced || 0,
+    last_referenced:   entry.last_referenced || null,
+    deprecated:        false,
+    deprecated_by:     null,
+    // Type-specific fields
+    ...(entry.decision     && { decision:     entry.decision }),
+    ...(entry.rationale    && { rationale:    entry.rationale }),
+    ...(entry.alternatives && { alternatives: entry.alternatives }),
+    ...(entry.adr_reference && { adr_reference: entry.adr_reference }),
+    ...(entry.pattern_type && { pattern_type: entry.pattern_type }),
+    ...(entry.language     && { language:     entry.language }),
+    ...(entry.example_good && { example_good: entry.example_good }),
+    ...(entry.example_bad  && { example_bad:  entry.example_bad }),
+    ...(entry.bug_category && { bug_category: entry.bug_category }),
+    ...(entry.root_cause   && { root_cause:   entry.root_cause }),
+    ...(entry.fix          && { fix:          entry.fix }),
+    ...(entry.preference   && { preference:   entry.preference }),
+    ...(entry.strength     && { strength:     entry.strength }),
+    ...(entry.domain       && { domain:       entry.domain }),
+    ...(entry.tech_stack   && { tech_stack:   entry.tech_stack }),
+  };
+
+  const filePath = getFilePath(entry.type);
+  fs.appendFileSync(filePath, JSON.stringify(full) + '\n');
+
+  // Also append to unified knowledge-base.jsonl for cross-type queries
+  if (filePath !== paths.KB_PATH) {
+    fs.appendFileSync(paths.KB_PATH, JSON.stringify(full) + '\n');
+  }
+
+  return id;
+}
+
+/**
+ * Deprecate an entry (never hard-delete).
+ */
+function deprecate(id, reason, supersededBy = null) {
+  const paths = getPaths();
+  const entries = readAll();
+  const entry   = entries.find(e => e.id === id);
+  if (!entry) throw new Error(`Knowledge entry not found: ${id}`);
+
+  // Append a deprecation marker (new entry with same id, deprecated=true)
+  const filePath = getFilePath(entry.type);
+  const deprecated = {
+    ...entry,
+    deprecated:        true,
+    deprecated_by:     supersededBy,
+    deprecated_reason: reason,
+    deprecated_at:     new Date().toISOString(),
+  };
+
+  fs.appendFileSync(filePath, JSON.stringify(deprecated) + '\n');
+  if (filePath !== paths.KB_PATH) {
+    fs.appendFileSync(paths.KB_PATH, JSON.stringify(deprecated) + '\n');
+  }
+
+  return id;
+}
+
+/**
+ * Reinforce an entry (increase confidence, increment reference count).
+ */
+function reinforce(id) {
+  const paths = getPaths();
+  const entries   = readAll();
+  const entry     = entries.find(e => e.id === id && !e.deprecated);
+  if (!entry) return;
+
+  const reinforced = {
+    ...entry,
+    confidence:       Math.min(1.0, entry.confidence + 0.05),
+    times_referenced: entry.times_referenced + 1,
+    last_referenced:  new Date().toISOString(),
+  };
+
+  const filePath = getFilePath(entry.type);
+  fs.appendFileSync(filePath, JSON.stringify(reinforced) + '\n');
+  if (filePath !== paths.KB_PATH) {
+    fs.appendFileSync(paths.KB_PATH, JSON.stringify(reinforced) + '\n');
+  }
+}
+
+// ── Read operations ───────────────────────────────────────────────────────────
+
+/**
+ * Read all entries from a JSONL file.
+ * Handles the append pattern: later entries with same ID supersede earlier ones.
+ */
+function readFile(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+
+  const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+  const byId  = new Map(); // Later entries (same ID) win
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      byId.set(entry.id, entry); // Last write wins
+    } catch {
+      // Skip malformed lines — never crash on corrupt JSONL
+    }
+  }
+
+  return [...byId.values()];
+}
+
+function readAll(includeGlobal = false) {
+  const paths = getPaths();
+  let entries = readFile(paths.KB_PATH);
+  if (includeGlobal && fs.existsSync(paths.GLOBAL_KB_PATH)) {
+    const globalEntries = readFile(paths.GLOBAL_KB_PATH).map(e => ({ ...e, global: true }));
+    entries = [...entries, ...globalEntries];
+  }
+  return entries;
+}
+
+function readByType(type) {
+  return readFile(getFilePath(type)).filter(e => e.type === type);
+}
+
+// ── Query operations ──────────────────────────────────────────────────────────
+
+/**
+ * Query the knowledge base.
+ * Returns entries sorted by relevance score (confidence × recency × tag overlap).
+ */
+function query(params = {}) {
+  const {
+    tags          = [],
+    topic,
+    type,
+    minConfidence = 0.3,
+    limit         = 20,
+    includeGlobal = false,
+    includeDeprecated = false,
+    project,
+  } = params;
+
+  let entries = readAll(includeGlobal);
+
+  // Filter
+  if (!includeDeprecated) entries = entries.filter(e => !e.deprecated);
+  if (type)               entries = entries.filter(e => e.type === type);
+  if (project)            entries = entries.filter(e => !e.project || e.project === project);
+  entries = entries.filter(e => e.confidence >= minConfidence);
+
+  // Score entries by relevance
+  const scored = entries.map(e => ({
+    entry: e,
+    score: scoreRelevance(e, { tags, topic }),
+  }));
+
+  return scored
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map(s => s.entry);
+}
+
+function scoreRelevance(entry, { tags = [], topic = '' }) {
+  let score = entry.confidence; // Base score from confidence
+
+  // Tag overlap
+  const entryTags = entry.tags || [];
+  const tagOverlap = tags.filter(t => entryTags.some(et => et.toLowerCase() === t.toLowerCase())).length;
+  score += tagOverlap * 0.2;
+
+  // Topic text match
+  if (topic) {
+    const topicWords = topic.toLowerCase().split(/\s+/);
+    const entryText  = `${entry.topic} ${entry.content}`.toLowerCase();
+    const wordMatches = topicWords.filter(w => w.length > 3 && entryText.includes(w)).length;
+    score += (wordMatches / Math.max(topicWords.length, 1)) * 0.3;
+  }
+
+  // Recency boost (entries referenced in last 30 days get a small boost)
+  if (entry.last_referenced) {
+    const daysSince = (Date.now() - new Date(entry.last_referenced).getTime()) / 86_400_000;
+    if (daysSince < 30) score += 0.1 * (1 - daysSince / 30);
+  }
+
+  // Penalty for very low reference count (may be noisy)
+  if (entry.times_referenced === 0) score *= 0.9;
+
+  return score;
+}
+
+// ── Project name helper ───────────────────────────────────────────────────────
+function readProjectName() {
+  const projectMd = path.join(process.cwd(), '.planning', 'PROJECT.md');
+  if (!fs.existsSync(projectMd)) return 'unknown';
+  const match = fs.readFileSync(projectMd, 'utf8').match(/^# (.+)/m);
+  return match?.[1]?.trim().slice(0, 50) || 'unknown';
+}
+
+// ── Statistics ────────────────────────────────────────────────────────────────
+function stats() {
+  const all    = readAll();
+  const active = all.filter(e => !e.deprecated);
+  const byType = {};
+  for (const e of active) {
+    byType[e.type] = (byType[e.type] || 0) + 1;
+  }
+  return {
+    total_entries:      all.length,
+    active_entries:     active.length,
+    deprecated_entries: all.length - active.length,
+    by_type:            byType,
+    avg_confidence:     active.length
+      ? active.reduce((s, e) => s + e.confidence, 0) / active.length
+      : 0,
+  };
+}
+
+module.exports = {
+  add, deprecate, reinforce,
+  readAll, readByType, readFile, query, stats,
+  setBaseDir, setGlobalDir, getPaths,
+};

package/bin/memory/session-memory-loader.js

@@ -0,0 +1,137 @@
+/**
+ * MindForge v2 — Session Memory Loader
+ * Loads relevant knowledge at session start and formats it for CLAUDE.md injection.
+ *
+ * Called at session boot to populate the agent with accumulated knowledge
+ * before any task begins.
+ */
+'use strict';
+
+const fs      = require('fs');
+const path    = require('path');
+const Indexer = require('./knowledge-indexer');
+const Store   = require('./knowledge-store');
+
+/**
+ * Load relevant session context from the knowledge graph.
+ * Returns a formatted string for injection into agent context at session start.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.techStack  - Tech stack from PROJECT.md (for relevance filtering)
+ * @param {string}   opts.phase      - Current phase description
+ * @param {string}   opts.topic      - Current task/topic focus
+ * @param {number}   opts.maxEntries - Maximum entries to load (default: 20)
+ */
+function loadForSession(opts = {}) {
+  const { techStack = [], phase = '', topic = '', maxEntries = 20 } = opts;
+
+  const context = Indexer.loadSessionContext({ techStack, phase, topic });
+  const allLoaded = [
+    ...context.preferences,
+    ...context.decisions,
+    ...context.bugPatterns,
+    ...context.codePatterns,
+    ...context.domain,
+  ];
+
+  if (allLoaded.length === 0) {
+    return { formatted: '', entries: [], count: 0 };
+  }
+
+  // Reinforce all loaded entries (they are being actively used)
+  for (const entry of allLoaded) {
+    try { Store.reinforce(entry.id); } catch (e) { /* ignore cleanup errors */ }
+  }
+
+  const formatted = formatForContext(context);
+
+  return {
+    formatted,
+    entries:     allLoaded,
+    count:       allLoaded.length,
+    preferences: context.preferences.length,
+    decisions:   context.decisions.length,
+    bugPatterns: context.bugPatterns.length,
+    codePatterns: context.codePatterns.length,
+    domain:      context.domain.length,
+  };
+}
+
+/**
+ * Format loaded knowledge entries for agent context injection.
+ */
+function formatForContext(context) {
+  const sections = [];
+
+  if (context.preferences.length > 0) {
+    sections.push('### Team Preferences');
+    context.preferences.forEach(e => {
+      sections.push(`- [${(e.confidence * 100).toFixed(0)}% confidence] ${e.topic}: ${e.content.slice(0, 200)}`);
+    });
+  }
+
+  if (context.decisions.length > 0) {
+    sections.push('\n### Architectural Decisions (from this project)');
+    context.decisions.forEach(e => {
+      const adr = e.adr_reference ? ` (${e.adr_reference})` : '';
+      sections.push(`- ${e.topic}${adr}: ${e.content.slice(0, 200)}`);
+    });
+  }
+
+  if (context.bugPatterns.length > 0) {
+    sections.push('\n### Bug Patterns to Avoid');
+    context.bugPatterns.forEach(e => {
+      sections.push(`- ⚠️  ${e.topic}: ${e.root_cause?.slice(0, 150) || e.content.slice(0, 150)}`);
+      if (e.fix) sections.push(`  Fix: ${e.fix.slice(0, 100)}`);
+    });
+  }
+
+  if (context.domain.length > 0) {
+    sections.push('\n### Domain Knowledge');
+    context.domain.forEach(e => {
+      sections.push(`- ${e.topic}: ${e.content.slice(0, 200)}`);
+    });
+  }
+
+  return sections.join('\n');
+}
+
+/**
+ * Read tech stack from PROJECT.md for relevance filtering.
+ */
+function readTechStack() {
+  const projectMd = path.join(process.cwd(), '.planning', 'PROJECT.md');
+  if (!fs.existsSync(projectMd)) return [];
+  const content = fs.readFileSync(projectMd, 'utf8');
+  // Extract tech stack section
+  const techSection = content.match(/## Tech stack\n+([\s\S]*?)(?=\n##|$)/i)?.[1] || '';
+  return techSection
+    .split('\n')
+    .map(l => l.replace(/^[-*•]\s*/, '').split(/[\s,/]/).filter(w => w.length > 2))
+    .flat()
+    .filter(Boolean)
+    .slice(0, 20);
+}
+
+/**
+ * Generate the memory header displayed at session start.
+ */
+function generateSessionHeader(loadResult) {
+  if (loadResult.count === 0) {
+    return '🧠 Knowledge Base — no relevant memories for this session\n';
+  }
+
+  const lines = [
+    `🧠 Knowledge Base — ${loadResult.count} relevant memories loaded:`,
+  ];
+
+  if (loadResult.preferences > 0)  lines.push(`  Preferences  : ${loadResult.preferences}`);
+  if (loadResult.decisions > 0)    lines.push(`  Decisions    : ${loadResult.decisions}`);
+  if (loadResult.bugPatterns > 0)  lines.push(`  Bug patterns : ${loadResult.bugPatterns}`);
+  if (loadResult.codePatterns > 0) lines.push(`  Code patterns: ${loadResult.codePatterns}`);
+  if (loadResult.domain > 0)       lines.push(`  Domain       : ${loadResult.domain}`);
+
+  return lines.join('\n');
+}
+
+module.exports = { loadForSession, readTechStack, generateSessionHeader, formatForContext };

package/bin/migrations/0.1.0-to-0.5.0.js

@@ -13,13 +13,12 @@ module.exports = {
     if (!handoff.implicit_knowledge) handoff.implicit_knowledge = [];
     if (!handoff.quality_signals)    handoff.quality_signals    = [];
     fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
-    console.log(`    • HANDOFF.json: added intelligence layer fields`);
+    console.log('    • HANDOFF.json: added intelligence layer fields');
   },
 };
 
 // bin/migrations/0.5.0-to-0.6.0.js
 'use strict';
-const fs = require('fs');
 module.exports = {
   fromVersion: '0.5.0',
   toVersion:   '0.6.0',
@@ -32,6 +31,6 @@ module.exports = {
     if (!Array.isArray(handoff.recent_commits)) handoff.recent_commits = [];
     if (!Array.isArray(handoff.recent_files))   handoff.recent_files   = [];
     fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
-    console.log(`    • HANDOFF.json: added distribution platform fields`);
+    console.log('    • HANDOFF.json: added distribution platform fields');
   },
 };

package/bin/migrations/0.5.0-to-0.6.0.js

@@ -12,6 +12,6 @@ module.exports = {
     if (!Array.isArray(handoff.recent_commits)) handoff.recent_commits = [];
     if (!Array.isArray(handoff.recent_files))   handoff.recent_files   = [];
     fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
-    console.log(`    • HANDOFF.json: added distribution platform fields`);
+    console.log('    • HANDOFF.json: added distribution platform fields');
   },
 };

package/bin/migrations/0.6.0-to-1.0.0.js

@@ -32,7 +32,7 @@ module.exports = {
       }
 
       fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
-      console.log(`    • HANDOFF.json: added plugin_api_version, normalised arrays`);
+      console.log('    • HANDOFF.json: added plugin_api_version, normalised arrays');
     }
 
     // ── 2. AUDIT.jsonl ────────────────────────────────────────────────────────
@@ -59,7 +59,7 @@ module.exports = {
         fs.writeFileSync(paths.audit, updated.join('\n') + '\n');
         console.log(`    • AUDIT.jsonl: backfilled session_id in ${modified} of ${lines.length} entries`);
       } else {
-        console.log(`    • AUDIT.jsonl: all entries already have session_id`);
+        console.log('    • AUDIT.jsonl: all entries already have session_id');
       }
     }
 
@@ -93,7 +93,7 @@ module.exports = {
         fs.appendFileSync(paths.state,
           `\n\n---\n*Migrated to MindForge v1.0.0 schema on ${new Date().toISOString().slice(0,10)}*\n`
         );
-        console.log(`    • STATE.md: added v1.0.0 migration note`);
+        console.log('    • STATE.md: added v1.0.0 migration note');
       }
     }
   },

package/bin/migrations/migrate.js

@@ -30,12 +30,12 @@ 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`);
+    console.log('  ℹ️  No .planning/ directory found — skipping migration');
     return { status: 'no-planning-dir' };
   }
 
   if (compareSemver(fromVersion, toVersion) >= 0) {
-    console.log(`  ✅  No migration needed`);
+    console.log('  ✅  No migration needed');
     return { status: 'no-migration-needed' };
   }
 
@@ -54,7 +54,7 @@ async function runMigrations(fromVersion, toVersion) {
   );
 
   if (migrationsToRun.length === 0) {
-    console.log(`  ✅  No applicable migrations`);
+    console.log('  ✅  No applicable migrations');
     return { status: 'no-migrations' };
   }
 
@@ -69,7 +69,7 @@ async function runMigrations(fromVersion, toVersion) {
     const filesToBackup = Object.values(PATHS).filter(p => fs.existsSync(p));
 
     if (filesToBackup.length === 0) {
-      console.log(`  ℹ️  No files to migrate`);
+      console.log('  ℹ️  No files to migrate');
       fs.rmdirSync(backupDir);
       return { status: 'no-files' };
     }
@@ -93,11 +93,15 @@ async function runMigrations(fromVersion, toVersion) {
   } 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 {}
+      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.`
+      'Free disk space and retry.'
     );
   }
 
@@ -106,10 +110,10 @@ async function runMigrations(fromVersion, toVersion) {
     console.log(`\n  Running: v${migration.fromVersion} → v${migration.toVersion}...`);
     try {
       await migration.run(PATHS);
-      console.log(`  ✅  Complete`);
+      console.log('  ✅  Complete');
     } catch (migErr) {
       console.error(`  ❌  Failed: ${migErr.message}`);
-      console.log(`  Restoring from backup...`);
+      console.log('  Restoring from backup...');
 
       // Restore all files from backup
       for (const f of fs.readdirSync(backupDir)) {
@@ -117,7 +121,7 @@ async function runMigrations(fromVersion, toVersion) {
                     path.join(PLANNING_DIR, f);
         fs.copyFileSync(path.join(backupDir, f), dst);
       }
-      console.log(`  ✅  Restored from backup. No changes applied.`);
+      console.log('  ✅  Restored from backup. No changes applied.');
       throw new Error(`Migration failed at v${migration.toVersion}: ${migErr.message}`);
     }
   }
@@ -136,8 +140,8 @@ async function runMigrations(fromVersion, toVersion) {
   if (process.env.CI === 'true') {
     try {
       fs.rmSync(backupDir, { recursive: true, force: true });
-      console.log(`  🗑️  CI mode: backup auto-deleted (disk space)`);
-    } catch {
+      console.log('  🗑️  CI mode: backup auto-deleted (disk space)');
+    } catch (err) {
       // Silent failure on cleanup — migration succeeded, cleanup is optional
     }
   } else {

package/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;