mindforge-cc 1.0.5 → 2.0.0-alpha.4

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;

package/bin/models/cost-tracker.js

@@ -0,0 +1,118 @@
+/**
+ * MindForge v2 — Cost Tracker
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const METRICS_DIR = path.join(process.cwd(), '.mindforge', 'metrics');
+const USAGE_LOG = path.join(METRICS_DIR, 'token-usage.jsonl');
+
+function ensureDir() {
+  if (!fs.existsSync(METRICS_DIR)) {
+    fs.mkdirSync(METRICS_DIR, { recursive: true });
+  }
+}
+
+let _dailyCache = { value: 0, computed_at: 0 };
+
+function getTodaySpend() {
+  if (!fs.existsSync(USAGE_LOG)) return 0;
+  
+  const today = new Date().toISOString().slice(0, 10);
+  const content = fs.readFileSync(USAGE_LOG, 'utf8');
+  const lines = content.trim().split('\n');
+  
+  let total = 0;
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.date === today) {
+        total += entry.cost_usd || 0;
+      }
+    } catch (e) {
+      process.stderr.write('[cost-tracker] Skipped malformed entry\n');
+    }
+  }
+  return total;
+}
+
+function getTodaySpendCached() {
+  const AGE_MS = Date.now() - _dailyCache.computed_at;
+  if (AGE_MS > 60_000) {
+    _dailyCache.value = getTodaySpend();
+    _dailyCache.computed_at = Date.now();
+  }
+  return _dailyCache.value;
+}
+
+async function preflight(estimatedCost = 0) {
+  const settings = require('./model-router').getAllSettings();
+  const hardLimit = parseFloat(settings.MODEL_COST_HARD_LIMIT_USD || '0.0');
+  
+  if (hardLimit <= 0) return;
+
+  const todaySpend = getTodaySpendCached();
+  const projected = todaySpend + estimatedCost;
+
+  if (projected >= hardLimit) {
+    throw Object.assign(
+      new Error(`Daily cost limit $${hardLimit} reached (Today: $${todaySpend.toFixed(4)})`),
+      { code: 'COST_LIMIT_REACHED', spend: todaySpend, limit: hardLimit }
+    );
+  }
+}
+
+async function record(entry) {
+  ensureDir();
+  const enriched = {
+    ...entry,
+    date: new Date().toISOString().slice(0, 10),
+    timestamp: new Date().toISOString()
+  };
+  fs.appendFileSync(USAGE_LOG, JSON.stringify(enriched) + '\n');
+  _dailyCache.computed_at = 0; // Invalidate cache
+}
+
+function getSummary(params = { days: 7 }) {
+  if (!fs.existsSync(USAGE_LOG)) return { total_usd: 0, by_model: {} };
+  
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - params.days);
+  const cutoffStr = cutoffDate.toISOString().slice(0, 10);
+
+  const content = fs.readFileSync(USAGE_LOG, 'utf8');
+  const lines = content.trim().split('\n');
+  
+  const result = {
+    total_usd: 0,
+    by_model: {},
+    by_phase: {},
+    calls: 0
+  };
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.date >= cutoffStr) {
+        const cost = entry.cost_usd || 0;
+        result.total_usd += cost;
+        result.calls++;
+        
+        const model = entry.model || 'unknown';
+        if (!result.by_model[model]) result.by_model[model] = { cost: 0, calls: 0, tokens: 0 };
+        result.by_model[model].cost += cost;
+        result.by_model[model].calls++;
+        result.by_model[model].tokens += (entry.input_tokens || 0) + (entry.output_tokens || 0);
+
+        const phase = entry.phase || 'unknown';
+        if (!result.by_phase[phase]) result.by_phase[phase] = 0;
+        result.by_phase[phase] += cost;
+      }
+    } catch (e) { /* ignore parse errors for summary */ }
+  }
+  return result;
+}
+
+module.exports = { record, preflight, getTodaySpend, getTodaySpendCached, getSummary };

package/bin/models/gemini-provider.js

@@ -0,0 +1,79 @@
+/**
+ * MindForge v2 — Gemini Provider
+ * Using header-based auth for security.
+ */
+'use strict';
+
+const https = require('https');
+
+class GeminiProvider {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+
+  async complete(params) {
+    const { model, systemPrompt, userMessage, maxTokens = 8192, temperature = 0.2 } = params;
+
+    const data = JSON.stringify({
+      system_instruction: { parts: [{ text: systemPrompt }] },
+      contents: [{ parts: [{ text: userMessage }] }],
+      generationConfig: {
+        maxOutputTokens: maxTokens,
+        temperature,
+      },
+    });
+
+    const modelId = model.startsWith('models/') ? model : `models/${model}`;
+
+    return new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: 'generativelanguage.googleapis.com',
+        path: `/v1beta/${modelId}:generateContent`,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-goog-api-key': this.apiKey, // Header auth
+          'Content-Length': Buffer.byteLength(data),
+        },
+        timeout: 180_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 || 'Gemini API error'), { status: res.statusCode }));
+            }
+
+            // Gemini 1.5 Pro billing is complex; using $1.25 / 1M input as baseline
+            const inputTokens = json.usageMetadata.promptTokenCount;
+            const outputTokens = json.usageMetadata.candidatesTokenCount;
+            const cost = (inputTokens * 0.00000125) + (outputTokens * 0.00000375);
+
+            resolve({
+              model: modelId,
+              content: json.candidates[0].content.parts[0].text,
+              input_tokens: inputTokens,
+              output_tokens: outputTokens,
+              cost_usd: cost,
+              provider: 'google'
+            });
+          } catch (e) {
+            reject(new Error('Failed to parse Gemini response: ' + e.message));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(Object.assign(new Error('Gemini timeout'), { status: 408 }));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
+}
+
+module.exports = GeminiProvider;

package/bin/models/model-client.js

@@ -0,0 +1,98 @@
+/**
+ * MindForge v2 — Model Client
+ * Unified client with routing, fallbacks, and cost tracking.
+ */
+'use strict';
+
+const Router = require('./model-router');
+const CostTracker = require('./cost-tracker');
+const AnthropicProvider = require('./anthropic-provider');
+const OpenAIProvider = require('./openai-provider');
+const GeminiProvider = require('./gemini-provider');
+
+const FALLBACK_CHAINS = {
+  'claude-3-opus-20240229': ['gpt-4o', 'claude-3-5-sonnet-20240620'],
+  'gpt-4o': ['claude-3-5-sonnet-20240620'],
+  'gemini-1.5-pro': ['claude-3-5-sonnet-20240620'],
+};
+
+class ModelClient {
+  static async complete(params) {
+    const {
+      persona = 'developer',
+      tier = 1,
+      maxTokens,
+      temperature,
+      taskName = 'unknown',
+      sessionId = 'unknown',
+      phaseNum = 0
+    } = params;
+
+    // 1. Route to model
+    const routing = Router.route(persona, tier);
+    let modelId = routing.model;
+
+    // 2. Pre-flight cost check
+    try {
+      await CostTracker.preflight(0.05); // Conservative estimate
+    } catch (e) {
+      if (e.code === 'COST_LIMIT_REACHED') throw e;
+    }
+
+    // 3. Execute with fallbacks
+    let result = null;
+    let attempts = [modelId, ...(FALLBACK_CHAINS[modelId] || [])];
+
+    for (const currentModel of attempts) {
+      try {
+        const provider = this._getProvider(currentModel);
+        if (!provider) continue;
+
+        result = await provider.complete({
+          model: currentModel,
+          systemPrompt: params.systemPrompt,
+          userMessage: params.userMessage,
+          maxTokens,
+          temperature
+        });
+
+        // Add metadata
+        result.task_name = taskName;
+        result.session_id = sessionId;
+        result.phase = phaseNum;
+
+        if (currentModel !== modelId) {
+          result.content = `[FALLBACK NOTICE: ${modelId} unavailable — used ${currentModel} instead.]\n\n${result.content}`;
+        }
+
+        // 4. Record cost
+        await CostTracker.record(result);
+        return result;
+
+      } catch (err) {
+        process.stderr.write(`[model-client] ${currentModel} failed: ${err.message}\n`);
+        if (attempts.indexOf(currentModel) === attempts.length - 1) {
+          throw err;
+        }
+      }
+    }
+  }
+
+  static _getProvider(modelId) {
+    if (modelId.includes('claude')) {
+      if (!process.env.ANTHROPIC_API_KEY) return null;
+      return new AnthropicProvider(process.env.ANTHROPIC_API_KEY);
+    }
+    if (modelId.includes('gpt')) {
+      if (!process.env.OPENAI_API_KEY) return null;
+      return new OpenAIProvider(process.env.OPENAI_API_KEY);
+    }
+    if (modelId.includes('gemini')) {
+      if (!process.env.GOOGLE_API_KEY) return null;
+      return new GeminiProvider(process.env.GOOGLE_API_KEY);
+    }
+    return null;
+  }
+}
+
+module.exports = ModelClient;

package/bin/models/model-router.js

@@ -0,0 +1,111 @@
+/**
+ * MindForge v2 — Model Router
+ * Resolves persona and tier to a specific model ID based on settings and context.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Default model assignments
+const DEFAULTS = {
+  PLANNER_MODEL:          'claude-3-opus-20240229',
+  EXECUTOR_MODEL:         'claude-3-5-sonnet-20240620',
+  REVIEWER_MODEL:         'gpt-4o',
+  SECURITY_MODEL:         'claude-3-opus-20240229',
+  RESEARCH_MODEL:         'gemini-1.5-pro',
+  QA_MODEL:               'claude-3-5-sonnet-20240620',
+  DEBUG_MODEL:            'claude-3-opus-20240229',
+  QUICK_MODEL:            'claude-3-5-haiku-20241022',
+  CROSS_REVIEW_SECONDARY: 'gpt-4o',
+  CROSS_REVIEW_TERTIARY:  'gemini-1.5-pro',
+};
+
+// Persona to setting key mapping
+const PERSONA_MAP = {
+  'developer':         'EXECUTOR_MODEL',
+  'architect':         'PLANNER_MODEL',
+  'planner':           'PLANNER_MODEL',
+  'security-reviewer': 'SECURITY_MODEL',
+  'qa-engineer':       'QA_MODEL',
+  'research-agent':    'RESEARCH_MODEL',
+  'debug-specialist':  'DEBUG_MODEL',
+};
+
+let _settingsCache = null;
+
+function readMindforgeSettings() {
+  if (_settingsCache) return _settingsCache;
+  const configPath = path.join(process.cwd(), 'MINDFORGE.md');
+  if (!fs.existsSync(configPath)) return DEFAULTS;
+
+  const content = fs.readFileSync(configPath, 'utf8');
+  const settings = { ...DEFAULTS };
+  
+  const lines = content.split('\n');
+  for (const line of lines) {
+    const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
+    if (match) {
+      settings[match[1]] = match[2].trim();
+    }
+  }
+  _settingsCache = settings;
+  return settings;
+}
+
+function route(persona = 'developer', tier = 1) {
+  const settings = readMindforgeSettings();
+  
+  // 1. Tier 3 override (Security/Privacy always uses SECURITY_MODEL)
+  if (tier === 3) {
+    return {
+      model: settings.SECURITY_MODEL,
+      setting: 'SECURITY_MODEL',
+      reason: 'Tier 3 (Security/Privacy) override'
+    };
+  }
+
+  // 2. Persona mapping (Specific personas like research, debug, qa)
+  if (persona !== 'developer' && PERSONA_MAP[persona]) {
+    const settingKey = PERSONA_MAP[persona];
+    return {
+      model: settings[settingKey],
+      setting: settingKey,
+      reason: `Mapped from specific persona "${persona}"`
+    };
+  }
+
+  // 3. Budget Bias (Tier 1 uses QUICK_MODEL for default developer tasks)
+  if (tier === 1) {
+    return {
+      model: settings.QUICK_MODEL,
+      setting: 'QUICK_MODEL',
+      reason: 'Tier 1 Budget Bias (efficiency mode)'
+    };
+  }
+
+  // 4. Default mapping
+  const settingKey = 'EXECUTOR_MODEL';
+  const model = settings[settingKey];
+
+  return {
+    model,
+    setting: settingKey,
+    reason: `Default EXECUTOR_MODEL for tier ${tier}`
+  };
+}
+
+function getModel(settingKey) {
+  const settings = readMindforgeSettings();
+  return settings[settingKey] || DEFAULTS[settingKey];
+}
+
+function clearCache() {
+  _settingsCache = null;
+}
+
+function getAllSettings() {
+  return readMindforgeSettings();
+}
+
+module.exports = { route, getModel, clearCache, getAllSettings };

package/bin/models/openai-provider.js

@@ -0,0 +1,78 @@
+/**
+ * MindForge v2 — OpenAI Provider
+ */
+'use strict';
+
+const https = require('https');
+
+class OpenAIProvider {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+
+  async complete(params) {
+    const { model, systemPrompt, userMessage, maxTokens = 4096, temperature = 0.7 } = params;
+
+    const data = JSON.stringify({
+      model,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userMessage }
+      ],
+      max_tokens: maxTokens,
+      temperature,
+    });
+
+    return new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: 'api.openai.com',
+        path: '/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+          '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 || 'OpenAI API error'), { status: res.statusCode }));
+            }
+
+            const inputTokens = json.usage.prompt_tokens;
+            const outputTokens = json.usage.completion_tokens;
+            
+            // Basic cost calculation (GPT-4o prices)
+            const cost = (inputTokens * 0.000005) + (outputTokens * 0.000015);
+
+            resolve({
+              model: json.model,
+              content: json.choices[0].message.content,
+              input_tokens: inputTokens,
+              output_tokens: outputTokens,
+              cost_usd: cost,
+              provider: 'openai'
+            });
+          } catch (e) {
+            reject(new Error('Failed to parse OpenAI response: ' + e.message));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(Object.assign(new Error('OpenAI timeout'), { status: 408 }));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
+}
+
+module.exports = OpenAIProvider;