kantban-cli 0.1.49 → 0.1.52

package/dist/{chunk-QHJZIGEE.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";
 
@@ -148,6 +293,53 @@ function classifyTrajectory(snapshots) {
   return { status: "spinning", evidence: "no improvement detected", confidence: 1 };
 }
 
+// src/lib/git-state.ts
+import { execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+var realExecFile = promisify(execFileCb);
+var _execFile = realExecFile;
+async function detectBranchMerged(opts) {
+  const { worktreePath, iterationStartedAt } = opts;
+  const fetchTimeoutMs = opts.fetchTimeoutMs ?? 15e3;
+  const targetBranch = opts.targetBranch ?? "main";
+  try {
+    const { stdout: headOut } = await _execFile("git", ["-C", worktreePath, "rev-parse", "HEAD"]);
+    const headSha = headOut.trim();
+    if (!headSha) return { merged: false };
+    try {
+      await _execFile("git", ["-C", worktreePath, "fetch", "origin", targetBranch], { timeout: fetchTimeoutMs });
+    } catch {
+      return { merged: false };
+    }
+    try {
+      await _execFile("git", ["-C", worktreePath, "merge-base", "--is-ancestor", headSha, `origin/${targetBranch}`]);
+    } catch {
+      return { merged: false };
+    }
+    const { stdout: logOut } = await _execFile("git", [
+      "-C",
+      worktreePath,
+      "log",
+      `origin/${targetBranch}`,
+      "--ancestry-path",
+      `${headSha}..origin/${targetBranch}`,
+      "--reverse",
+      "--format=%H %cI",
+      "-1"
+    ]);
+    const line = logOut.trim().split("\n")[0] ?? "";
+    const spaceIdx = line.indexOf(" ");
+    if (spaceIdx < 0) return { merged: false };
+    const mergeCommitSha = line.slice(0, spaceIdx);
+    const mergeCommitTime = new Date(line.slice(spaceIdx + 1));
+    if (Number.isNaN(mergeCommitTime.getTime())) return { merged: false };
+    if (mergeCommitTime.getTime() < iterationStartedAt.getTime()) return { merged: false };
+    return { merged: true, mergeCommitSha, mergeCommitTime };
+  } catch {
+    return { merged: false };
+  }
+}
+
 // src/lib/prompt-composer.ts
 var PROMPT_BUDGETS = {
   system_preamble: 800,
@@ -539,52 +731,6 @@ ${ticketContext.ticket.description}`);
   return parts.join("\n");
 }
 
-// src/lib/git-state.ts
-import { execFile as execFileCb } from "child_process";
-import { promisify } from "util";
-var realExecFile = promisify(execFileCb);
-var _execFile = realExecFile;
-async function detectBranchMerged(opts) {
-  const { worktreePath, iterationStartedAt } = opts;
-  const fetchTimeoutMs = opts.fetchTimeoutMs ?? 15e3;
-  try {
-    const { stdout: headOut } = await _execFile("git", ["-C", worktreePath, "rev-parse", "HEAD"]);
-    const headSha = headOut.trim();
-    if (!headSha) return { merged: false };
-    try {
-      await _execFile("git", ["-C", worktreePath, "fetch", "origin", "main"], { timeout: fetchTimeoutMs });
-    } catch {
-      return { merged: false };
-    }
-    try {
-      await _execFile("git", ["-C", worktreePath, "merge-base", "--is-ancestor", headSha, "origin/main"]);
-    } catch {
-      return { merged: false };
-    }
-    const { stdout: logOut } = await _execFile("git", [
-      "-C",
-      worktreePath,
-      "log",
-      "origin/main",
-      "--ancestry-path",
-      `${headSha}..origin/main`,
-      "--reverse",
-      "--format=%H %cI",
-      "-1"
-    ]);
-    const line = logOut.trim().split("\n")[0] ?? "";
-    const spaceIdx = line.indexOf(" ");
-    if (spaceIdx < 0) return { merged: false };
-    const mergeCommitSha = line.slice(0, spaceIdx);
-    const mergeCommitTime = new Date(line.slice(spaceIdx + 1));
-    if (Number.isNaN(mergeCommitTime.getTime())) return { merged: false };
-    if (mergeCommitTime.getTime() < iterationStartedAt.getTime()) return { merged: false };
-    return { merged: true, mergeCommitSha, mergeCommitTime };
-  } catch {
-    return { merged: false };
-  }
-}
-
 // src/lib/ralph-loop.ts
 var API_TIMEOUT_MS = 3e4;
 function withTimeout(promise, ms, label) {
@@ -970,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",
@@ -998,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;
 }
@@ -1017,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,
@@ -1031,7 +1177,8 @@ function generateGateProxyMcpConfig(apiUrl, apiToken, boardId, gateConfigPath, c
     // Ensure gate commands can find npm/node even if the agent CLI spawns
     // MCP servers with a replacement env instead of merging with process.env.
     // Without this, gate-runner's `sh -c "npm run ..."` fails with ENOENT.
-    PATH: process.env.PATH ?? defaultPath()
+    PATH: process.env.PATH ?? defaultPath(),
+    SHELL: process.env.SHELL ?? "/bin/bash"
   };
   if (gateCwd) gateProxyEnv["GATE_CWD"] = gateCwd;
   const gateProxyServer = {
@@ -1045,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;
 }
@@ -1058,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 {
         }
       }
@@ -1086,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 {
       }
     }
@@ -1094,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 {
@@ -1200,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" },
@@ -1213,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()
       });
@@ -1298,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);
@@ -1313,19 +1499,26 @@ 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,
   classifyTrajectory,
+  detectBranchMerged,
   RalphLoop,
   generateMcpConfig,
   cleanupMcpConfig,
@@ -1334,4 +1527,4 @@ export {
   reapOrphanedMcpConfigDirs,
   ClaudeProvider
 };
-//# sourceMappingURL=chunk-QHJZIGEE.js.map
+//# sourceMappingURL=chunk-3A4B7CUH.js.map