squads-cli 0.1.2 → 0.2.1

package/dist/init-XQZ7BOGT.js

@@ -0,0 +1,812 @@
+#!/usr/bin/env node
+import {
+  loadTemplate
+} from "./chunk-FFFCFZ6A.js";
+import {
+  checkGitStatus,
+  getRepoName
+} from "./chunk-TZXD6WFN.js";
+import {
+  Events,
+  track
+} from "./chunk-QJ7C7CMB.js";
+import {
+  RESET,
+  colors,
+  icons,
+  writeLine
+} from "./chunk-M5FXNY6Y.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 { execSync as execSync2 } from "child_process";
+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: "warning",
+      message: "Recommended for GitHub integration",
+      hint: "Install: https://cli.github.com"
+    };
+  }
+  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 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 !== "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: "Enterprise \u2014 Engineering + Marketing + Operations",
+      squads: [getEngineeringSquad(), getMarketingSquad(), getOperationsSquad()]
+    },
+    custom: {
+      label: "Custom",
+      description: "Empty scaffold \u2014 you build from scratch",
+      squads: []
+    }
+  };
+  return configs[useCase];
+}
+function getProductSquad() {
+  return {
+    name: "product",
+    description: "Roadmap, specs, user feedback synthesis",
+    agentCount: 3,
+    agentSummary: "lead, scanner, worker",
+    dirs: [
+      ".agents/squads/product",
+      ".agents/memory/product/lead",
+      ".agents/memory/product/scanner",
+      ".agents/memory/product/worker"
+    ],
+    files: [
+      [".agents/squads/product/SQUAD.md", "squads/product/SQUAD.md"],
+      [".agents/squads/product/lead.md", "squads/product/lead.md"],
+      [".agents/squads/product/scanner.md", "squads/product/scanner.md"],
+      [".agents/squads/product/worker.md", "squads/product/worker.md"]
+    ],
+    memoryFiles: [
+      [".agents/memory/product/lead/state.md", "memory/product/lead/state.md"]
+    ]
+  };
+}
+function getEngineeringSquad() {
+  return {
+    name: "engineering",
+    description: "Solves GitHub issues, reviews code, writes tests",
+    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",
+    description: "Creates content, grows audience, tracks growth",
+    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",
+    description: "Runs daily ops, tracks finances and goals",
+    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 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 businessCompetitors;
+  let selectedUseCase;
+  if (options.yes || options.quick || !isInteractive()) {
+    businessName = path.basename(cwd);
+    businessDescription = "A startup building and integrating AI smart capabilities for autonomous execution.";
+    businessFocus = "Track the big AI players \u2014 Anthropic, OpenAI, Google, Amazon, Meta, and xAI: latest model releases, API changes, pricing shifts, and strategic moves that affect builders.";
+    businessCompetitors = "";
+    selectedUseCase = "custom";
+  } else {
+    const dirName = path.basename(cwd);
+    writeLine(chalk.bold("  Tell us about your business:"));
+    writeLine(chalk.dim("  (Agents read this to produce useful output \u2014 be specific)"));
+    writeLine();
+    businessName = await prompt(
+      "Company or project name?",
+      dirName
+    );
+    writeLine(chalk.dim('    e.g., "We sell handmade coffee mugs online" or "B2B SaaS for construction teams"'));
+    businessDescription = await prompt(
+      "What does it do? (one sentence)",
+      ""
+    );
+    if (!businessDescription) {
+      writeLine(chalk.dim(`    Tip: Without a description, agents produce generic output. You can edit .agents/BUSINESS_BRIEF.md later.`));
+      businessDescription = `${businessName} \u2014 add your business description to .agents/BUSINESS_BRIEF.md`;
+    }
+    writeLine();
+    writeLine(chalk.dim('    e.g., "Identify our top 3 competitors and what they do better than us"'));
+    businessFocus = await prompt(
+      "What should your agents research first?",
+      "Our market position, top competitors, and biggest growth opportunity"
+    );
+    writeLine();
+    writeLine(chalk.dim('    e.g., "BlueCart, MarketMan" \u2014 leave blank to skip'));
+    businessCompetitors = await prompt(
+      "Who are your main competitors? (optional)",
+      ""
+    );
+    if (!options.pack) {
+      writeLine();
+      writeLine(chalk.bold("  Add squad packs? (optional)"));
+      writeLine();
+      writeLine(`  ${chalk.cyan("1)")} Core only ${chalk.dim("\u2014 intelligence, research, product, company")} ${chalk.green("(recommended)")}`);
+      writeLine(`  ${chalk.cyan("2)")} + Engineering ${chalk.dim("\u2014 issue-solver, code-reviewer, test-writer")}`);
+      writeLine(`  ${chalk.cyan("3)")} + All packs ${chalk.dim("\u2014 engineering, marketing, operations")}`);
+      writeLine();
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const packChoice = await new Promise((resolve) => {
+        rl.question(`  ${chalk.dim("Enter choice [1-3]:")} `, (answer) => {
+          rl.close();
+          resolve(answer.trim() || "1");
+        });
+      });
+      if (packChoice === "2") {
+        options.pack = ["engineering"];
+      } else if (packChoice === "3") {
+        options.pack = ["all"];
+      }
+    }
+    selectedUseCase = "custom";
+  }
+  const useCaseConfig = getUseCaseConfig(selectedUseCase);
+  if (options.pack && options.pack.length > 0) {
+    const additionalSquads = [];
+    for (const pack of options.pack) {
+      if (pack === "engineering") additionalSquads.push(getEngineeringSquad());
+      if (pack === "marketing") additionalSquads.push(getMarketingSquad());
+      if (pack === "operations") additionalSquads.push(getOperationsSquad());
+      if (pack === "all") {
+        additionalSquads.push(getEngineeringSquad(), getMarketingSquad(), getOperationsSquad());
+      }
+    }
+    const existingNames = new Set(useCaseConfig.squads.map((s) => s.name));
+    for (const squad of additionalSquads) {
+      if (!existingNames.has(squad.name)) {
+        useCaseConfig.squads.push(squad);
+        existingNames.add(squad.name);
+      }
+    }
+  }
+  const coreAgentCount = 14;
+  const coreSquadCount = 4;
+  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)}`);
+  if (businessCompetitors) {
+    writeLine(`  ${chalk.green("\u2713")} Competitors: ${chalk.cyan(businessCompetitors)}`);
+  }
+  if (options.pack && options.pack.length > 0) {
+    writeLine(`  ${chalk.green("\u2713")} Packs: ${chalk.cyan(options.pack.join(", "))}`);
+  }
+  writeLine();
+  const spinner = ora("Planting the seed...").start();
+  try {
+    const isPlaceholder = businessDescription.includes("add your business description");
+    const variables = {
+      BUSINESS_NAME: businessName,
+      BUSINESS_DESCRIPTION: businessDescription || `${businessName} \u2014 details to be added by the manager agent.`,
+      BUSINESS_FOCUS: businessFocus,
+      COMPETITORS_SECTION: businessCompetitors ? `## Competitors
+
+${businessCompetitors}
+
+` : "",
+      PLACEHOLDER_SENTINEL: isPlaceholder ? '<!-- STATUS: PLACEHOLDER \u2014 Edit this file before running agents. -->\n<!-- Agents that read "PLACEHOLDER" in this comment will ask you to fill it in. -->\n\n' : "",
+      PROVIDER: selectedProvider,
+      PROVIDER_NAME: provider?.name || "Unknown"
+    };
+    const dirs = [
+      ".agents/squads/company",
+      ".agents/squads/research",
+      ".agents/squads/intelligence",
+      ".agents/squads/product",
+      ".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/lead",
+      ".agents/memory/research/analyst",
+      ".agents/memory/research/synthesizer",
+      ".agents/memory/intelligence/intel-lead",
+      ".agents/memory/intelligence/intel-eval",
+      ".agents/memory/intelligence/intel-critic",
+      ".agents/memory/product/lead",
+      ".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/lead.md", "squads/research/lead.md"],
+      [".agents/squads/research/analyst.md", "squads/research/analyst.md"],
+      [".agents/squads/research/synthesizer.md", "squads/research/synthesizer.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 productFiles = getProductSquad().files;
+    const useCaseFiles = [];
+    for (const squad of useCaseConfig.squads) {
+      useCaseFiles.push(...squad.files);
+    }
+    for (const [dest, template] of [...companyFiles, ...researchFiles, ...intelligenceFiles, ...productFiles, ...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/lead/state.md", "memory/research/lead/state.md"],
+      [".agents/memory/intelligence/intel-lead/state.md", "memory/intelligence/intel-lead/state.md"],
+      [".agents/memory/product/lead/state.md", "memory/product/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 systemMd = loadSeedTemplate("config/SYSTEM.md", variables);
+    await writeFile(path.join(cwd, ".agents/config/SYSTEM.md"), systemMd);
+    const directivesMd = loadSeedTemplate("memory/company/directives.md", variables);
+    await writeIfNew(path.join(cwd, ".agents/memory/company/directives.md"), directivesMd);
+    const businessBrief = loadSeedTemplate("BUSINESS_BRIEF.md.template", variables);
+    await writeFile(path.join(cwd, ".agents/BUSINESS_BRIEF.md"), businessBrief);
+    const agentsMd = loadTemplate("core/AGENTS.md.template", variables);
+    await writeIfNew(path.join(cwd, "AGENTS.md"), agentsMd);
+    const readmePath = path.join(cwd, "README.md");
+    let existingReadme = "";
+    try {
+      existingReadme = await fs.readFile(readmePath, "utf-8");
+    } catch {
+    }
+    const isStub = existingReadme.trim() === "" || /^# [^\n]+\s*$/.test(existingReadme.trim());
+    if (isStub) {
+      const readmeContent = loadSeedTemplate("README.md.template", variables);
+      await writeFile(readmePath, readmeContent);
+    }
+    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");
+    const err = error;
+    if (err?.code === "EACCES" || err?.code === "EPERM") {
+      writeLine(chalk.red("  Permission denied \u2014 cannot write to this directory."));
+      writeLine(chalk.dim("  Try running in a directory you own, or check folder permissions."));
+    } else if (err?.code === "ENOENT") {
+      writeLine(chalk.red(`  Could not find or create: ${err.path || "unknown path"}`));
+      writeLine(chalk.dim("  Check that the directory exists and you have write access."));
+    } else {
+      const msg = error instanceof Error ? error.message : String(error);
+      writeLine(chalk.red(`  ${msg}`));
+      writeLine(chalk.dim("  Run with --verbose for more details, or check squads doctor."));
+    }
+    process.exit(1);
+  }
+  try {
+    execSync2('git add -A && git commit -q -m "feat: init AI workforce\n\nCo-Authored-By: Claude <noreply@anthropic.com>"', {
+      cwd,
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  writeLine();
+  writeLine(chalk.green.bold(`  ${businessName}'s AI workforce is ready.`));
+  writeLine();
+  writeLine(chalk.dim("  Created:"));
+  writeLine(chalk.dim("  \u2022 research/    3 agents \u2014 Researches your market, competitors, and opportunities"));
+  writeLine(chalk.dim("  \u2022 company/     5 agents \u2014 Manages goals, events, and strategy"));
+  writeLine(chalk.dim("  \u2022 intelligence/ 3 agents \u2014 Monitors trends and competitive signals"));
+  writeLine(chalk.dim("  \u2022 product/      3 agents \u2014 Roadmap, specs, user feedback synthesis"));
+  for (const squad of useCaseConfig.squads) {
+    const namePad = " ".repeat(Math.max(0, 14 - squad.name.length));
+    writeLine(chalk.dim(`  \u2022 ${squad.name}/${namePad}${squad.agentCount} agents \u2014 ${squad.description}`));
+  }
+  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"));
+  writeLine(chalk.dim("  \u2022 AGENTS.md                     Agent instructions (vendor-neutral)"));
+  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("$EDITOR .agents/BUSINESS_BRIEF.md")}`);
+  writeLine(chalk.dim("        Set your business context \u2014 agents use this for every run"));
+  writeLine();
+  const firstRunCommand = getFirstRunCommand(selectedUseCase);
+  const squadCommand = firstRunCommand.command.replace(/\/[^/]+$/, "");
+  writeLine(`     ${chalk.cyan("2.")} ${chalk.yellow(firstRunCommand.command)}`);
+  writeLine(chalk.dim(`        ${firstRunCommand.description}`));
+  writeLine(chalk.dim(`        Full squad (4+ agents, longer): ${squadCommand}`));
+  writeLine();
+  writeLine(`     ${chalk.cyan("3.")} ${chalk.yellow(`squads run`)}`);
+  writeLine(chalk.dim("        Autopilot \u2014 runs all squads on schedule, learns between cycles"));
+  writeLine(chalk.dim(`        Options: squads run --once (single cycle), squads run -i 15 --budget 50`));
+  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: "Run a single agent \u2014 finds and solves GitHub issues (~2 min)"
+      };
+    case "marketing":
+      return {
+        command: "squads run marketing/content-drafter",
+        description: "Run a single agent \u2014 drafts content for your business (~2 min)"
+      };
+    case "operations":
+      return {
+        command: "squads run operations/ops-lead",
+        description: "Run a single agent \u2014 coordinates daily operations (~2 min)"
+      };
+    case "full-company":
+    case "custom":
+    default:
+      return {
+        command: "squads run research/lead",
+        description: "Run a single agent \u2014 researches the topic you set (~2 min)"
+      };
+  }
+}
+export {
+  initCommand
+};
+//# sourceMappingURL=init-XQZ7BOGT.js.map