patchrelay 0.36.18 → 0.37.0

package/dist/cli/watch/timeline-builder.js

@@ -2,6 +2,7 @@ import { getThreadTurns } from "../../codex-thread-utils.js";
 // ─── Build Timeline from Rehydration Data ─────────────────────────
 export function buildTimelineFromRehydration(runs, feedEvents, liveThread, activeRunId) {
     const entries = [];
+    const activeRun = activeRunId ? runs.find((run) => run.id === activeRunId) : undefined;
     // 1. Add run boundaries and items from reports
     for (const run of runs) {
         entries.push({
@@ -32,22 +33,28 @@ export function buildTimelineFromRehydration(runs, feedEvents, liveThread, activ
     }
     // 2. Items from live thread (active run)
     if (liveThread && activeRunId) {
-        entries.push(...itemsFromThread(activeRunId, liveThread));
+        entries.push(...itemsFromThread(activeRunId, liveThread, activeRun?.startedAt));
     }
     // 3. Feed events → feed entries + CI check aggregation
     entries.push(...feedEventsToEntries(feedEvents));
     // 4. Sort by timestamp, then by entry order for stability
-    entries.sort((a, b) => {
-        const cmp = a.at.localeCompare(b.at);
-        if (cmp !== 0)
-            return cmp;
-        // Within same timestamp: run-start before items, items before run-end
-        const kindCmp = kindOrder(a.kind) - kindOrder(b.kind);
-        if (kindCmp !== 0)
-            return kindCmp;
-        return a.id.localeCompare(b.id);
+    return sortTimelineEntries(entries);
+}
+export function reconcileTimelineFromRehydration(previousTimeline, runs, feedEvents, liveThread, activeRunId) {
+    const rehydrated = buildTimelineFromRehydration(runs, feedEvents, liveThread, activeRunId);
+    if (previousTimeline.length === 0) {
+        return rehydrated;
+    }
+    const previousById = new Map(previousTimeline.map((entry) => [entry.id, entry]));
+    const rehydratedIds = new Set(rehydrated.map((entry) => entry.id));
+    const liveUserMessages = collectUserMessageCounts(rehydrated, activeRunId);
+    const merged = rehydrated.map((entry) => mergeTimelineEntry(previousById.get(entry.id), entry));
+    const carriedForward = previousTimeline.filter((entry) => {
+        if (rehydratedIds.has(entry.id))
+            return false;
+        return shouldCarryForwardEntry(entry, activeRunId, liveUserMessages);
     });
-    return entries;
+    return sortTimelineEntries([...merged, ...carriedForward]);
 }
 function kindOrder(kind) {
     switch (kind) {
@@ -131,27 +138,37 @@ function syntheticTimestamp(startMs, endMs, index, total) {
     return new Date(startMs + fraction * (endMs - startMs)).toISOString();
 }
 // ─── Items from Live Thread ───────────────────────────────────────
-function itemsFromThread(runId, thread) {
+function itemsFromThread(runId, thread, runStartedAt) {
     const entries = [];
+    let itemIndex = 0;
     for (const turn of getThreadTurns(thread)) {
         for (const item of turn.items) {
             entries.push({
                 id: `live-${item.id}`,
-                at: new Date().toISOString(), // live items don't have timestamps; they'll sort to the end
+                at: liveItemTimestamp(runStartedAt, itemIndex),
                 kind: "item",
                 runId,
                 item: materializeItem(item),
             });
+            itemIndex += 1;
         }
     }
     return entries;
 }
+const LIVE_ITEM_FALLBACK_START_MS = Date.UTC(9999, 0, 1, 0, 0, 0, 0);
+function liveItemTimestamp(runStartedAt, itemIndex) {
+    const baseMs = runStartedAt ? Date.parse(runStartedAt) : LIVE_ITEM_FALLBACK_START_MS;
+    const stableBaseMs = Number.isFinite(baseMs) ? baseMs : LIVE_ITEM_FALLBACK_START_MS;
+    return new Date(stableBaseMs + itemIndex).toISOString();
+}
 function materializeItem(item) {
     const r = item;
     const id = String(r.id ?? "unknown");
     const type = String(r.type ?? "unknown");
     const base = { id, type, status: "completed" };
     switch (type) {
+        case "userMessage":
+            return { ...base, text: extractUserMessageText(r.content) };
         case "agentMessage":
             return { ...base, text: String(r.text ?? "") };
         case "commandExecution":
@@ -340,16 +357,150 @@ function mergeDefinedItemFields(base, patch) {
         ...base,
         id: patch.id,
         type: patch.type,
-        status: patch.status,
-        ...(patch.text !== undefined ? { text: patch.text } : {}),
+        status: preferredItemStatus(base.status, patch.status),
+        ...(mergePreferredString(base.text, patch.text) !== undefined ? { text: mergePreferredString(base.text, patch.text) } : {}),
         ...(patch.command !== undefined ? { command: patch.command } : {}),
-        ...(patch.output !== undefined ? { output: patch.output } : {}),
+        ...(mergePreferredString(base.output, patch.output) !== undefined ? { output: mergePreferredString(base.output, patch.output) } : {}),
         ...(patch.exitCode !== undefined ? { exitCode: patch.exitCode } : {}),
-        ...(patch.durationMs !== undefined ? { durationMs: patch.durationMs } : {}),
-        ...(patch.changes !== undefined ? { changes: patch.changes } : {}),
+        ...(patch.durationMs !== undefined || base.durationMs !== undefined
+            ? { durationMs: preferredNumber(base.durationMs, patch.durationMs) }
+            : {}),
+        ...(patch.changes !== undefined || base.changes !== undefined
+            ? { changes: preferredChanges(base.changes, patch.changes) }
+            : {}),
         ...(patch.toolName !== undefined ? { toolName: patch.toolName } : {}),
     };
 }
+function mergeTimelineEntry(existing, incoming) {
+    if (!existing || existing.kind !== incoming.kind) {
+        return incoming;
+    }
+    switch (incoming.kind) {
+        case "item":
+            return {
+                ...incoming,
+                at: existing.at,
+                ...(existing.runId !== undefined && incoming.runId === undefined ? { runId: existing.runId } : {}),
+                item: incoming.item && existing.item ? mergeDefinedItemFields(existing.item, incoming.item) : incoming.item,
+            };
+        case "run-start":
+        case "run-end":
+            return {
+                ...incoming,
+                at: existing.at,
+                run: existing.run && incoming.run ? { ...existing.run, ...incoming.run } : incoming.run,
+            };
+        case "feed":
+            return {
+                ...incoming,
+                at: existing.at,
+                feed: existing.feed && incoming.feed ? { ...existing.feed, ...incoming.feed } : incoming.feed,
+            };
+        case "ci-checks":
+            return {
+                ...incoming,
+                at: existing.at,
+                ciChecks: incoming.ciChecks ?? existing.ciChecks,
+            };
+    }
+}
+function shouldCarryForwardEntry(entry, activeRunId, liveUserMessages) {
+    if (entry.kind !== "item" || entry.runId !== activeRunId) {
+        return false;
+    }
+    if (entry.item?.id.startsWith("prompt-") === true) {
+        const text = normalizePromptText(entry.item.text);
+        return !text || !consumeUserMessageMatch(liveUserMessages, text);
+    }
+    return entry.item?.status === "inProgress";
+}
+function sortTimelineEntries(entries) {
+    return [...entries].sort((a, b) => {
+        const cmp = a.at.localeCompare(b.at);
+        if (cmp !== 0)
+            return cmp;
+        // Within same timestamp: run-start before items, items before run-end
+        const kindCmp = kindOrder(a.kind) - kindOrder(b.kind);
+        if (kindCmp !== 0)
+            return kindCmp;
+        return a.id.localeCompare(b.id);
+    });
+}
+function preferredItemStatus(existing, incoming) {
+    return itemStatusRank(incoming) >= itemStatusRank(existing) ? incoming : existing;
+}
+function itemStatusRank(status) {
+    switch (status) {
+        case "failed":
+        case "completed":
+        case "declined":
+            return 2;
+        case "inProgress":
+            return 1;
+        default:
+            return 0;
+    }
+}
+function mergePreferredString(existing, incoming) {
+    if (incoming === undefined)
+        return existing;
+    if (existing === undefined)
+        return incoming;
+    return incoming.length >= existing.length ? incoming : existing;
+}
+function preferredNumber(existing, incoming) {
+    return incoming ?? existing;
+}
+function preferredChanges(existing, incoming) {
+    if (incoming === undefined)
+        return existing;
+    if (existing === undefined)
+        return incoming;
+    return incoming.length >= existing.length ? incoming : existing;
+}
+function collectUserMessageCounts(entries, activeRunId) {
+    const texts = new Map();
+    for (const entry of entries) {
+        if (entry.kind !== "item" || entry.runId !== activeRunId || entry.item?.type !== "userMessage") {
+            continue;
+        }
+        const text = normalizePromptText(entry.item.text);
+        if (text) {
+            texts.set(text, (texts.get(text) ?? 0) + 1);
+        }
+    }
+    return texts;
+}
+function consumeUserMessageMatch(messages, text) {
+    const count = messages.get(text) ?? 0;
+    if (count <= 0) {
+        return false;
+    }
+    if (count === 1) {
+        messages.delete(text);
+    }
+    else {
+        messages.set(text, count - 1);
+    }
+    return true;
+}
+function normalizePromptText(text) {
+    const normalized = text?.trim();
+    return normalized && normalized.length > 0 ? normalized : null;
+}
+function extractUserMessageText(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((entry) => {
+        if (!entry || typeof entry !== "object")
+            return undefined;
+        const value = entry.text;
+        return typeof value === "string" ? value : undefined;
+    })
+        .filter((value) => Boolean(value))
+        .join("\n\n");
+}
 // ─── Feed Events to Timeline Entries ──────────────────────────────
 function feedEventsToEntries(feedEvents) {
     const entries = [];

package/dist/cli/watch/timeline-presentation.js

@@ -76,6 +76,7 @@ function buildCompactTimelineRows(entries) {
     }
     for (const run of runs.values()) {
         const status = resolveCompactRunStatus(run.run, run.items);
+        const verboseItems = status === "running" ? selectVerboseItems(run.items) : run.items;
         rows.push({
             id: run.id,
             kind: "run",
@@ -83,7 +84,7 @@ function buildCompactTimelineRows(entries) {
             finalized: status !== "running",
             run: { ...run.run, status, ...(run.endedAt ? { endedAt: run.endedAt } : {}) },
             details: summarizeRunDetails(run.items),
-            items: run.items.map((item) => ({ at: run.at, item })),
+            items: verboseItems.map((item) => ({ at: run.at, item })),
         });
     }
     rows.sort((left, right) => {
@@ -167,6 +168,25 @@ function summarizeRunDetails(items) {
     }
     return dedupeDetails(details).slice(0, 3);
 }
+function selectVerboseItems(items) {
+    const latestAssistantMessage = findLatest(items, (item) => item.type === "agentMessage" && Boolean(item.text?.trim()));
+    const latestUserMessage = !latestAssistantMessage
+        ? findLatest(items, (item) => item.type === "userMessage" && Boolean(item.text?.trim()))
+        : undefined;
+    const activeCommand = findLatest(items, (item) => item.type === "commandExecution" && item.status === "inProgress");
+    const latestCommandWithOutput = findLatest(items, (item) => item.type === "commandExecution" && Boolean(item.output?.trim()));
+    const latestCommand = activeCommand
+        ?? latestCommandWithOutput
+        ?? findLatest(items, (item) => item.type === "commandExecution" && Boolean(item.command?.trim()));
+    const latestFileChange = findLatest(items, (item) => item.type === "fileChange" && Array.isArray(item.changes) && item.changes.length > 0);
+    const latestToolCall = !latestFileChange
+        ? findLatest(items, (item) => item.type === "mcpToolCall" || item.type === "dynamicToolCall")
+        : undefined;
+    const selectedIds = new Set([latestUserMessage, latestAssistantMessage, latestCommand, latestFileChange, latestToolCall]
+        .filter((item) => Boolean(item))
+        .map((item) => item.id));
+    return items.filter((item) => selectedIds.has(item.id));
+}
 function summarizeNarrative(input) {
     const normalized = input
         .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")

package/dist/cli/watch/transient-status.js

@@ -0,0 +1,28 @@
+export const defaultTimerApi = {
+    setTimeout(callback, delayMs) {
+        return setTimeout(callback, delayMs);
+    },
+    clearTimeout(timer) {
+        clearTimeout(timer);
+    },
+};
+export function showTransientStatus(controller, message, setStatus, timers, delayMs = 3_000) {
+    setStatus(message);
+    if (controller.timer !== null) {
+        timers.clearTimeout(controller.timer);
+    }
+    controller.timer = timers.setTimeout(() => {
+        controller.timer = null;
+        setStatus(null);
+    }, delayMs);
+}
+export function setPersistentStatus(controller, message, setStatus, timers) {
+    clearTransientStatus(controller, timers);
+    setStatus(message);
+}
+export function clearTransientStatus(controller, timers) {
+    if (controller.timer !== null) {
+        timers.clearTimeout(controller.timer);
+        controller.timer = null;
+    }
+}

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

@@ -0,0 +1,76 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { buildDetailLines } from "./detail-rows.js";
+import { lineToPlainText } from "./render-rich-text.js";
+export function findLastAssistantMessage(timeline) {
+    return findLastItemField(timeline, (entry) => entry.item?.type === "agentMessage", "text");
+}
+export function findLastCommand(timeline) {
+    return findLastItemField(timeline, (entry) => entry.item?.type === "commandExecution", "command");
+}
+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`;
+}
+export function writeTextToClipboard(text, stream = process.stderr) {
+    if (!stream.isTTY || text.length === 0) {
+        return false;
+    }
+    const encoded = Buffer.from(text, "utf8").toString("base64");
+    stream.write(`\u001b]52;c;${encoded}\u0007`);
+    return true;
+}
+export function exportWatchTextToTempFile(text, issueKey) {
+    const directory = mkdtempSync(join(tmpdir(), "patchrelay-watch-"));
+    const safeIssueKey = issueKey.replace(/[^a-zA-Z0-9._-]+/g, "-");
+    const filePath = join(directory, `${safeIssueKey || "issue"}-transcript.txt`);
+    writeFileSync(filePath, text, "utf8");
+    return filePath;
+}
+export function openTextInPager(text, stream = process.stderr) {
+    if (!stream.isTTY) {
+        return { ok: false, reason: "interactive TTY required" };
+    }
+    const streamWithFd = stream;
+    if (typeof streamWithFd.fd !== "number") {
+        return { ok: false, reason: "TTY stream fd unavailable" };
+    }
+    const pagerCommand = process.env.PAGER?.trim() || "less -R";
+    stream.write("\u001b[?1049l");
+    try {
+        const result = spawnSync("/bin/sh", ["-lc", pagerCommand], {
+            input: text,
+            stdio: ["pipe", streamWithFd.fd, streamWithFd.fd],
+        });
+        if (result.error) {
+            return { ok: false, reason: result.error.message };
+        }
+        if (typeof result.status === "number" && result.status !== 0) {
+            return { ok: false, reason: `${pagerCommand} exited with status ${result.status}` };
+        }
+        return { ok: true };
+    }
+    finally {
+        stream.write("\u001b[?1049h\u001b[2J\u001b[H");
+    }
+}
+function findLastItemField(timeline, predicate, field) {
+    for (let index = timeline.length - 1; index >= 0; index -= 1) {
+        const entry = timeline[index];
+        if (!predicate(entry))
+            continue;
+        const value = entry.item?.[field];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return null;
+}

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

@@ -1,8 +1,7 @@
-import { buildTimelineFromRehydration, appendFeedToTimeline, appendCodexItemToTimeline, completeCodexItemInTimeline, appendDeltaToTimelineItem, } from "./timeline-builder.js";
+import { reconcileTimelineFromRehydration, appendFeedToTimeline, appendCodexItemToTimeline, completeCodexItemInTimeline, appendDeltaToTimelineItem, } from "./timeline-builder.js";
 // ─── Array size caps (prevent OOM) ───────────────────────────────
 const MAX_TIMELINE_ENTRIES = 2000;
 const MAX_RAW_FEED_EVENTS = 2000;
-const MAX_FEED_EVENTS = 1000;
 function capArray(arr, max) {
     return arr.length > max ? arr.slice(arr.length - max) : arr;
 }
@@ -32,7 +31,6 @@ export const initialWatchState = {
     filter: "non-done",
     follow: true,
     ...DETAIL_INITIAL,
-    feedEvents: [],
 };
 const TERMINAL_FACTORY_STATES = new Set(["done", "failed"]);
 function effectiveSessionState(issue) {
@@ -216,7 +214,7 @@ export function watchReducer(state, action) {
                 };
             }
         case "timeline-rehydrate": {
-            const timeline = buildTimelineFromRehydration(action.runs, action.feedEvents, action.liveThread, action.activeRunId);
+            const timeline = reconcileTimelineFromRehydration(state.timeline, action.runs, action.feedEvents, action.liveThread, action.activeRunId);
             const activeRun = action.runs.find((r) => r.id === action.activeRunId);
             return {
                 ...state,
@@ -243,14 +241,6 @@ export function watchReducer(state, action) {
                     ...state,
                     ...detailStateForPosition(state, maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows), true),
                 };
-        case "enter-feed":
-            return { ...state, view: "feed", activeDetailKey: null, ...DETAIL_INITIAL };
-        case "exit-feed":
-            return { ...state, view: "list" };
-        case "feed-snapshot":
-            return { ...state, feedEvents: action.events };
-        case "feed-new-event":
-            return { ...state, feedEvents: capArray([...state.feedEvents, action.event], MAX_FEED_EVENTS) };
         case "switch-detail-tab":
             return { ...state, follow: true, ...DETAIL_INITIAL, detailTab: action.tab };
         default:

package/dist/linear-agent-session-client.js

@@ -0,0 +1,109 @@
+import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
+import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+export class LinearAgentSessionClient {
+    config;
+    db;
+    linearProvider;
+    logger;
+    feed;
+    constructor(config, db, linearProvider, logger, feed) {
+        this.config = config;
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    ensureAgentSessionIssue(issue) {
+        if (issue.agentSessionId) {
+            return issue;
+        }
+        const recoveredAgentSessionId = this.db.webhookEvents.findLatestAgentSessionIdForIssue(issue.linearIssueId);
+        if (!recoveredAgentSessionId)
+            return issue;
+        this.logger.info({ issueKey: issue.issueKey, agentSessionId: recoveredAgentSessionId }, "Recovered missing Linear agent session id from webhook history");
+        return this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            agentSessionId: recoveredAgentSessionId,
+        });
+    }
+    async emitActivity(issue, content, options) {
+        const syncedIssue = this.ensureAgentSessionIssue(issue);
+        if (!syncedIssue.agentSessionId)
+            return;
+        try {
+            const linear = await this.linearProvider.forProject(syncedIssue.projectId);
+            if (!linear)
+                return;
+            const allowEphemeral = content.type === "thought" || content.type === "action";
+            await linear.createAgentActivity({
+                agentSessionId: syncedIssue.agentSessionId,
+                content,
+                ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: syncedIssue.issueKey, type: content.type, error: msg }, "Failed to emit Linear activity");
+            this.feed?.publish({
+                level: "warn",
+                kind: "linear",
+                issueKey: syncedIssue.issueKey,
+                projectId: syncedIssue.projectId,
+                status: "linear_error",
+                summary: `Linear activity failed: ${msg}`,
+            });
+        }
+    }
+    async syncSessionPlan(issue, linear, options) {
+        if (!issue.agentSessionId || !linear.updateAgentSession) {
+            return;
+        }
+        const externalUrls = buildAgentSessionExternalUrls(this.config, {
+            ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+            ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
+        });
+        await linear.updateAgentSession({
+            agentSessionId: issue.agentSessionId,
+            plan: buildAgentSessionPlanForIssue(issue, options),
+            ...(externalUrls ? { externalUrls } : {}),
+        });
+    }
+    async syncCodexPlan(issue, params) {
+        const syncedIssue = this.ensureAgentSessionIssue(issue);
+        if (!syncedIssue.agentSessionId)
+            return;
+        const plan = params.plan;
+        if (!Array.isArray(plan))
+            return;
+        const STATUS_MAP = {
+            pending: "pending",
+            inProgress: "inProgress",
+            completed: "completed",
+        };
+        const steps = plan.map((entry) => {
+            const e = entry;
+            const step = typeof e.step === "string" ? e.step : String(e.step ?? "");
+            const status = typeof e.status === "string" ? (STATUS_MAP[e.status] ?? "pending") : "pending";
+            return { content: step, status };
+        });
+        const fullPlan = [
+            { content: "Prepare workspace", status: "completed" },
+            ...steps,
+            { content: "Merge", status: "pending" },
+        ];
+        try {
+            const linear = await this.linearProvider.forProject(syncedIssue.projectId);
+            if (!linear?.updateAgentSession)
+                return;
+            await linear.updateAgentSession({
+                agentSessionId: syncedIssue.agentSessionId,
+                plan: fullPlan,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: syncedIssue.issueKey, error: msg }, "Failed to sync codex plan to Linear");
+        }
+    }
+}