@maestroai/cli 0.1.0

package/dist/chunk-5ZDNPLKN.js

@@ -0,0 +1,1172 @@
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import * as readline from "readline";
+import chalk from "chalk";
+import figures from "figures";
+import {
+  Planner,
+  TaskParser,
+  TaskWriter,
+  generateTaskId,
+  resetTaskCounter,
+  getDefaultSystemPrompt
+} from "@maestroai/core";
+
+// src/utils/claude-check.ts
+import { existsSync } from "fs";
+import { execSync } from "child_process";
+import path from "path";
+import os from "os";
+function checkClaudeInstalled() {
+  try {
+    const claudePath = execSync("command -v claude", { encoding: "utf-8" }).trim();
+    if (!claudePath) {
+      const homeDir = os.homedir();
+      const commonPaths = [
+        path.join(homeDir, ".local", "bin", "claude"),
+        "/usr/local/bin/claude",
+        path.join(homeDir, "bin", "claude")
+      ];
+      for (const checkPath of commonPaths) {
+        if (existsSync(checkPath)) {
+          try {
+            const version2 = execSync("claude --version", { encoding: "utf-8" }).trim();
+            return { installed: true, path: checkPath, version: version2 };
+          } catch {
+            return { installed: true, path: checkPath };
+          }
+        }
+      }
+      return {
+        installed: false,
+        error: "Claude CLI not found in PATH or common installation directories"
+      };
+    }
+    let version;
+    try {
+      version = execSync("claude --version", { encoding: "utf-8" }).trim();
+    } catch {
+    }
+    return { installed: true, path: claudePath, version };
+  } catch (error) {
+    return {
+      installed: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function getClaudeInstallInstructions() {
+  const platform = os.platform();
+  if (platform === "darwin") {
+    return `Install Claude CLI for macOS:
+  npm install -g @anthropic-ai/claude-code
+
+Or using Homebrew:
+  brew install anthropic/claude/claude-code`;
+  }
+  if (platform === "linux") {
+    return `Install Claude CLI for Linux:
+  npm install -g @anthropic-ai/claude-code`;
+  }
+  if (platform === "win32") {
+    return `Install Claude CLI for Windows:
+  npm install -g @anthropic-ai/claude-code`;
+  }
+  return `Install Claude CLI:
+  npm install -g @anthropic-ai/claude-code`;
+}
+
+// src/commands/init.ts
+function ask(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  return new Promise((resolve5) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve5(answer.trim() || defaultValue || "");
+    });
+  });
+}
+function detectExistingProject(dir) {
+  const result = {
+    type: "unknown",
+    techStack: {},
+    hasExistingCode: false,
+    configFiles: []
+  };
+  const pkgJsonPath = path2.resolve(dir, "package.json");
+  if (fs.existsSync(pkgJsonPath)) {
+    result.hasExistingCode = true;
+    result.configFiles.push("package.json");
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (allDeps["next"]) result.techStack.frontend = "next.js";
+      else if (allDeps["react"]) result.techStack.frontend = "react";
+      else if (allDeps["vue"]) result.techStack.frontend = "vue";
+      else if (allDeps["svelte"]) result.techStack.frontend = "svelte";
+      else if (allDeps["angular"]) result.techStack.frontend = "angular";
+      if (allDeps["@shadcn/ui"] || allDeps["shadcn-ui"] || allDeps["shadcn"]) result.techStack.uiLibrary = "shadcn";
+      else if (allDeps["tailwindcss"]) result.techStack.uiLibrary = "tailwind";
+      else if (allDeps["@mui/material"]) result.techStack.uiLibrary = "material-ui";
+      if (allDeps["express"]) result.techStack.backend = "node/express";
+      else if (allDeps["fastify"]) result.techStack.backend = "node/fastify";
+      else if (allDeps["hono"]) result.techStack.backend = "node/hono";
+      result.type = "node";
+    } catch {
+    }
+  }
+  if (fs.existsSync(path2.resolve(dir, "tsconfig.json"))) {
+    result.hasExistingCode = true;
+    result.configFiles.push("tsconfig.json");
+  }
+  if (fs.existsSync(path2.resolve(dir, "pyproject.toml"))) {
+    result.hasExistingCode = true;
+    result.configFiles.push("pyproject.toml");
+    result.type = "python";
+  }
+  if (fs.existsSync(path2.resolve(dir, "requirements.txt"))) {
+    result.hasExistingCode = true;
+    result.configFiles.push("requirements.txt");
+    if (result.type === "unknown") result.type = "python";
+  }
+  if (fs.existsSync(path2.resolve(dir, "go.mod"))) {
+    result.hasExistingCode = true;
+    result.configFiles.push("go.mod");
+    result.type = "go";
+  }
+  if (fs.existsSync(path2.resolve(dir, "Cargo.toml"))) {
+    result.hasExistingCode = true;
+    result.configFiles.push("Cargo.toml");
+    result.type = "rust";
+  }
+  return result;
+}
+function plannedToTask(planned) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: generateTaskId(),
+    title: planned.title,
+    description: planned.description,
+    status: "pending",
+    priority: planned.priority,
+    assignee: null,
+    dependencies: planned.dependencies,
+    tags: planned.tags,
+    createdAt: now,
+    updatedAt: now,
+    completedAt: null,
+    notes: []
+  };
+}
+function registerInitCommand(program) {
+  program.command("init").description("Initialize a new Maestro project").option("--no-plan", "skip automatic task planning (create empty todo.md)").option("--model <model>", "model to use for planning", "sonnet").option("-d, --dir <path>", "working directory for project context", ".").option("-i, --instructions <path>", "path to an instructions/requirements file for the planner").action(async (options) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    try {
+      console.log();
+      console.log(chalk.bold("  MAESTRO") + " - Project Initialization");
+      console.log();
+      const claudeCheck = checkClaudeInstalled();
+      if (!claudeCheck.installed) {
+        console.log(chalk.red(`  ${figures.cross} Claude CLI is not installed`));
+        console.log();
+        console.log(chalk.yellow("  Maestro requires Claude CLI to orchestrate agents."));
+        console.log();
+        console.log(chalk.bold("  Installation Instructions:"));
+        console.log(chalk.dim(getClaudeInstallInstructions()));
+        console.log();
+        const proceed = await ask(rl, chalk.yellow("  Continue anyway? (not recommended) (y/n)"), "n");
+        if (proceed.toLowerCase() !== "y") {
+          console.log();
+          console.log(chalk.dim("  Initialization cancelled. Install Claude CLI and try again."));
+          rl.close();
+          process.exit(0);
+        }
+        console.log();
+      } else {
+        console.log(chalk.green(`  ${figures.tick} Claude CLI detected`));
+        if (claudeCheck.version) {
+          console.log(chalk.dim(`  Version: ${claudeCheck.version}`));
+        }
+        console.log();
+      }
+      const targetDir = path2.resolve(options.dir);
+      if (targetDir !== process.cwd()) {
+        fs.mkdirSync(targetDir, { recursive: true });
+        process.chdir(targetDir);
+        console.log(chalk.dim(`  Changed to directory: ${targetDir}`));
+        console.log();
+      }
+      const detected = detectExistingProject(targetDir);
+      if (detected.hasExistingCode) {
+        console.log(chalk.cyan(`  ${figures.info} Existing ${detected.type} project detected`));
+        console.log(chalk.dim(`  Found: ${detected.configFiles.join(", ")}`));
+        const detectedTech = Object.values(detected.techStack).filter(Boolean);
+        if (detectedTech.length > 0) {
+          console.log(chalk.dim(`  Detected tech: ${detectedTech.join(", ")}`));
+        }
+        console.log();
+      }
+      let instructionsContent = "";
+      if (options.instructions) {
+        const instrPath = path2.resolve(options.instructions);
+        if (!fs.existsSync(instrPath)) {
+          console.error(chalk.red(`  ${figures.cross} Instructions file not found: ${instrPath}`));
+          process.exit(1);
+        }
+        instructionsContent = fs.readFileSync(instrPath, "utf-8").trim();
+        console.log(chalk.cyan(`  ${figures.info} Loaded instructions from ${chalk.bold(options.instructions)} (${instructionsContent.split("\n").length} lines)`));
+        console.log();
+      }
+      const projectName = await ask(rl, "  Project name", path2.basename(targetDir));
+      console.log();
+      console.log(chalk.dim("  Describe what the agents should work on. This can be:"));
+      console.log(chalk.dim("    - A new app to build from scratch"));
+      console.log(chalk.dim("    - A feature to add to an existing project"));
+      console.log(chalk.dim("    - A bug fix, refactor, or any other work"));
+      if (instructionsContent) {
+        console.log(chalk.dim("  (Instructions file loaded \u2014 leave blank to use it as the primary goal)"));
+      }
+      const description = await ask(rl, "  Goal / Description", instructionsContent ? "" : "");
+      const devCountStr = await ask(rl, "  Number of developer agents", "3");
+      const devCount = Math.max(1, parseInt(devCountStr, 10) || 3);
+      console.log();
+      console.log(chalk.dim("  Tech Stack (leave blank to skip):"));
+      const frontend = await ask(rl, "    Frontend framework (e.g., react, vue, svelte)", detected.techStack.frontend ?? "");
+      const uiLibrary = await ask(rl, "    UI library (e.g., shadcn, tailwind, material-ui)", detected.techStack.uiLibrary ?? "");
+      const backend = await ask(rl, "    Backend (e.g., node/express, python/fastapi, go)", detected.techStack.backend ?? "");
+      const database = await ask(rl, "    Database (e.g., postgres, mongodb, sqlite)", detected.techStack.database ?? "");
+      const otherTech = await ask(rl, "    Other tools/frameworks", "");
+      const techParts = [];
+      if (frontend) techParts.push(`Frontend: ${frontend}`);
+      if (uiLibrary) techParts.push(`UI: ${uiLibrary}`);
+      if (backend) techParts.push(`Backend: ${backend}`);
+      if (database) techParts.push(`Database: ${database}`);
+      if (otherTech) techParts.push(`Other: ${otherTech}`);
+      console.log();
+      const workingDirValue = ".";
+      const configDescription = description || (instructionsContent ? `See instructions file: ${options.instructions}` : "A Maestro-managed project");
+      const configContent = `# Maestro Project Configuration
+name: "${projectName}"
+description: "${configDescription}"
+version: "1.0.0"
+
+agents:
+  - role: orchestrator
+    count: 1
+
+  - role: project-manager
+    count: 1
+
+  - role: architect
+    count: 1
+
+  - role: developer
+    count: ${devCount}
+
+  - role: designer
+    count: 1
+
+  - role: qa-engineer
+    count: 1
+
+  - role: devops
+    count: 1
+
+  - role: technical-writer
+    count: 1
+
+  - role: code-reviewer
+    count: 1
+
+settings:
+  workingDirectory: "${workingDirValue}"
+  todoFile: "todo.md"
+  messagesDirectory: ".maestro/messages"
+  logsDirectory: ".maestro/logs"
+  defaultModel: "claude-sonnet-4-20250514"
+  maxConcurrentAgents: 10
+  pollIntervalMs: 5000
+  maxTotalBudgetUsd: 50.00
+
+  # Claude CLI configuration
+  # NOTE: Agents run with skip-permissions. Process safety (no builds, no Docker,
+  # no servers) is enforced via system prompts in .agents/*.md. Edit those files
+  # to customise safety rules.
+  claudeCommand: claude
+  claudeArgs:
+    - "--dangerously-skip-permissions"
+
+  feedback:
+    interactionMode: supervised
+    requirePlanApproval: true
+    progressReportIntervalMs: 60000
+    milestonePercentages: [25, 50, 75, 100]
+    questionTimeoutMs: 300000
+${techParts.length > 0 ? `
+techStack:
+${frontend ? `  frontend: "${frontend}"
+` : ""}${uiLibrary ? `  uiLibrary: "${uiLibrary}"
+` : ""}${backend ? `  backend: "${backend}"
+` : ""}${database ? `  database: "${database}"
+` : ""}${otherTech ? `  other: "${otherTech}"
+` : ""}` : ""}`;
+      const maestroYamlPath = path2.resolve("maestro.yaml");
+      if (fs.existsSync(maestroYamlPath)) {
+        const overwrite = await ask(rl, `  ${chalk.yellow("maestro.yaml already exists. Overwrite? (y/n)")}`, "n");
+        if (overwrite.toLowerCase() === "y") {
+          fs.writeFileSync(maestroYamlPath, configContent, "utf-8");
+          console.log(`  ${chalk.green(figures.tick)} Updated ${chalk.bold("maestro.yaml")}`);
+        } else {
+          console.log(chalk.dim("  Skipping maestro.yaml"));
+        }
+      } else {
+        fs.writeFileSync(maestroYamlPath, configContent, "utf-8");
+        console.log(`  ${chalk.green(figures.tick)} Created ${chalk.bold("maestro.yaml")}`);
+      }
+      const dirs = [
+        ".maestro",
+        ".maestro/messages",
+        ".maestro/logs",
+        ".maestro/sessions"
+      ];
+      for (const dir of dirs) {
+        const dirPath = path2.resolve(dir);
+        if (!fs.existsSync(dirPath)) {
+          fs.mkdirSync(dirPath, { recursive: true });
+          console.log(`  ${chalk.green(figures.tick)} Created ${chalk.bold(dir + "/")}`);
+        }
+      }
+      const gitignorePath = path2.resolve(".maestro/.gitignore");
+      if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, `logs/
+sessions/
+stop
+`, "utf-8");
+        console.log(`  ${chalk.green(figures.tick)} Created ${chalk.bold(".maestro/.gitignore")}`);
+      }
+      const techStackConfig = techParts.length > 0 ? {
+        frontend: frontend || void 0,
+        uiLibrary: uiLibrary || void 0,
+        backend: backend || void 0,
+        database: database || void 0,
+        other: otherTech || void 0
+      } : void 0;
+      const agentsDir = path2.resolve(".agents");
+      if (!fs.existsSync(agentsDir)) {
+        fs.mkdirSync(agentsDir, { recursive: true });
+        console.log(`  ${chalk.green(figures.tick)} Created ${chalk.bold(".agents/")}`);
+      }
+      const roles = ["orchestrator", "project-manager", "architect", "developer", "designer", "qa-engineer", "devops", "technical-writer", "code-reviewer"];
+      let createdPromptCount = 0;
+      for (const role of roles) {
+        const promptPath = path2.resolve(agentsDir, `${role}.md`);
+        if (!fs.existsSync(promptPath)) {
+          const prompt = getDefaultSystemPrompt({
+            role,
+            agentId: "{{agentId}}",
+            projectName: "{{projectName}}",
+            todoFilePath: "{{todoFilePath}}",
+            inboxPath: "{{inboxPath}}",
+            outboxPath: "{{outboxPath}}",
+            workingDirectory: "{{workingDirectory}}",
+            techStack: techStackConfig
+          });
+          const header = [
+            `<!-- Maestro Agent Prompt: ${role} -->`,
+            `<!-- Edit this file to customise the ${role} agent's behaviour. -->`,
+            `<!-- Delete this file to fall back to the built-in default prompt. -->`,
+            ""
+          ].join("\n");
+          fs.writeFileSync(promptPath, header + prompt + "\n", "utf-8");
+          createdPromptCount++;
+        }
+      }
+      if (createdPromptCount > 0) {
+        console.log(`  ${chalk.green(figures.tick)} Created ${createdPromptCount} agent prompt files in ${chalk.bold(".agents/")}`);
+      }
+      const todoPath = path2.resolve("todo.md");
+      const hasExistingTodo = fs.existsSync(todoPath);
+      let existingTasks = [];
+      if (hasExistingTodo) {
+        const parser = new TaskParser();
+        const existing = parser.parse(fs.readFileSync(todoPath, "utf-8"));
+        existingTasks = existing.tasks;
+        console.log(chalk.cyan(`  ${figures.info} Found existing ${chalk.bold("todo.md")} with ${existingTasks.length} tasks`));
+        const doneTasks = existingTasks.filter((t) => t.status === "done").length;
+        const inProgress = existingTasks.filter((t) => t.status === "in-progress").length;
+        const pending = existingTasks.filter((t) => t.status === "pending").length;
+        console.log(chalk.dim(`    ${doneTasks} done, ${inProgress} in-progress, ${pending} pending`));
+        console.log();
+      }
+      if (options.plan) {
+        console.log();
+        const planner = new Planner({
+          model: options.model,
+          workingDirectory: process.cwd(),
+          techStack: techStackConfig
+        });
+        let planGoal = "";
+        if (instructionsContent) {
+          planGoal = instructionsContent;
+          if (description) {
+            planGoal = `${description}
+
+--- Detailed Instructions ---
+${instructionsContent}`;
+          }
+        } else {
+          planGoal = description || `Set up and develop ${projectName}`;
+        }
+        if (detected.hasExistingCode) {
+          planGoal += `
+
+This is an existing ${detected.type} project. Found config files: ${detected.configFiles.join(", ")}.`;
+          planGoal += `
+Build on the existing codebase rather than creating from scratch.`;
+        }
+        if (existingTasks.length > 0) {
+          planGoal += `
+
+EXISTING TASKS (do NOT duplicate these \u2014 only create NEW tasks for work not already covered):`;
+          for (const t of existingTasks) {
+            planGoal += `
+- [${t.status}] ${t.id}: ${t.title}`;
+          }
+        }
+        const spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+        let spinnerIndex = 0;
+        let spinnerActive = true;
+        const spinnerInterval = setInterval(() => {
+          if (!spinnerActive) return;
+          const frame = chalk.cyan(spinnerFrames[spinnerIndex]);
+          process.stdout.write(`\r  ${frame} ${chalk.dim("Planning tasks with Claude...")}`);
+          spinnerIndex = (spinnerIndex + 1) % spinnerFrames.length;
+        }, 80);
+        try {
+          const plannedTasks = await planner.decompose(planGoal);
+          spinnerActive = false;
+          clearInterval(spinnerInterval);
+          process.stdout.write("\r  " + chalk.green(figures.tick) + " " + chalk.dim("Planning tasks with Claude... done") + "\n");
+          let maxExistingNum = 0;
+          for (const t of existingTasks) {
+            const match = t.id.match(/^T-(\d+)$/);
+            if (match) {
+              maxExistingNum = Math.max(maxExistingNum, parseInt(match[1], 10));
+            }
+          }
+          resetTaskCounter(maxExistingNum);
+          const titleToId = /* @__PURE__ */ new Map();
+          for (const t of existingTasks) {
+            titleToId.set(t.title, t.id);
+          }
+          const newTasks = [];
+          for (const planned of plannedTasks) {
+            const task = plannedToTask(planned);
+            task.dependencies = planned.dependencies.map((depTitle) => titleToId.get(depTitle)).filter((id) => id != null);
+            titleToId.set(planned.title, task.id);
+            newTasks.push(task);
+          }
+          const allTasks = [...existingTasks, ...newTasks];
+          const writer = new TaskWriter();
+          const todoContent = writer.write(projectName, allTasks);
+          fs.writeFileSync(todoPath, todoContent, "utf-8");
+          if (existingTasks.length > 0) {
+            console.log(
+              chalk.green(`  ${figures.tick} Updated ${chalk.bold("todo.md")}: ${existingTasks.length} existing + ${newTasks.length} new tasks`)
+            );
+          } else {
+            console.log(
+              chalk.green(`  ${figures.tick} Created ${chalk.bold("todo.md")} with ${newTasks.length} planned tasks`)
+            );
+          }
+          console.log();
+          if (newTasks.length > 0) {
+            if (existingTasks.length > 0) {
+              console.log(chalk.dim("  New tasks:"));
+            }
+            for (const task of newTasks) {
+              const priorityColor = task.priority === "critical" ? chalk.red : task.priority === "high" ? chalk.yellow : task.priority === "medium" ? chalk.cyan : chalk.dim;
+              console.log(
+                `    ${priorityColor(task.id)} ${task.title}`
+              );
+            }
+          }
+        } catch (err) {
+          spinnerActive = false;
+          clearInterval(spinnerInterval);
+          process.stdout.write("\r  " + chalk.yellow(figures.warning) + " " + chalk.dim("Planning tasks with Claude... failed") + "\n");
+          console.log(
+            chalk.yellow(
+              `  ${figures.warning} Planning failed: ${err.message}`
+            )
+          );
+          if (!hasExistingTodo) {
+            console.log(chalk.dim("  Creating empty todo.md instead"));
+            writeEmptyTodo(todoPath, projectName);
+          } else {
+            console.log(chalk.dim("  Keeping existing todo.md unchanged"));
+          }
+        }
+      } else if (!hasExistingTodo) {
+        writeEmptyTodo(todoPath, projectName);
+      } else {
+        console.log(chalk.dim(`  Keeping existing ${chalk.bold("todo.md")} (${existingTasks.length} tasks)`));
+      }
+      console.log();
+      console.log(chalk.green("  Project initialized successfully!"));
+      console.log();
+      console.log(chalk.bold("  Process Safety"));
+      console.log();
+      console.log(chalk.dim("  Agents share your machine's CPU and memory. To keep things stable,"));
+      console.log(chalk.dim("  they follow built-in process safety rules:"));
+      console.log();
+      console.log(`  ${chalk.green(figures.tick)} ${chalk.white("Agents will")}:`);
+      console.log(chalk.dim("    - Write production code, tests, configs, docs, and infrastructure files"));
+      console.log(chalk.dim("    - Run lightweight commands (linters, type-checks on single files)"));
+      console.log(chalk.dim("    - Run targeted test files (a single spec, not the full suite)"));
+      console.log(chalk.dim("    - Install individual packages (e.g. npm install <pkg>)"));
+      console.log();
+      console.log(`  ${chalk.red(figures.cross)} ${chalk.white("Agents will not")}:`);
+      console.log(chalk.dim("    - Run builds (npm run build, cargo build, make, etc.)"));
+      console.log(chalk.dim("    - Run Docker commands (docker build, docker compose up, etc.)"));
+      console.log(chalk.dim("    - Start dev servers (npm run dev, npm start, flask run, etc.)"));
+      console.log(chalk.dim("    - Run full dependency installs (npm install with no args)"));
+      console.log(chalk.dim("    - Run full test suites (npm test, pytest with no args)"));
+      console.log();
+      console.log(`  ${chalk.cyan(figures.info)} ${chalk.white("You handle")}:`);
+      console.log(chalk.dim("    - Building the project when agents finish writing code"));
+      console.log(chalk.dim("    - Running Docker and starting dev servers"));
+      console.log(chalk.dim("    - Running full test suites and CI pipelines"));
+      console.log(chalk.dim("    - Reviewing and approving agent plans (in supervised mode)"));
+      console.log();
+      console.log(chalk.dim(`  Want full autonomy? Edit the process safety section in ${chalk.bold(".agents/*.md")}`));
+      console.log(chalk.dim(`  to loosen or remove these restrictions per role.`));
+      console.log();
+      console.log(`  Next steps:`);
+      console.log(`    1. Review ${chalk.bold("todo.md")} and edit tasks if needed`);
+      console.log(`    2. Edit ${chalk.bold("maestro.yaml")} to adjust agents and settings`);
+      console.log(`    3. Customize agent prompts in ${chalk.bold(".agents/")} (optional)`);
+      console.log(`    4. Run ${chalk.bold("maestro start")} to begin`);
+      if (instructionsContent) {
+        console.log();
+        console.log(chalk.dim(`  Instructions from ${chalk.bold(options.instructions)} were used for task planning.`));
+      }
+      console.log();
+    } finally {
+      rl.close();
+    }
+  });
+}
+function writeEmptyTodo(todoPath, projectName) {
+  if (!fs.existsSync(todoPath)) {
+    const writer = new TaskWriter();
+    const todoContent = writer.write(projectName, []);
+    fs.writeFileSync(todoPath, todoContent, "utf-8");
+    console.log(`  ${chalk.green(figures.tick)} Created ${chalk.bold("todo.md")}`);
+  }
+}
+
+// src/commands/start.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+import chalk2 from "chalk";
+import figures2 from "figures";
+import {
+  loadProjectConfig,
+  WorkspaceManager,
+  Orchestrator
+} from "@maestroai/core";
+
+// src/logging/file-logger.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+var FileLogger = class {
+  logsDir;
+  streams = /* @__PURE__ */ new Map();
+  constructor(logsDir) {
+    this.logsDir = logsDir;
+    fs2.mkdirSync(this.logsDir, { recursive: true });
+  }
+  /**
+   * Attach to an orchestrator and start logging all agent output.
+   */
+  attach(orchestrator) {
+    orchestrator.on("agent:output", (event) => {
+      this.writeEvent(event);
+    });
+    orchestrator.on("agent:spawned", (state) => {
+      const agentId = state.config.id;
+      this.writeLine(
+        agentId,
+        `[system] Agent spawned: ${state.config.name} (${state.config.role})`
+      );
+    });
+    orchestrator.on("agent:status-changed", (agentId, oldStatus, newStatus) => {
+      this.writeLine(agentId, `[system] Status: ${oldStatus} -> ${newStatus}`);
+    });
+    orchestrator.on("agent:error", (agentId, error) => {
+      this.writeLine(agentId, `[error] ${error.message}`);
+    });
+    orchestrator.on("agent:stopped", (agentId, exitCode) => {
+      this.writeLine(
+        agentId,
+        `[system] Agent stopped (exit code: ${exitCode})`
+      );
+      this.closeStream(agentId);
+    });
+  }
+  /**
+   * Close all open log streams.
+   */
+  close() {
+    for (const [agentId] of this.streams) {
+      this.closeStream(agentId);
+    }
+  }
+  writeEvent(event) {
+    this.writeLine(event.agentId, `[${event.type}] ${JSON.stringify(event.data)}`);
+  }
+  writeLine(agentId, line) {
+    const stream = this.getOrCreateStream(agentId);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    stream.write(`${timestamp} ${line}
+`);
+  }
+  getOrCreateStream(agentId) {
+    let stream = this.streams.get(agentId);
+    if (!stream) {
+      const logFile = path3.join(this.logsDir, `${agentId}.log`);
+      stream = fs2.createWriteStream(logFile, { flags: "a" });
+      this.streams.set(agentId, stream);
+    }
+    return stream;
+  }
+  closeStream(agentId) {
+    const stream = this.streams.get(agentId);
+    if (stream) {
+      stream.end();
+      this.streams.delete(agentId);
+    }
+  }
+};
+
+// src/commands/start.ts
+function truncate(str, max) {
+  return str.length > max ? str.slice(0, max - 3) + "..." : str;
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+function registerStartCommand(program) {
+  program.command("start").description("Start the Maestro orchestrator").option("-c, --config <path>", "path to maestro.yaml", "./maestro.yaml").option("-d, --dir <path>", "working directory for project context", ".").option("--no-tui", "run without TUI (log to console)").option("-m, --mode <mode>", "interaction mode (unattended, supervised, interactive)", "supervised").option("-v, --verbose", "show detailed agent output including tool calls", false).action(async (options) => {
+    if (options.dir && options.dir !== ".") {
+      try {
+        process.chdir(path4.resolve(options.dir));
+        console.log(chalk2.dim(`  Working directory changed to: ${process.cwd()}`));
+      } catch (err) {
+        console.error(
+          chalk2.red(`${figures2.cross} Failed to change directory: ${err.message}`)
+        );
+        process.exit(1);
+      }
+    }
+    const configPath = path4.resolve(options.config);
+    if (!fs3.existsSync(configPath)) {
+      console.error(
+        chalk2.red(`${figures2.cross} Config file not found: ${configPath}`)
+      );
+      console.error(
+        chalk2.dim(`  Run ${chalk2.bold("maestro init")} to create one.`)
+      );
+      process.exit(1);
+    }
+    const stopFilePath = path4.resolve(".maestro/stop");
+    if (fs3.existsSync(stopFilePath)) {
+      fs3.unlinkSync(stopFilePath);
+    }
+    let projectConfig;
+    try {
+      projectConfig = await loadProjectConfig(configPath);
+    } catch (err) {
+      console.error(
+        chalk2.red(`${figures2.cross} Failed to load config: ${err.message}`)
+      );
+      process.exit(1);
+    }
+    if (options.mode) {
+      projectConfig.settings.feedback = {
+        progressReportIntervalMs: 6e4,
+        milestonePercentages: [25, 50, 75, 100],
+        questionTimeoutMs: 3e5,
+        requirePlanApproval: true,
+        ...projectConfig.settings.feedback,
+        interactionMode: options.mode
+      };
+    }
+    const workspace = new WorkspaceManager(process.cwd());
+    await workspace.initialize(projectConfig);
+    const orchestrator = new Orchestrator(projectConfig);
+    const fileLogger = new FileLogger(
+      projectConfig.settings.logsDirectory || ".maestro/logs"
+    );
+    fileLogger.attach(orchestrator);
+    let shuttingDown = false;
+    const SHUTDOWN_TIMEOUT_MS = 15e3;
+    const shutdown = async (signal) => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      clearInterval(stopWatcher);
+      if (!options.tui) {
+        console.log();
+        console.log(
+          chalk2.yellow(`${figures2.warning} Received ${signal}, shutting down gracefully...`)
+        );
+      }
+      const forceExitTimer = setTimeout(() => {
+        if (!options.tui) {
+          console.log(
+            chalk2.red(`${figures2.cross} Shutdown timed out, forcing exit`)
+          );
+        }
+        process.exit(1);
+      }, SHUTDOWN_TIMEOUT_MS);
+      forceExitTimer.unref();
+      try {
+        await orchestrator.stop();
+      } catch {
+      }
+      fileLogger.close();
+      clearTimeout(forceExitTimer);
+      process.exit(0);
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    const stopWatcher = setInterval(() => {
+      if (fs3.existsSync(stopFilePath)) {
+        clearInterval(stopWatcher);
+        shutdown("stop-file");
+      }
+    }, 1e3);
+    stopWatcher.unref();
+    if (options.tui) {
+      const { renderApp } = await import("./src/tui/App.js");
+      renderApp(orchestrator, projectConfig);
+      await orchestrator.start();
+    } else {
+      console.log();
+      console.log(chalk2.bold("  MAESTRO") + ` - ${projectConfig.name}`);
+      console.log(chalk2.dim(`  ${projectConfig.description}`));
+      console.log();
+      const agentNameMap = /* @__PURE__ */ new Map();
+      orchestrator.on("agent:spawned", (state) => {
+        agentNameMap.set(state.config.id, state.config.name);
+        const pid = state.pid ? ` (PID ${state.pid})` : "";
+        console.log(
+          chalk2.green(`${figures2.play} Agent spawned: ${state.config.name} [${state.config.role}]${pid}`)
+        );
+        console.log(
+          chalk2.dim(`  model: ${state.config.model ?? "default"} | mode: ${state.config.permissionMode}`)
+        );
+      });
+      orchestrator.on("agent:status-changed", (agentId, _oldStatus, newStatus) => {
+        const name = agentNameMap.get(agentId) ?? agentId;
+        const color = newStatus === "running" ? chalk2.green : newStatus === "error" ? chalk2.red : chalk2.yellow;
+        console.log(color(`${figures2.pointer} ${name}: ${newStatus}`));
+      });
+      orchestrator.on("agent:output", (event) => {
+        const displayName = agentNameMap.get(event.agentId) ?? event.agentId;
+        const prefix = chalk2.dim(`  [${displayName}]`);
+        if (event.type === "user") {
+          const message = event.data.message;
+          if (message && typeof message === "object" && Array.isArray(message.content)) {
+            for (const block of message.content) {
+              if (block.type !== "tool_result") continue;
+              let resultText = "";
+              if (typeof block.content === "string") {
+                resultText = block.content.trim();
+              } else if (Array.isArray(block.content)) {
+                resultText = block.content.filter((s) => s.type === "text" && typeof s.text === "string").map((s) => s.text.trim()).join(" ");
+              }
+              if (resultText) {
+                const firstLine = resultText.split("\n")[0];
+                console.log(`${prefix} ${chalk2.dim(truncate(firstLine, 150))}`);
+              }
+            }
+          }
+          return;
+        }
+        if (event.type === "assistant") {
+          let text = "";
+          const message = event.data.message;
+          if (message && typeof message === "object" && Array.isArray(message.content)) {
+            text = message.content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("");
+          } else if (typeof event.data.content === "string") {
+            text = event.data.content;
+          } else if (typeof message === "string") {
+            text = message;
+          }
+          if (text) {
+            for (const line of text.split("\n")) {
+              console.log(`${prefix} ${line}`);
+            }
+          }
+        } else if (event.type === "result") {
+          const cost = typeof event.data.cost_usd === "number" ? `$${event.data.cost_usd.toFixed(4)}` : "";
+          const turns = typeof event.data.num_turns === "number" ? `${event.data.num_turns} turns` : "";
+          const usage = event.data.usage;
+          let usageStr = "";
+          if (usage && typeof usage === "object") {
+            const parts = [];
+            if (typeof usage.input_tokens === "number") parts.push(`in:${usage.input_tokens}`);
+            if (typeof usage.output_tokens === "number") parts.push(`out:${usage.output_tokens}`);
+            if (typeof usage.cache_read_input_tokens === "number" && usage.cache_read_input_tokens > 0) {
+              parts.push(`cache:${usage.cache_read_input_tokens}`);
+            }
+            if (parts.length > 0) usageStr = parts.join(" ");
+          }
+          console.log(`${prefix} ${chalk2.green("done")} ${[cost, turns, usageStr].filter(Boolean).join(" | ")}`);
+        } else if (event.type === "error") {
+          const msg = event.data.error ?? JSON.stringify(event.data);
+          console.log(`${prefix} ${chalk2.red(`error: ${msg}`)}`);
+        } else if (options.verbose) {
+          if (event.type === "tool_use") {
+            const toolName = event.data.tool ?? event.data.name ?? "tool";
+            console.log(`${prefix} ${chalk2.cyan(`[${toolName}]`)} ${chalk2.dim(truncate(JSON.stringify(event.data.input ?? ""), 120))}`);
+          } else if (event.type === "system") {
+            const msg = event.data.message ?? "";
+            if (msg) console.log(`${prefix} ${chalk2.dim(msg)}`);
+          }
+        }
+      });
+      orchestrator.on("task:assigned", (task, agentId) => {
+        const name = agentNameMap.get(agentId) ?? agentId;
+        console.log(
+          chalk2.blue(`${figures2.pointer} Task assigned: ${task.id} "${task.title}" \u2192 ${name}`)
+        );
+      });
+      orchestrator.on("task:completed", (task) => {
+        console.log(
+          chalk2.green(`${figures2.tick} Task completed: ${task.title}`)
+        );
+      });
+      orchestrator.on("orchestrator:cycle", (stats) => {
+        const sorted = [...stats.agents].sort((a, b) => {
+          const rank = (agent) => {
+            if (agent.status === "running" || agent.status === "starting") return 0;
+            if (agent.spawned && agent.status === "idle") return 1;
+            if (agent.status === "error") return 2;
+            if (!agent.spawned) return 4;
+            return 3;
+          };
+          return rank(a) - rank(b);
+        });
+        const agentTags = sorted.map((a) => {
+          const label = a.name;
+          if (a.status === "running" || a.status === "starting") {
+            return chalk2.green.bold(label);
+          } else if (a.status === "error") {
+            return chalk2.red(label);
+          } else if (!a.spawned) {
+            return chalk2.gray(`${label} (Standby)`);
+          } else if (a.status === "stopped") {
+            return chalk2.dim(label);
+          }
+          return chalk2.yellow(label);
+        });
+        const totalTokens = stats.totalInputTokens + stats.totalOutputTokens + stats.totalCacheReadTokens + stats.totalCacheCreationTokens;
+        const tokenStr = totalTokens > 0 ? ` | tokens: ${totalTokens.toLocaleString()}` : "";
+        console.log(
+          chalk2.dim(`  [cycle] tasks: ${stats.completedTasks}/${stats.totalTasks} | cost: $${stats.totalCostUsd.toFixed(4)}${tokenStr}`)
+        );
+        console.log(
+          chalk2.dim("  agents: ") + agentTags.join(chalk2.dim(" | "))
+        );
+      });
+      orchestrator.on("rate-limit", (agentId, resetAt) => {
+        const name = agentNameMap.get(agentId) ?? agentId;
+        const resetInfo = resetAt ? ` Resets at ${resetAt}.` : "";
+        console.log(
+          chalk2.red.bold(`${figures2.warning} RATE LIMIT: Agent ${name} hit API usage limit.${resetInfo}`)
+        );
+      });
+      orchestrator.on("plan:proposed", (proposal) => {
+        console.log(chalk2.cyan(`
+${figures2.info} Plan proposed with ${proposal.tasks.length} tasks:`));
+        for (const task of proposal.tasks) {
+          console.log(chalk2.dim(`  - [${task.priority}] ${task.title}`));
+        }
+        orchestrator.decidePlan(proposal.id, "approved");
+        console.log(chalk2.green(`${figures2.tick} Plan auto-approved (non-TUI mode)`));
+      });
+      orchestrator.on("architecture:ready", (archTasks) => {
+        console.log();
+        console.log(chalk2.bold.cyan(`${figures2.info} Architecture phase complete!`));
+        console.log(chalk2.dim("  Review ARCHITECTURE.md and architecture-related files."));
+        console.log(chalk2.dim("  Completed architecture tasks:"));
+        for (const task of archTasks) {
+          console.log(chalk2.dim(`    - ${task.title}`));
+        }
+        orchestrator.approveArchitecture();
+        console.log(chalk2.green(`${figures2.tick} Architecture auto-approved, advancing to development`));
+      });
+      orchestrator.on("phase:changed", (phase) => {
+        console.log(chalk2.cyan(`${figures2.pointer} Phase: ${phase}`));
+      });
+      orchestrator.on("question:asked", (question) => {
+        console.log(chalk2.yellow(`
+${figures2.warning} Agent ${question.fromAgent} asks: ${question.question}`));
+        if (question.options) {
+          question.options.forEach((opt, i) => console.log(chalk2.dim(`  ${i + 1}. ${opt}`)));
+        }
+        console.log(chalk2.dim("  (auto-skipping in non-TUI mode)"));
+      });
+      orchestrator.on("orchestrator:activity", (activity) => {
+        const kindColors = {
+          "task-delegated": chalk2.cyan,
+          "task-completed": chalk2.green,
+          "task-blocked": chalk2.red,
+          "task-failed": chalk2.red,
+          "agent-spawned": chalk2.green,
+          "agent-stopped": chalk2.gray,
+          "agent-error": chalk2.red,
+          "phase-changed": chalk2.magenta,
+          "pipeline-handoff": chalk2.yellow,
+          "plan-created": chalk2.blue,
+          "plan-approved": chalk2.green,
+          "plan-rejected": chalk2.red,
+          "project-completed": chalk2.green,
+          "info": chalk2.blue
+        };
+        const color = kindColors[activity.kind] ?? chalk2.dim;
+        const time = new Date(activity.timestamp).toLocaleTimeString("en-US", {
+          hour12: false,
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit"
+        });
+        console.log(
+          chalk2.yellow(`  [Orchestrator]`) + chalk2.dim(` ${time} `) + color(activity.message)
+        );
+      });
+      orchestrator.on("progress:report", (report) => {
+        console.log(chalk2.cyan(`  [progress] ${report.percentComplete.toFixed(0)}% | phase: ${report.phase} | ${report.completedTasks}/${report.totalTasks} tasks`));
+      });
+      orchestrator.on("milestone:reached", (milestone) => {
+        console.log(chalk2.bold.green(`
+${figures2.star} Milestone: ${milestone.name} - ${milestone.message}`));
+        orchestrator.acknowledgeMilestone(milestone.id);
+      });
+      orchestrator.on("project:completed", (summary) => {
+        const totalTokens = summary.totalInputTokens + summary.totalOutputTokens + summary.totalCacheReadTokens + summary.totalCacheCreationTokens;
+        console.log();
+        console.log(chalk2.bold.green("=".repeat(60)));
+        console.log(chalk2.bold.green(`  ${figures2.star} PROJECT COMPLETED ${figures2.star}`));
+        console.log(chalk2.bold.green("=".repeat(60)));
+        console.log();
+        console.log(chalk2.bold("  Tasks"));
+        console.log(`    Completed:  ${chalk2.green(String(summary.doneTasks))} / ${summary.totalTasks}`);
+        if (summary.cancelledTasks > 0) {
+          console.log(`    Cancelled:  ${chalk2.yellow(String(summary.cancelledTasks))}`);
+        }
+        console.log();
+        console.log(chalk2.bold("  Usage"));
+        console.log(`    Cost:       ${chalk2.cyan("$" + summary.totalCostUsd.toFixed(4))}`);
+        if (totalTokens > 0) {
+          console.log(`    Tokens:     ${totalTokens.toLocaleString()} total`);
+          console.log(`                ${chalk2.dim(`in: ${summary.totalInputTokens.toLocaleString()} | out: ${summary.totalOutputTokens.toLocaleString()} | cache-read: ${summary.totalCacheReadTokens.toLocaleString()} | cache-write: ${summary.totalCacheCreationTokens.toLocaleString()}`)}`);
+        }
+        console.log(`    Duration:   ${formatDuration(summary.uptimeMs)}`);
+        console.log();
+        const activeAgents = summary.agentSummaries.filter((a) => a.tasksCompleted > 0);
+        if (activeAgents.length > 0) {
+          console.log(chalk2.bold("  Agent Breakdown"));
+          for (const agent of activeAgents) {
+            const agentTokens = agent.inputTokens + agent.outputTokens;
+            const tokenInfo = agentTokens > 0 ? `, ${agentTokens.toLocaleString()} tokens` : "";
+            console.log(
+              `    ${agent.name} ${chalk2.dim(`(${agent.role})`)}: ${agent.tasksCompleted} tasks, $${agent.costUsd.toFixed(4)}${tokenInfo}`
+            );
+          }
+          console.log();
+        }
+        console.log(chalk2.bold("  Next Steps"));
+        console.log(`    ${figures2.arrowRight} Review the completed work in your project directory`);
+        console.log(`    ${figures2.arrowRight} Run your test suite to verify the changes`);
+        console.log(`    ${figures2.arrowRight} Check git diff to review all modifications`);
+        console.log(`    ${figures2.arrowRight} Commit and push when ready`);
+        console.log();
+        console.log(chalk2.dim("  " + "=".repeat(56)));
+        console.log();
+      });
+      await orchestrator.start();
+      console.log(
+        chalk2.green(`${figures2.tick} Orchestrator started`)
+      );
+    }
+  });
+}
+
+// src/commands/status.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+import chalk3 from "chalk";
+import figures3 from "figures";
+function parseTodoFile(content) {
+  const counts = {
+    pending: 0,
+    inProgress: 0,
+    done: 0,
+    blocked: 0,
+    cancelled: 0,
+    total: 0
+  };
+  const lines = content.split("\n");
+  let currentSection = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("## ")) {
+      const heading = trimmed.slice(3).trim().toLowerCase();
+      if (heading.includes("pending")) currentSection = "pending";
+      else if (heading.includes("in progress") || heading.includes("in-progress"))
+        currentSection = "in-progress";
+      else if (heading.includes("done") || heading.includes("completed"))
+        currentSection = "done";
+      else if (heading.includes("blocked")) currentSection = "blocked";
+      else if (heading.includes("cancelled") || heading.includes("canceled"))
+        currentSection = "cancelled";
+      continue;
+    }
+    if (trimmed.startsWith("- ") || trimmed.startsWith("* ")) {
+      counts.total++;
+      switch (currentSection) {
+        case "pending":
+          counts.pending++;
+          break;
+        case "in-progress":
+          counts.inProgress++;
+          break;
+        case "done":
+          counts.done++;
+          break;
+        case "blocked":
+          counts.blocked++;
+          break;
+        case "cancelled":
+          counts.cancelled++;
+          break;
+        default:
+          if (trimmed.includes("[x]") || trimmed.includes("[X]")) {
+            counts.done++;
+          } else {
+            counts.pending++;
+          }
+          break;
+      }
+    }
+  }
+  return counts;
+}
+function registerStatusCommand(program) {
+  program.command("status").description("Show current project status").option("-c, --config <path>", "path to maestro.yaml", "./maestro.yaml").action(async (options) => {
+    const todoPath = path5.resolve("todo.md");
+    const stopFilePath = path5.resolve(".maestro/stop");
+    const isRunning = !fs4.existsSync(stopFilePath) && fs4.existsSync(path5.resolve(".maestro"));
+    console.log();
+    console.log(chalk3.bold("  MAESTRO") + " - Project Status");
+    console.log();
+    console.log(
+      `  Orchestrator: ${isRunning ? chalk3.green("possibly running") : chalk3.dim("stopped")}`
+    );
+    console.log();
+    if (!fs4.existsSync(todoPath)) {
+      console.log(chalk3.yellow(`  ${figures3.warning} No todo.md found`));
+      console.log(chalk3.dim(`  Run ${chalk3.bold("maestro init")} to set up your project.`));
+      console.log();
+      return;
+    }
+    const content = fs4.readFileSync(todoPath, "utf-8");
+    const counts = parseTodoFile(content);
+    if (counts.total === 0) {
+      console.log(chalk3.dim("  No tasks found in todo.md"));
+      console.log();
+      return;
+    }
+    const barWidth = 30;
+    const doneRatio = counts.done / counts.total;
+    const filledWidth = Math.round(doneRatio * barWidth);
+    const bar = chalk3.green("\u2588".repeat(filledWidth)) + chalk3.dim("\u2591".repeat(barWidth - filledWidth));
+    console.log(`  Progress: ${bar} ${Math.round(doneRatio * 100)}%`);
+    console.log();
+    console.log(`  ${chalk3.green(figures3.tick)} Done:        ${counts.done}`);
+    console.log(`  ${chalk3.yellow(figures3.play)} In Progress: ${counts.inProgress}`);
+    console.log(`  ${chalk3.dim(figures3.circle)} Pending:     ${counts.pending}`);
+    if (counts.blocked > 0) {
+      console.log(`  ${chalk3.red(figures3.cross)} Blocked:     ${counts.blocked}`);
+    }
+    if (counts.cancelled > 0) {
+      console.log(`  ${chalk3.dim(figures3.cross)} Cancelled:   ${counts.cancelled}`);
+    }
+    console.log(`  ${"\u2500".repeat(28)}`);
+    console.log(`  Total:                ${counts.total}`);
+    console.log();
+  });
+}
+
+// src/commands/stop.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+import chalk4 from "chalk";
+import figures4 from "figures";
+function registerStopCommand(program) {
+  program.command("stop").description("Stop the running Maestro orchestrator").action(async () => {
+    const maestroDir = path6.resolve(".maestro");
+    const stopFilePath = path6.resolve(".maestro/stop");
+    if (!fs5.existsSync(maestroDir)) {
+      console.error(
+        chalk4.red(
+          `${figures4.cross} No .maestro directory found. Is this a Maestro project?`
+        )
+      );
+      process.exit(1);
+    }
+    if (fs5.existsSync(stopFilePath)) {
+      console.log(
+        chalk4.yellow(`${figures4.warning} Stop signal already sent.`)
+      );
+      return;
+    }
+    fs5.writeFileSync(stopFilePath, (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
+    console.log(
+      chalk4.green(
+        `${figures4.tick} Stop signal sent. The orchestrator will shut down gracefully.`
+      )
+    );
+  });
+}
+
+// src/index.ts
+function createProgram() {
+  const program = new Command();
+  program.name("maestro").description("Orchestrate multiple Claude Code agents working as a team").version("0.1.0");
+  registerInitCommand(program);
+  registerStartCommand(program);
+  registerStatusCommand(program);
+  registerStopCommand(program);
+  return program;
+}
+
+export {
+  createProgram
+};
+//# sourceMappingURL=chunk-5ZDNPLKN.js.map