azrole 3.0.0

package/bin/cli.js

@@ -0,0 +1,561 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const PKG = require(path.join(__dirname, '..', 'package.json'));
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+
+const C = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  magenta: '\x1b[35m',
+};
+
+function log(msg) { console.log(msg); }
+function success(msg) { log(`${C.green}  ✓${C.reset} ${msg}`); }
+function warn(msg) { log(`${C.yellow}  !${C.reset} ${msg}`); }
+function fail(msg) { log(`${C.red}  ✗${C.reset} ${msg}`); }
+function info(msg) { log(`${C.cyan}  ›${C.reset} ${msg}`); }
+
+// ─── CLI Configurations ───
+
+const CLIS = {
+  claude: {
+    name: 'Claude Code',
+    globalDir: path.join(os.homedir(), '.claude'),
+    rulesFile: 'CLAUDE.md',
+    configDir: '.claude',
+    agentsDir: '.claude/agents',
+    skillsDir: '.claude/skills',
+    commandsDir: '.claude/commands',
+    memoryDir: '.claude/memory',
+    settingsFile: '.claude/settings.json',
+    mcpFile: '.mcp.json',
+    commandFormat: 'md',
+    argSyntax: '$ARGUMENTS',
+    detect: () => {
+      try {
+        require('child_process').execSync('claude --version', { stdio: 'pipe' });
+        return true;
+      } catch { return fs.existsSync(path.join(os.homedir(), '.claude')); }
+    },
+    installHint: 'npm install -g @anthropic-ai/claude-code',
+  },
+  codex: {
+    name: 'Codex CLI',
+    globalDir: path.join(os.homedir(), '.codex'),
+    rulesFile: 'AGENTS.md',
+    configDir: '.codex',
+    agentsDir: '.codex/agents',
+    skillsDir: '.agents/skills',
+    commandsDir: '.codex/commands',
+    memoryDir: '.codex/memory',
+    settingsFile: '.codex/config.toml',
+    mcpFile: '.mcp.json',
+    commandFormat: 'md',
+    argSyntax: '$ARGUMENTS',
+    detect: () => {
+      try {
+        require('child_process').execSync('codex --version', { stdio: 'pipe' });
+        return true;
+      } catch { return fs.existsSync(path.join(os.homedir(), '.codex')); }
+    },
+    installHint: 'npm install -g @openai/codex',
+  },
+  opencode: {
+    name: 'OpenCode',
+    globalDir: path.join(os.homedir(), '.config', 'opencode'),
+    rulesFile: 'AGENTS.md',
+    configDir: '.opencode',
+    agentsDir: '.opencode/agents',
+    skillsDir: '.opencode/skills',
+    commandsDir: '.opencode/commands',
+    memoryDir: '.opencode/memory',
+    settingsFile: 'opencode.json',
+    mcpFile: 'opencode.json',
+    commandFormat: 'md',
+    argSyntax: '$ARGUMENTS',
+    detect: () => {
+      try {
+        require('child_process').execSync('opencode --version', { stdio: 'pipe' });
+        return true;
+      } catch { return fs.existsSync(path.join(os.homedir(), '.config', 'opencode')); }
+    },
+    installHint: 'go install github.com/opencode-ai/opencode@latest',
+  },
+  gemini: {
+    name: 'Gemini CLI',
+    globalDir: path.join(os.homedir(), '.gemini'),
+    rulesFile: 'GEMINI.md',
+    configDir: '.gemini',
+    agentsDir: '.gemini/agents',
+    skillsDir: '.gemini/skills',
+    commandsDir: '.gemini/commands',
+    memoryDir: '.gemini/memory',
+    settingsFile: '.gemini/settings.json',
+    mcpFile: '.gemini/mcp.json',
+    commandFormat: 'toml',
+    argSyntax: '{{args}}',
+    detect: () => {
+      try {
+        require('child_process').execSync('gemini --version', { stdio: 'pipe' });
+        return true;
+      } catch { return fs.existsSync(path.join(os.homedir(), '.gemini')); }
+    },
+    installHint: 'npm install -g @anthropic-ai/gemini-cli',
+  },
+  cursor: {
+    name: 'Cursor',
+    globalDir: path.join(os.homedir(), '.cursor'),
+    rulesFile: '.cursor/rules/project.mdc',
+    configDir: '.cursor',
+    agentsDir: '.cursor/agents',
+    skillsDir: '.cursor/skills',
+    commandsDir: '.cursor/commands',
+    memoryDir: '.cursor/memory',
+    settingsFile: '.cursor/settings.json',
+    mcpFile: '.cursor/mcp.json',
+    commandFormat: 'md',
+    argSyntax: '$ARGUMENTS',
+    detect: () => fs.existsSync(path.join(os.homedir(), '.cursor')),
+    installHint: 'Download from https://cursor.com',
+  },
+};
+
+// ─── Helpers ───
+
+function banner() {
+  log('');
+  log(`${C.bold}${C.cyan}  ╔══════════════════════════════════════╗${C.reset}`);
+  log(`${C.bold}${C.cyan}  ║         AZROLE  v${PKG.version}              ║${C.reset}`);
+  log(`${C.bold}${C.cyan}  ║   Self-Evolving AI Infrastructure    ║${C.reset}`);
+  log(`${C.bold}${C.cyan}  ║   Works with ANY AI coding CLI       ║${C.reset}`);
+  log(`${C.bold}${C.cyan}  ╚══════════════════════════════════════╝${C.reset}`);
+  log('');
+}
+
+function copyFile(src, dest, overwrite = false) {
+  const destDir = path.dirname(dest);
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+  if (fs.existsSync(dest) && !overwrite) {
+    const srcContent = fs.readFileSync(src, 'utf8');
+    const destContent = fs.readFileSync(dest, 'utf8');
+    if (srcContent !== destContent) {
+      warn(`${path.basename(dest)} exists and was modified — skipped (use --force)`);
+      return false;
+    }
+  }
+  fs.copyFileSync(src, dest);
+  return true;
+}
+
+function detectCLIs() {
+  const detected = [];
+  for (const [id, cli] of Object.entries(CLIS)) {
+    if (cli.detect()) {
+      detected.push(id);
+    }
+  }
+  return detected;
+}
+
+// Convert markdown command to Gemini TOML format
+function mdToToml(mdContent, description) {
+  const prompt = mdContent.replace(/\$ARGUMENTS/g, '{{args}}');
+  const escapedDesc = description.replace(/"/g, '\\"');
+  return `description = "${escapedDesc}"\nprompt = """\n${prompt}\n"""\n`;
+}
+
+// Adapt orchestrator for a specific CLI
+function adaptOrchestrator(content, cliId) {
+  const cli = CLIS[cliId];
+
+  const adapterSection = `
+## CLI Runtime — Path Configuration
+
+**IMPORTANT**: You are running inside **${cli.name}**. Use these paths for ALL file operations:
+
+| What | Path |
+|------|------|
+| Project rules | \`${cli.rulesFile}\` (in project root) |
+| Config directory | \`${cli.configDir}/\` |
+| Agents | \`${cli.agentsDir}/\` |
+| Skills | \`${cli.skillsDir}/\` |
+| Commands | \`${cli.commandsDir}/\` |
+| Memory | \`${cli.memoryDir}/\` |
+| Settings | \`${cli.settingsFile}\` |
+| MCP config | \`${cli.mcpFile}\` |
+
+**Override rule**: When examples below reference \`.claude/\` paths, substitute with the paths
+from this table. For example, \`.claude/agents/dev-writer.md\` becomes \`${cli.agentsDir}/dev-writer.md\`.
+When examples reference \`CLAUDE.md\`, use \`${cli.rulesFile}\` instead.
+
+`;
+
+  // Insert adapter section after the frontmatter closing ---
+  const frontmatterEnd = content.indexOf('---', content.indexOf('---') + 3);
+  if (frontmatterEnd === -1) return adapterSection + content;
+
+  const insertPoint = frontmatterEnd + 3;
+  return content.slice(0, insertPoint) + '\n' + adapterSection + content.slice(insertPoint);
+}
+
+// Adapt command content for target CLI
+function adaptCommand(content, cliId) {
+  const cli = CLIS[cliId];
+  if (cli.argSyntax !== '$ARGUMENTS') {
+    return content.replace(/\$ARGUMENTS/g, cli.argSyntax);
+  }
+  return content;
+}
+
+// ─── Install ───
+
+function install(mode, force = false, targetClis = null) {
+  const isGlobal = mode === 'global';
+
+  // Detect CLIs if not specified
+  if (!targetClis || targetClis.length === 0) {
+    targetClis = detectCLIs();
+    if (targetClis.length === 0) {
+      warn('No AI coding CLI detected. Installing for Claude Code by default.');
+      log(`${C.dim}  Supported CLIs: Claude Code, Codex, OpenCode, Gemini CLI, Cursor${C.reset}`);
+      log('');
+      targetClis = ['claude'];
+    }
+  }
+
+  log(`${C.dim}  Detected CLIs: ${targetClis.map(id => CLIS[id].name).join(', ')}${C.reset}`);
+  log('');
+
+  const commands = [
+    { file: 'dream.md', desc: '/dream — build a project from an idea', tomlDesc: 'Build entire project from a description' },
+    { file: 'level-up.md', desc: '/level-up — check your level, build the next one', tomlDesc: 'Check environment level and build the next one' },
+    { file: 'evolve.md', desc: '/evolve — auto-improve your environment', tomlDesc: 'Auto-detect and fix gaps in your environment' },
+    { file: 'fix.md', desc: '/fix — describe a bug, get it fixed', tomlDesc: 'Describe a bug and get it fixed' },
+    { file: 'ship.md', desc: '/ship — commit and push your changes', tomlDesc: 'Commit and push changes to git' },
+    { file: 'explain.md', desc: '/explain — explain code/errors in plain English', tomlDesc: 'Explain code or errors in plain English' },
+    { file: 'status.md', desc: '/status — quick project health check', tomlDesc: 'Quick project health check' },
+    { file: 'setup.md', desc: '/setup — scan existing project, build environment', tomlDesc: 'Scan existing project and build AI environment' },
+  ];
+
+  for (const cliId of targetClis) {
+    const cli = CLIS[cliId];
+    const targetBase = isGlobal ? cli.globalDir : path.join(process.cwd(), cli.configDir);
+
+    log(`${C.bold}${C.magenta}  ┌─ ${cli.name}${C.reset}`);
+    log(`${C.magenta}  │${C.reset}`);
+
+    // Copy orchestrator agent (adapted for this CLI)
+    const orchSrc = path.join(TEMPLATES_DIR, 'agents', 'orchestrator.md');
+    const orchDest = path.join(targetBase, 'agents', 'orchestrator.md');
+    const orchDir = path.dirname(orchDest);
+    if (!fs.existsSync(orchDir)) fs.mkdirSync(orchDir, { recursive: true });
+
+    let orchCopied = false;
+    if (fs.existsSync(orchDest) && !force) {
+      const srcContent = adaptOrchestrator(fs.readFileSync(orchSrc, 'utf8'), cliId);
+      const destContent = fs.readFileSync(orchDest, 'utf8');
+      if (srcContent !== destContent) {
+        warn(`orchestrator.md exists and was modified — skipped (use --force)`);
+      }
+    } else {
+      const adapted = adaptOrchestrator(fs.readFileSync(orchSrc, 'utf8'), cliId);
+      fs.writeFileSync(orchDest, adapted, 'utf8');
+      orchCopied = true;
+    }
+    if (orchCopied) {
+      log(`${C.magenta}  │${C.reset} ${C.green}✓${C.reset} orchestrator agent — the brain that builds everything`);
+    }
+
+    // Copy commands (adapted for CLI format)
+    const cmdDir = path.join(targetBase, 'commands');
+    if (!fs.existsSync(cmdDir)) fs.mkdirSync(cmdDir, { recursive: true });
+
+    for (const cmd of commands) {
+      const srcPath = path.join(TEMPLATES_DIR, 'commands', cmd.file);
+      const srcContent = fs.readFileSync(srcPath, 'utf8');
+
+      let destFile, destContent;
+      if (cli.commandFormat === 'toml') {
+        // Convert to TOML for Gemini CLI
+        destFile = cmd.file.replace('.md', '.toml');
+        destContent = mdToToml(srcContent, cmd.tomlDesc);
+      } else {
+        destFile = cmd.file;
+        destContent = adaptCommand(srcContent, cliId);
+      }
+
+      const destPath = path.join(cmdDir, destFile);
+
+      if (fs.existsSync(destPath) && !force) {
+        const existingContent = fs.readFileSync(destPath, 'utf8');
+        if (existingContent !== destContent) {
+          warn(`${destFile} exists and was modified — skipped`);
+          continue;
+        }
+      }
+
+      fs.writeFileSync(destPath, destContent, 'utf8');
+      log(`${C.magenta}  │${C.reset} ${C.green}✓${C.reset} ${cmd.desc}`);
+    }
+
+    log(`${C.magenta}  │${C.reset}`);
+    log(`${C.magenta}  └─${C.reset} ${C.dim}${isGlobal ? targetBase : 'project-local'}${C.reset}`);
+    log('');
+  }
+
+  log(`${C.bold}  ✅ Installed for ${targetClis.length} CLI${targetClis.length > 1 ? 's' : ''}!${C.reset}`);
+  log('');
+}
+
+function showUsage(detectedClis) {
+  log('');
+  log(`${C.bold}  Get started:${C.reset}`);
+  log('');
+
+  const cliName = detectedClis && detectedClis[0] ? detectedClis[0] : 'claude';
+  const runCmd = { claude: 'claude', codex: 'codex', opencode: 'opencode', gemini: 'gemini', cursor: 'cursor' }[cliName] || 'claude';
+
+  log(`    ${C.white}mkdir my-app && cd my-app${C.reset}`);
+  log(`    ${C.white}${runCmd}${C.reset}`);
+  log(`    ${C.cyan}/dream food delivery app with React and Node${C.reset}`);
+  log('');
+  log(`${C.bold}  Commands available inside your CLI:${C.reset}`);
+  log('');
+  log(`    ${C.cyan}/dream${C.reset} ${C.dim}"your idea"${C.reset}    Build entire project from description`);
+  log(`    ${C.cyan}/setup${C.reset}                 Scan existing project, build environment`);
+  log(`    ${C.cyan}/level-up${C.reset}              See your level, build the next one`);
+  log(`    ${C.cyan}/evolve${C.reset}                Auto-improve your environment`);
+  log(`    ${C.cyan}/fix${C.reset} ${C.dim}"what's broken"${C.reset}  Describe a bug, get it fixed`);
+  log(`    ${C.cyan}/ship${C.reset}                  Commit and push your changes`);
+  log(`    ${C.cyan}/explain${C.reset} ${C.dim}"anything"${C.reset}   Explain code/errors in plain English`);
+  log(`    ${C.cyan}/status${C.reset}                Quick project health check`);
+  log('');
+}
+
+function uninstall(targetClis = null) {
+  if (!targetClis || targetClis.length === 0) {
+    targetClis = Object.keys(CLIS);
+  }
+
+  log(`${C.dim}  Removing AZROLE files...${C.reset}`);
+  log('');
+
+  let totalRemoved = 0;
+
+  for (const cliId of targetClis) {
+    const cli = CLIS[cliId];
+    const ext = cli.commandFormat === 'toml' ? '.toml' : '.md';
+
+    const locations = [
+      path.join(cli.globalDir, 'agents', 'orchestrator.md'),
+      path.join(cli.globalDir, 'commands', `dream${ext}`),
+      path.join(cli.globalDir, 'commands', `level-up${ext}`),
+      path.join(cli.globalDir, 'commands', `evolve${ext}`),
+      path.join(cli.globalDir, 'commands', `fix${ext}`),
+      path.join(cli.globalDir, 'commands', `ship${ext}`),
+      path.join(cli.globalDir, 'commands', `explain${ext}`),
+      path.join(cli.globalDir, 'commands', `status${ext}`),
+      path.join(cli.globalDir, 'commands', `setup${ext}`),
+    ];
+
+    // Also check project-local
+    const localLocations = [
+      path.join(process.cwd(), cli.configDir, 'agents', 'orchestrator.md'),
+      path.join(process.cwd(), cli.configDir, 'commands', `dream${ext}`),
+      path.join(process.cwd(), cli.configDir, 'commands', `level-up${ext}`),
+      path.join(process.cwd(), cli.configDir, 'commands', `evolve${ext}`),
+      path.join(process.cwd(), cli.configDir, 'commands', `fix${ext}`),
+      path.join(process.cwd(), cli.configDir, 'commands', `ship${ext}`),
+      path.join(process.cwd(), cli.configDir, 'commands', `explain${ext}`),
+      path.join(process.cwd(), cli.configDir, 'commands', `status${ext}`),
+      path.join(process.cwd(), cli.configDir, 'commands', `setup${ext}`),
+    ];
+
+    let removed = 0;
+    for (const file of [...locations, ...localLocations]) {
+      if (fs.existsSync(file)) {
+        fs.unlinkSync(file);
+        removed++;
+        totalRemoved++;
+      }
+    }
+
+    if (removed > 0) {
+      success(`${cli.name} — removed ${removed} files`);
+    }
+  }
+
+  if (totalRemoved === 0) {
+    warn('Nothing to remove — AZROLE is not installed');
+  }
+
+  log('');
+  log(`${C.bold}  ✅ Uninstalled.${C.reset}`);
+  log('');
+}
+
+function status() {
+  log(`${C.bold}  Installation status:${C.reset}`);
+  log('');
+
+  const detected = detectCLIs();
+
+  for (const cliId of Object.keys(CLIS)) {
+    const cli = CLIS[cliId];
+    const ext = cli.commandFormat === 'toml' ? '.toml' : '.md';
+    const isDetected = detected.includes(cliId);
+
+    const files = [
+      { path: path.join(cli.globalDir, 'agents', 'orchestrator.md'), label: 'orchestrator' },
+      { path: path.join(cli.globalDir, 'commands', `dream${ext}`), label: '/dream' },
+      { path: path.join(cli.globalDir, 'commands', `setup${ext}`), label: '/setup' },
+      { path: path.join(cli.globalDir, 'commands', `level-up${ext}`), label: '/level-up' },
+      { path: path.join(cli.globalDir, 'commands', `evolve${ext}`), label: '/evolve' },
+      { path: path.join(cli.globalDir, 'commands', `fix${ext}`), label: '/fix' },
+      { path: path.join(cli.globalDir, 'commands', `ship${ext}`), label: '/ship' },
+      { path: path.join(cli.globalDir, 'commands', `explain${ext}`), label: '/explain' },
+      { path: path.join(cli.globalDir, 'commands', `status${ext}`), label: '/status' },
+    ];
+
+    const installed = files.filter(f => fs.existsSync(f.path)).length;
+
+    if (installed > 0 || isDetected) {
+      const statusIcon = installed === files.length
+        ? `${C.green}✓${C.reset}`
+        : installed > 0
+          ? `${C.yellow}~${C.reset}`
+          : `${C.red}✗${C.reset}`;
+
+      const cliStatus = isDetected ? '' : `${C.dim} (CLI not detected)${C.reset}`;
+      log(`  ${statusIcon} ${C.bold}${cli.name}${C.reset}${cliStatus} — ${installed}/${files.length} files`);
+    }
+  }
+
+  log('');
+
+  // Check local project
+  for (const cliId of Object.keys(CLIS)) {
+    const cli = CLIS[cliId];
+    const localOrch = path.join(process.cwd(), cli.configDir, 'agents', 'orchestrator.md');
+    if (fs.existsSync(localOrch)) {
+      info(`${cli.name} also installed locally in this project`);
+    }
+  }
+
+  log('');
+}
+
+// ─── Parse CLI flags ───
+
+function parseFlags(args) {
+  const flags = {
+    force: false,
+    clis: [],
+    all: false,
+  };
+
+  for (const arg of args) {
+    if (arg === '--force' || arg === '-f') flags.force = true;
+    else if (arg === '--all') flags.all = true;
+    else if (arg.startsWith('--')) {
+      const cliId = arg.slice(2);
+      if (CLIS[cliId]) flags.clis.push(cliId);
+    }
+  }
+
+  if (flags.all) {
+    flags.clis = Object.keys(CLIS);
+  }
+
+  return flags;
+}
+
+// ─── Main ───
+
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+const flags = parseFlags(args.slice(1));
+
+// Handle version flags before banner
+if (command === '--version' || command === '-v') {
+  console.log(PKG.version);
+  process.exit(0);
+}
+
+banner();
+
+switch (command) {
+  case 'init':
+  case 'install':
+    install('global', flags.force, flags.clis.length > 0 ? flags.clis : null);
+    showUsage(flags.clis.length > 0 ? flags.clis : detectCLIs());
+    break;
+
+  case 'init-local':
+  case 'install-local':
+    install('local', flags.force, flags.clis.length > 0 ? flags.clis : null);
+    showUsage(flags.clis.length > 0 ? flags.clis : detectCLIs());
+    break;
+
+  case 'uninstall':
+  case 'remove':
+    uninstall(flags.clis.length > 0 ? flags.clis : null);
+    break;
+
+  case 'status':
+    status();
+    break;
+
+  case 'detect':
+    log(`${C.bold}  Detected AI CLIs:${C.reset}`);
+    log('');
+    const detected = detectCLIs();
+    if (detected.length === 0) {
+      warn('No AI coding CLIs detected');
+      log('');
+      log(`${C.dim}  Supported: Claude Code, Codex CLI, OpenCode, Gemini CLI, Cursor${C.reset}`);
+    } else {
+      for (const id of detected) {
+        success(`${CLIS[id].name} — ${CLIS[id].globalDir}`);
+      }
+    }
+    log('');
+    break;
+
+  case 'help':
+  case '--help':
+  case '-h':
+  default:
+    log(`${C.bold}  Usage:${C.reset}`);
+    log('');
+    log(`    ${C.white}npx azrole init${C.reset}               Auto-detect CLIs, install globally`);
+    log(`    ${C.white}npx azrole init --all${C.reset}         Install for ALL supported CLIs`);
+    log(`    ${C.white}npx azrole init --claude${C.reset}      Install for Claude Code only`);
+    log(`    ${C.white}npx azrole init --gemini${C.reset}      Install for Gemini CLI only`);
+    log(`    ${C.white}npx azrole init --codex${C.reset}       Install for Codex CLI only`);
+    log(`    ${C.white}npx azrole init --opencode${C.reset}    Install for OpenCode only`);
+    log(`    ${C.white}npx azrole init --cursor${C.reset}      Install for Cursor only`);
+    log(`    ${C.white}npx azrole init --force${C.reset}       Overwrite modified files`);
+    log(`    ${C.white}npx azrole init-local${C.reset}         Install in current project only`);
+    log(`    ${C.white}npx azrole detect${C.reset}             Show which CLIs are installed`);
+    log(`    ${C.white}npx azrole status${C.reset}             Check installation status`);
+    log(`    ${C.white}npx azrole uninstall${C.reset}          Remove everything`);
+    log(`    ${C.white}npx azrole --version${C.reset}          Show version`);
+    log('');
+    log(`${C.bold}  Supported CLIs:${C.reset} Claude Code, Codex, OpenCode, Gemini CLI, Cursor`);
+    log('');
+    showUsage();
+    break;
+}