mindforge-cc 1.0.0

package/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/bin/wizard/environment-detector.js

@@ -0,0 +1,76 @@
+'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'))) 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 };

package/bin/wizard/setup-wizard.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const readline = require('readline');
+const detector = require('./environment-detector');
+const generator = require('./config-generator');
+
+const VERSION = require('../../package.json').version;
+const ARGS = process.argv.slice(2);
+const IS_INTERACTIVE =
+  !ARGS.some((a) => ['--claude', '--antigravity', '--all', '--help'].includes(a)) &&
+  process.stdin.isTTY !== false;
+
+const TTY = process.stdout.isTTY;
+const c = {
+  bold: (s) => (TTY ? `\x1b[1m${s}\x1b[0m` : s),
+  cyan: (s) => (TTY ? `\x1b[36m${s}\x1b[0m` : s),
+  green: (s) => (TTY ? `\x1b[32m${s}\x1b[0m` : s),
+  yellow: (s) => (TTY ? `\x1b[33m${s}\x1b[0m` : s),
+  red: (s) => (TTY ? `\x1b[31m${s}\x1b[0m` : s),
+  dim: (s) => (TTY ? `\x1b[2m${s}\x1b[0m` : s),
+};
+
+function createReadline() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: TTY,
+  });
+}
+
+function ask(rl, q, def) {
+  return new Promise((resolve) => {
+    const prompt = def ? `${q} ${c.dim(`[${def}]`)}: ` : `${q}: `;
+    rl.question(prompt, (answer) => resolve(answer.trim() || def || ''));
+  });
+}
+
+function askChoice(rl, q, choices, defaultIdx = 0) {
+  console.log(`\n${q}`);
+  choices.forEach((choice, i) => console.log(`  ${i + 1}) ${choice}`));
+  return new Promise((resolve) => {
+    rl.question(`Choice [${defaultIdx + 1}]: `, (answer) => {
+      const idx = Number.parseInt(answer.trim(), 10) - 1;
+      resolve(choices[Number.isInteger(idx) && idx >= 0 && idx < choices.length ? idx : defaultIdx]);
+    });
+  });
+}
+
+function askMultiChoice(rl, q, choices) {
+  console.log(`\n${q}`);
+  choices.forEach((choice, i) => console.log(`  ${i + 1}) ${choice}`));
+  return new Promise((resolve) => {
+    rl.question('Select (comma-separated): ', (answer) => {
+      const selected = answer
+        .split(',')
+        .map((s) => Number.parseInt(s.trim(), 10) - 1)
+        .filter((i) => Number.isInteger(i) && i >= 0 && i < choices.length)
+        .map((i) => choices[i]);
+      resolve(selected.length ? selected : [choices[0]]);
+    });
+  });
+}
+
+function printBanner() {
+  console.log('');
+  console.log(c.bold(c.cyan('  MindForge Setup Wizard')));
+  console.log(c.dim(`  v${VERSION}`));
+  console.log('');
+}
+
+async function detectEnvironment() {
+  console.log(c.bold('  Detecting environment...\n'));
+  const env = await detector.detect();
+  const rows = [
+    ['Runtime(s)', env.runtimes.join(', ') || 'none'],
+    ['Git repo', env.hasGit ? 'yes' : 'no'],
+    ['Node.js', env.nodeVersion],
+    ['Project type', env.projectType],
+    ['Package manager', env.packageManager],
+    ['Existing MindForge', env.existingInstall ? `yes (${env.existingVersion})` : 'no'],
+  ];
+  rows.forEach(([k, v]) => console.log(`  ${c.dim(k.padEnd(20))} ${v}`));
+  console.log('');
+  return env;
+}
+
+async function selectRuntime(rl, detected) {
+  const choices = ['Claude Code', 'Antigravity', 'Both'];
+  const pick = await askChoice(rl, 'Install runtime:', choices, detected.includes('claude') ? 0 : 2);
+  if (pick === 'Claude Code') return ['claude'];
+  if (pick === 'Antigravity') return ['antigravity'];
+  return ['claude', 'antigravity'];
+}
+
+async function selectScope(rl) {
+  const pick = await askChoice(rl, 'Install scope:', ['Global', 'Local'], 0);
+  return pick.toLowerCase();
+}
+
+async function configureFeatures(rl) {
+  const features = await askMultiChoice(rl, 'Configure optional integrations:', [
+    'Jira integration',
+    'Slack notifications',
+    'GitHub integration',
+    'None',
+  ]);
+
+  const config = {};
+  const credGuidance = [];
+
+  if (features.includes('Jira integration')) {
+    config.jira = {
+      baseUrl: await ask(rl, '  Jira base URL', 'https://your-org.atlassian.net'),
+      projectKey: await ask(rl, '  Jira project key', 'ENG'),
+    };
+    credGuidance.push({
+      service: 'Jira / Confluence (Atlassian)',
+      envVar: 'JIRA_API_TOKEN',
+      url: 'https://id.atlassian.com/manage-profile/security/api-tokens',
+      instruction: 'Create token and export JIRA_API_TOKEN',
+    });
+  }
+
+  if (features.includes('Slack notifications')) {
+    config.slack = { channelId: await ask(rl, '  Slack channel ID', 'C01234ABCDE') };
+    credGuidance.push({
+      service: 'Slack',
+      envVar: 'SLACK_BOT_TOKEN',
+      url: 'https://api.slack.com/apps',
+      instruction: 'Create bot token and export SLACK_BOT_TOKEN',
+    });
+  }
+
+  if (features.includes('GitHub integration')) {
+    config.github = {
+      repo: await ask(rl, '  GitHub repo (owner/name)', ''),
+      reviewers: await ask(rl, '  Default reviewers', ''),
+    };
+    credGuidance.push({
+      service: 'GitHub',
+      envVar: 'GITHUB_TOKEN',
+      url: 'https://github.com/settings/tokens',
+      instruction: 'Create PAT and export GITHUB_TOKEN',
+    });
+  }
+
+  return { config, credGuidance };
+}
+
+async function install(runtimes, scope) {
+  const installer = require('../install');
+  if (!installer || typeof installer.install !== 'function') return;
+  for (const runtime of runtimes) {
+    await installer.install(runtime, scope);
+  }
+}
+
+function printNextSteps(runtimes, scope, credGuidance = []) {
+  console.log('');
+  console.log(c.bold(c.green('  Setup complete')));
+  console.log(`  Runtime: ${runtimes.join(', ')}`);
+  console.log(`  Scope: ${scope}`);
+  console.log('  Next: run /mindforge:health');
+
+  if (credGuidance.length > 0) {
+    console.log(c.bold('\n  Configure credentials:\n'));
+    credGuidance.forEach((g) => {
+      console.log(`  ${c.cyan(g.service)}`);
+      console.log(`    ${g.instruction} (${g.envVar})`);
+      console.log(c.dim(`    Docs: ${g.url}\n`));
+    });
+  }
+}
+
+function handleWizardError(err) {
+  console.error(c.red('\n  Setup encountered an issue:\n'));
+
+  const COMMON_ERRORS = {
+    ENOENT: {
+      message: 'A required file was not found.',
+      action: 'Run from project root and verify install artifacts exist.',
+    },
+    EACCES: {
+      message: 'Permission denied writing to target path.',
+      action: 'Adjust permissions or run with appropriate access.',
+    },
+    MODULE_NOT_FOUND: {
+      message: 'Installer module is missing.',
+      action: 'Reinstall package and retry.',
+    },
+    ERR_INVALID_ARG_TYPE: {
+      message: 'Unexpected argument type while running setup.',
+      action: 'Run non-interactive mode as fallback.',
+    },
+  };
+
+  const known = COMMON_ERRORS[err.code] || COMMON_ERRORS.ERR_INVALID_ARG_TYPE;
+  console.error(`  Problem: ${known.message}`);
+  console.error(`  Action:  ${known.action}`);
+  console.error(c.dim('\n  Fallback examples:'));
+  console.error(c.dim('  npx mindforge-cc --claude --local'));
+  console.error(c.dim('  npx mindforge-cc --antigravity --local'));
+  console.error(c.dim('  npx mindforge-cc --all --global\n'));
+}
+
+async function main() {
+  printBanner();
+
+  if (!IS_INTERACTIVE) {
+    const installer = require('../install');
+    if (installer && typeof installer.runCli === 'function') {
+      installer.runCli();
+    }
+    return;
+  }
+
+  const rl = createReadline();
+  try {
+    const env = await detectEnvironment();
+    const runtimes = await selectRuntime(rl, env.runtimes);
+    const scope = await selectScope(rl);
+    const { config, credGuidance } = await configureFeatures(rl);
+    rl.close();
+
+    await install(runtimes, scope);
+    await generator.writeIntegrationsConfig(config);
+    printNextSteps(runtimes, scope, credGuidance);
+  } catch (err) {
+    rl.close();
+    handleWizardError(err);
+    process.exit(1);
+  }
+}
+
+main();