work-kit-cli 0.2.8 → 0.4.0

package/cli/src/observer/data.ts

@@ -1,28 +1,41 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { execFileSync } from "node:child_process";
 import type { WorkKitState, PhaseName } from "../state/schema.js";
-import { PHASE_NAMES, SUBSTAGES_BY_PHASE } from "../state/schema.js";
-import { readState, stateExists } from "../state/store.js";
+import { PHASE_NAMES, STEPS_BY_PHASE, MODE_AUTO } from "../state/schema.js";
+import { readState, stateExists, STATE_DIR, AWAITING_INPUT_MARKER_FILE, IDLE_MARKER_FILE, gitMainRepoRoot } from "../state/store.js";
+import { TRACKER_DIR, INDEX_FILE } from "../config/constants.js";
 
-// ── View Types ──────────────────────────────────────────────────────
+const AWAITING_INPUT_MARKER = path.join(STATE_DIR, AWAITING_INPUT_MARKER_FILE);
+const IDLE_MARKER = path.join(STATE_DIR, IDLE_MARKER_FILE);
+
+// ── View Types ─────────────────────────────────────────────────────
+
+export interface WorktreeEntry {
+  root: string;     // main repo root that owns this worktree
+  worktree: string; // worktree path (may equal root)
+}
 
 export interface WorkItemView {
   slug: string;
+  repoName: string;
   branch: string;
   mode: string;
   classification?: string;
   status: string;
   currentPhase: string | null;
-  currentSubStage: string | null;
+  currentStep: string | null;
   currentPhaseStartedAt?: string;
-  currentSubStageStatus?: string;
-  currentSubStageIndex?: number;
-  currentSubStageStartedAt?: string;
+  currentStepStatus?: string;
+  currentStepIndex?: number;
+  currentStepStartedAt?: string;
   currentPhaseTotal?: number;
   gated: boolean;
+  awaitingInput: boolean;
+  idle: boolean;
   worktreePath: string;
-  phaseSubStages: { name: string; status: string; startedAt?: string; completedAt?: string; outcome?: string }[];
+  phaseSteps: { name: string; status: string; startedAt?: string; completedAt?: string; outcome?: string }[];
   startedAt: string;
   progress: { completed: number; total: number; percent: number };
   phases: { name: string; status: string; startedAt?: string; completedAt?: string }[];
@@ -31,6 +44,7 @@ export interface WorkItemView {
 
 export interface CompletedItemView {
   slug: string;
+  repoName: string;
   pr?: string;
   completedAt: string;
   phases: string;
@@ -42,7 +56,7 @@ export interface DashboardData {
   lastUpdated: Date;
 }
 
-// ── Worktree Discovery ──────────────────────────────────────────────
+// ── Worktree Discovery ─────────────────────────────────────────────
 
 export function discoverWorktrees(mainRepoRoot: string): string[] {
   let output: string;
@@ -74,9 +88,97 @@ export function discoverWorktrees(mainRepoRoot: string): string[] {
   return worktrees;
 }
 
-// ── Collect Single Work Item ────────────────────────────────────────
+// ── Discover All Work-Kit Projects on the System ───────────────────
+//
+// Scans ~/.claude/projects/ for sessions, reads `cwd` from session
+// jsonl files, resolves each to a git toplevel, and keeps only those
+// roots that have at least one work-kit-tracked worktree.
+
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), ".claude", "projects");
+
+function extractCwdFromJsonl(filePath: string): string | null {
+  let fd: number | null = null;
+  try {
+    const buf = Buffer.alloc(16 * 1024);
+    fd = fs.openSync(filePath, "r");
+    const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+    const content = buf.subarray(0, bytesRead).toString("utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (!line.includes('"cwd"')) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (typeof obj.cwd === "string" && obj.cwd.length > 0) return obj.cwd;
+      } catch {
+        // Likely a truncated final line — skip
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try { fs.closeSync(fd); } catch { /* ignore */ }
+    }
+  }
+}
+
+export function discoverWorkKitProjects(): string[] {
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(CLAUDE_PROJECTS_DIR);
+  } catch {
+    return [];
+  }
 
-export function collectWorkItem(worktreeRoot: string): WorkItemView | null {
+  const cwds = new Set<string>();
+  for (const entry of entries) {
+    const projDir = path.join(CLAUDE_PROJECTS_DIR, entry);
+    let files: string[];
+    try {
+      files = fs.readdirSync(projDir).filter(f => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    if (files.length === 0) continue;
+
+    // Single-pass scan for the most-recently-modified jsonl — avoids
+    // re-statting in a sort comparator (which is O(N log N) stats).
+    let newestFile: string | null = null;
+    let newestMtime = -Infinity;
+    for (const f of files) {
+      try {
+        const m = fs.statSync(path.join(projDir, f)).mtimeMs;
+        if (m > newestMtime) {
+          newestMtime = m;
+          newestFile = f;
+        }
+      } catch { /* ignore */ }
+    }
+    if (!newestFile) continue;
+
+    const cwd = extractCwdFromJsonl(path.join(projDir, newestFile));
+    if (cwd) cwds.add(cwd);
+  }
+
+  // Resolve each cwd to its main repo root (works whether the session
+  // was run from the main repo or from inside a worktree) and keep
+  // only roots that actually have work-kit setup.
+  const roots = new Set<string>();
+  for (const cwd of cwds) {
+    const mainRoot = gitMainRepoRoot(cwd);
+    if (!mainRoot || roots.has(mainRoot)) continue;
+    if (discoverWorktrees(mainRoot).length > 0) {
+      roots.add(mainRoot);
+    }
+  }
+
+  return Array.from(roots);
+}
+
+// ── Collect Single Work Item ───────────────────────────────────────
+
+export function collectWorkItem(worktreeRoot: string, mainRepoRoot?: string): WorkItemView | null {
   if (!stateExists(worktreeRoot)) return null;
 
   let state: WorkKitState;
@@ -91,30 +193,29 @@ export function collectWorkItem(worktreeRoot: string): WorkItemView | null {
   let total = 0;
   const phaseViews: { name: string; status: string; startedAt?: string; completedAt?: string }[] = [];
 
-  const phaseList: PhaseName[] = state.mode === "auto-kit" && state.workflow
+  const phaseList: PhaseName[] = state.mode === MODE_AUTO && state.workflow
     ? getAutoKitPhases(state)
     : [...PHASE_NAMES];
 
-  // Track current phase substage position
+  // Track current phase step position
   let currentPhaseStartedAt: string | undefined;
-  let currentSubStageStatus: string | undefined;
-  let currentSubStageIndex: number | undefined;
-  let currentSubStageStartedAt: string | undefined;
+  let currentStepStatus: string | undefined;
+  let currentStepIndex: number | undefined;
+  let currentStepStartedAt: string | undefined;
   let currentPhaseTotal: number | undefined;
-  let phaseSubStages: WorkItemView["phaseSubStages"] = [];
+  let phaseSteps: WorkItemView["phaseSteps"] = [];
 
   for (const phaseName of phaseList) {
     const phase = state.phases[phaseName];
     if (!phase) {
       phaseViews.push({ name: phaseName, status: "pending" });
-      // Count substages for total
-      const subs = SUBSTAGES_BY_PHASE[phaseName] || [];
-      total += subs.length;
+      const steps = STEPS_BY_PHASE[phaseName];
+      total += steps.length;
       continue;
     }
 
-    // If any sub-stage is "waiting", show the phase as waiting in the view
-    const hasWaiting = Object.values(phase.subStages).some(ss => ss.status === "waiting");
+    // If any step is "waiting", show the phase as waiting in the view
+    const hasWaiting = Object.values(phase.steps).some(s => s.status === "waiting");
     phaseViews.push({
       name: phaseName,
       status: hasWaiting ? "waiting" : phase.status,
@@ -122,21 +223,18 @@ export function collectWorkItem(worktreeRoot: string): WorkItemView | null {
       completedAt: phase.completedAt,
     });
 
-    const subStageKeys = Object.keys(phase.subStages);
-    if (subStageKeys.length === 0) {
-      // Use default substages — skip entirely skipped phases
+    const stepKeys = Object.keys(phase.steps);
+    if (stepKeys.length === 0) {
       if (phase.status === "skipped") continue;
-      const defaults = SUBSTAGES_BY_PHASE[phaseName] || [];
+      const defaults = STEPS_BY_PHASE[phaseName];
       total += defaults.length;
       if (phase.status === "completed") completed += defaults.length;
     } else {
-      let phaseIdx = 0;
-      const activeKeys = subStageKeys.filter(k => phase.subStages[k].status !== "skipped");
+      const activeKeys = stepKeys.filter(k => phase.steps[k].status !== "skipped");
       for (const key of activeKeys) {
-        const sub = phase.subStages[key];
+        const s = phase.steps[key];
         total++;
-        phaseIdx++;
-        if (sub.status === "completed") {
+        if (s.status === "completed") {
           completed++;
         }
       }
@@ -144,21 +242,21 @@ export function collectWorkItem(worktreeRoot: string): WorkItemView | null {
       if (phaseName === state.currentPhase) {
         currentPhaseStartedAt = phase.startedAt;
         currentPhaseTotal = activeKeys.length;
-        if (state.currentSubStage) {
-          const idx = activeKeys.indexOf(state.currentSubStage);
-          currentSubStageIndex = idx >= 0 ? idx + 1 : undefined;
-          const ss = phase.subStages[state.currentSubStage];
-          currentSubStageStatus = ss?.status;
-          currentSubStageStartedAt = ss?.startedAt;
+        if (state.currentStep) {
+          const idx = activeKeys.indexOf(state.currentStep);
+          currentStepIndex = idx >= 0 ? idx + 1 : undefined;
+          const s = phase.steps[state.currentStep];
+          currentStepStatus = s?.status;
+          currentStepStartedAt = s?.startedAt;
         }
-        phaseSubStages = activeKeys.map(key => {
-          const ss = phase.subStages[key];
+        phaseSteps = activeKeys.map(key => {
+          const s = phase.steps[key];
           return {
             name: key,
-            status: ss.status,
-            startedAt: ss.startedAt,
-            completedAt: ss.completedAt,
-            outcome: ss.outcome,
+            status: s.status,
+            startedAt: s.startedAt,
+            completedAt: s.completedAt,
+            outcome: s.outcome,
           };
         });
       }
@@ -173,29 +271,39 @@ export function collectWorkItem(worktreeRoot: string): WorkItemView | null {
     count: loopbacks.length,
     lastReason: loopbacks.length > 0 ? loopbacks[loopbacks.length - 1].reason : undefined,
     lastFrom: loopbacks.length > 0
-      ? `${loopbacks[loopbacks.length - 1].from.phase}/${loopbacks[loopbacks.length - 1].from.subStage}`
+      ? `${loopbacks[loopbacks.length - 1].from.phase}/${loopbacks[loopbacks.length - 1].from.step}`
       : undefined,
     lastTo: loopbacks.length > 0
-      ? `${loopbacks[loopbacks.length - 1].to.phase}/${loopbacks[loopbacks.length - 1].to.subStage}`
+      ? `${loopbacks[loopbacks.length - 1].to.phase}/${loopbacks[loopbacks.length - 1].to.step}`
       : undefined,
   };
 
+  const repoRoot = mainRepoRoot ?? worktreeRoot;
   return {
     slug: state.slug,
+    repoName: path.basename(repoRoot),
     branch: state.branch,
     mode: state.mode,
     classification: state.classification,
     status: state.status,
     currentPhase: state.currentPhase,
-    currentSubStage: state.currentSubStage,
+    currentStep: state.currentStep,
     currentPhaseStartedAt,
-    currentSubStageStatus,
-    currentSubStageIndex,
-    currentSubStageStartedAt,
+    currentStepStatus,
+    currentStepIndex,
+    currentStepStartedAt,
     currentPhaseTotal,
     gated: state.gated ?? false,
+    awaitingInput: fs.existsSync(path.join(worktreeRoot, AWAITING_INPUT_MARKER)),
+    // Idle badge only fires when the agent ended its turn *mid-step*
+    // (suggesting it asked a prose question) — not during normal gaps
+    // between steps.
+    idle:
+      fs.existsSync(path.join(worktreeRoot, IDLE_MARKER)) &&
+      state.status === "in-progress" &&
+      currentStepStatus === "in-progress",
     worktreePath: state.metadata.worktreeRoot,
-    phaseSubStages,
+    phaseSteps,
     startedAt: state.started,
     progress: { completed, total, percent },
     phases: phaseViews,
@@ -206,17 +314,17 @@ export function collectWorkItem(worktreeRoot: string): WorkItemView | null {
 function getAutoKitPhases(state: WorkKitState): PhaseName[] {
   if (!state.workflow) return [...PHASE_NAMES];
   const phases = new Set<PhaseName>();
-  for (const step of state.workflow) {
-    if (step.included) phases.add(step.phase);
+  for (const ws of state.workflow) {
+    if (ws.included) phases.add(ws.phase);
   }
   // Maintain canonical order
   return PHASE_NAMES.filter(p => phases.has(p));
 }
 
-// ── Collect Completed Items ─────────────────────────────────────────
+// ── Collect Completed Items ────────────────────────────────────────
 
 export function collectCompletedItems(mainRepoRoot: string): CompletedItemView[] {
-  const indexPath = path.join(mainRepoRoot, ".work-kit-tracker", "index.md");
+  const indexPath = path.join(mainRepoRoot, TRACKER_DIR, INDEX_FILE);
   if (!fs.existsSync(indexPath)) return [];
 
   let content: string;
@@ -227,7 +335,6 @@ export function collectCompletedItems(mainRepoRoot: string): CompletedItemView[]
   }
 
   const items: CompletedItemView[] = [];
-  // Format: | Date | Slug | PR | Status | Phases |
   const lines = content.split("\n");
   for (const line of lines) {
     const match = line.match(/^\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|/);
@@ -236,6 +343,7 @@ export function collectCompletedItems(mainRepoRoot: string): CompletedItemView[]
     if (col1 === "Date" || col1.startsWith("-")) continue;
     items.push({
       slug: match[2].trim(),
+      repoName: path.basename(mainRepoRoot),
       pr: match[3].trim() !== "n/a" ? match[3].trim() : undefined,
       completedAt: col1,
       phases: match[5].trim(),
@@ -245,15 +353,31 @@ export function collectCompletedItems(mainRepoRoot: string): CompletedItemView[]
   return items;
 }
 
-// ── Collect All Dashboard Data ──────────────────────────────────────
-
-export function collectDashboardData(mainRepoRoot: string, cachedWorktrees?: string[]): DashboardData {
-  const worktrees = cachedWorktrees ?? discoverWorktrees(mainRepoRoot);
+// ── Collect All Dashboard Data ─────────────────────────────────────
+
+export function collectDashboardData(
+  mainRepoRoots: string[],
+  cachedEntries?: WorktreeEntry[]
+): DashboardData {
+  let entries: WorktreeEntry[];
+  if (cachedEntries) {
+    entries = cachedEntries;
+  } else {
+    entries = [];
+    const seen = new Set<string>();
+    for (const root of mainRepoRoots) {
+      for (const wt of discoverWorktrees(root)) {
+        if (seen.has(wt)) continue;
+        seen.add(wt);
+        entries.push({ root, worktree: wt });
+      }
+    }
+  }
   const activeItems: WorkItemView[] = [];
   const completedFromWorktrees: CompletedItemView[] = [];
 
-  for (const wt of worktrees) {
-    const item = collectWorkItem(wt);
+  for (const entry of entries) {
+    const item = collectWorkItem(entry.worktree, entry.root);
     if (!item) continue;
     if (item.status === "completed") {
       const phaseNames = item.phases
@@ -262,6 +386,7 @@ export function collectDashboardData(mainRepoRoot: string, cachedWorktrees?: str
         .join("→");
       completedFromWorktrees.push({
         slug: item.slug,
+        repoName: item.repoName,
         completedAt: item.startedAt,
         phases: phaseNames,
       });
@@ -279,14 +404,20 @@ export function collectDashboardData(mainRepoRoot: string, cachedWorktrees?: str
     return new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime();
   });
 
-  // Merge completed items from worktrees and index file, dedup by slug
-  // Also exclude any slug that is currently active (re-initialized features)
+  // Merge completed items from worktrees and index files, dedup by slug
   const activeSlugs = new Set(activeItems.map(i => i.slug));
-  const indexItems = collectCompletedItems(mainRepoRoot);
+  const indexItems: CompletedItemView[] = [];
+  for (const root of mainRepoRoots) {
+    indexItems.push(...collectCompletedItems(root));
+  }
   const seen = new Set(completedFromWorktrees.map(i => i.slug));
   const completedItems = [
     ...completedFromWorktrees.filter(i => !activeSlugs.has(i.slug)),
-    ...indexItems.filter(i => !seen.has(i.slug) && !activeSlugs.has(i.slug)),
+    ...indexItems.filter(i => {
+      if (activeSlugs.has(i.slug) || seen.has(i.slug)) return false;
+      seen.add(i.slug);
+      return true;
+    }),
   ];
 
   return {