@pasajero_0/agent-stack 0.1.0

package/dist/index.js

@@ -0,0 +1,683 @@
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { checkbox, input, confirm } from "@inquirer/prompts";
+import chalk2 from "chalk";
+
+// src/detect/project.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+async function detectProject(dir) {
+  const hasPackageJson = existsSync(join(dir, "package.json"));
+  const hasSrcDir = existsSync(join(dir, "src"));
+  const hasGitRepo = existsSync(join(dir, ".git"));
+  const isExistingProject = hasPackageJson || hasSrcDir || hasGitRepo;
+  let projectName;
+  if (hasPackageJson) {
+    try {
+      const raw = await readFile(join(dir, "package.json"), "utf-8");
+      const pkg = JSON.parse(raw);
+      projectName = pkg.name;
+    } catch {
+    }
+  }
+  return {
+    isExistingProject,
+    hasPackageJson,
+    hasSrcDir,
+    hasGitRepo,
+    projectName,
+    scenario: isExistingProject ? "existing" : "empty"
+  };
+}
+
+// src/claude/provider.ts
+import { homedir } from "node:os";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/utils/shell.ts
+import { execa } from "execa";
+async function commandExists(cmd) {
+  try {
+    await execa("which", [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function run(cmd, args, options) {
+  const result = await execa(cmd, args, {
+    cwd: options?.cwd,
+    env: options?.env,
+    reject: false
+  });
+  return {
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode ?? 1
+  };
+}
+async function runSilent(cmd, args) {
+  const result = await execa(cmd, args, { reject: false });
+  return { stdout: result.stdout, exitCode: result.exitCode ?? 1 };
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var log = {
+  info: (msg) => console.log(chalk.blue("\u2139"), msg),
+  success: (msg) => console.log(chalk.green("\u2714"), msg),
+  warn: (msg) => console.log(chalk.yellow("\u26A0"), msg),
+  error: (msg) => console.error(chalk.red("\u2716"), msg),
+  step: (msg) => console.log(chalk.cyan("\u2192"), msg),
+  dim: (msg) => console.log(chalk.dim(msg))
+};
+function spinner(text) {
+  return ora({ text, color: "cyan" });
+}
+function banner() {
+  console.log();
+  console.log(chalk.bold.cyan("  agent-stack"));
+  console.log(chalk.dim("  AI coding environment configurator"));
+  console.log();
+}
+
+// src/claude/provider.ts
+var PROVIDER_ID = "claude-code";
+var PROVIDER_NAME = "Claude Code";
+async function detect() {
+  const home = homedir();
+  const configPaths = [join2(home, ".claude"), join2(home, ".config", "claude")];
+  const installed = await commandExists("claude");
+  let version;
+  if (installed) {
+    const result = await runSilent("claude", ["--version"]);
+    if (result.exitCode === 0) version = result.stdout.trim();
+  }
+  return {
+    name: PROVIDER_ID,
+    displayName: PROVIDER_NAME,
+    installed,
+    version,
+    configPaths: configPaths.filter((p) => existsSync2(p))
+  };
+}
+async function install() {
+  log.step("Installing Claude Code via npm...");
+  const result = await run("npm", ["install", "-g", "@anthropic-ai/claude-code"]);
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to install Claude Code: ${result.stderr}`);
+  }
+  log.success("Claude Code installed successfully");
+}
+async function configureMcp(servers, envValues) {
+  for (const server of servers) {
+    const args = ["mcp", "add", server.name, "--transport", server.transport];
+    if (server.command) args.push("--", server.command);
+    if (server.args) args.push(...server.args);
+    const env = {};
+    if (server.env) {
+      for (const key of Object.keys(server.env)) {
+        if (envValues[key]) env[key] = envValues[key];
+      }
+    }
+    const envArgs = [];
+    for (const [key, value] of Object.entries(env)) {
+      envArgs.push("-e", `${key}=${value}`);
+    }
+    const result = await run("claude", [...args, ...envArgs]);
+    if (result.exitCode !== 0) {
+      log.warn(`Failed to add MCP server "${server.name}": ${result.stderr}`);
+    } else {
+      log.success(`MCP server "${server.displayName}" configured`);
+    }
+  }
+}
+async function listMcp() {
+  const result = await runSilent("claude", ["mcp", "list"]);
+  if (result.exitCode !== 0) return [];
+  const lines = result.stdout.trim().split("\n").filter(Boolean);
+  return lines.map((line) => {
+    const parts = line.split(/\s+/);
+    return { name: parts[0] ?? line, command: parts[1] ?? "", args: parts.slice(2) };
+  });
+}
+
+// src/mcp/catalog.ts
+import { readFileSync } from "node:fs";
+import { join as join3, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+function getPackageRoot() {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join3(thisDir, "..", "mcp", "catalog.json"),
+    join3(thisDir, "..", "..", "mcp", "catalog.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      return readFileSync(candidate, "utf-8");
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Could not find mcp/catalog.json");
+}
+var catalogData = JSON.parse(getPackageRoot());
+var MCP_CATALOG = catalogData;
+
+// src/mcp/installer.ts
+async function installMcpServers(servers, envValues) {
+  const s = spinner(`Configuring MCP servers for ${PROVIDER_NAME}...`);
+  s.start();
+  try {
+    await configureMcp(servers, envValues);
+    s.succeed(`MCP servers configured for ${PROVIDER_NAME}`);
+  } catch (err) {
+    s.fail(`Failed to configure MCP for ${PROVIDER_NAME}`);
+    throw err;
+  }
+}
+
+// src/claude/harness.ts
+import { readFileSync as readFileSync2, readdirSync, statSync, existsSync as existsSync4 } from "node:fs";
+import { writeFile, mkdir, chmod } from "node:fs/promises";
+import { join as join5, dirname as dirname2, relative, basename } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/detect/harness-params.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var PM_BY_LOCKFILE = [
+  { lock: "pnpm-lock.yaml", pm: "pnpm" },
+  { lock: "yarn.lock", pm: "yarn" },
+  { lock: "bun.lockb", pm: "bun" },
+  { lock: "package-lock.json", pm: "npm" }
+];
+var ALL_PMS = ["npm", "yarn", "pnpm", "bun"];
+function detectPackageManager(dir) {
+  for (const { lock, pm } of PM_BY_LOCKFILE) {
+    if (existsSync3(join4(dir, lock))) return { packageManager: pm, lockfile: lock };
+  }
+  return { packageManager: "npm", lockfile: "package-lock.json" };
+}
+function forbiddenPmsFor(pm) {
+  return ALL_PMS.filter((p) => p !== pm).join("|");
+}
+function forgeFromRemote(remoteUrl) {
+  return /gitlab/i.test(remoteUrl) ? "glab" : "gh";
+}
+function generatedGlobsFor(dir) {
+  return existsSync3(join4(dir, "tsconfig.json")) ? "*/dist/*|dist/*|*.d.ts|*.map" : "*/dist/*|dist/*|*/build/*";
+}
+async function detectGit(dir) {
+  let mainBranch = "main";
+  let forgeCli = "gh";
+  const head = await run("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: dir });
+  const m = head.exitCode === 0 ? head.stdout.trim().match(/refs\/remotes\/origin\/(.+)$/) : null;
+  if (m) {
+    mainBranch = m[1];
+  } else {
+    const cur = await run("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: dir });
+    const branch = cur.stdout.trim();
+    if (cur.exitCode === 0 && branch && branch !== "HEAD") mainBranch = branch;
+  }
+  const remote = await run("git", ["remote", "get-url", "origin"], { cwd: dir });
+  if (remote.exitCode === 0 && remote.stdout) forgeCli = forgeFromRemote(remote.stdout);
+  return { mainBranch, forgeCli };
+}
+async function detectCommands(dir, pm) {
+  const cmds = [];
+  try {
+    const pkg = JSON.parse(await readFile2(join4(dir, "package.json"), "utf-8"));
+    const scripts = pkg.scripts ?? {};
+    for (const name of ["typecheck", "test", "build"]) {
+      if (scripts[name]) cmds.push(`${pm} ${name}`);
+    }
+  } catch {
+  }
+  return cmds;
+}
+async function detectHarnessParams(dir) {
+  const { packageManager, lockfile } = detectPackageManager(dir);
+  const { mainBranch, forgeCli } = await detectGit(dir);
+  const commands = await detectCommands(dir, packageManager);
+  return {
+    packageManager,
+    forbiddenPms: forbiddenPmsFor(packageManager),
+    lockfile,
+    generatedGlobs: generatedGlobsFor(dir),
+    docsDir: "docs/",
+    mainBranch,
+    forgeCli,
+    commands
+  };
+}
+
+// src/claude/harness.ts
+var HOOKS_BLOCK = {
+  PreToolUse: [
+    {
+      matcher: "Bash",
+      hooks: [{ type: "command", command: "$CLAUDE_PROJECT_DIR/.claude/hooks/guard-bash.sh" }]
+    },
+    {
+      matcher: "Edit|Write|MultiEdit",
+      hooks: [{ type: "command", command: "$CLAUDE_PROJECT_DIR/.claude/hooks/guard-file.sh" }]
+    }
+  ],
+  SessionStart: [
+    {
+      hooks: [
+        { type: "command", command: "$CLAUDE_PROJECT_DIR/.claude/hooks/session-start-context.sh" }
+      ]
+    }
+  ],
+  Stop: [
+    {
+      hooks: [{ type: "command", command: "$CLAUDE_PROJECT_DIR/.claude/hooks/stop-flag-reflect.sh" }]
+    }
+  ],
+  PostToolUse: [
+    {
+      matcher: "Edit|Write|MultiEdit",
+      hooks: [
+        { type: "command", command: "$CLAUDE_PROJECT_DIR/.claude/hooks/post-edit-lint.sh" },
+        { type: "command", command: "$CLAUDE_PROJECT_DIR/.claude/hooks/post-edit-verify.sh" }
+      ]
+    }
+  ]
+};
+function templatesRoot() {
+  const thisDir = dirname2(fileURLToPath2(import.meta.url));
+  const candidates = [
+    join5(thisDir, "..", "templates", "claude"),
+    // dist/index.js -> ../templates/claude
+    join5(thisDir, "..", "..", "templates", "claude")
+    // src/claude/ -> ../../templates/claude
+  ];
+  for (const c of candidates) {
+    if (existsSync4(c)) return c;
+  }
+  throw new Error("Could not find templates/claude");
+}
+function toolVersion() {
+  const thisDir = dirname2(fileURLToPath2(import.meta.url));
+  for (const c of [join5(thisDir, "..", "package.json"), join5(thisDir, "..", "..", "package.json")]) {
+    try {
+      return JSON.parse(readFileSync2(c, "utf-8")).version ?? "0.0.0";
+    } catch {
+      continue;
+    }
+  }
+  return "0.0.0";
+}
+function substitute(text, p) {
+  return text.replaceAll("{{PM}}", p.packageManager).replaceAll("{{FORBIDDEN_PM}}", p.forbiddenPms).replaceAll("{{GEN_GLOBS}}", p.generatedGlobs).replaceAll("{{LOCKFILE}}", p.lockfile).replaceAll("{{DOCS_DIR}}", p.docsDir).replaceAll("{{MAIN_BRANCH}}", p.mainBranch);
+}
+function walk(dir) {
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    const full = join5(dir, name);
+    if (statSync(full).isDirectory()) out.push(...walk(full));
+    else out.push(full);
+  }
+  return out;
+}
+function buildSettings(p) {
+  const allow = [
+    ...p.commands.map((c) => `Bash(${c}:*)`),
+    "Bash(git status:*)",
+    "Bash(git diff:*)",
+    "Bash(git log:*)",
+    "Bash(git show:*)",
+    `Bash(${p.forgeCli} api:*)`,
+    `Bash(${p.forgeCli} pr view:*)`,
+    `Bash(${p.forgeCli} pr diff:*)`,
+    "WebSearch"
+  ];
+  const settings = {
+    $schema: "https://json.schemastore.org/claude-code-settings.json",
+    permissions: { allow },
+    hooks: HOOKS_BLOCK
+  };
+  return JSON.stringify(settings, null, 2) + "\n";
+}
+function buildSettingsLocal(p) {
+  const settings = {
+    permissions: {
+      allow: ["WebSearch", `Bash(${p.forgeCli} api:*)`],
+      deny: [
+        "Read(./**/dist/**)",
+        "Read(./**/build/**)",
+        "Read(./**/coverage/**)",
+        "Read(./**/*.d.ts)",
+        "Read(./**/*.map)",
+        "Read(./**/*.gen.*)",
+        `Read(./**/${p.lockfile})`,
+        "Read(./**/node_modules/**)"
+      ]
+    }
+  };
+  return JSON.stringify(settings, null, 2) + "\n";
+}
+function buildClaudeMd(p, root) {
+  const normative = readFileSync2(join5(root, "_normative.md"), "utf-8").replace(
+    /^<!--[\s\S]*?-->\s*/,
+    ""
+  );
+  const cmds = p.commands.length ? `- Commands: ${p.commands.map((c) => `\`${c}\``).join(", ")}.
+` : "";
+  const body = `# Project guide
+
+> Generated by agent-stack. Edit freely to describe your project.
+
+## Tooling
+
+- Package manager: **${p.packageManager}** only \u2014 other package managers are blocked by the guard-bash hook.
+- Default branch: \`${p.mainBranch}\`. \`git push\` is manual-only.
+- Never hand-edit generated files: ${p.generatedGlobs.split("|").join(", ")}, ${p.lockfile}.
+${cmds}
+## Subagent delegation
+
+- **task-analyzer** at the start of a non-trivial task.
+- **code-reviewer** after writing or modifying code.
+- **test-writer** for unit tests.
+- **pattern-scout** to (re)generate \`.claude/rules/\` after structural changes.
+
+`;
+  return body + normative;
+}
+function buildCodemap() {
+  return `# CODEMAP
+
+> Generated by agent-stack \u2014 replace with a real map of where things live (apps, packages, entry points).
+
+| Path | What |
+| --- | --- |
+| \`src/\` | source |
+| \`tests/\` | tests |
+
+## Harness (not committed)
+
+\`.claude/\`, \`CLAUDE.md\`, \`CODEMAP.md\` are git-excluded (\`.git/info/exclude\`) \u2014 personal harness, not project history.
+`;
+}
+function buildHarnessFiles(params) {
+  const root = templatesRoot();
+  const files = [];
+  for (const abs of walk(root)) {
+    if (basename(abs).startsWith("_")) continue;
+    const rel = relative(root, abs);
+    const content = substitute(readFileSync2(abs, "utf-8"), params);
+    files.push({ path: join5(".claude", rel), content, action: "create" });
+  }
+  files.push({ path: ".claude/settings.json", content: buildSettings(params), action: "create" });
+  files.push({
+    path: ".claude/settings.local.json",
+    content: buildSettingsLocal(params),
+    action: "create"
+  });
+  files.push({ path: "CLAUDE.md", content: buildClaudeMd(params, root), action: "create" });
+  files.push({ path: "CODEMAP.md", content: buildCodemap(), action: "create" });
+  files.push({
+    path: ".claude/.harness.json",
+    content: JSON.stringify({ templateVersion: toolVersion(), params }, null, 2) + "\n",
+    action: "create"
+  });
+  return files;
+}
+async function writeHarnessFiles(projectDir, files) {
+  for (const f of files) {
+    const full = join5(projectDir, f.path);
+    await mkdir(dirname2(full), { recursive: true });
+    await writeFile(full, f.content, "utf-8");
+    if (f.path.startsWith(".claude/hooks/") && f.path.endsWith(".sh")) {
+      await chmod(full, 493);
+    }
+    log.success(f.path);
+  }
+}
+async function emitHarness(projectDir) {
+  const params = await detectHarnessParams(projectDir);
+  const files = buildHarnessFiles(params);
+  await writeHarnessFiles(projectDir, files);
+  return files;
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  banner();
+  log.step("Detecting environment...");
+  const project = await detectProject(process.cwd());
+  if (project.scenario === "existing") {
+    const name = project.projectName ? chalk2.cyan(project.projectName) : chalk2.dim("unnamed");
+    log.info(`Existing project: ${name}`);
+  } else {
+    log.info("Empty directory \u2014 fresh setup");
+  }
+  console.log();
+  const info = await detect();
+  const status = info.installed ? chalk2.green("  \u2714 " + info.displayName) : chalk2.dim("  \u2716 " + info.displayName);
+  const version = info.version ? chalk2.dim(` (${info.version})`) : "";
+  console.log(`${status}${version}`);
+  console.log();
+  if (!info.installed) {
+    log.warn("Claude Code is not installed.");
+    const doInstall = await confirm({ message: "Install Claude Code now?", default: true });
+    if (doInstall) {
+      await install();
+    } else {
+      log.error("Claude Code is required. Exiting.");
+      process.exit(1);
+    }
+  }
+  console.log();
+  log.step("Generating the Claude harness...");
+  await emitHarness(process.cwd());
+  const { mcpServers, envValues } = await collectMcpConfig();
+  if (mcpServers.length > 0) {
+    console.log();
+    await installMcpServers(mcpServers, envValues);
+  }
+  console.log();
+  console.log(chalk2.bold.green("  Setup complete!"));
+  console.log();
+  log.dim("  Next steps:");
+  log.dim("  \u2022 Exclude the harness from git: add .claude/, CLAUDE.md, CODEMAP.md to .git/info/exclude");
+  log.dim("  \u2022 Generate rules: open `claude` and run the pattern-scout subagent (.claude/rules/ is empty by design)");
+  log.dim("  \u2022 Smoke-test the guards: a `git push` or foreign package-manager command should block");
+  console.log();
+}
+async function collectMcpConfig() {
+  const selectedNames = await checkbox({
+    message: "Select MCP servers to install:",
+    choices: MCP_CATALOG.map((s) => ({
+      name: `${s.displayName} \u2014 ${s.description}`,
+      value: s.name,
+      checked: !s.optional
+    }))
+  });
+  const mcpServers = MCP_CATALOG.filter((s) => selectedNames.includes(s.name));
+  const envValues = {};
+  for (const server of mcpServers) {
+    if (server.envPrompts) {
+      for (const [key, prompt] of Object.entries(server.envPrompts)) {
+        const value = await input({ message: prompt + chalk2.dim(" (enter to skip)") });
+        envValues[key] = value || "<your-token-here>";
+      }
+    }
+  }
+  return { mcpServers, envValues };
+}
+
+// src/commands/detect.ts
+import chalk3 from "chalk";
+async function detectCommand() {
+  banner();
+  const project = await detectProject(process.cwd());
+  if (project.scenario === "existing") {
+    const name = project.projectName ? chalk3.cyan(project.projectName) : chalk3.dim("unnamed");
+    log.info(`Existing project detected: ${name}`);
+  } else {
+    log.info("Empty directory \u2014 no existing project detected");
+  }
+  console.log();
+  log.step("Detecting Claude Code...");
+  console.log();
+  const info = await detect();
+  const status = info.installed ? chalk3.green("\u2714 installed") : chalk3.dim("\u2716 not found");
+  const version = info.version ? chalk3.dim(` (${info.version})`) : "";
+  console.log(`  ${info.displayName.padEnd(20)} ${status}${version}`);
+  console.log();
+  if (info.installed) {
+    log.success("Claude Code detected.");
+  } else {
+    log.warn("Claude Code not detected.");
+    log.info("Run 'agent-stack init' to install and configure it.");
+  }
+}
+
+// src/commands/mcp.ts
+import chalk4 from "chalk";
+import { checkbox as checkbox2, input as input2 } from "@inquirer/prompts";
+async function mcpCommand(action) {
+  banner();
+  const info = await detect();
+  if (!info.installed) {
+    log.error("Claude Code not detected. Run 'agent-stack init' first.");
+    process.exit(1);
+  }
+  if (action === "list") {
+    console.log();
+    log.step(`${info.displayName} MCP servers:`);
+    const servers2 = await listMcp();
+    if (servers2.length === 0) {
+      log.dim("  No MCP servers configured");
+    } else {
+      for (const s of servers2) {
+        console.log(`  ${chalk4.cyan(s.name.padEnd(25))} ${chalk4.dim(s.command)} ${s.args.join(" ")}`);
+      }
+    }
+    console.log();
+    return;
+  }
+  const selectedServers = await checkbox2({
+    message: "Select MCP servers to install:",
+    choices: MCP_CATALOG.map((s) => ({
+      name: `${s.displayName} \u2014 ${s.description}`,
+      value: s.name,
+      checked: !s.optional
+    }))
+  });
+  const servers = MCP_CATALOG.filter((s) => selectedServers.includes(s.name));
+  const envValues = {};
+  for (const server of servers) {
+    if (server.envPrompts) {
+      for (const [key, prompt] of Object.entries(server.envPrompts)) {
+        const value = await input2({ message: prompt });
+        envValues[key] = value;
+      }
+    }
+  }
+  await installMcpServers(servers, envValues);
+  console.log();
+  log.success("MCP servers configured successfully!");
+}
+
+// src/commands/generate.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join6 } from "node:path";
+async function generateCommand(options = {}) {
+  banner();
+  const projectDir = process.cwd();
+  if (existsSync5(join6(projectDir, ".claude")) && !options.force) {
+    log.error(".claude/ already exists.");
+    log.info("Run `agent-stack update` to refresh the harness (preserves rules/ and tmp/),");
+    log.info("or pass --force to overwrite from scratch.");
+    process.exit(1);
+  }
+  log.step("Detecting project and generating the Claude harness...");
+  const files = await emitHarness(projectDir);
+  console.log();
+  log.success(`Generated ${files.length} harness file(s).`);
+  log.dim("  Next steps:");
+  log.dim(
+    "  \u2022 Exclude the harness from git: add .claude/, CLAUDE.md, CODEMAP.md to .git/info/exclude"
+  );
+  log.dim(
+    "  \u2022 Generate rules: open `claude` and run the pattern-scout subagent (.claude/rules/ is empty by design)"
+  );
+  log.dim("  \u2022 Smoke-test the guards: a `git push` or foreign package-manager command should block");
+}
+
+// src/commands/update.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
+import { join as join7 } from "node:path";
+async function updateCommand(options = {}) {
+  banner();
+  const projectDir = process.cwd();
+  if (!existsSync6(join7(projectDir, ".claude"))) {
+    log.error("No .claude/ found. Run `agent-stack generate` to deploy the harness first.");
+    process.exit(1);
+  }
+  const params = await detectHarnessParams(projectDir);
+  const files = buildHarnessFiles(params);
+  const created = [];
+  const changed = [];
+  let unchanged = 0;
+  for (const f of files) {
+    const full = join7(projectDir, f.path);
+    if (!existsSync6(full)) created.push(f.path);
+    else if (readFileSync3(full, "utf-8") !== f.content) changed.push(f.path);
+    else unchanged++;
+  }
+  if (options.dryRun) {
+    log.step("Harness update preview (dry run):");
+    created.forEach((p) => console.log(`  + ${p}`));
+    changed.forEach((p) => console.log(`  ~ ${p}`));
+    console.log();
+    log.dim(`  ${unchanged} unchanged. rules/ and tmp/ are preserved (not emitter-owned).`);
+    return;
+  }
+  log.step("Updating the Claude harness...");
+  await writeHarnessFiles(projectDir, files);
+  console.log();
+  log.success(
+    `Harness updated: ${created.length} added, ${changed.length} changed, ${unchanged} unchanged.`
+  );
+  log.dim("  .claude/rules/ and .claude/tmp/ were left untouched.");
+}
+
+// src/commands/sync.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join8 } from "node:path";
+async function syncCommand() {
+  await detectCommand();
+  console.log();
+  if (existsSync7(join8(process.cwd(), ".claude"))) {
+    await updateCommand();
+  } else {
+    await generateCommand();
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("agent-stack").description("CLI that deploys a Claude Code harness and manages MCP servers").version("0.1.0");
+program.command("init").description("Setup wizard: detect Claude Code, deploy the harness, install MCP servers").action(initCommand);
+program.command("detect").description("Detect the project and whether Claude Code is installed").action(detectCommand);
+var mcp = program.command("mcp").description("Manage MCP servers");
+mcp.command("install").description("Install and configure MCP servers for detected providers").action(() => mcpCommand("install"));
+mcp.command("list").description("List configured MCP servers").action(() => mcpCommand("list"));
+program.command("generate").description("Deploy the Claude harness into the current repo (fresh)").option("-f, --force", "Overwrite an existing .claude/ harness").action(generateCommand);
+program.command("update").description("Update an existing harness to the current version (preserves rules/ and tmp/)").option("--dry-run", "Show what would change without writing").action(updateCommand);
+program.command("sync").description("Detect Claude Code and generate or update the harness").action(syncCommand);
+
+// src/index.ts
+program.parse();
+//# sourceMappingURL=index.js.map