zhuge-workflow 0.1.0

package/dist/index.js

@@ -0,0 +1,801 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/setup.ts
+import chalk2 from "chalk";
+import { checkbox, confirm, select } from "@inquirer/prompts";
+
+// src/utils/shell.ts
+import { execa } from "execa";
+async function exec(cmd, args, opts) {
+  return execa(cmd, args, { ...opts, reject: true });
+}
+async function execInherit(cmd, args, opts) {
+  return execa(cmd, args, {
+    ...opts,
+    stdio: "inherit"
+  });
+}
+async function commandExists(cmd) {
+  try {
+    await execa("which", [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/adapters/base-adapter.ts
+var BaseAdapter = class {
+  /** 执行命令并提取版本号 */
+  async getVersionFromCommand(cmd, args = ["--version"]) {
+    try {
+      const result = await exec(cmd, args);
+      const stdout = String(result.stdout ?? "");
+      const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+      return match?.[1];
+    } catch {
+      return void 0;
+    }
+  }
+  /** 检查命令是否存在 */
+  commandExists(cmd) {
+    return commandExists(cmd);
+  }
+  /** 获取 npm 包最新版本 */
+  async getLatestNpmVersion(packageName) {
+    try {
+      const result = await exec("npm", ["info", packageName, "version"]);
+      return String(result.stdout ?? "").trim();
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/adapters/openspec.adapter.ts
+var OpenSpecAdapter = class extends BaseAdapter {
+  meta = {
+    name: "openspec",
+    displayName: "OpenSpec",
+    description: "AI-native spec-driven development",
+    installMethod: "npm-global",
+    required: false,
+    order: 1,
+    interactive: false,
+    pinnedVersion: "1.1.1"
+  };
+  packageName = "@fission-ai/openspec";
+  binName = "openspec";
+  async check() {
+    const installed = await this.commandExists(this.binName);
+    if (!installed) return { installed: false };
+    const version = await this.getVersionFromCommand(this.binName);
+    const latest = await this.getLatestNpmVersion(this.packageName);
+    return {
+      installed: true,
+      version,
+      latestVersion: latest,
+      updateAvailable: !!(version && latest && version !== latest)
+    };
+  }
+  async install(version) {
+    const pkg = version ? `${this.packageName}@${version}` : this.packageName;
+    await execInherit("npm", ["install", "-g", pkg]);
+  }
+  async update(version) {
+    if (version) {
+      await execInherit("npm", ["install", "-g", `${this.packageName}@${version}`]);
+    } else {
+      await execInherit("npm", ["update", "-g", this.packageName]);
+    }
+  }
+  async uninstall() {
+    await execInherit("npm", ["uninstall", "-g", this.packageName]);
+  }
+  async initProject(cwd) {
+    await execInherit(this.binName, ["init"], { cwd });
+  }
+};
+
+// src/adapters/trellis.adapter.ts
+var TrellisAdapter = class extends BaseAdapter {
+  meta = {
+    name: "trellis",
+    displayName: "Trellis",
+    description: "AI workflow structure for Claude Code and Cursor",
+    installMethod: "npm-global",
+    required: false,
+    order: 2,
+    interactive: false,
+    pinnedVersion: "0.2.15"
+  };
+  packageName = "@mindfoldhq/trellis";
+  binName = "trellis";
+  async check() {
+    const installed = await this.commandExists(this.binName);
+    if (!installed) return { installed: false };
+    const version = await this.getVersionFromCommand(this.binName);
+    const latest = await this.getLatestNpmVersion(this.packageName);
+    return {
+      installed: true,
+      version,
+      latestVersion: latest,
+      updateAvailable: !!(version && latest && version !== latest)
+    };
+  }
+  async install(version) {
+    const pkg = version ? `${this.packageName}@${version}` : this.packageName;
+    await execInherit("npm", ["install", "-g", pkg]);
+  }
+  async update(version) {
+    if (version) {
+      await execInherit("npm", ["install", "-g", `${this.packageName}@${version}`]);
+    } else {
+      await execInherit("npm", ["update", "-g", this.packageName]);
+    }
+  }
+  async uninstall() {
+    await execInherit("npm", ["uninstall", "-g", this.packageName]);
+  }
+  async initProject(cwd) {
+    await execInherit(this.binName, ["init"], { cwd });
+  }
+};
+
+// src/adapters/ccb.adapter.ts
+import { existsSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/utils/platform.ts
+import { homedir } from "os";
+import { resolve } from "path";
+function expandHome(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return resolve(homedir(), p.slice(2));
+  }
+  return p;
+}
+function getHome() {
+  return process.env.ZHUGE_HOME || homedir();
+}
+function isCI() {
+  return process.env.ZHUGE_CI === "true" || process.env.CI === "true";
+}
+
+// src/adapters/ccb.adapter.ts
+var CcbAdapter = class extends BaseAdapter {
+  meta = {
+    name: "ccb",
+    displayName: "Claude Code Bridge (CCB)",
+    description: "Multi-model collaboration via split-pane terminal",
+    installMethod: "git-clone-script",
+    required: false,
+    order: 3,
+    interactive: false
+  };
+  repoUrl = "https://github.com/bfly123/claude_code_bridge.git";
+  get cloneDir() {
+    return resolve2(getHome(), ".local/share/claude_code_bridge");
+  }
+  async check() {
+    const installed = await this.commandExists("ccb");
+    if (!installed) return { installed: false };
+    const version = await this.getVersionFromCommand("ccb");
+    return { installed: true, version };
+  }
+  async install() {
+    if (!existsSync(this.cloneDir)) {
+      await execInherit("git", ["clone", this.repoUrl, this.cloneDir]);
+    }
+    await execInherit("bash", ["./install.sh", "install"], { cwd: this.cloneDir });
+  }
+  async update() {
+    if (existsSync(this.cloneDir)) {
+      await execInherit("git", ["-C", this.cloneDir, "pull"]);
+    } else {
+      await execInherit("git", ["clone", this.repoUrl, this.cloneDir]);
+    }
+    await execInherit("bash", ["./install.sh", "install"], { cwd: this.cloneDir });
+  }
+  async uninstall() {
+    if (existsSync(this.cloneDir)) {
+      await execInherit("bash", ["./install.sh", "uninstall"], { cwd: this.cloneDir });
+    }
+  }
+};
+
+// src/adapters/ccg.adapter.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+var CcgAdapter = class extends BaseAdapter {
+  meta = {
+    name: "ccg",
+    displayName: "CCG Workflow",
+    description: "Claude Code enhanced multi-model workflow",
+    installMethod: "npx",
+    required: false,
+    order: 4,
+    interactive: true,
+    pinnedVersion: "1.7.61"
+  };
+  get configPath() {
+    return resolve3(getHome(), ".claude/.ccg/config.toml");
+  }
+  async check() {
+    const installed = existsSync2(this.configPath);
+    if (!installed) return { installed: false };
+    return { installed: true, version: "detected" };
+  }
+  async install(version) {
+    const pkg = version ? `ccg-workflow@${version}` : "ccg-workflow@latest";
+    await execInherit("npx", [pkg]);
+  }
+  async update(version) {
+    await this.install(version);
+  }
+  async uninstall() {
+    const ccgDir = resolve3(getHome(), ".claude/.ccg");
+    if (existsSync2(ccgDir)) {
+      const { rmSync } = await import("fs");
+      rmSync(ccgDir, { recursive: true, force: true });
+    }
+  }
+};
+
+// src/adapters/index.ts
+function getAllAdapters() {
+  return [
+    new OpenSpecAdapter(),
+    new TrellisAdapter(),
+    new CcbAdapter(),
+    new CcgAdapter()
+  ].sort((a, b) => a.meta.order - b.meta.order);
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+function info(msg) {
+  console.log(chalk.blue("\u2139"), msg);
+}
+function success(msg) {
+  console.log(chalk.green("\u2714"), msg);
+}
+function warn(msg) {
+  console.log(chalk.yellow("\u26A0"), msg);
+}
+function error(msg) {
+  console.log(chalk.red("\u2716"), msg);
+}
+function spinner(text) {
+  return ora({ text, color: "cyan" }).start();
+}
+function title(text) {
+  console.log();
+  console.log(chalk.bold.cyan(text));
+  console.log(chalk.dim("\u2500".repeat(text.length + 4)));
+}
+
+// src/core/plugin-runner.ts
+async function checkAllAdapters(adapters) {
+  const spin = spinner("Checking installed tools...");
+  const results = [];
+  for (const adapter of adapters) {
+    try {
+      const status = await adapter.check();
+      let action;
+      if (!status.installed) {
+        action = "install";
+      } else if (status.updateAvailable) {
+        action = "update";
+      } else {
+        action = "skip";
+      }
+      results.push({ adapter, status, action });
+    } catch {
+      results.push({
+        adapter,
+        status: { installed: false },
+        action: "install"
+      });
+    }
+  }
+  spin.succeed("Tool check complete");
+  return results;
+}
+async function runAdapter(adapter, action, version) {
+  if (adapter.meta.interactive) {
+    console.log();
+    info(`Starting ${adapter.meta.displayName} (interactive)...`);
+    console.log();
+    await adapter[action](version);
+    console.log();
+  } else {
+    const spin = spinner(
+      `${action === "install" ? "Installing" : "Updating"} ${adapter.meta.displayName}${version ? `@${version}` : ""}...`
+    );
+    try {
+      await adapter[action](version);
+      spin.succeed(`${adapter.meta.displayName} ${action === "install" ? "installed" : "updated"}${version ? ` (v${version})` : ""}`);
+    } catch (err) {
+      spin.fail(`${adapter.meta.displayName} ${action} failed`);
+      throw err;
+    }
+  }
+}
+
+// src/core/config-deployer.ts
+import { resolve as resolve5, dirname as dirname2, basename } from "path";
+import {
+  existsSync as existsSync4,
+  readFileSync,
+  writeFileSync,
+  copyFileSync,
+  mkdirSync,
+  renameSync,
+  readdirSync,
+  statSync as statSync2
+} from "fs";
+
+// src/core/config-source.ts
+import { resolve as resolve4, dirname } from "path";
+import { existsSync as existsSync3, statSync } from "fs";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getBundledTemplatesDir() {
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve4(dir, "templates");
+    if (existsSync3(candidate) && statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+    dir = resolve4(dir, "..");
+  }
+  throw new Error("Could not find templates directory");
+}
+
+// src/core/config-deployer.ts
+async function deployConfigs(targets) {
+  const templatesDir = getBundledTemplatesDir();
+  for (const target of targets) {
+    const spin = spinner(`Deploying configs to ${target.displayName}...`);
+    try {
+      let deployed = 0;
+      for (const rule of target.rules) {
+        const sourcePath = resolve5(templatesDir, target.name, rule.source);
+        const targetPath = expandHome(rule.target);
+        if (!existsSync4(sourcePath)) {
+          continue;
+        }
+        mkdirSync(dirname2(targetPath), { recursive: true });
+        if (statSync2(sourcePath).isDirectory()) {
+          deployed += deployDirectory(sourcePath, targetPath, rule.strategy);
+        } else {
+          deployFile(sourcePath, targetPath, rule);
+          deployed++;
+        }
+      }
+      spin.succeed(`${target.displayName}: ${deployed} file(s) deployed`);
+    } catch (err) {
+      spin.fail(`${target.displayName}: deploy failed`);
+      error(String(err));
+    }
+  }
+}
+function deployFile(source, target, rule) {
+  switch (rule.strategy) {
+    case "replace":
+      deployReplace(source, target);
+      break;
+    case "append":
+      deployAppend(source, target);
+      break;
+    case "merge-section":
+      if (!rule.sectionMarker) {
+        throw new Error(`merge-section requires sectionMarker for ${rule.source}`);
+      }
+      deployMergeSection(source, target, rule.sectionMarker);
+      break;
+  }
+}
+function deployReplace(source, target) {
+  if (existsSync4(target)) {
+    const backupPath = `${target}.bak.${Date.now()}`;
+    renameSync(target, backupPath);
+  }
+  copyFileSync(source, target);
+}
+function deployAppend(source, target) {
+  const content = readFileSync(source, "utf-8");
+  if (existsSync4(target)) {
+    const existing = readFileSync(target, "utf-8");
+    if (existing.includes(content.trim())) return;
+    writeFileSync(target, existing + "\n" + content);
+  } else {
+    writeFileSync(target, content);
+  }
+}
+function deployMergeSection(source, target, marker) {
+  const newContent = readFileSync(source, "utf-8");
+  if (!existsSync4(target)) {
+    writeFileSync(target, newContent);
+    return;
+  }
+  const existing = readFileSync(target, "utf-8");
+  const startIdx = existing.indexOf(marker.start);
+  const endIdx = existing.indexOf(marker.end);
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before = existing.substring(0, startIdx);
+    const after = existing.substring(endIdx + marker.end.length);
+    writeFileSync(target, before + newContent + after);
+  } else {
+    warn(`Section markers not found in ${basename(target)}, appending instead`);
+    writeFileSync(target, existing + "\n" + newContent);
+  }
+}
+function deployDirectory(sourceDir, targetDir, _strategy) {
+  mkdirSync(targetDir, { recursive: true });
+  let count = 0;
+  for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+    const srcPath = resolve5(sourceDir, entry.name);
+    const tgtPath = resolve5(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      count += deployDirectory(srcPath, tgtPath, _strategy);
+    } else {
+      copyFileSync(srcPath, tgtPath);
+      count++;
+    }
+  }
+  return count;
+}
+
+// src/configs/claude.config.ts
+import { existsSync as existsSync5 } from "fs";
+var claudeConfig = {
+  name: "claude",
+  displayName: "Claude Code",
+  configDir: "~/.claude",
+  detect: async () => existsSync5(expandHome("~/.claude")),
+  rules: [
+    // CLAUDE.md - Global 区块（个人配置）
+    {
+      source: "CLAUDE.md",
+      target: "~/.claude/CLAUDE.md",
+      strategy: "merge-section",
+      sectionMarker: {
+        start: "<!-- Global -->",
+        end: "<!-- Global_END -->"
+      }
+    },
+    // CLAUDE.md - CCG 增强区块
+    {
+      source: "CLAUDE-ccg.md",
+      target: "~/.claude/CLAUDE.md",
+      strategy: "merge-section",
+      sectionMarker: {
+        start: "<!-- CCG \u589E\u5F3A -->",
+        end: "<!-- CCG \u589E\u5F3A_END -->"
+      }
+    },
+    // rules - 整体替换（全部由 zhuge 管理）
+    {
+      source: "rules",
+      target: "~/.claude/rules",
+      strategy: "replace"
+    },
+    // skills - 只复制 zhuge 管理的，不删除已有的（保护 CCB/第三方 skill）
+    {
+      source: "skills",
+      target: "~/.claude/skills",
+      strategy: "replace"
+    },
+    // commands/developer - 只复制 zhuge 管理的（保护 CCG 的 commands/ccg/）
+    {
+      source: "commands",
+      target: "~/.claude/commands",
+      strategy: "replace"
+    }
+  ]
+};
+
+// src/configs/index.ts
+function getAllConfigTargets() {
+  return [claudeConfig];
+}
+function getConfigTargetsByNames(names) {
+  const all = getAllConfigTargets();
+  return all.filter((t) => names.includes(t.name));
+}
+
+// src/commands/setup.ts
+async function setupCommand(options) {
+  const ciMode = options.yes || isCI();
+  title("zhuge setup");
+  const adapters = getAllAdapters();
+  const actions = await checkAllAdapters(adapters);
+  printStatusTable(actions);
+  const actionable = actions.filter((a) => a.action !== "skip");
+  const skippable = actions.filter((a) => a.action === "skip");
+  if (actionable.length === 0 && skippable.length === actions.length) {
+    success("All tools are up to date!");
+  }
+  let selected;
+  if (ciMode) {
+    selected = actionable;
+  } else if (actionable.length === 0) {
+    const reconfig = await confirm({
+      message: "All tools installed. Reconfigure any tool?",
+      default: false
+    });
+    if (!reconfig) {
+      selected = [];
+    } else {
+      const choices = skippable.map((a) => ({
+        name: `${a.adapter.meta.displayName} (reconfigure)`,
+        value: a
+      }));
+      const picked = await checkbox({
+        message: "Select tools to reconfigure:",
+        choices
+      });
+      selected = picked.map((p) => ({ ...p, action: "install" }));
+    }
+  } else {
+    const choices = actionable.map((a) => ({
+      name: formatActionChoice(a),
+      value: a,
+      checked: true
+    }));
+    selected = await checkbox({
+      message: "Select tools to install/update:",
+      choices
+    });
+  }
+  if (selected.length > 0) {
+    const versionMap = /* @__PURE__ */ new Map();
+    if (!ciMode) {
+      for (const item of selected) {
+        if (item.adapter.meta.pinnedVersion) {
+          const strategy = await select({
+            message: `${item.adapter.meta.displayName} - Version strategy:`,
+            choices: [
+              {
+                name: `Pinned v${item.adapter.meta.pinnedVersion} (tested with zhuge)`,
+                value: "pinned"
+              },
+              { name: "Latest version", value: "latest" }
+            ]
+          });
+          if (strategy === "pinned") {
+            versionMap.set(item.adapter.meta.name, item.adapter.meta.pinnedVersion);
+          }
+        }
+      }
+    }
+    console.log();
+    for (const item of selected) {
+      try {
+        const version = versionMap.get(item.adapter.meta.name);
+        await runAdapter(item.adapter, item.action === "skip" ? "install" : item.action, version);
+      } catch (err) {
+        error(`Failed: ${item.adapter.meta.displayName} - ${err}`);
+      }
+    }
+  }
+  await deployConfigsPhase(ciMode);
+  console.log();
+  title("Setup Complete");
+  if (selected.length > 0) {
+    for (const item of selected) {
+      const verb = item.action === "update" ? "Updated" : "Installed";
+      success(`${verb}: ${item.adapter.meta.displayName}`);
+    }
+  } else {
+    info("No tools were installed or updated.");
+  }
+}
+function printStatusTable(actions) {
+  console.log();
+  const header = `  ${pad("Tool", 24)} ${pad("Status", 10)} ${pad("Version", 12)} Action`;
+  console.log(chalk2.dim(header));
+  console.log(chalk2.dim("  " + "\u2500".repeat(64)));
+  for (const { adapter, status, action } of actions) {
+    const name = pad(adapter.meta.displayName, 24);
+    const st = status.installed ? chalk2.green(pad("OK", 10)) : chalk2.red(pad("Missing", 10));
+    const ver = pad(status.version || "-", 12);
+    const act = action === "install" ? chalk2.yellow("Install") : action === "update" ? chalk2.cyan(`Update \u2192 ${status.latestVersion || "?"}`) : chalk2.dim("Skip");
+    console.log(`  ${name} ${st} ${ver} ${act}`);
+  }
+  console.log();
+}
+function formatActionChoice(a) {
+  if (a.action === "install") {
+    return `${a.adapter.meta.displayName} - Install`;
+  }
+  return `${a.adapter.meta.displayName} - Update to ${a.status.latestVersion || "latest"}`;
+}
+function pad(s, len) {
+  return s.padEnd(len);
+}
+async function deployConfigsPhase(ciMode) {
+  console.log();
+  if (ciMode) {
+    info("Config deployment skipped in CI mode (use zhuge setup interactively)");
+    return;
+  }
+  const deploy = await confirm({
+    message: "Deploy AI tool config files?",
+    default: true
+  });
+  if (!deploy) return;
+  const targets = await checkbox({
+    message: "Deploy configs to:",
+    choices: [
+      { name: "Claude Code (~/.claude/)", value: "claude", checked: true }
+    ]
+  });
+  if (targets.length === 0) {
+    info("No config targets selected, skipping.");
+    return;
+  }
+  const configTargets = getConfigTargetsByNames(targets);
+  await deployConfigs(configTargets);
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync6, writeFileSync as writeFileSync2, readFileSync as readFileSync2, mkdirSync as mkdirSync2, copyFileSync as copyFileSync2, readdirSync as readdirSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+async function initCommand() {
+  const cwd = process.cwd();
+  title("zhuge init");
+  if (!existsSync6(resolve6(cwd, ".git"))) {
+    error('Current directory is not a git repository. Run "git init" first.');
+    process.exit(1);
+  }
+  const checks = await Promise.all([
+    commandExists("openspec"),
+    commandExists("trellis")
+  ]);
+  if (!checks[0]) {
+    warn('OpenSpec not installed. Run "zhuge setup" first to install it.');
+    info("Skipping OpenSpec init...");
+  }
+  if (!checks[1]) {
+    warn('Trellis not installed. Run "zhuge setup" first to install it.');
+    info("Skipping Trellis init...");
+  }
+  if (checks[0]) {
+    console.log();
+    info("Running OpenSpec init...");
+    console.log();
+    try {
+      await execInherit("openspec", ["init"], { cwd });
+      success("OpenSpec init complete");
+    } catch (err) {
+      error(`OpenSpec init failed: ${err}`);
+    }
+  }
+  if (checks[1]) {
+    console.log();
+    info("Running Trellis init...");
+    console.log();
+    try {
+      await execInherit("trellis", ["init"], { cwd });
+      success("Trellis init complete");
+    } catch (err) {
+      error(`Trellis init failed: ${err}`);
+    }
+  }
+  console.log();
+  info("Running zhuge init...");
+  await zhugeOwnInit(cwd);
+  console.log();
+  title("Init Complete");
+  success(`Project initialized at ${cwd}`);
+}
+async function zhugeOwnInit(cwd) {
+  const zhugeDir = resolve6(cwd, ".zhuge");
+  mkdirSync2(zhugeDir, { recursive: true });
+  const stateFile = resolve6(zhugeDir, "init-state.json");
+  const state = {
+    version: "0.1.0",
+    initializedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tools: {
+      openspec: existsSync6(resolve6(cwd, "openspec")) || existsSync6(resolve6(cwd, "specs")),
+      trellis: existsSync6(resolve6(cwd, ".trellis"))
+    }
+  };
+  writeFileSync2(stateFile, JSON.stringify(state, null, 2));
+  const claudeMdPath = resolve6(cwd, "CLAUDE.md");
+  if (existsSync6(claudeMdPath)) {
+    const existing = readFileSync2(claudeMdPath, "utf-8");
+    const zhugeSection = buildZhugeSection(cwd);
+    if (!existing.includes("<!-- zhuge-workflow -->")) {
+      writeFileSync2(claudeMdPath, existing + "\n" + zhugeSection);
+      success("Updated project CLAUDE.md with zhuge section");
+    } else {
+      info("CLAUDE.md already contains zhuge section, skipping");
+    }
+  } else {
+    const content = buildProjectClaudeMd(cwd);
+    writeFileSync2(claudeMdPath, content);
+    success("Created project CLAUDE.md");
+  }
+  deployInitTemplates(cwd);
+  const gitignorePath = resolve6(cwd, ".gitignore");
+  if (existsSync6(gitignorePath)) {
+    const gitignore = readFileSync2(gitignorePath, "utf-8");
+    if (!gitignore.includes(".zhuge/")) {
+      writeFileSync2(gitignorePath, gitignore.trimEnd() + "\n.zhuge/\n");
+    }
+  }
+  success("zhuge init complete");
+}
+function buildZhugeSection(cwd) {
+  const parts = [
+    "<!-- zhuge-workflow -->",
+    "",
+    "## Workflow",
+    ""
+  ];
+  if (existsSync6(resolve6(cwd, "specs")) || existsSync6(resolve6(cwd, "openspec"))) {
+    parts.push("- OpenSpec specs available in `specs/` or `openspec/`");
+  }
+  if (existsSync6(resolve6(cwd, ".trellis"))) {
+    parts.push("- Trellis workflow configured in `.trellis/`");
+  }
+  parts.push("");
+  parts.push("<!-- zhuge-workflow-end -->");
+  return parts.join("\n");
+}
+function buildProjectClaudeMd(cwd) {
+  const parts = [
+    `# ${resolve6(cwd).split("/").pop() || "Project"}`,
+    ""
+  ];
+  parts.push(buildZhugeSection(cwd));
+  return parts.join("\n");
+}
+function deployInitTemplates(cwd) {
+  const templatesDir = resolve6(getBundledTemplatesDir(), "init");
+  if (!existsSync6(templatesDir)) {
+    warn("Init templates not found, skipping file replacements");
+    return;
+  }
+  const mappings = [
+    { source: "claude-agents", target: ".claude/agents" },
+    { source: "claude-hooks", target: ".claude/hooks" },
+    { source: "trellis-scripts", target: ".trellis/scripts" }
+  ];
+  let count = 0;
+  for (const { source, target } of mappings) {
+    const srcDir = resolve6(templatesDir, source);
+    if (!existsSync6(srcDir)) continue;
+    const tgtDir = resolve6(cwd, target);
+    mkdirSync2(tgtDir, { recursive: true });
+    for (const entry of readdirSync2(srcDir, { withFileTypes: true })) {
+      if (entry.isFile()) {
+        copyFileSync2(resolve6(srcDir, entry.name), resolve6(tgtDir, entry.name));
+        count++;
+      }
+    }
+  }
+  if (count > 0) {
+    success(`Deployed ${count} zhuge enhanced file(s)`);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("zhuge").description("AI development workflow installer and manager").version("0.1.0");
+program.command("setup").description("Install external tools and deploy AI config files").option("--yes", "Skip all prompts and use defaults (CI mode)").action(async (options) => {
+  await setupCommand(options);
+});
+program.command("init").description("Initialize project-level documents in current directory").action(async () => {
+  await initCommand();
+});
+program.parse();
+//# sourceMappingURL=index.js.map