@michael_magdy/mic-drop 0.1.1 → 0.1.2

package/dist/index.js

@@ -27,11 +27,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 
 // package.json
-var version = "0.1.1";
+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"));
@@ -323,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;
@@ -352,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"];
@@ -372,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" }
@@ -399,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();
@@ -420,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();
@@ -443,6 +483,7 @@ var WindowsTerminalLauncher = class {
 // src/terminal/registry.ts
 var ALL_LAUNCHERS = [
   new WarpLauncher(),
+  new WarpWindowsLauncher(),
   new ITermLauncher(),
   new TerminalAppLauncher(),
   new GnomeTerminalLauncher(),
@@ -472,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();
@@ -490,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) {
@@ -519,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 {
@@ -549,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 {
@@ -586,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);
     }
   }
 }
@@ -741,15 +782,15 @@ async function runSetup() {
     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;
@@ -803,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}`);
@@ -841,8 +882,8 @@ 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michael_magdy/mic-drop",
-  "version": "0.1.1",
+  "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",