kantban-cli 0.1.51 → 0.1.52

package/dist/{chunk-X2CJ3ZAI.js → chunk-3A4B7CUH.js}

@@ -5,10 +5,155 @@ import {
   crossSpawnOptions,
   defaultPath,
   killProcessTree,
+  normalizeEol,
   npxCommand,
   resolveCommand
 } from "./chunk-5ZU2OOES.js";
 
+// src/lib/worktree.ts
+import { execFile as defaultExecFile, execFileSync } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
+function generateWorktreeName(ticketNumber, columnName) {
+  const slug = columnSlug(columnName);
+  return `kantban-${ticketNumber}-${slug}`;
+}
+function columnSlug(columnName) {
+  return columnName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function renderWorktreePath(ticketNumber, columnName, pathPattern, options) {
+  const slug = columnSlug(columnName);
+  const worktreeName = generateWorktreeName(ticketNumber, columnName);
+  if (pathPattern) {
+    return pathPattern.replace(/\{ticket_number\}/g, String(ticketNumber)).replace(/\{column_slug\}/g, slug).replace(/\{worktree_name\}/g, worktreeName);
+  }
+  return join(options.defaultRoot, options.boardId, slug, String(ticketNumber));
+}
+function defaultWorktreeRoot() {
+  return join(homedir(), ".kantban", "worktrees");
+}
+function isPlausibleRemoteUrl(url) {
+  return url.includes("/") || url.includes("@") || url.includes("://");
+}
+function ensureWorktreeRemote(worktreePath) {
+  try {
+    const remotes = normalizeEol(execFileSync("git", ["-C", worktreePath, "remote"], {
+      stdio: "pipe",
+      encoding: "utf-8"
+    })).trim();
+    if (remotes.split("\n").includes("origin")) {
+      const currentUrl = normalizeEol(execFileSync("git", ["-C", worktreePath, "remote", "get-url", "origin"], {
+        stdio: "pipe",
+        encoding: "utf-8"
+      })).trim();
+      if (isPlausibleRemoteUrl(currentUrl)) return;
+      console.error(`[worktree] Invalid origin URL in ${worktreePath}: "${currentUrl}" \u2014 fixing`);
+      execFileSync("git", ["-C", worktreePath, "remote", "remove", "origin"], {
+        stdio: "pipe"
+      });
+    }
+    const originUrl = normalizeEol(execFileSync("git", ["remote", "get-url", "origin"], {
+      stdio: "pipe",
+      encoding: "utf-8"
+    })).trim();
+    if (originUrl && isPlausibleRemoteUrl(originUrl)) {
+      execFileSync("git", ["-C", worktreePath, "remote", "add", "origin", originUrl], {
+        stdio: "pipe"
+      });
+      console.error(`[worktree] Added missing origin remote to ${worktreePath}: ${originUrl}`);
+    } else {
+      console.error(`[worktree] WARNING: main repo origin URL is also invalid: "${originUrl}"`);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[worktree] Failed to ensure remote for ${worktreePath}: ${msg}`);
+  }
+}
+async function cleanupWorktree(worktreeName, exec = defaultExecFile) {
+  let target = worktreeName;
+  try {
+    const path = await findWorktreeForBranch(exec, worktreeName);
+    if (!path) return true;
+    target = path;
+  } catch {
+    return true;
+  }
+  return new Promise((resolve) => {
+    exec("git", ["worktree", "remove", "--force", target], (err) => {
+      if (err) {
+        console.error(`[worktree] cleanup failed for ${worktreeName} (${target}): ${err.message}`);
+        resolve(false);
+      } else {
+        resolve(true);
+      }
+    });
+  });
+}
+function execPromise(exec, cmd, args) {
+  return new Promise((resolve, reject) => {
+    exec(cmd, args, (err, stdout, stderr) => {
+      if (err) reject(Object.assign(err, { stdout, stderr }));
+      else resolve({ stdout, stderr });
+    });
+  });
+}
+async function findWorktreeForBranch(exec, branch) {
+  try {
+    const { stdout } = await execPromise(exec, "git", ["worktree", "list", "--porcelain"]);
+    const targetRef = `refs/heads/${branch}`;
+    let currentPath = null;
+    for (const line of normalizeEol(stdout).split("\n")) {
+      if (line.startsWith("worktree ")) currentPath = line.slice("worktree ".length);
+      if (line.startsWith("branch ") && line.slice("branch ".length) === targetRef && currentPath) {
+        return currentPath;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function mergeWorktreeBranch(worktreeName, integrationBranch, exec = defaultExecFile) {
+  try {
+    try {
+      await execPromise(exec, "git", ["rev-parse", "--verify", worktreeName]);
+    } catch {
+      return true;
+    }
+    await execPromise(exec, "git", ["branch", integrationBranch, "HEAD"]).catch(() => {
+    });
+    const checkedOutPath = await findWorktreeForBranch(exec, integrationBranch);
+    if (checkedOutPath) {
+      await execPromise(exec, "git", ["-C", checkedOutPath, "merge", "--no-edit", worktreeName]);
+      console.error(`[worktree] merged ${worktreeName} \u2192 ${integrationBranch}`);
+      return true;
+    }
+    const { stdout: baseOut } = await execPromise(exec, "git", ["merge-base", integrationBranch, worktreeName]);
+    const mergeBase = baseOut.trim();
+    const { stdout: integrationSha } = await execPromise(exec, "git", ["rev-parse", integrationBranch]);
+    if (integrationSha.trim() === mergeBase) {
+      const { stdout: worktreeSha } = await execPromise(exec, "git", ["rev-parse", worktreeName]);
+      await execPromise(exec, "git", ["update-ref", `refs/heads/${integrationBranch}`, worktreeSha.trim()]);
+      console.error(`[worktree] fast-forward merged ${worktreeName} \u2192 ${integrationBranch}`);
+      return true;
+    }
+    const tmpWorktree = `merge-tmp-${Date.now()}`;
+    try {
+      await execPromise(exec, "git", ["worktree", "add", tmpWorktree, integrationBranch]);
+      await execPromise(exec, "git", ["-C", tmpWorktree, "merge", "--no-edit", worktreeName]);
+      console.error(`[worktree] merged ${worktreeName} \u2192 ${integrationBranch}`);
+    } finally {
+      await execPromise(exec, "git", ["worktree", "remove", "--force", tmpWorktree]).catch(() => {
+      });
+    }
+    return true;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[worktree] merge failed for ${worktreeName} \u2192 ${integrationBranch}: ${msg}`);
+    return false;
+  }
+}
+
 // src/lib/stuck-detector.ts
 import { z } from "zod";
 
@@ -971,13 +1116,13 @@ function fingerprintsMatch(a, b) {
 
 // src/lib/mcp-config.ts
 import { writeFileSync, unlinkSync, mkdirSync, existsSync, readdirSync, rmdirSync, rmSync } from "fs";
-import { join, dirname } from "path";
+import { join as join2, dirname } from "path";
 import { fileURLToPath } from "url";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 function generateMcpConfig(apiUrl, apiToken, boardId) {
-  const localMcpPath = existsSync(join(__dirname, "..", "..", "mcp", "dist", "index.js")) ? join(__dirname, "..", "..", "mcp", "dist", "index.js") : join(__dirname, "..", "..", "..", "mcp", "dist", "index.js");
+  const localMcpPath = existsSync(join2(__dirname, "..", "..", "mcp", "dist", "index.js")) ? join2(__dirname, "..", "..", "mcp", "dist", "index.js") : join2(__dirname, "..", "..", "..", "mcp", "dist", "index.js");
   const useLocal = existsSync(localMcpPath);
   const kantbanServer = useLocal ? {
     command: "node",
@@ -999,9 +1144,9 @@ function generateMcpConfig(apiUrl, apiToken, boardId) {
       kantban: kantbanServer
     }
   };
-  const dir = join(homedir(), ".kantban", "pipelines", boardId, String(process.pid));
+  const dir = join2(homedir2(), ".kantban", "pipelines", boardId, String(process.pid));
   mkdirSync(dir, { recursive: true, mode: 448 });
-  const filePath = join(dir, "mcp-config.json");
+  const filePath = join2(dir, "mcp-config.json");
   writeFileSync(filePath, JSON.stringify(config, null, 2), { mode: 384 });
   return filePath;
 }
@@ -1018,10 +1163,10 @@ function cleanupMcpConfig(filePath) {
   }
 }
 function generateGateProxyMcpConfig(apiUrl, apiToken, boardId, gateConfigPath, columnId, columnName, projectId, gateCwd, ticketId) {
-  const localMcpPath = existsSync(join(__dirname, "..", "..", "mcp", "dist", "index.js")) ? join(__dirname, "..", "..", "mcp", "dist", "index.js") : join(__dirname, "..", "..", "..", "mcp", "dist", "index.js");
+  const localMcpPath = existsSync(join2(__dirname, "..", "..", "mcp", "dist", "index.js")) ? join2(__dirname, "..", "..", "mcp", "dist", "index.js") : join2(__dirname, "..", "..", "..", "mcp", "dist", "index.js");
   const useLocal = existsSync(localMcpPath);
   const kantbanServer = useLocal ? { command: "node", args: [localMcpPath], env: { KANTBAN_API_TOKEN: apiToken, KANTBAN_API_URL: apiUrl, KANTBAN_HIDDEN_TOOLS: "kantban_move_ticket,kantban_move_tickets,kantban_complete_task,kantban_move_to_board" } } : { command: npxCommand(), args: ["-y", "kantban-mcp@latest"], env: { KANTBAN_API_TOKEN: apiToken, KANTBAN_API_URL: apiUrl, KANTBAN_HIDDEN_TOOLS: "kantban_move_ticket,kantban_move_tickets,kantban_complete_task,kantban_move_to_board" } };
-  const gateProxyPath = existsSync(join(__dirname, "lib", "gate-proxy-server.js")) ? join(__dirname, "lib", "gate-proxy-server.js") : join(__dirname, "gate-proxy-server.js");
+  const gateProxyPath = existsSync(join2(__dirname, "lib", "gate-proxy-server.js")) ? join2(__dirname, "lib", "gate-proxy-server.js") : join2(__dirname, "gate-proxy-server.js");
   const gateProxyEnv = {
     GATE_CONFIG_PATH: gateConfigPath,
     COLUMN_ID: columnId,
@@ -1047,10 +1192,10 @@ function generateGateProxyMcpConfig(apiUrl, apiToken, boardId, gateConfigPath, c
       "kantban-gates": gateProxyServer
     }
   };
-  const dir = join(homedir(), ".kantban", "pipelines", boardId, String(process.pid));
+  const dir = join2(homedir2(), ".kantban", "pipelines", boardId, String(process.pid));
   mkdirSync(dir, { recursive: true, mode: 448 });
   const suffix = ticketId ? `${columnId}-${ticketId}` : columnId;
-  const filePath = join(dir, `mcp-config-${suffix}.json`);
+  const filePath = join2(dir, `mcp-config-${suffix}.json`);
   writeFileSync(filePath, JSON.stringify(config, null, 2), { mode: 384 });
   return filePath;
 }
@@ -1060,7 +1205,7 @@ function cleanupGateProxyConfigs(pipelineDir) {
     for (const f of files) {
       if (f.startsWith("mcp-config-") && f.endsWith(".json")) {
         try {
-          unlinkSync(join(pipelineDir, f));
+          unlinkSync(join2(pipelineDir, f));
         } catch {
         }
       }
@@ -1088,7 +1233,7 @@ function reapOrphanedMcpConfigDirs(boardDir) {
     }
     if (!alive) {
       try {
-        rmSync(join(boardDir, entry), { recursive: true, force: true });
+        rmSync(join2(boardDir, entry), { recursive: true, force: true });
       } catch {
       }
     }
@@ -1096,10 +1241,10 @@ function reapOrphanedMcpConfigDirs(boardDir) {
 }
 
 // src/providers/claude-provider.ts
-import { spawn } from "child_process";
-import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { spawn, execFileSync as execFileSync2 } from "child_process";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2, rmSync as rmSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 
 // src/providers/claude-stream-parser.ts
 var ClaudeStreamParser = class {
@@ -1202,7 +1347,7 @@ var ClaudeProvider = class {
       supportsMaxTurns: true,
       supportsMcpConfigInjection: true,
       supportsMcpConfigOverride: false,
-      supportsWorktreeFlag: true,
+      supportsWorktreeFlag: false,
       supportsSandboxModes: false,
       supportedModels: [
         { id: "claude-haiku-4-5-20251001", displayName: "Haiku 4.5", tier: "fast" },
@@ -1215,13 +1360,56 @@ var ClaudeProvider = class {
   async invoke(request) {
     const args = this.buildArgs(request);
     const startTime = Date.now();
+    if (request.workingDirectory) {
+      const branch = request.branch ?? request.workingDirectory;
+      if (!existsSync2(request.workingDirectory)) {
+        try {
+          execFileSync2("git", ["worktree", "add", "-b", branch, request.workingDirectory, "HEAD"], {
+            stdio: "pipe"
+          });
+        } catch {
+          try {
+            execFileSync2("git", ["worktree", "add", request.workingDirectory, branch], {
+              stdio: "pipe"
+            });
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`worktree_creation_failed: ${msg}`);
+          }
+        }
+      } else {
+        try {
+          execFileSync2("git", ["-C", request.workingDirectory, "rev-parse", "--git-dir"], {
+            stdio: "pipe"
+          });
+        } catch {
+          try {
+            rmSync2(request.workingDirectory, { recursive: true, force: true });
+            execFileSync2("git", ["worktree", "add", "-b", branch, request.workingDirectory, "HEAD"], {
+              stdio: "pipe"
+            });
+          } catch {
+            try {
+              execFileSync2("git", ["worktree", "add", request.workingDirectory, branch], {
+                stdio: "pipe"
+              });
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              throw new Error(`worktree_creation_failed: ${msg}`);
+            }
+          }
+        }
+      }
+      if (existsSync2(request.workingDirectory)) {
+        ensureWorktreeRemote(request.workingDirectory);
+      }
+    }
     const [cmd, prefixArgs] = resolveCommand("claude");
     const resolvedArgs = [...prefixArgs, ...args];
     return new Promise((resolve) => {
       const child = spawn(cmd, resolvedArgs, {
         stdio: ["pipe", "pipe", "pipe"],
-        // Do NOT set cwd to the worktree name — the worktree doesn't exist yet.
-        // Claude Code's --worktree flag creates it internally.
+        ...request.workingDirectory ? { cwd: request.workingDirectory } : {},
         // Only use shell:true as fallback when resolveCommand couldn't resolve
         ...prefixArgs.length > 0 ? {} : crossSpawnOptions()
       });
@@ -1300,10 +1488,6 @@ var ClaudeProvider = class {
     if (request.maxTurns) {
       args.push("--max-turns", String(request.maxTurns));
     }
-    const worktreeName = request.branch ?? request.workingDirectory;
-    if (worktreeName) {
-      args.push("--worktree", worktreeName);
-    }
     if (request.toolRestrictions) {
       const tr = request.toolRestrictions;
       if (tr.tools !== void 0) args.push("--tools", tr.tools);
@@ -1315,15 +1499,21 @@ var ClaudeProvider = class {
   writeMcpConfigJson(mcpConfig) {
     if (!mcpConfig) return "";
     const config = { mcpServers: mcpConfig.servers };
-    const dir = join2(homedir2(), ".kantban", "tmp");
+    const dir = join3(homedir3(), ".kantban", "tmp");
     mkdirSync2(dir, { recursive: true, mode: 448 });
-    const filePath = join2(dir, `mcp-config-${Date.now()}.json`);
+    const filePath = join3(dir, `mcp-config-${Date.now()}.json`);
     writeFileSync2(filePath, JSON.stringify(config, null, 2), { mode: 384 });
     return filePath;
   }
 };
 
 export {
+  generateWorktreeName,
+  renderWorktreePath,
+  defaultWorktreeRoot,
+  ensureWorktreeRemote,
+  cleanupWorktree,
+  mergeWorktreeBranch,
   parseJsonFromLlmOutput,
   composeStuckDetectionPrompt,
   parseStuckDetectionResponse,
@@ -1337,4 +1527,4 @@ export {
   reapOrphanedMcpConfigDirs,
   ClaudeProvider
 };
-//# sourceMappingURL=chunk-X2CJ3ZAI.js.map
+//# sourceMappingURL=chunk-3A4B7CUH.js.map