mindforge-cc 1.0.5 → 2.0.0-alpha.6

package/bin/autonomous/steer.js

@@ -0,0 +1,71 @@
+/**
+ * MindForge — Steering Manager
+ * Manages mid-execution guidance via steering-queue.jsonl.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const QUEUE_PATH = path.join(process.cwd(), '.planning/steering-queue.jsonl');
+
+/**
+ * Add guidance to the queue.
+ */
+function pushGuidance(instruction, scope = 'global', taskId = null) {
+  const item = {
+    id: `steer-${Date.now()}`,
+    timestamp: new Date().toISOString(),
+    instruction,
+    scope,
+    taskId
+  };
+  fs.appendFileSync(QUEUE_PATH, JSON.stringify(item) + '\n');
+  return item.id;
+}
+
+/**
+ * Get and remove all pending guidance for the current context.
+ */
+function popGuidance(taskId = null) {
+  if (!fs.existsSync(QUEUE_PATH)) return [];
+
+  const lines = fs.readFileSync(QUEUE_PATH, 'utf8').split('\n').filter(Boolean);
+  const relevant = [];
+  const remaining = [];
+
+  for (const line of lines) {
+    const item = JSON.parse(line);
+    if (item.scope === 'global' || item.taskId === taskId) {
+      relevant.push(item);
+    } else {
+      remaining.push(item);
+    }
+  }
+
+  // Rewrite remaining
+  fs.writeFileSync(QUEUE_PATH, remaining.map(JSON.stringify).join('\n') + (remaining.length ? '\n' : ''));
+  return relevant;
+}
+
+/**
+ * Inject steering guidance into a PLAN file content.
+ */
+function injectSteering(planContent, guidanceItems) {
+  if (!guidanceItems || guidanceItems.length === 0) return planContent;
+
+  const guidanceText = guidanceItems
+    .map(g => `[STEERING GUIDANCE — DO NOT IGNORE] ${g.instruction}`)
+    .join('\n');
+
+  // Hardened injection: inject at beginning of <action> to ensure visibility
+  return planContent.replace(/<action>([\s\S]*?)<\/action>/, (match, action) => {
+    return `<action>\n${guidanceText}\n\nOriginal plan instructions:\n${action}\n</action>`;
+  });
+}
+
+module.exports = {
+  pushGuidance,
+  popGuidance,
+  injectSteering
+};

package/bin/autonomous/stuck-monitor.js

@@ -0,0 +1,77 @@
+/**
+ * MindForge — Stuck Detection Engine
+ * Monitors AUDIT.jsonl for S01-S04 patterns.
+ */
+'use strict';
+
+const fs = require('fs');
+
+class StuckMonitor {
+  constructor(auditPath) {
+    this.auditPath = auditPath;
+    this.history = [];
+    this.patterns = {
+      S01_LINT_LOOP: 0,
+      S02_COMMAND_LOOP: 0,
+    };
+  }
+
+  analyze(event) {
+    this.history.push(event);
+    if (this.history.length > 50) this.history.shift();
+
+    // Check S01: Lint Loop (Identical multi_replace calls)
+    if (this.detectS01(event)) return { pattern: 'S01', message: 'Stuck in lint loop: identical edits detected.' };
+
+    // Check S02: Command Loop (Identical failing commands)
+    if (this.detectS02(event)) return { pattern: 'S02', message: 'Stuck in command loop: identical failing commands.' };
+
+    return null;
+  }
+
+  detectS01(event) {
+    if (event.tool !== 'multi_replace_file_content') return false;
+
+    const similar = this.history.filter(h =>
+      h.tool === 'multi_replace_file_content' &&
+      h.args?.TargetFile === event.args?.TargetFile &&
+      this.isContentSimilar(h.args?.ReplacementChunks?.[0]?.ReplacementContent, event.args?.ReplacementChunks?.[0]?.ReplacementContent)
+    );
+
+    return similar.length >= 3;
+  }
+
+  detectS02(event) {
+    if (event.tool !== 'run_command' || event.status !== 'failed') return false;
+
+    const identical = this.history.filter(h =>
+      h.tool === 'run_command' &&
+      h.status === 'failed' &&
+      h.args?.CommandLine === event.args?.CommandLine
+    );
+
+    return identical.length >= 3;
+  }
+
+  isContentSimilar(a, b) {
+    if (!a || !b) return false;
+    if (a === b) return true;
+    // Simple similarity check (hardened from Roadmap requirement)
+    const dist = this.levenshtein(a.slice(0, 100), b.slice(0, 100));
+    return dist < 10;
+  }
+
+  levenshtein(a, b) {
+    const tmp = [];
+    for (let i = 0; i <= a.length; i++) { tmp[i] = [i]; }
+    for (let j = 0; j <= b.length; j++) { tmp[0][j] = j; }
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            tmp[i][j] = Math.min(tmp[i - 1][j] + 1, tmp[i][j - 1] + 1, tmp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+    }
+    return tmp[a.length][b.length];
+  }
+}
+
+module.exports = StuckMonitor;

package/bin/browser/browser-daemon.js

@@ -0,0 +1,139 @@
+/**
+ * MindForge v2 — Browser Daemon
+ * Lightweight HTTP server controlling Chromium.
+ * Consistent with ADR-017 / ADR-024 (Localhost only).
+ */
+'use strict';
+
+const http      = require('http');
+const playwright = require('playwright-core');
+const fs        = require('fs');
+const path      = require('path');
+
+const PORT      = process.env.BROWSER_PORT || 7338;
+const HEADLESS  = process.env.BROWSER_HEADLESS !== 'false';
+const TIMEOUT   = (parseInt(process.env.BROWSER_IDLE_TIMEOUT_MINUTES) || 30) * 60 * 1000;
+
+let browser, lastActionAt = Date.now(), isLaunching = false;
+const sessions = new Map(); // name -> { context, page }
+
+async function init() {
+  if (isLaunching) return;
+  isLaunching = true;
+  try {
+    browser = await playwright.chromium.launch({
+      headless: HEADLESS,
+      args: ['--no-sandbox', '--disable-setuid-sandbox', '--no-first-run']
+    });
+    setInterval(checkIdle, 60000);
+  } finally {
+    isLaunching = false;
+  }
+}
+
+function checkIdle() {
+  if (Date.now() - lastActionAt > TIMEOUT) {
+    console.log('[daemon] Idle timeout reached. Shutting down.');
+    process.exit(0);
+  }
+}
+
+async function getOrCreateSession(name = 'default') {
+  if (sessions.has(name)) return sessions.get(name);
+  const context = await browser.newContext();
+  const page    = await context.newPage();
+  const s = { context, page };
+  sessions.set(name, s);
+  return s;
+}
+
+const server = http.createServer(async (req, res) => {
+  lastActionAt = Date.now();
+  const send = (data, code = 200) => {
+    res.writeHead(code, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+  };
+
+  // Only allow localhost
+  const remote = req.socket.remoteAddress;
+  if (remote !== '127.0.0.1' && remote !== '::1' && remote !== '::ffff:127.0.0.1') {
+    return send({ error: 'Forbidden: Localhost only' }, 403);
+  }
+
+  let body = '';
+  req.on('data', chunk => body += chunk);
+  req.on('end', async () => {
+    try {
+      const { url, session: sessionName, selector, text, script, type, expected_text, name } = body ? JSON.parse(body) : {};
+      const { page, context } = await getOrCreateSession(sessionName);
+
+      if (req.url === '/status' && req.method === 'GET') {
+        return send({ alive: true, sessions: Array.from(sessions.keys()), uptime: process.uptime() });
+      }
+
+      if (req.url === '/navigate' && req.method === 'POST') {
+        const start = Date.now();
+        const r = await page.goto(url, { waitUntil: 'load', timeout: 30000 });
+        return send({ 
+          success: true, 
+          status_code: r ? r.status() : 200, 
+          load_time_ms: Date.now() - start 
+        });
+      }
+
+      if (req.url === '/click' && req.method === 'POST') {
+        const target = selector ? page.locator(selector) : page.getByText(text, { exact: false });
+        await target.first().click({ timeout: 5000 });
+        return send({ success: true, element_found: true });
+      }
+
+      if (req.url === '/type' && req.method === 'POST') {
+        await page.locator(selector).fill(text, { timeout: 5000 });
+        return send({ success: true });
+      }
+
+      if (req.url === '/screenshot' && req.method === 'POST') {
+        const buf = await page.screenshot({ type: 'png' });
+        return send({ success: true, screenshot_b64: buf.toString('base64') });
+      }
+
+      if (req.url === '/evaluate' && req.method === 'POST') {
+        const result = await page.evaluate(script);
+        return send({ success: true, result });
+      }
+
+      if (req.url === '/assert' && req.method === 'POST') {
+        if (type === 'visible') {
+          const loc = page.locator(selector).first();
+          const visible = await loc.isVisible();
+          const actual = visible ? await loc.innerText() : '';
+          const passed = visible && (!expected_text || actual.includes(expected_text));
+          return send({ passed, actual_text: actual });
+        }
+        if (type === 'url') return send({ passed: page.url().includes(expected_text), actual_url: page.url() });
+        if (type === 'title') return send({ passed: (await page.title()).includes(expected_text), actual_title: await page.title() });
+        if (type === 'no_console_errors') return send({ passed: true }); // simplified
+      }
+
+      send({ error: 'Not Found' }, 404);
+    } catch (err) {
+      send({ success: false, error: err.message }, 500);
+    }
+  });
+});
+
+init().then(() => {
+  server.listen(PORT, '127.0.0.1', () => console.log(`[daemon] Browser daemon listening on port ${PORT}`));
+}).catch(err => {
+  console.error('[daemon] Initialization failed:', err);
+  process.exit(1);
+});
+
+async function shutdown() {
+  console.log('[daemon] Shutting down gracefully...');
+  if (browser) await browser.close();
+  process.exit(0);
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);

package/bin/browser/daemon-manager.js

@@ -0,0 +1,91 @@
+/**
+ * MindForge v2 — Browser Daemon Manager
+ * Starts and stops the browser-daemon.js process.
+ */
+'use strict';
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs   = require('fs');
+const http = require('http');
+
+const PORT = process.env.BROWSER_PORT || 7338;
+const DAEMON_SCRIPT = path.join(__dirname, 'browser-daemon.js');
+
+async function isRunning() {
+  return new Promise(resolve => {
+    const req = http.get(`http://127.0.0.1:${PORT}/status`, res => {
+      resolve(res.statusCode === 200);
+    });
+    req.on('error', () => resolve(false));
+    req.end();
+  });
+}
+
+async function start() {
+  if (await isRunning()) return;
+
+  const out = fs.openSync(path.join(process.cwd(), '.planning/browser-daemon.log'), 'a');
+  const err = fs.openSync(path.join(process.cwd(), '.planning/browser-daemon.log'), 'a');
+
+  const child = spawn(process.execPath, [DAEMON_SCRIPT], {
+    detached: true,
+    stdio: ['ignore', out, err],
+    env: { ...process.env, BROWSER_HEADLESS: 'true' }
+  });
+
+  child.unref();
+  console.log('[manager] Starting browser daemon...');
+
+  // Wait for it to wake up
+  for (let i = 0; i < 10; i++) {
+    await new Promise(r => setTimeout(r, 500));
+    if (await isRunning()) {
+      console.log('[manager] Browser daemon ready.');
+      return;
+    }
+  }
+  throw new Error('Timeout waiting for browser daemon to start');
+}
+
+async function stop() {
+  if (!(await isRunning())) return;
+  // Simple way to kill on localhost
+  try {
+    if (process.platform === 'win32') {
+      execSync(`for /f "tokens=5" %a in ('netstat -aon ^| find ":${PORT}" ^| find "LISTENING"') do taskkill /f /pid %a`);
+    } else {
+      execSync(`lsof -t -i:${PORT} | xargs kill -9`);
+    }
+    console.log('[manager] Browser daemon stopped.');
+  } catch (err) {
+    console.error('[manager] Failed to stop daemon:', err.message);
+  }
+}
+
+async function ensureRunning(opts = {}) {
+  if (!(await isRunning())) await start();
+}
+
+async function request(method, endpoint, body = null) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: PORT,
+      path: endpoint,
+      method: method,
+      headers: { 'Content-Type': 'application/json' }
+    }, res => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); } catch { resolve({ success: false, error: 'Invalid JSON response' }); }
+      });
+    });
+    req.on('error', err => reject(err));
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+module.exports = { start, stop, isRunning, ensureRunning, request };

package/bin/browser/qa-engine.js

@@ -0,0 +1,47 @@
+/**
+ * MindForge v2 — QA Engine
+ * Diff-aware systematic UI testing.
+ */
+'use strict';
+
+const { execSync } = require('child_process');
+const DaemonMgr    = require('./daemon-manager');
+const ScreenStore  = require('./screenshot-store');
+
+const DEV_SERVER = process.env.DEV_SERVER_URL || 'http://localhost:3000';
+
+function extractSurfaces() {
+  const files = execSync('git diff --name-only HEAD~1', { encoding: 'utf8' }).split('\n').filter(Boolean);
+  const surfaces = [];
+  for (const file of files) {
+    if (file.includes('pages/') || file.includes('app/')) {
+      const route = file.replace(/.*(pages|app)/, '').replace(/\.(tsx|jsx|ts|js)$/, '').replace(/\/page$/, '').replace(/\/index$/, '') || '/';
+      surfaces.push({ file, route });
+    }
+  }
+  return surfaces;
+}
+
+async function runQA(phaseNum) {
+  await DaemonMgr.ensureRunning();
+  const surfaces = extractSurfaces();
+  const results = [];
+  const bugs = [];
+
+  for (const surface of surfaces) {
+    const route = surface.route;
+    const r = await DaemonMgr.request('POST', '/navigate', { url: `${DEV_SERVER}${route}`, session: 'default' });
+    const passed = r.success && r.status_code < 400;
+    
+    if (!passed) {
+      const snap = await DaemonMgr.request('POST', '/screenshot', { session: 'default' });
+      const shot = snap.success ? ScreenStore.save(snap.screenshot_b64, phaseNum, 'qa', `fail-${route.replace(/\//g, '-')}.png`) : null;
+      bugs.push({ surface: route, error: r.error || `Status ${r.status_code}`, screenshot: shot });
+    }
+    results.push({ surface: route, passed });
+  }
+
+  return { surfaces: surfaces.length, passed: results.filter(r => r.passed).length, failed: bugs.length, results, bugs };
+}
+
+module.exports = { runQA };

package/bin/browser/qa-report-writer.js

@@ -0,0 +1,32 @@
+/**
+ * MindForge v2 — QA Report Writer
+ */
+'use strict';
+
+const fs    = require('fs');
+const path  = require('path');
+
+function write(phaseNum, qaResult) {
+  const dir = path.join(process.cwd(), '.planning', 'phases', String(phaseNum));
+  fs.mkdirSync(dir, { recursive: true });
+
+  const lines = [
+    `# QA Report — Phase ${phaseNum}`,
+    `Generated: ${new Date().toISOString()}`,
+    `Total: ${qaResult.surfaces} | Passed: ${qaResult.passed} | Failed: ${qaResult.failed}`,
+    '',
+    '## Results',
+    '| Surface | Result |',
+    '|---|---|',
+    ...qaResult.results.map(r => `| ${r.surface} | ${r.passed ? '✅ Pass' : '❌ Fail'} |`),
+    '',
+    '## Bugs found',
+    ...qaResult.bugs.map((b, i) => `### Bug ${i + 1}: ${b.surface}\n- Error: ${b.error}\n- Screenshot: ${b.screenshot}\n`)
+  ];
+
+  const file = path.join(dir, `QA-REPORT-${phaseNum}.md`);
+  fs.writeFileSync(file, lines.join('\n'));
+  return file;
+}
+
+module.exports = { write };

package/bin/browser/regression-writer.js

@@ -0,0 +1,27 @@
+/**
+ * MindForge v2 — Regression Writer
+ */
+'use strict';
+
+const fs    = require('fs');
+const path  = require('path');
+
+function write(bug, phaseNum) {
+  const dir = path.join(process.cwd(), 'tests', 'regression');
+  fs.mkdirSync(dir, { recursive: true });
+  const name = `phase${phaseNum}-${bug.surface.replace(/\//g, '-').slice(1) || 'home'}.test.ts`;
+  const content = `
+import { test, expect } from '@playwright/test';
+
+test('Regression: ${bug.surface} [${bug.error}]', async ({ page }) => {
+  await page.goto('${bug.surface}');
+  // TODO: Add more specific assertions based on the bug
+  expect(await page.isVisible('body')).toBeTruthy();
+});
+`;
+  const file = path.join(dir, name);
+  fs.writeFileSync(file, content);
+  return file;
+}
+
+module.exports = { write };

package/bin/browser/screenshot-store.js

@@ -0,0 +1,49 @@
+/**
+ * MindForge v2 — Screenshot Store
+ * Saves / lists / cleans up browser screenshots.
+ */
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const STORE = path.join(process.cwd(), '.planning', 'screenshots');
+const ensureDir = (dir) => fs.mkdirSync(dir, { recursive: true });
+
+function save(base64Png, phaseNum, planId, filename = 'screenshot.png') {
+  const dir = path.join(STORE, `phase-${phaseNum}`, String(planId));
+  ensureDir(dir);
+  const safe = filename.replace(/[^a-zA-Z0-9._-]/g, '-').replace(/\.png$/i, '') + '.png';
+  const dest = path.join(dir, safe);
+  fs.writeFileSync(dest, Buffer.from(base64Png, 'base64'));
+  return dest;
+}
+
+function list(phaseNum, planId) {
+  const dir = planId
+    ? path.join(STORE, `phase-${phaseNum}`, String(planId))
+    : path.join(STORE, `phase-${phaseNum}`);
+  if (!fs.existsSync(dir)) return [];
+  const walk = d => fs.readdirSync(d, { withFileTypes: true })
+    .flatMap(e => e.isDirectory() ? walk(path.join(d, e.name)) : path.join(d, e.name))
+    .filter(p => p.endsWith('.png'));
+  return walk(dir);
+}
+
+function cleanup(phaseNum) {
+  const dir = path.join(STORE, `phase-${phaseNum}`);
+  if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
+}
+
+function diskUsage() {
+  if (!fs.existsSync(STORE)) return 0;
+  let total = 0;
+  const walk = d => { for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+    const p = path.join(d, e.name);
+    e.isDirectory() ? walk(p) : (total += fs.statSync(p).size);
+  }};
+  walk(STORE);
+  return total;
+}
+
+module.exports = { save, list, cleanup, diskUsage };

package/bin/browser/session-manager.js

@@ -0,0 +1,93 @@
+/**
+ * MindForge v2 — Session Manager
+ * Persists browser state (cookies, localStorage) to disk.
+ */
+/* global localStorage */
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const SESSIONS_DIR = path.join(process.cwd(), '.mindforge', 'browser', 'sessions');
+const ensureDir = () => fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+
+async function saveSession(name, context) {
+  const safeName = name.replace(/[^a-z0-9_-]/gi, '_');
+  const filePath = path.join(SESSIONS_DIR, `${safeName}.json`);
+  ensureDir();
+  const cookies = await context.cookies();
+  const storageByOrigin = {};
+
+  for (const page of context.pages()) {
+    try {
+      const origin = new URL(page.url()).origin;
+      if (origin.startsWith('http')) {
+        const ls = await page.evaluate(() => {
+          const items = {};
+          for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            items[key] = localStorage.getItem(key);
+          }
+          return items;
+        }).catch(() => ({}));
+        if (Object.keys(ls).length) storageByOrigin[origin] = { localStorage: ls };
+      }
+    } catch (err) {
+      // Ignore navigation or evaluation errors for individual pages during session save
+    }
+  }
+
+  const data = {
+    name,
+    saved_at: new Date().toISOString(),
+    url: context.pages()[0]?.url() ?? '',
+    cookies,
+    storage: storageByOrigin,
+    _warning: 'Contains authentication cookies. NEVER commit this file.',
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  return filePath;
+}
+
+async function loadSession(name, context) {
+  const safeName = name.replace(/[^a-z0-9_-]/gi, '_');
+  const filePath = path.join(SESSIONS_DIR, `${safeName}.json`);
+  if (!fs.existsSync(filePath)) throw new Error(`Session file not found: ${filePath}`);
+
+  const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  let cookiesLoaded = 0;
+
+  if (data.cookies?.length) {
+    const now = Date.now() / 1000;
+    const valid = data.cookies.filter(c => !c.expires || c.expires === -1 || c.expires > now);
+    if (valid.length) {
+      await context.addCookies(valid);
+      cookiesLoaded = valid.length;
+    }
+  }
+
+  return { cookiesLoaded };
+}
+
+function importFromBrowser(source) {
+  const home = os.homedir();
+  const paths = {
+    chrome: `${home}/Library/Application Support/Google/Chrome/Default/Cookies`,
+    arc: `${home}/Library/Application Support/Arc/User Data/Default/Cookies`,
+    brave: `${home}/Library/Application Support/BraveSoftware/Brave-Browser/Default/Cookies`,
+    edge: `${home}/Library/Application Support/Microsoft Edge/Default/Cookies`,
+  };
+
+  const p = paths[source.toLowerCase()];
+  if (!p || !fs.existsSync(p)) {
+    throw new Error(`Cookie file for ${source} not found at ${p}`);
+  }
+
+  // Real SQLite parsing would happen here via better-sqlite3 if installed.
+  // This is a placeholder for the logic specified in the roadmap.
+  return [];
+}
+
+module.exports = { saveSession, loadSession, importFromBrowser };