@michael_magdy/mic-drop 0.1.0

package/README.md

@@ -0,0 +1,208 @@
+# mic-drop
+
+Turn a Jira ticket into an isolated git worktree with Claude Code running automatically — in one command.
+
+```bash
+mic-drop PROJ-123
+```
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) 18+
+- [Git](https://git-scm.com/) 2.5+ (worktree support)
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) — `npm install -g @anthropic-ai/claude-code`
+- A Jira Cloud instance with API access
+
+## Installation
+
+```bash
+npm install -g @michael_magdy/mic-drop
+```
+
+Then run the setup wizard once:
+
+```bash
+mic-drop setup
+```
+
+This will ask for your Jira credentials and save them securely to your OS keychain (macOS Keychain, Linux Secret Service, or Windows Credential Manager). No environment variables needed.
+
+To generate a Jira API token, go to [Atlassian API Tokens](https://id.atlassian.com/manage-profile/security/api-tokens).
+
+## Quick Start
+
+```bash
+# From inside any git repository
+cd ~/Projects/my-app
+mic-drop PROJ-123
+```
+
+That's it. The tool will:
+1. Fetch the ticket title and description from Jira
+2. Create a worktree at `.worktrees/PROJ-123/` branched off your base branch
+3. Copy any configured project files (if configured in `.worktree.json`)
+4. Open a new terminal window with Claude, ticket context pasted and ready to submit
+
+## Usage
+
+```
+mic-drop [options] <TICKET-123>
+mic-drop setup
+```
+
+| Option | Description |
+|--------|-------------|
+| `TICKET-123` | The Jira issue key (required) |
+| `-p, --project <path>` | Path to the git project root. Defaults to the current git repository. |
+| `-a, --auto` | Auto-submit the ticket to Claude without waiting for review |
+| `-h, --help` | Show help |
+
+### Examples
+
+```bash
+# Use the current directory's git root
+mic-drop PROJ-42
+
+# Specify a project explicitly
+mic-drop -p ~/Projects/my-app PROJ-42
+
+# Auto-submit without review
+mic-drop PROJ-42 --auto
+```
+
+## Project Configuration
+
+Create a `.worktree.json` file in your project root to customize behaviour. All fields are optional — sensible defaults are used when omitted.
+
+```json
+{
+  "baseBranch": "main",
+  "worktreesDir": ".worktrees",
+  "copyFiles": [".env", ".env.local"],
+  "copyDirs": [],
+  "terminal": "warp",
+  "claudeMode": "--permission-mode plan"
+}
+```
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `baseBranch` | `develop` | Branch to base new worktrees on |
+| `worktreesDir` | `.worktrees` | Where to create worktrees, relative to project root |
+| `copyFiles` | `[]` | Files to copy from the main project into the worktree |
+| `copyDirs` | `[]` | Directories to copy recursively |
+| `terminal` | `warp` | Terminal to use: `warp`, `iterm`, `terminal` |
+| `claudeMode` | `--permission-mode plan` | Flags passed to the `claude` CLI |
+
+### Legacy `.worktree.conf`
+
+If your project has an existing bash-style `.worktree.conf`, `mic-drop` will read it automatically and prompt you to migrate to `.worktree.json`.
+
+### Branch Naming
+
+Branches are automatically named using the pattern: `TICKET-KEY_Title-With-Hyphens`
+
+For example, ticket `PROJ-42` with title "Fix login button" becomes branch `PROJ-42_Fix-login-button`.
+
+### Example Configs
+
+**React / Next.js:**
+```json
+{
+  "baseBranch": "main",
+  "copyFiles": [".env", ".env.local"]
+}
+```
+
+**Android (Kotlin/Java):**
+```json
+{
+  "baseBranch": "develop",
+  "copyFiles": ["local.properties", "app/google-services.json"],
+  "copyDirs": ["keystores", ".gradle"]
+}
+```
+
+**Python / Django:**
+```json
+{
+  "baseBranch": "main",
+  "copyFiles": [".env"],
+  "copyDirs": [".venv"]
+}
+```
+
+## Directory Structure
+
+After running, your file system looks like this:
+
+```
+~/Projects/my-app/
+├── .git/
+├── .worktrees/          ← added to .gitignore automatically
+│   └── PROJ-42/         ← Claude is working here (isolated branch)
+│       └── src/
+├── .worktree.json
+└── src/                 ← your main branch, untouched
+```
+
+Each worktree is a fully independent checkout on its own branch. You can build, test, and run them separately while Claude works.
+
+## Worktree Cleanup
+
+When Claude finishes and you've merged the PR:
+
+```bash
+# From the main project directory
+git worktree remove .worktrees/PROJ-42
+git branch -d PROJ-42_Fix-login-button
+
+# Or prune all finished worktrees at once:
+git worktree prune
+```
+
+## Workflow
+
+```
+┌─────────────┐     ┌──────────────────┐     ┌─────────────────┐
+│  Jira Board │────▶│  mic-drop PROJ-42 │────▶│  Claude works   │
+│  Pick ticket│     │  One command      │     │  independently  │
+└─────────────┘     └──────────────────┘     └────────┬────────┘
+                                                       │
+                     ┌──────────────────┐              │
+                     │  You keep coding │              │
+                     │  on your branch  │◀─────────────┘
+                     └────────┬─────────┘         (in parallel)
+                              │
+                     ┌────────▼─────────┐
+                     │  Review and      │
+                     │  merge the PR    │
+                     └──────────────────┘
+```
+
+## Troubleshooting
+
+**"No credentials found. Run: mic-drop setup"**
+Run `mic-drop setup` to configure your Jira credentials.
+
+**"Not inside a git repository"**
+Run the command from inside a git repo, or pass `-p /path/to/project`.
+
+**Could not fetch ticket**
+Check that your Jira domain, email, and API token are correct. Run `mic-drop setup` to reconfigure.
+
+**"Worktree already exists"**
+A worktree for that ticket was already created. Remove it first:
+```bash
+git worktree remove .worktrees/PROJ-42
+```
+
+**Files not being copied**
+Verify paths in `copyFiles` and `copyDirs` are relative to the project root. The tool will warn about missing files but won't fail.
+
+**Terminal opens but Claude doesn't start (Warp)**
+macOS requires Accessibility permissions for terminal automation. Go to **System Preferences → Privacy & Security → Accessibility** and ensure your terminal app is listed.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,806 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/setup.ts
+var import_prompts = require("@inquirer/prompts");
+var import_path5 = __toESM(require("path"));
+
+// src/config/credentials.ts
+var import_keytar = __toESM(require("keytar"));
+var SERVICE = "mic-drop";
+async function saveCredentials(creds) {
+  await import_keytar.default.setPassword(SERVICE, "jira-domain", creds.domain);
+  await import_keytar.default.setPassword(SERVICE, "jira-email", creds.email);
+  await import_keytar.default.setPassword(SERVICE, "jira-api-token", creds.apiToken);
+}
+async function loadCredentials() {
+  const [domain, email, apiToken] = await Promise.all([
+    import_keytar.default.getPassword(SERVICE, "jira-domain"),
+    import_keytar.default.getPassword(SERVICE, "jira-email"),
+    import_keytar.default.getPassword(SERVICE, "jira-api-token")
+  ]);
+  if (!domain || !email || !apiToken) return null;
+  return { domain, email, apiToken };
+}
+
+// src/config/projectConfig.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+
+// src/config/schema.ts
+var import_zod = require("zod");
+var ProjectConfigSchema = import_zod.z.object({
+  baseBranch: import_zod.z.string().default("develop"),
+  worktreesDir: import_zod.z.string().default(".worktrees"),
+  copyFiles: import_zod.z.array(import_zod.z.string()).default([]),
+  copyDirs: import_zod.z.array(import_zod.z.string()).default([]),
+  terminal: import_zod.z.string().default("warp"),
+  claudeMode: import_zod.z.string().default("--permission-mode plan")
+});
+var PROJECT_CONFIG_DEFAULTS = {
+  baseBranch: "develop",
+  worktreesDir: ".worktrees",
+  copyFiles: [],
+  copyDirs: [],
+  terminal: "warp",
+  claudeMode: "--permission-mode plan"
+};
+
+// src/config/projectConfig.ts
+var JSON_CONFIG = ".worktree.json";
+var LEGACY_CONFIG = ".worktree.conf";
+async function loadProjectConfig(repoRoot) {
+  const jsonPath = import_path.default.join(repoRoot, JSON_CONFIG);
+  const legacyPath = import_path.default.join(repoRoot, LEGACY_CONFIG);
+  if (import_fs.default.existsSync(jsonPath)) {
+    const raw = JSON.parse(import_fs.default.readFileSync(jsonPath, "utf-8"));
+    const config = ProjectConfigSchema.parse(raw);
+    return { config, source: "json" };
+  }
+  if (import_fs.default.existsSync(legacyPath)) {
+    const config = parseLegacyConf(import_fs.default.readFileSync(legacyPath, "utf-8"));
+    return { config, source: "legacy" };
+  }
+  return { config: { ...PROJECT_CONFIG_DEFAULTS }, source: "defaults" };
+}
+function saveProjectConfig(repoRoot, config) {
+  const jsonPath = import_path.default.join(repoRoot, JSON_CONFIG);
+  import_fs.default.writeFileSync(jsonPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function parseLegacyConf(content) {
+  const partial = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const arrayMatch = trimmed.match(/^(\w+)=\(([^)]*)\)$/);
+    if (arrayMatch) {
+      const key = arrayMatch[1];
+      const raw = arrayMatch[2].trim();
+      const items = [];
+      for (const m of raw.matchAll(/\"([^\"]*)\"|'([^']*)'|(\S+)/g)) {
+        items.push(m[1] ?? m[2] ?? m[3]);
+      }
+      partial[key] = items;
+      continue;
+    }
+    const scalarMatch = trimmed.match(/^(\w+)=(?:"([^"]*)"|'([^']*)'|(.*))$/);
+    if (scalarMatch) {
+      const key = scalarMatch[1];
+      const value = scalarMatch[2] ?? scalarMatch[3] ?? scalarMatch[4] ?? "";
+      partial[key] = value;
+    }
+  }
+  return ProjectConfigSchema.parse({
+    baseBranch: partial["BASE_BRANCH"],
+    worktreesDir: partial["WORKTREES_DIR"],
+    copyFiles: partial["COPY_FILES"],
+    copyDirs: partial["COPY_DIRS"],
+    terminal: partial["TERMINAL"],
+    claudeMode: partial["CLAUDE_MODE"]
+  });
+}
+
+// src/jira/adfParser.ts
+function extractText(node) {
+  const parts = [];
+  if (node.type === "text" && node.text) {
+    parts.push(node.text);
+  }
+  if (node.content) {
+    for (const child of node.content) {
+      parts.push(...extractText(child));
+    }
+  }
+  return parts;
+}
+function parseAdf(description) {
+  if (!description || typeof description !== "object") {
+    return "No description provided.";
+  }
+  const texts = extractText(description);
+  if (texts.length === 0) return "No description provided.";
+  return texts.join("\n");
+}
+
+// src/jira/client.ts
+var JiraAuthError = class extends Error {
+  constructor() {
+    super("Invalid Jira credentials. Run mic-drop setup to reconfigure.");
+    this.name = "JiraAuthError";
+  }
+};
+var JiraTicketNotFoundError = class extends Error {
+  constructor(key) {
+    super(`Ticket ${key} not found.`);
+    this.name = "JiraTicketNotFoundError";
+  }
+};
+var JiraApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "JiraApiError";
+  }
+  status;
+};
+async function fetchIssue(creds, issueKey) {
+  const token = Buffer.from(`${creds.email}:${creds.apiToken}`).toString("base64");
+  const url = `https://${creds.domain}/rest/api/3/issue/${issueKey}`;
+  const res = await fetch(url, {
+    headers: {
+      Authorization: `Basic ${token}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (res.status === 401 || res.status === 403) {
+    throw new JiraAuthError();
+  }
+  if (res.status === 404) {
+    throw new JiraTicketNotFoundError(issueKey);
+  }
+  if (!res.ok) {
+    throw new JiraApiError(res.status, `Jira API returned HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  const title = data.fields?.summary;
+  if (!title) {
+    throw new JiraApiError(200, `Could not parse ticket ${issueKey} \u2014 missing summary field.`);
+  }
+  return {
+    key: issueKey,
+    title,
+    description: parseAdf(data.fields.description)
+  };
+}
+async function verifyCredentials(creds) {
+  const token = Buffer.from(`${creds.email}:${creds.apiToken}`).toString("base64");
+  const url = `https://${creds.domain}/rest/api/3/myself`;
+  const res = await fetch(url, {
+    headers: {
+      Authorization: `Basic ${token}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (res.status === 401 || res.status === 403) {
+    throw new JiraAuthError();
+  }
+  if (!res.ok) {
+    throw new JiraApiError(res.status, `Jira API returned HTTP ${res.status}`);
+  }
+}
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var logger = {
+  info: (msg) => console.log(import_chalk.default.cyan("  " + msg)),
+  success: (msg) => console.log(import_chalk.default.green("  \u2713 " + msg)),
+  warn: (msg) => console.log(import_chalk.default.yellow("  \u26A0 " + msg)),
+  error: (msg) => console.error(import_chalk.default.red("  \u2717 " + msg)),
+  step: (msg) => console.log(import_chalk.default.bold("\n" + msg)),
+  detail: (label, value) => console.log(import_chalk.default.gray("    " + label + ":") + " " + value)
+};
+
+// src/terminal/fallback.ts
+var FallbackLauncher = class {
+  name = "fallback";
+  platform = ["darwin", "linux", "win32"];
+  async isAvailable() {
+    return true;
+  }
+  async launch({ workingDirectory, command }) {
+    logger.warn("Could not auto-launch a terminal. Run these commands manually:");
+    console.log(`
+    cd ${workingDirectory}`);
+    console.log(`    ${command}
+`);
+  }
+};
+
+// src/terminal/launchers/warp.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_child_process = require("child_process");
+var WarpLauncher = class {
+  name = "warp";
+  platform = ["darwin"];
+  async isAvailable() {
+    try {
+      (0, import_child_process.execSync)("test -d /Applications/Warp.app", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async launch({ workingDirectory, command }) {
+    const scriptPath = import_path2.default.join(workingDirectory, ".start-claude.sh");
+    import_fs2.default.writeFileSync(scriptPath, `#!/bin/bash
+${command}
+`, { mode: 493 });
+    (0, import_child_process.spawn)("open", ["-a", "Warp", workingDirectory], { detached: true, stdio: "ignore" }).unref();
+    await sleep(2e3);
+    const script = [
+      `tell application "System Events" to tell process "Warp" to keystroke "bash .start-claude.sh"`,
+      `tell application "System Events" to tell process "Warp" to keystroke return`
+    ].join("\n");
+    (0, import_child_process.spawn)("osascript", ["-e", script], { detached: true, stdio: "ignore" }).unref();
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/terminal/launchers/iterm.ts
+var import_child_process2 = require("child_process");
+var ITermLauncher = class {
+  name = "iterm";
+  platform = ["darwin"];
+  async isAvailable() {
+    try {
+      (0, import_child_process2.execSync)("test -d '/Applications/iTerm.app'", { stdio: "ignore" });
+      return true;
+    } catch {
+      try {
+        (0, import_child_process2.execSync)("test -d '/Applications/iTerm2.app'", { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+  async launch({ workingDirectory, command }) {
+    const escapedDir = workingDirectory.replace(/'/g, "'\\''");
+    const escapedCmd = command.replace(/'/g, "'\\''");
+    const script = `
+tell application "iTerm"
+  activate
+  set newWindow to (create window with default profile)
+  tell current session of newWindow
+    write text "cd '${escapedDir}' && ${escapedCmd}"
+  end tell
+end tell`;
+    (0, import_child_process2.spawn)("osascript", ["-e", script], { detached: true, stdio: "ignore" }).unref();
+  }
+};
+
+// src/terminal/launchers/terminal-app.ts
+var import_child_process3 = require("child_process");
+var TerminalAppLauncher = class {
+  name = "terminal";
+  platform = ["darwin"];
+  async isAvailable() {
+    return process.platform === "darwin";
+  }
+  async launch({ workingDirectory, command }) {
+    const escapedDir = workingDirectory.replace(/'/g, "'\\''");
+    const escapedCmd = command.replace(/'/g, "'\\''");
+    const script = `
+tell application "Terminal"
+  activate
+  do script "cd '${escapedDir}' && ${escapedCmd}"
+end tell`;
+    (0, import_child_process3.spawn)("osascript", ["-e", script], { detached: true, stdio: "ignore" }).unref();
+  }
+};
+
+// src/terminal/launchers/gnome-terminal.ts
+var import_child_process4 = require("child_process");
+var GnomeTerminalLauncher = class {
+  name = "gnome-terminal";
+  platform = ["linux"];
+  async isAvailable() {
+    try {
+      (0, import_child_process4.execSync)("which gnome-terminal", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async launch({ workingDirectory, command }) {
+    (0, import_child_process4.spawn)(
+      "gnome-terminal",
+      ["--working-directory", workingDirectory, "--", "bash", "-c", command],
+      { detached: true, stdio: "ignore" }
+    ).unref();
+  }
+};
+
+// src/terminal/launchers/konsole.ts
+var import_child_process5 = require("child_process");
+var KonsoleLauncher = class {
+  name = "konsole";
+  platform = ["linux"];
+  async isAvailable() {
+    try {
+      (0, import_child_process5.execSync)("which konsole", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async launch({ workingDirectory, command }) {
+    (0, import_child_process5.spawn)("konsole", ["--workdir", workingDirectory, "-e", command], {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+  }
+};
+
+// src/terminal/launchers/windows-terminal.ts
+var import_child_process6 = require("child_process");
+var WindowsTerminalLauncher = class {
+  name = "windows-terminal";
+  platform = ["win32"];
+  async isAvailable() {
+    try {
+      (0, import_child_process6.execSync)("where wt", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async launch({ workingDirectory, command }) {
+    (0, import_child_process6.spawn)("wt", ["-d", workingDirectory, "powershell", "-Command", command], {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+  }
+};
+
+// src/terminal/registry.ts
+var ALL_LAUNCHERS = [
+  new WarpLauncher(),
+  new ITermLauncher(),
+  new TerminalAppLauncher(),
+  new GnomeTerminalLauncher(),
+  new KonsoleLauncher(),
+  new WindowsTerminalLauncher()
+];
+var FALLBACK = new FallbackLauncher();
+function getLauncher(name) {
+  const platform = process.platform;
+  const launcher = ALL_LAUNCHERS.find(
+    (l) => l.name === name && l.platform.includes(platform)
+  );
+  return launcher ?? FALLBACK;
+}
+async function getAvailableLaunchers() {
+  const platform = process.platform;
+  const platformLaunchers = ALL_LAUNCHERS.filter(
+    (l) => l.platform.includes(platform)
+  );
+  const available = [];
+  for (const launcher of platformLaunchers) {
+    if (await launcher.isAvailable()) {
+      available.push(launcher);
+    }
+  }
+  return available;
+}
+
+// src/git/gitignore.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+function ensureGitignoreEntry(repoRoot, entry) {
+  const gitignorePath = import_path3.default.join(repoRoot, ".gitignore");
+  const entryNorm = entry.endsWith("/") ? entry : entry + "/";
+  const entryBase = entry.replace(/\/$/, "");
+  let existing = "";
+  if (import_fs3.default.existsSync(gitignorePath)) {
+    existing = import_fs3.default.readFileSync(gitignorePath, "utf-8");
+    const lines = existing.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === entryBase || trimmed === entryNorm) {
+        return;
+      }
+    }
+  }
+  const toAppend = existing.endsWith("\n") || existing === "" ? entryNorm + "\n" : "\n" + entryNorm + "\n";
+  import_fs3.default.appendFileSync(gitignorePath, toAppend, "utf-8");
+}
+
+// src/git/worktree.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var import_simple_git = __toESM(require("simple-git"));
+var WorktreeExistsError = class extends Error {
+  constructor(targetDir) {
+    super(`Worktree already exists at ${targetDir}. Remove it first with:
+    git worktree remove ${targetDir}`);
+    this.name = "WorktreeExistsError";
+  }
+};
+var GitNotRepoError = class extends Error {
+  constructor() {
+    super("Not inside a git repository.");
+    this.name = "GitNotRepoError";
+  }
+};
+async function resolveRepoRoot(startDir) {
+  const git = (0, import_simple_git.default)(startDir);
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) throw new GitNotRepoError();
+  return await git.revparse(["--show-toplevel"]);
+}
+async function createWorktree(opts) {
+  const { repoRoot, targetDir, branchName, baseBranch } = opts;
+  const git = (0, import_simple_git.default)(repoRoot);
+  if (import_fs4.default.existsSync(targetDir)) {
+    throw new WorktreeExistsError(targetDir);
+  }
+  await git.raw(["worktree", "prune"]);
+  await git.fetch("origin", baseBranch);
+  const branchSummary = await git.branch(["-a"]);
+  const branchExists = branchName in branchSummary.branches || `remotes/origin/${branchName}` in branchSummary.branches;
+  import_fs4.default.mkdirSync(import_path4.default.dirname(targetDir), { recursive: true });
+  if (branchExists) {
+    await git.raw(["worktree", "add", targetDir, branchName]);
+  } else {
+    await git.raw([
+      "worktree",
+      "add",
+      targetDir,
+      `origin/${baseBranch}`,
+      "-b",
+      branchName
+    ]);
+  }
+  try {
+    const worktreeGit = (0, import_simple_git.default)(targetDir);
+    await worktreeGit.branch(["--unset-upstream"]);
+  } catch {
+  }
+  return { branchReused: branchExists };
+}
+async function excludeFromWorktree(worktreeDir, entries) {
+  const git = (0, import_simple_git.default)(worktreeDir);
+  const gitDir = (await git.revparse(["--git-dir"])).trim();
+  const absoluteGitDir = import_path4.default.isAbsolute(gitDir) ? gitDir : import_path4.default.join(worktreeDir, gitDir);
+  const excludePath = import_path4.default.join(absoluteGitDir, "info", "exclude");
+  import_fs4.default.mkdirSync(import_path4.default.dirname(excludePath), { recursive: true });
+  const existing = import_fs4.default.existsSync(excludePath) ? import_fs4.default.readFileSync(excludePath, "utf-8") : "";
+  const existingLines = existing.split("\n");
+  const toAdd = entries.filter((e) => !existingLines.includes(e));
+  if (toAdd.length > 0) {
+    import_fs4.default.appendFileSync(excludePath, toAdd.join("\n") + "\n", "utf-8");
+  }
+}
+function copyProjectFiles(repoRoot, targetDir, copyFiles, copyDirs) {
+  const copied = [];
+  const missing = [];
+  for (const file of copyFiles) {
+    const src = import_path4.default.join(repoRoot, file);
+    const dest = import_path4.default.join(targetDir, file);
+    if (import_fs4.default.existsSync(src)) {
+      import_fs4.default.mkdirSync(import_path4.default.dirname(dest), { recursive: true });
+      import_fs4.default.copyFileSync(src, dest);
+      copied.push(file);
+    } else {
+      missing.push(file);
+    }
+  }
+  for (const dir of copyDirs) {
+    const src = import_path4.default.join(repoRoot, dir);
+    const dest = import_path4.default.join(targetDir, dir);
+    if (import_fs4.default.existsSync(src) && import_fs4.default.statSync(src).isDirectory()) {
+      copyDirRecursive(src, dest);
+      copied.push(dir + "/");
+    } else {
+      missing.push(dir + "/");
+    }
+  }
+  return { copied, missing };
+}
+function copyDirRecursive(src, dest) {
+  import_fs4.default.mkdirSync(dest, { recursive: true });
+  for (const entry of import_fs4.default.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = import_path4.default.join(src, entry.name);
+    const destPath = import_path4.default.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      import_fs4.default.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/utils/spinner.ts
+var import_ora = __toESM(require("ora"));
+function createSpinner(text) {
+  return (0, import_ora.default)({ text, color: "cyan" });
+}
+async function withSpinner(text, fn) {
+  const spinner = createSpinner(text);
+  spinner.start();
+  try {
+    const result = await fn();
+    spinner.succeed();
+    return result;
+  } catch (err) {
+    spinner.fail();
+    throw err;
+  }
+}
+
+// src/commands/setup.ts
+async function runSetup() {
+  logger.step("mic-drop setup");
+  console.log();
+  const existingCreds = await loadCredentials().catch(() => null);
+  const domain = await (0, import_prompts.input)({
+    message: "Jira domain (e.g. yourcompany.atlassian.net):",
+    default: existingCreds?.domain,
+    validate: (v) => v.trim() ? true : "Required"
+  });
+  const email = await (0, import_prompts.input)({
+    message: "Jira email:",
+    default: existingCreds?.email,
+    validate: (v) => v.trim() ? true : "Required"
+  });
+  const apiToken = await (0, import_prompts.password)({
+    message: "Jira API token:",
+    validate: (v) => v.trim() ? true : "Required"
+  });
+  const creds = {
+    domain: domain.trim(),
+    email: email.trim(),
+    apiToken: apiToken.trim()
+  };
+  await withSpinner("Verifying credentials...", async () => {
+    await verifyCredentials(creds);
+  }).catch((err) => {
+    if (err instanceof JiraAuthError) {
+      logger.error("Invalid credentials. Check your domain, email, and API token.");
+      process.exit(1);
+    }
+    throw err;
+  });
+  await saveCredentials(creds);
+  logger.success("Credentials saved to system keychain.");
+  console.log();
+  logger.step("Per-project configuration");
+  let repoRoot = null;
+  try {
+    repoRoot = await resolveRepoRoot(process.cwd());
+  } catch (err) {
+    if (!(err instanceof GitNotRepoError)) throw err;
+  }
+  if (!repoRoot) {
+    console.log(
+      "  (Not in a git repo \u2014 run mic-drop setup from inside a project to configure it)\n"
+    );
+    console.log("Setup complete. Run: mic-drop PROJ-123\n");
+    return;
+  }
+  const configProject = await (0, import_prompts.confirm)({
+    message: `Configure project at ${repoRoot}?`,
+    default: true
+  });
+  if (!configProject) {
+    console.log("\nSetup complete. Run: mic-drop PROJ-123\n");
+    return;
+  }
+  const { config: existing, source } = await loadProjectConfig(repoRoot);
+  if (source === "legacy") {
+    logger.warn(
+      "Found .worktree.conf (legacy format). Settings have been migrated \u2014 a new .worktree.json will be written."
+    );
+  }
+  const baseBranch = await (0, import_prompts.input)({
+    message: "Base branch:",
+    default: existing.baseBranch
+  });
+  const worktreesDir = await (0, import_prompts.input)({
+    message: "Worktrees directory (relative to project root):",
+    default: existing.worktreesDir
+  });
+  const copyFilesRaw = await (0, import_prompts.input)({
+    message: "Files to copy into worktree (comma-separated, or leave empty):",
+    default: existing.copyFiles.join(", ")
+  });
+  const copyDirsRaw = await (0, import_prompts.input)({
+    message: "Directories to copy into worktree (comma-separated, or leave empty):",
+    default: existing.copyDirs.join(", ")
+  });
+  const available = await getAvailableLaunchers();
+  const terminalChoices = [
+    ...available.map((l) => ({ name: l.name, value: l.name })),
+    { name: "none (print instructions only)", value: "fallback" }
+  ];
+  const terminal = terminalChoices.length > 1 ? await (0, import_prompts.select)({
+    message: "Preferred terminal:",
+    choices: terminalChoices,
+    default: available.find((l) => l.name === existing.terminal) ? existing.terminal : terminalChoices[0].value
+  }) : terminalChoices[0].value;
+  const claudeMode = await (0, import_prompts.input)({
+    message: "Claude CLI flags:",
+    default: existing.claudeMode
+  });
+  const parseList = (raw) => raw.split(",").map((s) => s.trim()).filter(Boolean);
+  const newConfig = {
+    baseBranch: baseBranch.trim() || "develop",
+    worktreesDir: worktreesDir.trim() || ".worktrees",
+    copyFiles: parseList(copyFilesRaw),
+    copyDirs: parseList(copyDirsRaw),
+    terminal,
+    claudeMode: claudeMode.trim() || "--permission-mode plan"
+  };
+  saveProjectConfig(repoRoot, newConfig);
+  logger.success(`Config written to ${import_path5.default.join(repoRoot, ".worktree.json")}`);
+  ensureGitignoreEntry(repoRoot, newConfig.worktreesDir);
+  logger.success(`.gitignore updated with ${newConfig.worktreesDir}/`);
+  console.log("\nSetup complete. Run: mic-drop PROJ-123\n");
+}
+
+// src/commands/run.ts
+var import_path6 = __toESM(require("path"));
+var import_fs5 = __toESM(require("fs"));
+
+// src/utils/slugify.ts
+var MAX_DESC_LENGTH = 60;
+function slugify(title) {
+  return title.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").slice(0, MAX_DESC_LENGTH).replace(/-+$/, "");
+}
+function buildBranchName(issueKey, title) {
+  return `${issueKey}_${slugify(title)}`;
+}
+
+// src/ticket/formatter.ts
+function formatTicketFile(issue, baseBranch) {
+  return [
+    `[${issue.key}] ${issue.title}`,
+    "",
+    issue.description,
+    "",
+    `When you're done implementing this, create a pull request using:`,
+    `gh pr create --base ${baseBranch}`
+  ].join("\n");
+}
+
+// src/commands/run.ts
+async function runTicket(issueKey, opts) {
+  let repoRoot;
+  try {
+    repoRoot = await resolveRepoRoot(opts.project ?? process.cwd());
+  } catch (err) {
+    if (err instanceof GitNotRepoError) {
+      logger.error("Not inside a git repository. Use -p to specify the project path.");
+      process.exit(1);
+    }
+    throw err;
+  }
+  const { config, source } = await loadProjectConfig(repoRoot);
+  if (source === "legacy") {
+    logger.warn("Using legacy .worktree.conf \u2014 run `mic-drop setup` to migrate to .worktree.json");
+  }
+  const creds = await loadCredentials().catch(() => null);
+  if (!creds) {
+    logger.error("No credentials found. Run: mic-drop setup");
+    process.exit(1);
+  }
+  logger.step(`Fetching ${issueKey}...`);
+  const issue = await withSpinner(
+    `Fetching ${issueKey} from Jira`,
+    () => fetchIssue(creds, issueKey)
+  ).catch((err) => {
+    logger.error(err.message);
+    process.exit(1);
+  });
+  logger.detail("Title", issue.title);
+  const branchName = buildBranchName(issueKey, issue.title);
+  const worktreesRoot = import_path6.default.isAbsolute(config.worktreesDir) ? config.worktreesDir : import_path6.default.join(repoRoot, config.worktreesDir);
+  const targetDir = import_path6.default.join(worktreesRoot, issueKey);
+  logger.step("Preparing worktree...");
+  logger.detail("Branch", branchName);
+  logger.detail("Base", `origin/${config.baseBranch}`);
+  logger.detail("Target", targetDir);
+  const { branchReused } = await withSpinner(
+    "Creating worktree",
+    () => createWorktree({
+      repoRoot,
+      targetDir,
+      branchName,
+      baseBranch: config.baseBranch,
+      copyFiles: config.copyFiles,
+      copyDirs: config.copyDirs
+    })
+  ).catch((err) => {
+    if (err instanceof WorktreeExistsError) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+    logger.error(`Worktree creation failed: ${err.message}`);
+    process.exit(1);
+  });
+  if (branchReused) {
+    logger.warn(`Branch ${branchName} already existed \u2014 reusing it.`);
+  }
+  if (config.copyFiles.length > 0 || config.copyDirs.length > 0) {
+    const { copied, missing } = copyProjectFiles(
+      repoRoot,
+      targetDir,
+      config.copyFiles,
+      config.copyDirs
+    );
+    for (const f of copied) logger.success(`Copied ${f}`);
+    for (const f of missing) logger.warn(`Not found, skipped: ${f}`);
+  }
+  const ticketContent = formatTicketFile(issue, config.baseBranch);
+  const ticketFile = import_path6.default.join(targetDir, ".ticket.md");
+  import_fs5.default.writeFileSync(ticketFile, ticketContent, "utf-8");
+  logger.success("Wrote .ticket.md");
+  await excludeFromWorktree(targetDir, [".ticket.md", ".start-claude.sh"]);
+  ensureGitignoreEntry(repoRoot, config.worktreesDir);
+  logger.success("Updated .gitignore");
+  const claudeCommand = `claude ${config.claudeMode} "$(cat .ticket.md)"`;
+  logger.step("Launching terminal...");
+  const launcher = getLauncher(config.terminal);
+  logger.detail("Terminal", launcher.name);
+  logger.detail("Directory", targetDir);
+  logger.detail("Command", claudeCommand);
+  await launcher.launch({
+    workingDirectory: targetDir,
+    command: claudeCommand
+  });
+  logger.success(`Done! Claude is starting in ${launcher.name === "fallback" ? "manual mode" : launcher.name}.`);
+  console.log();
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("mic-drop").description("Turn a Jira ticket into an isolated git worktree with Claude Code \u2014 in one command.").version("0.1.0");
+program.command("setup").description("Interactive setup wizard for Jira credentials and project configuration").action(async () => {
+  await runSetup();
+});
+program.argument("<issue-key>", "Jira issue key (e.g. PROJ-123)").option("-p, --project <path>", "Path to the git project root (defaults to current directory)").description("Create a worktree and launch Claude for the given Jira ticket").action(async (issueKey, opts) => {
+  await runTicket(issueKey, opts);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@michael_magdy/mic-drop",
+  "version": "0.1.0",
+  "author": "Michael Magdy",
+  "description": "Turn a Jira ticket into an isolated git worktree with Claude Code running automatically — in one command.",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": {
+    "mic-drop": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src --ext .ts",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": ["jira", "git", "worktree", "claude", "cli", "ai"],
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^7.0.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "keytar": "^7.9.0",
+    "ora": "^8.0.1",
+    "simple-git": "^3.22.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5",
+    "vitest": "^1.6.0"
+  }
+}