@jjlabsio/claude-crew 0.1.14 → 0.1.16

package/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
       "name": "claude-crew",
       "source": "./",
       "description": "오케스트레이터 + PM, 플래너, 개발, QA, 마케팅 에이전트 팀으로 단일 제품의 개발과 마케팅을 통합 관리",
-      "version": "0.1.14",
+      "version": "0.1.16",
       "author": {
         "name": "Jaejin Song",
         "email": "wowlxx28@gmail.com"
@@ -28,5 +28,5 @@
       "category": "workflow"
     }
   ],
-  "version": "0.1.14"
+  "version": "0.1.16"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-crew",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "1인 SaaS 개발자를 위한 멀티 에이전트 오케스트레이션 — 개발, 마케팅, 일정을 한 대화에서 통합 관리",
   "author": {
     "name": "Jaejin Song",

package/hud/index.mjs

@@ -187,11 +187,40 @@ function colorizeContext(pct) {
   return `ctx:${color(`${pct}%`)}`;
 }
 
+// ---------------------------------------------------------------------------
+// Rate limits (5h / weekly)
+// ---------------------------------------------------------------------------
+function getRateLimits(stdin) {
+  const rl = stdin?.rate_limits;
+  if (!rl) return null;
+  const parse = (v) => {
+    if (v == null) return null;
+    const n = typeof v === 'number' ? v : parseFloat(v);
+    return isNaN(n) ? null : Math.round(Math.min(Math.max(n, 0), 100));
+  };
+  const fiveHour = parse(rl.five_hour?.used_percentage);
+  const sevenDay = parse(rl.seven_day?.used_percentage);
+  if (fiveHour == null && sevenDay == null) return null;
+  return { fiveHour, sevenDay };
+}
+
+function colorizeRateLimits(limits) {
+  if (!limits) return null;
+  const colorize = (pct) => {
+    const color = pct >= 85 ? red : pct >= 70 ? yellow : green;
+    return color(`${pct}%`);
+  };
+  const parts = [];
+  if (limits.fiveHour != null) parts.push(`5h:${colorize(limits.fiveHour)}`);
+  if (limits.sevenDay != null) parts.push(`weekly:${colorize(limits.sevenDay)}`);
+  return parts.join(' ');
+}
+
 // ---------------------------------------------------------------------------
 // Transcript parsing (agents + skills)
 // ---------------------------------------------------------------------------
 function parseTranscript(transcriptPath) {
-  const result = { agents: [], lastSkill: null, sessionStart: null };
+  const result = { agents: [], todos: [], lastSkill: null, sessionStart: null };
   if (!transcriptPath || !existsSync(transcriptPath)) return result;
 
   const agentModels = loadAgentModels();
@@ -200,55 +229,120 @@ function parseTranscript(transcriptPath) {
     const content = readFileSync(transcriptPath, 'utf-8');
     const lines = content.split('\n').filter(Boolean);
 
-    // Map of tool_use_id -> agent info
     const agentMap = new Map();
+    const latestTodos = [];
+    const taskIdToIndex = new Map();
     let lastTimestamp = null;
 
     for (const line of lines) {
       let entry;
       try { entry = JSON.parse(line); } catch { continue; }
 
-      // Track last known timestamp
       if (entry.timestamp) {
         lastTimestamp = entry.timestamp;
       }
 
-      // Session start time
       if (!result.sessionStart && entry.timestamp) {
         result.sessionStart = new Date(entry.timestamp);
       }
 
-      // Track agents
+      // Process tool_use blocks from assistant messages
       if (entry.type === 'tool_use' || entry.type === 'assistant') {
-        const content = entry.message?.content;
-        if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === 'tool_use') {
-              // Agent start
-              if (block.name === 'Agent' || block.name === 'proxy_Agent') {
-                const id = block.id;
-                if (id) {
-                  const input = block.input || {};
-                  const agentType = input.subagent_type || input.type || 'general';
-                  const rawType = agentType.replace(/^claude-crew:/, '');
-                  const model = input.model || agentModels[rawType] || null;
-                  const description = input.description || input.prompt?.slice(0, 50) || '';
-                  const ts = entry.timestamp || lastTimestamp;
-                  agentMap.set(id, {
-                    id,
-                    type: agentType,
-                    model,
-                    description,
-                    startTime: ts ? new Date(ts) : null,
-                    status: 'running',
-                  });
+        const blocks = entry.message?.content;
+        if (Array.isArray(blocks)) {
+          for (const block of blocks) {
+            if (block.type !== 'tool_use') continue;
+
+            // Agent start
+            if (block.name === 'Agent' || block.name === 'proxy_Agent') {
+              const id = block.id;
+              if (id) {
+                const input = block.input || {};
+                const agentType = input.subagent_type || input.type || 'general';
+                const rawType = agentType.replace(/^claude-crew:/, '');
+                const model = input.model || agentModels[rawType] || null;
+                const description = input.description || input.prompt?.slice(0, 50) || '';
+                const ts = entry.timestamp || lastTimestamp;
+                agentMap.set(id, {
+                  id,
+                  type: agentType,
+                  model,
+                  description,
+                  startTime: ts ? new Date(ts) : null,
+                  status: 'running',
+                });
+              }
+            }
+
+            // Skill invocation
+            if (block.name === 'Skill' || block.name === 'proxy_Skill') {
+              const skillName = block.input?.skill || block.input?.name;
+              if (skillName) {
+                result.lastSkill = skillName;
+              }
+            }
+
+            // TodoWrite — full replacement of todo list
+            if (block.name === 'TodoWrite') {
+              const input = block.input || {};
+              if (input.todos && Array.isArray(input.todos)) {
+                const contentToTaskIds = new Map();
+                for (const [taskId, idx] of taskIdToIndex) {
+                  if (idx < latestTodos.length) {
+                    const c = latestTodos[idx].content;
+                    const ids = contentToTaskIds.get(c) ?? [];
+                    ids.push(taskId);
+                    contentToTaskIds.set(c, ids);
+                  }
+                }
+
+                latestTodos.length = 0;
+                taskIdToIndex.clear();
+                latestTodos.push(...input.todos);
+
+                for (let i = 0; i < latestTodos.length; i++) {
+                  const ids = contentToTaskIds.get(latestTodos[i].content);
+                  if (ids) {
+                    for (const taskId of ids) {
+                      taskIdToIndex.set(taskId, i);
+                    }
+                    contentToTaskIds.delete(latestTodos[i].content);
+                  }
                 }
               }
-              // Skill invocation
-              if (block.name === 'Skill' || block.name === 'proxy_Skill') {
-                const skillName = block.input?.skill || block.input?.name;
-                if (skillName) {
-                  result.lastSkill = skillName;
+            }
+
+            // TaskCreate — append a single task
+            if (block.name === 'TaskCreate') {
+              const input = block.input || {};
+              const subject = typeof input.subject === 'string' ? input.subject : '';
+              const description = typeof input.description === 'string' ? input.description : '';
+              const todoContent = subject || description || 'Untitled task';
+              const status = normalizeTaskStatus(input.status) ?? 'pending';
+              latestTodos.push({ content: todoContent, status });
+
+              const taskId = typeof input.taskId === 'string' || typeof input.taskId === 'number'
+                ? String(input.taskId)
+                : block.id;
+              if (taskId) {
+                taskIdToIndex.set(taskId, latestTodos.length - 1);
+              }
+            }
+
+            // TaskUpdate — update status/content of existing task
+            if (block.name === 'TaskUpdate') {
+              const input = block.input || {};
+              const index = resolveTaskIndex(input.taskId, taskIdToIndex, latestTodos);
+              if (index !== null) {
+                const status = normalizeTaskStatus(input.status);
+                if (status) {
+                  latestTodos[index] = { ...latestTodos[index], status };
+                }
+                const subject = typeof input.subject === 'string' ? input.subject : '';
+                const description = typeof input.description === 'string' ? input.description : '';
+                const newContent = subject || description;
+                if (newContent) {
+                  latestTodos[index] = { ...latestTodos[index], content: newContent };
                 }
               }
             }
@@ -261,17 +355,23 @@ function parseTranscript(transcriptPath) {
       if (entry.type === 'tool_result') {
         const toolUseId = entry.tool_use_id;
         if (toolUseId && agentMap.has(toolUseId)) {
-          agentMap.get(toolUseId).status = 'completed';
+          const agent = agentMap.get(toolUseId);
+          agent.status = 'completed';
+          const ts = entry.timestamp || lastTimestamp;
+          if (ts) agent.endTime = new Date(ts);
         }
       }
       if (entry.type === 'user') {
-        const content = entry.message?.content;
-        if (Array.isArray(content)) {
-          for (const block of content) {
+        const blocks = entry.message?.content;
+        if (Array.isArray(blocks)) {
+          for (const block of blocks) {
             if (block.type === 'tool_result') {
               const toolUseId = block.tool_use_id;
               if (toolUseId && agentMap.has(toolUseId)) {
-                agentMap.get(toolUseId).status = 'completed';
+                const agent = agentMap.get(toolUseId);
+                agent.status = 'completed';
+                const ts = entry.timestamp || lastTimestamp;
+                if (ts) agent.endTime = new Date(ts);
               }
             }
           }
@@ -287,11 +387,46 @@ function parseTranscript(transcriptPath) {
       if (a.startTime && (now - a.startTime.getTime()) > STALE_THRESHOLD_MS) return false;
       return true;
     });
+    result.todos = [...latestTodos];
   } catch { /* ignore parse errors */ }
 
   return result;
 }
 
+// ---------------------------------------------------------------------------
+// Todo helpers
+// ---------------------------------------------------------------------------
+function normalizeTaskStatus(status) {
+  if (typeof status !== 'string') return null;
+  switch (status) {
+    case 'pending':
+    case 'not_started':
+      return 'pending';
+    case 'in_progress':
+    case 'running':
+      return 'in_progress';
+    case 'completed':
+    case 'complete':
+    case 'done':
+      return 'completed';
+    default:
+      return null;
+  }
+}
+
+function resolveTaskIndex(taskId, taskIdToIndex, latestTodos) {
+  if (typeof taskId === 'string' || typeof taskId === 'number') {
+    const key = String(taskId);
+    const mapped = taskIdToIndex.get(key);
+    if (typeof mapped === 'number') return mapped;
+    if (/^\d+$/.test(key)) {
+      const numericIndex = parseInt(key, 10) - 1;
+      if (numericIndex >= 0 && numericIndex < latestTodos.length) return numericIndex;
+    }
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Agent model name (short)
 // ---------------------------------------------------------------------------
@@ -307,14 +442,18 @@ function shortModelName(model) {
 // ---------------------------------------------------------------------------
 // Agent duration formatting
 // ---------------------------------------------------------------------------
-function formatAgentDuration(startTime) {
-  if (!startTime) return '?';
-  const ms = Date.now() - startTime.getTime();
+function formatAgentDuration(startTime, endTime) {
+  if (!startTime) return '';
+  const ms = (endTime ?? new Date()).getTime() - startTime.getTime();
+  if (ms < 1000) return '<1s';
   const seconds = Math.floor(ms / 1000);
-  const minutes = Math.floor(seconds / 60);
-  if (seconds < 10) return '';
   if (seconds < 60) return `${seconds}s`;
-  return `${minutes}m`;
+  const minutes = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  if (minutes < 60) return `${minutes}m${secs}s`;
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  return `${hours}h${mins}m`;
 }
 
 // ---------------------------------------------------------------------------
@@ -337,7 +476,7 @@ function renderAgentsMultiLine(agents, maxLines = 5) {
     const rawType = a.type.includes(':') ? a.type.split(':').pop() : a.type;
     const name = rawType.padEnd(7);
     const model = shortModelName(a.model).padEnd(8);
-    const duration = formatAgentDuration(a.startTime).padStart(4);
+    const duration = formatAgentDuration(a.startTime, a.endTime).padStart(6);
     const desc = a.description.length > 40 ? a.description.slice(0, 37) + '...' : a.description;
 
     detailLines.push(
@@ -353,6 +492,29 @@ function renderAgentsMultiLine(agents, maxLines = 5) {
   return { headerPart, detailLines };
 }
 
+// ---------------------------------------------------------------------------
+// Todo progress rendering
+// ---------------------------------------------------------------------------
+function renderTodosLine(todos) {
+  if (!todos || todos.length === 0) return null;
+
+  const inProgress = todos.find(t => t.status === 'in_progress');
+  const completed = todos.filter(t => t.status === 'completed').length;
+  const total = todos.length;
+
+  if (!inProgress) {
+    if (completed === total && total > 0) {
+      return `${green('\u2713')} all done ${dim(`(${completed}/${total})`)}`;
+    }
+    return null;
+  }
+
+  const content = inProgress.content.length > 50
+    ? inProgress.content.slice(0, 47) + '...'
+    : inProgress.content;
+  return `${yellow('\u25b8')} ${content} ${dim(`(${completed}/${total})`)}`;
+}
+
 // ---------------------------------------------------------------------------
 // Session duration
 // ---------------------------------------------------------------------------
@@ -441,11 +603,19 @@ async function main() {
 
   midElements.push(colorizeSession(transcript.sessionStart));
 
+  const rateLimits = getRateLimits(stdin);
+  const rateLimitsStr = colorizeRateLimits(rateLimits);
+  if (rateLimitsStr) midElements.push(rateLimitsStr);
+
+  // --- Todos line ---
+  const todosLine = renderTodosLine(transcript.todos);
+
   // --- Output ---
   const outputLines = [];
   outputLines.push(topElements.join(SEPARATOR));
   outputLines.push(midElements.join(SEPARATOR));
   outputLines.push(...detailLines);
+  if (todosLine) outputLines.push(todosLine);
 
   console.log(outputLines.filter(Boolean).join('\n'));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jjlabsio/claude-crew",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "1인 SaaS 개발자를 위한 멀티 에이전트 오케스트레이션 — 개발, 마케팅, 일정을 한 대화에서 통합 관리",
   "author": "Jaejin Song <wowlxx28@gmail.com>",
   "license": "MIT",

package/scripts/setup-hud.mjs

@@ -69,18 +69,6 @@ async function main() {
       writeFileSync(localSettingsPath, JSON.stringify(localSettings, null, 2));
     }
 
-    // --- Remove legacy global statusLine from ~/.claude/settings.json ---
-    const globalSettingsPath = join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), 'settings.json');
-    if (existsSync(globalSettingsPath)) {
-      try {
-        const globalSettings = JSON.parse(readFileSync(globalSettingsPath, 'utf-8'));
-        if (globalSettings.statusLine) {
-          delete globalSettings.statusLine;
-          writeFileSync(globalSettingsPath, JSON.stringify(globalSettings, null, 2));
-        }
-      } catch { /* ignore */ }
-    }
-
     console.log(JSON.stringify({ continue: true }));
   } catch (e) {
     console.log(JSON.stringify({