mindforge-cc 8.1.1 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/spawn-agent.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * MindForge Agent Spawner — v2.0.0
+ * Specialized logic for invoking personas and identities.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ARGS = process.argv.slice(2);
+const MODE = ARGS[0]; // 'spawn' or 'identity'
+const TARGET = ARGS[1];
+const IS_DRY_RUN = ARGS.includes('--dry-run');
+
+const ROOT = path.resolve(__dirname, '..');
+
+if (!MODE || !TARGET) {
+  console.error('❌ Usage: node bin/spawn-agent.js <mode> <target> [--dry-run]');
+  process.exit(1);
+}
+
+async function run() {
+  let identityPath;
+  let personaPath;
+
+  if (MODE === 'identity') {
+    identityPath = path.join(ROOT, 'agents', TARGET, 'IDENTITY.md');
+    if (!fs.existsSync(identityPath)) {
+      console.error(`❌ Identity not found: ${identityPath}`);
+      process.exit(1);
+    }
+    console.log(`📡 Loading specialized identity: ${TARGET}`);
+  } else if (MODE === 'spawn') {
+    personaPath = path.join(ROOT, '.mindforge', 'personas', `${TARGET}.md`);
+    if (!fs.existsSync(personaPath)) {
+      console.error(`❌ Persona not found: ${personaPath}`);
+      process.exit(1);
+    }
+    console.log(`🌌 Spawning persona essence: ${TARGET}`);
+  }
+
+  if (IS_DRY_RUN) {
+    console.log('🧪 Dry run successful. Environment prepared.');
+    process.exit(0);
+  }
+
+  // Future: Integration with Antigravity / Claude Code runtime
+  console.log('🛠️ Dispatching to agent runtime...');
+  // For now, we simulate the environment preparation
+  setTimeout(() => {
+    console.log('✅ Agent environment active.');
+    process.exit(0);
+  }, 500);
+}
+
+run().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/updater/changelog-fetcher.js

@@ -0,0 +1,62 @@
+/**
+ * MindForge — Changelog Fetcher
+ * Downloads and parses CHANGELOG.md entries between two versions.
+ * Used by /mindforge:update to show what changed.
+ */
+'use strict';
+
+const { compareSemver } = require('./version-comparator');
+
+const CHANGELOG_URL = 'https://raw.githubusercontent.com/mindforge-dev/mindforge/main/CHANGELOG.md';
+
+/**
+ * Fetch CHANGELOG.md and extract entries between fromVersion and toVersion.
+ * Returns formatted markdown string, or null if unavailable.
+ */
+async function fetchChangelog(fromVersion, toVersion) {
+  const raw = await fetchRaw();
+  if (!raw) return null;
+  return extractEntries(raw, fromVersion, toVersion);
+}
+
+async function fetchRaw() {
+  const https = require('https');
+  return new Promise(resolve => {
+    const req = https.get(CHANGELOG_URL, { timeout: 8000 }, res => {
+      if (res.statusCode !== 200) { resolve(null); return; }
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { body += chunk; });
+      res.on('end', () => resolve(body));
+    });
+    req.on('error',   () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+/**
+ * Parse CHANGELOG.md and extract version sections in range (from, to].
+ */
+function extractEntries(changelog, fromVersion, toVersion) {
+  const sections = [];
+  let current = null;
+
+  for (const line of changelog.split('\n')) {
+    const vMatch = line.match(/^## \[?v?(\d+\.\d+\.\d+)/);
+    if (vMatch) {
+      if (current) sections.push(current);
+      const v = vMatch[1];
+      const inRange = compareSemver(v, fromVersion) > 0 && compareSemver(v, toVersion) <= 0;
+      current = inRange ? { version: v, lines: [line] } : null;
+    } else if (current) {
+      current.lines.push(line);
+    }
+  }
+  if (current) sections.push(current);
+
+  return sections.length
+    ? sections.map(s => s.lines.join('\n').trimEnd()).join('\n\n')
+    : null;
+}
+
+module.exports = { fetchChangelog };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/updater/self-update.js

@@ -0,0 +1,169 @@
+/**
+ * MindForge — Self-Update Engine
+ * Full update workflow: check → changelog → scope detection → apply → migrate → verify.
+ */
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+const { execSync }         = require('child_process');
+const { compareSemver, upgradeType, fetchLatestVersion } = require('./version-comparator');
+const { fetchChangelog }   = require('./changelog-fetcher');
+
+const CURRENT_VERSION = require('../../package.json').version;
+
+/**
+ * Detect where MindForge was originally installed.
+ * Checks local before global (local installs take precedence).
+ * Returns { scope: 'local'|'global', runtime: 'claude'|'antigravity' }
+ */
+function detectInstallScope() {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const cwd  = process.cwd();
+
+  // Per ADR-019: local installs take precedence over global
+  const locations = [
+    { scope: 'local',  runtime: 'claude',      file: path.join(cwd,  '.claude', 'CLAUDE.md') },
+    { scope: 'local',  runtime: 'antigravity', file: path.join(cwd,  '.agent',  'CLAUDE.md') },
+    { scope: 'global', runtime: 'claude',      file: path.join(home, '.claude', 'CLAUDE.md') },
+    { scope: 'global', runtime: 'antigravity', file: path.join(home, '.gemini', 'antigravity', 'CLAUDE.md') },
+  ];
+
+  for (const loc of locations) {
+    if (fs.existsSync(loc.file) && fs.readFileSync(loc.file, 'utf8').includes('MindForge')) {
+      return { scope: loc.scope, runtime: loc.runtime };
+    }
+  }
+
+  // Default: global claude (most common installation)
+  return { scope: 'global', runtime: 'claude' };
+}
+
+/**
+ * Read the schema_version from HANDOFF.json.
+ * This is the authoritative "what version are the .planning files" source.
+ * Must be read BEFORE the update runs (after update, installer version = new).
+ */
+function readHandoffSchemaVersion() {
+  const handoffPath = path.join(process.cwd(), '.planning', 'HANDOFF.json');
+  if (!fs.existsSync(handoffPath)) return null;
+  try {
+    const data = JSON.parse(fs.readFileSync(handoffPath, 'utf8'));
+    return data.schema_version || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Main update entry point.
+ * Called by /mindforge:update command.
+ *
+ * options:
+ *   apply          {boolean}  — actually apply the update (default: false = check only)
+ *   force          {boolean}  — skip major-version safety warning
+ *   skipChangelog  {boolean}  — skip changelog fetch
+ */
+async function checkAndUpdate(options = {}) {
+  const { apply = false, force = false, skipChangelog = false } = options;
+  const isCI = process.env.CI === 'true' || process.env.MINDFORGE_CI === 'true';
+
+  const TTY = process.stdout.isTTY;
+  const bold = s => TTY ? `\x1b[1m${s}\x1b[0m` : s;
+  const warn = s => TTY ? `\x1b[33m${s}\x1b[0m` : s;
+  const ok   = s => TTY ? `\x1b[32m${s}\x1b[0m` : s;
+  const err  = s => TTY ? `\x1b[31m${s}\x1b[0m` : s;
+
+  console.log(`\n${bold('⚡  MindForge Update Check')}\n`);
+  console.log(`  Current : v${CURRENT_VERSION}`);
+  process.stdout.write('  Latest  : checking npm registry... ');
+
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion) {
+    console.log(`${warn('unavailable')}`);
+    console.log(`\n  ${warn('⚠️')}  Cannot reach npm registry. Check your internet connection.`);
+    console.log('  Manual check: npm info mindforge-cc version\n');
+    return { status: 'check-failed' };
+  }
+
+  const type = upgradeType(CURRENT_VERSION, latestVersion);
+  if (type === 'none') {
+    console.log(`${ok('up to date')}`);
+    console.log(`\n  ${ok('✅')}  v${CURRENT_VERSION} is the latest version.\n`);
+    return { status: 'up-to-date', current: CURRENT_VERSION };
+  }
+
+  console.log(`${ok(`v${latestVersion} available`)}`);
+  console.log(`  Update  : ${CURRENT_VERSION} → ${latestVersion} ${warn(`(${type})`)}`);
+
+  // Major version safety gate
+  if (type === 'major' && !force) {
+    console.log(`\n  ${warn('⚠️  MAJOR UPDATE')} — may contain breaking changes.`);
+    console.log('  Review the changelog before applying.');
+    console.log('  To apply anyway: /mindforge:update --apply --force\n');
+  }
+
+  // Fetch and display changelog
+  if (!skipChangelog) {
+    process.stdout.write('\n  Fetching changelog... ');
+    const changelog = await fetchChangelog(CURRENT_VERSION, latestVersion);
+    if (changelog) {
+      console.log('done\n');
+      console.log('─'.repeat(62));
+      console.log(changelog.slice(0, 3000));  // Max 3000 chars to avoid flooding terminal
+      if (changelog.length > 3000) console.log('\n  [changelog truncated — see CHANGELOG.md for full details]');
+      console.log('─'.repeat(62));
+    } else {
+      console.log('unavailable\n');
+    }
+  }
+
+  if (!apply) {
+    if (isCI) {
+      console.log('\n  CI mode: check-only (no apply without --apply)');
+    }
+    console.log('\n  To apply: /mindforge:update --apply');
+    console.log(`  Or directly: npx mindforge-cc@${latestVersion} --update\n`);
+    return { status: 'update-available', current: CURRENT_VERSION, latest: latestVersion, type };
+  }
+
+  // ── Apply the update ────────────────────────────────────────────────────────
+
+  // Capture schema version BEFORE updating (critical for correct migration path)
+  const fromSchemaVersion = readHandoffSchemaVersion() || CURRENT_VERSION;
+  console.log(`\n  Schema version: v${fromSchemaVersion}`);
+
+  // Detect original install scope to preserve it
+  const { scope, runtime } = detectInstallScope();
+  console.log(`  Install scope : ${runtime} / ${scope}`);
+  console.log('\n  Applying update...');
+
+  try {
+    execSync(
+      `npx mindforge-cc@${latestVersion} --${runtime} --${scope}`,
+      { stdio: 'inherit', timeout: 120_000 }
+    );
+  } catch (updateErr) {
+    console.error(`\n  ${err('❌')}  Update failed: ${updateErr.message}`);
+    console.error(`  Fallback: npx mindforge-cc@${latestVersion} --${runtime} --${scope}`);
+    return { status: 'update-failed', error: updateErr.message };
+  }
+
+  // Run schema migration with the pre-update schema version
+  try {
+    const { runMigrations } = require('../migrations/migrate');
+    const migResult = await runMigrations(fromSchemaVersion, latestVersion);
+    if (migResult.status === 'migrated') {
+      console.log(`  ✅  Schema migrated: v${fromSchemaVersion} → v${latestVersion}`);
+    }
+  } catch (migErr) {
+    console.warn(`  ${warn('⚠️')}  Schema migration had an issue: ${migErr.message}`);
+    console.warn('      Run /mindforge:migrate manually if state files look wrong.');
+  }
+
+  console.log(`\n  ${ok('✅')}  MindForge updated to v${latestVersion}\n`);
+  console.log('  Run /mindforge:health to verify the update.\n');
+  return { status: 'updated', from: CURRENT_VERSION, to: latestVersion };
+}
+
+module.exports = { checkAndUpdate, detectInstallScope, readHandoffSchemaVersion };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/updater/version-comparator.js

@@ -0,0 +1,68 @@
+/**
+ * MindForge — Version Comparator
+ * Pure functions for semver comparison.
+ * No external dependencies — must work offline.
+ */
+'use strict';
+
+/**
+ * Compare two semver strings (strips leading 'v').
+ * Returns: negative if a < b, 0 if a == b, positive if a > b
+ */
+function compareSemver(a, b) {
+  const pa = a.replace(/^v/, '').split('.').map(Number);
+  const pb = b.replace(/^v/, '').split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] || 0) - (pb[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+/**
+ * Determine the upgrade type between two versions.
+ * Returns 'major' | 'minor' | 'patch' | 'none'
+ */
+function upgradeType(current, latest) {
+  const c = current.replace(/^v/, '').split('.').map(Number);
+  const l = latest.replace(/^v/, '').split('.').map(Number);
+  if (l[0] > c[0]) return 'major';
+  if (l[1] > c[1]) return 'minor';
+  if (l[2] > c[2]) return 'patch';
+  return 'none';
+}
+
+/**
+ * Fetch the latest published version from the npm registry.
+ * Returns null on any error — callers must handle gracefully.
+ * Timeout: 5 seconds (respects enterprise proxies that may be slow).
+ */
+async function fetchLatestVersion(packageName = 'mindforge-cc') {
+  const https = require('https');
+  return new Promise(resolve => {
+    const options = {
+      hostname: 'registry.npmjs.org',
+      path:     `/${encodeURIComponent(packageName)}/latest`,
+      method:   'GET',
+      headers:  { 'Accept': 'application/json', 'User-Agent': `mindforge-cc/${require('../../package.json').version}` },
+      timeout:  5000,
+    };
+
+    const req = https.request(options, res => {
+      if (res.statusCode !== 200) { resolve(null); return; }
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { body += chunk; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(body).version || null); }
+        catch { resolve(null); }
+      });
+    });
+
+    req.on('error',   () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+    req.end();
+  });
+}
+
+module.exports = { compareSemver, upgradeType, fetchLatestVersion };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/validate-config.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * MindForge configuration validator
+ * Validates MINDFORGE.md against the JSON schema
+ * Usage: node bin/validate-config.js [path-to-MINDFORGE.md]
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const CONFIG_PATH  = process.argv[2] || 'MINDFORGE.md';
+const SCHEMA_PATH  = '.mindforge/MINDFORGE-SCHEMA.json';
+
+if (!fs.existsSync(CONFIG_PATH)) {
+  console.log('ℹ️  MINDFORGE.md not found — using all defaults. Create one to customise.');
+  process.exit(0);
+}
+
+if (!fs.existsSync(SCHEMA_PATH)) {
+  console.log('ℹ️  MINDFORGE-SCHEMA.json not found — skipping schema validation.');
+  process.exit(0);
+}
+
+const content = fs.readFileSync(CONFIG_PATH, 'utf8');
+const schema  = JSON.parse(fs.readFileSync(SCHEMA_PATH, 'utf8'));
+
+const errors   = [];
+const warnings = [];
+
+// Parse key=value pairs from MINDFORGE.md
+const settings = {};
+const lines = content.split('\n');
+lines.forEach(line => {
+  const match = line.match(/^([A-Z_]+)=(.+)$/);
+  if (match) {
+    const [, key, value] = match;
+    settings[key] = value.trim();
+  }
+});
+
+// Validate against schema
+for (const [key, def] of Object.entries(schema.properties || {})) {
+  const value = settings[key];
+
+  if (def.required && !value) {
+    errors.push(`${key} is required but not set`);
+    continue;
+  }
+
+  if (!value) continue;
+
+  if (def.type === 'number') {
+    const num = parseFloat(value);
+    if (isNaN(num)) errors.push(`${key}: expected number, got "${value}"`);
+    if (def.minimum !== undefined && num < def.minimum)
+      errors.push(`${key}: ${num} is below minimum ${def.minimum}`);
+    if (def.maximum !== undefined && num > def.maximum)
+      errors.push(`${key}: ${num} exceeds maximum ${def.maximum}`);
+  }
+
+  if (def.type === 'enum' && !def.values.includes(value)) {
+    errors.push(`${key}: "${value}" is not valid. Options: ${def.values.join(', ')}`);
+  }
+
+  if (def.type === 'boolean' && !['true','false'].includes(value)) {
+    errors.push(`${key}: expected true or false, got "${value}"`);
+  }
+
+  if (def.nonOverridable) {
+    warnings.push(`${key}: this is a non-overridable governance primitive (value will be ignored)`);
+  }
+}
+
+// Report
+const total = errors.length + warnings.length;
+if (total === 0) {
+  console.log(`✅ MINDFORGE.md valid — ${Object.keys(settings).length} settings configured`);
+  process.exit(0);
+}
+
+if (errors.length) {
+  console.error(`❌ MINDFORGE.md has ${errors.length} error(s):`);
+  errors.forEach(e => console.error(`   • ${e}`));
+}
+if (warnings.length) {
+  console.warn(`⚠️  MINDFORGE.md has ${warnings.length} warning(s):`);
+  warnings.forEach(w => console.warn(`   • ${w}`));
+}
+
+process.exit(errors.length ? 1 : 0);

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/wizard/config-generator.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function ensureDir(p) {
+  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
+}
+
+function replaceIfPlaceholder(content, placeholder, value, keyName) {
+  if (content.includes(placeholder)) {
+    return {
+      content: content.replace(placeholder, value),
+      changed: true,
+      msg: `  ✅ ${keyName} configured`,
+    };
+  }
+  if (!content.includes(value)) {
+    return {
+      content,
+      changed: false,
+      msg: `  ⏭️  ${keyName} already configured — not overwriting`,
+    };
+  }
+  return { content, changed: false, msg: null };
+}
+
+async function writeIntegrationsConfig(config) {
+  const configPath = '.mindforge/org/integrations/INTEGRATIONS-CONFIG.md';
+  ensureDir(path.dirname(configPath));
+
+  if (!fs.existsSync(configPath)) {
+    console.log('  ⏭️  INTEGRATIONS-CONFIG.md not found — skipping integration write');
+    return;
+  }
+
+  let content = fs.readFileSync(configPath, 'utf8');
+  const logs = [];
+
+  if (config.jira) {
+    let out = replaceIfPlaceholder(
+      content,
+      'JIRA_BASE_URL=https://your-org.atlassian.net',
+      `JIRA_BASE_URL=${config.jira.baseUrl}`,
+      'JIRA_BASE_URL'
+    );
+    content = out.content; if (out.msg) logs.push(out.msg);
+
+    out = replaceIfPlaceholder(
+      content,
+      'JIRA_PROJECT_KEY=ENG',
+      `JIRA_PROJECT_KEY=${config.jira.projectKey}`,
+      'JIRA_PROJECT_KEY'
+    );
+    content = out.content; if (out.msg) logs.push(out.msg);
+  }
+
+  if (config.slack) {
+    const out = replaceIfPlaceholder(
+      content,
+      'SLACK_CHANNEL_ID=C01234ABCDE',
+      `SLACK_CHANNEL_ID=${config.slack.channelId}`,
+      'SLACK_CHANNEL_ID'
+    );
+    content = out.content; if (out.msg) logs.push(out.msg);
+  }
+
+  if (config.github) {
+    let out = replaceIfPlaceholder(
+      content,
+      'GITHUB_REPO=your-org/your-repo',
+      `GITHUB_REPO=${config.github.repo}`,
+      'GITHUB_REPO'
+    );
+    content = out.content; if (out.msg) logs.push(out.msg);
+
+    out = replaceIfPlaceholder(
+      content,
+      'GITHUB_DEFAULT_REVIEWERS=senior-engineer-1,senior-engineer-2',
+      `GITHUB_DEFAULT_REVIEWERS=${config.github.reviewers}`,
+      'GITHUB_DEFAULT_REVIEWERS'
+    );
+    content = out.content; if (out.msg) logs.push(out.msg);
+  }
+
+  fs.writeFileSync(configPath, content);
+  logs.forEach((l) => console.log(l));
+}
+
+async function writeGovernanceConfig(team) {
+  const configPath = '.mindforge/governance/GOVERNANCE-CONFIG.md';
+  ensureDir(path.dirname(configPath));
+  if (!fs.existsSync(configPath)) return;
+
+  let content = fs.readFileSync(configPath, 'utf8');
+  if (team.tier2Approvers && content.includes('TIER2_APPROVERS=senior-engineer-1,senior-engineer-2')) {
+    content = content.replace(
+      'TIER2_APPROVERS=senior-engineer-1,senior-engineer-2',
+      `TIER2_APPROVERS=${team.tier2Approvers}`
+    );
+  }
+  if (team.tier3Approvers && content.includes('TIER3_APPROVERS=security-officer,compliance-officer,cto')) {
+    content = content.replace(
+      'TIER3_APPROVERS=security-officer,compliance-officer,cto',
+      `TIER3_APPROVERS=${team.tier3Approvers}`
+    );
+  }
+
+  fs.writeFileSync(configPath, content);
+}
+
+module.exports = { writeIntegrationsConfig, writeGovernanceConfig };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/wizard/environment-detector.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function safeExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function readJsonSafe(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+async function detect() {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const cwd = process.cwd();
+
+  const runtimes = [];
+  if (fs.existsSync(path.join(home, '.claude')) || fs.existsSync(path.join(cwd, '.claude'))) runtimes.push('claude');
+  if (
+    fs.existsSync(path.join(home, '.gemini', 'antigravity')) ||
+    fs.existsSync(path.join(cwd, '.agent')) ||
+    fs.existsSync(path.join(cwd, '.agents')) ||
+    fs.existsSync(path.join(cwd, 'agents'))
+  ) {
+    runtimes.push('antigravity');
+  }
+
+  let projectType = 'unknown';
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = readJsonSafe(pkgPath) || {};
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    if (deps.next || deps.react) projectType = 'Next.js / React';
+    else if (deps.fastify || deps.express) projectType = 'Node.js API';
+    else projectType = 'Node.js';
+  } else if (fs.existsSync(path.join(cwd, 'pyproject.toml'))) {
+    projectType = 'Python';
+  } else if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) {
+    projectType = 'Rust';
+  } else if (fs.existsSync(path.join(cwd, 'go.mod'))) {
+    projectType = 'Go';
+  }
+
+  let packageManager = 'npm';
+  if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) packageManager = 'pnpm';
+  else if (fs.existsSync(path.join(cwd, 'yarn.lock'))) packageManager = 'yarn';
+  else if (fs.existsSync(path.join(cwd, 'bun.lockb'))) packageManager = 'bun';
+
+  let existingInstall = false;
+  let existingVersion = null;
+  const claudePath = path.join(cwd, '.claude', 'CLAUDE.md');
+  if (fs.existsSync(claudePath)) {
+    const content = fs.readFileSync(claudePath, 'utf8');
+    if (content.includes('MindForge')) {
+      existingInstall = true;
+      const m = content.match(/MindForge v(\d+\.\d+\.\d+)/);
+      existingVersion = m ? m[1] : 'unknown';
+    }
+  }
+
+  return {
+    runtimes,
+    hasGit: !!safeExec('git rev-parse --is-inside-work-tree'),
+    projectType,
+    packageManager,
+    existingInstall,
+    existingVersion,
+    nodeVersion: process.versions.node,
+    platform: process.platform,
+  };
+}
+
+module.exports = { detect };