patchrelay 0.45.1 → 0.46.0

package/dist/cli/watch/event-log-rows.js

@@ -0,0 +1,119 @@
+import { relativeTime, truncate } from "./format-utils.js";
+export { relativeTime };
+const RUN_LABEL = {
+    implementation: "implementation",
+    ci_repair: "ci repair",
+    review_fix: "review fix",
+    branch_upkeep: "branch upkeep",
+    queue_repair: "queue repair",
+};
+export function buildEventLogLines(source) {
+    const lines = [];
+    for (const run of source.rawRuns) {
+        const label = RUN_LABEL[run.runType] ?? run.runType;
+        lines.push({
+            id: `run-start-${run.id}`,
+            at: run.startedAt,
+            category: "run",
+            phrase: `${label} started`,
+        });
+        if (run.endedAt) {
+            const failed = run.status === "failed" || run.status === "errored";
+            const reason = run.report && typeof run.report === "object"
+                ? extractFailureReason(run.report)
+                : undefined;
+            lines.push({
+                id: `run-end-${run.id}`,
+                at: run.endedAt,
+                category: "run",
+                phrase: `${label} ended · ${humanStatus(run.status)}`,
+                color: failed ? "red" : run.status === "completed" ? "green" : undefined,
+                ...(failed && reason ? { continuation: reason } : {}),
+            });
+        }
+    }
+    for (const event of source.rawFeedEvents) {
+        const mapped = mapFeedEvent(event);
+        if (mapped)
+            lines.push(mapped);
+    }
+    lines.sort((left, right) => {
+        const lt = new Date(left.at).getTime();
+        const rt = new Date(right.at).getTime();
+        if (lt !== rt)
+            return lt - rt;
+        return left.id.localeCompare(right.id);
+    });
+    return lines;
+}
+function mapFeedEvent(event) {
+    const base = { id: `feed-${event.id}`, at: event.at };
+    switch (event.kind) {
+        case "stage": {
+            const phrase = formatStagePhrase(event);
+            if (!phrase)
+                return null;
+            return {
+                ...base,
+                category: "stage",
+                phrase,
+                ...(event.level === "error" ? { color: "red" } : event.level === "warn" ? { color: "yellow" } : {}),
+            };
+        }
+        case "github":
+            return { ...base, category: "github", phrase: compactSummary(event), ...(event.level === "error" ? { color: "red" } : {}) };
+        case "linear":
+            return { ...base, category: "github", phrase: compactSummary(event) };
+        case "comment":
+            return { ...base, category: "review", phrase: compactSummary(event) };
+        case "agent":
+        case "turn": {
+            const summary = event.summary?.toLowerCase() ?? "";
+            if (summary.startsWith("prompt")) {
+                return { ...base, category: "human", phrase: compactSummary(event) };
+            }
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+function formatStagePhrase(event) {
+    const from = event.stage;
+    const to = event.nextStage;
+    if (from && to)
+        return `${from} → ${to}`;
+    if (event.summary)
+        return compactSummary(event);
+    return null;
+}
+function compactSummary(event) {
+    const summary = event.summary?.trim() ?? "";
+    if (!summary)
+        return event.kind;
+    return summary;
+}
+function extractFailureReason(report) {
+    const reason = report["failureReason"] ?? report["error"] ?? report["message"];
+    if (typeof reason === "string" && reason.trim().length > 0) {
+        return truncate(reason.replace(/\s+/g, " ").trim(), 140);
+    }
+    return undefined;
+}
+function humanStatus(status) {
+    switch (status) {
+        case "completed":
+        case "succeeded":
+            return "success";
+        case "failed":
+        case "errored":
+            return "failed";
+        case "running":
+            return "running";
+        default:
+            return status;
+    }
+}
+export function formatEventAge(at) {
+    return relativeTime(at);
+}

package/dist/cli/watch/issue-token.js

@@ -0,0 +1,81 @@
+const GLYPH = {
+    running: "\u25cf",
+    queued: "\u25cb",
+    approved: "\u2713",
+    declined: "\u2717",
+    attention: "\u26a0",
+};
+const COLOR = {
+    running: "yellow",
+    queued: "gray",
+    approved: "green",
+    declined: "red",
+    attention: "red",
+};
+export function issueTokenFor(issue) {
+    if (issue.factoryState === "done") {
+        return { glyph: GLYPH.approved, color: COLOR.approved, kind: "approved", phrase: "done" };
+    }
+    if (issue.factoryState === "failed") {
+        return { glyph: GLYPH.declined, color: COLOR.declined, kind: "declined", phrase: "failed" };
+    }
+    if (issue.factoryState === "escalated") {
+        return { glyph: GLYPH.attention, color: COLOR.attention, kind: "attention", phrase: "escalated" };
+    }
+    if (issue.factoryState === "awaiting_input" || issue.sessionState === "waiting_input") {
+        return { glyph: GLYPH.attention, color: COLOR.attention, kind: "attention", phrase: "needs human" };
+    }
+    if (issue.factoryState === "delegated") {
+        return { glyph: GLYPH.queued, color: COLOR.queued, kind: "queued", phrase: "delegated" };
+    }
+    return {
+        glyph: GLYPH.running,
+        color: COLOR.running,
+        kind: "running",
+        phrase: phraseForRunning(issue),
+    };
+}
+function phraseForRunning(issue) {
+    switch (issue.factoryState) {
+        case "implementing":
+            return "implementing";
+        case "pr_open":
+            return "pr open";
+        case "changes_requested":
+            return "changes requested";
+        case "repairing_ci":
+            return "repairing ci";
+        case "awaiting_queue":
+            return "awaiting queue";
+        case "repairing_queue":
+            return "repairing queue";
+        default:
+            return issue.factoryState;
+    }
+}
+export function prTokenFor(issue) {
+    if (issue.prNumber === undefined)
+        return null;
+    const kind = prKind(issue);
+    return {
+        prNumber: issue.prNumber,
+        glyph: GLYPH[kind],
+        color: COLOR[kind],
+        kind,
+    };
+}
+function prKind(issue) {
+    if (issue.prState === "merged")
+        return "approved";
+    if (issue.prState === "closed")
+        return "declined";
+    if (issue.prReviewState === "approved")
+        return "approved";
+    if (issue.prReviewState === "changes_requested")
+        return "declined";
+    if (issue.prChecksSummary?.overall === "failure" || issue.prCheckStatus === "failure")
+        return "declined";
+    if (issue.prChecksSummary?.overall === "success" || issue.prCheckStatus === "success")
+        return "approved";
+    return "running";
+}

package/dist/cli/watch/watch-actions.js

@@ -3,6 +3,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { buildDetailLines } from "./detail-rows.js";
+import { buildCodexLogLines } from "./codex-log-rows.js";
 import { lineToPlainText } from "./render-rich-text.js";
 export function findLastAssistantMessage(timeline) {
     return findLastItemField(timeline, (entry) => entry.item?.type === "agentMessage", "text");
@@ -14,11 +15,14 @@ export function findLastCommandOutput(timeline) {
     return findLastItemField(timeline, (entry) => entry.item?.type === "commandExecution" && Boolean(entry.item?.output?.trim()), "output");
 }
 export function buildWatchDetailExportText(input) {
-    const lines = buildDetailLines({
-        ...input,
-        width: input.width ?? 100,
-    });
-    return `${lines.map(lineToPlainText).join("\n").trimEnd()}\n`;
+    const width = input.width ?? 100;
+    const detail = buildDetailLines({ ...input, width });
+    const log = buildCodexLogLines(input.timeline, width);
+    const sections = [detail.map(lineToPlainText).join("\n").trimEnd()];
+    if (log.length > 0) {
+        sections.push(`app-server log\n${log.map(lineToPlainText).join("\n").trimEnd()}`);
+    }
+    return `${sections.join("\n\n").trimEnd()}\n`;
 }
 export function writeTextToClipboard(text, stream = process.stderr) {
     if (!stream.isTTY || text.length === 0) {

package/dist/cli/watch/watch-state.js

@@ -162,6 +162,14 @@ export function watchReducer(state, action) {
             return { ...state, view: "detail", activeDetailKey: action.issueKey, follow: true, ...DETAIL_INITIAL };
         case "exit-detail":
             return { ...state, view: "list", activeDetailKey: null, ...DETAIL_INITIAL };
+        case "enter-log":
+            if (state.view !== "detail" || !state.activeDetailKey)
+                return state;
+            return { ...state, view: "log", follow: true, detailScrollOffset: 0 };
+        case "exit-log":
+            if (state.view !== "log")
+                return state;
+            return { ...state, view: "detail", follow: true, detailScrollOffset: 0 };
         case "detail-navigate": {
             const list = action.filtered;
             if (list.length === 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.45.1",
+  "version": "0.46.0",
   "license": "MIT",
   "type": "module",
   "repository": {