@h-rig/run-plugin 0.0.6-alpha.186

package/dist/src/read-model/read-model-backend/run-status.js

@@ -0,0 +1,237 @@
+// @bun
+// packages/run-plugin/src/read-model/read-model-backend/run-status.ts
+var OPERATOR_INACTIVE_RUN_STATUSES = new Set([
+  "completed",
+  "complete",
+  "done",
+  "success",
+  "succeeded",
+  "passed",
+  "failed",
+  "failure",
+  "error",
+  "errored",
+  "stopped",
+  "cancelled",
+  "canceled",
+  "aborted",
+  "abort",
+  "merged",
+  "closed",
+  "skipped",
+  "needs-attention",
+  "needs_attention"
+]);
+var TERMINAL_RUN_STATUSES = ["completed", "failed", "stopped"];
+var RUNTIME_ACTIVE_STATUSES = new Set([
+  "created",
+  "preparing",
+  "running",
+  "validating",
+  "reviewing",
+  "closing-out"
+]);
+var ACTIVE_RUN_STATUSES = [
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "paused",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "needs-attention"
+];
+var KNOWN_RUN_STATUS = Object.fromEntries([...ACTIVE_RUN_STATUSES, ...TERMINAL_RUN_STATUSES].map((status) => [status, true]));
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+function isActiveRunStatus(status) {
+  return !isTerminalRunStatus(status);
+}
+function isRuntimeActiveStatus(status) {
+  return RUNTIME_ACTIVE_STATUSES.has(normalizeRunStatusToken(status));
+}
+function normalizeRunStatusToken(status) {
+  return String(status ?? "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+function isOperatorActiveRunStatus(status) {
+  const normalized = normalizeRunStatusToken(status);
+  if (!normalized)
+    return false;
+  return !OPERATOR_INACTIVE_RUN_STATUSES.has(normalized);
+}
+function canonicalStatusToken(status) {
+  const normalized = normalizeRunStatusToken(status);
+  if (normalized === "waiting-input")
+    return "waiting-user-input";
+  return normalized;
+}
+function asRunStatus(status) {
+  return KNOWN_RUN_STATUS[status] ? status : null;
+}
+function statusColorRole(status) {
+  switch (canonicalStatusToken(status)) {
+    case "done":
+    case "completed":
+    case "ready":
+    case "healthy":
+    case "approved":
+    case "merged":
+      return "success";
+    case "needs-attention":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "blocked":
+    case "paused":
+      return "action-yellow";
+    case "running":
+    case "adopted":
+    case "preparing":
+    case "created":
+    case "queued":
+    case "starting":
+    case "pending":
+    case "in-progress":
+    case "active":
+    case "booting":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "active-cyan";
+    case "failed":
+    case "error":
+    case "rejected":
+      return "failure";
+    case "stopped":
+    case "cancelled":
+    case "canceled":
+    case "stale":
+      return "muted";
+    default:
+      return "neutral";
+  }
+}
+function isNeedsAttention(run) {
+  return canonicalStatusToken(run.status) === "needs-attention" || run.pendingApprovals + run.pendingInputs > 0 || run.stallCount > 0;
+}
+function phaseForStatus(status, runStatus, needsAttention) {
+  if (runStatus && isTerminalRunStatus(runStatus))
+    return runStatus === "completed" || runStatus === "failed" || runStatus === "stopped" ? runStatus : "stopped";
+  if (needsAttention)
+    return "needs-attention";
+  switch (status) {
+    case "created":
+    case "queued":
+    case "preparing":
+    case "starting":
+    case "booting":
+      return "starting";
+    case "waiting-approval":
+    case "waiting-user-input":
+      return "waiting";
+    case "paused":
+      return "paused";
+    case "running":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "active";
+    default:
+      return runStatus && isActiveRunStatus(runStatus) ? "active" : "unknown";
+  }
+}
+function classifyRun(run) {
+  const status = canonicalStatusToken(run.status) || (run.live && !run.stale ? "starting" : "unknown");
+  const runStatus = asRunStatus(status);
+  const isTerminal = runStatus ? isTerminalRunStatus(runStatus) : false;
+  const isNeedsAttentionValue = isNeedsAttention(run);
+  const phase = phaseForStatus(status, runStatus, isNeedsAttentionValue);
+  return {
+    status,
+    runStatus: runStatus ?? "needs-attention",
+    phase,
+    isActive: runStatus ? isActiveRunStatus(runStatus) : !isTerminal && status !== "unknown",
+    isTerminal,
+    isNeedsAttention: isNeedsAttentionValue,
+    offersRecovery: phase === "failed"
+  };
+}
+function runStatusText(run) {
+  return classifyRun(run).status;
+}
+function runStatusColorRole(run) {
+  const classification = classifyRun(run);
+  return classification.isNeedsAttention && !classification.isTerminal ? "action-yellow" : statusColorRole(classification.status);
+}
+function statusRank(run) {
+  const classification = classifyRun(run);
+  if (classification.isNeedsAttention)
+    return 0;
+  switch (classification.phase) {
+    case "needs-attention":
+      return 0;
+    case "active":
+    case "waiting":
+    case "paused":
+      return 1;
+    case "starting":
+      return 2;
+    case "completed":
+      return 3;
+    case "failed":
+      return 4;
+    case "stopped":
+      return 5;
+    case "unknown":
+      return 6;
+  }
+}
+function isSteerableStatus(status) {
+  switch (status) {
+    case "needs-attention":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "paused":
+      return false;
+    default: {
+      const runStatus = asRunStatus(status);
+      return runStatus ? isActiveRunStatus(runStatus) : false;
+    }
+  }
+}
+function canSteer(run) {
+  const classification = classifyRun(run);
+  if (classification.phase === "active" || classification.phase === "starting")
+    return true;
+  return classification.isNeedsAttention && isSteerableStatus(classification.status);
+}
+function canStop(run) {
+  const classification = classifyRun(run);
+  return classification.isActive && !classification.isTerminal;
+}
+function canPause(run) {
+  const phase = classifyRun(run).phase;
+  return phase === "active" || phase === "starting";
+}
+function canResume(run) {
+  return classifyRun(run).phase === "paused";
+}
+export {
+  statusRank,
+  statusColorRole,
+  runStatusText,
+  runStatusColorRole,
+  normalizeRunStatusToken,
+  isRuntimeActiveStatus,
+  isOperatorActiveRunStatus,
+  isNeedsAttention,
+  classifyRun,
+  canStop,
+  canSteer,
+  canResume,
+  canPause,
+  asRunStatus
+};

package/dist/src/read-model/read-model-backend/stats.d.ts

@@ -0,0 +1,12 @@
+import type { RigStatsData } from "@rig/contracts";
+import type { RunRecord } from "./projection";
+export { isNeedsAttention } from "./run-status";
+type ListRunsFn = (projectRoot: string) => Promise<readonly RunRecord[]>;
+export declare function parseTimestamp(value: string | null | undefined): number | null;
+export declare function median(values: readonly number[]): number | null;
+export declare function rate(part: number, total: number): number | null;
+export declare function completedDuration(run: RunRecord): number | null;
+export declare function computeStats(projectRootOrRuns: string | readonly RunRecord[], options?: {
+    since?: Date | null;
+    listRuns?: ListRunsFn;
+}): Promise<RigStatsData>;