claude-kanban 0.1.0 → 0.2.1

package/dist/bin/cli.js

@@ -14,9 +14,9 @@ import { fileURLToPath } from "url";
 import { existsSync as existsSync3 } from "fs";
 
 // src/server/services/executor.ts
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 import { join as join4 } from "path";
-import { writeFileSync as writeFileSync4, unlinkSync, mkdirSync as mkdirSync2, existsSync as existsSync2, appendFileSync as appendFileSync2, readFileSync as readFileSync4 } from "fs";
+import { writeFileSync as writeFileSync4, unlinkSync, mkdirSync as mkdirSync2, existsSync as existsSync2, appendFileSync as appendFileSync2, readFileSync as readFileSync4, rmSync } from "fs";
 import { EventEmitter } from "events";
 
 // src/server/services/project.ts
@@ -444,6 +444,7 @@ function getRecentProgress(projectPath, lines = 100) {
 // src/server/services/executor.ts
 var KANBAN_DIR4 = ".claude-kanban";
 var LOGS_DIR = "logs";
+var WORKTREES_DIR = "worktrees";
 var TaskExecutor = class extends EventEmitter {
   projectPath;
   runningTasks = /* @__PURE__ */ new Map();
@@ -493,6 +494,194 @@ var TaskExecutor = class extends EventEmitter {
     if (!existsSync2(logPath)) return null;
     return readFileSync4(logPath, "utf-8");
   }
+  /**
+   * Format tool use for display in logs
+   */
+  formatToolUse(toolName, input) {
+    const truncate = (str, maxLen = 80) => {
+      if (str.length <= maxLen) return str;
+      return str.slice(0, maxLen) + "...";
+    };
+    switch (toolName) {
+      case "Bash":
+        return `[Bash] $ ${truncate(String(input.command || ""))}
+`;
+      case "Read":
+        return `[Read] ${input.file_path}
+`;
+      case "Edit":
+        return `[Edit] ${input.file_path}
+`;
+      case "Write":
+        return `[Write] ${input.file_path}
+`;
+      case "Grep":
+        return `[Grep] "${truncate(String(input.pattern || ""))}" in ${input.path || "."}
+`;
+      case "Glob":
+        return `[Glob] ${input.pattern} in ${input.path || "."}
+`;
+      case "Task":
+        return `[Task] ${input.description || truncate(String(input.prompt || ""))}
+`;
+      case "TodoWrite":
+        const todos = input.todos;
+        if (todos && Array.isArray(todos)) {
+          const summary = todos.map((t) => `  ${t.status === "completed" ? "\u2713" : t.status === "in_progress" ? "\u2192" : "\u25CB"} ${truncate(t.content, 60)}`).join("\n");
+          return `[TodoWrite]
+${summary}
+`;
+        }
+        return `[TodoWrite]
+`;
+      case "WebFetch":
+        return `[WebFetch] ${input.url}
+`;
+      case "WebSearch":
+        return `[WebSearch] "${truncate(String(input.query || ""))}"
+`;
+      default:
+        const meaningfulParams = ["file_path", "path", "command", "query", "url", "pattern", "target"];
+        for (const param of meaningfulParams) {
+          if (input[param]) {
+            return `[${toolName}] ${truncate(String(input[param]))}
+`;
+          }
+        }
+        return `[${toolName}]
+`;
+    }
+  }
+  /**
+   * Check if project is a git repository
+   */
+  isGitRepo() {
+    try {
+      execSync("git rev-parse --is-inside-work-tree", {
+        cwd: this.projectPath,
+        stdio: "pipe"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get worktrees directory path
+   */
+  getWorktreesDir() {
+    return join4(this.projectPath, KANBAN_DIR4, WORKTREES_DIR);
+  }
+  /**
+   * Get worktree path for a task
+   */
+  getWorktreePath(taskId) {
+    return join4(this.getWorktreesDir(), taskId);
+  }
+  /**
+   * Get branch name for a task
+   */
+  getBranchName(taskId) {
+    return `task/${taskId}`;
+  }
+  /**
+   * Create a git worktree for isolated task execution
+   */
+  createWorktree(taskId) {
+    if (!this.isGitRepo()) {
+      console.log("[executor] Not a git repo, skipping worktree creation");
+      return null;
+    }
+    const worktreePath = this.getWorktreePath(taskId);
+    const branchName = this.getBranchName(taskId);
+    try {
+      const worktreesDir = this.getWorktreesDir();
+      if (!existsSync2(worktreesDir)) {
+        mkdirSync2(worktreesDir, { recursive: true });
+      }
+      if (existsSync2(worktreePath)) {
+        this.removeWorktree(taskId);
+      }
+      try {
+        execSync(`git rev-parse --verify ${branchName}`, {
+          cwd: this.projectPath,
+          stdio: "pipe"
+        });
+        execSync(`git branch -D ${branchName}`, {
+          cwd: this.projectPath,
+          stdio: "pipe"
+        });
+      } catch {
+      }
+      execSync(`git worktree add -b ${branchName} "${worktreePath}"`, {
+        cwd: this.projectPath,
+        stdio: "pipe"
+      });
+      console.log(`[executor] Created worktree at ${worktreePath} on branch ${branchName}`);
+      return { worktreePath, branchName };
+    } catch (error) {
+      console.error("[executor] Failed to create worktree:", error);
+      return null;
+    }
+  }
+  /**
+   * Remove a git worktree
+   */
+  removeWorktree(taskId) {
+    const worktreePath = this.getWorktreePath(taskId);
+    const branchName = this.getBranchName(taskId);
+    try {
+      if (existsSync2(worktreePath)) {
+        execSync(`git worktree remove "${worktreePath}" --force`, {
+          cwd: this.projectPath,
+          stdio: "pipe"
+        });
+        console.log(`[executor] Removed worktree at ${worktreePath}`);
+      }
+    } catch (error) {
+      console.error("[executor] Failed to remove worktree via git:", error);
+      try {
+        if (existsSync2(worktreePath)) {
+          rmSync(worktreePath, { recursive: true, force: true });
+          execSync("git worktree prune", {
+            cwd: this.projectPath,
+            stdio: "pipe"
+          });
+        }
+      } catch {
+        console.error("[executor] Failed to force remove worktree directory");
+      }
+    }
+    try {
+      execSync(`git branch -D ${branchName}`, {
+        cwd: this.projectPath,
+        stdio: "pipe"
+      });
+      console.log(`[executor] Deleted branch ${branchName}`);
+    } catch {
+    }
+  }
+  /**
+   * Merge worktree branch back to main branch
+   */
+  mergeWorktreeBranch(taskId) {
+    const branchName = this.getBranchName(taskId);
+    try {
+      const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: this.projectPath,
+        encoding: "utf-8"
+      }).trim();
+      execSync(`git merge ${branchName} --no-edit`, {
+        cwd: this.projectPath,
+        stdio: "pipe"
+      });
+      console.log(`[executor] Merged ${branchName} into ${currentBranch}`);
+      return true;
+    } catch (error) {
+      console.error("[executor] Failed to merge branch:", error);
+      return false;
+    }
+  }
   /**
    * Get number of currently running tasks
    */
@@ -578,10 +767,10 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     }
     updateTask(this.projectPath, taskId, { status: "in_progress" });
     const startedAt = /* @__PURE__ */ new Date();
+    const worktreeInfo = this.createWorktree(taskId);
+    const executionPath = worktreeInfo?.worktreePath || this.projectPath;
     const prompt = this.buildTaskPrompt(task, config);
     const kanbanDir = join4(this.projectPath, KANBAN_DIR4);
-    const prdPath = join4(kanbanDir, "prd.json");
-    const progressPath = join4(kanbanDir, "progress.txt");
     const promptFile = join4(kanbanDir, `prompt-${taskId}.txt`);
     writeFileSync4(promptFile, prompt);
     const args = [];
@@ -596,9 +785,13 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     const commandDisplay = `${config.agent.command} ${args.join(" ")}`;
     const fullCommand = `${config.agent.command} ${args.join(" ")}`;
     console.log("[executor] Command:", fullCommand);
-    console.log("[executor] CWD:", this.projectPath);
+    console.log("[executor] CWD:", executionPath);
+    if (worktreeInfo) {
+      console.log("[executor] Using worktree:", worktreeInfo.worktreePath);
+      console.log("[executor] Branch:", worktreeInfo.branchName);
+    }
     const childProcess = spawn("bash", ["-c", fullCommand], {
-      cwd: this.projectPath,
+      cwd: executionPath,
       env: {
         ...process.env,
         TERM: "xterm-256color",
@@ -614,7 +807,9 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
       taskId,
       process: childProcess,
       startedAt,
-      output: []
+      output: [],
+      worktreePath: worktreeInfo?.worktreePath,
+      branchName: worktreeInfo?.branchName
     };
     this.runningTasks.set(taskId, runningTask);
     this.initLogFile(taskId);
@@ -626,6 +821,12 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     this.emit("task:started", { taskId, timestamp: startedAt.toISOString() });
     logOutput(`[claude-kanban] Starting task: ${task.title}
 `);
+    if (worktreeInfo) {
+      logOutput(`[claude-kanban] Worktree: ${worktreeInfo.worktreePath}
+`);
+      logOutput(`[claude-kanban] Branch: ${worktreeInfo.branchName}
+`);
+    }
     logOutput(`[claude-kanban] Command: ${commandDisplay}
 `);
     logOutput(`[claude-kanban] Process spawned (PID: ${childProcess.pid})
@@ -645,8 +846,7 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
               if (block.type === "text") {
                 text += block.text;
               } else if (block.type === "tool_use") {
-                text += `[Tool: ${block.name}]
-`;
+                text += this.formatToolUse(block.name, block.input);
               }
             }
           } else if (json.type === "content_block_delta" && json.delta?.text) {
@@ -682,6 +882,9 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
         unlinkSync(promptFile);
       } catch {
       }
+      if (worktreeInfo) {
+        this.removeWorktree(taskId);
+      }
       updateTask(this.projectPath, taskId, { status: "failed", passes: false });
       const endedAt = /* @__PURE__ */ new Date();
       addExecutionEntry(this.projectPath, taskId, {
@@ -723,6 +926,15 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     const isComplete = output.includes("<promise>COMPLETE</promise>");
     const task = getTaskById(this.projectPath, taskId);
     if (isComplete || exitCode === 0) {
+      if (runningTask.worktreePath && runningTask.branchName) {
+        const merged = this.mergeWorktreeBranch(taskId);
+        if (merged) {
+          console.log(`[executor] Successfully merged ${runningTask.branchName}`);
+        } else {
+          console.log(`[executor] Failed to merge ${runningTask.branchName}, branch preserved for manual merge`);
+        }
+        this.removeWorktree(taskId);
+      }
       updateTask(this.projectPath, taskId, {
         status: "completed",
         passes: true
@@ -742,6 +954,9 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
       this.emit("task:completed", { taskId, duration });
       this.afkTasksCompleted++;
     } else {
+      if (runningTask.worktreePath) {
+        this.removeWorktree(taskId);
+      }
       updateTask(this.projectPath, taskId, {
         status: "failed",
         passes: false
@@ -790,6 +1005,9 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
       }, 2e3);
     } catch {
     }
+    if (runningTask.worktreePath) {
+      this.removeWorktree(taskId);
+    }
     updateTask(this.projectPath, taskId, {
       status: "ready"
     });
@@ -889,6 +1107,9 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
         runningTask.process.kill("SIGKILL");
       } catch {
       }
+      if (runningTask.worktreePath) {
+        this.removeWorktree(taskId);
+      }
       this.runningTasks.delete(taskId);
     }
     this.stopAFKMode();