mindforge-cc 1.0.5 → 2.0.0-alpha.6

package/bin/install.js

@@ -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);
 }
@@ -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);
   });
 }

package/bin/installer-core.js

@@ -21,7 +21,7 @@ const RUNTIMES = {
   antigravity: {
     globalDir:      path.join(os.homedir(), '.gemini', 'antigravity'),
     localDir:       'agents',
-    commandsSubdir: 'mindforge',
+    commandsSubdir: 'workflows',
     entryFile:      'CLAUDE.md',
   },
 };
@@ -51,6 +51,31 @@ const fsu = {
   },
 };
 
+// ── Registry Management ────────────────────────────────────────────────────────
+const RegistryManager = {
+  getRegistryPath: () => path.join(os.homedir(), '.mindforge', 'registry.json'),
+
+  registerProject(projectPath) {
+    const regPath = this.getRegistryPath();
+    fsu.ensureDir(path.dirname(regPath));
+
+    let registry = { projects: [] };
+    if (fsu.exists(regPath)) {
+      try {
+        registry = JSON.parse(fsu.read(regPath));
+      } catch (e) {
+        console.error('  ⚠️  Registry file corrupted, recreating...');
+      }
+    }
+
+    if (!registry.projects.includes(projectPath)) {
+      registry.projects.push(projectPath);
+      fsu.write(regPath, JSON.stringify(registry, null, 2));
+      console.log(`  ✅  Registered project in ${regPath}`);
+    }
+  }
+};
+
 // ── Self-install detection ────────────────────────────────────────────────────
 function isSelfInstall() {
   const pkgPath = path.join(process.cwd(), 'package.json');
@@ -88,7 +113,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 +137,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.');
         }
       }
     }
@@ -125,14 +150,14 @@ function safeCopyClaude(src, dst, options = {}) {
 
 // ── Install verification ──────────────────────────────────────────────────────
 function verifyInstall(baseDir, cmdsDir, runtime, scope) {
-  // Minimum required files for a functional installation
+  const pfx = runtime === 'antigravity' ? 'mindforge:' : '';
   const required = [
-    path.join(baseDir, 'CLAUDE.md'),
-    path.join(cmdsDir, 'help.md'),
-    path.join(cmdsDir, 'init-project.md'),
-    path.join(cmdsDir, 'health.md'),
-    path.join(cmdsDir, 'execute-phase.md'),
-    path.join(cmdsDir, 'security-scan.md'),
+    scope === 'local' ? path.join(process.cwd(), 'CLAUDE.md') : path.join(baseDir, 'CLAUDE.md'),
+    path.join(cmdsDir, `${pfx}help.md`),
+    path.join(cmdsDir, `${pfx}init-project.md`),
+    path.join(cmdsDir, `${pfx}health.md`),
+    path.join(cmdsDir, `${pfx}execute-phase.md`),
+    path.join(cmdsDir, `${pfx}security-scan.md`),
   ];
 
   const missing = required.filter(f => !fsu.exists(f));
@@ -161,24 +186,38 @@ 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;
   }
 
-  // ── 1. Install CLAUDE.md ────────────────────────────────────────────────────
+  // ── 1. Install CLAUDE.md (Root standardization for IDEs) ────────────────────
   const claudeSrc = runtime === 'claude'
     ? src('.claude', 'CLAUDE.md')
     : src('.agent', 'CLAUDE.md');
 
   if (fsu.exists(claudeSrc)) {
+    // Keep legacy location based on runtime config
     safeCopyClaude(claudeSrc, path.join(baseDir, 'CLAUDE.md'), { force, verbose });
-    console.log(`  ✅  CLAUDE.md`);
+
+    // ✨ STANDARD: Inject into project root and IDE-specific rules files
+    if (scope === 'local' && !selfInstall) {
+      const rootClaude = path.join(process.cwd(), 'CLAUDE.md');
+      const rootCursor = path.join(process.cwd(), '.cursorrules');
+      const rootWindsurf = path.join(process.cwd(), '.windsurfrules');
+      
+      safeCopyClaude(claudeSrc, rootClaude, { force, verbose });
+      safeCopyClaude(claudeSrc, rootCursor, { force, verbose });
+      safeCopyClaude(claudeSrc, rootWindsurf, { force, verbose });
+      console.log('  ✅  CLAUDE.md (Mirrored to project root & .cursorrules)');
+    } else {
+      console.log('  ✅  CLAUDE.md');
+    }
   }
 
   // ── 2. Install commands ─────────────────────────────────────────────────────
@@ -189,8 +228,24 @@ async function install(runtime, scope, options = {}) {
   if (fsu.exists(cmdSrc)) {
     fsu.ensureDir(cmdsDir);
     const files = fsu.listFiles(cmdSrc).filter(f => f.endsWith('.md'));
-    files.forEach(f => fsu.copy(path.join(cmdSrc, f), path.join(cmdsDir, f)));
-    console.log(`  ✅  ${files.length} commands`);
+    
+    // Install for specific runtime
+    files.forEach(f => {
+      const targetName = runtime === 'antigravity' ? `mindforge:${f}` : f;
+      fsu.copy(path.join(cmdSrc, f), path.join(cmdsDir, targetName));
+    });
+
+    // ✨ STANDARD: Mirror to .claude/commands for cross-IDE compatibility (Cursor/Windsurf/Claude Code)
+    if (scope === 'local' && runtime !== 'claude' && !selfInstall) {
+      const standardCmdDir = path.join(process.cwd(), '.claude', 'commands', 'mindforge');
+      fsu.ensureDir(standardCmdDir);
+      files.forEach(f => {
+        fsu.copy(path.join(cmdSrc, f), path.join(standardCmdDir, f));
+      });
+      console.log(`  ✅  ${files.length} commands (Mirrored to .claude/commands/mindforge/)`);
+    } else {
+      console.log(`  ✅  ${files.length} commands`);
+    }
   }
 
   // ── 3. Framework files (local scope only, non-self-install) ─────────────────
@@ -217,10 +272,10 @@ async function install(runtime, scope, options = {}) {
           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)`);
+        console.log('  ✅  .mindforge/ (minimal core)');
       } else {
         fsu.copyDir(forgeSrc, forgeDst, { excludePatterns: SENSITIVE_EXCLUDE });
-        console.log(`  ✅  .mindforge/ (framework engine)`);
+        console.log('  ✅  .mindforge/ (framework engine)');
       }
     }
 
@@ -236,14 +291,14 @@ async function install(runtime, scope, options = {}) {
             const d = path.join(planningDst, name);
             if (fsu.exists(s)) fsu.copy(s, d);
           });
-          console.log(`  ✅  .planning/ (minimal state)`);
+          console.log('  ✅  .planning/ (minimal state)');
         } else {
           fsu.copyDir(planningSrc, planningDst, { excludePatterns: SENSITIVE_EXCLUDE });
-          console.log(`  ✅  .planning/ (state templates)`);
+          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
@@ -251,7 +306,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)
@@ -260,17 +315,18 @@ 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');
       }
     }
 
+    RegistryManager.registerProject(process.cwd());
   }
 
   // ── 4. Verify installation ──────────────────────────────────────────────────
   verifyInstall(baseDir, cmdsDir, runtime, scope);
-  console.log(`  ✅  Install verified`);
+  console.log('  ✅  Install verified');
 }
 
 // ── Uninstall ─────────────────────────────────────────────────────────────────
@@ -302,8 +358,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 ──────────────────────────────────────────────────────────────────
@@ -341,13 +397,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 };