tools-manager 0.1.0

package/dist/cli.js

@@ -0,0 +1,2007 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/core/init.ts
+import { dirname as dirname2, join as join6 } from "path";
+import { fileURLToPath } from "url";
+
+// src/core/db.ts
+import { Database } from "bun:sqlite";
+
+// src/core/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function managerRoot() {
+  return process.env.TOOLS_MANAGER_HOME || join(homedir(), ".tools-manager");
+}
+function paths() {
+  const root = managerRoot();
+  return {
+    root,
+    skillsDir: join(root, "skills"),
+    cacheGitDir: join(root, "cache", "git"),
+    logsDir: join(root, "logs"),
+    dbPath: join(root, "tools-manager.db"),
+    configPath: join(root, "config.toml")
+  };
+}
+function expandHome(input) {
+  if (input === "~")
+    return homedir();
+  if (input.startsWith("~/"))
+    return join(homedir(), input.slice(2));
+  return input;
+}
+
+// src/core/fs.ts
+import { mkdir, readdir, readFile, rm, stat, symlink, copyFile, lstat, writeFile } from "fs/promises";
+import { dirname, join as join2 } from "path";
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+async function readTextIfExists(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function writeText(path, contents) {
+  await ensureDir(dirname(path));
+  await writeFile(path, contents, "utf8");
+}
+async function backupFile(path) {
+  if (!await pathExists(path))
+    return null;
+  const backup = `${path}.bak.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+  await copyFile(path, backup);
+  return backup;
+}
+async function copyDir(src, dst) {
+  await rm(dst, { recursive: true, force: true });
+  await ensureDir(dst);
+  for (const entry of await readdir(src, { withFileTypes: true })) {
+    if (entry.name === ".git")
+      continue;
+    const source = join2(src, entry.name);
+    const target = join2(dst, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(source, target);
+    } else if (entry.isSymbolicLink()) {
+      const real = await Bun.file(source).arrayBuffer();
+      await Bun.write(target, real);
+    } else {
+      await copyFile(source, target);
+    }
+  }
+}
+async function removePath(path) {
+  await rm(path, { recursive: true, force: true });
+}
+async function syncDir(src, dst, mode) {
+  await ensureDir(dirname(dst));
+  await rm(dst, { recursive: true, force: true });
+  if (mode === "symlink") {
+    try {
+      await symlink(src, dst, "dir");
+      return "symlink";
+    } catch {
+      await copyDir(src, dst);
+      return "copy";
+    }
+  }
+  await copyDir(src, dst);
+  return "copy";
+}
+async function replaceWithSymlink(src, dst) {
+  await rm(dst, { recursive: true, force: true });
+  await ensureDir(dirname(dst));
+  await symlink(src, dst, "dir");
+}
+
+// src/core/db.ts
+var database = null;
+async function openDb() {
+  if (database)
+    return database;
+  const p = paths();
+  await ensureDir(p.root);
+  database = new Database(p.dbPath);
+  database.exec("PRAGMA journal_mode = WAL");
+  migrate(database);
+  ensureDefaultPreset(database);
+  return database;
+}
+function closeDb() {
+  database?.close();
+  database = null;
+}
+function migrate(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS skills (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT,
+      path TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      source_url TEXT,
+      source_ref TEXT,
+      source_subpath TEXT,
+      source_commit TEXT,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS presets (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS preset_skills (
+      preset_id INTEGER NOT NULL,
+      skill_id INTEGER NOT NULL,
+      PRIMARY KEY (preset_id, skill_id),
+      FOREIGN KEY (preset_id) REFERENCES presets(id) ON DELETE CASCADE,
+      FOREIGN KEY (skill_id) REFERENCES skills(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS mcp_servers (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      command TEXT NOT NULL,
+      args_json TEXT NOT NULL,
+      env_json TEXT NOT NULL,
+      target_tools_json TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+}
+function ensureDefaultPreset(db) {
+  db.query("INSERT OR IGNORE INTO presets (name) VALUES (?)").run("Default");
+}
+
+// src/core/config.ts
+async function ensureConfig() {
+  const p = paths();
+  await ensureDir(p.root);
+  if (!await pathExists(p.configPath)) {
+    await writeText(p.configPath, [
+      "# Tools Manager configuration",
+      'sync_mode = "symlink"',
+      "",
+      "# Optional remote used by `tm backup`.",
+      '# git_remote = "git@github.com:you/tools-manager-skills.git"',
+      ""
+    ].join(`
+`));
+  }
+}
+async function readConfig() {
+  await ensureConfig();
+  const text = await readTextIfExists(paths().configPath) || "";
+  const syncMode = /sync_mode\s*=\s*"copy"/.test(text) ? "copy" : "symlink";
+  const remoteMatch = text.match(/git_remote\s*=\s*"([^"]+)"/);
+  return {
+    syncMode,
+    ...remoteMatch?.[1] ? { gitRemote: remoteMatch[1] } : {}
+  };
+}
+
+// src/core/skill.ts
+import { basename, join as join5, resolve } from "path";
+import { lstat as lstat2, readdir as readdir2, readFile as readFile2, realpath, stat as stat2 } from "fs/promises";
+
+// src/core/git.ts
+import { createHash } from "crypto";
+import { join as join3 } from "path";
+
+// src/core/errors.ts
+class UsageError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+}
+function assertUsage(condition, message) {
+  if (!condition) {
+    throw new UsageError(message);
+  }
+}
+
+// src/core/git.ts
+function isGitSource(source) {
+  return /^https?:\/\/.+/.test(source) || /^file:\/\/.+/.test(source) || /^ssh:\/\/.+/.test(source) || /^[^@\s]+@[^:\s]+:.+/.test(source) || source.endsWith(".git");
+}
+function parseGitSource(source) {
+  const hashIndex = source.indexOf("#");
+  if (hashIndex === -1)
+    return { url: source };
+  const url = source.slice(0, hashIndex);
+  const spec = source.slice(hashIndex + 1);
+  assertUsage(url.length > 0, "Git URL is empty.");
+  assertUsage(spec.length > 0, "Git ref after # is empty.");
+  const colonIndex = spec.indexOf(":");
+  if (colonIndex === -1)
+    return { url, ref: spec };
+  const ref = spec.slice(0, colonIndex);
+  const subpath = spec.slice(colonIndex + 1);
+  assertUsage(ref.length > 0, "Git ref before : is empty.");
+  assertUsage(subpath.length > 0, "Git subpath after : is empty.");
+  return { url, ref, subpath };
+}
+async function cloneGitSource(source) {
+  const p = paths();
+  await ensureDir(p.cacheGitDir);
+  const key = createHash("sha1").update(`${source.url}#${source.ref || ""}`).digest("hex");
+  const checkoutDir = join3(p.cacheGitDir, key);
+  await removePath(checkoutDir);
+  const args = ["clone", "--depth", "1"];
+  if (source.ref)
+    args.push("--branch", source.ref);
+  args.push(source.url, checkoutDir);
+  runGit(args, "Failed to clone Git source.");
+  const commitSha = runGit(["-C", checkoutDir, "rev-parse", "HEAD"], "Failed to read Git commit.", true).trim() || null;
+  return { checkoutDir, commitSha };
+}
+function runGit(args, message, capture = false) {
+  const proc = Bun.spawnSync(["git", ...args], {
+    stdout: capture ? "pipe" : "inherit",
+    stderr: "pipe"
+  });
+  if (!proc.success) {
+    const stderr = new TextDecoder().decode(proc.stderr).trim();
+    throw new Error(`${message}${stderr ? `
+${stderr}` : ""}${gitFailureHint(args, stderr)}`);
+  }
+  return capture ? new TextDecoder().decode(proc.stdout) : "";
+}
+function gitFailureHint(args, stderr) {
+  if (args[0] !== "clone")
+    return "";
+  if (!/authentication failed|HTTP Basic: Access denied|Permission denied \(publickey\)/i.test(stderr))
+    return "";
+  return [
+    "",
+    "Git authentication failed. Tools Manager uses your local git command and does not store credentials.",
+    "For private repositories, make sure git can clone this URL first:",
+    "  git clone <repo-url>",
+    "Use a personal access token for HTTPS repositories with 2FA, or use an SSH URL after configuring your SSH key."
+  ].join(`
+`);
+}
+
+// src/core/tools.ts
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+var toolAdapters = [
+  {
+    key: "codex",
+    displayName: "Codex",
+    detectPath: join4(homedir2(), ".codex"),
+    skillsDir: join4(homedir2(), ".codex", "skills"),
+    projectSkillsDir: ".codex/skills",
+    mcpKind: "codex-toml",
+    mcpPath: join4(homedir2(), ".codex", "config.toml")
+  },
+  {
+    key: "claude_code",
+    displayName: "Claude Code",
+    detectPath: join4(homedir2(), ".claude"),
+    skillsDir: join4(homedir2(), ".claude", "skills"),
+    projectSkillsDir: ".claude/skills",
+    mcpKind: "claude-json",
+    mcpPath: join4(homedir2(), ".claude", "mcp.json")
+  },
+  {
+    key: "cursor",
+    displayName: "Cursor",
+    detectPath: join4(homedir2(), ".cursor"),
+    skillsDir: join4(homedir2(), ".cursor", "skills"),
+    projectSkillsDir: ".cursor/skills",
+    mcpKind: "cursor-json",
+    mcpPath: join4(homedir2(), ".cursor", "mcp.json")
+  }
+];
+function getTool(key) {
+  const tool = toolAdapters.find((adapter) => adapter.key === key);
+  if (!tool)
+    throw new Error(`Unknown tool: ${key}. Expected one of: ${toolAdapters.map((t) => t.key).join(", ")}`);
+  return tool;
+}
+function resolveTools(input) {
+  if (!input || input === "all")
+    return toolAdapters;
+  return [getTool(input)];
+}
+async function detectTools() {
+  return Promise.all(toolAdapters.map(async (tool) => ({ ...tool, installed: await pathExists(tool.detectPath) })));
+}
+
+// src/core/skill.ts
+async function findSkillFile(dir) {
+  const canonical = join5(dir, "SKILL.md");
+  if (await pathExists(canonical))
+    return canonical;
+  const legacy = join5(dir, "skill.md");
+  if (await pathExists(legacy))
+    return legacy;
+  return null;
+}
+async function findSkillCandidates(root) {
+  const candidates = [];
+  await walk(root, candidates);
+  return candidates;
+}
+async function walk(dir, candidates) {
+  const skillFile = await findSkillFile(dir);
+  if (skillFile) {
+    candidates.push({ dir, skillFile });
+    return;
+  }
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === ".git" || entry.name === "node_modules")
+      continue;
+    await walk(join5(dir, entry.name), candidates);
+  }
+}
+async function addSkill(source) {
+  const skills = await addSkills(source);
+  return skills[0];
+}
+async function addSkills(source) {
+  await ensureDir(paths().skillsDir);
+  const resolved = isGitSource(source) ? await resolveGitImport(source) : await resolveLocalImport(source);
+  const candidates = await findSkillCandidates(resolved.root);
+  assertUsage(candidates.length > 0, `No skill found in ${resolved.root}. Expected SKILL.md or skill.md.`);
+  const imported = [];
+  for (const candidate of candidates)
+    imported.push(await importCandidate(candidate, resolved.importSource));
+  return imported;
+}
+async function addCodexSkills(skillsDir = getTool("codex").skillsDir) {
+  return addSkillsFromDirectory(skillsDir, "Codex");
+}
+async function addLocalAgentSkills(toolInput, tools = toolAdapters) {
+  if (toolInput === "all")
+    return addAllLocalAgentSkills(tools);
+  const tool = tools.find((adapter) => adapter.key === toolInput) || getTool(toolInput);
+  const skills = await addSkillsFromDirectory(tool.skillsDir, tool.displayName);
+  return [{ tool: tool.key, skills, skipped: false }];
+}
+async function addAllLocalAgentSkills(tools = toolAdapters) {
+  const results = [];
+  for (const tool of tools) {
+    if (!await pathExists(tool.skillsDir)) {
+      results.push({ tool: tool.key, skills: [], skipped: true, reason: `Skills directory does not exist: ${tool.skillsDir}` });
+      continue;
+    }
+    const skills = await addSkillsFromDirectory(tool.skillsDir, tool.displayName, { requireAny: false });
+    results.push({ tool: tool.key, skills, skipped: false });
+  }
+  assertUsage(results.some((result) => result.skills.length > 0), "No local agent skills found.");
+  return results;
+}
+async function listAgentSkills(toolInput = "all", tools = toolAdapters) {
+  const selected = toolInput === "all" ? tools : [tools.find((adapter) => adapter.key === toolInput) || getTool(toolInput)];
+  const results = [];
+  for (const tool of selected) {
+    const skills = [];
+    let entries;
+    try {
+      entries = await readdir2(tool.skillsDir, { withFileTypes: true });
+    } catch {
+      results.push({ tool: tool.key, path: tool.skillsDir, skills });
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink() || entry.name.startsWith("."))
+        continue;
+      const dir = join5(tool.skillsDir, entry.name);
+      const skillFile = await findSkillFile(dir);
+      if (!skillFile)
+        continue;
+      const meta = await readSkillMetadata(skillFile);
+      skills.push({
+        tool: tool.key,
+        name: slug(meta.name || entry.name),
+        description: meta.description,
+        path: dir
+      });
+    }
+    skills.sort((a, b) => a.name.localeCompare(b.name));
+    results.push({ tool: tool.key, path: tool.skillsDir, skills });
+  }
+  return results;
+}
+async function addSkillsFromDirectory(skillsDir, label, options = {}) {
+  const requireAny = options.requireAny ?? true;
+  assertUsage(await pathExists(skillsDir), `${label} skills directory does not exist: ${skillsDir}`);
+  const entries = await readdir2(skillsDir, { withFileTypes: true });
+  const imported = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink() || entry.name.startsWith("."))
+      continue;
+    const dir = join5(skillsDir, entry.name);
+    if (!await findSkillFile(dir))
+      continue;
+    const existingManagedDir = await managedSymlinkTarget(dir);
+    const skill = existingManagedDir ? await importCandidate({ dir: existingManagedDir, skillFile: await findSkillFile(existingManagedDir) }, { sourceType: "local" }, { copy: false }) : await addSkill(dir);
+    await linkManagedSkillToSource(skill, dir);
+    imported.push(skill);
+  }
+  assertUsage(!requireAny || imported.length > 0, `No skills found in ${skillsDir}. Expected direct child directories with SKILL.md or skill.md.`);
+  return imported;
+}
+async function managedSymlinkTarget(sourceDir) {
+  try {
+    if (!(await lstat2(sourceDir)).isSymbolicLink())
+      return null;
+    const target = await realpath(sourceDir);
+    const managedRoot = await realpath(paths().skillsDir).catch(() => resolve(paths().skillsDir));
+    if (!target.startsWith(`${managedRoot}/`))
+      return null;
+    return await findSkillFile(target) ? target : null;
+  } catch {
+    return null;
+  }
+}
+async function linkManagedSkillToSource(skill, sourceDir) {
+  const source = resolve(sourceDir);
+  const target = resolve(skill.path);
+  if (source === target)
+    return;
+  try {
+    const existing = await lstat2(source);
+    if (existing.isSymbolicLink()) {
+      const linkedPath = await realpath(source);
+      const realTarget = await realpath(target);
+      if (linkedPath === realTarget)
+        return;
+    }
+  } catch {
+    return;
+  }
+  await replaceWithSymlink(target, source);
+}
+async function resolveLocalImport(source) {
+  const root = resolve(expandHome(source));
+  assertUsage(await pathExists(root), `Path does not exist: ${root}`);
+  assertUsage((await stat2(root)).isDirectory(), `Path is not a directory: ${root}`);
+  return { root, importSource: { sourceType: "local" } };
+}
+async function resolveGitImport(source) {
+  const parsed = parseGitSource(source);
+  const cloned = await cloneGitSource(parsed);
+  const root = parsed.subpath ? join5(cloned.checkoutDir, parsed.subpath) : cloned.checkoutDir;
+  assertUsage(await pathExists(root), `Git subpath does not exist: ${parsed.subpath}`);
+  return {
+    root,
+    importSource: {
+      sourceType: "git",
+      url: parsed.url,
+      ...parsed.ref ? { ref: parsed.ref } : {},
+      ...parsed.subpath ? { subpath: parsed.subpath } : {},
+      commitSha: cloned.commitSha
+    }
+  };
+}
+async function importCandidate(candidate, source, options = {}) {
+  const meta = await readSkillMetadata(candidate.skillFile);
+  const name = slug(meta.name || basename(candidate.dir));
+  const target = join5(paths().skillsDir, name);
+  if (options.copy !== false)
+    await copyDir(candidate.dir, target);
+  const db = await openDb();
+  db.query(`
+    INSERT INTO skills (name, description, path, source_type, source_url, source_ref, source_subpath, source_commit, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+    ON CONFLICT(name) DO UPDATE SET
+      description = excluded.description,
+      path = excluded.path,
+      source_type = excluded.source_type,
+      source_url = excluded.source_url,
+      source_ref = excluded.source_ref,
+      source_subpath = excluded.source_subpath,
+      source_commit = excluded.source_commit,
+      updated_at = CURRENT_TIMESTAMP
+  `).run(name, meta.description, target, source.sourceType, source.url || null, source.ref || null, source.subpath || null, source.commitSha || null);
+  const skill = db.query("SELECT * FROM skills WHERE name = ?").get(name);
+  await addSkillToPreset(skill.id);
+  return skill;
+}
+async function addSkillToPreset(skillId, presetName = "Default") {
+  const db = await openDb();
+  db.query("INSERT OR IGNORE INTO presets (name) VALUES (?)").run(presetName);
+  const preset = db.query("SELECT id FROM presets WHERE name = ?").get(presetName);
+  db.query("INSERT OR IGNORE INTO preset_skills (preset_id, skill_id) VALUES (?, ?)").run(preset.id, skillId);
+}
+async function listSkills() {
+  const db = await openDb();
+  return db.query("SELECT * FROM skills ORDER BY name").all();
+}
+async function getSkill(name) {
+  const db = await openDb();
+  return db.query("SELECT * FROM skills WHERE name = ?").get(name) || null;
+}
+async function findSkillAgentLinks(skill, tools = toolAdapters) {
+  const target = await realpath(skill.path).catch(() => resolve(skill.path));
+  const links = [];
+  for (const tool of tools) {
+    const path = join5(tool.skillsDir, skill.name);
+    try {
+      if (!(await lstat2(path)).isSymbolicLink())
+        continue;
+      if (await realpath(path) === target)
+        links.push({ tool: tool.key, path });
+    } catch {
+      continue;
+    }
+  }
+  return links;
+}
+async function removeSkill(name, options = {}) {
+  const db = await openDb();
+  const skill = await getSkill(name);
+  if (!skill)
+    throw new Error(`Skill not found: ${name}`);
+  const agentLinks = await findSkillAgentLinks(skill, options.tools);
+  if (options.removeAgentLinks) {
+    for (const link of agentLinks)
+      await removePath(link.path);
+  }
+  db.query("DELETE FROM preset_skills WHERE skill_id = ?").run(skill.id);
+  db.query("DELETE FROM skills WHERE id = ?").run(skill.id);
+  await removePath(skill.path);
+  return { skill, agentLinks };
+}
+async function skillMarkdownSummary(skill) {
+  const file = await findSkillFile(skill.path) || join5(skill.path, "SKILL.md");
+  const markdown = await readFile2(file, "utf8");
+  return markdown.split(`
+`).slice(0, 40).join(`
+`);
+}
+async function readSkillMetadata(skillFile) {
+  const text = await readFile2(skillFile, "utf8");
+  const frontmatter = text.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatter?.[1])
+    return { name: null, description: null };
+  return {
+    name: readYamlScalar(frontmatter[1], "name") || null,
+    description: readYamlScalar(frontmatter[1], "description") || null
+  };
+}
+function readYamlScalar(text, key) {
+  const match = text.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+  return match?.[1]?.trim().replace(/^["']|["']$/g, "");
+}
+function slug(input) {
+  const value = input.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return value || "skill";
+}
+
+// src/core/init.ts
+async function initManager() {
+  const p = paths();
+  await ensureDir(p.root);
+  await ensureDir(p.skillsDir);
+  await ensureDir(p.cacheGitDir);
+  await ensureDir(p.logsDir);
+  await ensureConfig();
+  await openDb();
+  await installBuiltinSkills();
+}
+async function installBuiltinSkills() {
+  const builtinDirs = await findBuiltinSkillDirs();
+  for (const sourceDir of builtinDirs) {
+    await installBuiltinSkill(sourceDir, join6(sourceDir, "SKILL.md"));
+  }
+}
+async function findBuiltinSkillDirs() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    join6(here, "..", ".."),
+    join6(here, "..")
+  ];
+  for (const candidate of candidates) {
+    if (await pathExists(join6(candidate, "SKILL.md")))
+      return [candidate];
+  }
+  return [];
+}
+async function installBuiltinSkill(sourceDir, skillFile) {
+  const meta = await readSkillMetadata(skillFile);
+  const name = slug(meta.name || sourceDir.split("/").at(-1) || "skill");
+  const target = join6(paths().skillsDir, name);
+  await ensureDir(target);
+  await Bun.write(join6(target, "SKILL.md"), Bun.file(skillFile));
+  const db = await openDb();
+  db.query(`
+    INSERT INTO skills (name, description, path, source_type, source_url, source_ref, source_subpath, source_commit, updated_at)
+    VALUES (?, ?, ?, 'builtin', NULL, NULL, NULL, NULL, CURRENT_TIMESTAMP)
+    ON CONFLICT(name) DO UPDATE SET
+      description = excluded.description,
+      path = excluded.path,
+      source_type = excluded.source_type,
+      source_url = excluded.source_url,
+      source_ref = excluded.source_ref,
+      source_subpath = excluded.source_subpath,
+      source_commit = excluded.source_commit,
+      updated_at = CURRENT_TIMESTAMP
+  `).run(name, meta.description, target);
+  const skill = db.query("SELECT id FROM skills WHERE name = ?").get(name);
+  await addSkillToPreset(skill.id);
+}
+
+// src/core/status.ts
+async function status() {
+  const db = await openDb();
+  const skillCount = db.query("SELECT COUNT(*) AS count FROM skills").get().count;
+  const presetCount = db.query("SELECT COUNT(*) AS count FROM presets").get().count;
+  const mcpCount = db.query("SELECT COUNT(*) AS count FROM mcp_servers").get().count;
+  return {
+    root: paths().root,
+    skillsDir: paths().skillsDir,
+    dbPath: paths().dbPath,
+    configPath: paths().configPath,
+    skillCount,
+    presetCount,
+    mcpCount,
+    tools: await detectTools()
+  };
+}
+
+// src/core/preset.ts
+import { tmpdir } from "os";
+import { join as join7, resolve as resolve2 } from "path";
+async function listPresets() {
+  const db = await openDb();
+  return db.query(`
+    SELECT p.*, COUNT(ps.skill_id) AS skill_count
+    FROM presets p
+    LEFT JOIN preset_skills ps ON ps.preset_id = p.id
+    GROUP BY p.id
+    ORDER BY p.name
+  `).all();
+}
+async function getPresetSkills(presetName) {
+  const db = await openDb();
+  return db.query(`
+    SELECT s.*
+    FROM skills s
+    JOIN preset_skills ps ON ps.skill_id = s.id
+    JOIN presets p ON p.id = ps.preset_id
+    WHERE p.name = ?
+    ORDER BY s.name
+  `).all(presetName);
+}
+async function movePreset(fromName, toName) {
+  const db = await openDb();
+  const from = db.query("SELECT id FROM presets WHERE name = ?").get(fromName);
+  if (!from)
+    throw new Error(`Preset not found: ${fromName}`);
+  db.query("INSERT OR IGNORE INTO presets (name) VALUES (?)").run(toName);
+  const to = db.query("SELECT id FROM presets WHERE name = ?").get(toName);
+  db.query(`
+    INSERT OR IGNORE INTO preset_skills (preset_id, skill_id)
+    SELECT ?, skill_id
+    FROM preset_skills
+    WHERE preset_id = ?
+  `).run(to.id, from.id);
+  db.query("DELETE FROM preset_skills WHERE preset_id = ?").run(from.id);
+  const skillCount = db.query("SELECT COUNT(*) AS count FROM preset_skills WHERE preset_id = ?").get(to.id).count;
+  return { from: fromName, to: toName, skillCount };
+}
+async function moveSkillPreset(skillName, fromName, toName) {
+  const db = await openDb();
+  const skill = db.query("SELECT id, name FROM skills WHERE name = ?").get(skillName);
+  if (!skill)
+    throw new Error(`Skill not found: ${skillName}`);
+  const from = db.query("SELECT id FROM presets WHERE name = ?").get(fromName);
+  if (!from)
+    throw new Error(`Preset not found: ${fromName}`);
+  const membership = db.query("SELECT 1 FROM preset_skills WHERE preset_id = ? AND skill_id = ?").get(from.id, skill.id);
+  if (!membership)
+    throw new Error(`Skill ${skillName} is not in preset ${fromName}`);
+  db.query("INSERT OR IGNORE INTO presets (name) VALUES (?)").run(toName);
+  const to = db.query("SELECT id FROM presets WHERE name = ?").get(toName);
+  db.query("INSERT OR IGNORE INTO preset_skills (preset_id, skill_id) VALUES (?, ?)").run(to.id, skill.id);
+  db.query("DELETE FROM preset_skills WHERE preset_id = ? AND skill_id = ?").run(from.id, skill.id);
+  return { skill: skill.name, from: fromName, to: toName };
+}
+async function applyPreset(presetName, toolInput, syncMode, adapters) {
+  const skills = await getPresetSkills(presetName);
+  if (skills.length === 0) {
+    throw new Error(`Preset not found or empty: ${presetName}`);
+  }
+  const config = await readConfig();
+  const tools = adapters ? resolveSelectedTools(toolInput, adapters) : resolveTools(toolInput);
+  const mode = syncMode || config.syncMode;
+  assertNoTempManagerSymlinkToRealAgents(mode, tools);
+  const results = [];
+  for (const tool of tools) {
+    for (const skill of skills) {
+      const target = join7(tool.skillsDir, skill.name);
+      const appliedMode = await syncDir(skill.path, target, mode);
+      results.push({ tool: tool.key, skill: skill.name, mode: appliedMode, target });
+    }
+  }
+  return results;
+}
+function resolveSelectedTools(toolInput, adapters) {
+  if (!toolInput || toolInput === "all")
+    return adapters;
+  const tool = adapters.find((adapter) => adapter.key === toolInput);
+  if (!tool)
+    throw new Error(`Unknown tool: ${toolInput}. Expected one of: ${adapters.map((adapter) => adapter.key).join(", ")}`);
+  return [tool];
+}
+function assertNoTempManagerSymlinkToRealAgents(syncMode, tools) {
+  if (syncMode !== "symlink")
+    return;
+  const root = resolve2(managerRoot());
+  const tmp = resolve2(tmpdir());
+  if (!root.startsWith(`${tmp}/`))
+    return;
+  const realAgentSkillDirs = new Set(toolAdapters.map((tool) => resolve2(tool.skillsDir)));
+  const selectedRealTools = tools.filter((tool) => realAgentSkillDirs.has(resolve2(tool.skillsDir)));
+  if (selectedRealTools.length === 0)
+    return;
+  throw new UsageError(`Refusing to symlink skills from temporary Tools Manager home (${root}) into real agent directories. ` + `Use a non-temporary TOOLS_MANAGER_HOME, set sync_mode = "copy", or pass test-only tool adapters.`);
+}
+
+// src/core/mcp.ts
+import { dirname as dirname3 } from "path";
+
+// src/core/json.ts
+function parseJsonArray(value) {
+  const parsed = JSON.parse(value);
+  return Array.isArray(parsed) ? parsed.map(String) : [];
+}
+function parseJsonRecord(value) {
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return {};
+  return Object.fromEntries(Object.entries(parsed).map(([key, val]) => [key, String(val)]));
+}
+function stableJson(value) {
+  return JSON.stringify(value);
+}
+
+// src/core/mcp.ts
+async function addMcpServer(input) {
+  const db = await openDb();
+  db.query(`
+    INSERT INTO mcp_servers (name, command, args_json, env_json, target_tools_json, enabled, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+    ON CONFLICT(name) DO UPDATE SET
+      command = excluded.command,
+      args_json = excluded.args_json,
+      env_json = excluded.env_json,
+      target_tools_json = excluded.target_tools_json,
+      enabled = excluded.enabled,
+      updated_at = CURRENT_TIMESTAMP
+  `).run(input.name, input.command, stableJson(input.args), stableJson(input.env), stableJson(input.targetTools), input.enabled ? 1 : 0);
+}
+async function listMcpServers() {
+  const db = await openDb();
+  const rows = db.query("SELECT * FROM mcp_servers ORDER BY name").all();
+  return rows.map(rowToServer);
+}
+async function getMcpServer(name) {
+  const db = await openDb();
+  const row = db.query("SELECT * FROM mcp_servers WHERE name = ?").get(name);
+  return row ? rowToServer(row) : null;
+}
+async function removeMcpServer(name) {
+  const db = await openDb();
+  const row = db.query("SELECT * FROM mcp_servers WHERE name = ?").get(name);
+  if (!row)
+    throw new Error(`MCP server not found: ${name}`);
+  db.query("DELETE FROM mcp_servers WHERE name = ?").run(name);
+  return rowToServer(row);
+}
+async function importMcpFromTools(toolInput) {
+  const tools = resolveTools(toolInput);
+  const results = [];
+  for (const tool of tools) {
+    const text = await readTextIfExists(tool.mcpPath);
+    const servers = parseToolMcp(tool, text);
+    for (const server of servers)
+      await addMcpServer(server);
+    results.push({ tool: tool.key, path: tool.mcpPath, count: servers.length, servers: servers.map((server) => server.name) });
+  }
+  return results;
+}
+async function listToolMcpServers(toolInput = "all", adapters) {
+  const tools = adapters || resolveTools(toolInput);
+  const results = [];
+  for (const tool of tools) {
+    const text = await readTextIfExists(tool.mcpPath);
+    const servers = parseToolMcp(tool, text).sort((a, b) => a.name.localeCompare(b.name));
+    results.push({ tool: tool.key, path: tool.mcpPath, servers });
+  }
+  return results;
+}
+async function syncMcp(toolInput) {
+  const servers = (await listMcpServers()).filter((server) => server.enabled);
+  const tools = resolveTools(toolInput);
+  const results = [];
+  for (const tool of tools) {
+    const selected = servers.filter((server) => server.targetTools.includes("all") || server.targetTools.includes(tool.key));
+    const backup = await renderToolMcp(tool, selected);
+    results.push({ tool: tool.key, path: tool.mcpPath, count: selected.length, backup });
+  }
+  return results;
+}
+function parseToolMcp(tool, text) {
+  if (!text?.trim())
+    return [];
+  return tool.mcpKind === "codex-toml" ? parseCodexToml(text, tool.key) : parseMcpJson(text, tool.key);
+}
+function rowToServer(row) {
+  return {
+    name: row.name,
+    command: row.command,
+    args: parseJsonArray(row.args_json),
+    env: parseJsonRecord(row.env_json),
+    targetTools: parseJsonArray(row.target_tools_json),
+    enabled: row.enabled === 1
+  };
+}
+async function renderToolMcp(tool, servers) {
+  await ensureDir(dirname3(tool.mcpPath));
+  const backup = await backupFile(tool.mcpPath);
+  if (tool.mcpKind === "codex-toml") {
+    await writeText(tool.mcpPath, renderCodexToml(await readTextIfExists(tool.mcpPath), servers));
+    return backup;
+  }
+  await writeText(tool.mcpPath, renderMcpJson(await readTextIfExists(tool.mcpPath), servers));
+  return backup;
+}
+function renderMcpJson(existing, servers) {
+  let root = {};
+  if (existing?.trim()) {
+    try {
+      const parsed = JSON.parse(existing);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+        root = parsed;
+    } catch {
+      root = {};
+    }
+  }
+  const mcpServers = normalizeObject(root.mcpServers);
+  for (const server of servers) {
+    mcpServers[server.name] = serverToJson(server);
+  }
+  root.mcpServers = mcpServers;
+  return `${JSON.stringify(root, null, 2)}
+`;
+}
+function parseMcpJson(text, tool) {
+  try {
+    const parsed = JSON.parse(text);
+    const root = normalizeObject(parsed);
+    const mcpServers = normalizeObject(root.mcpServers);
+    return Object.entries(mcpServers).flatMap(([name, value]) => {
+      const server = normalizeObject(value);
+      const command = typeof server.command === "string" ? server.command : "";
+      if (!command)
+        return [];
+      return [{
+        name,
+        command,
+        args: Array.isArray(server.args) ? server.args.map(String) : [],
+        env: parseStringRecord(server.env),
+        targetTools: [tool],
+        enabled: true
+      }];
+    });
+  } catch {
+    return [];
+  }
+}
+function renderCodexToml(existing, servers) {
+  const retained = stripManagedCodexServers(existing || "", servers.map((server) => server.name)).trimEnd();
+  const blocks = servers.map((server) => {
+    const lines = [
+      `[mcp_servers.${tomlQuotedKey(server.name)}]`,
+      `command = ${tomlString(server.command)}`,
+      `args = [${server.args.map(tomlString).join(", ")}]`
+    ];
+    const envEntries = Object.entries(server.env);
+    if (envEntries.length > 0) {
+      lines.push("");
+      lines.push(`[mcp_servers.${tomlQuotedKey(server.name)}.env]`);
+      for (const [key, value] of envEntries) {
+        lines.push(`${key} = ${tomlString(value)}`);
+      }
+    }
+    return lines.join(`
+`);
+  });
+  return [retained, ...blocks].filter(Boolean).join(`
+
+`) + `
+`;
+}
+function parseCodexToml(text, tool) {
+  const servers = new Map;
+  let currentName = null;
+  let currentEnvName = null;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const header = line.match(/^\[mcp_servers\.(?:"([^"]+)"|([^\].]+))(?:\.env)?\]$/);
+    if (header) {
+      const name = header[1] || header[2] || "";
+      currentName = name;
+      currentEnvName = line.endsWith(".env]") ? name : null;
+      if (!servers.has(name)) {
+        servers.set(name, { name, command: "", args: [], env: {}, targetTools: [tool], enabled: true });
+      }
+      continue;
+    }
+    if (!currentName)
+      continue;
+    const server = servers.get(currentName);
+    if (!server)
+      continue;
+    const assignment = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/);
+    if (!assignment)
+      continue;
+    const key = assignment[1];
+    const value = assignment[2];
+    if (currentEnvName) {
+      server.env[key] = parseTomlString(value);
+    } else if (key === "command") {
+      server.command = parseTomlString(value);
+    } else if (key === "args") {
+      server.args = parseTomlStringArray(value);
+    }
+  }
+  return Array.from(servers.values()).filter((server) => server.command);
+}
+function stripManagedCodexServers(existing, names) {
+  if (names.length === 0)
+    return existing;
+  const lines = existing.split(/\r?\n/);
+  const output = [];
+  let skipping = false;
+  for (const line of lines) {
+    const anyHeader = line.match(/^\[([^\]]+)\]$/);
+    if (anyHeader) {
+      const header = line.match(/^\[mcp_servers\.(?:"([^"]+)"|([^\].]+))(?:\.env)?\]$/);
+      if (header) {
+        const name = header[1] || header[2] || "";
+        skipping = names.includes(name);
+      } else {
+        skipping = false;
+      }
+    }
+    if (!skipping)
+      output.push(line);
+  }
+  return output.join(`
+`);
+}
+function serverToJson(server) {
+  return {
+    command: server.command,
+    args: server.args,
+    ...Object.keys(server.env).length > 0 ? { env: server.env } : {}
+  };
+}
+function normalizeObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function parseStringRecord(value) {
+  const record = normalizeObject(value);
+  return Object.fromEntries(Object.entries(record).filter((entry) => typeof entry[1] === "string"));
+}
+function parseTomlString(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"')) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return trimmed.replace(/^"|"$/g, "");
+    }
+  }
+  return trimmed;
+}
+function parseTomlStringArray(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]"))
+    return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    return Array.isArray(parsed) ? parsed.map(String) : [];
+  } catch {
+    return trimmed.slice(1, -1).split(",").map((item) => parseTomlString(item)).filter(Boolean);
+  }
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function tomlQuotedKey(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value) ? value : JSON.stringify(value);
+}
+
+// src/core/agent.ts
+async function listAgentOverview(toolInput = "all", tools) {
+  const selected = tools ? toolInput === "all" ? tools : [tools.find((tool) => tool.key === toolInput) || getTool(toolInput)] : resolveTools(toolInput);
+  const skills = await listAgentSkills(toolInput, selected);
+  const mcpServers = await listToolMcpServers(toolInput, selected);
+  return selected.map((tool) => {
+    const toolSkills = skills.find((item) => item.tool === tool.key);
+    const toolMcp = mcpServers.find((item) => item.tool === tool.key);
+    return {
+      tool: tool.key,
+      displayName: tool.displayName,
+      skillsPath: toolSkills?.path || tool.skillsDir,
+      mcpPath: toolMcp?.path || tool.mcpPath,
+      skills: toolSkills?.skills || [],
+      mcpServers: toolMcp?.servers || []
+    };
+  });
+}
+
+// src/core/backup.ts
+async function backup() {
+  const skillsDir = paths().skillsDir;
+  if (!await pathExists(`${skillsDir}/.git`)) {
+    runGit(["-C", skillsDir, "init"], "Failed to initialize Git repository.");
+  }
+  const config = await readConfig();
+  if (config.gitRemote) {
+    const remotes = runGit(["-C", skillsDir, "remote"], "Failed to inspect Git remotes.", true);
+    if (!remotes.split(/\r?\n/).includes("origin")) {
+      runGit(["-C", skillsDir, "remote", "add", "origin", config.gitRemote], "Failed to add Git remote.");
+    }
+  }
+  runGit(["-C", skillsDir, "add", "-A"], "Failed to stage skills.");
+  const status2 = runGit(["-C", skillsDir, "status", "--porcelain"], "Failed to inspect Git status.", true);
+  if (!status2.trim()) {
+    return { initialized: true, committed: false, pushed: false, message: "No changes to backup." };
+  }
+  const message = `chore: backup skills ${new Date().toISOString()}`;
+  runGit(["-C", skillsDir, "commit", "-m", message], "Failed to commit skills.");
+  let pushed = false;
+  if (config.gitRemote) {
+    runGit(["-C", skillsDir, "push", "-u", "origin", "HEAD"], "Failed to push skills.");
+    pushed = true;
+  }
+  return { initialized: true, committed: true, pushed, message };
+}
+
+// src/core/output.ts
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function heading(text) {
+  console.log(`
+${text}`);
+  console.log("=".repeat(text.length));
+}
+function note(text) {
+  console.log(text);
+}
+function success(text) {
+  console.log(`OK  ${text}`);
+}
+function table(rows, options = {}) {
+  if (options.title)
+    heading(options.title);
+  if (rows.length === 0) {
+    console.log(options.empty || "No rows.");
+    return;
+  }
+  const maxWidth = options.maxWidth ?? 64;
+  const columns = Object.keys(rows[0] || {});
+  const widths = columns.map((column) => Math.max(displayWidth(column), ...rows.map((row) => displayWidth(formatCell(row[column], maxWidth)))));
+  const border = `+-${widths.map((width) => "-".repeat(width)).join("-+-")}-+`;
+  console.log(border);
+  console.log(`| ${columns.map((column, index) => padCell(column, widths[index] || 0)).join(" | ")} |`);
+  console.log(border);
+  for (const row of rows) {
+    console.log(`| ${columns.map((column, index) => padCell(formatCell(row[column], maxWidth), widths[index] || 0)).join(" | ")} |`);
+  }
+  console.log(border);
+}
+function formatCell(value, maxWidth) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (displayWidth(text) <= maxWidth)
+    return text;
+  return truncateCell(text, maxWidth);
+}
+function padCell(text, width) {
+  return `${text}${" ".repeat(Math.max(0, width - displayWidth(text)))}`;
+}
+function truncateCell(text, maxWidth) {
+  const suffix = "...";
+  const target = Math.max(0, maxWidth - suffix.length);
+  let result = "";
+  let width = 0;
+  for (const char of text) {
+    const next = charWidth(char);
+    if (width + next > target)
+      break;
+    result += char;
+    width += next;
+  }
+  return `${result}${suffix}`;
+}
+function displayWidth(text) {
+  let width = 0;
+  for (const char of text)
+    width += charWidth(char);
+  return width;
+}
+function charWidth(char) {
+  const code = char.codePointAt(0) || 0;
+  if (code === 0)
+    return 0;
+  if (code < 32 || code >= 127 && code < 160)
+    return 0;
+  return code >= 4352 ? 2 : 1;
+}
+
+// src/cli.ts
+async function main() {
+  const argv = process.argv.slice(2);
+  const global = { json: takeFlag(argv, "--json") };
+  const command = argv.shift();
+  if (command === undefined) {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      await interactiveMenu(global);
+    } else {
+      printHelp();
+    }
+    return;
+  }
+  switch (command) {
+    case "init":
+      await initManager();
+      success("Initialized tools manager.");
+      break;
+    case "status":
+      await cmdStatus(global);
+      break;
+    case "agents":
+      await cmdAgents(argv, global);
+      break;
+    case "skills":
+      await cmdSkills(argv, global);
+      break;
+    case "presets":
+      await cmdPresets(argv, global);
+      break;
+    case "mcp":
+      await cmdMcp(argv, global);
+      break;
+    case "backup":
+      await cmdBackup(global);
+      break;
+    case "-h":
+    case "--help":
+      printHelp();
+      break;
+    default:
+      throw new UsageError(`Unknown command: ${command}`);
+  }
+}
+var menuCommands = [
+  { group: "System", label: "Status", description: "Paths, counts, and detected agents.", argv: ["status"] },
+  { group: "Agents", label: "List agent-side contents", description: "Show skills and MCP currently in agents.", argv: ["agents", "list", "--tool", "$tool?"] },
+  { group: "Skills", label: "Add skill from source", description: "Import a local path or Git URL.", argv: ["skills", "add", "$source"] },
+  { group: "Skills", label: "Import skills from agent", description: "Copy agent-side skills into tm.", argv: ["skills", "add", "--tool", "$tool?"] },
+  { group: "Skills", label: "List managed skills", description: "Browse skills stored in tm.", argv: ["skills", "list"] },
+  { group: "Skills", label: "Show managed skill", description: "Inspect one tm skill document.", argv: ["skills", "show", "$skill"] },
+  { group: "Skills", label: "Remove skill", description: "Delete managed source and agent symlinks.", argv: ["skills", "remove", "$skill"] },
+  { group: "Skills", label: "Sync preset skills", description: "Apply a tm preset to agents.", argv: ["skills", "sync", "$preset?", "--tool", "$tool?", "--mode", "$mode?"] },
+  { group: "Skill Presets", label: "List skill presets", description: "Show skill groups.", argv: ["presets", "list"] },
+  { group: "Skill Presets", label: "Move skill to preset", description: "Move one skill between presets.", argv: ["presets", "move-skill", "$skill", "$from", "$to"] },
+  { group: "Skill Presets", label: "Move whole preset", description: "Move all skills between presets.", argv: ["presets", "move", "$from", "$to"] },
+  { group: "MCP", label: "Add managed MCP server", description: "Register server and target agents.", argv: ["mcp", "add", "$mcp", "--command", "$command", "--arg", "$args?", "--env", "$env?", "--tool", "$tool?"] },
+  { group: "MCP", label: "Import MCP from agent", description: "Copy agent config servers into tm.", argv: ["mcp", "add", "--tool", "$tool?"] },
+  { group: "MCP", label: "List managed MCP servers", description: "Browse MCP servers stored in tm.", argv: ["mcp", "list"] },
+  { group: "MCP", label: "Show managed MCP server", description: "Inspect one tm MCP server.", argv: ["mcp", "show", "$mcp"] },
+  { group: "MCP", label: "Remove MCP server", description: "Delete from tm; sync to update agents.", argv: ["mcp", "remove", "$mcp"] },
+  { group: "MCP", label: "Sync managed MCP", description: "Write tm MCP registry to agents.", argv: ["mcp", "sync", "--tool", "$tool?"] },
+  { group: "System", label: "Backup skills", description: "Commit managed skills with Git.", argv: ["backup"] },
+  { group: "System", label: "Help", description: "Print command reference.", argv: ["--help"] }
+];
+async function interactiveMenu(global) {
+  while (true) {
+    const selected = await selectMenu("Tools Manager", menuCommands);
+    if (!selected)
+      return;
+    const argv = await resolveMenuArgs(selected.argv);
+    if (!argv)
+      continue;
+    note(`
+$ tm ${argv.join(" ")}`);
+    const command = argv.shift();
+    if (command === "--help") {
+      printHelp();
+      await waitForMenuReturn();
+      continue;
+    }
+    try {
+      switch (command) {
+        case "status":
+          await cmdStatus(global);
+          break;
+        case "agents":
+          await cmdAgents(argv, global);
+          break;
+        case "skills":
+          await cmdSkills(argv, global);
+          break;
+        case "presets":
+          await cmdPresets(argv, global);
+          break;
+        case "mcp":
+          await cmdMcp(argv, global);
+          break;
+        case "backup":
+          await cmdBackup(global);
+          break;
+        default:
+          throw new UsageError(`Unknown command: ${command}`);
+      }
+    } catch (error) {
+      resetTerminalInput();
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+    await waitForMenuReturn();
+  }
+}
+async function resolveMenuArgs(argv) {
+  const resolved = [];
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "$skill") {
+      const value = await selectExistingOrCustom("Skill", await skillNameOptions(), "Skill name: ");
+      if (value === null)
+        return null;
+      resolved.push(value);
+    } else if (arg === "$source") {
+      const value = await selectExistingOrCustom("Skill Source", ["~/.codex/skills", "~/.claude/skills", "~/.cursor/skills"], "Skill source path or Git URL: ");
+      if (value === null)
+        return null;
+      resolved.push(value);
+    } else if (arg === "$mcp") {
+      const value = await selectExistingOrCustom("MCP Server", await mcpNameOptions(), "MCP server name: ");
+      if (value === null)
+        return null;
+      resolved.push(value);
+    } else if (arg === "$command") {
+      const value = await selectExistingOrCustom("Command", ["npx", "bunx", "node", "python", "python3"], "Command: ");
+      if (value === null)
+        return null;
+      resolved.push(value);
+    } else if (arg === "$args?") {
+      const previous = resolved[resolved.length - 1];
+      const value = await selectExistingOrCustom("Args", ["none", "@playwright/mcp@latest", "-y @modelcontextprotocol/server-filesystem"], "Args [optional, space separated]: ");
+      if (value === null)
+        return null;
+      if (value && value !== "none") {
+        for (const item of value.split(/\s+/).filter(Boolean)) {
+          resolved.push(item);
+          resolved.push("--arg");
+        }
+        resolved.pop();
+      } else if (previous === "--arg") {
+        resolved.pop();
+      }
+    } else if (arg === "$env?") {
+      const previous = resolved[resolved.length - 1];
+      const value = await selectExistingOrCustom("Env", ["none"], "Env [optional, KEY=VALUE, comma separated]: ");
+      if (value === null)
+        return null;
+      if (value && value !== "none") {
+        for (const item of value.split(",").map((part) => part.trim()).filter(Boolean)) {
+          resolved.push(item);
+          resolved.push("--env");
+        }
+        resolved.pop();
+      } else if (previous === "--env") {
+        resolved.pop();
+      }
+    } else if (arg === "$from") {
+      const value = await selectExistingOrCustom("From Preset", await presetNameOptions(), "From preset: ");
+      if (value === null)
+        return null;
+      resolved.push(value);
+    } else if (arg === "$to") {
+      const value = await selectExistingOrCustom("To Preset", await presetNameOptions(), "To preset: ");
+      if (value === null)
+        return null;
+      resolved.push(value);
+    } else if (arg === "$preset?") {
+      const value = await selectExistingOrCustom("Preset", await presetNameOptions("Default"), "Preset [Default]: ");
+      if (value === null)
+        return null;
+      if (value && value !== "Default")
+        resolved.push(value);
+    } else if (arg === "$tool?") {
+      const previous = resolved[resolved.length - 1];
+      if (previous === "--tool") {
+        const value = await selectExistingOrCustom("Tool", ["all", "codex", "cursor", "claude_code"], "Tool [all|codex|cursor|claude_code]: ");
+        if (value === null)
+          return null;
+        resolved.push(value);
+      }
+    } else if (arg === "$mode?") {
+      const previous = resolved[resolved.length - 1];
+      if (previous === "--mode") {
+        const value = await selectExistingOrCustom("Sync Mode", ["symlink", "copy"], "Sync mode [symlink|copy]: ");
+        if (value === null)
+          return null;
+        if (value)
+          resolved.push(value);
+        else
+          resolved.pop();
+      }
+    } else {
+      resolved.push(arg);
+    }
+  }
+  return resolved.filter(Boolean);
+}
+async function cmdStatus(global) {
+  const value = await status();
+  if (global.json)
+    return printJson(value);
+  heading("Tools Manager Status");
+  note(`Root: ${value.root}`);
+  note(`Skills: ${value.skillCount} (${value.skillsDir})`);
+  note(`Skill presets: ${value.presetCount}`);
+  note(`MCP servers: ${value.mcpCount}`);
+  table(value.tools.map((tool) => ({ tool: tool.key, installed: tool.installed ? "yes" : "no", skills: tool.skillsDir, mcp: tool.mcpPath })), { title: "Tools" });
+}
+async function cmdAgents(argv, global) {
+  const sub = argv.shift();
+  switch (sub) {
+    case "list": {
+      const tool = takeOption(argv, "--tool") || "all";
+      assertUsage(argv.length === 0, "Usage: tm agents list [--tool <tool|all>] [--json]");
+      const result = await listAgentOverview(tool);
+      if (global.json)
+        return printJson(result);
+      printAgentOverview(result);
+      break;
+    }
+    default:
+      throw new UsageError("Usage: tm agents <list>");
+  }
+}
+function printAgentOverview(result) {
+  const rows = result.flatMap((agent) => {
+    const skillRows = agent.skills.map((skill) => ({
+      tool: agent.tool,
+      type: "skill",
+      name: skill.name,
+      detail: skill.description || "",
+      path: skill.path
+    }));
+    const mcpRows = agent.mcpServers.map((server) => ({
+      tool: agent.tool,
+      type: "mcp",
+      name: server.name,
+      detail: [server.command, ...server.args].join(" "),
+      path: agent.mcpPath
+    }));
+    if (skillRows.length === 0 && mcpRows.length === 0) {
+      return [{ tool: agent.tool, type: "", name: "", detail: "No skills or MCP servers found.", path: `${agent.skillsPath} | ${agent.mcpPath}` }];
+    }
+    return [...skillRows, ...mcpRows];
+  });
+  table(rows, { title: "Agent Contents", empty: "No agents found." });
+}
+async function cmdSkills(argv, global) {
+  const sub = argv.shift();
+  switch (sub) {
+    case "add": {
+      const tool = takeOption(argv, "--tool");
+      if (tool) {
+        assertUsage(argv.length === 0, "Usage: tm skills add --tool <tool|all>");
+        const result = await addLocalAgentSkills(tool);
+        if (global.json)
+          return printJson(result);
+        printToolSkillImportResult(result);
+        break;
+      }
+      if (takeFlag(argv, "--all")) {
+        assertUsage(argv.length === 0, "Usage: tm skills add --all");
+        const result = await addAllLocalAgentSkills();
+        if (global.json)
+          return printJson(result);
+        printToolSkillImportResult(result);
+        break;
+      }
+      if (takeFlag(argv, "--codex")) {
+        assertUsage(argv.length === 0, "Usage: tm skills add --codex");
+        const skills2 = await addCodexSkills();
+        if (global.json)
+          return printJson(skills2);
+        printSkills(skills2, "Imported Skills");
+        break;
+      }
+      const source = argv.shift();
+      assertUsage(source, "Usage: tm skills add <source>");
+      const skills = await addSkills(source);
+      if (global.json)
+        return printJson(skills);
+      if (skills.length === 1)
+        success(`Added skill ${skills[0].name}`);
+      else
+        printSkills(skills, `Imported Skills (${skills.length})`);
+      break;
+    }
+    case "list": {
+      const tool = takeOption(argv, "--tool");
+      assertUsage(argv.length === 0, "Usage: tm skills list [--tool <tool|all>] [--json]");
+      if (tool) {
+        const result = await listAgentSkills(tool);
+        if (global.json)
+          return printJson(result);
+        printAgentSkills(result);
+        break;
+      }
+      const skills = await listSkills();
+      if (global.json)
+        return printJson(skills);
+      printSkills(skills, `Skills (${skills.length})`);
+      break;
+    }
+    case "show": {
+      const name = argv.shift();
+      assertUsage(name, "Usage: tm skills show <name>");
+      const skill = await getSkill(name);
+      assertUsage(skill, `Skill not found: ${name}`);
+      const markdown = await skillMarkdownSummary(skill);
+      if (global.json)
+        return printJson({ ...skill, markdown });
+      heading(skill.name);
+      note(`Description: ${skill.description || ""}`);
+      note(`Path: ${skill.path}`);
+      note(`Source: ${skill.source_type}${skill.source_url ? ` ${skill.source_url}` : ""}`);
+      note("");
+      note(markdown);
+      break;
+    }
+    case "remove":
+    case "rm": {
+      const yes = takeFlag(argv, "--yes") || takeFlag(argv, "-y");
+      const name = argv.shift();
+      assertUsage(name, "Usage: tm skills remove <name> [--yes]");
+      const skill = await getSkill(name);
+      assertUsage(skill, `Skill not found: ${name}`);
+      const agentLinks = await findSkillAgentLinks(skill);
+      if (global.json) {
+        const result2 = await removeSkill(name, { removeAgentLinks: true });
+        return printJson(result2);
+      }
+      if (agentLinks.length > 0) {
+        note(`Removing ${skill.name} will delete its managed source:`);
+        note(`  ${skill.path}`);
+        note("These agent skill symlinks point to that source and will also be deleted:");
+        for (const link of agentLinks)
+          note(`  ${link.tool}: ${link.path}`);
+      } else {
+        note(`Removing ${skill.name} will delete its managed source:`);
+        note(`  ${skill.path}`);
+      }
+      if (!yes) {
+        const confirmed = await confirm("Continue? [y/N] ");
+        if (!confirmed) {
+          note("Aborted.");
+          break;
+        }
+      }
+      const result = await removeSkill(name, { removeAgentLinks: true });
+      success(`Removed skill ${result.skill.name}`);
+      if (result.agentLinks.length > 0)
+        success(`Removed ${result.agentLinks.length} agent symlink(s).`);
+      break;
+    }
+    case "sync": {
+      const preset = argv[0]?.startsWith("--") ? "Default" : argv.shift() || "Default";
+      const tool = takeOption(argv, "--tool") || "all";
+      const mode = takeSyncMode(argv);
+      assertUsage(argv.length === 0, "Usage: tm skills sync [preset] [--tool <tool|all>] [--mode <symlink|copy>]");
+      const result = await applyPreset(preset, tool, mode);
+      if (global.json)
+        return printJson(result);
+      table(result.map((row) => ({ tool: row.tool, skill: row.skill, mode: row.mode, target: row.target })), { title: `Synced ${result.length} Skills` });
+      break;
+    }
+    default:
+      throw new UsageError("Usage: tm skills <add|list|show|remove|sync>");
+  }
+}
+function printToolSkillImportResult(result) {
+  const rows = result.flatMap((tool) => tool.skills.map((skill) => ({ tool: tool.tool, name: skill.name, source: skill.source_type, description: skill.description || "" })));
+  table(rows, { title: `Imported Skills (${rows.length})`, empty: "No skills imported." });
+}
+function printSkills(skills, title) {
+  table(skills.map((skill) => ({ name: skill.name, source: skill.source_type, description: skill.description || "" })), { title, empty: "No skills found." });
+}
+function printAgentSkills(result) {
+  const rows = result.flatMap((item) => item.skills.map((skill) => ({ tool: item.tool, name: skill.name, description: skill.description || "", path: skill.path })));
+  table(rows, { title: `Agent Skills (${rows.length})`, empty: "No agent skills found." });
+}
+async function cmdPresets(argv, global) {
+  const sub = argv.shift();
+  switch (sub) {
+    case "list": {
+      const presets = await listPresets();
+      if (global.json)
+        return printJson(presets);
+      table(presets.map((preset) => ({ name: preset.name, skills: preset.skill_count })), { title: `Skill Presets (${presets.length})` });
+      break;
+    }
+    case "apply": {
+      const preset = argv[0]?.startsWith("--") ? "Default" : argv.shift() || "Default";
+      const tool = takeOption(argv, "--tool") || "all";
+      const mode = takeSyncMode(argv);
+      assertUsage(argv.length === 0, "Usage: tm presets apply [preset] [--tool <tool|all>] [--mode <symlink|copy>]");
+      const result = await applyPreset(preset, tool, mode);
+      if (global.json)
+        return printJson(result);
+      table(result.map((row) => ({ tool: row.tool, skill: row.skill, mode: row.mode, target: row.target })), { title: `Applied ${result.length} Skills` });
+      break;
+    }
+    case "move":
+    case "mv": {
+      const from = argv.shift();
+      const to = argv.shift();
+      assertUsage(from && to, "Usage: tm presets move <from> <to>");
+      const result = await movePreset(from, to);
+      if (global.json)
+        return printJson(result);
+      success(`Moved ${result.skillCount} skills from ${result.from} to ${result.to}.`);
+      break;
+    }
+    case "move-skill": {
+      const skill = argv.shift();
+      const from = argv.shift();
+      const to = argv.shift();
+      assertUsage(skill && from && to, "Usage: tm presets move-skill <skill> <from> <to>");
+      const result = await moveSkillPreset(skill, from, to);
+      if (global.json)
+        return printJson(result);
+      success(`Moved ${result.skill} from ${result.from} to ${result.to}.`);
+      break;
+    }
+    default:
+      throw new UsageError("Usage: tm presets <list|apply|move|move-skill>");
+  }
+}
+async function cmdMcp(argv, global) {
+  const sub = argv.shift();
+  switch (sub) {
+    case "add": {
+      const importTool = takeOption(argv, "--tool");
+      if (importTool && argv.length === 0) {
+        const result = await importMcpFromTools(importTool);
+        if (global.json)
+          return printJson(result);
+        table(result.map((row) => ({ tool: row.tool, servers: row.count, path: row.path, names: row.servers.join(",") })), { title: "Imported MCP Servers" });
+        break;
+      }
+      const name = argv.shift();
+      assertUsage(name, "Usage: tm mcp add <name> --command <cmd> [--arg value] [--env K=V] [--tool <tool|all>]");
+      const command = takeOption(argv, "--command");
+      assertUsage(command, "Missing required --command.");
+      const args = takeRepeatedOption(argv, "--arg");
+      const env = Object.assign({}, ...takeRepeatedOption(argv, "--env").map(parseKeyValue));
+      const targetTools = importTool ? [importTool, ...takeRepeatedOption(argv, "--tool")] : takeRepeatedOption(argv, "--tool");
+      await addMcpServer({ name, command, args, env, targetTools: targetTools.length ? targetTools : ["all"], enabled: true });
+      success(`Added MCP server ${name}`);
+      break;
+    }
+    case "list": {
+      const tool = takeOption(argv, "--tool");
+      assertUsage(argv.length === 0, "Usage: tm mcp list [--tool <tool|all>] [--json]");
+      if (tool) {
+        const result = await listToolMcpServers(tool);
+        if (global.json)
+          return printJson(result);
+        printToolMcpServers(result);
+        break;
+      }
+      const servers = await listMcpServers();
+      if (global.json)
+        return printJson(servers);
+      table(servers.map((server) => ({ name: server.name, command: server.command, tools: server.targetTools.join(","), enabled: server.enabled ? "yes" : "no" })), { title: `MCP Servers (${servers.length})` });
+      break;
+    }
+    case "show": {
+      const name = argv.shift();
+      assertUsage(name, "Usage: tm mcp show <name>");
+      const server = await getMcpServer(name);
+      assertUsage(server, `MCP server not found: ${name}`);
+      if (global.json)
+        return printJson(server);
+      heading(server.name);
+      note(`Command: ${server.command}`);
+      note(`Args: ${server.args.join(" ")}`);
+      note(`Tools: ${server.targetTools.join(",")}`);
+      note(`Enabled: ${server.enabled ? "yes" : "no"}`);
+      if (Object.keys(server.env).length > 0) {
+        note("Env:");
+        for (const [key, value] of Object.entries(server.env))
+          note(`  ${key}=${value}`);
+      }
+      break;
+    }
+    case "sync": {
+      const tool = takeOption(argv, "--tool") || "all";
+      const result = await syncMcp(tool);
+      if (global.json)
+        return printJson(result);
+      table(result.map((row) => ({ tool: row.tool, servers: row.count, path: row.path, backup: row.backup || "" })), { title: "MCP Sync" });
+      break;
+    }
+    case "remove":
+    case "rm": {
+      const name = argv.shift();
+      assertUsage(name, "Usage: tm mcp remove <name>");
+      const server = await removeMcpServer(name);
+      if (global.json)
+        return printJson(server);
+      success(`Removed MCP server ${server.name}`);
+      break;
+    }
+    default:
+      throw new UsageError("Usage: tm mcp <add|list|show|sync|remove>");
+  }
+}
+function printToolMcpServers(result) {
+  const rows = result.flatMap((item) => item.servers.map((server) => ({ tool: item.tool, name: server.name, command: [server.command, ...server.args].join(" "), env: Object.keys(server.env).length, path: item.path })));
+  table(rows, { title: `Agent MCP Servers (${rows.length})`, empty: "No agent MCP servers found." });
+}
+async function cmdBackup(global) {
+  const result = await backup();
+  if (global.json)
+    return printJson(result);
+  success(result.message);
+  if (result.pushed)
+    success("Pushed to origin.");
+}
+function parseKeyValue(value) {
+  const index = value.indexOf("=");
+  assertUsage(index > 0, `Expected KEY=VALUE, got: ${value}`);
+  return { [value.slice(0, index)]: value.slice(index + 1) };
+}
+function takeFlag(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index === -1)
+    return false;
+  argv.splice(index, 1);
+  return true;
+}
+function takeOption(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index === -1)
+    return;
+  const value = argv[index + 1];
+  assertUsage(value && !value.startsWith("--"), `Missing value for ${flag}.`);
+  argv.splice(index, 2);
+  return value;
+}
+function takeSyncMode(argv) {
+  const mode = takeOption(argv, "--mode");
+  if (!mode)
+    return;
+  assertUsage(mode === "symlink" || mode === "copy", "Expected --mode to be one of: symlink, copy.");
+  return mode;
+}
+function takeRepeatedOption(argv, flag) {
+  const values = [];
+  let value;
+  while (value = takeOption(argv, flag))
+    values.push(value);
+  return values;
+}
+async function selectMenu(title, commands) {
+  let selected = 0;
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+  const render = () => {
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write(`${ansi.dim("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E")}
+`);
+    process.stdout.write(`${ansi.dim("\u2502")} ${ansi.signal(title.padEnd(76))} ${ansi.dim("\u2502")}
+`);
+    process.stdout.write(`${ansi.dim("\u2502")} ${ansi.muted("One local control plane for skills, presets, and MCP servers.".padEnd(76))} ${ansi.dim("\u2502")}
+`);
+    process.stdout.write(`${ansi.dim("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F")}
+
+`);
+    process.stdout.write(`${ansi.muted("\u2191/\u2193 choose")}  ${ansi.muted("Enter run")}  ${ansi.muted("Esc/q quit")}
+
+`);
+    let group = "";
+    commands.forEach((command, index) => {
+      const active = index === selected;
+      if (command.group !== group) {
+        group = command.group;
+        process.stdout.write(`
+${ansi.group(group)}
+`);
+      }
+      const line = ` ${command.label.padEnd(24)} ${command.description.padEnd(44)} ${commandText(command.argv)}`;
+      process.stdout.write(active ? `${ansi.selected(`\u203A${line}`)}
+` : `${ansi.dim(" ")}${line}
+`);
+    });
+  };
+  render();
+  return new Promise((resolve3) => {
+    const cleanup = () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.off("data", onData);
+      process.stdout.write(`
+`);
+    };
+    const onData = (chunk) => {
+      if (chunk === "\x03" || chunk === "\x1B" || chunk.toLowerCase() === "q") {
+        cleanup();
+        resolve3(null);
+        return;
+      }
+      if (chunk === "\r" || chunk === `
+`) {
+        const command = commands[selected] || null;
+        cleanup();
+        resolve3(command);
+        return;
+      }
+      if (chunk === "\x1B[A") {
+        selected = (selected - 1 + commands.length) % commands.length;
+        render();
+      } else if (chunk === "\x1B[B") {
+        selected = (selected + 1) % commands.length;
+        render();
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+var ansi = {
+  signal: (value) => `\x1B[38;5;191m${value}\x1B[0m`,
+  muted: (value) => `\x1B[38;5;244m${value}\x1B[0m`,
+  dim: (value) => `\x1B[2m${value}\x1B[0m`,
+  group: (value) => `\x1B[38;5;214m${value.toUpperCase()}\x1B[0m`,
+  selected: (value) => `\x1B[38;5;16m\x1B[48;5;191m${value}\x1B[0m`
+};
+function commandText(argv) {
+  return ansi.muted(`tm ${argv.filter((arg) => !arg.startsWith("$")).join(" ")}`);
+}
+async function selectValue(title, values, options = {}) {
+  const customLabel = "<custom>";
+  const choices = options.custom ? [...values, customLabel] : values;
+  let selected = 0;
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+  const render = () => {
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write(`${ansi.signal(title)}
+`);
+    process.stdout.write(`${ansi.muted("\u2191/\u2193 choose")}  ${ansi.muted("Enter select")}  ${ansi.muted("Esc return")}
+
+`);
+    choices.forEach((value, index) => {
+      const active = index === selected;
+      const description = value === customLabel ? "custom input" : options.descriptions?.[value] || "";
+      const line = ` ${value.padEnd(18)} ${description}`;
+      process.stdout.write(active ? `${ansi.selected(`\u203A${line}`)}
+` : `${ansi.dim(" ")}${line}
+`);
+    });
+  };
+  render();
+  return new Promise((resolve3) => {
+    const cleanup = () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.off("data", onData);
+      process.stdout.write(`
+`);
+    };
+    const onData = (chunk) => {
+      if (chunk === "\x03" || chunk === "\x1B") {
+        cleanup();
+        resolve3(null);
+        return;
+      }
+      if (chunk === "\r" || chunk === `
+`) {
+        const value = choices[selected] || null;
+        cleanup();
+        resolve3(value === customLabel ? "__custom__" : value);
+        return;
+      }
+      if (chunk === "\x1B[A") {
+        selected = (selected - 1 + choices.length) % choices.length;
+        render();
+      } else if (chunk === "\x1B[B") {
+        selected = (selected + 1) % choices.length;
+        render();
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function selectExistingOrCustom(title, values, prompt) {
+  const uniqueValues = [...new Set(values.filter(Boolean))];
+  const selected = await selectValue(title, uniqueValues, { custom: true });
+  if (selected === null)
+    return null;
+  if (selected === "__custom__")
+    return promptText(prompt);
+  return selected;
+}
+async function skillNameOptions() {
+  try {
+    return (await listSkills()).map((skill) => skill.name);
+  } catch {
+    return [];
+  }
+}
+async function presetNameOptions(fallback) {
+  try {
+    const names = (await listPresets()).map((preset) => preset.name);
+    return fallback && !names.includes(fallback) ? [fallback, ...names] : names;
+  } catch {
+    return fallback ? [fallback] : [];
+  }
+}
+async function mcpNameOptions() {
+  try {
+    return (await listMcpServers()).map((server) => server.name);
+  } catch {
+    return [];
+  }
+}
+async function promptText(prompt) {
+  if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdout.write(`${prompt}${ansi.muted("(Esc to return) ")}`);
+  return new Promise((resolve3) => {
+    let value = "";
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      resetTerminalInput();
+      process.stdout.write(`
+`);
+    };
+    const onData = (data) => {
+      const chunk = String(data);
+      if (chunk === "\x03" || chunk === "\x1B") {
+        cleanup();
+        resolve3(null);
+        return;
+      }
+      if (chunk === "\r" || chunk === `
+`) {
+        cleanup();
+        resolve3(value.trim());
+        return;
+      }
+      if (chunk === "\x7F") {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+        return;
+      }
+      if (chunk >= " ") {
+        value += chunk;
+        process.stdout.write(chunk);
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function waitForMenuReturn() {
+  if (!process.stdin.isTTY)
+    return;
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdout.write(`
+${ansi.muted("Press Enter or Esc to return to menu.")}`);
+  await new Promise((resolve3) => {
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      resetTerminalInput();
+      process.stdout.write(`
+`);
+    };
+    const onData = (data) => {
+      const chunk = String(data);
+      if (chunk === "\r" || chunk === `
+` || chunk === "\x1B" || chunk === "\x03") {
+        cleanup();
+        resolve3();
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+function resetTerminalInput() {
+  if (process.stdin.isTTY)
+    process.stdin.setRawMode(false);
+  process.stdin.pause();
+}
+async function confirm(prompt) {
+  process.stderr.write(prompt);
+  const line = await new Promise((resolve3) => {
+    process.stdin.once("data", (data) => resolve3(String(data)));
+  });
+  return ["y", "yes"].includes(line.trim().toLowerCase());
+}
+function printHelp() {
+  console.log(`Usage:
+  tm init
+  tm status [--json]
+  tm agents list [--tool <tool|all>] [--json]
+  tm skills add <source>
+  tm skills add --tool <tool|all>
+  tm skills add --codex
+  tm skills add --all
+  tm skills list [--json]
+  tm skills list --tool <tool|all> [--json]
+  tm skills show <name> [--json]
+  tm skills remove <name>
+  tm skills sync [preset] [--tool <tool|all>] [--mode <symlink|copy>]
+  tm presets list [--json]
+  tm presets apply [preset] [--tool <tool|all>] [--mode <symlink|copy>]
+  tm presets move-skill <skill> <from> <to>
+  tm presets move <from> <to>
+  tm mcp add <name> --command <cmd> [--arg value] [--env K=V] [--tool <tool|all>]
+  tm mcp add --tool <tool|all>
+  tm mcp list [--json]
+  tm mcp list --tool <tool|all> [--json]
+  tm mcp show <name> [--json]
+  tm mcp sync [--tool <tool|all>]
+  tm mcp remove <name>
+  tm backup`);
+}
+main().catch((error) => {
+  resetTerminalInput();
+  if (error instanceof UsageError) {
+    console.error(error.message);
+    process.exitCode = 2;
+    return;
+  }
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}).finally(() => closeDb());