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

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

@@ -0,0 +1,9 @@
+import type { RunJournalProjection } from "@rig/contracts";
+/**
+ * Extract the most useful human-facing failure diagnostic from the folded run journal.
+ *
+ * The live projection deliberately does not retain log/timeline lines, so this mirrors the
+ * deleted server-side categorization using only fields that survive folding: record fields,
+ * status reasons, closeout details, and reducer anomalies.
+ */
+export declare function summarizeRunError(projection: RunJournalProjection): string | null;

package/dist/src/read-model/read-model-backend/diagnostics.js

@@ -0,0 +1,51 @@
+// @bun
+// packages/run-plugin/src/read-model/read-model-backend/diagnostics.ts
+function normalizeString(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function isGenericRunFailure(value) {
+  const text = normalizeString(value);
+  return Boolean(text && /^Task run failed \([^)]*\)$/i.test(text));
+}
+function appendCandidate(candidates, value) {
+  const text = normalizeString(value);
+  if (text && !candidates.includes(text))
+    candidates.push(text);
+}
+function categorizeUsefulRunError(lines) {
+  const taskSourceFailure = lines.find((line) => /failed to update task source/i.test(line));
+  if (taskSourceFailure)
+    return `Task source update failed: ${taskSourceFailure}`;
+  const moduleFailure = lines.find((line) => /cannot find module/i.test(line));
+  if (moduleFailure)
+    return `Runtime module resolution failed: ${moduleFailure}`;
+  const providerFailure = lines.find((line) => /no api key found|unauthorized|authentication failed|invalid api key/i.test(line));
+  if (providerFailure)
+    return `Provider authentication failed: ${providerFailure}`;
+  return null;
+}
+function summarizeRunError(projection) {
+  if (projection.status !== "failed")
+    return null;
+  const candidates = [];
+  for (const anomaly of projection.anomalies) {
+    appendCandidate(candidates, `Journal anomaly (${anomaly.kind}): ${anomaly.detail}`);
+  }
+  for (const phase of projection.closeoutPhases) {
+    if (phase.outcome === "failed")
+      appendCandidate(candidates, phase.detail);
+  }
+  for (const entry of projection.statusHistory) {
+    appendCandidate(candidates, entry.reason);
+  }
+  appendCandidate(candidates, projection.record.statusDetail);
+  appendCandidate(candidates, projection.record.errorText);
+  const nonGeneric = candidates.filter((candidate) => !isGenericRunFailure(candidate));
+  return categorizeUsefulRunError(nonGeneric) ?? nonGeneric.at(-1) ?? normalizeString(projection.record.errorText);
+}
+export {
+  summarizeRunError
+};

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

@@ -0,0 +1,4 @@
+import type { RunRecord } from "./projection";
+export declare function runBlocksNewRunForTask(run: RunRecord): boolean;
+export declare function activeRunByTaskId(listRuns: (projectRoot: string) => Promise<RunRecord[]>, projectRoot: string): Promise<Map<string, string>>;
+export declare function assertNoActiveRunForTask(listRuns: (projectRoot: string) => Promise<RunRecord[]>, projectRoot: string, taskId: string): Promise<void>;

package/dist/src/read-model/read-model-backend/guard.js

@@ -0,0 +1,25 @@
+// @bun
+// packages/run-plugin/src/read-model/read-model-backend/guard.ts
+var TERMINAL = new Set(["completed", "failed", "stopped"]);
+function runBlocksNewRunForTask(run) {
+  return run.live && !run.stale && !TERMINAL.has(run.status) && run.status !== "needs-attention" && run.status !== "needs_attention";
+}
+async function activeRunByTaskId(listRuns, projectRoot) {
+  const active = new Map;
+  for (const run of await listRuns(projectRoot)) {
+    if (run.taskId && runBlocksNewRunForTask(run) && !active.has(run.taskId))
+      active.set(run.taskId, run.runId);
+  }
+  return active;
+}
+async function assertNoActiveRunForTask(listRuns, projectRoot, taskId) {
+  const existing = (await activeRunByTaskId(listRuns, projectRoot)).get(taskId);
+  if (existing) {
+    throw new Error(`Task ${taskId} already has an active run: ${existing}. Attach instead: rig run attach ${existing} \u2014 or re-dispatch anyway with --force.`);
+  }
+}
+export {
+  runBlocksNewRunForTask,
+  assertNoActiveRunForTask,
+  activeRunByTaskId
+};

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

@@ -0,0 +1,23 @@
+import { type RunRecord } from "./projection";
+export type InboxKind = "approvals" | "inputs";
+export interface InboxFilters {
+    readonly run?: string;
+    readonly task?: string;
+}
+export interface InboxRecord {
+    readonly runId: string;
+    readonly taskId: string | null;
+    readonly requestId: string;
+    readonly status: "pending";
+    readonly prompt: string;
+    readonly requestedAt: string;
+    readonly payload: unknown;
+    readonly kind: "approval" | "input";
+}
+export declare function recordsFromRun(run: RunRecord, kind: InboxKind): InboxRecord[];
+export interface InboxDeps {
+    readonly listRuns?: (projectRoot: string) => Promise<readonly RunRecord[]>;
+}
+export declare function listInboxRecords(input: {
+    readonly projectRoot: string;
+}, kind: InboxKind, filters?: InboxFilters, deps?: InboxDeps): Promise<InboxRecord[]>;