create-claude-kanban 2.0.4 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-kanban",
-  "version": "2.0.4",
+  "version": "3.1.0",
   "description": "Scaffold a multi-agent kanban system for Claude Code projects",
   "type": "module",
   "bin": {

package/templates/kanban.cjs

@@ -151,6 +151,60 @@ function getThreadTs(taskId) {
 let chatSessionId = null;
 let chatSessionModel = null;
 
+// ── Agent Activity Tracker (v3: zombie detection) ──
+var agentTracker = {}; // taskId -> { pid, startedAt, lastActivity, agent, subject }
+var STALE_THRESHOLD = 30 * 60 * 1000; // 30 min
+
+function trackAgent(taskId, pid, agent, subject) {
+  agentTracker[String(taskId)] = { pid: pid, startedAt: Date.now(), lastActivity: Date.now(), agent: agent || "", subject: subject || "" };
+}
+function touchAgent(taskId) {
+  if (agentTracker[String(taskId)]) agentTracker[String(taskId)].lastActivity = Date.now();
+}
+function untrackAgent(taskId) {
+  delete agentTracker[String(taskId)];
+}
+function isProcessAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (e) { return false; }
+}
+function checkZombies() {
+  var now = Date.now();
+  var zombies = [];
+  Object.keys(agentTracker).forEach(function (tid) {
+    var info = agentTracker[tid];
+    var alive = isProcessAlive(info.pid);
+    var stale = (now - info.lastActivity) > STALE_THRESHOLD;
+    if (!alive || stale) {
+      zombies.push({ taskId: tid, reason: !alive ? "process_dead" : "stale", agent: info.agent, subject: info.subject, lastActivity: info.lastActivity, startedAt: info.startedAt });
+      if (!alive) {
+        untrackAgent(tid);
+        // Auto-mark stale in task file
+        try {
+          var t = readTask(tid);
+          if (t && t.status === "in_progress") {
+            updateTask(tid, { _stale: true, _staleReason: "process_dead", _staleAt: new Date().toISOString() });
+            logActivity({ type: "updated", taskId: tid, subject: info.subject, detail: "Zombie detected: agent process dead" });
+            broadcastRaw({ type: "zombie", taskId: tid, reason: "process_dead" });
+          }
+        } catch (e) {}
+      } else if (stale) {
+        try {
+          var t = readTask(tid);
+          if (t && t.status === "in_progress" && !t._stale) {
+            updateTask(tid, { _stale: true, _staleReason: "timeout", _staleAt: new Date().toISOString() });
+            logActivity({ type: "updated", taskId: tid, subject: info.subject, detail: "Zombie detected: no activity for 30min" });
+            broadcastRaw({ type: "zombie", taskId: tid, reason: "stale" });
+          }
+        } catch (e) {}
+      }
+    }
+  });
+  return zombies;
+}
+
+// Run zombie check every 60 seconds
+setInterval(checkZombies, 60000);
+
 // ── Orchestrator Prompt System ──
 const ORCHESTRATOR_FILE = path.join(os.homedir(), ".claude", "orchestrator.md");
 const ORCHESTRATOR_LOG = path.join(os.homedir(), ".claude", "orchestrator-history.jsonl");
@@ -546,6 +600,11 @@ function readActivity(since, limit) {
 }
 
 // ── Task 파일 읽기 ──
+function readTask(id) {
+  var all = readAllTasks();
+  return all.find(function(t) { return String(t.id) === String(id); }) || null;
+}
+
 function readAllTasks(projectFilter) {
   const tasks = [];
   if (!fs.existsSync(TASKS_DIR)) return tasks;
@@ -684,6 +743,9 @@ function updateTask(id, data) {
   if (data.reportPath !== undefined) task.reportPath = data.reportPath;
   if (data.reportSummary !== undefined) task.reportSummary = data.reportSummary;
   if (data.parentId !== undefined) task.parentId = data.parentId;
+  if (data._stale !== undefined) task._stale = data._stale;
+  if (data._staleReason !== undefined) task._staleReason = data._staleReason;
+  if (data._staleAt !== undefined) task._staleAt = data._staleAt;
   task.updatedAt = now;
   fs.writeFileSync(filePath, JSON.stringify(task, null, 2));
 
@@ -873,8 +935,18 @@ function buildExecutorPrompt(task) {
   if (agentPrompt) parts.push(agentPrompt);
 
   parts.push("## 태스크\n\n- **Task ID**: " + task.id + "\n- **Subject**: " + task.subject + "\n\n" + (task.description || "(설명 없음)"));
+
+  // v3: Include review feedback from comments
+  if (task.comments && task.comments.length > 0) {
+    var reviewComments = task.comments.filter(function (c) { return c.author === "reviewer"; });
+    if (reviewComments.length > 0) {
+      parts.push("## 리뷰 피드백\n\n이전 실행에서 리뷰어가 남긴 피드백입니다. 반드시 반영하세요:\n\n" +
+        reviewComments.map(function (c) { return "- " + c.text + " (" + c.createdAt + ")"; }).join("\n"));
+    }
+  }
+
   parts.push("작업 디렉토리: " + path.join(__dirname, ".."));
-  parts.push("## Slack Progress Reporting\n\n진행 상황을 Slack에 보고할 때 반드시 아래 API를 사용한다:\n\n```bash\ncurl -s -X POST http://localhost:4040/api/tasks/" + task.id + "/slack \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"text\":\"progress message\"}'\n```\n\n`$SLACK_AGENT_WEBHOOK` 직접 사용 금지. 반드시 위 API를 통해 보고.");
+  parts.push("## Slack Progress Reporting\n\n진행 상황을 Slack에 보고할 때 반드시 아래 API를 사용한다:\n\n```bash\ncurl -s -X POST http://localhost:" + PORT + "/api/tasks/" + task.id + "/slack \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"text\":\"progress message\"}'\n```\n\n`$SLACK_AGENT_WEBHOOK` 직접 사용 금지. 반드시 위 API를 통해 보고.");
 
   return parts.join("\n\n---\n\n");
 }
@@ -895,6 +967,7 @@ function spawnExecutor(task) {
   });
 
   activeExec = { process: proc, taskId: taskId, output: "" };
+  trackAgent(taskId, proc.pid, task.agent, task.subject);
   broadcastRaw({ type: "exec_start", taskId: taskId, subject: task.subject, agent: task.agent || "", model: model });
   logActivity({ type: "started", taskId: taskId, subject: task.subject, detail: "Agent: " + (task.agent || "none") + " | Model: " + model });
 
@@ -918,6 +991,7 @@ function spawnExecutor(task) {
         else if (json.type === "content_block_delta" && json.delta) text = json.delta.text || "";
         if (text && activeExec) {
           activeExec.output += text;
+          touchAgent(taskId);
           broadcastRaw({ type: "exec", taskId: taskId, chunk: text });
         }
       } catch (e) {}
@@ -931,6 +1005,7 @@ function spawnExecutor(task) {
   proc.on("close", function (code) {
     var output = activeExec ? activeExec.output : "";
     activeExec = null;
+    untrackAgent(taskId);
     if (code === 0) {
       updateTask(taskId, { status: "in_review", reportSummary: output.slice(0, 500) });
       broadcastRaw({ type: "exec_done", taskId: taskId, exitCode: 0 });
@@ -1526,6 +1601,94 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  // GET /api/metrics — progress metrics
+  if (req.url.split("?")[0] === "/api/metrics" && req.method === "GET") {
+    var metricsParams = new URL(req.url, "http://localhost").searchParams;
+    var mProject = metricsParams.get("project") || null;
+    var allT = readAllTasks(mProject);
+    var total = allT.length, pending = 0, active = 0, review = 0, completed = 0, blocked = 0, stale = 0;
+    var byAgent = {}, byPriority = { high: 0, medium: 0, low: 0 };
+    var dailyCompleted = {}; // date -> count
+    var dailyCreated = {};
+    allT.forEach(function (t) {
+      var st = t.status || "pending";
+      if (st === "pending") pending++;
+      else if (st === "in_progress") active++;
+      else if (st === "in_review") review++;
+      else if (st === "completed") completed++;
+      if (t.blockedBy && t.blockedBy.length > 0 && st !== "completed") blocked++;
+      if (t._stale) stale++;
+      var ag = t.agent || "unassigned";
+      if (!byAgent[ag]) byAgent[ag] = { total: 0, completed: 0, in_progress: 0, pending: 0 };
+      byAgent[ag].total++;
+      byAgent[ag][st] = (byAgent[ag][st] || 0) + 1;
+      byPriority[t.priority || "medium"]++;
+      if (t.completedAt) {
+        var d = t.completedAt.slice(0, 10);
+        dailyCompleted[d] = (dailyCompleted[d] || 0) + 1;
+      }
+      if (t.createdAt) {
+        var d2 = t.createdAt.slice(0, 10);
+        dailyCreated[d2] = (dailyCreated[d2] || 0) + 1;
+      }
+    });
+    // Build burndown: remaining tasks over time
+    var burndown = [];
+    var dates = Object.keys(Object.assign({}, dailyCompleted, dailyCreated)).sort();
+    if (dates.length > 0) {
+      var remaining = total;
+      for (var di = dates.length - 1; di >= 0; di--) {
+        burndown.unshift({ date: dates[di], remaining: remaining });
+        remaining = remaining + (dailyCompleted[dates[di]] || 0) - (dailyCreated[dates[di]] || 0);
+      }
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      total: total, pending: pending, active: active, review: review, completed: completed,
+      blocked: blocked, stale: stale,
+      completionRate: total > 0 ? Math.round(completed / total * 100) : 0,
+      byAgent: byAgent, byPriority: byPriority,
+      dailyCompleted: dailyCompleted, dailyCreated: dailyCreated,
+      burndown: burndown
+    }));
+    return;
+  }
+
+  // GET /api/agents/status — agent tracker + zombie info
+  if (req.url === "/api/agents/status" && req.method === "GET") {
+    var agents = {};
+    var allT = readAllTasks();
+    // Collect agent stats
+    allT.forEach(function(t) {
+      var a = t.agent || "unassigned";
+      if (!agents[a]) agents[a] = { total: 0, completed: 0, in_progress: 0, pending: 0, in_review: 0 };
+      agents[a].total++;
+      agents[a][t.status] = (agents[a][t.status] || 0) + 1;
+    });
+    // Merge live tracking
+    var tracked = {};
+    Object.keys(agentTracker).forEach(function(tid) {
+      var info = agentTracker[tid];
+      tracked[tid] = { pid: info.pid, alive: isProcessAlive(info.pid), startedAt: info.startedAt, lastActivity: info.lastActivity, agent: info.agent, subject: info.subject };
+    });
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ agents: agents, tracked: tracked, activeExec: activeExec ? { taskId: activeExec.taskId } : null }));
+    return;
+  }
+
+  // POST /api/tasks/:id/recover — recover zombie task
+  var recoverMatch = req.url.match(/^\/api\/tasks\/(\d+)\/recover$/);
+  if (recoverMatch && req.method === "POST") {
+    var rid = recoverMatch[1];
+    untrackAgent(rid);
+    updateTask(rid, { status: "pending", _stale: false, _staleReason: null, _staleAt: null, activeForm: null });
+    logActivity({ type: "updated", taskId: rid, subject: "", detail: "Recovered from zombie state" });
+    broadcastRaw({ type: "tasks_updated" });
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, taskId: rid }));
+    return;
+  }
+
   // GET /api/tasks
   if (req.url.split("?")[0] === "/api/tasks" && req.method === "GET") {
     var taskParams = new URL(req.url, "http://localhost").searchParams;
@@ -1607,6 +1770,39 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  // GET /api/tasks/:id/comments — list comments
+  var commentsGetMatch = req.url.match(/^\/api\/tasks\/(\d+)\/comments$/);
+  if (commentsGetMatch && req.method === "GET") {
+    var cid = commentsGetMatch[1];
+    var ct = readTask(cid);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(ct && ct.comments ? ct.comments : []));
+    return;
+  }
+
+  // POST /api/tasks/:id/comments — add comment
+  var commentsPostMatch = req.url.match(/^\/api\/tasks\/(\d+)\/comments$/);
+  if (commentsPostMatch && req.method === "POST") {
+    var cid2 = commentsPostMatch[1];
+    collectBody(req, function (body) {
+      try {
+        var cdata = JSON.parse(body);
+        var filePath = findTaskFile(cid2);
+        if (!filePath) { res.writeHead(404); res.end(JSON.stringify({ error: "not found" })); return; }
+        var task = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (!task.comments) task.comments = [];
+        var comment = { author: cdata.author || "user", text: cdata.text || "", createdAt: new Date().toISOString() };
+        task.comments.push(comment);
+        fs.writeFileSync(filePath, JSON.stringify(task, null, 2));
+        broadcastRaw({ type: "tasks_updated" });
+        logActivity({ type: "updated", taskId: cid2, subject: task.subject || "", detail: "Comment by " + comment.author });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, comment: comment }));
+      } catch (e) { res.writeHead(400); res.end(JSON.stringify({ error: String(e) })); }
+    });
+    return;
+  }
+
   // POST /api/tasks/:id/slack — Agent progress reporting via thread
   const slackMatch = req.url.match(/^\/api\/tasks\/([\w.-]+)\/slack$/);
   if (slackMatch && req.method === "POST") {