@devchangjun/ctm 0.1.0

package/dist/index.js

@@ -0,0 +1,1191 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import chalk from "chalk";
+import { input, password, select } from "@inquirer/prompts";
+import ora from "ora";
+
+// src/lib/config.ts
+import Conf from "conf";
+var conf = new Conf({
+  projectName: "ctm",
+  schema: {
+    jiraBaseUrl: { type: "string", default: "" },
+    jiraEmail: { type: "string", default: "" },
+    jiraApiToken: { type: "string", default: "" },
+    jiraAccountId: { type: "string", default: "" },
+    jiraProjectKey: { type: "string", default: "" },
+    baseBranch: { type: "string", default: "main" },
+    branchPrefix: { type: "string", default: "" }
+  }
+});
+function getConfig() {
+  return {
+    jiraBaseUrl: conf.get("jiraBaseUrl"),
+    jiraEmail: conf.get("jiraEmail"),
+    jiraApiToken: conf.get("jiraApiToken"),
+    jiraAccountId: conf.get("jiraAccountId"),
+    jiraProjectKey: conf.get("jiraProjectKey"),
+    baseBranch: conf.get("baseBranch"),
+    branchPrefix: conf.get("branchPrefix")
+  };
+}
+function setConfig(config) {
+  for (const [key, value] of Object.entries(config)) {
+    conf.set(key, value);
+  }
+}
+function getConfigPath() {
+  return conf.path;
+}
+function ensureConfig() {
+  const config = getConfig();
+  const missing = [];
+  if (!config.jiraBaseUrl) missing.push("jiraBaseUrl");
+  if (!config.jiraEmail) missing.push("jiraEmail");
+  if (!config.jiraApiToken) missing.push("jiraApiToken");
+  if (!config.jiraAccountId) missing.push("jiraAccountId");
+  if (!config.jiraProjectKey) missing.push("jiraProjectKey");
+  if (missing.length > 0) {
+    throw new Error(
+      `CTM not configured (missing: ${missing.join(", ")}). Run \`ctm init\` first.`
+    );
+  }
+  return config;
+}
+function resolveIssueKey(input3, projectKey) {
+  if (/^\d+$/.test(input3)) return `${projectKey}-${input3}`;
+  return input3.toUpperCase();
+}
+function extractIssueKeyFromBranch(branch) {
+  const match = branch.match(/([A-Z]+-\d+)/);
+  return match ? match[1] : null;
+}
+var BRANCH_PREFIXES = ["feat", "fix", "refactor", "qa", "chore"];
+function buildBranchName(prefix, issueKey) {
+  if (prefix) return `${prefix}/${issueKey}`;
+  return issueKey;
+}
+function smartBranchPrefix(issueType, defaultPrefix) {
+  const type = issueType.toLowerCase();
+  if (type.includes("bug")) return "fix";
+  if (type.includes("story") || type.includes("feature") || type.includes("improvement"))
+    return "feat";
+  if (type.includes("refactor")) return "refactor";
+  if (type.includes("qa") || type.includes("test")) return "qa";
+  if (type.includes("task") || type.includes("epic") || type.includes("chore")) return "chore";
+  const match = BRANCH_PREFIXES.find((p) => p === defaultPrefix);
+  return match ?? "feat";
+}
+
+// src/lib/jira.ts
+var _config = null;
+function initJira(config) {
+  _config = config;
+}
+function cfg() {
+  if (!_config) throw new Error("Jira client not initialized. Call initJira() first.");
+  return _config;
+}
+function auth(email, token) {
+  return `Basic ${Buffer.from(`${email}:${token}`).toString("base64")}`;
+}
+async function req(path, method = "GET", body) {
+  const { baseUrl, email, apiToken } = cfg();
+  const res = await fetch(`${baseUrl}${path}`, {
+    method,
+    headers: {
+      Authorization: auth(email, apiToken),
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Jira ${res.status} ${res.statusText}: ${text.slice(0, 300)}`);
+  }
+  if (res.status === 204) return void 0;
+  return res.json();
+}
+async function validateCredentials(baseUrl, email, token) {
+  try {
+    const res = await fetch(`${baseUrl}/rest/api/3/myself`, {
+      headers: { Authorization: auth(email, token) }
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function getMyself() {
+  return req("/rest/api/3/myself");
+}
+async function getProjects() {
+  const data = await req(
+    "/rest/api/3/project/search?maxResults=100&orderBy=name"
+  );
+  return data.values.map((p) => ({ key: p.key, name: p.name }));
+}
+function parseNode(node) {
+  if (node.type === "text") return node.text ?? "";
+  if (node.content) return node.content.map(parseNode).join("");
+  return "";
+}
+function parseDescription(desc) {
+  if (!desc) return "";
+  if (typeof desc === "string") return desc;
+  try {
+    const node = desc;
+    if (node.content) {
+      return node.content.map((child) => parseNode(child)).join("\n").trim();
+    }
+  } catch {
+  }
+  return "";
+}
+function toCtmIssue(raw, baseUrl) {
+  return {
+    id: raw.id,
+    key: raw.key,
+    title: raw.fields.summary,
+    description: parseDescription(raw.fields.description) || void 0,
+    priority: raw.fields.priority ?? { id: "", name: "None" },
+    status: raw.fields.status,
+    url: `${baseUrl}/browse/${raw.key}`,
+    issuetype: raw.fields.issuetype ?? { id: "", name: "Task" },
+    labels: raw.fields.labels ?? [],
+    assignee: raw.fields.assignee
+  };
+}
+var ISSUE_FIELDS = [
+  "summary",
+  "description",
+  "priority",
+  "status",
+  "assignee",
+  "labels",
+  "issuetype"
+];
+async function getMyIssues(accountId, opts = {}) {
+  const parts = [`assignee = "${accountId}"`];
+  if (opts.projectKey) parts.push(`project = "${opts.projectKey}"`);
+  if (opts.statusFilter) {
+    parts.push(`status = "${opts.statusFilter}"`);
+  } else {
+    parts.push(`statusCategory != Done`);
+  }
+  const jql = `${parts.join(" AND ")} ORDER BY updated DESC`;
+  const data = await req("/rest/api/3/search/jql", "POST", {
+    jql,
+    fields: ISSUE_FIELDS,
+    maxResults: 50
+  });
+  const { baseUrl } = cfg();
+  return data.issues.map((i) => toCtmIssue(i, baseUrl));
+}
+async function getIssue(key) {
+  const data = await req(
+    `/rest/api/3/issue/${key}?fields=${ISSUE_FIELDS.join(",")}`
+  );
+  const { baseUrl } = cfg();
+  return toCtmIssue(data, baseUrl);
+}
+async function updateIssueStatus(issueKey, targetStatus) {
+  const data = await req(`/rest/api/3/issue/${issueKey}/transitions`);
+  const transition = data.transitions.find((t) => {
+    const name = (t.to?.name ?? t.name).toLowerCase();
+    return name === targetStatus.toLowerCase();
+  });
+  if (!transition) {
+    const available = data.transitions.map((t) => t.to?.name ?? t.name).join(", ");
+    throw new Error(`No transition to "${targetStatus}". Available: ${available}`);
+  }
+  await req(`/rest/api/3/issue/${issueKey}/transitions`, "POST", {
+    transition: { id: transition.id }
+  });
+}
+async function addComment(issueKey, text) {
+  await req(`/rest/api/3/issue/${issueKey}/comment`, "POST", {
+    body: {
+      type: "doc",
+      version: 1,
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text }]
+        }
+      ]
+    }
+  });
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  const existing = getConfig();
+  console.log(chalk.bold("\n\u{1F3AB}  CTM \u2014 Colo Ticket Manager\n"));
+  console.log(chalk.dim("Configure your Jira connection. Press Enter to keep existing values.\n"));
+  const jiraBaseUrl = await input({
+    message: "Jira base URL",
+    default: existing.jiraBaseUrl || void 0,
+    validate: (v) => v.startsWith("https://") ? true : "Must start with https://"
+  });
+  const jiraEmail = await input({
+    message: "Jira email",
+    default: existing.jiraEmail || void 0,
+    validate: (v) => v.includes("@") ? true : "Enter a valid email"
+  });
+  const jiraApiToken = await password({
+    message: "Jira API token (hidden)",
+    mask: "\u2022",
+    validate: (v) => v.length > 0 ? true : "Required"
+  });
+  const spinner = ora("Validating credentials\u2026").start();
+  const valid = await validateCredentials(jiraBaseUrl, jiraEmail, jiraApiToken);
+  if (!valid) {
+    spinner.fail(chalk.red("Invalid credentials. Check your email and API token."));
+    console.log(
+      chalk.dim(
+        "  Get a token: https://id.atlassian.com/manage-profile/security/api-tokens"
+      )
+    );
+    process.exit(1);
+  }
+  initJira({ baseUrl: jiraBaseUrl, email: jiraEmail, apiToken: jiraApiToken });
+  const me = await getMyself();
+  spinner.succeed(
+    `Authenticated as ${chalk.green(me.displayName)} ${chalk.dim(`(${me.emailAddress})`)}`
+  );
+  const projectSpinner = ora("Loading projects\u2026").start();
+  const projects = await getProjects();
+  projectSpinner.stop();
+  if (projects.length === 0) {
+    console.log(chalk.yellow("No projects found. Check your Jira permissions."));
+    process.exit(1);
+  }
+  const jiraProjectKey = await select({
+    message: "Default Jira project",
+    choices: projects.map((p) => ({
+      value: p.key,
+      name: `${chalk.cyan(p.key.padEnd(10))} ${p.name}`
+    })),
+    default: existing.jiraProjectKey || projects[0]?.key,
+    pageSize: 12
+  });
+  const baseBranch = await input({
+    message: "Base branch",
+    default: existing.baseBranch || "main"
+  });
+  const branchPrefix = await input({
+    message: "Default branch prefix (e.g. feat, fix \u2014 leave empty for none)",
+    default: existing.branchPrefix || ""
+  });
+  setConfig({
+    jiraBaseUrl,
+    jiraEmail,
+    jiraApiToken,
+    jiraAccountId: me.accountId,
+    jiraProjectKey,
+    baseBranch,
+    branchPrefix
+  });
+  console.log();
+  console.log(chalk.green("\u2713 CTM configured successfully!"));
+  console.log(`  ${chalk.dim("Config:")} ${chalk.cyan(getConfigPath())}`);
+  console.log();
+  console.log(chalk.dim("  Next: ctm ls        \u2014 view your Jira issues"));
+  console.log(chalk.dim("        ctm start 123  \u2014 create a branch for issue 123"));
+  console.log();
+}
+
+// src/commands/issues.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+
+// src/lib/ui.ts
+import chalk2 from "chalk";
+var PRIORITY_COLOR = {
+  highest: chalk2.red,
+  high: chalk2.yellow,
+  medium: chalk2.blue,
+  low: chalk2.gray,
+  lowest: chalk2.gray
+};
+function priorityBadge(name) {
+  const color = PRIORITY_COLOR[name.toLowerCase()] ?? chalk2.white;
+  return color("\u25CF");
+}
+function priorityLabel(name) {
+  const color = PRIORITY_COLOR[name.toLowerCase()] ?? chalk2.white;
+  return color(name);
+}
+function printIssue(issue) {
+  console.log();
+  console.log(chalk2.bold("\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"));
+  console.log(`  ${chalk2.cyan("Key:")}      ${chalk2.bold(issue.key)}`);
+  console.log(`  ${chalk2.cyan("Title:")}    ${issue.title}`);
+  console.log(`  ${chalk2.cyan("Type:")}     ${issue.issuetype.name}`);
+  console.log(`  ${chalk2.cyan("Priority:")} ${priorityLabel(issue.priority.name)}`);
+  console.log(`  ${chalk2.cyan("Status:")}   ${issue.status.name}`);
+  if (issue.assignee) {
+    console.log(`  ${chalk2.cyan("Assignee:")} ${issue.assignee.displayName}`);
+  }
+  if (issue.labels.length > 0) {
+    console.log(`  ${chalk2.cyan("Labels:")}   ${issue.labels.join(", ")}`);
+  }
+  console.log(`  ${chalk2.cyan("URL:")}      ${chalk2.underline(chalk2.dim(issue.url))}`);
+  if (issue.description) {
+    const preview = issue.description.slice(0, 200);
+    const suffix = issue.description.length > 200 ? " \u2026" : "";
+    console.log(`  ${chalk2.cyan("Desc:")}`);
+    for (const line of preview.split("\n").slice(0, 4)) {
+      console.log(`    ${chalk2.dim(line)}`);
+    }
+    if (suffix) console.log(chalk2.dim("    \u2026"));
+  }
+  console.log(chalk2.bold("\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"));
+  console.log();
+}
+function printSuccess(msg) {
+  console.log(`${chalk2.green("\u2713")} ${msg}`);
+}
+function printWarn(msg) {
+  console.log(`${chalk2.yellow("\u26A0")} ${msg}`);
+}
+function printError(msg) {
+  console.error(`${chalk2.red("\u2717")} ${msg}`);
+}
+
+// src/commands/issues.ts
+var STATUS_PRIORITY = ["In Progress", "To Do", "Open", "Backlog", "Selected for Development"];
+function groupByStatus(issues) {
+  const map = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const s = issue.status.name;
+    if (!map.has(s)) map.set(s, []);
+    map.get(s).push(issue);
+  }
+  const sorted = /* @__PURE__ */ new Map();
+  for (const s of STATUS_PRIORITY) {
+    if (map.has(s)) sorted.set(s, map.get(s));
+  }
+  for (const [k, v] of map) {
+    if (!sorted.has(k)) sorted.set(k, v);
+  }
+  return sorted;
+}
+async function issuesCommand(options) {
+  const config = ensureConfig();
+  initJira({
+    baseUrl: config.jiraBaseUrl,
+    email: config.jiraEmail,
+    apiToken: config.jiraApiToken
+  });
+  const spinner = ora2("Fetching issues\u2026").start();
+  const issues = await getMyIssues(config.jiraAccountId, {
+    projectKey: options.all ? void 0 : options.project ?? config.jiraProjectKey,
+    statusFilter: options.status
+  });
+  spinner.stop();
+  if (issues.length === 0) {
+    console.log(chalk3.dim("\nNo open issues assigned to you.\n"));
+    return;
+  }
+  const grouped = groupByStatus(issues);
+  console.log();
+  for (const [status, group] of grouped) {
+    console.log(chalk3.bold(status));
+    for (const issue of group) {
+      const badge = priorityBadge(issue.priority.name);
+      const key = chalk3.cyan(issue.key.padEnd(12));
+      const title = issue.title.length > 55 ? issue.title.slice(0, 54) + "\u2026" : issue.title.padEnd(55);
+      const type = chalk3.dim(`[${issue.issuetype.name}]`);
+      console.log(`  ${badge} ${key} ${title} ${type}`);
+    }
+    console.log();
+  }
+  console.log(
+    chalk3.dim(`${issues.length} issue(s)  \xB7  ctm start [key] to begin working`)
+  );
+  console.log();
+}
+
+// src/commands/start.ts
+import chalk4 from "chalk";
+import ora3 from "ora";
+import { select as select2, input as input2, confirm } from "@inquirer/prompts";
+
+// src/lib/git.ts
+import simpleGit from "simple-git";
+import { execa } from "execa";
+import { basename, dirname, join } from "path";
+function getGit(cwd = process.cwd()) {
+  return simpleGit(cwd);
+}
+async function getCurrentBranch() {
+  const result = await getGit().revparse(["--abbrev-ref", "HEAD"]);
+  return result.trim();
+}
+async function getRepoRoot() {
+  const result = await getGit().revparse(["--show-toplevel"]);
+  return result.trim();
+}
+async function hasUncommittedChanges() {
+  const status = await getGit().status();
+  return !status.isClean();
+}
+async function stashChanges(message) {
+  await getGit().stash(["push", "-m", message]);
+}
+async function createAndCheckout(branchName, baseBranch) {
+  const git = getGit();
+  await git.fetch(["--prune"]);
+  const local = await git.branchLocal();
+  if (local.all.includes(branchName)) {
+    await git.checkout(branchName);
+    return;
+  }
+  await git.checkoutBranch(branchName, `origin/${baseBranch}`);
+}
+async function checkoutBranch(branchName) {
+  await getGit().checkout(branchName);
+}
+async function pushBranch(branchName) {
+  await getGit().push(["-u", "origin", branchName]);
+}
+async function getLocalBranches() {
+  const result = await getGit().branchLocal();
+  return result.all;
+}
+async function deleteLocalBranch(branchName) {
+  await getGit().deleteLocalBranch(branchName, true);
+}
+async function deleteRemoteBranch(branchName) {
+  await getGit().push(["origin", "--delete", branchName]);
+}
+async function getDiffStat(baseBranch) {
+  try {
+    const stat = await getGit().diffSummary([`origin/${baseBranch}..HEAD`]);
+    return { files: stat.files.length, insertions: stat.insertions, deletions: stat.deletions };
+  } catch {
+    return { files: 0, insertions: 0, deletions: 0 };
+  }
+}
+async function hasNewCommits(baseBranch) {
+  try {
+    const log = await getGit().log([`origin/${baseBranch}..HEAD`]);
+    return log.total > 0;
+  } catch {
+    return false;
+  }
+}
+async function createPR(title, body) {
+  const result = await execa("gh", ["pr", "create", "--title", title, "--body", body]);
+  const lines = result.stdout.trim().split("\n");
+  return lines[lines.length - 1];
+}
+function getWorktreePath(repoRoot, branchName) {
+  const repoName = basename(repoRoot);
+  const safeBranch = branchName.replace(/\//g, "-");
+  return join(dirname(repoRoot), `${repoName}--${safeBranch}`);
+}
+async function addWorktree(worktreePath, branchName, baseBranch) {
+  const git = getGit();
+  await git.fetch(["--prune"]);
+  const local = await git.branchLocal();
+  if (local.all.includes(branchName)) {
+    await git.raw(["worktree", "add", worktreePath, branchName]);
+  } else {
+    await git.raw(["worktree", "add", "-b", branchName, worktreePath, `origin/${baseBranch}`]);
+  }
+}
+async function listWorktrees() {
+  const git = getGit();
+  const raw = await git.raw(["worktree", "list", "--porcelain"]);
+  const entries = [];
+  let current = {};
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) entries.push(current);
+      current = { path: line.slice(9), isMain: entries.length === 0 };
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.slice(5);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.slice(7);
+    } else if (line === "detached") {
+      current.branch = "detached";
+    }
+  }
+  if (current.path) entries.push(current);
+  return entries;
+}
+async function removeWorktree(worktreePath, force = false) {
+  const git = getGit();
+  const args = ["worktree", "remove", ...force ? ["--force"] : [], worktreePath];
+  await git.raw(args);
+  await git.raw(["worktree", "prune"]);
+}
+async function findWorktreeForBranch(branchName) {
+  const trees = await listWorktrees();
+  return trees.find((t) => t.branch === `refs/heads/${branchName}`);
+}
+
+// src/commands/start.ts
+async function pickIssueInteractively(config) {
+  const spinner = ora3("Loading your issues\u2026").start();
+  const issues = await getMyIssues(config.jiraAccountId, {
+    projectKey: config.jiraProjectKey
+  });
+  spinner.stop();
+  if (issues.length === 0) {
+    throw new Error("No open issues assigned to you in this project.");
+  }
+  const key = await select2({
+    message: "Select an issue to start:",
+    choices: issues.map((i) => ({
+      value: i.key,
+      name: `${chalk4.cyan(i.key.padEnd(12))} ${(i.title.length > 54 ? i.title.slice(0, 53) + "\u2026" : i.title).padEnd(55)} ${chalk4.dim(i.priority.name)}`
+    })),
+    pageSize: 12
+  });
+  return issues.find((i) => i.key === key);
+}
+async function startCommand(keyArg, options) {
+  const config = ensureConfig();
+  initJira({
+    baseUrl: config.jiraBaseUrl,
+    email: config.jiraEmail,
+    apiToken: config.jiraApiToken
+  });
+  let issue;
+  if (!keyArg) {
+    issue = await pickIssueInteractively(config);
+  } else {
+    const key = resolveIssueKey(keyArg, config.jiraProjectKey);
+    const spinner = ora3(`Fetching ${key}\u2026`).start();
+    issue = await getIssue(key);
+    spinner.succeed(`Found: ${chalk4.cyan(issue.key)} \u2014 ${issue.title}`);
+  }
+  printIssue(issue);
+  const defaultPrefix = smartBranchPrefix(issue.issuetype.name, config.branchPrefix);
+  const prefix = await select2({
+    message: "Branch type",
+    choices: BRANCH_PREFIXES.map((p) => ({
+      value: p,
+      name: p
+    })),
+    default: defaultPrefix
+  });
+  const suggestedBranch = buildBranchName(prefix, issue.key);
+  const branchName = await input2({
+    message: "Branch name (edit if needed)",
+    default: suggestedBranch,
+    validate: (v) => {
+      if (!v) return "Required";
+      if (/\s/.test(v)) return "No spaces allowed";
+      return true;
+    }
+  });
+  if (options.worktree) {
+    await runWorktreeMode(branchName, issue.key, config.baseBranch);
+  } else {
+    await runBranchMode(branchName, config.baseBranch);
+  }
+  try {
+    await updateIssueStatus(issue.key, "In Progress");
+    printSuccess(`Jira status \u2192 ${chalk4.green("In Progress")}`);
+  } catch (err) {
+    printWarn(`Could not update Jira status: ${String(err)}`);
+  }
+  console.log();
+  console.log(`  Ticket: ${chalk4.dim(issue.url)}`);
+  console.log();
+}
+async function runBranchMode(branchName, baseBranch) {
+  const currentBranch = await getCurrentBranch();
+  if (await hasUncommittedChanges()) {
+    printWarn(`Uncommitted changes on "${currentBranch}".`);
+    const shouldStash = await confirm({
+      message: "Stash them before switching?",
+      default: true
+    });
+    if (shouldStash) {
+      await stashChanges(`ctm: stash before ${branchName}`);
+      printSuccess("Changes stashed.");
+    }
+  }
+  const spinner = ora3(`Creating branch ${chalk4.cyan(branchName)}\u2026`).start();
+  try {
+    await createAndCheckout(branchName, baseBranch);
+    spinner.succeed(`Switched to ${chalk4.cyan(branchName)}`);
+  } catch (err) {
+    spinner.fail(`Failed to create branch: ${String(err)}`);
+    process.exit(1);
+  }
+  console.log();
+  console.log(`${chalk4.green("\u2713")} Ready! Branch: ${chalk4.cyan(branchName)}`);
+}
+async function runWorktreeMode(branchName, issueKey, baseBranch) {
+  const repoRoot = await getRepoRoot();
+  const worktreePath = getWorktreePath(repoRoot, branchName);
+  const existing = await findWorktreeForBranch(branchName);
+  if (existing) {
+    printWarn(`Worktree already exists for "${branchName}"`);
+    console.log(`  ${chalk4.cyan(existing.path)}`);
+    console.log();
+    console.log(`  ${chalk4.dim("cd")} ${chalk4.cyan(existing.path)}`);
+    console.log();
+    process.exit(0);
+  }
+  const spinner = ora3(
+    `Creating worktree ${chalk4.cyan(branchName)} at ${chalk4.dim(worktreePath)}\u2026`
+  ).start();
+  try {
+    await addWorktree(worktreePath, branchName, baseBranch);
+    spinner.succeed(`Worktree created for ${chalk4.cyan(branchName)}`);
+  } catch (err) {
+    spinner.fail(`Failed to create worktree: ${String(err)}`);
+    process.exit(1);
+  }
+  console.log();
+  console.log(`${chalk4.green("\u2713")} Ready!`);
+  console.log(`  ${chalk4.bold("Worktree:")} ${chalk4.cyan(worktreePath)}`);
+  console.log(`  ${chalk4.bold("Branch:")}   ${chalk4.cyan(branchName)}`);
+  console.log();
+  console.log(`  ${chalk4.dim("Move into the worktree:")}`);
+  console.log(`  ${chalk4.cyan(`cd ${worktreePath}`)}`);
+  void issueKey;
+}
+
+// src/commands/done.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+import { confirm as confirm2 } from "@inquirer/prompts";
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
+async function doneCommand(keyArg) {
+  const config = ensureConfig();
+  initJira({
+    baseUrl: config.jiraBaseUrl,
+    email: config.jiraEmail,
+    apiToken: config.jiraApiToken
+  });
+  const currentBranch = await getCurrentBranch();
+  let issueKey;
+  if (keyArg) {
+    issueKey = resolveIssueKey(keyArg, config.jiraProjectKey);
+  } else {
+    const extracted = extractIssueKeyFromBranch(currentBranch);
+    if (!extracted) {
+      printError(
+        `Cannot detect issue key from branch "${currentBranch}". Pass it explicitly: ctm done CTM-123`
+      );
+      process.exit(1);
+    }
+    issueKey = extracted;
+  }
+  const issueSpinner = ora4(`Fetching ${issueKey}\u2026`).start();
+  const issue = await getIssue(issueKey);
+  issueSpinner.stop();
+  printIssue(issue);
+  if (await hasUncommittedChanges()) {
+    printError("You have uncommitted changes. Commit or stash them first.");
+    process.exit(1);
+  }
+  if (!await hasNewCommits(config.baseBranch)) {
+    printWarn(`No new commits on "${currentBranch}" vs origin/${config.baseBranch}.`);
+    const proceed = await confirm2({ message: "Create PR anyway?", default: false });
+    if (!proceed) process.exit(0);
+  }
+  const go = await confirm2({
+    message: `Push "${currentBranch}" and create PR for "${issueKey}"?`,
+    default: true
+  });
+  if (!go) process.exit(0);
+  const pushSpinner = ora4(`Pushing ${chalk5.cyan(currentBranch)}\u2026`).start();
+  try {
+    await pushBranch(currentBranch);
+    pushSpinner.succeed(`Pushed ${chalk5.cyan(currentBranch)}`);
+  } catch (err) {
+    pushSpinner.fail(`Push failed: ${String(err)}`);
+    process.exit(1);
+  }
+  const prTitle = `${issue.key}: ${issue.title}`;
+  let prBody;
+  try {
+    const repoRoot = await getRepoRoot();
+    prBody = await readFile(join2(repoRoot, ".github", "pull_request_template.md"), "utf-8");
+  } catch {
+    prBody = `Jira: [${issue.key}](${issue.url})`;
+  }
+  const prSpinner = ora4("Creating PR\u2026").start();
+  let prUrl;
+  try {
+    prUrl = await createPR(prTitle, prBody);
+    prSpinner.succeed(`PR created: ${chalk5.cyan(prUrl)}`);
+  } catch (err) {
+    prSpinner.fail(`Failed to create PR: ${String(err)}`);
+    console.log(chalk5.dim("  Ensure `gh` is installed and authenticated: gh auth login"));
+    process.exit(1);
+  }
+  try {
+    await addComment(issue.key, `PR: ${prUrl}`);
+    printSuccess("PR URL added to Jira issue.");
+  } catch {
+  }
+  console.log();
+  console.log(`${chalk5.green("\u2713")} Done!`);
+  console.log(`  PR:     ${chalk5.cyan(prUrl)}`);
+  console.log(`  Ticket: ${chalk5.dim(issue.url)}`);
+  console.log();
+}
+
+// src/commands/status.ts
+import chalk6 from "chalk";
+import ora5 from "ora";
+async function statusCommand() {
+  const config = ensureConfig();
+  const currentBranch = await getCurrentBranch();
+  const issueKey = extractIssueKeyFromBranch(currentBranch);
+  console.log();
+  console.log(`${chalk6.cyan("Branch:")} ${chalk6.white(currentBranch)}`);
+  if (!issueKey) {
+    console.log(chalk6.dim("  No Jira ticket detected in branch name."));
+    console.log();
+    return;
+  }
+  initJira({
+    baseUrl: config.jiraBaseUrl,
+    email: config.jiraEmail,
+    apiToken: config.jiraApiToken
+  });
+  const spinner = ora5(`Fetching ${issueKey}\u2026`).start();
+  let issue;
+  try {
+    issue = await getIssue(issueKey);
+    spinner.stop();
+  } catch (err) {
+    spinner.fail(`Could not fetch issue: ${String(err)}`);
+    return;
+  }
+  const diff = await getDiffStat(config.baseBranch);
+  console.log(`${chalk6.cyan("Ticket:")} ${chalk6.bold(issue.key)} \u2014 ${issue.title}`);
+  console.log(`${chalk6.cyan("Status:")} ${issue.status.name}`);
+  console.log(`${chalk6.cyan("Priority:")} ${priorityLabel(issue.priority.name)}`);
+  console.log(`${chalk6.cyan("URL:")}    ${chalk6.underline(chalk6.dim(issue.url))}`);
+  console.log();
+  if (diff.files > 0) {
+    console.log(
+      `${chalk6.cyan("Changes:")} ${diff.files} file(s)  ${chalk6.green(`+${diff.insertions}`)}  ${chalk6.red(`-${diff.deletions}`)}`
+    );
+  } else {
+    console.log(chalk6.dim("No changes vs base branch yet."));
+  }
+  console.log();
+}
+
+// src/commands/clean.ts
+import chalk7 from "chalk";
+import { confirm as confirm3 } from "@inquirer/prompts";
+import ora6 from "ora";
+async function cleanCommand(keyArg) {
+  const config = ensureConfig();
+  const currentBranch = await getCurrentBranch();
+  let branchToClean;
+  if (keyArg) {
+    const key = resolveIssueKey(keyArg, config.jiraProjectKey);
+    const branches = await getLocalBranches();
+    const match = branches.find((b) => b.includes(key));
+    if (!match) {
+      printError(`No local branch found matching issue key "${key}".`);
+      console.log(chalk7.dim(`  Local branches: ${branches.slice(0, 5).join(", ")}`));
+      process.exit(1);
+    }
+    branchToClean = match;
+  } else {
+    const key = extractIssueKeyFromBranch(currentBranch);
+    if (!key) {
+      printError(
+        `Cannot detect issue key from branch "${currentBranch}". Pass it explicitly: ctm clean CTM-123`
+      );
+      process.exit(1);
+    }
+    branchToClean = currentBranch;
+  }
+  console.log();
+  console.log(`Branch to delete: ${chalk7.cyan(branchToClean)}`);
+  console.log();
+  const confirmed = await confirm3({
+    message: `Delete branch "${branchToClean}"?`,
+    default: false
+  });
+  if (!confirmed) process.exit(0);
+  if (branchToClean === currentBranch) {
+    const switchSpinner = ora6(`Switching to ${chalk7.cyan(config.baseBranch)}\u2026`).start();
+    try {
+      await checkoutBranch(config.baseBranch);
+      switchSpinner.succeed(`Switched to ${chalk7.cyan(config.baseBranch)}`);
+    } catch (err) {
+      switchSpinner.fail(`Cannot switch to base branch: ${String(err)}`);
+      process.exit(1);
+    }
+  }
+  const worktree = await findWorktreeForBranch(branchToClean);
+  if (worktree) {
+    printWarn(`Worktree found: ${chalk7.cyan(worktree.path)}`);
+    const removeWt = await confirm3({
+      message: `Remove worktree directory as well?`,
+      default: true
+    });
+    if (removeWt) {
+      const wtSpinner = ora6("Removing worktree\u2026").start();
+      try {
+        await removeWorktree(worktree.path);
+        wtSpinner.succeed(`Worktree removed: ${chalk7.cyan(worktree.path)}`);
+      } catch (err) {
+        wtSpinner.fail(`Could not remove worktree: ${String(err)}`);
+        printWarn("Continuing with branch deletion anyway.");
+      }
+    }
+  }
+  const localSpinner = ora6("Deleting local branch\u2026").start();
+  try {
+    await deleteLocalBranch(branchToClean);
+    localSpinner.succeed(`Deleted local branch ${chalk7.cyan(branchToClean)}`);
+  } catch (err) {
+    localSpinner.fail(`Failed: ${String(err)}`);
+  }
+  const deleteRemote = await confirm3({
+    message: `Also delete remote branch origin/${branchToClean}?`,
+    default: false
+  });
+  if (deleteRemote) {
+    const remoteSpinner = ora6("Deleting remote branch\u2026").start();
+    try {
+      await deleteRemoteBranch(branchToClean);
+      remoteSpinner.succeed("Remote branch deleted.");
+    } catch (err) {
+      remoteSpinner.fail(`Failed: ${String(err)}`);
+    }
+  }
+  console.log();
+  printSuccess("Cleanup complete.");
+  console.log();
+}
+
+// src/commands/help.ts
+import chalk8 from "chalk";
+var COMMANDS = [
+  {
+    name: "init",
+    usage: "ctm init",
+    description: "Jira \uC5F0\uACB0 \uC815\uBCF4\uB97C \uC124\uC815\uD569\uB2C8\uB2E4. \uCD5C\uCD08 1\uD68C \uC2E4\uD589\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.",
+    examples: [
+      { cmd: "ctm init", comment: "\uB300\uD654\uD615 \uC124\uC815 \uC2DC\uC791" }
+    ]
+  },
+  {
+    name: "issues",
+    aliases: ["ls"],
+    usage: "ctm ls [options]",
+    description: "\uB0B4 Jira \uC774\uC288 \uBAA9\uB85D\uC744 \uC0C1\uD0DC\uBCC4\uB85C \uCD9C\uB825\uD569\uB2C8\uB2E4.",
+    options: [
+      { flag: "-a, --all", desc: "\uC804\uCCB4 \uD504\uB85C\uC81D\uD2B8\uC758 \uC774\uC288 \uC870\uD68C" },
+      { flag: "-s, --status <status>", desc: "\uD2B9\uC815 \uC0C1\uD0DC\uB85C \uD544\uD130 (\uC608: 'In Progress')" },
+      { flag: "-p, --project <key>", desc: "\uD2B9\uC815 \uD504\uB85C\uC81D\uD2B8 \uD0A4\uB85C \uD544\uD130" }
+    ],
+    examples: [
+      { cmd: "ctm ls", comment: "\uAE30\uBCF8 \uD504\uB85C\uC81D\uD2B8 \uC774\uC288 \uBAA9\uB85D" },
+      { cmd: "ctm ls --all", comment: "\uC804\uCCB4 \uD504\uB85C\uC81D\uD2B8" },
+      { cmd: "ctm ls --status 'In Progress'", comment: "\uC9C4\uD589 \uC911\uC778 \uC774\uC288\uB9CC" },
+      { cmd: "ctm ls --project CGKR", comment: "\uD2B9\uC815 \uD504\uB85C\uC81D\uD2B8" }
+    ]
+  },
+  {
+    name: "start",
+    usage: "ctm start [key] [-w]",
+    description: "Jira \uC774\uC288\uC5D0 \uB300\uD55C \uBE0C\uB7F0\uCE58\uB97C \uC0DD\uC131\uD558\uACE0 \uCCB4\uD06C\uC544\uC6C3\uD569\uB2C8\uB2E4.\n  Jira \uC0C1\uD0DC\uB97C 'In Progress'\uB85C \uBCC0\uACBD\uD569\uB2C8\uB2E4.",
+    options: [
+      { flag: "-w, --worktree", desc: "\uBCC4\uB3C4 \uB514\uB809\uD1A0\uB9AC(worktree)\uB97C \uC0DD\uC131\uD569\uB2C8\uB2E4 (\uBE0C\uB7F0\uCE58 \uC804\uD658 \uC5C6\uC774 \uBCD1\uB82C \uC791\uC5C5 \uAC00\uB2A5)" }
+    ],
+    examples: [
+      { cmd: "ctm start", comment: "\uC774\uC288 \uBAA9\uB85D\uC5D0\uC11C \uC778\uD130\uB799\uD2F0\uBE0C \uC120\uD0DD" },
+      { cmd: "ctm start CGKR-1423", comment: "\uD2B9\uC815 \uC774\uC288 \uD0A4\uB85C \uBC14\uB85C \uC2DC\uC791" },
+      { cmd: "ctm start 1423 --worktree", comment: "worktree \uBAA8\uB4DC\uB85C \uBC1C\uB3D9" }
+    ]
+  },
+  {
+    name: "done",
+    usage: "ctm done [key]",
+    description: "\uD604\uC7AC \uBE0C\uB79C\uCE58\uB97C push\uD558\uACE0 GitHub PR\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4.\n  .github/pull_request_template.md \uAC00 \uC788\uC73C\uBA74 \uC790\uB3D9\uC73C\uB85C PR body\uC5D0 \uC801\uC6A9\uB429\uB2C8\uB2E4.\n  gh CLI\uAC00 \uC124\uCE58\xB7\uC778\uC99D\uB418\uC5B4 \uC788\uC5B4\uC57C \uD569\uB2C8\uB2E4.",
+    examples: [
+      { cmd: "ctm done", comment: "\uD604\uC7AC \uBE0C\uB79C\uCE58 \uAE30\uC900 \uC790\uB3D9 \uAC10\uC9C0" },
+      { cmd: "ctm done CGKR-1423", comment: "\uC774\uC288 \uD0A4 \uBA85\uC2DC" }
+    ]
+  },
+  {
+    name: "status",
+    aliases: ["st"],
+    usage: "ctm st",
+    description: "\uD604\uC7AC \uBE0C\uB79C\uCE58\uC640 \uC5F0\uACB0\uB41C Jira \uC774\uC288 \uC815\uBCF4, \uBCC0\uACBD \uD604\uD669\uC744 \uCD9C\uB825\uD569\uB2C8\uB2E4.",
+    examples: [
+      { cmd: "ctm st", comment: "\uD604\uC7AC \uC0C1\uD0DC \uD655\uC778" }
+    ]
+  },
+  {
+    name: "clean",
+    usage: "ctm clean [key]",
+    description: "Jira \uC774\uC288\uC5D0 \uC5F0\uACB0\uB41C \uB85C\uCEC8 \uBE0C\uB7F0\uCE58\uB97C \uC0AD\uC81C\uD569\uB2C8\uB2E4.\n  \uC6D0\uACA9 \uBE0C\uB7F0\uCE58\uB3C4 \uD568\uAED8 \uC0AD\uC81C\uD560\uC9C0 \uBB3B\uC5B4\uBD05\uB2C8\uB2E4.\n  worktree\uAC00 \uC788\uC73C\uBA74 \uD568\uAED8 \uC815\uB9AC\uD560\uC9C0 \uBB3B\uC5B4\uBF45\uB2C8\uB2E4.",
+    examples: [
+      { cmd: "ctm clean", comment: "\uD604\uC7AC \uBE0C\uB7F0\uCE58 \uC0AD\uC81C" },
+      { cmd: "ctm clean CGKR-1423", comment: "\uD2B9\uC815 \uC774\uC288 \uBE0C\uB7F0\uCE58 \uC0AD\uC81C" },
+      { cmd: "ctm clean 1423", comment: "\uC22B\uC790\uB9CC \uC785\uB825 \uAC00\uB2A5" }
+    ]
+  },
+  {
+    name: "worktree",
+    aliases: ["wt"],
+    usage: "ctm wt [rm <key>]",
+    description: "worktree \uBAA9\uB85D\uC744 \uD655\uC778\uD558\uAC70\uB098 \uC81C\uAC70\uD569\uB2C8\uB2E4.\n  ctm start --worktree\uB85C \uC0DD\uC131\uB41C worktree\uB97C \uAD00\uB9AC\uD569\uB2C8\uB2E4.",
+    options: [
+      { flag: "-b, --branch", desc: "worktree \uC81C\uAC70 \uC2DC \uBE0C\uB7F0\uCE58\uB3C4 \uD568\uAED8 \uC0AD\uC81C" },
+      { flag: "-f, --force", desc: "\uBCC0\uACBD\uC0AC\uD56D\uC774 \uC788\uC5B4\uB3C4 \uAC15\uC81C \uC81C\uAC70" }
+    ],
+    examples: [
+      { cmd: "ctm wt", comment: "worktree \uBAA9\uB85D" },
+      { cmd: "ctm wt rm CGKR-1423", comment: "worktree \uC81C\uAC70 (\uBE0C\uB7F0\uCE58 \uC720\uC9C0)" },
+      { cmd: "ctm wt rm 1423 --branch", comment: "worktree + \uBE0C\uB7F0\uCE58 \uD568\uAED8 \uC0AD\uC81C" }
+    ]
+  }
+];
+var DIM_RULE = chalk8.dim("\u2500".repeat(56));
+function renderHeader() {
+  console.log();
+  console.log(`  ${chalk8.bold.cyan("ctm")}  ${chalk8.dim("\u2014 Colo Ticket Manager")}`);
+  console.log(`  ${chalk8.dim("Jira \uD2F0\uCF13 \uAE30\uBC18 Git \uBE0C\uB79C\uCE58 \uAD00\uB9AC CLI")}`);
+  console.log();
+}
+function renderUsageLine() {
+  console.log(`  ${chalk8.bold("\uC0AC\uC6A9\uBC95")}  ${chalk8.cyan("ctm")} ${chalk8.dim("<command>")} ${chalk8.dim("[options]")}`);
+  console.log();
+}
+function renderCommandRow(cmd) {
+  const aliases = cmd.aliases?.length ? chalk8.dim(` (${cmd.aliases.join(", ")})`) : "";
+  const name = chalk8.cyan(cmd.name.padEnd(10)) + aliases;
+  const shortDesc = cmd.description.split("\n")[0];
+  console.log(`  ${name}  ${shortDesc}`);
+}
+function renderCommandDetail(cmd) {
+  const aliases = cmd.aliases?.length ? "  " + chalk8.dim(`alias: ${cmd.aliases.join(", ")}`) : "";
+  console.log();
+  console.log(DIM_RULE);
+  console.log(`  ${chalk8.bold.cyan(cmd.name)}${aliases}`);
+  console.log();
+  console.log(`  ${chalk8.bold("\uC0AC\uC6A9\uBC95")}   ${chalk8.cyan(cmd.usage)}`);
+  console.log();
+  for (const line of cmd.description.split("\n")) {
+    console.log(`  ${line}`);
+  }
+  console.log();
+  if (cmd.options?.length) {
+    console.log(`  ${chalk8.bold("\uC635\uC158")}`);
+    for (const opt of cmd.options) {
+      console.log(`    ${chalk8.green(opt.flag.padEnd(26))}  ${opt.desc}`);
+    }
+    console.log();
+  }
+  console.log(`  ${chalk8.bold("\uC608\uC2DC")}`);
+  for (const ex of cmd.examples) {
+    console.log(`    ${chalk8.cyan(ex.cmd.padEnd(38))}  ${chalk8.dim(ex.comment)}`);
+  }
+}
+function renderWorkflow() {
+  console.log();
+  console.log(`  ${chalk8.bold("\uC77C\uBC18\uC801\uC778 \uC6CC\uD06C\uD50C\uB85C\uC6B0")}`);
+  console.log();
+  const steps = [
+    ["ctm init", "\uCD5C\uCD08 1\uD68C \u2014 Jira \uC5F0\uACB0 \uC124\uC815"],
+    ["ctm ls", "\uB0B4 \uC774\uC288 \uBAA9\uB85D \uD655\uC778"],
+    ["ctm start CGKR-123", "\uBE0C\uB79C\uCE58 \uC0DD\uC131 + Jira 'In Progress'"],
+    ["ctm st", "\uD604\uC7AC \uC0C1\uD0DC \uD655\uC778"],
+    ["ctm done", "push + GitHub PR \uC0DD\uC131"],
+    ["ctm clean", "\uBA38\uC9C0 \uD6C4 \uBE0C\uB79C\uCE58 \uC815\uB9AC"]
+  ];
+  for (const [cmd, comment] of steps) {
+    console.log(`    ${chalk8.cyan(cmd.padEnd(24))}  ${chalk8.dim(comment)}`);
+  }
+  console.log();
+}
+function helpCommand(commandName) {
+  if (commandName) {
+    const target = COMMANDS.find(
+      (c) => c.name === commandName || c.aliases?.includes(commandName)
+    );
+    if (!target) {
+      console.error(
+        `${chalk8.red("\u2717")} \uC54C \uC218 \uC5C6\uB294 \uBA85\uB839\uC5B4: ${chalk8.bold(commandName)}
+`
+      );
+      console.log(`  \uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uBA85\uB839\uC5B4: ${COMMANDS.map((c) => chalk8.cyan(c.name)).join(", ")}`);
+      console.log();
+      process.exit(1);
+    }
+    renderHeader();
+    renderCommandDetail(target);
+    console.log();
+    console.log(DIM_RULE);
+    console.log();
+    return;
+  }
+  renderHeader();
+  renderUsageLine();
+  console.log(`  ${chalk8.bold("\uBA85\uB839\uC5B4")}`);
+  console.log();
+  for (const cmd of COMMANDS) {
+    renderCommandRow(cmd);
+  }
+  renderWorkflow();
+  console.log(
+    `  ${chalk8.dim(`\uC790\uC138\uD55C \uB3C4\uC6C0\uB9D0: ${chalk8.cyan("ctm help <command>")}`)}`
+  );
+  console.log();
+}
+
+// src/commands/worktree.ts
+import chalk9 from "chalk";
+import { confirm as confirm4 } from "@inquirer/prompts";
+import ora7 from "ora";
+async function worktreeListCommand() {
+  let trees;
+  try {
+    trees = await listWorktrees();
+  } catch (err) {
+    printError(`Failed to list worktrees: ${String(err)}`);
+    process.exit(1);
+  }
+  console.log();
+  if (trees.length === 0) {
+    console.log(chalk9.dim("  No worktrees found.\n"));
+    return;
+  }
+  console.log(
+    `  ${"PATH".padEnd(52)} ${"BRANCH".padEnd(30)} HEAD`
+  );
+  console.log(chalk9.dim(`  ${"\u2500".repeat(52)} ${"\u2500".repeat(30)} ${"\u2500".repeat(7)}`));
+  for (const t of trees) {
+    const pathLabel = t.isMain ? `${t.path}  ${chalk9.dim("(main)")}` : t.path;
+    const branchDisplay = t.branch.replace("refs/heads/", "");
+    const shortHead = t.head.slice(0, 7);
+    const pathCol = chalk9.cyan(pathLabel.length > 50 ? "\u2026" + pathLabel.slice(-49) : pathLabel);
+    const branchCol = t.isMain ? chalk9.dim(branchDisplay) : chalk9.white(branchDisplay);
+    console.log(`  ${pathCol.padEnd(52)} ${branchCol.padEnd(30)} ${chalk9.dim(shortHead)}`);
+  }
+  console.log();
+  console.log(chalk9.dim(`  ${trees.length} worktree(s)  \xB7  ctm wt rm [key] to remove`));
+  console.log();
+}
+async function worktreeRemoveCommand(keyArg, options) {
+  const config = ensureConfig();
+  let branchName;
+  if (keyArg) {
+    const issueKey = resolveIssueKey(keyArg, config.jiraProjectKey);
+    const branches = await getLocalBranches();
+    const match = branches.find((b) => b.includes(issueKey));
+    if (!match) {
+      printError(`No local branch found matching issue key "${issueKey}".`);
+      process.exit(1);
+    }
+    branchName = match;
+  } else {
+    printError("Please specify an issue key: ctm wt rm <key>");
+    console.log(chalk9.dim("  Example: ctm wt rm CGKR-1423  or  ctm wt rm 1423"));
+    process.exit(1);
+  }
+  const tree = await findWorktreeForBranch(branchName);
+  if (!tree) {
+    const issueKey = extractIssueKeyFromBranch(branchName) ?? branchName;
+    const all = await listWorktrees();
+    const fuzzy = all.find(
+      (t) => !t.isMain && t.branch.includes(issueKey)
+    );
+    if (!fuzzy) {
+      printWarn(`No worktree found for branch "${branchName}".`);
+      console.log(chalk9.dim("  Use ctm wt to see existing worktrees."));
+      process.exit(0);
+    }
+    return doRemove(fuzzy, branchName, options);
+  }
+  return doRemove(tree, branchName, options);
+}
+async function doRemove(tree, branchName, options) {
+  const branchDisplay = tree.branch.replace("refs/heads/", "");
+  console.log();
+  console.log(`  ${chalk9.bold("Worktree:")} ${chalk9.cyan(tree.path)}`);
+  console.log(`  ${chalk9.bold("Branch:")}   ${chalk9.cyan(branchDisplay)}`);
+  console.log();
+  const confirmed = await confirm4({
+    message: `Remove worktree at "${tree.path}"?`,
+    default: false
+  });
+  if (!confirmed) process.exit(0);
+  const spinner = ora7("Removing worktree\u2026").start();
+  try {
+    await removeWorktree(tree.path, options.force);
+    spinner.succeed(`Worktree removed: ${chalk9.cyan(tree.path)}`);
+  } catch (err) {
+    spinner.fail(`Failed to remove worktree: ${String(err)}`);
+    console.log(chalk9.dim("  Try: ctm wt rm <key> --force"));
+    process.exit(1);
+  }
+  const deleteBranch = options.branch ?? await confirm4({
+    message: `Also delete branch "${branchDisplay}"?`,
+    default: false
+  });
+  if (deleteBranch) {
+    try {
+      await deleteLocalBranch(branchName);
+      printSuccess(`Local branch "${branchDisplay}" deleted.`);
+    } catch (err) {
+      printWarn(`Could not delete local branch: ${String(err)}`);
+    }
+    const deleteRemote = await confirm4({
+      message: `Also delete remote branch origin/${branchDisplay}?`,
+      default: false
+    });
+    if (deleteRemote) {
+      try {
+        await deleteRemoteBranch(branchName);
+        printSuccess("Remote branch deleted.");
+      } catch (err) {
+        printWarn(`Could not delete remote branch: ${String(err)}`);
+      }
+    }
+  }
+  console.log();
+  printSuccess("Done.");
+  console.log();
+}
+
+// src/index.ts
+var program = new Command();
+program.name("ctm").description("Colo Ticket Manager \u2014 Jira-driven branch management").version("0.1.0");
+program.command("init").description("Configure CTM with Jira credentials and project settings").action(initCommand);
+program.command("issues").alias("ls").description("List Jira issues assigned to you").option("-a, --all", "Show issues from all projects").option("-s, --status <status>", "Filter by status").option("-p, --project <project>", "Filter by project key").action(issuesCommand);
+program.command("start [key]").description("Create and checkout a branch for a Jira issue (e.g. CTM-123 or just 123)").option("-w, --worktree", "Create a linked worktree instead of switching branches").action(startCommand);
+program.command("done [key]").description("Push branch, create PR, and mark the Jira issue as Done").action(doneCommand);
+program.command("status").alias("st").description("Show current branch status and linked Jira issue").action(statusCommand);
+program.command("clean [key]").description("Delete local (and optionally remote) branch for a Jira issue").action(cleanCommand);
+program.command("help [command]").description("\uBA85\uB839\uC5B4 \uB3C4\uC6C0\uB9D0 \uCD9C\uB825").action(helpCommand);
+var wt = program.command("worktree").alias("wt").description("Manage git worktrees created by ctm start --worktree");
+wt.command("list", { isDefault: true }).description("List all worktrees for the current repo").action(worktreeListCommand);
+wt.command("rm [key]").description("Remove a worktree (optionally also delete the branch)").option("-b, --branch", "Also delete the git branch").option("-f, --force", "Force remove even with untracked changes").action(worktreeRemoveCommand);
+program.parseAsync().catch((err) => {
+  if (err instanceof Error && err.name === "ExitPromptError") {
+    process.exit(0);
+  }
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});