helloloop 0.8.6 → 0.10.0

package/src/dashboard_command.mjs

@@ -0,0 +1,371 @@
+import path from "node:path";
+
+import { nowIso, sleep } from "./common.mjs";
+import { createContext } from "./context.mjs";
+import { analyzeExecution } from "./backlog.mjs";
+import { loadBacklog } from "./config.mjs";
+import { buildDashboardHostContinuation } from "./host_continuation.mjs";
+import { loadRuntimeSettings } from "./runtime_settings_loader.mjs";
+import { collectRepoStatusSnapshot } from "./runner_status.mjs";
+import { hasRetryBudget, pickRetryDelaySeconds } from "./runtime_settings.mjs";
+import { isTrackedPidAlive } from "./supervisor_state.mjs";
+import { listActiveSessionEntries, listKnownWorkspaceEntries } from "./workspace_registry.mjs";
+
+function formatRuntimeLabel(runtime) {
+  if (!runtime?.status) {
+    return "idle";
+  }
+  const details = [runtime.status];
+  if (Number.isFinite(Number(runtime.recoveryCount)) && Number(runtime.recoveryCount) > 0) {
+    details.push(`recovery=${runtime.recoveryCount}`);
+  }
+  if (Number.isFinite(Number(runtime?.heartbeat?.idleSeconds)) && Number(runtime.heartbeat.idleSeconds) > 0) {
+    details.push(`idle=${runtime.heartbeat.idleSeconds}s`);
+  }
+  return details.join(" | ");
+}
+
+function formatCurrentAction(session) {
+  return session.activity?.current?.label
+    || session.runtime?.failureReason
+    || session.latestStatus?.message
+    || session.runtime?.status
+    || "等待新事件";
+}
+
+function formatTodoLabel(activity) {
+  if (!activity?.todo?.total) {
+    return "";
+  }
+  return `${activity.todo.completed}/${activity.todo.total}`;
+}
+
+function readBacklogSnapshot(context) {
+  try {
+    const backlog = loadBacklog(context);
+    return {
+      tasks: Array.isArray(backlog.tasks) ? backlog.tasks : [],
+      execution: analyzeExecution(backlog),
+    };
+  } catch {
+    return {
+      tasks: [],
+      execution: null,
+    };
+  }
+}
+
+function normalizeSupervisorSnapshot(supervisor) {
+  if (!supervisor?.status) {
+    return supervisor;
+  }
+  if (["launching", "running"].includes(String(supervisor.status)) && !isTrackedPidAlive(supervisor.guardianPid || supervisor.pid)) {
+    return {
+      ...supervisor,
+      status: "stopped",
+      message: supervisor.message || "后台会话当前未运行。",
+    };
+  }
+  return supervisor;
+}
+
+function normalizeRuntimeSnapshot(supervisor, runtime) {
+  if (!runtime) {
+    return runtime;
+  }
+  if (!supervisor?.status || supervisor.status !== "stopped") {
+    return runtime;
+  }
+  if (!["launching", "running", "recovering", "probe_running", "probe_waiting", "retry_waiting"].includes(String(runtime.status || ""))) {
+    return runtime;
+  }
+
+  const stoppedReason = "后台 supervisor 当前未运行；以下展示的是最近一次执行快照。";
+  return {
+    ...runtime,
+    status: "stopped",
+    failureReason: runtime.failureReason || stoppedReason,
+    heartbeat: runtime.heartbeat
+      ? {
+        ...runtime.heartbeat,
+        status: "stopped",
+        leaseExpired: true,
+        leaseReason: runtime.heartbeat.leaseReason || stoppedReason,
+      }
+      : runtime.heartbeat,
+  };
+}
+
+function normalizeActivitySnapshot(supervisor, activity) {
+  if (!activity) {
+    return activity;
+  }
+  if (!supervisor?.status || supervisor.status !== "stopped") {
+    return activity;
+  }
+  if (String(activity.status || "") !== "running") {
+    return activity;
+  }
+
+  return {
+    ...activity,
+    status: "stopped",
+    runtime: activity.runtime
+      ? {
+        ...activity.runtime,
+        status: "stopped",
+      }
+      : activity.runtime,
+  };
+}
+
+function buildSessionSnapshot(entry) {
+  const context = createContext({
+    repoRoot: entry.repoRoot,
+    configDirName: entry.configDirName,
+  });
+  let repoSnapshot;
+  try {
+    repoSnapshot = collectRepoStatusSnapshot(context, {
+      sessionId: entry.sessionId,
+    });
+  } catch (error) {
+    repoSnapshot = {
+      supervisor: null,
+      latestStatus: {
+        message: String(error?.message || error || "状态读取失败。"),
+      },
+      runtime: null,
+      activity: null,
+      summary: null,
+      nextTask: null,
+    };
+  }
+  const backlogSnapshot = readBacklogSnapshot(context);
+  const supervisor = normalizeSupervisorSnapshot(repoSnapshot.supervisor);
+  const runtime = normalizeRuntimeSnapshot(supervisor, repoSnapshot.runtime);
+  const activity = normalizeActivitySnapshot(supervisor, repoSnapshot.activity);
+  const snapshotForContinuation = {
+    ...repoSnapshot,
+    supervisor,
+    runtime,
+    activity,
+  };
+
+  return {
+    repoRoot: entry.repoRoot,
+    repoName: path.basename(entry.repoRoot),
+    sessionId: entry.sessionId || repoSnapshot.latestStatus?.sessionId || "",
+    command: entry.command || supervisor?.command || "",
+    supervisor,
+    latestStatus: repoSnapshot.latestStatus,
+    runtime,
+    activity,
+    summary: repoSnapshot.summary,
+    nextTask: repoSnapshot.nextTask,
+    tasks: backlogSnapshot.tasks,
+    execution: backlogSnapshot.execution,
+    isActive: entry.isActive === true,
+    hostResume: buildDashboardHostContinuation(entry, snapshotForContinuation),
+    updatedAt: repoSnapshot.activity?.updatedAt
+      || repoSnapshot.runtime?.updatedAt
+      || repoSnapshot.latestStatus?.updatedAt
+      || supervisor?.updatedAt
+      || entry.updatedAt
+      || "",
+  };
+}
+
+function buildTaskTotals(sessions) {
+  const totals = {
+    total: 0,
+    pending: 0,
+    inProgress: 0,
+    done: 0,
+    failed: 0,
+    blocked: 0,
+  };
+
+  for (const session of sessions) {
+    totals.total += Number(session.summary?.total || 0);
+    totals.pending += Number(session.summary?.pending || 0);
+    totals.inProgress += Number(session.summary?.inProgress || 0);
+    totals.done += Number(session.summary?.done || 0);
+    totals.failed += Number(session.summary?.failed || 0);
+    totals.blocked += Number(session.summary?.blocked || 0);
+  }
+
+  return totals;
+}
+
+export function collectDashboardSnapshot() {
+  const activeEntries = listActiveSessionEntries()
+    .map((entry) => ({ ...entry, isActive: true }));
+  const knownEntries = listKnownWorkspaceEntries()
+    .map((entry) => ({ ...entry, isActive: false }));
+  const mergedEntries = new Map();
+
+  for (const entry of [...knownEntries, ...activeEntries]) {
+    const key = `${entry.repoRoot}::${entry.configDirName || ""}`;
+    const current = mergedEntries.get(key) || {};
+    mergedEntries.set(key, {
+      ...current,
+      ...entry,
+      isActive: entry.isActive === true || current.isActive === true,
+    });
+  }
+
+  const sessions = [...mergedEntries.values()]
+    .map((entry) => buildSessionSnapshot(entry))
+    .sort((left, right) => String(right.updatedAt || "").localeCompare(String(left.updatedAt || "")));
+
+  return {
+    schemaVersion: 1,
+    generatedAt: nowIso(),
+    activeCount: activeEntries.length,
+    repoCount: sessions.length,
+    taskTotals: buildTaskTotals(sessions),
+    primaryHostResume: sessions[0]?.hostResume || null,
+    sessions,
+  };
+}
+
+function renderCompactSession(session, index) {
+  return [
+    `${index + 1}. ${session.repoName}`,
+    `   session=${session.sessionId}`,
+    `   task=${session.latestStatus?.taskTitle || "无"}`,
+    `   runtime=${formatRuntimeLabel(session.runtime)}`,
+    `   action=${formatCurrentAction(session)}`,
+    ...(formatTodoLabel(session.activity) ? [`   todo=${formatTodoLabel(session.activity)}`] : []),
+  ].join("\n");
+}
+
+function renderDetailedSession(session, index, options) {
+  const lines = [
+    `[${index + 1}] ${session.repoName}`,
+    `- 仓库：${session.repoRoot}`,
+    `- 会话：${session.sessionId}`,
+    `- supervisor：${session.supervisor?.status || "unknown"}`,
+    `- 命令：${session.command || "unknown"}`,
+    `- 当前任务：${session.latestStatus?.taskTitle || "无"}`,
+    `- 当前阶段：${session.latestStatus?.stage || "unknown"}`,
+    `- backlog：已完成 ${session.summary?.done || 0} / 总计 ${session.summary?.total || 0} / 待处理 ${session.summary?.pending || 0}`,
+    `- 运行状态：${formatRuntimeLabel(session.runtime)}`,
+    `- 当前动作：${formatCurrentAction(session)}`,
+    `- 宿主续跑：${session.hostResume?.issue?.label || (session.hostResume?.supervisorActive ? "后台仍在运行，可直接接续观察" : "需要按续跑提示继续")}`,
+  ];
+
+  if (formatTodoLabel(session.activity)) {
+    lines.push(`- 当前待办：${formatTodoLabel(session.activity)}`);
+  }
+  if (Array.isArray(session.activity?.activeCommands) && session.activity.activeCommands[0]?.label) {
+    lines.push(`- 活动命令：${session.activity.activeCommands[0].label}`);
+  }
+  if (Array.isArray(session.activity?.recentFileChanges) && session.activity.recentFileChanges[0]?.changes?.length) {
+    const fileLabels = session.activity.recentFileChanges[0].changes
+      .slice(0, 3)
+      .map((item) => `${item.kind}:${item.path}`);
+    lines.push(`- 最近文件：${fileLabels.join(" | ")}`);
+  }
+  if (options.events && Array.isArray(session.activity?.recentEvents) && session.activity.recentEvents.length) {
+    lines.push("- 最近事件：");
+    for (const event of session.activity.recentEvents.slice(-5)) {
+      lines.push(`  - [${event.status || "info"}] ${event.kind}: ${event.label}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+export function renderDashboardText(snapshot, options = {}) {
+  const lines = [
+    "HelloLoop Dashboard",
+    "===================",
+    `仓库总数：${snapshot.repoCount}`,
+    `活跃会话：${snapshot.activeCount}`,
+    `更新时间：${snapshot.generatedAt}`,
+  ];
+
+  if (!snapshot.sessions.length) {
+    lines.push("");
+    lines.push("当前没有已登记仓库或后台会话。");
+    return lines.join("\n");
+  }
+
+  for (const [index, session] of snapshot.sessions.entries()) {
+    lines.push("");
+    lines.push(options.compact
+      ? renderCompactSession(session, index)
+      : renderDetailedSession(session, index, options));
+  }
+
+  return lines.join("\n");
+}
+
+export function buildDashboardSnapshotSignature(snapshot) {
+  return JSON.stringify(snapshot.sessions.map((session) => ({
+    repoRoot: session.repoRoot,
+    sessionId: session.sessionId,
+    taskId: session.latestStatus?.taskId || "",
+    stage: session.latestStatus?.stage || "",
+    runtimeStatus: session.runtime?.status || "",
+    idleSeconds: session.runtime?.heartbeat?.idleSeconds || 0,
+    action: session.activity?.current?.label || "",
+    todoCompleted: session.activity?.todo?.completed || 0,
+    todoTotal: session.activity?.todo?.total || 0,
+    eventLabel: session.activity?.recentEvents?.at(-1)?.label || "",
+    resumeIssue: session.hostResume?.issue?.code || "",
+    taskFingerprint: (session.tasks || [])
+      .map((task) => `${task.id}:${task.status || "pending"}:${task.title}`)
+      .join("|"),
+  })));
+}
+
+export async function runDashboardCommand(options = {}) {
+  const pollMs = Math.max(500, Number(options.pollMs || options.watchPollMs || 2000));
+  const observerRetry = loadRuntimeSettings({
+    globalConfigFile: options.globalConfigFile,
+  }).observerRetry;
+  let previousSignature = "";
+  let retryCount = 0;
+
+  while (true) {
+    try {
+      const snapshot = collectDashboardSnapshot();
+      const signature = buildDashboardSnapshotSignature(snapshot);
+      retryCount = 0;
+
+      if (signature !== previousSignature || !options.watch) {
+        previousSignature = signature;
+        if (options.json) {
+          console.log(JSON.stringify(snapshot));
+        } else {
+          if (options.watch && process.stdout.isTTY) {
+            process.stdout.write("\x1bc");
+          }
+          console.log(renderDashboardText(snapshot, options));
+        }
+      }
+    } catch (error) {
+      const nextAttempt = retryCount + 1;
+      if (!options.watch || !observerRetry.enabled || !hasRetryBudget(observerRetry.maxRetryCount, nextAttempt)) {
+        throw error;
+      }
+
+      const delaySeconds = pickRetryDelaySeconds(observerRetry.retryDelaysSeconds, nextAttempt);
+      process.stderr.write(
+        `[HelloLoop dashboard] 看板采集失败，将在 ${delaySeconds} 秒后自动重试（第 ${nextAttempt} 次）：${String(error?.message || error || "unknown error")}\n`,
+      );
+      retryCount = nextAttempt;
+      await sleep(delaySeconds * 1000);
+      continue;
+    }
+
+    if (!options.watch) {
+      return 0;
+    }
+
+    await sleep(pollMs);
+  }
+}

package/src/dashboard_tui.mjs

@@ -0,0 +1,289 @@
+import { collectDashboardSnapshot } from "./dashboard_command.mjs";
+import { sleep } from "./common.mjs";
+import { loadRuntimeSettings } from "./runtime_settings_loader.mjs";
+import { hasRetryBudget, pickRetryDelaySeconds } from "./runtime_settings.mjs";
+
+const STATUS_GROUPS = [
+  { key: "in_progress", label: "进行中" },
+  { key: "pending", label: "待处理" },
+  { key: "done", label: "已完成" },
+  { key: "blocked", label: "阻塞" },
+  { key: "failed", label: "失败" },
+];
+
+const KEYBOARD_HELP = [
+  "←/→ 切换仓库",
+  "↑/↓ 滚动",
+  "1-9 直达仓库",
+  "r 刷新",
+  "q 退出",
+];
+
+function truncateText(text, maxWidth) {
+  if (maxWidth <= 0) {
+    return "";
+  }
+  const normalized = String(text || "").replace(/\s+/gu, " ").trim();
+  if (normalized.length <= maxWidth) {
+    return normalized.padEnd(maxWidth, " ");
+  }
+  if (maxWidth <= 1) {
+    return normalized.slice(0, maxWidth);
+  }
+  return `${normalized.slice(0, Math.max(0, maxWidth - 1))}…`;
+}
+
+function repeat(char, count) {
+  return count > 0 ? char.repeat(count) : "";
+}
+
+function normalizeSelectedIndex(snapshot, currentIndex) {
+  if (!snapshot.sessions.length) {
+    return 0;
+  }
+  const bounded = Number(currentIndex || 0);
+  if (!Number.isFinite(bounded) || bounded < 0) {
+    return 0;
+  }
+  return Math.min(bounded, snapshot.sessions.length - 1);
+}
+
+function groupTasks(session) {
+  const grouped = new Map(STATUS_GROUPS.map((item) => [item.key, []]));
+  for (const task of Array.isArray(session?.tasks) ? session.tasks : []) {
+    const status = String(task.status || "pending");
+    const bucket = grouped.get(status) || grouped.get("pending");
+    bucket.push(task);
+  }
+  return grouped;
+}
+
+function renderRepoTabs(snapshot, selectedIndex, width) {
+  const tabs = snapshot.sessions.map((session, index) => {
+    const active = index === selectedIndex ? "*" : " ";
+    const task = session.latestStatus?.taskTitle || session.nextTask?.title || "无任务";
+    return `${active}${index + 1}.${session.repoName} ${session.runtime?.status || "idle"} ${task}`;
+  });
+
+  const line = tabs.join("  |  ");
+  return truncateText(line, width);
+}
+
+function buildSessionMetaLines(session, width) {
+  const lines = [
+    `仓库：${session.repoRoot}`,
+    `会话：${session.sessionId}`,
+    `当前任务：${session.latestStatus?.taskTitle || "无"}`,
+    `运行状态：${session.runtime?.status || "idle"}${Number.isFinite(Number(session.runtime?.heartbeat?.idleSeconds)) && Number(session.runtime?.heartbeat?.idleSeconds) > 0 ? ` | idle=${session.runtime.heartbeat.idleSeconds}s` : ""}`,
+    `当前动作：${session.activity?.current?.label || session.latestStatus?.message || session.runtime?.failureReason || "等待新事件"}`,
+    `backlog：总计 ${session.summary?.total || 0} / 待处理 ${session.summary?.pending || 0} / 进行中 ${session.summary?.inProgress || 0} / 已完成 ${session.summary?.done || 0} / 阻塞 ${session.summary?.blocked || 0} / 失败 ${session.summary?.failed || 0}`,
+  ];
+
+  return lines.map((line) => truncateText(line, width));
+}
+
+function renderTaskLine(task, width) {
+  const meta = `[${task.priority || "P2"}|${task.risk || "low"}]`;
+  return truncateText(`${meta} ${task.title}`, width);
+}
+
+function renderTaskSections(session, width) {
+  const sections = [];
+  const grouped = groupTasks(session);
+
+  for (const statusGroup of STATUS_GROUPS) {
+    const tasks = grouped.get(statusGroup.key) || [];
+    sections.push(`${statusGroup.label} (${tasks.length})`);
+    if (!tasks.length) {
+      sections.push("  - 无");
+      sections.push("");
+      continue;
+    }
+
+    for (const task of tasks) {
+      sections.push(`  - ${renderTaskLine(task, Math.max(10, width - 4))}`);
+    }
+    sections.push("");
+  }
+
+  return sections;
+}
+
+function renderEmptyState(width, height, message) {
+  const lines = [
+    "HelloLoop TUI Dashboard",
+    repeat("=", Math.max(20, Math.min(width, 40))),
+    "",
+    message,
+  ];
+  while (lines.length < height) {
+    lines.push("");
+  }
+  return lines.slice(0, height).map((line) => truncateText(line, width)).join("\n");
+}
+
+function renderTui(snapshot, state) {
+  const width = Math.max(60, Number(process.stdout.columns || 120));
+  const height = Math.max(24, Number(process.stdout.rows || 40));
+
+  if (!snapshot.sessions.length) {
+    return renderEmptyState(width, height, "当前没有已登记仓库或后台会话。");
+  }
+
+  const selectedIndex = normalizeSelectedIndex(snapshot, state.selectedIndex);
+  const selectedSession = snapshot.sessions[selectedIndex];
+  const lines = [
+    truncateText(`HelloLoop TUI Dashboard | 仓库 ${snapshot.repoCount || 0} | 活跃会话 ${snapshot.activeCount || 0} | 任务总计 ${snapshot.taskTotals?.total || 0} | 待处理 ${snapshot.taskTotals?.pending || 0} | 进行中 ${snapshot.taskTotals?.inProgress || 0} | 已完成 ${snapshot.taskTotals?.done || 0}`, width),
+    truncateText(`更新时间：${snapshot.generatedAt} | 键位：${KEYBOARD_HELP.join(" / ")}`, width),
+    repeat("─", width),
+    renderRepoTabs(snapshot, selectedIndex, width),
+    repeat("─", width),
+    ...buildSessionMetaLines(selectedSession, width),
+    repeat("─", width),
+  ];
+
+  const contentLines = renderTaskSections(selectedSession, width);
+  const availableContentHeight = Math.max(1, height - lines.length - 1);
+  const maxOffset = Math.max(0, contentLines.length - availableContentHeight);
+  const scrollOffset = Math.min(Math.max(0, Number(state.scrollOffset || 0)), maxOffset);
+
+  const visibleContent = contentLines.slice(scrollOffset, scrollOffset + availableContentHeight);
+  const footer = truncateText(
+    `仓库 ${selectedIndex + 1}/${snapshot.sessions.length} | 滚动 ${scrollOffset + 1}-${Math.min(contentLines.length, scrollOffset + visibleContent.length)}/${contentLines.length}`,
+    width,
+  );
+
+  while (visibleContent.length < availableContentHeight) {
+    visibleContent.push("");
+  }
+
+  return [...lines, ...visibleContent, footer]
+    .slice(0, height)
+    .map((line) => truncateText(line, width))
+    .join("\n");
+}
+
+function applyInputKey(buffer, state, snapshot) {
+  const input = String(buffer || "");
+  if (!input) {
+    return false;
+  }
+
+  if (input === "\u0003" || input === "q") {
+    state.running = false;
+    return true;
+  }
+  if (input === "r") {
+    state.forceRefresh = true;
+    return true;
+  }
+  if (input === "\u001b[C") {
+    state.selectedIndex = Math.min(snapshot.sessions.length - 1, state.selectedIndex + 1);
+    state.scrollOffset = 0;
+    return true;
+  }
+  if (input === "\u001b[D") {
+    state.selectedIndex = Math.max(0, state.selectedIndex - 1);
+    state.scrollOffset = 0;
+    return true;
+  }
+  if (input === "\u001b[A") {
+    state.scrollOffset = Math.max(0, state.scrollOffset - 1);
+    return true;
+  }
+  if (input === "\u001b[B") {
+    state.scrollOffset += 1;
+    return true;
+  }
+
+  const digit = Number.parseInt(input, 10);
+  if (Number.isInteger(digit) && digit > 0 && digit <= snapshot.sessions.length) {
+    state.selectedIndex = digit - 1;
+    state.scrollOffset = 0;
+    return true;
+  }
+
+  return false;
+}
+
+function enterAlternateScreen() {
+  process.stdout.write("\x1b[?1049h\x1b[?25l");
+}
+
+function leaveAlternateScreen() {
+  process.stdout.write("\x1b[?25h\x1b[?1049l");
+}
+
+export async function runDashboardTuiCommand(options = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("HelloLoop TUI 需要在真实终端中运行。");
+  }
+
+  const pollMs = Math.max(500, Number(options.pollMs || options.watchPollMs || 1500));
+  const observerRetry = loadRuntimeSettings({
+    globalConfigFile: options.globalConfigFile,
+  }).observerRetry;
+
+  const state = {
+    running: true,
+    selectedIndex: 0,
+    scrollOffset: 0,
+    forceRefresh: true,
+  };
+  let lastFrame = "";
+  let retryCount = 0;
+  let lastSnapshot = collectDashboardSnapshot();
+
+  const onData = (buffer) => {
+    applyInputKey(buffer, state, lastSnapshot);
+  };
+
+  enterAlternateScreen();
+  process.stdin.setEncoding("utf8");
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on("data", onData);
+
+  try {
+    while (state.running) {
+      try {
+        lastSnapshot = collectDashboardSnapshot();
+        retryCount = 0;
+      } catch (error) {
+        const nextAttempt = retryCount + 1;
+        if (!observerRetry.enabled || !hasRetryBudget(observerRetry.maxRetryCount, nextAttempt)) {
+          throw error;
+        }
+
+        const delaySeconds = pickRetryDelaySeconds(observerRetry.retryDelaysSeconds, nextAttempt);
+        const frame = renderEmptyState(
+          Math.max(60, Number(process.stdout.columns || 120)),
+          Math.max(24, Number(process.stdout.rows || 40)),
+          `看板采集失败，将在 ${delaySeconds} 秒后自动重试（第 ${nextAttempt} 次）：${String(error?.message || error || "unknown error")}`,
+        );
+        process.stdout.write("\x1b[H\x1b[2J");
+        process.stdout.write(frame);
+        retryCount = nextAttempt;
+        await sleep(delaySeconds * 1000);
+        continue;
+      }
+
+      const frame = renderTui(lastSnapshot, state);
+      if (frame !== lastFrame || state.forceRefresh) {
+        process.stdout.write("\x1b[H\x1b[2J");
+        process.stdout.write(frame);
+        lastFrame = frame;
+        state.forceRefresh = false;
+      }
+
+      await sleep(pollMs);
+    }
+  } finally {
+    process.stdin.off("data", onData);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    leaveAlternateScreen();
+  }
+
+  return 0;
+}