agent-mgr 0.2.0

package/dist/index.js

@@ -0,0 +1,1477 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/commands/init.ts
+import { join as join7 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import chalk from "chalk";
+import { checkbox, confirm } from "@inquirer/prompts";
+
+// src/adapters/claude-code.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/lib/fs-utils.ts
+import { mkdirSync, existsSync, symlinkSync, copyFileSync, readFileSync, writeFileSync, unlinkSync, readdirSync, appendFileSync } from "fs";
+import { dirname, join, relative, extname } from "path";
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function syncFile(source, dest, method = "symlink") {
+  ensureDir(dirname(dest));
+  if (existsSync(dest)) unlinkSync(dest);
+  if (method === "symlink") {
+    const rel = relative(dirname(dest), source);
+    symlinkSync(rel, dest);
+  } else {
+    copyFileSync(source, dest);
+  }
+}
+function removeFile(filePath) {
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+    return true;
+  }
+  return false;
+}
+function listMarkdownFiles(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { recursive: true }).map((f) => f.toString()).filter((f) => extname(f) === ".md");
+}
+function readJson(path) {
+  if (!existsSync(path)) return {};
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+function writeJson(path, data) {
+  ensureDir(dirname(path));
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
+}
+function parseSimpleYaml(text) {
+  const result = {};
+  let currentKey = null;
+  let currentList = null;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("- ") && currentKey) {
+      if (!currentList) currentList = [];
+      currentList.push(trimmed.slice(2).trim());
+      continue;
+    }
+    if (currentKey && currentList) {
+      result[currentKey] = currentList;
+      currentList = null;
+    }
+    const match = trimmed.match(/^(\w+):\s*(.*)$/);
+    if (match) {
+      currentKey = match[1];
+      const value = match[2].trim();
+      if (value) {
+        result[currentKey] = value;
+        currentKey = null;
+      }
+    }
+  }
+  if (currentKey && currentList) {
+    result[currentKey] = currentList;
+  }
+  return result;
+}
+function serializeSimpleYaml(data) {
+  let out = "";
+  for (const [key, value] of Object.entries(data)) {
+    if (Array.isArray(value)) {
+      out += `${key}:
+`;
+      for (const item of value) {
+        out += `  - ${item}
+`;
+      }
+    } else {
+      out += `${key}: ${value}
+`;
+    }
+  }
+  return out;
+}
+function readYaml(path) {
+  if (!existsSync(path)) return {};
+  const text = readFileSync(path, "utf-8");
+  return parseSimpleYaml(text);
+}
+function writeYaml(path, data) {
+  ensureDir(dirname(path));
+  writeFileSync(path, serializeSimpleYaml(data));
+}
+function writeToml(path, data) {
+  ensureDir(dirname(path));
+  writeFileSync(path, serializeToml(data));
+}
+function readToml(path) {
+  if (!existsSync(path)) return {};
+  const text = readFileSync(path, "utf-8");
+  return parseSimpleToml(text);
+}
+function serializeToml(data, prefix = "") {
+  let out = "";
+  for (const [key, value] of Object.entries(data)) {
+    if (value === null || value === void 0) continue;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      const section = prefix ? `${prefix}.${key}` : key;
+      out += `[${section}]
+`;
+      for (const [k, v] of Object.entries(value)) {
+        if (typeof v === "object" && !Array.isArray(v) && v !== null) {
+          out += serializeToml({ [k]: v }, section);
+        } else {
+          out += `${k} = ${tomlValue(v)}
+`;
+        }
+      }
+      out += "\n";
+    } else {
+      out += `${key} = ${tomlValue(value)}
+`;
+    }
+  }
+  return out;
+}
+function tomlValue(v) {
+  if (typeof v === "string") return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (Array.isArray(v)) return `[${v.map(tomlValue).join(", ")}]`;
+  if (typeof v === "object" && v !== null) {
+    const entries = Object.entries(v);
+    return `{ ${entries.map(([k, val]) => `${k} = ${tomlValue(val)}`).join(", ")} }`;
+  }
+  return `"${v}"`;
+}
+function parseSimpleToml(text) {
+  const result = {};
+  let currentSection = "";
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const sectionMatch = trimmed.match(/^\[(.+)\]$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      const parts = currentSection.split(".");
+      let obj = result;
+      for (const part of parts) {
+        if (!(part in obj)) obj[part] = {};
+        obj = obj[part];
+      }
+      continue;
+    }
+    const kvMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+    if (kvMatch) {
+      const key = kvMatch[1];
+      const rawVal = kvMatch[2].trim();
+      const val = parseTomlValue(rawVal);
+      if (currentSection) {
+        const parts = currentSection.split(".");
+        let obj = result;
+        for (const part of parts) {
+          obj = obj[part];
+        }
+        obj[key] = val;
+      } else {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+}
+function parseTomlValue(raw) {
+  if (raw.startsWith('"') && raw.endsWith('"')) return raw.slice(1, -1);
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (/^\d+$/.test(raw)) return parseInt(raw, 10);
+  if (raw.startsWith("[") && raw.endsWith("]")) {
+    const inner = raw.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(",").map((s) => parseTomlValue(s.trim()));
+  }
+  if (raw.startsWith("{") && raw.endsWith("}")) {
+    const inner = raw.slice(1, -1).trim();
+    if (!inner) return {};
+    const result = {};
+    for (const pair of inner.split(",")) {
+      const [k, ...v] = pair.split("=");
+      if (k && v.length) result[k.trim()] = parseTomlValue(v.join("=").trim());
+    }
+    return result;
+  }
+  return raw;
+}
+var GIT_EXCLUDE_PATTERNS = [
+  ".agent-mgr.yml",
+  "commands/",
+  ".claude/commands/",
+  ".cursor/commands/",
+  ".codex/",
+  ".opencode/commands/",
+  ".mcp.json",
+  "opencode.json"
+];
+function excludeHasPattern(content, pattern) {
+  return content.split("\n").some((line) => line.trim() === pattern);
+}
+function addGitExclude(projectRoot) {
+  const excludePath = join(projectRoot, ".git", "info", "exclude");
+  if (!existsSync(join(projectRoot, ".git"))) return;
+  const existing = existsSync(excludePath) ? readFileSync(excludePath, "utf-8") : "";
+  const missing = GIT_EXCLUDE_PATTERNS.filter((p) => !excludeHasPattern(existing, p));
+  if (missing.length === 0) return;
+  const addition = "\n# agent-mgr\n" + missing.join("\n") + "\n";
+  ensureDir(dirname(excludePath));
+  appendFileSync(excludePath, addition);
+}
+function updateGitExclude(projectRoot) {
+  const excludePath = join(projectRoot, ".git", "info", "exclude");
+  if (!existsSync(excludePath)) return;
+  const existing = readFileSync(excludePath, "utf-8");
+  if (!existing.includes("# agent-mgr")) return;
+  const missing = GIT_EXCLUDE_PATTERNS.filter((p) => !excludeHasPattern(existing, p));
+  if (missing.length === 0) return;
+  appendFileSync(excludePath, missing.join("\n") + "\n");
+}
+function parseFrontmatter(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { description: "", body: content.trim() };
+  }
+  const endIndex = trimmed.indexOf("---", 3);
+  if (endIndex === -1) {
+    return { description: "", body: content.trim() };
+  }
+  const frontmatter = trimmed.slice(3, endIndex).trim();
+  const body = trimmed.slice(endIndex + 3).trim();
+  let description = "";
+  for (const line of frontmatter.split("\n")) {
+    const match = line.match(/^description:\s*(.+)$/);
+    if (match) {
+      description = match[1].trim();
+      break;
+    }
+  }
+  return { description, body };
+}
+
+// src/adapters/claude-code.ts
+var claudeCodeAdapter = {
+  name: "Claude Code",
+  id: "claude-code",
+  supportsCommands: true,
+  getCommandsDir(scope, projectRoot) {
+    if (scope === "global") return join2(homedir(), ".claude", "commands");
+    return join2(projectRoot, ".claude", "commands");
+  },
+  getMcpConfigPath(scope, projectRoot) {
+    if (scope === "global") return join2(homedir(), ".claude.json");
+    return join2(projectRoot, ".mcp.json");
+  },
+  async readMcpConfig(scope, projectRoot) {
+    const path = this.getMcpConfigPath(scope, projectRoot);
+    const data = readJson(path);
+    return data.mcpServers ?? {};
+  },
+  async writeMcpConfig(servers, scope, projectRoot) {
+    const path = this.getMcpConfigPath(scope, projectRoot);
+    const existing = readJson(path);
+    existing.mcpServers = {
+      ...existing.mcpServers ?? {},
+      ...servers
+    };
+    writeJson(path, existing);
+  }
+};
+
+// src/adapters/cursor.ts
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var cursorAdapter = {
+  name: "Cursor",
+  id: "cursor",
+  supportsCommands: true,
+  getCommandsDir(scope, projectRoot) {
+    if (scope === "global") return join3(homedir2(), ".cursor", "commands");
+    return join3(projectRoot, ".cursor", "commands");
+  },
+  getMcpConfigPath(scope, projectRoot) {
+    if (scope === "global") return join3(homedir2(), ".cursor", "mcp.json");
+    return join3(projectRoot, ".cursor", "mcp.json");
+  },
+  async readMcpConfig(scope, projectRoot) {
+    const path = this.getMcpConfigPath(scope, projectRoot);
+    const data = readJson(path);
+    return data.mcpServers ?? {};
+  },
+  async writeMcpConfig(servers, scope, projectRoot) {
+    const path = this.getMcpConfigPath(scope, projectRoot);
+    const existing = readJson(path);
+    existing.mcpServers = {
+      ...existing.mcpServers ?? {},
+      ...servers
+    };
+    writeJson(path, existing);
+  }
+};
+
+// src/adapters/codex.ts
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+var codexAdapter = {
+  name: "Codex",
+  id: "codex",
+  supportsCommands: false,
+  getCommandsDir() {
+    return null;
+  },
+  getMcpConfigPath(scope, projectRoot) {
+    if (scope === "global") return join4(homedir3(), ".codex", "config.toml");
+    return join4(projectRoot, ".codex", "config.toml");
+  },
+  async readMcpConfig(scope, projectRoot) {
+    const path = this.getMcpConfigPath(scope, projectRoot);
+    const data = readToml(path);
+    const servers = data.mcp_servers ?? {};
+    const result = {};
+    for (const [name, cfg] of Object.entries(servers)) {
+      result[name] = {
+        name,
+        command: cfg.command ?? "",
+        args: cfg.args ?? [],
+        env: cfg.env ?? {}
+      };
+    }
+    return result;
+  },
+  async writeMcpConfig(servers, scope, projectRoot) {
+    const path = this.getMcpConfigPath(scope, projectRoot);
+    const existing = readToml(path);
+    const mcpServers = existing.mcp_servers ?? {};
+    for (const [name, server] of Object.entries(servers)) {
+      mcpServers[name] = {
+        command: server.command,
+        args: server.args ?? [],
+        env: server.env ?? {}
+      };
+    }
+    existing.mcp_servers = mcpServers;
+    writeToml(path, existing);
+  }
+};
+
+// src/adapters/opencode.ts
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
+var opencodeAdapter = {
+  name: "OpenCode",
+  id: "opencode",
+  supportsCommands: true,
+  getCommandsDir(scope, projectRoot) {
+    if (scope === "global") return join5(homedir4(), ".config", "opencode", "commands");
+    return join5(projectRoot, ".opencode", "commands");
+  },
+  getMcpConfigPath(scope, projectRoot) {
+    if (scope === "global") return join5(homedir4(), ".config", "opencode", "opencode.json");
+    return join5(projectRoot, "opencode.json");
+  },
+  async readMcpConfig(scope, projectRoot) {
+    const path = this.getMcpConfigPath(scope, projectRoot);
+    const data = readJson(path);
+    const mcp2 = data.mcp ?? {};
+    const result = {};
+    for (const [name, cfg] of Object.entries(mcp2)) {
+      const cmd = cfg.command;
+      if (Array.isArray(cmd) && cmd.length > 0) {
+        result[name] = {
+          name,
+          command: cmd[0],
+          args: cmd.slice(1),
+          env: cfg.environment ?? {}
+        };
+      }
+    }
+    return result;
+  },
+  async writeMcpConfig(servers, scope, projectRoot) {
+    const path = this.getMcpConfigPath(scope, projectRoot);
+    const existing = readJson(path);
+    const mcp2 = existing.mcp ?? {};
+    for (const [name, server] of Object.entries(servers)) {
+      mcp2[name] = {
+        type: "local",
+        command: [server.command, ...server.args ?? []],
+        environment: server.env ?? {},
+        enabled: true
+      };
+    }
+    existing.mcp = mcp2;
+    writeJson(path, existing);
+  }
+};
+
+// src/adapters/index.ts
+var adapters = {
+  "claude-code": claudeCodeAdapter,
+  cursor: cursorAdapter,
+  codex: codexAdapter,
+  opencode: opencodeAdapter
+};
+function getAdapters(ids) {
+  return ids.map((id) => adapters[id]).filter((a) => a !== void 0);
+}
+var ALL_TARGET_IDS = Object.keys(adapters);
+
+// src/lib/config.ts
+import { existsSync as existsSync3 } from "fs";
+
+// src/lib/paths.ts
+import { homedir as homedir5 } from "os";
+import { join as join6, resolve } from "path";
+import { existsSync as existsSync2 } from "fs";
+var GLOBAL_DIR = join6(homedir5(), ".agent-mgr");
+var GLOBAL_CONFIG_PATH = join6(GLOBAL_DIR, "config.yml");
+var GLOBAL_COMMANDS_DIR = join6(GLOBAL_DIR, "commands");
+var GLOBAL_MCP_PATH = join6(GLOBAL_DIR, "mcp.json");
+var PROJECT_CONFIG_FILE = ".agent-mgr.yml";
+var PROJECT_COMMANDS_DIR = "commands";
+function findProjectRoot(from = process.cwd()) {
+  let dir = resolve(from);
+  while (true) {
+    if (existsSync2(join6(dir, PROJECT_CONFIG_FILE))) return dir;
+    const parent = resolve(dir, "..");
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function getCommandsDir(scope, projectRoot) {
+  if (scope === "global") return GLOBAL_COMMANDS_DIR;
+  return join6(projectRoot ?? process.cwd(), PROJECT_COMMANDS_DIR);
+}
+function getConfigPath(scope, projectRoot) {
+  if (scope === "global") return GLOBAL_CONFIG_PATH;
+  return join6(projectRoot ?? process.cwd(), PROJECT_CONFIG_FILE);
+}
+var GLOBAL_PROFILES_DIR = join6(GLOBAL_DIR, "profiles");
+var GLOBAL_REPOS_DIR = join6(GLOBAL_DIR, "repos");
+function getProfileDir(profileName) {
+  return join6(GLOBAL_PROFILES_DIR, profileName);
+}
+function getProfileCommandsDir(profileName) {
+  return join6(GLOBAL_PROFILES_DIR, profileName, "commands");
+}
+
+// src/lib/config.ts
+function loadConfig(scope, projectRoot) {
+  const configPath = getConfigPath(scope, projectRoot);
+  if (!existsSync3(configPath)) return { targets: [] };
+  const raw = readYaml(configPath);
+  return {
+    targets: Array.isArray(raw.targets) ? raw.targets : [],
+    activeProfile: typeof raw.activeProfile === "string" ? raw.activeProfile : void 0,
+    repos: Array.isArray(raw.repos) ? raw.repos : void 0
+  };
+}
+function saveConfig(config, scope, projectRoot) {
+  const configPath = getConfigPath(scope, projectRoot);
+  const data = { targets: config.targets };
+  if (config.activeProfile) data.activeProfile = config.activeProfile;
+  if (config.repos && config.repos.length > 0) data.repos = config.repos;
+  writeYaml(configPath, data);
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  const scope = options.global ? "global" : "project";
+  const cwd = process.cwd();
+  if (scope === "project" && existsSync4(join7(cwd, PROJECT_CONFIG_FILE))) {
+    console.log(chalk.yellow("Already initialized in this directory."));
+    return;
+  }
+  if (scope === "global" && existsSync4(join7(GLOBAL_DIR, "config.yml"))) {
+    console.log(chalk.yellow("Global config already exists at ~/.agent-mgr/"));
+    return;
+  }
+  let targets;
+  if (options.all) {
+    targets = ALL_TARGET_IDS;
+  } else if (options.targets) {
+    targets = options.targets.split(",").map((t) => t.trim());
+    const invalid = targets.filter((t) => !ALL_TARGET_IDS.includes(t));
+    if (invalid.length > 0) {
+      console.log(chalk.red(`Unknown targets: ${invalid.join(", ")}`));
+      console.log(chalk.dim(`Available: ${ALL_TARGET_IDS.join(", ")}`));
+      return;
+    }
+  } else {
+    targets = await checkbox({
+      message: "What platforms do you want to sync?",
+      choices: [
+        { name: "Claude Code", value: "claude-code" },
+        { name: "Cursor", value: "cursor" },
+        { name: "Codex", value: "codex" },
+        { name: "OpenCode", value: "opencode" }
+      ]
+    });
+  }
+  if (targets.length === 0) {
+    console.log(chalk.red("No targets selected. Aborting."));
+    return;
+  }
+  if (scope === "global") {
+    ensureDir(GLOBAL_DIR);
+    ensureDir(GLOBAL_COMMANDS_DIR);
+    saveConfig({ targets }, "global");
+    console.log(chalk.green("\u2713 Created ~/.agent-mgr/config.yml"));
+    console.log(chalk.green("\u2713 Created ~/.agent-mgr/commands/"));
+  } else {
+    const commandsDir = join7(cwd, PROJECT_COMMANDS_DIR);
+    ensureDir(commandsDir);
+    saveConfig({ targets }, "project", cwd);
+    console.log(chalk.green(`\u2713 Created ${PROJECT_CONFIG_FILE}`));
+    console.log(chalk.green(`\u2713 Created ${PROJECT_COMMANDS_DIR}/`));
+    if (existsSync4(join7(cwd, ".git"))) {
+      const shouldGitignore = options.gitignore !== void 0 ? options.gitignore : await confirm({
+        message: "Gitignore agent-mgr config and generated files?",
+        default: true
+      });
+      if (shouldGitignore) {
+        addGitExclude(cwd);
+        console.log(chalk.green("\u2713 Added agent-mgr files to .git/info/exclude"));
+      }
+    }
+  }
+  console.log(chalk.dim("\nAdd commands with: amgr add <name>"));
+  console.log(chalk.dim("Sync with: amgr sync"));
+  console.log("");
+  console.log(chalk.bold("Tip:") + " This tool works best when your AI agent helps you configure it.");
+  console.log(chalk.dim("Ask your agent to run `amgr help-agent` to learn what it can do, or run:"));
+  console.log(chalk.cyan("  amgr help       ") + chalk.dim("\u2014 see all commands"));
+  console.log(chalk.cyan("  amgr help-agent ") + chalk.dim("\u2014 give your AI agent the full reference"));
+}
+
+// src/commands/add.ts
+import { join as join8 } from "path";
+import { existsSync as existsSync5, writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+import chalk2 from "chalk";
+function addCommand(name, options) {
+  const scope = options.global ? "global" : "project";
+  let commandsDir;
+  if (scope === "global") {
+    commandsDir = GLOBAL_COMMANDS_DIR;
+  } else {
+    const root = findProjectRoot();
+    if (!root) {
+      console.log(chalk2.red("Not in an agent-mgr project. Run `agent-mgr init` first."));
+      return;
+    }
+    commandsDir = getCommandsDir("project", root);
+  }
+  const cleanName = name.replace(/\.md$/, "");
+  const filePath = join8(commandsDir, `${cleanName}.md`);
+  if (existsSync5(filePath)) {
+    console.log(chalk2.yellow(`Command "${cleanName}" already exists at ${filePath}`));
+    return;
+  }
+  ensureDir(commandsDir);
+  let fileContent;
+  if (options.from) {
+    const sourcePath = options.from;
+    if (!existsSync5(sourcePath)) {
+      console.log(chalk2.red(`File not found: ${sourcePath}`));
+      return;
+    }
+    const sourceContent = readFileSync2(sourcePath, "utf-8");
+    if (sourceContent.trimStart().startsWith("---")) {
+      fileContent = sourceContent;
+    } else {
+      fileContent = `---
+description: ${cleanName} command
+---
+
+${sourceContent}`;
+    }
+  } else if (options.content) {
+    fileContent = `---
+description: ${cleanName} command
+---
+
+${options.content}
+
+$ARGUMENTS
+`;
+  } else {
+    fileContent = `---
+description: ${cleanName} command
+---
+
+$ARGUMENTS
+`;
+  }
+  writeFileSync2(filePath, fileContent);
+  console.log(chalk2.green(`\u2713 Created ${filePath}`));
+  console.log(chalk2.dim("Sync with: amgr sync"));
+}
+
+// src/commands/remove.ts
+import { join as join9 } from "path";
+import chalk3 from "chalk";
+async function removeCommand(name, options) {
+  const scope = options.global ? "global" : "project";
+  const cleanName = name.replace(/\.md$/, "");
+  let commandsDir;
+  let projectRoot;
+  if (scope === "global") {
+    commandsDir = GLOBAL_COMMANDS_DIR;
+    projectRoot = "";
+  } else {
+    const root = findProjectRoot();
+    if (!root) {
+      console.log(chalk3.red("Not in an agent-mgr project. Run `agent-mgr init` first."));
+      return;
+    }
+    projectRoot = root;
+    commandsDir = getCommandsDir("project", root);
+  }
+  const sourcePath = join9(commandsDir, `${cleanName}.md`);
+  const removed = removeFile(sourcePath);
+  if (!removed) {
+    console.log(chalk3.red(`Command "${cleanName}" not found.`));
+    return;
+  }
+  console.log(chalk3.green(`\u2713 Removed ${sourcePath}`));
+  const config = loadConfig(scope === "global" ? "global" : "project", projectRoot || void 0);
+  const targetAdapters = getAdapters(config.targets);
+  for (const adapter of targetAdapters) {
+    if (!adapter.supportsCommands) continue;
+    const dir = adapter.getCommandsDir(scope, projectRoot);
+    if (dir) {
+      const targetPath = join9(dir, `${cleanName}.md`);
+      if (removeFile(targetPath)) {
+        console.log(chalk3.green(`\u2713 Removed from ${adapter.name}`));
+      }
+    }
+    if (adapter.removeCommand) {
+      const didRemove = await adapter.removeCommand(cleanName, scope, projectRoot);
+      if (didRemove) {
+        console.log(chalk3.green(`\u2713 Removed from ${adapter.name} config`));
+      }
+    }
+  }
+}
+
+// src/commands/sync.ts
+import { join as join10 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import chalk4 from "chalk";
+function collectCommands(projectRoot) {
+  const seen = /* @__PURE__ */ new Map();
+  const globalConfig = loadConfig("global");
+  const globalFiles = listMarkdownFiles(GLOBAL_COMMANDS_DIR);
+  for (const file of globalFiles) {
+    seen.set(file, { file, sourcePath: join10(GLOBAL_COMMANDS_DIR, file), scope: "global" });
+  }
+  if (globalConfig.activeProfile) {
+    const profileDir = getProfileCommandsDir(globalConfig.activeProfile);
+    const profileFiles = listMarkdownFiles(profileDir);
+    for (const file of profileFiles) {
+      seen.set(file, { file, sourcePath: join10(profileDir, file), scope: "profile" });
+    }
+  }
+  if (projectRoot) {
+    const projectDir = getCommandsDir("project", projectRoot);
+    const projectFiles = listMarkdownFiles(projectDir);
+    for (const file of projectFiles) {
+      seen.set(file, { file, sourcePath: join10(projectDir, file), scope: "project" });
+    }
+  }
+  return Array.from(seen.values());
+}
+async function syncCommand(options) {
+  if (options.global) {
+    syncSingleScope("global", "", GLOBAL_COMMANDS_DIR);
+    return;
+  }
+  const root = findProjectRoot();
+  if (!root) {
+    console.log(chalk4.red("Not in an agent-mgr project. Run `agent-mgr init` first."));
+    return;
+  }
+  const config = loadConfig("project", root);
+  if (config.targets.length === 0) {
+    console.log(chalk4.red("No targets configured. Run `agent-mgr init` first."));
+    return;
+  }
+  const commands = collectCommands(root);
+  if (commands.length === 0) {
+    console.log(chalk4.yellow("No commands found. Add some with: amgr add <name>"));
+    return;
+  }
+  const targetAdapters = getAdapters(config.targets);
+  const results = [];
+  for (const cmd of commands) {
+    for (const adapter of targetAdapters) {
+      if (!adapter.supportsCommands) {
+        results.push({ target: adapter.name, command: cmd.file, status: "skipped", reason: "no command support", scope: cmd.scope });
+        continue;
+      }
+      try {
+        if (adapter.syncCommand) {
+          const raw = readFileSync3(cmd.sourcePath, "utf-8");
+          const { description, body } = parseFrontmatter(raw);
+          const cmdName = cmd.file.replace(/\.md$/, "");
+          await adapter.syncCommand(cmdName, description, body, "project", root);
+          results.push({ target: adapter.name, command: cmd.file, status: "synced", scope: cmd.scope });
+        } else {
+          const targetDir = adapter.getCommandsDir("project", root);
+          if (!targetDir) {
+            results.push({ target: adapter.name, command: cmd.file, status: "skipped", reason: "no directory for scope", scope: cmd.scope });
+            continue;
+          }
+          const destPath = join10(targetDir, cmd.file);
+          syncFile(cmd.sourcePath, destPath);
+          results.push({ target: adapter.name, command: cmd.file, status: "synced", scope: cmd.scope });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        results.push({ target: adapter.name, command: cmd.file, status: "failed", reason: msg, scope: cmd.scope });
+      }
+    }
+  }
+  let synced = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const r of results) {
+    if (r.status === "synced") {
+      const scopeTag = chalk4.dim(`[${r.scope}]`);
+      console.log(chalk4.green(`\u2713 ${r.command} \u2192 ${r.target} ${scopeTag}`));
+      synced++;
+    } else if (r.status === "skipped") {
+      skipped++;
+    } else {
+      console.log(chalk4.red(`\u2717 ${r.command} \u2192 ${r.target}: ${r.reason}`));
+      failed++;
+    }
+  }
+  const sourceFileNames = new Set(commands.map((c) => c.file));
+  for (const adapter of targetAdapters) {
+    if (!adapter.supportsCommands) continue;
+    const targetDir = adapter.getCommandsDir("project", root);
+    if (!targetDir) continue;
+    const existingFiles = listMarkdownFiles(targetDir);
+    for (const existing of existingFiles) {
+      if (!sourceFileNames.has(existing)) {
+        const stalePath = join10(targetDir, existing);
+        if (removeFile(stalePath)) {
+          console.log(chalk4.dim(`  Pruned ${existing} from ${adapter.name}`));
+        }
+      }
+    }
+  }
+  updateGitExclude(root);
+  console.log("");
+  console.log(`Synced ${chalk4.green(String(synced))} command(s) to ${targetAdapters.filter((a) => a.supportsCommands).length} target(s)`);
+  if (skipped > 0) console.log(chalk4.dim(`Skipped ${skipped} (no command support)`));
+  if (failed > 0) console.log(chalk4.red(`Failed: ${failed}`));
+}
+async function syncSingleScope(scope, projectRoot, commandsDir) {
+  const config = loadConfig(scope, projectRoot || void 0);
+  if (config.targets.length === 0) {
+    console.log(chalk4.red("No targets configured."));
+    return;
+  }
+  const files = listMarkdownFiles(commandsDir);
+  if (files.length === 0) {
+    console.log(chalk4.yellow("No commands found."));
+    return;
+  }
+  const targetAdapters = getAdapters(config.targets);
+  let synced = 0;
+  for (const file of files) {
+    const sourcePath = join10(commandsDir, file);
+    for (const adapter of targetAdapters) {
+      if (!adapter.supportsCommands) continue;
+      try {
+        if (adapter.syncCommand) {
+          const raw = readFileSync3(sourcePath, "utf-8");
+          const { description, body } = parseFrontmatter(raw);
+          const cmdName = file.replace(/\.md$/, "");
+          await adapter.syncCommand(cmdName, description, body, scope, projectRoot);
+        } else {
+          const targetDir = adapter.getCommandsDir(scope, projectRoot);
+          if (!targetDir) continue;
+          syncFile(sourcePath, join10(targetDir, file));
+        }
+        console.log(chalk4.green(`\u2713 ${file} \u2192 ${adapter.name}`));
+        synced++;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(chalk4.red(`\u2717 ${file} \u2192 ${adapter.name}: ${msg}`));
+      }
+    }
+  }
+  console.log(`
+Synced ${chalk4.green(String(synced))} command(s)`);
+}
+
+// src/commands/list.ts
+import { join as join11 } from "path";
+import { existsSync as existsSync6, lstatSync, readlinkSync } from "fs";
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import chalk5 from "chalk";
+function collectAllCommands(projectRoot) {
+  const seen = /* @__PURE__ */ new Map();
+  const globalFiles = listMarkdownFiles(GLOBAL_COMMANDS_DIR);
+  for (const file of globalFiles) {
+    seen.set(file, { file, sourcePath: join11(GLOBAL_COMMANDS_DIR, file), scope: "global" });
+  }
+  const globalConfig = loadConfig("global");
+  if (globalConfig.activeProfile) {
+    const profileDir = getProfileCommandsDir(globalConfig.activeProfile);
+    const profileFiles = listMarkdownFiles(profileDir);
+    for (const file of profileFiles) {
+      seen.set(file, { file, sourcePath: join11(profileDir, file), scope: "profile" });
+    }
+  }
+  if (projectRoot) {
+    const projectDir = getCommandsDir("project", projectRoot);
+    const projectFiles = listMarkdownFiles(projectDir);
+    for (const file of projectFiles) {
+      seen.set(file, { file, sourcePath: join11(projectDir, file), scope: "project" });
+    }
+  }
+  return Array.from(seen.values());
+}
+function listCommand(options) {
+  let projectRoot = null;
+  if (!options.global) {
+    projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      console.log(chalk5.red("Not in an agent-mgr project. Run `agent-mgr init` first."));
+      return;
+    }
+  }
+  const config = options.global ? loadConfig("global") : loadConfig("project", projectRoot);
+  const targetAdapters = getAdapters(config.targets).filter((a) => a.supportsCommands);
+  const commands = options.global ? listMarkdownFiles(GLOBAL_COMMANDS_DIR).map((f) => ({ file: f, sourcePath: join11(GLOBAL_COMMANDS_DIR, f), scope: "global" })) : collectAllCommands(projectRoot);
+  if (commands.length === 0) {
+    console.log(chalk5.yellow("No commands found."));
+    return;
+  }
+  console.log(chalk5.bold("\nCommands:\n"));
+  for (const cmd of commands) {
+    const statuses = [];
+    for (const adapter of targetAdapters) {
+      const dir = adapter.getCommandsDir(options.global ? "global" : "project", projectRoot ?? "");
+      if (!dir) {
+        statuses.push(chalk5.dim(`${adapter.id} \u2014`));
+        continue;
+      }
+      const targetPath = join11(dir, cmd.file);
+      if (existsSync6(targetPath)) {
+        const isSymlink = lstatSync(targetPath).isSymbolicLink();
+        if (isSymlink) {
+          const linkTarget = resolve2(dirname2(targetPath), readlinkSync(targetPath));
+          const inSync = linkTarget === resolve2(cmd.sourcePath);
+          statuses.push(inSync ? chalk5.green(`${adapter.id} \u2713`) : chalk5.yellow(`${adapter.id} \u26A0`));
+        } else {
+          statuses.push(chalk5.yellow(`${adapter.id} \u2713 (copy)`));
+        }
+      } else {
+        statuses.push(chalk5.red(`${adapter.id} \u2717`));
+      }
+    }
+    const scopeTag = chalk5.dim(`[${cmd.scope}]`);
+    console.log(`  ${cmd.file.padEnd(25)} ${scopeTag.padEnd(20)} ${statuses.join("  ")}`);
+  }
+  console.log("");
+}
+
+// src/commands/mcp-add.ts
+import chalk6 from "chalk";
+import { input, checkbox as checkbox2 } from "@inquirer/prompts";
+async function mcpAddCommand(options) {
+  const scope = options.global ? "global" : "project";
+  let projectRoot;
+  if (scope === "project") {
+    const root = findProjectRoot();
+    if (!root) {
+      console.log(chalk6.red("Not in an agent-mgr project. Run `agent-mgr init` first."));
+      return;
+    }
+    projectRoot = root;
+  } else {
+    projectRoot = "";
+  }
+  const config = loadConfig(scope, projectRoot || void 0);
+  const name = await input({ message: "MCP server name:" });
+  const command = await input({ message: "Command:" });
+  const argsRaw = await input({ message: "Arguments (space-separated, or empty):" });
+  const envRaw = await input({ message: "Environment variables (KEY=VAL KEY=VAL, or empty):" });
+  const args = argsRaw.trim() ? argsRaw.trim().split(/\s+/) : void 0;
+  const env = envRaw.trim() ? Object.fromEntries(envRaw.trim().split(/\s+/).map((pair) => {
+    const [k, ...v] = pair.split("=");
+    return [k, v.join("=")];
+  })) : void 0;
+  const availableTargets = config.targets.length > 0 ? config.targets : ALL_TARGET_IDS;
+  const targets = await checkbox2({
+    message: "Which tools?",
+    choices: availableTargets.map((id) => ({ name: id, value: id }))
+  });
+  const targetAdapters = getAdapters(targets);
+  for (const adapter of targetAdapters) {
+    try {
+      await adapter.writeMcpConfig(
+        { [name]: { name, command, args: args ?? [], env: env ?? {} } },
+        scope,
+        projectRoot
+      );
+      console.log(chalk6.green(`\u2713 ${name} \u2192 ${adapter.name}`));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk6.red(`\u2717 ${adapter.name}: ${msg}`));
+    }
+  }
+}
+
+// src/commands/mcp-remove.ts
+import chalk7 from "chalk";
+async function mcpRemoveCommand(name, options) {
+  const scope = options.global ? "global" : "project";
+  let projectRoot;
+  if (scope === "project") {
+    const root = findProjectRoot();
+    if (!root) {
+      console.log(chalk7.red("Not in an agent-mgr project. Run `agent-mgr init` first."));
+      return;
+    }
+    projectRoot = root;
+  } else {
+    projectRoot = "";
+  }
+  const config = loadConfig(scope, projectRoot || void 0);
+  const targetAdapters = getAdapters(config.targets);
+  for (const adapter of targetAdapters) {
+    try {
+      const mcpPath = adapter.getMcpConfigPath(scope, projectRoot);
+      const data = readJson(mcpPath);
+      if (data.mcpServers && name in data.mcpServers) {
+        delete data.mcpServers[name];
+        writeJson(mcpPath, data);
+        console.log(chalk7.green(`\u2713 Removed ${name} from ${adapter.name}`));
+      } else {
+        console.log(chalk7.dim(`  ${adapter.name}: ${name} not found`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk7.red(`\u2717 ${adapter.name}: ${msg}`));
+    }
+  }
+}
+
+// src/commands/mcp-list.ts
+import chalk8 from "chalk";
+async function mcpListCommand(options) {
+  const scope = options.global ? "global" : "project";
+  let projectRoot;
+  if (scope === "project") {
+    const root = findProjectRoot();
+    if (!root) {
+      console.log(chalk8.red("Not in an agent-mgr project. Run `agent-mgr init` first."));
+      return;
+    }
+    projectRoot = root;
+  } else {
+    projectRoot = "";
+  }
+  const config = loadConfig(scope, projectRoot || void 0);
+  const targetAdapters = getAdapters(config.targets);
+  const serversByTarget = /* @__PURE__ */ new Map();
+  const allServers = /* @__PURE__ */ new Set();
+  for (const adapter of targetAdapters) {
+    try {
+      const servers = await adapter.readMcpConfig(scope, projectRoot);
+      const names = new Set(Object.keys(servers));
+      serversByTarget.set(adapter.id, names);
+      for (const n of names) allServers.add(n);
+    } catch {
+      serversByTarget.set(adapter.id, /* @__PURE__ */ new Set());
+    }
+  }
+  if (allServers.size === 0) {
+    console.log(chalk8.yellow("No MCP servers configured."));
+    return;
+  }
+  console.log(chalk8.bold("\nMCP Servers:\n"));
+  for (const server of allServers) {
+    const statuses = [];
+    for (const adapter of targetAdapters) {
+      const has = serversByTarget.get(adapter.id)?.has(server);
+      statuses.push(has ? chalk8.green(`${adapter.id} \u2713`) : chalk8.red(`${adapter.id} \u2717`));
+    }
+    console.log(`  ${server.padEnd(25)} ${statuses.join("  ")}`);
+  }
+  console.log("");
+}
+
+// src/commands/hook.ts
+import { join as join12 } from "path";
+import { existsSync as existsSync7, writeFileSync as writeFileSync3, readFileSync as readFileSync4, chmodSync } from "fs";
+import chalk9 from "chalk";
+var HOOK_MARKER = "# agent-mgr auto-sync";
+var HOOK_CONTENT = `${HOOK_MARKER}
+npx agent-mgr sync 2>/dev/null || true
+`;
+function hookInstallCommand() {
+  const gitDir = join12(process.cwd(), ".git");
+  if (!existsSync7(gitDir)) {
+    console.log(chalk9.red("Not a git repository."));
+    return;
+  }
+  const hooksDir = join12(gitDir, "hooks");
+  ensureDir(hooksDir);
+  const hookNames = ["post-checkout", "post-merge"];
+  for (const hookName of hookNames) {
+    const hookPath = join12(hooksDir, hookName);
+    if (existsSync7(hookPath)) {
+      const content = readFileSync4(hookPath, "utf-8");
+      if (content.includes(HOOK_MARKER)) {
+        console.log(chalk9.dim(`  ${hookName}: already installed`));
+        continue;
+      }
+      writeFileSync3(hookPath, content.trimEnd() + "\n\n" + HOOK_CONTENT);
+    } else {
+      writeFileSync3(hookPath, "#!/bin/sh\n\n" + HOOK_CONTENT);
+    }
+    chmodSync(hookPath, 493);
+    console.log(chalk9.green(`\u2713 Installed ${hookName} hook`));
+  }
+}
+function hookRemoveCommand() {
+  const gitDir = join12(process.cwd(), ".git");
+  if (!existsSync7(gitDir)) {
+    console.log(chalk9.red("Not a git repository."));
+    return;
+  }
+  const hookNames = ["post-checkout", "post-merge"];
+  for (const hookName of hookNames) {
+    const hookPath = join12(join12(gitDir, "hooks"), hookName);
+    if (!existsSync7(hookPath)) continue;
+    const content = readFileSync4(hookPath, "utf-8");
+    if (!content.includes(HOOK_MARKER)) continue;
+    const lines = content.split("\n");
+    const filtered = lines.filter(
+      (line) => !line.includes(HOOK_MARKER) && !line.includes("npx agent-mgr sync")
+    );
+    const cleaned = filtered.join("\n").trim();
+    if (cleaned === "#!/bin/sh" || cleaned === "") {
+      writeFileSync3(hookPath, "#!/bin/sh\n");
+    } else {
+      writeFileSync3(hookPath, cleaned + "\n");
+    }
+    console.log(chalk9.green(`\u2713 Removed ${hookName} hook`));
+  }
+}
+
+// src/commands/help-agent.ts
+import chalk10 from "chalk";
+var AGENT_PROMPT = `# agent-mgr \u2014 CLI Tool Reference
+
+You have access to \`agent-mgr\` (alias: \`amgr\`), a CLI tool that manages AI agent commands, prompts, and MCP server configs across multiple platforms (Claude Code, Cursor, Codex, OpenCode).
+
+## How It Works
+
+Commands are markdown files stored in source directories. When synced, they get symlinked to each platform's expected directory. Commands are merged from three scopes with priority: project > profile > global.
+
+## Available Commands
+
+### Setup
+- \`amgr init\` \u2014 Initialize in current repo (interactive)
+- \`amgr init --all --gitignore\` \u2014 Init with all platforms, gitignore generated dirs
+- \`amgr init --targets claude-code,cursor\` \u2014 Init with specific platforms
+- \`amgr init --global\` \u2014 Initialize global config at ~/.agent-mgr/
+
+### Managing Commands
+- \`amgr add <name>\` \u2014 Create a new command template
+- \`amgr add <name> --from <path>\` \u2014 Import command from an existing .md file
+- \`amgr add <name> --content "prompt text"\` \u2014 Create command with inline content
+- \`amgr add <name> --global\` \u2014 Add to global commands
+- \`amgr remove <name>\` \u2014 Remove command from source and all synced targets
+- \`amgr list\` \u2014 Show all commands with scope and sync status per platform
+
+### Syncing
+- \`amgr sync\` \u2014 Merge and distribute project + profile + global commands
+- \`amgr sync --global\` \u2014 Sync global commands only
+
+### Profiles
+- \`amgr profile create <name>\` \u2014 Create a named command set
+- \`amgr profile switch <name>\` \u2014 Activate a profile
+- \`amgr profile list\` \u2014 Show all profiles and which is active
+- \`amgr profile delete <name>\` \u2014 Delete a profile
+
+### Import from GitHub
+- \`amgr sync-repo add <url>\` \u2014 Clone a repo and import its commands/ directory
+- \`amgr sync-repo add <url> --profile <name>\` \u2014 Import into a specific profile
+- \`amgr sync-repo update\` \u2014 Pull latest from all tracked repos
+- \`amgr sync-repo list\` \u2014 Show tracked repos
+- \`amgr sync-repo remove <url>\` \u2014 Stop tracking a repo
+
+### MCP Server Management
+- \`amgr mcp add\` \u2014 Interactive: add an MCP server config to selected platforms
+- \`amgr mcp remove <name>\` \u2014 Remove MCP server from all platforms
+- \`amgr mcp list\` \u2014 Show MCP servers and which platforms have them
+
+### Git Hooks
+- \`amgr hook install\` \u2014 Install post-checkout/post-merge hooks for auto-sync
+- \`amgr hook remove\` \u2014 Remove the git hooks
+
+### Help
+- \`amgr help\` \u2014 Detailed help with workflow and examples
+- \`amgr help-agent\` \u2014 Output this reference (for AI agents)
+
+## Command File Format
+
+Commands are markdown files with optional YAML frontmatter:
+
+\`\`\`markdown
+---
+description: What this command does
+---
+
+Your prompt content here.
+
+$ARGUMENTS
+\`\`\`
+
+\`$ARGUMENTS\` gets replaced with whatever the user types after the slash command.
+
+## Command Priority (when syncing)
+
+1. Project commands (\`commands/\`) \u2014 highest priority
+2. Active profile commands (\`~/.agent-mgr/profiles/<name>/commands/\`)
+3. Global commands (\`~/.agent-mgr/commands/\`) \u2014 lowest priority
+
+Same filename = higher scope wins.
+
+## Config Files
+
+- Project config: \`.agent-mgr.yml\` (targets, overrides)
+- Global config: \`~/.agent-mgr/config.yml\` (targets, active profile, tracked repos)
+- Source commands: \`commands/\` (project) or \`~/.agent-mgr/commands/\` (global)
+- Profiles: \`~/.agent-mgr/profiles/<name>/commands/\`
+- Repo cache: \`~/.agent-mgr/repos/\`
+
+## Supported Platforms
+
+| Platform | Commands | MCP |
+|----------|----------|-----|
+| Claude Code | \u2713 (.claude/commands/) | \u2713 (.claude/mcp.json) |
+| Cursor | \u2713 (.cursor/prompts/) | \u2713 (.cursor/mcp.json) |
+| Codex | \u2717 | \u2713 (.codex/mcp.json) |
+| OpenCode | \u2717 | \u2713 (opencode.json) |
+`;
+function helpAgentCommand() {
+  console.log(AGENT_PROMPT);
+  console.log(chalk10.dim("Copy the above and paste it to your AI agent, or pipe it:"));
+  console.log(chalk10.dim("  amgr help-agent | pbcopy"));
+}
+
+// src/commands/help-rich.ts
+import chalk11 from "chalk";
+function helpCommand() {
+  console.log(`
+${chalk11.bold("agent-manager")} \u2014 Write commands once, sync everywhere.
+
+${chalk11.bold.underline("WORKFLOW")}
+
+  ${chalk11.cyan("1.")} ${chalk11.bold("amgr init")}                    Set up in your repo or globally
+  ${chalk11.cyan("2.")} ${chalk11.bold("amgr add <name>")}              Create a command (or --from/--content)
+  ${chalk11.cyan("3.")} ${chalk11.bold("amgr sync")}                    Distribute to all platforms
+  ${chalk11.cyan("4.")} Use ${chalk11.bold("/command-name")} in your AI tool
+
+${chalk11.bold.underline("COMMANDS")}
+
+  ${chalk11.bold("Setup")}
+  amgr init                         Interactive setup
+  amgr init --all --gitignore       All platforms, auto-gitignore
+  amgr init --global                Global config at ~/.agent-mgr/
+
+  ${chalk11.bold("Commands")}
+  amgr add <name>                   Create template
+  amgr add <name> --from <file>     Import from existing .md
+  amgr add <name> --content "..."   Inline content
+  amgr remove <name>                Delete command + synced copies
+  amgr sync                         Sync all (project + profile + global)
+  amgr list                         Show commands with sync status
+
+  ${chalk11.bold("Profiles")}
+  amgr profile create <name>        Create a named command set
+  amgr profile switch <name>        Activate a profile
+  amgr profile list                 Show all profiles
+  amgr profile delete <name>        Delete a profile
+
+  ${chalk11.bold("Sync from GitHub")}
+  amgr sync-repo add <url>          Import commands from a repo
+  amgr sync-repo update             Pull latest from tracked repos
+  amgr sync-repo list               Show tracked repos
+  amgr sync-repo remove <url>       Stop tracking a repo
+
+  ${chalk11.bold("MCP Servers")}
+  amgr mcp add                      Add MCP server (interactive)
+  amgr mcp remove <name>            Remove from all platforms
+  amgr mcp list                     Show MCP servers per platform
+
+  ${chalk11.bold("Git Hooks")}
+  amgr hook install                 Auto-sync on checkout/merge
+  amgr hook remove                  Remove hooks
+
+  ${chalk11.bold("Help")}
+  amgr help                         This help page
+  amgr help-agent                   Output reference for AI agents
+
+${chalk11.bold.underline("COMMAND PRIORITY")}
+
+  When syncing, commands are merged from three sources:
+  ${chalk11.green("project")} > ${chalk11.blue("profile")} > ${chalk11.dim("global")}
+  If the same filename exists in multiple scopes, the higher priority wins.
+
+${chalk11.bold.underline("CONFIG FILES")}
+
+  Project:  .agent-mgr.yml + commands/
+  Global:   ~/.agent-mgr/config.yml + commands/
+  Profiles: ~/.agent-mgr/profiles/<name>/commands/
+  Repos:    ~/.agent-mgr/repos/ (cached clones)
+`);
+}
+
+// src/commands/profile.ts
+import { existsSync as existsSync8, readdirSync as readdirSync2, rmSync } from "fs";
+import chalk12 from "chalk";
+function profileCreateCommand(name) {
+  const profileDir = getProfileDir(name);
+  if (existsSync8(profileDir)) {
+    console.log(chalk12.yellow(`Profile "${name}" already exists.`));
+    return;
+  }
+  ensureDir(getProfileCommandsDir(name));
+  console.log(chalk12.green(`\u2713 Created profile "${name}"`));
+  console.log(chalk12.dim(`  Commands dir: ${getProfileCommandsDir(name)}`));
+  console.log(chalk12.dim(`  Switch to it: amgr profile switch ${name}`));
+}
+function profileSwitchCommand(name) {
+  const profileDir = getProfileDir(name);
+  if (!existsSync8(profileDir)) {
+    console.log(chalk12.red(`Profile "${name}" does not exist. Create it first: amgr profile create ${name}`));
+    return;
+  }
+  const config = loadConfig("global");
+  config.activeProfile = name;
+  saveConfig(config, "global");
+  console.log(chalk12.green(`\u2713 Switched to profile "${name}"`));
+  console.log(chalk12.dim("Run `amgr sync` to apply."));
+}
+function profileListCommand() {
+  if (!existsSync8(GLOBAL_PROFILES_DIR)) {
+    console.log(chalk12.yellow("No profiles found."));
+    return;
+  }
+  const entries = readdirSync2(GLOBAL_PROFILES_DIR, { withFileTypes: true });
+  const profiles = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  if (profiles.length === 0) {
+    console.log(chalk12.yellow("No profiles found."));
+    return;
+  }
+  const config = loadConfig("global");
+  const active = config.activeProfile;
+  console.log(chalk12.bold("\nProfiles:\n"));
+  for (const p of profiles) {
+    const commands = listMarkdownFiles(getProfileCommandsDir(p));
+    const isActive = p === active;
+    const marker = isActive ? chalk12.green(" (active)") : "";
+    console.log(`  ${p}${marker} \u2014 ${commands.length} command(s)`);
+  }
+  console.log("");
+}
+function profileDeleteCommand(name) {
+  const profileDir = getProfileDir(name);
+  if (!existsSync8(profileDir)) {
+    console.log(chalk12.red(`Profile "${name}" does not exist.`));
+    return;
+  }
+  const config = loadConfig("global");
+  if (config.activeProfile === name) {
+    config.activeProfile = void 0;
+    saveConfig(config, "global");
+  }
+  rmSync(profileDir, { recursive: true, force: true });
+  console.log(chalk12.green(`\u2713 Deleted profile "${name}"`));
+}
+
+// src/commands/sync-repo.ts
+import { join as join13, dirname as dirname3 } from "path";
+import { existsSync as existsSync9, copyFileSync as copyFileSync2, rmSync as rmSync2 } from "fs";
+import { execSync } from "child_process";
+import chalk13 from "chalk";
+function parseRepoUrl(url) {
+  const match = url.match(/^(?:https?:\/\/)?(?:github\.com\/)?([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+?)(?:\.git)?$/);
+  if (!match) return null;
+  const owner = match[1];
+  const name = match[2];
+  const cloneUrl = `https://github.com/${encodeURIComponent(owner)}/${encodeURIComponent(name)}.git`;
+  return { owner, name, cloneUrl };
+}
+function getRepoCacheDir(owner, name) {
+  return join13(GLOBAL_REPOS_DIR, `${owner}-${name}`);
+}
+function syncRepoCommand(url, options) {
+  const parsed = parseRepoUrl(url);
+  if (!parsed) {
+    console.log(chalk13.red("Invalid repo URL. Use: github.com/owner/repo or owner/repo"));
+    return;
+  }
+  const { owner, name, cloneUrl } = parsed;
+  const cacheDir = getRepoCacheDir(owner, name);
+  if (existsSync9(cacheDir)) {
+    console.log(chalk13.dim(`Updating ${owner}/${name}...`));
+    try {
+      execSync("git pull --ff-only", { cwd: cacheDir, stdio: "pipe" });
+    } catch {
+      console.log(chalk13.yellow("Pull failed, re-cloning..."));
+      rmSync2(cacheDir, { recursive: true, force: true });
+      execSync(`git clone --depth 1 ${cloneUrl} ${cacheDir}`, { stdio: "pipe" });
+    }
+  } else {
+    console.log(chalk13.dim(`Cloning ${owner}/${name}...`));
+    ensureDir(GLOBAL_REPOS_DIR);
+    try {
+      execSync(`git clone --depth 1 ${cloneUrl} ${cacheDir}`, { stdio: "pipe" });
+    } catch {
+      console.log(chalk13.red(`Failed to clone ${cloneUrl}. Check the URL and your git authentication.`));
+      return;
+    }
+  }
+  const repoCommandsDir = join13(cacheDir, "commands");
+  if (!existsSync9(repoCommandsDir)) {
+    console.log(chalk13.red(`No commands/ directory found in ${owner}/${name}.`));
+    return;
+  }
+  const files = listMarkdownFiles(repoCommandsDir);
+  if (files.length === 0) {
+    console.log(chalk13.yellow(`No .md files found in ${owner}/${name}/commands/`));
+    return;
+  }
+  let destDir;
+  const config = loadConfig("global");
+  if (options.profile) {
+    destDir = getProfileCommandsDir(options.profile);
+    ensureDir(destDir);
+  } else if (config.activeProfile) {
+    destDir = getProfileCommandsDir(config.activeProfile);
+    ensureDir(destDir);
+  } else {
+    destDir = GLOBAL_COMMANDS_DIR;
+    ensureDir(destDir);
+  }
+  let copied = 0;
+  for (const file of files) {
+    const src = join13(repoCommandsDir, file);
+    const dest = join13(destDir, file);
+    ensureDir(dirname3(dest));
+    copyFileSync2(src, dest);
+    console.log(chalk13.green(`\u2713 ${file}`));
+    copied++;
+  }
+  if (!config.repos) config.repos = [];
+  if (!config.repos.includes(url)) {
+    config.repos.push(url);
+    saveConfig(config, "global");
+  }
+  console.log("");
+  console.log(`Imported ${chalk13.green(String(copied))} command(s) from ${owner}/${name}`);
+  console.log(chalk13.dim("Run `amgr sync` to distribute to your platforms."));
+}
+function syncRepoUpdateCommand() {
+  const config = loadConfig("global");
+  if (!config.repos || config.repos.length === 0) {
+    console.log(chalk13.yellow("No tracked repos. Add one with: amgr sync-repo add <url>"));
+    return;
+  }
+  for (const url of config.repos) {
+    console.log(chalk13.bold(`
+${url}`));
+    syncRepoCommand(url, {});
+  }
+}
+function syncRepoListCommand() {
+  const config = loadConfig("global");
+  if (!config.repos || config.repos.length === 0) {
+    console.log(chalk13.yellow("No tracked repos."));
+    return;
+  }
+  console.log(chalk13.bold("\nTracked repos:\n"));
+  for (const url of config.repos) {
+    const parsed = parseRepoUrl(url);
+    if (parsed) {
+      const cacheDir = getRepoCacheDir(parsed.owner, parsed.name);
+      const cached = existsSync9(cacheDir) ? chalk13.green("cached") : chalk13.dim("not cached");
+      console.log(`  ${url} (${cached})`);
+    } else {
+      console.log(`  ${url}`);
+    }
+  }
+  console.log("");
+}
+function syncRepoRemoveCommand(url) {
+  const config = loadConfig("global");
+  if (!config.repos || !config.repos.includes(url)) {
+    console.log(chalk13.red(`Repo "${url}" is not tracked.`));
+    return;
+  }
+  config.repos = config.repos.filter((r) => r !== url);
+  saveConfig(config, "global");
+  const parsed = parseRepoUrl(url);
+  if (parsed) {
+    const cacheDir = getRepoCacheDir(parsed.owner, parsed.name);
+    if (existsSync9(cacheDir)) {
+      rmSync2(cacheDir, { recursive: true, force: true });
+    }
+  }
+  console.log(chalk13.green(`\u2713 Removed ${url}`));
+}
+
+// src/index.ts
+program.name("agent-mgr").description(
+  "Write commands once, sync everywhere. Manage AI agent commands, prompts, and MCP configs."
+).version("0.2.0");
+program.command("init").description("Initialize agent-mgr in this repo or globally").option("-g, --global", "Initialize global config at ~/.agent-mgr/").option("-t, --targets <targets>", "Comma-separated list of targets (claude-code,cursor,codex,opencode)").option("-a, --all", "Select all available targets").option("--gitignore", "Add generated dirs to .git/info/exclude").option("--no-gitignore", "Skip gitignoring generated dirs").action(initCommand);
+program.command("add <name>").description("Create a new command template").option("-g, --global", "Add to global commands").option("-f, --from <path>", "Import command from an existing .md file").option("-c, --content <text>", "Set the command content inline").action(addCommand);
+program.command("remove <name>").description("Remove a command from source and all targets").option("-g, --global", "Remove from global commands").action(removeCommand);
+program.command("sync").description("Sync all commands to configured targets").option("-g, --global", "Sync global commands").action(syncCommand);
+program.command("list").description("Show commands and their sync status").option("-g, --global", "List global commands").action(listCommand);
+var mcp = program.command("mcp").description("Manage MCP server configs across tools");
+mcp.command("add").description("Add an MCP server to configured targets").option("-g, --global", "Add to global MCP config").action(mcpAddCommand);
+mcp.command("remove <name>").description("Remove an MCP server from all targets").option("-g, --global", "Remove from global MCP config").action(mcpRemoveCommand);
+mcp.command("list").description("List MCP servers across targets").option("-g, --global", "List global MCP servers").action(mcpListCommand);
+var hook = program.command("hook").description("Manage git hooks for auto-sync");
+hook.command("install").description("Install post-checkout and post-merge hooks").action(hookInstallCommand);
+hook.command("remove").description("Remove agent-mgr git hooks").action(hookRemoveCommand);
+program.command("help-agent").description("Output a full reference for AI agents to understand this tool").action(helpAgentCommand);
+var profile = program.command("profile").description("Manage command profiles");
+profile.command("create <name>").description("Create a new profile").action(profileCreateCommand);
+profile.command("switch <name>").description("Switch to a profile").action(profileSwitchCommand);
+profile.command("list").description("List all profiles").action(profileListCommand);
+profile.command("delete <name>").description("Delete a profile").action(profileDeleteCommand);
+var syncRepo = program.command("sync-repo").description("Import commands from a GitHub repo");
+syncRepo.command("add <url>").description("Clone a repo and import its commands").option("-p, --profile <name>", "Import into a specific profile").action(syncRepoCommand);
+syncRepo.command("update").description("Pull latest from all tracked repos").action(syncRepoUpdateCommand);
+syncRepo.command("list").description("List tracked repos").action(syncRepoListCommand);
+syncRepo.command("remove <url>").description("Stop tracking a repo and remove cached clone").action(syncRepoRemoveCommand);
+program.command("help").description("Show detailed help with examples").action(helpCommand);
+program.parse();