claude-kanban 0.3.1 → 0.4.0

package/dist/server/index.js

@@ -134,6 +134,7 @@ function getTaskCounts(projectPath) {
     draft: 0,
     ready: 0,
     in_progress: 0,
+    in_review: 0,
     completed: 0,
     failed: 0
   };
@@ -210,6 +211,7 @@ var WORKTREES_DIR = "worktrees";
 var TaskExecutor = class extends EventEmitter {
   projectPath;
   runningTasks = /* @__PURE__ */ new Map();
+  reviewingTasks = /* @__PURE__ */ new Map();
   afkMode = false;
   afkIteration = 0;
   afkMaxIterations = 0;
@@ -513,7 +515,7 @@ ${worktreeSection}## INSTRUCTIONS
 ${verifySection}${verifySteps.length > 0 ? "4" : "3"}. When complete, update the task in ${prdPath}:
    - Find the task with id "${task.id}"
    - Set "passes": true
-   - Set "status": "completed"
+   (Note: Do NOT change the status - the system will move it to review)
 
 ${verifySteps.length > 0 ? "5" : "4"}. Document your work in ${progressPath}:
    - What you implemented and files changed
@@ -692,7 +694,7 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     }, timeoutMs);
   }
   /**
-   * Handle task completion
+   * Handle task completion - moves to in_review, keeps worktree alive
    */
   handleTaskComplete(taskId, exitCode, startedAt) {
     const runningTask = this.runningTasks.get(taskId);
@@ -704,31 +706,25 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     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);
+        this.reviewingTasks.set(taskId, {
+          worktreePath: runningTask.worktreePath,
+          branchName: runningTask.branchName,
+          startedAt,
+          endedAt
+        });
+        console.log(`[executor] Task ${taskId} ready for review at ${runningTask.worktreePath}`);
       }
       updateTask(this.projectPath, taskId, {
-        status: "completed",
+        status: "in_review",
         passes: true
       });
-      addExecutionEntry(this.projectPath, taskId, {
-        startedAt: startedAt.toISOString(),
-        endedAt: endedAt.toISOString(),
-        status: "completed",
-        duration
-      });
       logTaskExecution(this.projectPath, {
         taskId,
         taskTitle: task?.title || "Unknown",
-        status: "completed",
+        status: "in_review",
         duration
       });
-      this.emit("task:completed", { taskId, duration });
+      this.emit("task:completed", { taskId, duration, status: "in_review" });
       this.afkTasksCompleted++;
     } else {
       if (runningTask.worktreePath) {
@@ -760,6 +756,151 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
       this.continueAFKMode();
     }
   }
+  /**
+   * Get info about a task in review
+   */
+  getReviewingTask(taskId) {
+    return this.reviewingTasks.get(taskId);
+  }
+  /**
+   * Merge a reviewed task into the base branch
+   */
+  mergeTask(taskId) {
+    const reviewInfo = this.reviewingTasks.get(taskId);
+    if (!reviewInfo) {
+      return { success: false, error: "Task not in review or no worktree found" };
+    }
+    const merged = this.mergeWorktreeBranch(taskId);
+    if (!merged) {
+      return { success: false, error: "Merge failed - may have conflicts" };
+    }
+    this.removeWorktree(taskId);
+    this.reviewingTasks.delete(taskId);
+    updateTask(this.projectPath, taskId, {
+      status: "completed"
+    });
+    addExecutionEntry(this.projectPath, taskId, {
+      startedAt: reviewInfo.startedAt.toISOString(),
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "completed",
+      duration: (/* @__PURE__ */ new Date()).getTime() - reviewInfo.startedAt.getTime()
+    });
+    console.log(`[executor] Task ${taskId} merged successfully`);
+    return { success: true };
+  }
+  /**
+   * Create a PR for a reviewed task
+   */
+  createPR(taskId) {
+    const reviewInfo = this.reviewingTasks.get(taskId);
+    const task = getTaskById(this.projectPath, taskId);
+    if (!reviewInfo) {
+      return { success: false, error: "Task not in review or no worktree found" };
+    }
+    try {
+      execSync(`git push -u origin ${reviewInfo.branchName}`, {
+        cwd: this.projectPath,
+        stdio: "pipe"
+      });
+      const prTitle = task?.title || `Task ${taskId}`;
+      const prBody = task?.description || "";
+      const result = execSync(
+        `gh pr create --title "${prTitle.replace(/"/g, '\\"')}" --body "${prBody.replace(/"/g, '\\"')}" --head ${reviewInfo.branchName}`,
+        {
+          cwd: this.projectPath,
+          encoding: "utf-8"
+        }
+      );
+      const prUrl = result.trim();
+      try {
+        execSync(`git worktree remove "${reviewInfo.worktreePath}" --force`, {
+          cwd: this.projectPath,
+          stdio: "pipe"
+        });
+      } catch {
+      }
+      this.reviewingTasks.delete(taskId);
+      updateTask(this.projectPath, taskId, {
+        status: "completed"
+      });
+      addExecutionEntry(this.projectPath, taskId, {
+        startedAt: reviewInfo.startedAt.toISOString(),
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "completed",
+        duration: (/* @__PURE__ */ new Date()).getTime() - reviewInfo.startedAt.getTime()
+      });
+      console.log(`[executor] PR created for task ${taskId}: ${prUrl}`);
+      return { success: true, prUrl };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[executor] Failed to create PR:`, errorMsg);
+      return { success: false, error: errorMsg };
+    }
+  }
+  /**
+   * Discard a reviewed task - delete worktree and return to ready
+   */
+  discardTask(taskId) {
+    const reviewInfo = this.reviewingTasks.get(taskId);
+    if (!reviewInfo) {
+      return { success: false, error: "Task not in review or no worktree found" };
+    }
+    this.removeWorktree(taskId);
+    this.reviewingTasks.delete(taskId);
+    updateTask(this.projectPath, taskId, {
+      status: "ready",
+      passes: false
+    });
+    addExecutionEntry(this.projectPath, taskId, {
+      startedAt: reviewInfo.startedAt.toISOString(),
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "discarded",
+      duration: (/* @__PURE__ */ new Date()).getTime() - reviewInfo.startedAt.getTime()
+    });
+    console.log(`[executor] Task ${taskId} discarded, returned to ready`);
+    return { success: true };
+  }
+  /**
+   * Get diff for a task in review
+   */
+  getTaskDiff(taskId) {
+    const reviewInfo = this.reviewingTasks.get(taskId);
+    if (!reviewInfo) {
+      return { success: false, error: "Task not in review or no worktree found" };
+    }
+    try {
+      const diff = execSync(`git diff main...${reviewInfo.branchName}`, {
+        cwd: this.projectPath,
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB buffer for large diffs
+      });
+      return { success: true, diff };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return { success: false, error: errorMsg };
+    }
+  }
+  /**
+   * Get list of changed files for a task in review
+   */
+  getTaskChangedFiles(taskId) {
+    const reviewInfo = this.reviewingTasks.get(taskId);
+    if (!reviewInfo) {
+      return { success: false, error: "Task not in review or no worktree found" };
+    }
+    try {
+      const result = execSync(`git diff --name-only main...${reviewInfo.branchName}`, {
+        cwd: this.projectPath,
+        encoding: "utf-8"
+      });
+      const files = result.trim().split("\n").filter((f) => f);
+      return { success: true, files };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return { success: false, error: errorMsg };
+    }
+  }
   /**
    * Cancel a running task
    */
@@ -1426,6 +1567,90 @@ async function createServer(projectPath, port) {
       res.status(500).json({ error: String(error) });
     }
   });
+  app.post("/api/tasks/:id/merge", (req, res) => {
+    try {
+      const result = executor.mergeTask(req.params.id);
+      if (!result.success) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      const task = getTaskById(projectPath, req.params.id);
+      if (task) {
+        io.emit("task:updated", task);
+      }
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  app.post("/api/tasks/:id/create-pr", (req, res) => {
+    try {
+      const result = executor.createPR(req.params.id);
+      if (!result.success) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      const task = getTaskById(projectPath, req.params.id);
+      if (task) {
+        io.emit("task:updated", task);
+      }
+      res.json({ success: true, prUrl: result.prUrl });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  app.post("/api/tasks/:id/discard", (req, res) => {
+    try {
+      const result = executor.discardTask(req.params.id);
+      if (!result.success) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      const task = getTaskById(projectPath, req.params.id);
+      if (task) {
+        io.emit("task:updated", task);
+      }
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  app.get("/api/tasks/:id/diff", (req, res) => {
+    try {
+      const result = executor.getTaskDiff(req.params.id);
+      if (!result.success) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      res.json({ diff: result.diff });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  app.get("/api/tasks/:id/changed-files", (req, res) => {
+    try {
+      const result = executor.getTaskChangedFiles(req.params.id);
+      if (!result.success) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      res.json({ files: result.files });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  app.get("/api/tasks/:id/review-info", (req, res) => {
+    try {
+      const info = executor.getReviewingTask(req.params.id);
+      if (!info) {
+        res.status(404).json({ error: "Task not in review" });
+        return;
+      }
+      res.json(info);
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
   app.get("/api/tasks/:id/logs", (req, res) => {
     try {
       const logs = executor.getTaskLog(req.params.id);
@@ -1735,6 +1960,7 @@ function getClientHTML() {
     .status-dot-draft { background: #a3a3a3; }
     .status-dot-ready { background: #3b82f6; }
     .status-dot-in_progress { background: #f97316; }
+    .status-dot-in_review { background: #8b5cf6; }
     .status-dot-completed { background: #22c55e; }
     .status-dot-failed { background: #ef4444; }
 
@@ -1944,6 +2170,7 @@ function getClientHTML() {
     .status-badge-draft { background: #f5f5f5; color: #737373; }
     .status-badge-ready { background: #eff6ff; color: #3b82f6; }
     .status-badge-in_progress { background: #fff7ed; color: #f97316; }
+    .status-badge-in_review { background: #f5f3ff; color: #8b5cf6; }
     .status-badge-completed { background: #f0fdf4; color: #22c55e; }
     .status-badge-failed { background: #fef2f2; color: #ef4444; }
 
@@ -2269,11 +2496,16 @@ socket.on('task:output', ({ taskId, line }) => {
   }
 });
 
-socket.on('task:completed', ({ taskId }) => {
+socket.on('task:completed', ({ taskId, status }) => {
   state.running = state.running.filter(id => id !== taskId);
   const task = state.tasks.find(t => t.id === taskId);
-  if (task) { task.status = 'completed'; task.passes = true; }
-  showToast('Task completed: ' + (task?.title || taskId), 'success');
+  if (task) {
+    // Use status from server (could be 'in_review' or 'completed')
+    task.status = status || 'in_review';
+    task.passes = true;
+  }
+  const statusMsg = (status === 'in_review') ? 'ready for review' : 'completed';
+  showToast('Task ' + statusMsg + ': ' + (task?.title || taskId), 'success');
   render();
 });
 
@@ -2347,6 +2579,53 @@ async function retryTask(id) {
   });
 }
 
+async function mergeTask(id) {
+  const res = await fetch('/api/tasks/' + id + '/merge', { method: 'POST' });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(data.error || 'Merge failed');
+  }
+  return data;
+}
+
+async function createPR(id) {
+  const res = await fetch('/api/tasks/' + id + '/create-pr', { method: 'POST' });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(data.error || 'PR creation failed');
+  }
+  return data;
+}
+
+async function discardTask(id) {
+  const res = await fetch('/api/tasks/' + id + '/discard', { method: 'POST' });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(data.error || 'Discard failed');
+  }
+  return data;
+}
+
+async function getReviewInfo(id) {
+  const res = await fetch('/api/tasks/' + id + '/review-info');
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(data.error || 'Failed to get review info');
+  }
+  return data;
+}
+
+async function openInVSCode(id) {
+  try {
+    const info = await getReviewInfo(id);
+    // Open VS Code at the worktree path
+    window.open('vscode://file/' + encodeURIComponent(info.worktreePath), '_blank');
+    showToast('Opening in VS Code...', 'info');
+  } catch (e) {
+    showToast('Failed to open in VS Code: ' + e.message, 'error');
+  }
+}
+
 async function generateTask(prompt) {
   state.aiGenerating = true;
   render();
@@ -2550,6 +2829,7 @@ function renderColumn(status, title, tasks) {
     draft: 'To Do',
     ready: 'Ready',
     in_progress: 'In Progress',
+    in_review: 'In Review',
     completed: 'Done',
     failed: 'Failed'
   };
@@ -2915,7 +3195,7 @@ function renderSidePanel() {
       </div>
 
       <!-- Action Buttons -->
-      <div class="px-5 py-4 border-b border-canvas-200 flex gap-2 flex-shrink-0">
+      <div class="px-5 py-4 border-b border-canvas-200 flex flex-wrap gap-2 flex-shrink-0">
         \${task.status === 'draft' ? \`
           <button onclick="updateTask('\${task.id}', { status: 'ready' })" class="btn btn-primary px-4 py-2 text-sm">
             \u2192 Move to Ready
@@ -2931,6 +3211,20 @@ function renderSidePanel() {
             \u23F9 Stop Attempt
           </button>
         \` : ''}
+        \${task.status === 'in_review' ? \`
+          <button onclick="handleMerge('\${task.id}')" class="btn btn-primary px-4 py-2 text-sm">
+            \u2713 Merge
+          </button>
+          <button onclick="handleCreatePR('\${task.id}')" class="btn btn-ghost px-4 py-2 text-sm">
+            \u21E1 Create PR
+          </button>
+          <button onclick="openInVSCode('\${task.id}')" class="btn btn-ghost px-4 py-2 text-sm">
+            \u{1F4C2} Open in VS Code
+          </button>
+          <button onclick="handleDiscard('\${task.id}')" class="btn btn-danger px-4 py-2 text-sm">
+            \u2715 Discard
+          </button>
+        \` : ''}
         \${task.status === 'failed' ? \`
           <button onclick="retryTask('\${task.id}')" class="btn btn-primary px-4 py-2 text-sm">
             \u21BB Retry
@@ -3131,6 +3425,41 @@ function handleStartAFK() {
   render();
 }
 
+async function handleMerge(taskId) {
+  if (!confirm('Merge this task into the main branch?')) return;
+  try {
+    await mergeTask(taskId);
+    showToast('Task merged successfully!', 'success');
+    closeSidePanel();
+  } catch (e) {
+    showToast('Merge failed: ' + e.message, 'error');
+  }
+}
+
+async function handleCreatePR(taskId) {
+  try {
+    const result = await createPR(taskId);
+    showToast('PR created successfully!', 'success');
+    if (result.prUrl) {
+      window.open(result.prUrl, '_blank');
+    }
+    closeSidePanel();
+  } catch (e) {
+    showToast('PR creation failed: ' + e.message, 'error');
+  }
+}
+
+async function handleDiscard(taskId) {
+  if (!confirm('Discard this work? The task will return to Ready status.')) return;
+  try {
+    await discardTask(taskId);
+    showToast('Task discarded, returned to Ready', 'warning');
+    closeSidePanel();
+  } catch (e) {
+    showToast('Discard failed: ' + e.message, 'error');
+  }
+}
+
 // Filter tasks based on search query
 function filterTasks(tasks) {
   if (!state.searchQuery) return tasks;
@@ -3192,6 +3521,7 @@ function render() {
             \${renderColumn('draft', 'To Do', filterTasks(state.tasks))}
             \${renderColumn('ready', 'Ready', filterTasks(state.tasks))}
             \${renderColumn('in_progress', 'In Progress', filterTasks(state.tasks))}
+            \${renderColumn('in_review', 'In Review', filterTasks(state.tasks))}
             \${renderColumn('completed', 'Done', filterTasks(state.tasks))}
             \${renderColumn('failed', 'Failed', filterTasks(state.tasks))}
           </div>
@@ -3256,6 +3586,14 @@ window.closeSidePanel = closeSidePanel;
 window.showTaskMenu = showTaskMenu;
 window.filterTasks = filterTasks;
 window.scrollSidePanelLog = scrollSidePanelLog;
+window.mergeTask = mergeTask;
+window.createPR = createPR;
+window.discardTask = discardTask;
+window.handleMerge = handleMerge;
+window.handleCreatePR = handleCreatePR;
+window.handleDiscard = handleDiscard;
+window.openInVSCode = openInVSCode;
+window.getReviewInfo = getReviewInfo;
 
 // Keyboard shortcuts
 document.addEventListener('keydown', (e) => {