@michael_magdy/mic-drop 0.1.0 → 0.1.2

package/dist/index.js

@@ -26,9 +26,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/index.ts
 var import_commander = require("commander");
 
+// package.json
+var version = "0.1.2";
+
 // src/commands/setup.ts
 var import_prompts = require("@inquirer/prompts");
-var import_path5 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 
 // src/config/credentials.ts
 var import_keytar = __toESM(require("keytar"));
@@ -60,7 +63,9 @@ var ProjectConfigSchema = import_zod.z.object({
   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")
+  cliTool: import_zod.z.string().default("claude"),
+  cliCommand: import_zod.z.string().default("claude"),
+  cliFlags: import_zod.z.string().default("--permission-mode plan")
 });
 var PROJECT_CONFIG_DEFAULTS = {
   baseBranch: "develop",
@@ -68,7 +73,9 @@ var PROJECT_CONFIG_DEFAULTS = {
   copyFiles: [],
   copyDirs: [],
   terminal: "warp",
-  claudeMode: "--permission-mode plan"
+  cliTool: "claude",
+  cliCommand: "claude",
+  cliFlags: "--permission-mode plan"
 };
 
 // src/config/projectConfig.ts
@@ -79,6 +86,12 @@ async function loadProjectConfig(repoRoot) {
   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"));
+    if ("claudeMode" in raw && !("cliTool" in raw)) {
+      raw.cliTool = "claude";
+      raw.cliCommand = "claude";
+      raw.cliFlags = raw.claudeMode;
+      delete raw.claudeMode;
+    }
     const config = ProjectConfigSchema.parse(raw);
     return { config, source: "json" };
   }
@@ -115,16 +128,52 @@ function parseLegacyConf(content) {
       partial[key] = value;
     }
   }
+  const legacyFlags = partial["CLAUDE_MODE"];
   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"]
+    cliTool: "claude",
+    cliCommand: "claude",
+    cliFlags: legacyFlags
   });
 }
 
+// src/config/cliTools.ts
+var CLI_TOOLS = [
+  {
+    id: "claude",
+    label: "Claude Code",
+    command: "claude",
+    defaultFlags: "--permission-mode plan"
+  },
+  {
+    id: "gemini",
+    label: "Gemini CLI",
+    command: "gemini",
+    defaultFlags: ""
+    // default interactive mode (omit --yolo for safety)
+  },
+  {
+    id: "codex",
+    label: "OpenAI Codex CLI",
+    command: "codex",
+    defaultFlags: "--approval-mode suggest"
+    // suggest-only, mirrors plan mode
+  },
+  {
+    id: "other",
+    label: "Other",
+    command: "",
+    defaultFlags: ""
+  }
+];
+function getCliTool(id) {
+  return CLI_TOOLS.find((t) => t.id === id);
+}
+
 // src/jira/adfParser.ts
 function extractText(node) {
   const parts = [];
@@ -274,18 +323,58 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/terminal/launchers/iterm.ts
+// src/terminal/launchers/warp-windows.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
+var WarpWindowsLauncher = class {
+  name = "warp";
+  platform = ["win32"];
+  async isAvailable() {
+    try {
+      (0, import_child_process2.execSync)("where warp-terminal", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async launch({ workingDirectory, command }) {
+    const scriptPath = import_path3.default.join(workingDirectory, ".start-claude.sh");
+    import_fs3.default.writeFileSync(scriptPath, `#!/bin/bash
+${command}
+`);
+    (0, import_child_process2.spawn)("warp-terminal", ["--working-directory", workingDirectory], {
+      detached: true,
+      stdio: "ignore",
+      shell: true
+    }).unref();
+    await sleep2(2e3);
+    const psScript = [
+      `Add-Type -AssemblyName System.Windows.Forms`,
+      `[System.Windows.Forms.SendKeys]::SendWait("bash .start-claude.sh{ENTER}")`
+    ].join("; ");
+    (0, import_child_process2.spawn)("powershell", ["-NoProfile", "-Command", psScript], {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/terminal/launchers/iterm.ts
+var import_child_process3 = 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" });
+      (0, import_child_process3.execSync)("test -d '/Applications/iTerm.app'", { stdio: "ignore" });
       return true;
     } catch {
       try {
-        (0, import_child_process2.execSync)("test -d '/Applications/iTerm2.app'", { stdio: "ignore" });
+        (0, import_child_process3.execSync)("test -d '/Applications/iTerm2.app'", { stdio: "ignore" });
         return true;
       } catch {
         return false;
@@ -303,12 +392,12 @@ tell application "iTerm"
     write text "cd '${escapedDir}' && ${escapedCmd}"
   end tell
 end tell`;
-    (0, import_child_process2.spawn)("osascript", ["-e", script], { detached: true, stdio: "ignore" }).unref();
+    (0, import_child_process3.spawn)("osascript", ["-e", script], { detached: true, stdio: "ignore" }).unref();
   }
 };
 
 // src/terminal/launchers/terminal-app.ts
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var TerminalAppLauncher = class {
   name = "terminal";
   platform = ["darwin"];
@@ -323,25 +412,25 @@ tell application "Terminal"
   activate
   do script "cd '${escapedDir}' && ${escapedCmd}"
 end tell`;
-    (0, import_child_process3.spawn)("osascript", ["-e", script], { detached: true, stdio: "ignore" }).unref();
+    (0, import_child_process4.spawn)("osascript", ["-e", script], { detached: true, stdio: "ignore" }).unref();
   }
 };
 
 // src/terminal/launchers/gnome-terminal.ts
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 var GnomeTerminalLauncher = class {
   name = "gnome-terminal";
   platform = ["linux"];
   async isAvailable() {
     try {
-      (0, import_child_process4.execSync)("which gnome-terminal", { stdio: "ignore" });
+      (0, import_child_process5.execSync)("which gnome-terminal", { stdio: "ignore" });
       return true;
     } catch {
       return false;
     }
   }
   async launch({ workingDirectory, command }) {
-    (0, import_child_process4.spawn)(
+    (0, import_child_process5.spawn)(
       "gnome-terminal",
       ["--working-directory", workingDirectory, "--", "bash", "-c", command],
       { detached: true, stdio: "ignore" }
@@ -350,20 +439,20 @@ var GnomeTerminalLauncher = class {
 };
 
 // src/terminal/launchers/konsole.ts
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 var KonsoleLauncher = class {
   name = "konsole";
   platform = ["linux"];
   async isAvailable() {
     try {
-      (0, import_child_process5.execSync)("which konsole", { stdio: "ignore" });
+      (0, import_child_process6.execSync)("which konsole", { stdio: "ignore" });
       return true;
     } catch {
       return false;
     }
   }
   async launch({ workingDirectory, command }) {
-    (0, import_child_process5.spawn)("konsole", ["--workdir", workingDirectory, "-e", command], {
+    (0, import_child_process6.spawn)("konsole", ["--workdir", workingDirectory, "-e", command], {
       detached: true,
       stdio: "ignore"
     }).unref();
@@ -371,20 +460,20 @@ var KonsoleLauncher = class {
 };
 
 // src/terminal/launchers/windows-terminal.ts
-var import_child_process6 = require("child_process");
+var import_child_process7 = require("child_process");
 var WindowsTerminalLauncher = class {
   name = "windows-terminal";
   platform = ["win32"];
   async isAvailable() {
     try {
-      (0, import_child_process6.execSync)("where wt", { stdio: "ignore" });
+      (0, import_child_process7.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], {
+    (0, import_child_process7.spawn)("wt", ["-d", workingDirectory, "powershell", "-Command", command], {
       detached: true,
       stdio: "ignore"
     }).unref();
@@ -394,6 +483,7 @@ var WindowsTerminalLauncher = class {
 // src/terminal/registry.ts
 var ALL_LAUNCHERS = [
   new WarpLauncher(),
+  new WarpWindowsLauncher(),
   new ITermLauncher(),
   new TerminalAppLauncher(),
   new GnomeTerminalLauncher(),
@@ -423,15 +513,15 @@ async function getAvailableLaunchers() {
 }
 
 // src/git/gitignore.ts
-var import_fs3 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
+var import_fs4 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
 function ensureGitignoreEntry(repoRoot, entry) {
-  const gitignorePath = import_path3.default.join(repoRoot, ".gitignore");
+  const gitignorePath = import_path4.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");
+  if (import_fs4.default.existsSync(gitignorePath)) {
+    existing = import_fs4.default.readFileSync(gitignorePath, "utf-8");
     const lines = existing.split("\n");
     for (const line of lines) {
       const trimmed = line.trim();
@@ -441,12 +531,12 @@ function ensureGitignoreEntry(repoRoot, entry) {
     }
   }
   const toAppend = existing.endsWith("\n") || existing === "" ? entryNorm + "\n" : "\n" + entryNorm + "\n";
-  import_fs3.default.appendFileSync(gitignorePath, toAppend, "utf-8");
+  import_fs4.default.appendFileSync(gitignorePath, toAppend, "utf-8");
 }
 
 // src/git/worktree.ts
-var import_fs4 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
+var import_fs5 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
 var import_simple_git = __toESM(require("simple-git"));
 var WorktreeExistsError = class extends Error {
   constructor(targetDir) {
@@ -470,14 +560,14 @@ async function resolveRepoRoot(startDir) {
 async function createWorktree(opts) {
   const { repoRoot, targetDir, branchName, baseBranch } = opts;
   const git = (0, import_simple_git.default)(repoRoot);
-  if (import_fs4.default.existsSync(targetDir)) {
+  if (import_fs5.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 });
+  import_fs5.default.mkdirSync(import_path5.default.dirname(targetDir), { recursive: true });
   if (branchExists) {
     await git.raw(["worktree", "add", targetDir, branchName]);
   } else {
@@ -500,34 +590,34 @@ async function createWorktree(opts) {
 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 absoluteGitDir = import_path5.default.isAbsolute(gitDir) ? gitDir : import_path5.default.join(worktreeDir, gitDir);
+  const excludePath = import_path5.default.join(absoluteGitDir, "info", "exclude");
+  import_fs5.default.mkdirSync(import_path5.default.dirname(excludePath), { recursive: true });
+  const existing = import_fs5.default.existsSync(excludePath) ? import_fs5.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");
+    import_fs5.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);
+    const src = import_path5.default.join(repoRoot, file);
+    const dest = import_path5.default.join(targetDir, file);
+    if (import_fs5.default.existsSync(src)) {
+      import_fs5.default.mkdirSync(import_path5.default.dirname(dest), { recursive: true });
+      import_fs5.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()) {
+    const src = import_path5.default.join(repoRoot, dir);
+    const dest = import_path5.default.join(targetDir, dir);
+    if (import_fs5.default.existsSync(src) && import_fs5.default.statSync(src).isDirectory()) {
       copyDirRecursive(src, dest);
       copied.push(dir + "/");
     } else {
@@ -537,14 +627,14 @@ function copyProjectFiles(repoRoot, targetDir, copyFiles, copyDirs) {
   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);
+  import_fs5.default.mkdirSync(dest, { recursive: true });
+  for (const entry of import_fs5.default.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = import_path5.default.join(src, entry.name);
+    const destPath = import_path5.default.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      import_fs4.default.copyFileSync(srcPath, destPath);
+      import_fs5.default.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -657,9 +747,28 @@ async function runSetup() {
     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 cliToolId = await (0, import_prompts.select)({
+    message: "AI CLI tool:",
+    choices: CLI_TOOLS.map((t) => ({ name: t.label, value: t.id })),
+    default: existing.cliTool
+  });
+  const toolDef = getCliTool(cliToolId);
+  let cliCommand;
+  if (cliToolId === "other") {
+    console.log('  Enter the CLI command to run (e.g. "my-ai-tool").');
+    console.log('  It will be invoked as: <command> <flags> "$(cat .ticket.md)"');
+    cliCommand = await (0, import_prompts.input)({
+      message: "CLI command:",
+      default: existing.cliTool === "other" ? existing.cliCommand : "",
+      validate: (v) => v.trim() ? true : "Required"
+    });
+  } else {
+    cliCommand = toolDef.command;
+  }
+  const flagsDefault = toolDef.defaultFlags !== "" ? toolDef.defaultFlags : existing.cliTool === cliToolId ? existing.cliFlags : "";
+  const cliFlags = await (0, import_prompts.input)({
+    message: `${cliToolId === "other" ? "CLI" : toolDef.label} flags:`,
+    default: flagsDefault
   });
   const parseList = (raw) => raw.split(",").map((s) => s.trim()).filter(Boolean);
   const newConfig = {
@@ -668,18 +777,20 @@ async function runSetup() {
     copyFiles: parseList(copyFilesRaw),
     copyDirs: parseList(copyDirsRaw),
     terminal,
-    claudeMode: claudeMode.trim() || "--permission-mode plan"
+    cliTool: cliToolId,
+    cliCommand: cliCommand.trim(),
+    cliFlags: cliFlags.trim()
   };
   saveProjectConfig(repoRoot, newConfig);
-  logger.success(`Config written to ${import_path5.default.join(repoRoot, ".worktree.json")}`);
+  logger.success(`Config written to ${import_path6.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"));
+var import_path7 = __toESM(require("path"));
+var import_fs6 = __toESM(require("fs"));
 
 // src/utils/slugify.ts
 var MAX_DESC_LENGTH = 60;
@@ -733,8 +844,8 @@ async function runTicket(issueKey, opts) {
   });
   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);
+  const worktreesRoot = import_path7.default.isAbsolute(config.worktreesDir) ? config.worktreesDir : import_path7.default.join(repoRoot, config.worktreesDir);
+  const targetDir = import_path7.default.join(worktreesRoot, issueKey);
   logger.step("Preparing worktree...");
   logger.detail("Branch", branchName);
   logger.detail("Base", `origin/${config.baseBranch}`);
@@ -771,13 +882,14 @@ async function runTicket(issueKey, opts) {
     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");
+  const ticketFile = import_path7.default.join(targetDir, ".ticket.md");
+  import_fs6.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)"`;
+  const flags = config.cliFlags.trim();
+  const claudeCommand = flags ? `${config.cliCommand} ${flags} "$(cat .ticket.md)"` : `${config.cliCommand} "$(cat .ticket.md)"`;
   logger.step("Launching terminal...");
   const launcher = getLauncher(config.terminal);
   logger.detail("Terminal", launcher.name);
@@ -793,7 +905,7 @@ async function runTicket(issueKey, opts) {
 
 // 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.name("mic-drop").description("Turn a Jira ticket into an isolated git worktree with Claude Code \u2014 in one command.").version(version);
 program.command("setup").description("Interactive setup wizard for Jira credentials and project configuration").action(async () => {
   await runSetup();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michael_magdy/mic-drop",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "author": "Michael Magdy",
   "description": "Turn a Jira ticket into an isolated git worktree with Claude Code running automatically — in one command.",
   "type": "commonjs",
@@ -19,7 +19,14 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "keywords": ["jira", "git", "worktree", "claude", "cli", "ai"],
+  "keywords": [
+    "jira",
+    "git",
+    "worktree",
+    "claude",
+    "cli",
+    "ai"
+  ],
   "license": "MIT",
   "files": [
     "dist"