squads-cli 0.6.2 → 0.7.0

package/dist/init-UOWTNMIE.js

@@ -0,0 +1,747 @@
+#!/usr/bin/env node
+import {
+  loadTemplate
+} from "./chunk-FFFCFZ6A.js";
+import {
+  checkGitStatus,
+  getRepoName
+} from "./chunk-3KCWNZWW.js";
+import {
+  Events,
+  track
+} from "./chunk-L6GQCHDF.js";
+import {
+  RESET,
+  colors,
+  icons,
+  writeLine
+} from "./chunk-N7KDWU4W.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/commands/init.ts
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs/promises";
+import path from "path";
+import { createInterface } from "readline";
+
+// src/lib/setup-checks.ts
+import { execSync, spawn } from "child_process";
+var PROVIDERS = {
+  claude: {
+    id: "claude",
+    name: "Claude Code (Anthropic)",
+    cliCheck: "claude",
+    installCmd: "npm install -g @anthropic-ai/claude-code",
+    loginCmd: "claude login",
+    requiresSubscription: true,
+    requiresApiKey: false
+  },
+  gemini: {
+    id: "gemini",
+    name: "Gemini (Google)",
+    cliCheck: "gemini",
+    envKey: "GEMINI_API_KEY",
+    installCmd: "npm install -g @anthropic-ai/claude-code",
+    // Placeholder - gemini CLI
+    requiresSubscription: false,
+    requiresApiKey: true
+  },
+  openai: {
+    id: "openai",
+    name: "GPT (OpenAI)",
+    envKey: "OPENAI_API_KEY",
+    requiresSubscription: false,
+    requiresApiKey: true
+  },
+  ollama: {
+    id: "ollama",
+    name: "Ollama (Local)",
+    cliCheck: "ollama",
+    installCmd: "brew install ollama",
+    requiresSubscription: false,
+    requiresApiKey: false
+  },
+  cursor: {
+    id: "cursor",
+    name: "Cursor IDE",
+    requiresSubscription: true,
+    requiresApiKey: false
+  },
+  aider: {
+    id: "aider",
+    name: "Aider",
+    cliCheck: "aider",
+    installCmd: "pip install aider-chat",
+    requiresSubscription: false,
+    requiresApiKey: true
+  },
+  none: {
+    id: "none",
+    name: "Planning Only (no agent execution)",
+    requiresSubscription: false,
+    requiresApiKey: false
+  }
+};
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkGhCli() {
+  if (!commandExists("gh")) {
+    return {
+      name: "GitHub CLI",
+      status: "missing",
+      message: "Required for GitHub integration",
+      hint: "Install: brew install gh",
+      fixCommand: "brew install gh"
+    };
+  }
+  try {
+    execSync("gh auth status", { stdio: "ignore" });
+    return { name: "GitHub CLI", status: "ok" };
+  } catch {
+    return {
+      name: "GitHub CLI",
+      status: "warning",
+      message: "Installed but not authenticated",
+      hint: "Run: gh auth login",
+      fixCommand: "gh auth login"
+    };
+  }
+}
+function checkGhPermissions() {
+  try {
+    const result = execSync("gh auth status 2>&1", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const hasRepo = result.includes("repo") || result.includes("Token scopes:") && !result.includes("none");
+    const hasWorkflow = result.includes("workflow");
+    if (!hasRepo) {
+      return {
+        name: "GitHub Permissions",
+        status: "warning",
+        message: "Missing repo scope",
+        hint: "Run: gh auth refresh -s repo,workflow",
+        fixCommand: "gh auth refresh -s repo,workflow"
+      };
+    }
+    if (!hasWorkflow) {
+      return {
+        name: "GitHub Permissions",
+        status: "warning",
+        message: "Missing workflow scope (optional)",
+        hint: "For Actions: gh auth refresh -s repo,workflow"
+      };
+    }
+    return { name: "GitHub Permissions", status: "ok" };
+  } catch {
+    return {
+      name: "GitHub Permissions",
+      status: "warning",
+      message: "Could not verify permissions",
+      hint: "Run: gh auth status"
+    };
+  }
+}
+function checkClaudeCli() {
+  if (!commandExists("claude")) {
+    return {
+      name: "Claude CLI",
+      status: "missing",
+      message: "Required to run agents",
+      hint: "Install: npm install -g @anthropic-ai/claude-code",
+      fixCommand: "npm install -g @anthropic-ai/claude-code"
+    };
+  }
+  try {
+    execSync("claude --version", { stdio: "ignore" });
+    return { name: "Claude CLI", status: "ok" };
+  } catch {
+    return {
+      name: "Claude CLI",
+      status: "warning",
+      message: "Installed but may need login",
+      hint: "Run: claude login",
+      fixCommand: "claude login"
+    };
+  }
+}
+function checkProviderAuth(providerId) {
+  const provider = PROVIDERS[providerId];
+  if (!provider) {
+    return { name: "Provider", status: "warning", message: `Unknown provider: ${providerId}` };
+  }
+  if (providerId === "none" || providerId === "cursor") {
+    return { name: provider.name, status: "ok" };
+  }
+  if (provider.cliCheck) {
+    if (!commandExists(provider.cliCheck)) {
+      return {
+        name: provider.name,
+        status: "missing",
+        message: `CLI not installed`,
+        hint: provider.installCmd ? `Install: ${provider.installCmd}` : void 0,
+        fixCommand: provider.installCmd
+      };
+    }
+  }
+  if (provider.envKey && provider.requiresApiKey) {
+    if (!process.env[provider.envKey]) {
+      return {
+        name: provider.name,
+        status: "warning",
+        message: `${provider.envKey} not set`,
+        hint: `Set environment variable: export ${provider.envKey}=<your-key>`
+      };
+    }
+  }
+  return { name: provider.name, status: "ok" };
+}
+function runAuthChecks(providerId) {
+  const checks = [];
+  checks.push(checkProviderAuth(providerId));
+  if (providerId === "claude") {
+    checks.push(checkClaudeCli());
+  }
+  if (providerId !== "none") {
+    checks.push(checkGhPermissions());
+  }
+  return checks;
+}
+function displayCheckResults(checks) {
+  const errorChecks = [];
+  const warningChecks = [];
+  for (const check of checks) {
+    const icon = getStatusIcon(check.status);
+    const statusColor = getStatusColor(check.status);
+    if (check.status === "ok") {
+      writeLine(`  ${icon} ${check.name}`);
+    } else {
+      const suffix = check.message ? ` ${colors.dim}(${check.message})${RESET}` : "";
+      writeLine(`  ${icon} ${statusColor}${check.name}${RESET}${suffix}`);
+      if (check.hint) {
+        writeLine(`    ${colors.cyan}\u2192 ${check.hint}${RESET}`);
+      }
+      if (check.status === "error" || check.status === "missing") {
+        errorChecks.push(check);
+      } else if (check.status === "warning") {
+        warningChecks.push(check);
+      }
+    }
+  }
+  return {
+    hasErrors: errorChecks.length > 0,
+    hasWarnings: warningChecks.length > 0,
+    errorChecks,
+    warningChecks
+  };
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "ok":
+      return `${colors.green}${icons.success}${RESET}`;
+    case "warning":
+      return `${colors.yellow}${icons.warning}${RESET}`;
+    case "missing":
+    case "error":
+      return `${colors.red}${icons.error}${RESET}`;
+  }
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "ok":
+      return colors.green;
+    case "warning":
+      return colors.yellow;
+    case "missing":
+    case "error":
+      return colors.red;
+  }
+}
+
+// src/commands/init.ts
+function getUseCaseConfig(useCase) {
+  const configs = {
+    engineering: {
+      label: "Engineering",
+      description: "Ships code",
+      squads: [getEngineeringSquad()]
+    },
+    marketing: {
+      label: "Marketing",
+      description: "Grows audience",
+      squads: [getMarketingSquad()]
+    },
+    operations: {
+      label: "Operations",
+      description: "Runs the business",
+      squads: [getOperationsSquad()]
+    },
+    "full-company": {
+      label: "Full Company",
+      description: "Engineering + Marketing + Operations",
+      squads: [getEngineeringSquad(), getMarketingSquad(), getOperationsSquad()]
+    },
+    custom: {
+      label: "Custom",
+      description: "Empty scaffold \u2014 you build from scratch",
+      squads: []
+    }
+  };
+  return configs[useCase];
+}
+function getEngineeringSquad() {
+  return {
+    name: "engineering",
+    agentCount: 3,
+    agentSummary: "issue-solver, code-reviewer, test-writer",
+    dirs: [
+      ".agents/squads/engineering",
+      ".agents/memory/engineering/issue-solver",
+      ".agents/memory/engineering/code-reviewer",
+      ".agents/memory/engineering/test-writer"
+    ],
+    files: [
+      [".agents/squads/engineering/SQUAD.md", "squads/engineering/SQUAD.md"],
+      [".agents/squads/engineering/issue-solver.md", "squads/engineering/issue-solver.md"],
+      [".agents/squads/engineering/code-reviewer.md", "squads/engineering/code-reviewer.md"],
+      [".agents/squads/engineering/test-writer.md", "squads/engineering/test-writer.md"]
+    ],
+    memoryFiles: [
+      [".agents/memory/engineering/issue-solver/state.md", "memory/engineering/issue-solver/state.md"]
+    ]
+  };
+}
+function getMarketingSquad() {
+  return {
+    name: "marketing",
+    agentCount: 3,
+    agentSummary: "content-drafter, social-poster, growth-analyst",
+    dirs: [
+      ".agents/squads/marketing",
+      ".agents/memory/marketing/content-drafter",
+      ".agents/memory/marketing/social-poster",
+      ".agents/memory/marketing/growth-analyst"
+    ],
+    files: [
+      [".agents/squads/marketing/SQUAD.md", "squads/marketing/SQUAD.md"],
+      [".agents/squads/marketing/content-drafter.md", "squads/marketing/content-drafter.md"],
+      [".agents/squads/marketing/social-poster.md", "squads/marketing/social-poster.md"],
+      [".agents/squads/marketing/growth-analyst.md", "squads/marketing/growth-analyst.md"]
+    ],
+    memoryFiles: [
+      [".agents/memory/marketing/content-drafter/state.md", "memory/marketing/content-drafter/state.md"]
+    ]
+  };
+}
+function getOperationsSquad() {
+  return {
+    name: "operations",
+    agentCount: 3,
+    agentSummary: "ops-lead, finance-tracker, goal-tracker",
+    dirs: [
+      ".agents/squads/operations",
+      ".agents/memory/operations/ops-lead",
+      ".agents/memory/operations/finance-tracker",
+      ".agents/memory/operations/goal-tracker"
+    ],
+    files: [
+      [".agents/squads/operations/SQUAD.md", "squads/operations/SQUAD.md"],
+      [".agents/squads/operations/ops-lead.md", "squads/operations/ops-lead.md"],
+      [".agents/squads/operations/finance-tracker.md", "squads/operations/finance-tracker.md"],
+      [".agents/squads/operations/goal-tracker.md", "squads/operations/goal-tracker.md"]
+    ],
+    memoryFiles: [
+      [".agents/memory/operations/ops-lead/state.md", "memory/operations/ops-lead/state.md"]
+    ]
+  };
+}
+function isInteractive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+async function prompt(question, defaultValue = "") {
+  if (!isInteractive()) return defaultValue;
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    const suffix = defaultValue ? chalk.dim(` (${defaultValue})`) : "";
+    rl.question(`  ${question}${suffix} `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+async function promptProvider(forceProvider) {
+  if (forceProvider && forceProvider in PROVIDERS) {
+    return forceProvider;
+  }
+  if (!isInteractive()) return "claude";
+  writeLine();
+  writeLine(chalk.bold("  Select your AI assistant:"));
+  writeLine();
+  writeLine(`  ${chalk.cyan("1)")} Claude Code ${chalk.dim("(recommended)")}`);
+  writeLine(`  ${chalk.cyan("2)")} Gemini`);
+  writeLine(`  ${chalk.cyan("3)")} OpenAI GPT`);
+  writeLine(`  ${chalk.cyan("4)")} Ollama ${chalk.dim("(local)")}`);
+  writeLine(`  ${chalk.cyan("5)")} Other/None`);
+  writeLine();
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`  ${chalk.dim("Enter choice [1-5]:")} `, (answer) => {
+      rl.close();
+      const choice = answer.trim() || "1";
+      switch (choice) {
+        case "1":
+          resolve("claude");
+          break;
+        case "2":
+          resolve("gemini");
+          break;
+        case "3":
+          resolve("openai");
+          break;
+        case "4":
+          resolve("ollama");
+          break;
+        case "5":
+          resolve("none");
+          break;
+        default:
+          resolve("claude");
+          break;
+      }
+    });
+  });
+}
+async function promptUseCase() {
+  if (!isInteractive()) return "full-company";
+  writeLine();
+  writeLine(chalk.bold("  What does your AI workforce need to do?"));
+  writeLine();
+  writeLine(`  ${chalk.cyan("1)")} Engineering       ${chalk.dim("\u2014 ships code (issue-solver, code-reviewer, test-writer)")}`);
+  writeLine(`  ${chalk.cyan("2)")} Marketing          ${chalk.dim("\u2014 grows audience (content-drafter, social-poster, growth-analyst)")}`);
+  writeLine(`  ${chalk.cyan("3)")} Operations         ${chalk.dim("\u2014 runs the business (ops-lead, finance-tracker, goal-tracker)")}`);
+  writeLine(`  ${chalk.cyan("4)")} Full Company       ${chalk.dim("\u2014 all of the above")} ${chalk.green("(recommended)")}`);
+  writeLine(`  ${chalk.cyan("5)")} Custom             ${chalk.dim("\u2014 empty scaffold, you build from scratch")}`);
+  writeLine();
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`  ${chalk.dim("Enter choice [1-5]:")} `, (answer) => {
+      rl.close();
+      const choice = answer.trim() || "4";
+      switch (choice) {
+        case "1":
+          resolve("engineering");
+          break;
+        case "2":
+          resolve("marketing");
+          break;
+        case "3":
+          resolve("operations");
+          break;
+        case "4":
+          resolve("full-company");
+          break;
+        case "5":
+          resolve("custom");
+          break;
+        default:
+          resolve("full-company");
+          break;
+      }
+    });
+  });
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function loadSeedTemplate(templatePath, variables = {}) {
+  return loadTemplate(`seed/${templatePath}`, variables);
+}
+async function writeIfNew(filePath, content) {
+  if (await fileExists(filePath)) return false;
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content);
+  return true;
+}
+async function writeFile(filePath, content) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content);
+}
+async function initCommand(options) {
+  const cwd = process.cwd();
+  writeLine();
+  writeLine(chalk.bold("  Plant the seed for your AI workforce"));
+  writeLine(chalk.dim("  https://agents-squads.com/docs/getting-started"));
+  writeLine();
+  const selectedProvider = await promptProvider(options.provider);
+  const provider = PROVIDERS[selectedProvider];
+  writeLine();
+  writeLine(chalk.bold("  Checking prerequisites..."));
+  writeLine();
+  const checks = [
+    ...runAuthChecks(selectedProvider),
+    checkGhCli()
+  ];
+  const gitStatus = checkGitStatus(cwd);
+  if (!gitStatus.isGitRepo) {
+    checks.push({
+      name: "Git Repository",
+      status: "missing",
+      message: "Git is the coordination layer",
+      hint: "Run: git init",
+      fixCommand: "git init"
+    });
+  } else {
+    checks.push({ name: "Git Repository", status: "ok" });
+    if (gitStatus.hasRemote) {
+      const repoName = getRepoName(gitStatus.remoteUrl);
+      checks.push({ name: `Remote: ${repoName || gitStatus.remoteUrl}`, status: "ok" });
+    }
+  }
+  const { hasErrors } = displayCheckResults(checks);
+  if (hasErrors && !options.force) {
+    writeLine();
+    writeLine(chalk.red("  Fix the errors above before continuing."));
+    writeLine(chalk.dim("  Or run with --force to skip checks."));
+    writeLine();
+    process.exit(1);
+  }
+  writeLine();
+  let businessName;
+  let businessDescription;
+  let businessFocus;
+  let selectedUseCase;
+  if (options.yes || options.quick || !isInteractive()) {
+    businessName = path.basename(cwd);
+    businessDescription = "General business operations";
+    businessFocus = "Our market, competitors, and growth opportunities";
+    selectedUseCase = "full-company";
+  } else {
+    const dirName = path.basename(cwd);
+    writeLine(chalk.bold("  Tell us about your business:"));
+    writeLine();
+    businessName = await prompt(
+      "Company or project name?",
+      dirName
+    );
+    businessDescription = await prompt(
+      "What does it do? (one sentence)",
+      ""
+    );
+    writeLine();
+    businessFocus = await prompt(
+      "What should your first research squad investigate?",
+      "Our market, competitors, and growth opportunities"
+    );
+    selectedUseCase = await promptUseCase();
+  }
+  const useCaseConfig = getUseCaseConfig(selectedUseCase);
+  const coreAgentCount = 12;
+  const coreSquadCount = 3;
+  const useCaseAgentCount = useCaseConfig.squads.reduce((sum, s) => sum + s.agentCount, 0);
+  const totalAgentCount = coreAgentCount + useCaseAgentCount;
+  const totalSquadCount = coreSquadCount + useCaseConfig.squads.length;
+  writeLine();
+  writeLine(`  ${chalk.green("\u2713")} Business: ${chalk.cyan(businessName)}${businessDescription ? chalk.dim(` \u2014 ${businessDescription}`) : ""}`);
+  writeLine(`  ${chalk.green("\u2713")} Provider: ${chalk.cyan(provider?.name || selectedProvider)}`);
+  writeLine(`  ${chalk.green("\u2713")} Research focus: ${chalk.cyan(businessFocus)}`);
+  writeLine(`  ${chalk.green("\u2713")} Use case: ${chalk.cyan(useCaseConfig.label)} ${chalk.dim(`\u2014 ${useCaseConfig.description}`)}`);
+  writeLine();
+  const spinner = ora("Planting the seed...").start();
+  try {
+    const variables = {
+      BUSINESS_NAME: businessName,
+      BUSINESS_DESCRIPTION: businessDescription || `${businessName} \u2014 details to be added by the manager agent.`,
+      BUSINESS_FOCUS: businessFocus,
+      PROVIDER: selectedProvider,
+      PROVIDER_NAME: provider?.name || "Unknown"
+    };
+    const dirs = [
+      ".agents/squads/company",
+      ".agents/squads/research",
+      ".agents/squads/intelligence",
+      ".agents/memory/company/manager",
+      ".agents/memory/company/event-dispatcher",
+      ".agents/memory/company/goal-tracker",
+      ".agents/memory/company/company-eval",
+      ".agents/memory/company/company-critic",
+      ".agents/memory/research/researcher",
+      ".agents/memory/research/analyst",
+      ".agents/memory/research/research-eval",
+      ".agents/memory/research/research-critic",
+      ".agents/memory/intelligence/intel-lead",
+      ".agents/memory/intelligence/intel-eval",
+      ".agents/memory/intelligence/intel-critic",
+      ".agents/skills/squads-cli",
+      ".agents/skills/gh",
+      ".agents/config"
+    ];
+    for (const squad of useCaseConfig.squads) {
+      dirs.push(...squad.dirs);
+    }
+    if (selectedProvider === "claude") {
+      dirs.push(".claude");
+    }
+    for (const dir of dirs) {
+      await fs.mkdir(path.join(cwd, dir), { recursive: true });
+    }
+    spinner.text = "Creating squad definitions...";
+    const companyFiles = [
+      [".agents/squads/company/SQUAD.md", "squads/company/SQUAD.md"],
+      [".agents/squads/company/manager.md", "squads/company/manager.md"],
+      [".agents/squads/company/event-dispatcher.md", "squads/company/event-dispatcher.md"],
+      [".agents/squads/company/goal-tracker.md", "squads/company/goal-tracker.md"],
+      [".agents/squads/company/company-eval.md", "squads/company/company-eval.md"],
+      [".agents/squads/company/company-critic.md", "squads/company/company-critic.md"]
+    ];
+    const researchFiles = [
+      [".agents/squads/research/SQUAD.md", "squads/research/SQUAD.md"],
+      [".agents/squads/research/researcher.md", "squads/research/researcher.md"],
+      [".agents/squads/research/analyst.md", "squads/research/analyst.md"],
+      [".agents/squads/research/research-eval.md", "squads/research/research-eval.md"],
+      [".agents/squads/research/research-critic.md", "squads/research/research-critic.md"]
+    ];
+    const intelligenceFiles = [
+      [".agents/squads/intelligence/SQUAD.md", "squads/intelligence/SQUAD.md"],
+      [".agents/squads/intelligence/intel-lead.md", "squads/intelligence/intel-lead.md"],
+      [".agents/squads/intelligence/intel-eval.md", "squads/intelligence/intel-eval.md"],
+      [".agents/squads/intelligence/intel-critic.md", "squads/intelligence/intel-critic.md"]
+    ];
+    const useCaseFiles = [];
+    for (const squad of useCaseConfig.squads) {
+      useCaseFiles.push(...squad.files);
+    }
+    for (const [dest, template] of [...companyFiles, ...researchFiles, ...intelligenceFiles, ...useCaseFiles]) {
+      const content = loadSeedTemplate(template, variables);
+      await writeFile(path.join(cwd, dest), content);
+    }
+    spinner.text = "Creating memory and config...";
+    const coreMemoryFiles = [
+      [".agents/memory/company/manager/state.md", "memory/company/manager/state.md"],
+      [".agents/memory/research/researcher/state.md", "memory/research/researcher/state.md"],
+      [".agents/memory/intelligence/intel-lead/state.md", "memory/intelligence/intel-lead/state.md"]
+    ];
+    const useCaseMemoryFiles = [];
+    for (const squad of useCaseConfig.squads) {
+      useCaseMemoryFiles.push(...squad.memoryFiles);
+    }
+    for (const [dest, template] of [...coreMemoryFiles, ...useCaseMemoryFiles]) {
+      await writeIfNew(path.join(cwd, dest), loadSeedTemplate(template, variables));
+    }
+    const skillContent = loadSeedTemplate("skills/squads-cli/SKILL.md", variables);
+    await writeFile(path.join(cwd, ".agents/skills/squads-cli/SKILL.md"), skillContent);
+    const ghSkillContent = loadSeedTemplate("skills/gh/SKILL.md", variables);
+    await writeFile(path.join(cwd, ".agents/skills/gh/SKILL.md"), ghSkillContent);
+    const providerConfig = loadSeedTemplate("config/provider.yaml", variables);
+    await writeFile(path.join(cwd, ".agents/config/provider.yaml"), providerConfig);
+    const businessBrief = loadSeedTemplate("BUSINESS_BRIEF.md.template", variables);
+    await writeFile(path.join(cwd, ".agents/BUSINESS_BRIEF.md"), businessBrief);
+    spinner.text = "Setting up operating manual...";
+    if (selectedProvider === "claude") {
+      const claudeMd = loadSeedTemplate("CLAUDE.md.template", variables);
+      await writeIfNew(path.join(cwd, "CLAUDE.md"), claudeMd);
+      const hooksContent = loadSeedTemplate("hooks/settings.json.template", variables);
+      await writeIfNew(path.join(cwd, ".claude/settings.json"), hooksContent);
+    }
+    spinner.succeed("Seed planted");
+    await track(Events.CLI_INIT, {
+      success: true,
+      hasGit: gitStatus.isGitRepo,
+      hasRemote: gitStatus.hasRemote,
+      provider: selectedProvider,
+      useCase: selectedUseCase,
+      agentCount: totalAgentCount,
+      squadCount: totalSquadCount,
+      hasBusinessName: businessName !== path.basename(cwd),
+      hasBusinessDescription: businessDescription.length > 0
+    });
+  } catch (error) {
+    spinner.fail("Failed to plant the seed");
+    console.error(chalk.red(`  ${error}`));
+    process.exit(1);
+  }
+  writeLine();
+  writeLine(chalk.green.bold(`  ${businessName}'s AI workforce is ready.`));
+  writeLine();
+  writeLine(chalk.dim("  Created:"));
+  writeLine(chalk.dim("  \u2022 .agents/squads/company/       5 agents (manager, dispatcher, tracker, eval, critic)"));
+  writeLine(chalk.dim("  \u2022 .agents/squads/research/      4 agents (researcher, analyst, eval, critic)"));
+  writeLine(chalk.dim("  \u2022 .agents/squads/intelligence/  3 agents (intel-lead, eval, critic)"));
+  for (const squad of useCaseConfig.squads) {
+    const padding = " ".repeat(Math.max(0, 22 - squad.name.length));
+    writeLine(chalk.dim(`  \u2022 .agents/squads/${squad.name}/${padding}${squad.agentCount} agents (${squad.agentSummary})`));
+  }
+  writeLine(chalk.dim("  \u2022 .agents/skills/               CLI + GitHub workflow skills"));
+  writeLine(chalk.dim("  \u2022 .agents/memory/               Persistent state"));
+  writeLine(chalk.dim("  \u2022 .agents/BUSINESS_BRIEF.md"));
+  if (selectedProvider === "claude") {
+    writeLine(chalk.dim("  \u2022 CLAUDE.md                     Operating manual"));
+    writeLine(chalk.dim("  \u2022 .claude/settings.json         Session hooks"));
+  }
+  writeLine();
+  writeLine(chalk.bold("  Getting started:"));
+  writeLine();
+  writeLine(`     ${chalk.cyan("1.")} ${chalk.yellow('git add -A && git commit -m "feat: init AI workforce"')}`);
+  writeLine(chalk.dim("        Git is the coordination layer \u2014 commit first"));
+  writeLine();
+  const firstRunCommand = getFirstRunCommand(selectedUseCase);
+  writeLine(`     ${chalk.cyan("2.")} ${chalk.yellow(firstRunCommand.command)}`);
+  writeLine(chalk.dim(`        ${firstRunCommand.description}`));
+  writeLine();
+  writeLine(`     ${chalk.cyan("3.")} ${chalk.yellow(`squads dash`)}`);
+  writeLine(chalk.dim("        See all your squads and agents at a glance"));
+  writeLine();
+  writeLine(chalk.dim("  Docs: https://agents-squads.com/docs/getting-started"));
+  writeLine();
+}
+function getFirstRunCommand(useCase) {
+  switch (useCase) {
+    case "engineering":
+      return {
+        command: "squads run engineering/issue-solver",
+        description: "Your first agent finds and solves GitHub issues"
+      };
+    case "marketing":
+      return {
+        command: "squads run marketing/content-drafter",
+        description: "Your first agent drafts content for your business"
+      };
+    case "operations":
+      return {
+        command: "squads run operations/ops-lead",
+        description: "Your first agent starts running daily operations"
+      };
+    case "full-company":
+      return {
+        command: "squads run research/researcher",
+        description: "Your first agent researches the topic you set"
+      };
+    case "custom":
+    default:
+      return {
+        command: "squads run research/researcher",
+        description: "Your first agent researches the topic you set"
+      };
+  }
+}
+export {
+  initCommand
+};
+//# sourceMappingURL=init-UOWTNMIE.js.map