claude-kanban 0.3.0 → 0.4.0

package/dist/bin/cli.js

@@ -4,6 +4,10 @@
 import { Command } from "commander";
 import chalk from "chalk";
 import open from "open";
+import { existsSync as existsSync4 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { createInterface } from "readline";
+import { join as join6 } from "path";
 
 // src/server/index.ts
 import express from "express";
@@ -16,7 +20,7 @@ import { existsSync as existsSync3 } from "fs";
 // src/server/services/executor.ts
 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, rmSync, symlinkSync } 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
@@ -454,6 +458,7 @@ function getTaskCounts(projectPath) {
     draft: 0,
     ready: 0,
     in_progress: 0,
+    in_review: 0,
     completed: 0,
     failed: 0
   };
@@ -530,6 +535,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;
@@ -699,7 +705,6 @@ ${summary}
         cwd: this.projectPath,
         stdio: "pipe"
       });
-      this.symlinkDependencies(worktreePath);
       console.log(`[executor] Created worktree at ${worktreePath} on branch ${branchName}`);
       return { worktreePath, branchName };
     } catch (error) {
@@ -707,38 +712,6 @@ ${summary}
       return null;
     }
   }
-  /**
-   * Symlink dependency directories from main project to worktree
-   */
-  symlinkDependencies(worktreePath) {
-    const depDirs = [
-      "node_modules",
-      ".pnpm",
-      // pnpm store
-      ".yarn",
-      // yarn cache
-      "vendor",
-      // PHP/Ruby deps
-      "__pycache__",
-      // Python cache
-      ".venv",
-      // Python virtual env
-      "venv"
-      // Python virtual env
-    ];
-    for (const dir of depDirs) {
-      const sourcePath = join4(this.projectPath, dir);
-      const targetPath = join4(worktreePath, dir);
-      if (existsSync2(sourcePath) && !existsSync2(targetPath)) {
-        try {
-          symlinkSync(sourcePath, targetPath, "junction");
-          console.log(`[executor] Symlinked ${dir} to worktree`);
-        } catch (error) {
-          console.log(`[executor] Could not symlink ${dir}:`, error);
-        }
-      }
-    }
-  }
   /**
    * Remove a git worktree
    */
@@ -824,7 +797,7 @@ ${summary}
   /**
    * Build the prompt for a specific task
    */
-  buildTaskPrompt(task, config) {
+  buildTaskPrompt(task, config, worktreeInfo) {
     const kanbanDir = join4(this.projectPath, KANBAN_DIR4);
     const prdPath = join4(kanbanDir, "prd.json");
     const progressPath = join4(kanbanDir, "progress.txt");
@@ -838,9 +811,15 @@ ${task.steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}` : "";
     if (config.project.testCommand) {
       verifySteps.push(`Run tests: ${config.project.testCommand}`);
     }
-    const verifySection = verifySteps.length > 0 ? `2. Verify your work:
+    const verifySection = verifySteps.length > 0 ? `3. Verify your work:
 ${verifySteps.map((s) => `   - ${s}`).join("\n")}
 
+` : "";
+    const worktreeSection = worktreeInfo ? `## ENVIRONMENT
+You are running in an isolated git worktree on branch "${worktreeInfo.branchName}".
+This is a fresh checkout - dependencies (node_modules, vendor, etc.) are NOT installed.
+Before running any build/test commands, install dependencies first (e.g., npm install, composer install, pip install).
+
 ` : "";
     return `You are an AI coding agent. Complete the following task:
 
@@ -852,22 +831,24 @@ Priority: ${task.priority}
 ${task.description}
 ${stepsText}
 
-## INSTRUCTIONS
-1. Implement this task as described above.
+${worktreeSection}## INSTRUCTIONS
+1. If dependencies are not installed, install them first.
+
+2. Implement this task as described above.
 
-${verifySection}${verifySteps.length > 0 ? "3" : "2"}. When complete, update the task in ${prdPath}:
+${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 ? "4" : "3"}. Document your work in ${progressPath}:
+${verifySteps.length > 0 ? "5" : "4"}. Document your work in ${progressPath}:
    - What you implemented and files changed
    - Key decisions made and why
    - Gotchas, edge cases, or tricky parts discovered
    - Useful patterns or approaches that worked well
    - Anything a future agent should know about this area of the codebase
 
-${verifySteps.length > 0 ? "5" : "4"}. Make a git commit with a descriptive message.
+${verifySteps.length > 0 ? "6" : "5"}. Make a git commit with a descriptive message.
 
 Focus only on this task. When successfully complete, output: <promise>COMPLETE</promise>`;
   }
@@ -891,7 +872,7 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     const startedAt = /* @__PURE__ */ new Date();
     const worktreeInfo = this.createWorktree(taskId);
     const executionPath = worktreeInfo?.worktreePath || this.projectPath;
-    const prompt = this.buildTaskPrompt(task, config);
+    const prompt = this.buildTaskPrompt(task, config, worktreeInfo);
     const kanbanDir = join4(this.projectPath, KANBAN_DIR4);
     const promptFile = join4(kanbanDir, `prompt-${taskId}.txt`);
     writeFileSync4(promptFile, prompt);
@@ -1037,7 +1018,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);
@@ -1049,31 +1030,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) {
@@ -1105,6 +1080,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
    */
@@ -1771,6 +1891,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);
@@ -2080,6 +2284,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; }
 
@@ -2289,6 +2494,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; }
 
@@ -2614,11 +2820,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();
 });
 
@@ -2692,6 +2903,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();
@@ -2895,6 +3153,7 @@ function renderColumn(status, title, tasks) {
     draft: 'To Do',
     ready: 'Ready',
     in_progress: 'In Progress',
+    in_review: 'In Review',
     completed: 'Done',
     failed: 'Failed'
   };
@@ -3260,7 +3519,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
@@ -3276,6 +3535,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
@@ -3476,6 +3749,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;
@@ -3537,6 +3845,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>
@@ -3601,6 +3910,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) => {
@@ -3675,6 +3992,49 @@ async function findAvailablePort(startPort, maxAttempts = 10) {
 }
 
 // src/bin/cli.ts
+function isGitRepo(dir) {
+  return existsSync4(join6(dir, ".git"));
+}
+function hasGitRemote(dir) {
+  try {
+    const result = execSync2("git remote -v", { cwd: dir, stdio: "pipe" }).toString();
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function detectRemoteType(dir) {
+  try {
+    const result = execSync2("git remote get-url origin", { cwd: dir, stdio: "pipe" }).toString().toLowerCase();
+    if (result.includes("github.com")) return "github";
+    if (result.includes("gitlab.com") || result.includes("gitlab")) return "gitlab";
+    if (result.includes("bitbucket.org") || result.includes("bitbucket")) return "bitbucket";
+    if (result.trim()) return "other";
+    return null;
+  } catch {
+    return null;
+  }
+}
+function initializeGit(dir) {
+  execSync2("git init", { cwd: dir, stdio: "pipe" });
+  try {
+    execSync2("git add -A", { cwd: dir, stdio: "pipe" });
+    execSync2('git commit -m "Initial commit"', { cwd: dir, stdio: "pipe" });
+  } catch {
+  }
+}
+async function promptYesNo(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith("y"));
+    });
+  });
+}
 var VERSION = "0.1.0";
 var banner = `
 ${chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
@@ -3687,6 +4047,32 @@ async function main() {
   program.name("claude-kanban").description("Visual Kanban board for AI-powered development with Claude").version(VERSION).option("-p, --port <number>", "Port to run server on", "4242").option("-n, --no-open", "Do not auto-open browser").option("--init", "Re-initialize project files").option("--reset", "Reset all tasks (keeps config)").action(async (options) => {
     console.log(banner);
     const cwd = process.cwd();
+    if (!isGitRepo(cwd)) {
+      console.log(chalk.yellow("\n\u26A0 This directory is not a git repository."));
+      console.log(chalk.gray("Git is required for task isolation and parallel execution.\n"));
+      const shouldInit = await promptYesNo(chalk.white("Would you like to initialize git now? (y/n): "));
+      if (shouldInit) {
+        try {
+          console.log(chalk.gray("Initializing git repository..."));
+          initializeGit(cwd);
+          console.log(chalk.green("\u2713 Git repository initialized"));
+        } catch (error) {
+          console.error(chalk.red("Failed to initialize git:"), error);
+          process.exit(1);
+        }
+      } else {
+        console.log(chalk.red("\nGit is required to run Claude Kanban."));
+        console.log(chalk.gray('Please run "git init" manually and try again.'));
+        process.exit(1);
+      }
+    } else {
+      const remoteType = detectRemoteType(cwd);
+      if (remoteType) {
+        console.log(chalk.gray(`Git remote detected: ${remoteType}`));
+      } else if (!hasGitRemote(cwd)) {
+        console.log(chalk.gray("Git repository (local only, no remote)"));
+      }
+    }
     const initialized = await isProjectInitialized(cwd);
     if (!initialized || options.init) {
       console.log(chalk.yellow("Initializing project..."));