mindforge-cc 10.7.0 → 11.0.0

package/bin/models/model-router.js

@@ -36,15 +36,13 @@ const PERSONA_MAP = {
 };
 
 let _settingsCache = null;
+let _settingsMtime = 0;
+const CACHE_CHECK_INTERVAL_MS = 60000;
+let _lastCacheCheck = 0;
 
-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');
+function parseSettings(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
   const settings = { ...DEFAULTS };
-  
   const lines = content.split('\n');
   for (const line of lines) {
     const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
@@ -52,10 +50,30 @@ function readMindforgeSettings() {
       settings[match[1]] = match[2].trim();
     }
   }
-  _settingsCache = settings;
   return settings;
 }
 
+function readMindforgeSettings() {
+  const now = Date.now();
+  if (now - _lastCacheCheck < CACHE_CHECK_INTERVAL_MS && _settingsCache) {
+    return _settingsCache;
+  }
+  _lastCacheCheck = now;
+
+  const configPath = path.join(process.cwd(), 'MINDFORGE.md');
+  try {
+    const stat = fs.statSync(configPath);
+    if (stat.mtimeMs !== _settingsMtime) {
+      _settingsMtime = stat.mtimeMs;
+      _settingsCache = parseSettings(configPath);
+    }
+  } catch {
+    if (!_settingsCache) _settingsCache = { ...DEFAULTS };
+  }
+
+  return _settingsCache;
+}
+
 function route(persona = 'developer', tier = 1) {
   const settings = readMindforgeSettings();
   
@@ -105,6 +123,8 @@ function getModel(settingKey) {
 
 function clearCache() {
   _settingsCache = null;
+  _settingsMtime = 0;
+  _lastCacheCheck = 0;
 }
 
 function getAllSettings() {

package/bin/models/openai-provider.js

@@ -73,6 +73,50 @@ class OpenAIProvider {
       req.end();
     });
   }
+
+  async streamComplete(messages, options = {}) {
+    const model = options.model || 'gpt-4o';
+    const maxTokens = options.maxTokens || 4096;
+
+    const data = JSON.stringify({
+      model,
+      messages,
+      max_tokens: maxTokens,
+      stream: true,
+    });
+
+    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: 300_000,
+      }, res => {
+        if (res.statusCode !== 200) {
+          let body = '';
+          res.on('data', chunk => body += chunk);
+          res.on('end', () => {
+            reject(new Error(`OpenAI streaming failed: ${res.statusCode}`));
+          });
+          return;
+        }
+        resolve(res);
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('OpenAI stream timeout'));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
 }
 
 module.exports = OpenAIProvider;

package/bin/utils/file-io.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const fsp = require('fs/promises');
 const path = require('path');
 const crypto = require('crypto');
+const zlib = require('zlib');
 
 class AuditWriter {
   constructor(filePath) {
@@ -99,4 +100,65 @@ function readJSONSync(filePath) {
   }
 }
 
-module.exports = { AuditWriter, readJSON, writeJSON, readJSONL, readJSONSync };
+function atomicWriteJSON(filePath, data) {
+  const tmpPath = filePath + '.tmp.' + process.pid;
+  const content = JSON.stringify(data, null, 2) + '\n';
+  const fd = fs.openSync(tmpPath, 'w');
+  fs.writeSync(fd, content);
+  fs.fsyncSync(fd);
+  fs.closeSync(fd);
+  fs.renameSync(tmpPath, filePath);
+}
+
+async function atomicWriteJSONAsync(filePath, data) {
+  const tmpPath = filePath + '.tmp.' + process.pid;
+  const content = JSON.stringify(data, null, 2) + '\n';
+  const fh = await fsp.open(tmpPath, 'w');
+  await fh.write(content);
+  await fh.sync();
+  await fh.close();
+  await fsp.rename(tmpPath, filePath);
+}
+
+class AuditRotator {
+  constructor(options = {}) {
+    this.maxLines = options.maxLines || 5000;
+  }
+
+  shouldRotate(filePath) {
+    if (!fs.existsSync(filePath)) return false;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lineCount = content.split('\n').filter(l => l.trim()).length;
+    return lineCount >= this.maxLines;
+  }
+
+  rotate(filePath, archiveDir) {
+    const dir = archiveDir || path.join(path.dirname(filePath), '..', 'audit-archive');
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const baseName = path.basename(filePath, path.extname(filePath));
+    const archiveName = `${baseName}-${timestamp}.jsonl.gz`;
+    const archivePath = path.join(dir, archiveName);
+
+    // Crash-safe: write archive FIRST, then truncate source
+    const content = fs.readFileSync(filePath);
+    const compressed = zlib.gzipSync(content);
+    fs.writeFileSync(archivePath, compressed);
+
+    const lines = content.toString('utf8').split('\n').filter(l => l.trim());
+    const carryover = lines.slice(-100).join('\n') + '\n';
+    const tmpPath = filePath + '.tmp.' + process.pid;
+    const fd = fs.openSync(tmpPath, 'w');
+    fs.writeSync(fd, carryover);
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    fs.renameSync(tmpPath, filePath);
+
+    return archivePath;
+  }
+}
+
+module.exports = { AuditWriter, AuditRotator, readJSON, writeJSON, readJSONL, readJSONSync, atomicWriteJSON, atomicWriteJSONAsync };

package/bin/utils/index.js

@@ -1,5 +1,63 @@
 'use strict';
+
+class LRUMap {
+  constructor(maxSize, options = {}) {
+    this._max = maxSize;
+    this._onEvict = options.onEvict || null;
+    this._map = new Map();
+  }
+
+  get(key) {
+    if (!this._map.has(key)) return undefined;
+    const value = this._map.get(key);
+    this._map.delete(key);
+    this._map.set(key, value);
+    return value;
+  }
+
+  set(key, value) {
+    if (this._map.has(key)) {
+      this._map.delete(key);
+    } else if (this._map.size >= this._max) {
+      const oldest = this._map.keys().next().value;
+      const oldestValue = this._map.get(oldest);
+      this._map.delete(oldest);
+      if (this._onEvict) this._onEvict(oldest, oldestValue);
+    }
+    this._map.set(key, value);
+  }
+
+  has(key) {
+    return this._map.has(key);
+  }
+
+  delete(key) {
+    return this._map.delete(key);
+  }
+
+  clear() {
+    this._map.clear();
+  }
+
+  get size() {
+    return this._map.size;
+  }
+
+  keys() {
+    return this._map.keys();
+  }
+
+  values() {
+    return this._map.values();
+  }
+
+  entries() {
+    return this._map.entries();
+  }
+}
+
 module.exports = {
+  LRUMap,
   ...require('./paths'),
   ...require('./file-io'),
   ...require('./errors')

package/docs/getting-started.md

@@ -1,4 +1,4 @@
-# MindForge — Getting Started (v10.0.1)
+# MindForge — Getting Started (v11.0.0)
 
 This guide gets you from zero to a working MindForge project in under five minutes.
 

package/docs/user-guide.md

@@ -1,4 +1,4 @@
-# MindForge User Guide (v10.0.1)
+# MindForge User Guide (v11.0.0)
 
 This guide gets you from install to productive, with the minimum needed to run MindForge in a real project.
 
@@ -136,7 +136,7 @@ Observe your agent waves, token spend, and milestone progress in real-time.
 
 The dashboard provides a premium web interface at `http://localhost:7339`.
 
-> **Authentication (v10.0.1+):** The dashboard now requires a bearer token for access. The token is printed to the console at startup. Pass it in the `Authorization` header or use the login prompt in the browser UI.
+> **Authentication (v11.0.0+):** The dashboard now requires a bearer token for access. The token is printed to the console at startup. Pass it in the `Authorization` header or use the login prompt in the browser UI.
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mindforge-cc",
-  "version": "10.7.0",
-  "description": "MindForge \u2014 Sovereign Agentic Intelligence Framework. Bedrock Fortified: Production-Grade Architecture (v10)",
+  "version": "11.0.0",
+  "description": "MindForge \u2014 Sovereign Agentic Intelligence Framework. Sovereign Stability: Production-Hardened Agentic Intelligence (v11)",
   "bin": {
     "mindforge-cc": "bin/install.js",
     "mindforge": "bin/mindforge-cli.js"