aigent-team 0.1.0

package/dist/cli.js

@@ -0,0 +1,576 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  PLATFORMS,
+  assembleReference,
+  assembleSkillIndex,
+  configExists,
+  loadAgents,
+  loadConfig
+} from "./chunk-N3RYHWTR.js";
+
+// bin/cli.ts
+import { Command } from "commander";
+
+// src/cli/init.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+import inquirer from "inquirer";
+import chalk2 from "chalk";
+
+// src/detectors/platform-detector.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { resolve } from "path";
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPlatforms(cwd = process.cwd()) {
+  const results = [];
+  const claudeDir = existsSync(resolve(cwd, ".claude"));
+  const claudeCli = commandExists("claude");
+  results.push({
+    platform: "claude-code",
+    detected: claudeDir || claudeCli,
+    reason: claudeDir ? ".claude/ directory found" : claudeCli ? "claude CLI found" : "not detected"
+  });
+  const cursorDir = existsSync(resolve(cwd, ".cursor"));
+  const cursorCli = commandExists("cursor");
+  results.push({
+    platform: "cursor",
+    detected: cursorDir || cursorCli,
+    reason: cursorDir ? ".cursor/ directory found" : cursorCli ? "cursor CLI found" : "not detected"
+  });
+  const codexDir = existsSync(resolve(cwd, ".codex"));
+  const codexCli = commandExists("codex");
+  results.push({
+    platform: "codex",
+    detected: codexDir || codexCli,
+    reason: codexDir ? ".codex/ directory found" : codexCli ? "codex CLI found" : "not detected"
+  });
+  const antigravityDir = existsSync(resolve(cwd, ".agents"));
+  const geminiMd = existsSync(resolve(cwd, "GEMINI.md"));
+  const antigravityCli = commandExists("antigravity");
+  results.push({
+    platform: "antigravity",
+    detected: antigravityDir || geminiMd || antigravityCli,
+    reason: antigravityDir ? ".agents/ directory found" : geminiMd ? "GEMINI.md found" : antigravityCli ? "antigravity CLI found" : "not detected"
+  });
+  return results;
+}
+
+// src/cli/generate.ts
+import { writeFileSync, mkdirSync, existsSync as existsSync2, readFileSync } from "fs";
+import { resolve as resolve2, dirname } from "path";
+import chalk from "chalk";
+
+// src/compilers/base.compiler.ts
+var BaseCompiler = class {
+  /**
+   * Compile reference files for an agent into a given directory.
+   * Returns CompiledOutput[] for each reference file.
+   */
+  compileReferences(agent, baseDir, extension = ".md") {
+    if (!agent.references?.length) return [];
+    return agent.references.map((ref) => ({
+      filePath: `${baseDir}/${ref.id}${extension}`,
+      content: assembleReference(ref) + "\n",
+      overwriteStrategy: "replace"
+    }));
+  }
+  formatFrontmatter(data) {
+    const lines = ["---"];
+    for (const [key, value] of Object.entries(data)) {
+      if (value === void 0 || value === null) continue;
+      if (Array.isArray(value)) {
+        lines.push(`${key}:`);
+        for (const item of value) {
+          lines.push(`  - ${item}`);
+        }
+      } else {
+        lines.push(`${key}: ${JSON.stringify(value)}`);
+      }
+    }
+    lines.push("---");
+    return lines.join("\n");
+  }
+};
+
+// src/compilers/claude-code.compiler.ts
+var ClaudeCodeCompiler = class extends BaseCompiler {
+  platform = "claude-code";
+  compile(agents, config) {
+    const outputs = [];
+    for (const agent of agents) {
+      const frontmatter = this.formatFrontmatter({
+        name: agent.name,
+        description: agent.description,
+        tools: agent.tools.allowed
+      });
+      const body = assembleSkillIndex(agent);
+      const content = `${frontmatter}
+
+${body}
+`;
+      outputs.push({
+        filePath: `.claude/agents/${agent.id}-agent.md`,
+        content,
+        overwriteStrategy: "replace"
+      });
+      const refs = this.compileReferences(
+        agent,
+        `.claude/agents/${agent.id}-agent/references`
+      );
+      outputs.push(...refs);
+    }
+    const agentList = agents.map((a) => `- **${a.name}** (\`${a.id}\`): ${a.description.trim().split("\n")[0]}`).join("\n");
+    const claudeMd = [
+      `# CLAUDE.md`,
+      ``,
+      `This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.`,
+      ``,
+      `## Agent Team`,
+      ``,
+      `This project uses aigent-team. The following specialized agents are available:`,
+      ``,
+      agentList,
+      ``,
+      `Use the appropriate agent for your task by invoking it from the .claude/agents/ directory.`,
+      ``
+    ].join("\n");
+    outputs.push({
+      filePath: "CLAUDE.md",
+      content: claudeMd,
+      overwriteStrategy: "skip-if-exists"
+    });
+    return outputs;
+  }
+  validate(outputs) {
+    const errors = [];
+    const warnings = [];
+    for (const output of outputs) {
+      if (output.filePath.includes("/references/")) continue;
+      const lineCount = output.content.split("\n").length;
+      if (lineCount > 300) {
+        warnings.push(
+          `${output.filePath}: ${lineCount} lines (recommended max 300 for Claude Code)`
+        );
+      }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  }
+};
+
+// src/compilers/cursor.compiler.ts
+var CursorCompiler = class extends BaseCompiler {
+  platform = "cursor";
+  compile(agents, config) {
+    const outputs = [];
+    for (const agent of agents) {
+      const globs = agent.globs?.length ? agent.globs.join(", ") : void 0;
+      const frontmatterData = {
+        description: agent.description.trim().split("\n")[0],
+        alwaysApply: !globs
+      };
+      if (globs) {
+        frontmatterData.globs = globs;
+      }
+      const frontmatter = this.formatFrontmatter(frontmatterData);
+      const body = assembleSkillIndex(agent);
+      const content = `${frontmatter}
+
+${body}
+`;
+      outputs.push({
+        filePath: `.cursor/rules/${agent.id}-agent.mdc`,
+        content,
+        overwriteStrategy: "replace"
+      });
+      if (agent.references?.length) {
+        for (const ref of agent.references) {
+          const refFrontmatter = this.formatFrontmatter({
+            description: `${agent.name} reference: ${ref.title}`,
+            alwaysApply: false,
+            globs: globs || void 0
+          });
+          outputs.push({
+            filePath: `.cursor/rules/${agent.id}-refs/${ref.id}.mdc`,
+            content: `${refFrontmatter}
+
+${ref.content}
+`,
+            overwriteStrategy: "replace"
+          });
+        }
+      }
+    }
+    const sharedKnowledge = agents.flatMap((a) => a.sharedKnowledge).filter((v, i, arr) => arr.indexOf(v) === i && v).join("\n\n---\n\n");
+    if (sharedKnowledge) {
+      const frontmatter = this.formatFrontmatter({
+        description: "Shared project conventions and knowledge for all team agents",
+        alwaysApply: true
+      });
+      outputs.push({
+        filePath: ".cursor/rules/shared-conventions.mdc",
+        content: `${frontmatter}
+
+${sharedKnowledge}
+`,
+        overwriteStrategy: "replace"
+      });
+    }
+    return outputs;
+  }
+  validate(outputs) {
+    const errors = [];
+    const warnings = [];
+    for (const output of outputs) {
+      if (!output.filePath.endsWith(".mdc")) {
+        errors.push(`${output.filePath}: Cursor rules must have .mdc extension`);
+      }
+      if (!output.content.startsWith("---")) {
+        errors.push(`${output.filePath}: Missing YAML frontmatter`);
+      }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  }
+};
+
+// src/compilers/codex.compiler.ts
+var CodexCompiler = class extends BaseCompiler {
+  platform = "codex";
+  compile(agents, config) {
+    const outputs = [];
+    const sections = agents.map((agent) => {
+      const body = assembleSkillIndex(agent);
+      return `## ${agent.name} (${agent.id})
+
+${body}`;
+    });
+    const sharedKnowledge = agents.flatMap((a) => a.sharedKnowledge).filter((v, i, arr) => arr.indexOf(v) === i && v).join("\n\n");
+    const agentsMd = [
+      `# Project Agents`,
+      ``,
+      `This project uses specialized AI agents for different team roles.`,
+      ``,
+      ...sections,
+      ``,
+      sharedKnowledge ? `## Shared Knowledge
+
+${sharedKnowledge}` : ""
+    ].filter(Boolean).join("\n\n");
+    outputs.push({
+      filePath: "AGENTS.md",
+      content: agentsMd + "\n",
+      overwriteStrategy: "replace"
+    });
+    for (const agent of agents) {
+      const frontmatter = this.formatFrontmatter({
+        nickname_candidates: [agent.id, agent.role],
+        model: "inherit"
+      });
+      const body = assembleSkillIndex(agent);
+      const content = `${frontmatter}
+
+${body}
+`;
+      outputs.push({
+        filePath: `.codex/agents/${agent.id}-agent.md`,
+        content,
+        overwriteStrategy: "replace"
+      });
+      const refs = this.compileReferences(
+        agent,
+        `.codex/agents/${agent.id}-agent/references`
+      );
+      outputs.push(...refs);
+    }
+    return outputs;
+  }
+  validate(outputs) {
+    const errors = [];
+    const warnings = [];
+    const agentsMd = outputs.find((o) => o.filePath === "AGENTS.md");
+    if (!agentsMd) {
+      errors.push("AGENTS.md is missing from compiled output");
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  }
+};
+
+// src/compilers/antigravity.compiler.ts
+var TOOL_MAP = {
+  Read: "read_file",
+  Write: "str_replace_editor",
+  Edit: "str_replace_editor",
+  Bash: "bash",
+  Grep: "search",
+  Glob: "list_dir"
+};
+var AntigravityCompiler = class extends BaseCompiler {
+  platform = "antigravity";
+  compile(agents, config) {
+    const outputs = [];
+    const agentList = agents.map((a) => `- **${a.name}** (\`${a.id}\`): ${a.description.trim().split("\n")[0]}`).join("\n");
+    const geminiMd = [
+      `# Antigravity Configuration`,
+      ``,
+      `## Available Agents`,
+      ``,
+      agentList,
+      ``,
+      `Agents are defined as skills in the \`.agents/skills/\` directory.`,
+      `Use the appropriate agent skill for team-specific tasks.`,
+      ``
+    ].join("\n");
+    outputs.push({
+      filePath: "GEMINI.md",
+      content: geminiMd,
+      overwriteStrategy: "replace"
+    });
+    for (const agent of agents) {
+      const allowedTools = agent.tools.allowed.map((t) => TOOL_MAP[t] || t.toLowerCase()).filter((v, i, arr) => arr.indexOf(v) === i);
+      const frontmatter = this.formatFrontmatter({
+        name: `${agent.id}-agent`,
+        description: agent.description.trim().split("\n")[0],
+        "allowed-tools": allowedTools
+      });
+      const body = assembleSkillIndex(agent);
+      const content = `${frontmatter}
+
+${body}
+`;
+      outputs.push({
+        filePath: `.agents/skills/${agent.id}-agent/SKILL.md`,
+        content,
+        overwriteStrategy: "replace"
+      });
+      const refs = this.compileReferences(
+        agent,
+        `.agents/skills/${agent.id}-agent/references`
+      );
+      outputs.push(...refs);
+    }
+    return outputs;
+  }
+  validate(outputs) {
+    const errors = [];
+    const warnings = [];
+    for (const output of outputs) {
+      if (output.filePath.includes("SKILL.md")) {
+        const dirName = output.filePath.split("/").slice(-2, -1)[0];
+        const nameMatch = output.content.match(/^name:\s*"?(.+?)"?\s*$/m);
+        if (nameMatch && nameMatch[1] !== dirName) {
+          errors.push(
+            `${output.filePath}: SKILL.md name "${nameMatch[1]}" does not match directory "${dirName}"`
+          );
+        }
+      }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  }
+};
+
+// src/compilers/index.ts
+var compilers = {
+  "claude-code": () => new ClaudeCodeCompiler(),
+  cursor: () => new CursorCompiler(),
+  codex: () => new CodexCompiler(),
+  antigravity: () => new AntigravityCompiler()
+};
+function getAllCompilers(platforms) {
+  return platforms.map((p) => compilers[p]());
+}
+
+// src/cli/generate.ts
+function writeOutput(output, cwd) {
+  const fullPath = resolve2(cwd, output.filePath);
+  const dir = dirname(fullPath);
+  if (output.overwriteStrategy === "skip-if-exists" && existsSync2(fullPath)) {
+    return false;
+  }
+  if (output.overwriteStrategy === "merge" && existsSync2(fullPath)) {
+    const existing = readFileSync(fullPath, "utf-8");
+    if (!existing.includes("## Agent Team")) {
+      writeFileSync(fullPath, existing + "\n" + output.content);
+      return true;
+    }
+    return false;
+  }
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(fullPath, output.content);
+  return true;
+}
+async function runGenerate(cwd = process.cwd(), options = {}) {
+  const config = await loadConfig(cwd);
+  const agents = loadAgents(config, cwd);
+  const platforms = options.platform ? [options.platform] : config.platforms;
+  const compilers2 = getAllCompilers(platforms);
+  let totalFiles = 0;
+  let totalWarnings = 0;
+  for (const compiler of compilers2) {
+    const outputs = compiler.compile(agents, config);
+    const validation = compiler.validate(outputs);
+    if (!validation.valid) {
+      console.log(chalk.red(`
+\u2717 ${compiler.platform} validation errors:`));
+      for (const error of validation.errors) {
+        console.log(chalk.red(`  - ${error}`));
+      }
+      continue;
+    }
+    for (const warning of validation.warnings) {
+      console.log(chalk.yellow(`  \u26A0 ${warning}`));
+      totalWarnings++;
+    }
+    let written = 0;
+    for (const output of outputs) {
+      if (writeOutput(output, cwd)) {
+        written++;
+        console.log(chalk.dim(`  ${output.filePath}`));
+      }
+    }
+    console.log(chalk.green(`\u2713 ${compiler.platform}: ${written} file(s) generated`));
+    totalFiles += written;
+  }
+  console.log(chalk.bold(`
+Total: ${totalFiles} file(s) generated`));
+  if (totalWarnings > 0) {
+    console.log(chalk.yellow(`${totalWarnings} warning(s)`));
+  }
+}
+
+// src/cli/init.ts
+async function runInit(cwd = process.cwd()) {
+  console.log(chalk2.bold("\n\u{1F916} aigent-team init\n"));
+  if (configExists(cwd)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "aigent-team.config.json already exists. Overwrite?",
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log(chalk2.yellow("Aborted."));
+      return;
+    }
+  }
+  console.log(chalk2.dim("Detecting installed AI tools..."));
+  const detections = detectPlatforms(cwd);
+  const detectedPlatforms = detections.filter((d) => d.detected);
+  if (detectedPlatforms.length > 0) {
+    console.log(chalk2.green(`Found: ${detectedPlatforms.map((d) => d.platform).join(", ")}`));
+  } else {
+    console.log(chalk2.dim("No AI tools detected. You can still select platforms manually."));
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      default: cwd.split("/").pop()
+    },
+    {
+      type: "checkbox",
+      name: "platforms",
+      message: "Target platforms:",
+      choices: PLATFORMS.map((p) => ({
+        name: p,
+        checked: detections.find((d) => d.platform === p)?.detected ?? false
+      })),
+      validate: (input) => input.length > 0 || "Select at least one platform"
+    },
+    {
+      type: "checkbox",
+      name: "teams",
+      message: "Team agents to enable:",
+      choices: [
+        { name: "Lead (Tech Lead / Orchestrator)", value: "lead", checked: true },
+        { name: "BA (Business Analyst)", value: "ba", checked: true },
+        { name: "FE (Frontend)", value: "fe", checked: true },
+        { name: "BE (Backend)", value: "be", checked: true },
+        { name: "QA (Testing)", value: "qa", checked: true },
+        { name: "DevOps (Infrastructure)", value: "devops", checked: true }
+      ],
+      validate: (input) => input.length > 0 || "Select at least one team"
+    }
+  ]);
+  const config = {
+    projectName: answers.projectName,
+    platforms: answers.platforms,
+    teams: answers.teams
+  };
+  const configPath = resolve3(cwd, "aigent-team.config.json");
+  writeFileSync2(configPath, JSON.stringify(config, null, 2) + "\n");
+  console.log(chalk2.green(`
+\u2713 Created ${configPath}`));
+  console.log(chalk2.dim("\nGenerating platform configs..."));
+  await runGenerate(cwd);
+  console.log(chalk2.bold.green("\n\u2705 aigent-team initialized successfully!\n"));
+  console.log(chalk2.dim("Next steps:"));
+  console.log(chalk2.dim("  - Edit aigent-team.config.json to customize agents"));
+  console.log(chalk2.dim("  - Run `aigent-team generate` after making changes"));
+  console.log(chalk2.dim("  - Add .aigent-team/teams/<role>/ for local overrides\n"));
+}
+
+// src/cli/validate.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+import chalk3 from "chalk";
+async function runValidate(cwd = process.cwd()) {
+  console.log(chalk3.bold("\n\u{1F50D} Validating aigent-team configs...\n"));
+  const config = await loadConfig(cwd);
+  const agents = loadAgents(config, cwd);
+  const compilers2 = getAllCompilers(config.platforms);
+  let hasErrors = false;
+  for (const compiler of compilers2) {
+    const outputs = compiler.compile(agents, config);
+    const validation = compiler.validate(outputs);
+    if (validation.valid && validation.warnings.length === 0) {
+      console.log(chalk3.green(`\u2713 ${compiler.platform}: OK`));
+    } else {
+      for (const error of validation.errors) {
+        console.log(chalk3.red(`\u2717 ${compiler.platform}: ${error}`));
+        hasErrors = true;
+      }
+      for (const warning of validation.warnings) {
+        console.log(chalk3.yellow(`\u26A0 ${compiler.platform}: ${warning}`));
+      }
+    }
+    for (const output of outputs) {
+      const fullPath = resolve4(cwd, output.filePath);
+      if (!existsSync3(fullPath)) {
+        console.log(chalk3.yellow(`  \u26A0 ${output.filePath} not found on disk (run \`aigent-team generate\`)`));
+      }
+    }
+  }
+  if (hasErrors) {
+    console.log(chalk3.red("\n\u2717 Validation failed\n"));
+    process.exit(1);
+  } else {
+    console.log(chalk3.green("\n\u2705 All validations passed\n"));
+  }
+}
+
+// bin/cli.ts
+var program = new Command();
+program.name("aigent-team").description("Cross-platform AI agent team plugin for Claude Code, Cursor, Codex, and Antigravity").version("0.1.0");
+program.command("init").description("Initialize aigent-team in your project (interactive)").action(async () => {
+  await runInit(process.cwd());
+});
+program.command("generate").description("Generate platform-specific config files from aigent-team config").option("-p, --platform <platform>", "Generate for a specific platform only").action(async (options) => {
+  await runGenerate(process.cwd(), {
+    platform: options.platform
+  });
+});
+program.command("validate").description("Validate generated config files against platform constraints").action(async () => {
+  await runValidate(process.cwd());
+});
+program.parse();