mindforge-cc 8.1.1 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/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/.mindforge/mirrors/mirror-sre-776a1cf9/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/.mindforge/mirrors/mirror-sre-776a1cf9/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/.mindforge/mirrors/mirror-sre-776a1cf9/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 };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/browser/visual-verify-executor.js

@@ -0,0 +1,89 @@
+/**
+ * MindForge v2 — Visual Verify Executor
+ * Parses <verify-visual> blocks and runs them against the daemon.
+ */
+'use strict';
+
+const fs          = require('fs');
+const path        = require('path');
+const DaemonMgr   = require('./daemon-manager');
+const ScreenStore = require('./screenshot-store');
+
+const DEV_SERVER  = process.env.DEV_SERVER_URL || 'http://localhost:3000';
+
+function extractBlock(planContent) {
+  const m = planContent.match(/<verify-visual([^>]*)>([\s\S]*?)<\/verify-visual>/);
+  if (!m) return null;
+  const sessionM = m[1].match(/session\s*=\s*["']([^"']+)["']/);
+  return { content: m[2].trim(), session: sessionM?.[1] ?? 'default' };
+}
+
+function parseDirectives(content) {
+  return content.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#')).map(line => {
+    const colon = line.indexOf(':');
+    if (colon === -1) return null;
+    const directive = line.slice(0, colon).trim();
+    const rawArgs   = line.slice(colon + 1).trim();
+    const args = [];
+    const re   = /"([^"]*)"|\S+/g;
+    let m;
+    while ((m = re.exec(rawArgs)) !== null) args.push(m[1] !== undefined ? m[1] : m[0]);
+    return { directive, args };
+  }).filter(Boolean);
+}
+
+async function executeBlock(phaseNum, planId, planContent) {
+  const block = extractBlock(planContent);
+  if (!block) return { passed: true, steps: [], skipped: true };
+
+  await DaemonMgr.ensureRunning();
+  const directives = parseDirectives(block.content);
+  const steps = [];
+  const screenshots = [];
+  let passed = true;
+
+  for (const { directive, args } of directives) {
+    const step = { directive: `${directive}: ${args.join(' ')}`, status: 'pass', detail: '' };
+    try {
+      let r;
+      switch (directive) {
+        case 'navigate':
+          r = await DaemonMgr.request('POST', '/navigate', { url: args[0].startsWith('http') ? args[0] : `${DEV_SERVER}${args[0]}`, session: block.session });
+          step.detail = `${r.status_code} OK`;
+          break;
+        case 'wait':
+          await new Promise(res => setTimeout(res, parseInt(args[0]) || 500));
+          break;
+        case 'assert-visible':
+          r = await DaemonMgr.request('POST', '/assert', { type: 'visible', selector: args[0], expected_text: args[1], session: block.session });
+          if (!r.passed) { step.status = 'fail'; passed = false; }
+          break;
+        case 'screenshot':
+          r = await DaemonMgr.request('POST', '/screenshot', { session: block.session });
+          if (r.success) screenshots.push(ScreenStore.save(r.screenshot_b64, phaseNum, planId, args[0]));
+          break;
+        case 'click':
+          r = await DaemonMgr.request('POST', '/click', { selector: args[0], session: block.session });
+          if (!r.success) { step.status = 'fail'; passed = false; }
+          break;
+      }
+    } catch (err) {
+      step.status = 'fail'; step.detail = err.message; passed = false;
+    }
+    steps.push(step);
+    if (!passed) break;
+  }
+  return { passed, steps, screenshots, session: block.session };
+}
+
+function writeReport(phaseNum, planId, result) {
+  const dir = path.join(process.cwd(), '.planning', 'phases', String(phaseNum));
+  fs.mkdirSync(dir, { recursive: true });
+  const content = `# Visual Verify Result\nStatus: ${result.passed ? '✅ PASS' : '❌ FAIL'}\n\n` +
+    result.steps.map(s => `- ${s.directive} [${s.status}] ${s.detail}`).join('\n');
+  const file = path.join(dir, `VISUAL-VERIFY-${phaseNum}-${planId}.md`);
+  fs.writeFileSync(file, content);
+  return file;
+}
+
+module.exports = { executeBlock, writeReport };

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

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * MindForge Change Classifier
+ * Categorizes changes into Tiers based on risk and sensitivity.
+ */
+
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+
+const SENSITIVE_PATHS = [
+  'auth/',
+  'payment/',
+  'security/',
+  '.github/workflows/',
+  '.mindforge/governance/',
+  'bin/models/'
+];
+
+const SENSITIVE_PATTERNS = [
+  /jwt/i,
+  /bcrypt/i,
+  /stripe/i,
+  /apiKey/i,
+  /password/i,
+  /secret/i,
+  /token/i,
+  /PII/
+];
+
+function classify() {
+  try {
+    // Get list of changed files compared to origin/main or HEAD~1
+    const base = process.env.GITHUB_BASE_REF ? `origin/${process.env.GITHUB_BASE_REF}` : 'HEAD~1';
+    const diffFiles = execSync(`git diff --name-only ${base}..HEAD`, { encoding: 'utf8' }).split('\n').filter(Boolean);
+    
+    let tier = 1;
+    let reasons = [];
+
+    // 1. Path-based detection (Tier 3)
+    const matchedPath = diffFiles.find(file => SENSITIVE_PATHS.some(p => file.startsWith(p)));
+    if (matchedPath) {
+      tier = 3;
+      reasons.push(`Sensitive path modified: ${matchedPath}`);
+    }
+
+    // 2. Pattern-based detection in diff (Tier 3)
+    if (tier < 3) {
+      const diffContent = execSync(`git diff ${base}..HEAD`, { encoding: 'utf8' });
+      for (const pattern of SENSITIVE_PATTERNS) {
+        if (pattern.test(diffContent)) {
+          tier = 3;
+          reasons.push(`Sensitive pattern detected: ${pattern}`);
+          break;
+        }
+      }
+    }
+
+    // 3. Simple change (Tier 1 vs 2)
+    if (tier < 3) {
+      if (diffFiles.length > 10 || diffFiles.some(f => f.endsWith('.js') || f.endsWith('.ts'))) {
+        tier = 2; // Significant logic change
+      }
+    }
+
+    console.log(`TIER=${tier}`);
+    console.log(`REASONS=${reasons.join('; ')}`);
+    
+    // Write to GITHUB_OUTPUT if available
+    if (process.env.GITHUB_OUTPUT) {
+      fs.appendFileSync(process.env.GITHUB_OUTPUT, `tier=${tier}\n`);
+    }
+
+    return tier;
+  } catch (err) {
+    console.error(`❌ Classification failed: ${err.message}`);
+    // Default to Tier 3 for safety if classification fails
+    if (process.env.GITHUB_OUTPUT) {
+      fs.appendFileSync(process.env.GITHUB_OUTPUT, 'tier=3\n');
+    }
+    process.exit(0); // Don't fail the pipeline yet, let the gate handle it
+  }
+}
+
+classify();

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/dashboard/api-router.js

@@ -0,0 +1,198 @@
+/**
+ * MindForge v2 — Dashboard API Router
+ * All REST endpoints for the dashboard.
+ */
+'use strict';
+
+const path    = require('path');
+const fs      = require('fs');
+const Metrics = require('./metrics-aggregator');
+const Approval = require('./approval-handler');
+const SSE     = require('./sse-bridge');
+
+// Steering queue path (from Day 8 auto-executor)
+const STEERING_QUEUE = path.join(process.cwd(), '.planning', 'steering-queue.jsonl');
+const AUTO_STATE_PATH = path.join(process.cwd(), '.planning', 'auto-state.json');
+
+function register(app) {
+
+  // ── SSE stream ──────────────────────────────────────────────────────────────
+  app.get('/events', (req, res) => {
+    res.setHeader('Content-Type',  'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection',    'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no'); // Disable Nginx buffering
+    res.flushHeaders();
+
+    // Send current status immediately on connect
+    try {
+      const status = Metrics.getStatus();
+      res.write(`event: status:update\ndata: ${JSON.stringify(status)}\n\n`);
+    } catch { /* ignore */ }
+
+    SSE.addClient(res);
+  });
+
+  // ── Status ──────────────────────────────────────────────────────────────────
+  app.get('/api/status', (req, res) => {
+    try {
+      res.json(Metrics.getStatus());
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Audit entries ───────────────────────────────────────────────────────────
+  app.get('/api/audit', (req, res) => {
+    try {
+      const limit  = Math.min(parseInt(req.query.limit  || '50',  10), 200);
+      const offset = Math.max(parseInt(req.query.offset || '0',   10), 0);
+      const event  = typeof req.query.event === 'string' ? req.query.event : null;
+      res.json(Metrics.getAuditEntries(limit, offset, event));
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Quality metrics ─────────────────────────────────────────────────────────
+  app.get('/api/metrics', (req, res) => {
+    try {
+      res.json(Metrics.getMetrics());
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Approvals ───────────────────────────────────────────────────────────────
+  app.get('/api/approvals', (req, res) => {
+    try {
+      res.json(Metrics.getApprovals());
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/approve/:id', (req, res) => {
+    try {
+      const { id }                  = req.params;
+      const { decision, comment, approver } = req.body || {};
+
+      if (!decision) {
+        return res.status(400).json({ error: 'Missing "decision" field (approve|reject)' });
+      }
+
+      const result = Approval.processDecision(id, decision, comment, approver);
+
+      if (!result.success) {
+        return res.status(400).json(result);
+      }
+
+      // Broadcast approval event to all SSE clients
+      SSE.broadcast(
+        decision === 'approve' ? 'approval:resolved' : 'approval:resolved',
+        { approval_id: id, decision, message: result.message }
+      );
+
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Team activity ───────────────────────────────────────────────────────────
+  app.get('/api/team', (req, res) => {
+    try {
+      res.json(Metrics.getTeamActivity());
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Knowledge base query ────────────────────────────────────────────────────
+  app.get('/api/memory', (req, res) => {
+    try {
+      const q     = typeof req.query.q     === 'string' ? req.query.q.slice(0, 100) : '';
+      const limit = Math.min(parseInt(req.query.limit || '20', 10), 100);
+      res.json(Metrics.getMemory(q, limit));
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Costs ───────────────────────────────────────────────────────────────────
+  app.get('/api/costs', (req, res) => {
+    try {
+      const window = Math.min(parseInt(req.query.window || '7', 10), 90);
+      res.json(Metrics.getCosts(window));
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Steering (requires auto mode running) ───────────────────────────────────
+  app.post('/api/steer', (req, res) => {
+    try {
+      const { instruction, priority = 'normal' } = req.body || {};
+
+      if (!instruction || typeof instruction !== 'string') {
+        return res.status(400).json({ error: 'Missing "instruction" field' });
+      }
+      if (instruction.length > 500) {
+        return res.status(400).json({ error: 'Instruction too long (max 500 chars)' });
+      }
+      if (!['normal', 'urgent', 'stop'].includes(priority)) {
+        return res.status(400).json({ error: 'Invalid priority. Use: normal|urgent|stop' });
+      }
+
+      // Check auto mode is running
+      const autoState = fs.existsSync(AUTO_STATE_PATH)
+        ? JSON.parse(fs.readFileSync(AUTO_STATE_PATH, 'utf8'))
+        : null;
+
+      if (!autoState || autoState.status !== 'running') {
+        return res.status(409).json({ error: 'Auto mode is not running. Steering has no effect.' });
+      }
+
+      // Run injection guard
+      const INJECTION_PATTERNS = [
+        /IGNORE ALL PREVIOUS INSTRUCTIONS/i,
+        /DISREGARD YOUR INSTRUCTIONS/i,
+        /FORGET YOUR TRAINING/i,
+        /YOUR NEW INSTRUCTIONS ARE/i,
+        /OVERRIDE:/i,
+      ];
+      if (INJECTION_PATTERNS.some(p => p.test(instruction))) {
+        return res.status(400).json({ error: 'Instruction rejected: contains prohibited patterns' });
+      }
+
+      // Write to steering queue
+      const entry = {
+        id:          require('crypto').randomBytes(8).toString('hex'),
+        timestamp:   new Date().toISOString(),
+        instruction: instruction.trim(),
+        priority,
+        authored_by: 'dashboard',
+        applies_to:  'all',
+        status:      'queued',
+        applied_at:  null,
+        applied_to_plan: null,
+      };
+
+      if (!fs.existsSync(path.dirname(STEERING_QUEUE))) {
+        fs.mkdirSync(path.dirname(STEERING_QUEUE), { recursive: true });
+      }
+      fs.appendFileSync(STEERING_QUEUE, JSON.stringify(entry) + '\n');
+
+      res.json({ success: true, queued: true, id: entry.id, priority });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Client count (for dashboard connection indicator) ───────────────────────
+  app.get('/api/connections', (req, res) => {
+    res.json({ clients: SSE.getClientCount() });
+  });
+}
+
+module.exports = { register };