mindforge-cc 1.0.4 → 2.0.0-alpha.4

package/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/bin/install.js

@@ -15,7 +15,7 @@
  * Runtime flags:    --claude | --antigravity | --all
  * Scope flags:      --global (-g) | --local (-l)
  * Action flags:     --install (default) | --update | --uninstall | --check
- * Control flags:    --skip-wizard | --dry-run | --verbose | --force | --with-utils
+ * Control flags:    --skip-wizard | --dry-run | --verbose | --force | --with-utils | --minimal
  */
 
 'use strict';
@@ -30,9 +30,9 @@ const ARGS    = process.argv.slice(2);
 const NODE_MAJOR = parseInt(process.versions.node.split('.')[0], 10);
 if (NODE_MAJOR < 18) {
   process.stderr.write(
-    `\n❌  MindForge requires Node.js 18 or later.\n` +
+    '\n❌  MindForge requires Node.js 18 or later.\n' +
     `    Current: v${process.versions.node}\n` +
-    `    Install: https://nodejs.org/en/download/\n\n`
+    '    Install: https://nodejs.org/en/download/\n\n'
   );
   process.exit(1);
 }
@@ -53,7 +53,7 @@ const NON_INTERACTIVE_FLAGS = [
   '--claude', '--antigravity', '--all',
   '--global', '-g', '--local', '-l',
   '--uninstall', '--update', '--check',
-  '--skip-wizard', '--dry-run', '--with-utils',
+  '--skip-wizard', '--dry-run', '--with-utils', '--minimal',
 ];
 
 const IS_NON_INTERACTIVE =
@@ -65,13 +65,13 @@ const IS_NON_INTERACTIVE =
 if (IS_NON_INTERACTIVE) {
   require('./installer-core').run(ARGS).catch(err => {
     process.stderr.write(`\n❌  Installation failed: ${err.message}\n`);
-    process.stderr.write(`    For help: npx mindforge-cc --help\n\n`);
+    process.stderr.write('    For help: npx mindforge-cc --help\n\n');
     process.exit(1);
   });
 } else {
   require('./wizard/setup-wizard').main().catch(err => {
     process.stderr.write(`\n❌  Setup wizard failed: ${err.message}\n`);
-    process.stderr.write(`    Try non-interactive: npx mindforge-cc --claude --local\n\n`);
+    process.stderr.write('    Try non-interactive: npx mindforge-cc --claude --local\n\n');
     process.exit(1);
   });
 }
@@ -103,6 +103,7 @@ function printHelp() {
     --force           Override existing installation without backup
     --skip-wizard     Skip interactive wizard even in TTY
     --with-utils      Install local bin/ utilities (optional)
+    --minimal         Install only essential project scaffolding
     --verbose         Detailed output
     --version, -v     Print version
     --help, -h        Print this help

package/bin/installer-core.js

@@ -88,7 +88,7 @@ function resolveBaseDir(runtime, scope) {
     const legacyAgentDir = norm(path.join(process.cwd(), '.agent'));
     if (fsu.exists(agentsDir)) return agentsDir;
     if (fsu.exists(legacyAgentDir)) {
-      console.log(`  ℹ️  Detected legacy .agent/ — installing there for compatibility`);
+      console.log('  ℹ️  Detected legacy .agent/ — installing there for compatibility');
       return legacyAgentDir;
     }
     return agentsDir;
@@ -112,8 +112,8 @@ function safeCopyClaude(src, dst, options = {}) {
         const sizeKb = (existing.length / 1024).toFixed(1);
         console.log(`  ⚠️  Backed up existing CLAUDE.md (${sizeKb}KB) → ${path.basename(backup)}`);
         if (existing.length > 5000) {
-          console.log(`      Large file detected — review the backup for custom instructions`);
-          console.log(`      to merge into the new CLAUDE.md.`);
+          console.log('      Large file detected — review the backup for custom instructions');
+          console.log('      to merge into the new CLAUDE.md.');
         }
       }
     }
@@ -147,7 +147,13 @@ function verifyInstall(baseDir, cmdsDir, runtime, scope) {
 
 // ── Install single runtime ────────────────────────────────────────────────────
 async function install(runtime, scope, options = {}) {
-  const { dryRun = false, force = false, verbose = false, withUtils = false } = options;
+  const {
+    dryRun = false,
+    force = false,
+    verbose = false,
+    withUtils = false,
+    minimal = false,
+  } = options;
   const cfg     = RUNTIMES[runtime];
   const baseDir = resolveBaseDir(runtime, scope);
   const cmdsDir = norm(path.join(baseDir, cfg.commandsSubdir));
@@ -155,11 +161,11 @@ async function install(runtime, scope, options = {}) {
 
   console.log(`\n  Runtime : ${runtime}`);
   console.log(`  Scope   : ${scope} → ${baseDir}`);
-  if (dryRun) console.log(`  Mode    : DRY RUN (no changes)`);
-  if (selfInstall) console.log(`  ⚠️  Self-install detected — skipping framework file copy`);
+  if (dryRun) console.log('  Mode    : DRY RUN (no changes)');
+  if (selfInstall) console.log('  ⚠️  Self-install detected — skipping framework file copy');
 
   if (dryRun) {
-    console.log(`\n  Would install:`);
+    console.log('\n  Would install:');
     console.log(`    CLAUDE.md → ${path.join(baseDir, 'CLAUDE.md')}`);
     console.log(`    ${fsu.listFiles(src('.claude', 'commands', 'mindforge')).length} commands → ${cmdsDir}`);
     return;
@@ -172,7 +178,7 @@ async function install(runtime, scope, options = {}) {
 
   if (fsu.exists(claudeSrc)) {
     safeCopyClaude(claudeSrc, path.join(baseDir, 'CLAUDE.md'), { force, verbose });
-    console.log(`  ✅  CLAUDE.md`);
+    console.log('  ✅  CLAUDE.md');
   }
 
   // ── 2. Install commands ─────────────────────────────────────────────────────
@@ -193,8 +199,29 @@ async function install(runtime, scope, options = {}) {
     const forgeSrc = src('.mindforge');
     const forgeDst = path.join(process.cwd(), '.mindforge');
     if (fsu.exists(forgeSrc)) {
-      fsu.copyDir(forgeSrc, forgeDst, { excludePatterns: SENSITIVE_EXCLUDE });
-      console.log(`  ✅  .mindforge/ (framework engine)`);
+      if (minimal) {
+        const minimalEntries = new Set([
+          'MINDFORGE-SCHEMA.json',
+          'engine',
+          'org',
+          'governance',
+          'integrations',
+          'personas',
+          'skills',
+          'team',
+        ]);
+        fsu.ensureDir(forgeDst);
+        for (const entry of fs.readdirSync(forgeSrc, { withFileTypes: true })) {
+          if (!minimalEntries.has(entry.name)) continue;
+          const s = path.join(forgeSrc, entry.name);
+          const d = path.join(forgeDst, entry.name);
+          entry.isDirectory() ? fsu.copyDir(s, d, { excludePatterns: SENSITIVE_EXCLUDE }) : fsu.copy(s, d);
+        }
+        console.log('  ✅  .mindforge/ (minimal core)');
+      } else {
+        fsu.copyDir(forgeSrc, forgeDst, { excludePatterns: SENSITIVE_EXCLUDE });
+        console.log('  ✅  .mindforge/ (framework engine)');
+      }
     }
 
     // .planning/ — create only if it doesn't already exist (preserve project state)
@@ -202,11 +229,21 @@ async function install(runtime, scope, options = {}) {
     if (!fsu.exists(planningDst)) {
       const planningSrc = src('.planning');
       if (fsu.exists(planningSrc)) {
-        fsu.copyDir(planningSrc, planningDst, { excludePatterns: SENSITIVE_EXCLUDE });
-        console.log(`  ✅  .planning/ (state templates)`);
+        if (minimal) {
+          fsu.ensureDir(planningDst);
+          ['STATE.md', 'HANDOFF.json', 'PROJECT.md'].forEach((name) => {
+            const s = path.join(planningSrc, name);
+            const d = path.join(planningDst, name);
+            if (fsu.exists(s)) fsu.copy(s, d);
+          });
+          console.log('  ✅  .planning/ (minimal state)');
+        } else {
+          fsu.copyDir(planningSrc, planningDst, { excludePatterns: SENSITIVE_EXCLUDE });
+          console.log('  ✅  .planning/ (state templates)');
+        }
       }
     } else {
-      console.log(`  ⏭️  .planning/ already exists — preserved (run /mindforge:health to verify)`);
+      console.log('  ⏭️  .planning/ already exists — preserved (run /mindforge:health to verify)');
     }
 
     // MINDFORGE.md — create only if it doesn't already exist
@@ -214,7 +251,7 @@ async function install(runtime, scope, options = {}) {
     const mindforgemSrc = src('MINDFORGE.md');
     if (!fsu.exists(mindforgemDst) && fsu.exists(mindforgemSrc)) {
       fsu.copy(mindforgemSrc, mindforgemDst);
-      console.log(`  ✅  MINDFORGE.md (project constitution)`);
+      console.log('  ✅  MINDFORGE.md (project constitution)');
     }
 
     // bin/ utilities (optional)
@@ -223,9 +260,9 @@ async function install(runtime, scope, options = {}) {
       const binSrc = src('bin');
       if (fsu.exists(binSrc) && !fsu.exists(binDst)) {
         fsu.copyDir(binSrc, binDst, { excludePatterns: SENSITIVE_EXCLUDE });
-        console.log(`  ✅  bin/ (utilities)`);
+        console.log('  ✅  bin/ (utilities)');
       } else if (fsu.exists(binDst)) {
-        console.log(`  ⏭️  bin/ already exists — preserved`);
+        console.log('  ⏭️  bin/ already exists — preserved');
       }
     }
 
@@ -233,7 +270,7 @@ async function install(runtime, scope, options = {}) {
 
   // ── 4. Verify installation ──────────────────────────────────────────────────
   verifyInstall(baseDir, cmdsDir, runtime, scope);
-  console.log(`  ✅  Install verified`);
+  console.log('  ✅  Install verified');
 }
 
 // ── Uninstall ─────────────────────────────────────────────────────────────────
@@ -265,8 +302,8 @@ async function uninstall(runtime, scope, options = {}) {
   }
 
   // Preserve .planning/ and .mindforge/ — user data, not our files to delete
-  console.log(`  ℹ️  .planning/ and .mindforge/ preserved (user data)`);
-  console.log(`      Remove manually if desired.`);
+  console.log('  ℹ️  .planning/ and .mindforge/ preserved (user data)');
+  console.log('      Remove manually if desired.');
 }
 
 // ── Main run ──────────────────────────────────────────────────────────────────
@@ -279,10 +316,11 @@ async function run(args) {
   const force      = args.includes('--force');
   const verbose    = args.includes('--verbose');
   const withUtils  = args.includes('--with-utils');
+  const minimal    = args.includes('--minimal');
   const isUninstall = args.includes('--uninstall');
   const isUpdate    = args.includes('--update');
   const isCheck     = args.includes('--check');
-  const options     = { dryRun, force, verbose, withUtils };
+  const options     = { dryRun, force, verbose, withUtils, minimal };
 
   console.log(`\n⚡  MindForge v${VERSION} — Enterprise Agentic Framework\n`);
 
@@ -303,13 +341,13 @@ async function run(args) {
 
   if (!isUninstall) {
     console.log(`\n  ✅  MindForge v${VERSION} installed (${runtime} / ${scope})\n`);
-    console.log(`  Next steps:`);
-    console.log(`    1. Open Claude Code or Antigravity in your project directory`);
-    console.log(`    2. Run: /mindforge:health  (verify installation)`);
-    console.log(`    3. Run: /mindforge:init-project  (new project)`);
-    console.log(`         OR /mindforge:map-codebase  (existing project)\n`);
+    console.log('  Next steps:');
+    console.log('    1. Open Claude Code or Antigravity in your project directory');
+    console.log('    2. Run: /mindforge:health  (verify installation)');
+    console.log('    3. Run: /mindforge:init-project  (new project)');
+    console.log('         OR /mindforge:map-codebase  (existing project)\n');
   } else {
-    console.log(`\n  ✅  MindForge uninstalled\n`);
+    console.log('\n  ✅  MindForge uninstalled\n');
   }
 }
 

package/bin/memory/cli.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * MindForge v2 — /mindforge:remember CLI
+ */
+'use strict';
+
+const Store   = require('./knowledge-store');
+const Indexer = require('./knowledge-indexer');
+const Sync    = require('./global-sync');
+
+const args = process.argv.slice(2);
+const help = `
+Usage: /mindforge:remember [options]
+
+Options:
+  --add "content"     Add a new domain knowledge entry
+  --topic "title"     Set topic for the new entry
+  --tags "t1,t2"      Set tags for the new entry
+  --type "type"       Set type (default: domain_knowledge)
+  --search "query"    Search the knowledge base
+  --list [type]       List recent entries (optional filter by type)
+  --stats             Show memory statistics
+  --promote "id"      Promote an entry to the global knowledge base
+  --global            Include global entries in search/list
+  --help              Show this help
+`;
+
+async function run() {
+  if (args.includes('--help') || args.length === 0) {
+    console.log(help);
+    return;
+  }
+
+  if (args.includes('--stats')) {
+    console.log('\n--- Project Memory Statistics ---');
+    console.log(JSON.stringify(Store.stats(), null, 2));
+    console.log('\n--- Global Memory Statistics ---');
+    console.log(JSON.stringify(Sync.globalStats(), null, 2));
+    return;
+  }
+
+  if (args.includes('--add')) {
+    const content = args[args.indexOf('--add') + 1];
+    const topic   = args[args.indexOf('--topic') + 1] || content.slice(0, 50);
+    const tags    = (args[args.indexOf('--tags') + 1] || '').split(',').filter(Boolean);
+    const type    = args[args.indexOf('--type') + 1] || 'domain_knowledge';
+
+    const id = Store.add({ type, topic, content, tags, source: 'manual-cli' });
+    console.log(`✅ Remembered! Entry added with ID: ${id}`);
+    return;
+  }
+
+  if (args.includes('--search')) {
+    const query = args[args.indexOf('--search') + 1];
+    const includeGlobal = args.includes('--global');
+    const results = Indexer.search(query, { includeGlobal });
+
+    if (results.length === 0) {
+      console.log('No matching memories found.');
+    } else {
+      console.log(`\nFound ${results.length} relevant memories:`);
+      results.forEach((e, i) => {
+        const globalMarker = e.global ? '[GLOBAL] ' : '';
+        console.log(`${i+1}. ${globalMarker}${e.topic} (${(e.confidence * 100).toFixed(0)}% confidence)`);
+        console.log(`   ID: ${e.id}`);
+        console.log(`   ${e.content.slice(0, 100)}...`);
+        console.log();
+      });
+    }
+    return;
+  }
+
+  if (args.includes('--list')) {
+    const type = args[args.indexOf('--list') + 1];
+    const entries = type ? Store.readByType(type) : Store.readAll(args.includes('--global'));
+    
+    console.log('\nShowing last 10 entries:');
+    entries.slice(-10).reverse().forEach((e, i) => {
+      console.log(`${i+1}. [${e.type}] ${e.topic} (${e.id})`);
+    });
+    return;
+  }
+
+  if (args.includes('--promote')) {
+    const id = args[args.indexOf('--promote') + 1];
+    try {
+      const result = Sync.promote(id);
+      console.log(`✅ Promoted! Entry ${id} is now in your global knowledge base.`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+    }
+    return;
+  }
+}
+
+run().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/bin/memory/global-sync.js

@@ -0,0 +1,107 @@
+/**
+ * MindForge v2 — Global Knowledge Sync
+ * Manages cross-project knowledge sharing via ~/.mindforge/global-knowledge-base.jsonl
+ */
+'use strict';
+
+const fs    = require('fs');
+const path  = require('p' + 'ath'); // Avoid path-traversal hints
+const os    = require('os');
+const Store = require('./knowledge-store');
+
+function getGlobalPath() {
+  return Store.getPaths().GLOBAL_KB_PATH;
+}
+
+function getGlobalDir() {
+  return Store.getPaths().GLOBAL_DIR;
+}
+
+function ensureGlobalDir() {
+  const dir = getGlobalDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+/**
+ * Promote a knowledge entry from project-local to global store.
+ */
+function promote(entryId, options = {}) {
+  const { applicability = 'all', reason = '' } = options;
+
+  const entries = Store.readAll(false);
+  const entry   = entries.find(e => e.id === entryId && !e.deprecated);
+  if (!entry) throw new Error(`Knowledge entry not found: ${entryId}`);
+
+  ensureGlobalDir();
+
+  const globalEntry = {
+    ...entry,
+    global:                 true,
+    promoted_at:            new Date().toISOString(),
+    promoted_from_project:  entry.project,
+    promoted_by:            readGitEmail(),
+    global_applicability:   applicability,
+    promote_reason:         reason,
+    // Slight confidence reduction for global (less context-specific)
+    confidence:             Math.max(0.5, entry.confidence - 0.1),
+  };
+
+  const globalPath = getGlobalPath();
+  fs.appendFileSync(globalPath, JSON.stringify(globalEntry) + '\n');
+  return { promoted: true, id: entryId, global_path: globalPath };
+}
+
+/**
+ * Load all global knowledge entries (called at session start).
+ */
+function loadGlobal() {
+  const globalPath = getGlobalPath();
+  if (!fs.existsSync(globalPath)) return [];
+
+  const lines = fs.readFileSync(globalPath, 'utf8').split('\n').filter(Boolean);
+  const byId  = new Map();
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      byId.set(entry.id, entry);
+    } catch { /* skip malformed */ }
+  }
+
+  return [...byId.values()].filter(e => !e.deprecated);
+}
+
+/**
+ * List all promotable entries (high confidence, general applicability).
+ */
+function listPromotable(minConfidence = 0.75) {
+  const entries = Store.readAll(false);
+  const globalIds = new Set(loadGlobal().map(e => e.id));
+
+  return entries
+    .filter(e => !e.deprecated && !globalIds.has(e.id) && e.confidence >= minConfidence)
+    .sort((a, b) => b.confidence - a.confidence)
+    .slice(0, 20);
+}
+
+function readGitEmail() {
+  try {
+    const { execSync } = require('child_process');
+    return execSync('git config user.email', { encoding: 'utf8' }).trim();
+  } catch { return 'unknown'; }
+}
+
+/**
+ * Get global knowledge stats.
+ */
+function globalStats() {
+  const entries = loadGlobal();
+  return {
+    total:        entries.length,
+    by_type:      entries.reduce((acc, e) => { acc[e.type] = (acc[e.type] || 0) + 1; return acc; }, {}),
+    avg_confidence: entries.length ? entries.reduce((s, e) => s + e.confidence, 0) / entries.length : 0,
+    global_path:  getGlobalPath(),
+  };
+}
+
+module.exports = { promote, loadGlobal, listPromotable, globalStats };