helloloop 0.9.1 → 0.10.0

package/src/activity_projection.mjs

@@ -0,0 +1,294 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { appendText, fileExists, nowIso, readJson, writeJson } from "./common.mjs";
+import { parseCodexJsonlEventLine } from "./engine_event_parser_codex.mjs";
+
+const RECENT_EVENTS_LIMIT = 24;
+const RECENT_REASONING_LIMIT = 8;
+const RECENT_COMMANDS_LIMIT = 10;
+const RECENT_FILE_CHANGES_LIMIT = 10;
+
+function limitList(list, maxLength) {
+  if (list.length > maxLength) {
+    list.splice(0, list.length - maxLength);
+  }
+}
+
+function readDirEntriesSafe(dirPath) {
+  try {
+    return fs.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function collectArtifactCandidates(runDir, suffix) {
+  if (!runDir || !fileExists(runDir)) {
+    return [];
+  }
+
+  const candidates = [];
+  for (const entry of readDirEntriesSafe(runDir)) {
+    const fullPath = path.join(runDir, entry.name);
+    if (entry.isFile() && entry.name.endsWith(suffix)) {
+      candidates.push(fullPath);
+      continue;
+    }
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    for (const nestedEntry of readDirEntriesSafe(fullPath)) {
+      if (nestedEntry.isFile() && nestedEntry.name.endsWith(suffix)) {
+        candidates.push(path.join(fullPath, nestedEntry.name));
+      }
+    }
+  }
+
+  return candidates.sort((left, right) => fs.statSync(right).mtimeMs - fs.statSync(left).mtimeMs);
+}
+
+function relativeToRepo(repoRoot, targetPath) {
+  const normalized = String(targetPath || "").trim();
+  if (!normalized) {
+    return "";
+  }
+  return path.isAbsolute(normalized)
+    ? path.relative(repoRoot, normalized).replaceAll("\\", "/")
+    : normalized.replaceAll("\\", "/");
+}
+
+function compactEvent(event, repoRoot) {
+  return {
+    kind: event.kind,
+    itemId: event.itemId || "",
+    status: event.status || "",
+    label: event.label || "",
+    exitCode: event.exitCode ?? null,
+    summary: event.summary || event.outputSummary || "",
+    changes: Array.isArray(event.changes)
+      ? event.changes.map((change) => ({
+        path: relativeToRepo(repoRoot, change.path),
+        kind: change.kind,
+      }))
+      : [],
+    updatedAt: nowIso(),
+  };
+}
+
+function createBaseSnapshot(options) {
+  return {
+    schemaVersion: 1,
+    engine: options.engine || "",
+    phase: options.phase || "",
+    repoRoot: options.repoRoot || "",
+    runDir: options.runDir || "",
+    outputPrefix: options.outputPrefix || "",
+    attemptPrefix: options.attemptPrefix || "",
+    activityFile: options.activityFile || "",
+    activityEventsFile: options.activityEventsFile || "",
+    status: "running",
+    threadId: "",
+    current: {
+      kind: "",
+      status: "",
+      label: "",
+      itemId: "",
+    },
+    todo: {
+      total: 0,
+      completed: 0,
+      pending: 0,
+      items: [],
+    },
+    activeCommands: [],
+    recentCommands: [],
+    recentReasoning: [],
+    recentFileChanges: [],
+    recentEvents: [],
+    runtime: {},
+    finalMessage: "",
+    code: null,
+    startedAt: nowIso(),
+    updatedAt: nowIso(),
+  };
+}
+
+function resolveParser(engine) {
+  return engine === "codex" ? parseCodexJsonlEventLine : null;
+}
+
+export function readJsonIfExists(filePath) {
+  if (!filePath || !fileExists(filePath)) {
+    return null;
+  }
+  try {
+    return readJson(filePath);
+  } catch {
+    return null;
+  }
+}
+
+export function selectLatestRuntimeFile(runDir) {
+  return collectArtifactCandidates(runDir, "-runtime.json")[0] || "";
+}
+
+export function selectLatestActivityFile(runDir, attemptPrefix = "") {
+  if (attemptPrefix) {
+    const namedCandidates = collectArtifactCandidates(runDir, `${attemptPrefix}-activity.json`);
+    if (namedCandidates[0]) {
+      return namedCandidates[0];
+    }
+  }
+  return collectArtifactCandidates(runDir, "-activity.json")[0] || "";
+}
+
+export function createActivityProjector(options = {}) {
+  const parser = resolveParser(options.engine);
+  const activityFile = options.activityFile || path.join(options.runDir, `${options.attemptPrefix}-activity.json`);
+  const activityEventsFile = options.activityEventsFile || path.join(options.runDir, `${options.attemptPrefix}-activity.jsonl`);
+  const snapshot = createBaseSnapshot({
+    ...options,
+    activityFile,
+    activityEventsFile,
+  });
+  const activeCommands = new Map();
+  let stdoutBuffer = "";
+
+  const persistSnapshot = () => {
+    snapshot.updatedAt = nowIso();
+    snapshot.activeCommands = [...activeCommands.values()];
+    writeJson(activityFile, snapshot);
+  };
+
+  const appendActivityEvent = (event) => {
+    const compact = compactEvent(event, snapshot.repoRoot);
+    snapshot.current = {
+      kind: compact.kind,
+      status: compact.status,
+      label: compact.label,
+      itemId: compact.itemId,
+    };
+    snapshot.recentEvents.push(compact);
+    limitList(snapshot.recentEvents, RECENT_EVENTS_LIMIT);
+
+    if (compact.kind === "thread" && event.threadId) {
+      snapshot.threadId = event.threadId;
+    }
+
+    if (compact.kind === "todo" && event.todo) {
+      snapshot.todo = {
+        ...event.todo,
+        items: Array.isArray(event.todo.items) ? event.todo.items : [],
+      };
+    }
+
+    if (compact.kind === "reasoning" && compact.label) {
+      snapshot.recentReasoning.push({
+        label: compact.label,
+        status: compact.status,
+        updatedAt: compact.updatedAt,
+      });
+      limitList(snapshot.recentReasoning, RECENT_REASONING_LIMIT);
+    }
+
+    if (compact.kind === "command") {
+      const previous = activeCommands.get(compact.itemId) || {};
+      const next = {
+        id: compact.itemId,
+        label: compact.label,
+        status: compact.status,
+        exitCode: compact.exitCode,
+        summary: compact.summary,
+        startedAt: previous.startedAt || compact.updatedAt,
+        updatedAt: compact.updatedAt,
+      };
+      if (compact.status === "in_progress") {
+        activeCommands.set(compact.itemId, next);
+      } else {
+        activeCommands.delete(compact.itemId);
+        snapshot.recentCommands.push({
+          ...previous,
+          ...next,
+          completedAt: compact.updatedAt,
+        });
+        limitList(snapshot.recentCommands, RECENT_COMMANDS_LIMIT);
+      }
+    }
+
+    if (compact.kind === "file_change") {
+      snapshot.recentFileChanges.push({
+        label: compact.label,
+        status: compact.status,
+        changes: compact.changes,
+        updatedAt: compact.updatedAt,
+      });
+      limitList(snapshot.recentFileChanges, RECENT_FILE_CHANGES_LIMIT);
+    }
+
+    appendText(activityEventsFile, `${JSON.stringify(compact)}\n`);
+    persistSnapshot();
+  };
+
+  const consumeStdoutLine = (line) => {
+    if (!parser || !line) {
+      return;
+    }
+    try {
+      const event = parser(line);
+      if (event) {
+        appendActivityEvent(event);
+      }
+    } catch {
+      // Ignore non-JSON diagnostic lines from the engine output.
+    }
+  };
+
+  return {
+    activityFile,
+    activityEventsFile,
+    onStdoutChunk(text) {
+      if (!parser || !text) {
+        return;
+      }
+      stdoutBuffer += text;
+      while (stdoutBuffer.includes("\n")) {
+        const newlineIndex = stdoutBuffer.indexOf("\n");
+        const line = stdoutBuffer.slice(0, newlineIndex).trim();
+        stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
+        consumeStdoutLine(line);
+      }
+    },
+    onRuntimeStatus(payload = {}) {
+      snapshot.status = String(payload.status || snapshot.status || "running").trim() || "running";
+      snapshot.runtime = {
+        ...snapshot.runtime,
+        ...payload,
+      };
+      persistSnapshot();
+    },
+    finalize(payload = {}) {
+      if (stdoutBuffer.trim()) {
+        consumeStdoutLine(stdoutBuffer.trim());
+      }
+      stdoutBuffer = "";
+      const finalStatus = String(
+        payload.status
+        || (payload.result ? (payload.result.ok ? "completed" : "failed") : snapshot.status)
+        || "completed",
+      ).trim();
+      snapshot.status = finalStatus || snapshot.status;
+      snapshot.finalMessage = String(payload.finalMessage || snapshot.finalMessage || "").trim();
+      if (payload.result) {
+        const code = Number(payload.result.code);
+        snapshot.code = Number.isFinite(code) ? code : snapshot.code;
+        snapshot.runtime = {
+          ...snapshot.runtime,
+          watchdogTriggered: payload.result.watchdogTriggered === true,
+          leaseExpired: payload.result.leaseExpired === true,
+        };
+      }
+      persistSnapshot();
+    },
+  };
+}

package/src/analyze_confirmation.mjs

@@ -1,6 +1,7 @@
 import path from "node:path";
 
 import { renderInputIssueLines, renderUserIntentLines } from "./analyze_user_input.mjs";
+import { resolveFullAutoMainlineOptions } from "./auto_execution_options.mjs";
 import { analyzeExecution, summarizeBacklog } from "./backlog.mjs";
 import { loadPolicy, loadVerifyCommands } from "./config.mjs";
 import { getEngineDisplayName } from "./engine_metadata.mjs";
@@ -167,7 +168,7 @@ export function resolveAutoRunMaxTasks(backlog, options = {}) {
 
 export function renderAnalyzeConfirmation(context, analysis, backlog, options = {}, discovery = {}) {
   const summary = summarizeBacklog(backlog);
-  const execution = analyzeExecution(backlog, options);
+  const execution = analyzeExecution(backlog, resolveFullAutoMainlineOptions(options));
   const policy = loadPolicy(context);
   const verifyCommands = resolvePreviewVerifyCommands(context, execution);
   const autoRunMaxTasks = resolveAutoRunMaxTasks(backlog, options);
@@ -213,6 +214,7 @@ export function renderAnalyzeConfirmation(context, analysis, backlog, options =
     execution.blockedReason
       ? `- 当前阻塞：${execution.blockedReason}`
       : "- 当前阻塞：无",
+    "- 风险策略：确认后进入主线自动执行时，medium/high/critical 任务不会单独卡住续跑；手动 run-once/run-loop 仍需显式允许高风险",
     "- 偏差修正：按 backlog 优先级执行；如果分析识别出偏差修正任务，会先收口再继续后续开发",
     autoRunMaxTasks > 0
       ? `- 自动推进：最多 ${autoRunMaxTasks} 个任务；若主线终态复核仍发现缺口，则到达上限后暂停`

package/src/analyzer.mjs

@@ -16,6 +16,7 @@ import {
   rememberEngineSelection,
   resolveEngineSelection,
 } from "./engine_selection.mjs";
+import { shouldPromptForEngineSelection } from "./execution_interactivity.mjs";
 import {
   buildAnalysisSummaryText,
   buildCurrentWorkspaceDiscovery,
@@ -36,7 +37,7 @@ async function analyzeResolvedWorkspace(context, discovery, options = {}) {
       context,
       policy,
       options,
-      interactive: !options.yes,
+      interactive: shouldPromptForEngineSelection(options),
     });
   if (!engineResolution.ok) {
     return {

package/src/auto_execution_options.mjs

@@ -0,0 +1,13 @@
+/**
+ * Full-auto mainline begins only after the user has explicitly approved the
+ * analyze confirmation. Once that approval exists, HelloLoop should continue
+ * the backlog instead of stopping at medium/high/critical risk gates that are
+ * meant for manual run-once / run-loop invocations.
+ */
+export function resolveFullAutoMainlineOptions(options = {}) {
+  return {
+    ...options,
+    allowHighRisk: true,
+    fullAutoMainline: true,
+  };
+}

package/src/background_launch.mjs

@@ -0,0 +1,73 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { ensureDir, timestampForFile } from "./common.mjs";
+import { createContext } from "./context.mjs";
+import { spawnNodeProcess } from "./node_process_launch.mjs";
+
+export const HELLOLOOP_BACKGROUND_LAUNCH_ENV = "HELLOLOOP_BACKGROUND_LAUNCH_ACTIVE";
+
+function isDetachedAnalyzeCommand(command, options = {}) {
+  return command === "analyze"
+    && options.detach === true
+    && options.yes === true
+    && options.watch !== true;
+}
+
+export function shouldUseDetachedBackgroundLaunch(command, options = {}) {
+  return process.platform === "win32"
+    && process.env.HELLOLOOP_SUPERVISOR_ACTIVE !== "1"
+    && process.env[HELLOLOOP_BACKGROUND_LAUNCH_ENV] !== "1"
+    && isDetachedAnalyzeCommand(command, options);
+}
+
+function resolveLaunchFiles(options = {}) {
+  const context = createContext({
+    repoRoot: options.repoRoot || process.cwd(),
+    configDirName: options.configDirName,
+  });
+  const launcherRoot = path.join(context.configRoot, "launcher");
+  ensureDir(launcherRoot);
+
+  const stamp = timestampForFile();
+  return {
+    launcherRoot,
+    stdoutFile: path.join(launcherRoot, `${stamp}-analyze-stdout.log`),
+    stderrFile: path.join(launcherRoot, `${stamp}-analyze-stderr.log`),
+  };
+}
+
+export function launchDetachedBackgroundCli(argv, options = {}) {
+  const context = createContext({
+    repoRoot: options.repoRoot || process.cwd(),
+    configDirName: options.configDirName,
+  });
+  const files = resolveLaunchFiles(options);
+  const stdoutFd = fs.openSync(files.stdoutFile, "w");
+  const stderrFd = fs.openSync(files.stderrFile, "w");
+
+  try {
+    const child = spawnNodeProcess({
+      args: [
+        path.join(context.bundleRoot, "bin", "helloloop.js"),
+        ...argv,
+      ],
+      cwd: process.cwd(),
+      detached: true,
+      stdio: ["ignore", stdoutFd, stderrFd],
+      env: {
+        [HELLOLOOP_BACKGROUND_LAUNCH_ENV]: "1",
+      },
+    });
+    child.unref();
+    return {
+      pid: child.pid ?? 0,
+      stdoutFile: files.stdoutFile,
+      stderrFile: files.stderrFile,
+      launcherRoot: files.launcherRoot,
+    };
+  } finally {
+    fs.closeSync(stdoutFd);
+    fs.closeSync(stderrFd);
+  }
+}

package/src/cli.mjs

@@ -3,18 +3,29 @@ import { printHelp, parseArgs } from "./cli_args.mjs";
 import { handleAnalyzeCommand } from "./cli_analyze_command.mjs";
 import {
   handleDoctorCommand,
+  handleDashboardCommand,
   handleInitCommand,
   handleInstallCommand,
   handleNextCommand,
+  handleResumeHostCommand,
   handleRunLoopCommand,
   handleRunOnceCommand,
   handleStatusCommand,
+  handleTuiCommand,
   handleUninstallCommand,
+  handleWebCommand,
   handleWatchCommand,
 } from "./cli_command_handlers.mjs";
 import { resolveContextFromOptions, resolveStandardCommandOptions } from "./cli_context.mjs";
 import { runDoctor } from "./cli_support.mjs";
+import { runSupervisorGuardianFromSessionFile } from "./supervisor_guardian.mjs";
+import { runDashboardWebCommand } from "./dashboard_web.mjs";
 import { runSupervisedCommandFromSessionFile } from "./supervisor_runtime.mjs";
+import {
+  launchDetachedBackgroundCli,
+  shouldUseDetachedBackgroundLaunch,
+  HELLOLOOP_BACKGROUND_LAUNCH_ENV,
+} from "./background_launch.mjs";
 import {
   acquireVisibleTerminalSession,
   releaseCurrentTerminalSession,
@@ -33,11 +44,34 @@ export async function runCli(argv) {
       if (!parsed.options.sessionFile) {
         throw new Error("缺少 --session-file，无法启动 HelloLoop supervisor。");
       }
+      await runSupervisorGuardianFromSessionFile(parsed.options.sessionFile);
+      return;
+    }
+    if (command === "__supervise-worker") {
+      if (!parsed.options.sessionFile) {
+        throw new Error("缺少 --session-file，无法启动 HelloLoop supervisor worker。");
+      }
       await runSupervisedCommandFromSessionFile(parsed.options.sessionFile);
       return;
     }
+    if (command === "__web-server") {
+      process.exitCode = await runDashboardWebCommand({
+        ...parsed.options,
+        foreground: true,
+      });
+      return;
+    }
+
+    if (shouldUseDetachedBackgroundLaunch(command, parsed.options)) {
+      launchDetachedBackgroundCli(argv, parsed.options);
+      return;
+    }
 
-    if (process.env.HELLOLOOP_SUPERVISOR_ACTIVE !== "1" && shouldTrackVisibleTerminalCommand(command)) {
+    if (
+      process.env.HELLOLOOP_SUPERVISOR_ACTIVE !== "1"
+      && process.env[HELLOLOOP_BACKGROUND_LAUNCH_ENV] !== "1"
+      && shouldTrackVisibleTerminalCommand(command)
+    ) {
       acquireVisibleTerminalSession({
         command,
         repoRoot: process.cwd(),
@@ -59,11 +93,25 @@ export async function runCli(argv) {
       return;
     }
 
+    if (command === "dashboard") {
+      process.exitCode = await handleDashboardCommand(options);
+      return;
+    }
+    if (command === "tui") {
+      process.exitCode = await handleTuiCommand(options);
+      return;
+    }
+    if (command === "web") {
+      process.exitCode = await handleWebCommand(options);
+      return;
+    }
+
     const context = resolveContextFromOptions(options);
     const handlers = {
       doctor: () => handleDoctorCommand(context, options, runDoctor),
       init: () => handleInitCommand(context),
       next: () => handleNextCommand(context, options),
+      "resume-host": () => handleResumeHostCommand(context, options),
       "run-loop": () => handleRunLoopCommand(context, options),
       "run-once": () => handleRunOnceCommand(context, options),
       status: () => handleStatusCommand(context, options),

package/src/cli_analyze_command.mjs

@@ -15,10 +15,12 @@ import { loadPolicy } from "./config.mjs";
 import { createContext } from "./context.mjs";
 import { createDiscoveryPromptSession, resolveDiscoveryFailureInteractively } from "./discovery_prompt.mjs";
 import { resolveEngineSelection } from "./engine_selection.mjs";
+import { shouldPromptForEngineSelection } from "./execution_interactivity.mjs";
 import { resetRepoForRebuild } from "./rebuild.mjs";
 import { renderRebuildSummary } from "./cli_render.mjs";
 import { shouldConfirmRepoRebuild } from "./cli_support.mjs";
 import { launchAndMaybeWatchSupervisedCommand } from "./supervisor_cli_support.mjs";
+import { resolveFullAutoMainlineOptions } from "./auto_execution_options.mjs";
 
 async function resolveAnalyzeEngineSelection(options) {
   if (options.engineResolution?.ok) {
@@ -33,7 +35,7 @@ async function resolveAnalyzeEngineSelection(options) {
     context: provisionalContext,
     policy: loadPolicy(provisionalContext),
     options,
-    interactive: !options.yes,
+    interactive: shouldPromptForEngineSelection(options),
   });
 }
 
@@ -202,7 +204,11 @@ async function prepareAnalyzeExecution(initialOptions) {
 }
 
 async function maybeRunAutoExecution(result, activeOptions) {
-  const execution = analyzeExecution(result.backlog, activeOptions);
+  const autoOptions = resolveFullAutoMainlineOptions({
+    ...activeOptions,
+    engineResolution: result.engineResolution?.ok ? result.engineResolution : activeOptions.engineResolution,
+  });
+  const execution = analyzeExecution(result.backlog, autoOptions);
 
   if (activeOptions.dryRun) {
     console.log("已按 --dry-run 跳过自动执行。");
@@ -222,10 +228,8 @@ async function maybeRunAutoExecution(result, activeOptions) {
   console.log("");
   console.log("开始自动接续执行...");
   const payload = await launchAndMaybeWatchSupervisedCommand(result.context, "run-loop", {
-    ...activeOptions,
-    engineResolution: result.engineResolution?.ok ? result.engineResolution : activeOptions.engineResolution,
+    ...autoOptions,
     maxTasks: resolveAutoRunMaxTasks(result.backlog, activeOptions) || undefined,
-    fullAutoMainline: true,
   });
   return payload.exitCode || 0;
 }