@mingchuno/agent-workflows 0.1.0 → 0.3.0

package/dist/src/tui/notifications.js

@@ -0,0 +1,104 @@
+import { write as writeFileDescriptor } from "node:fs";
+const terminalOutcomes = [
+    "completed",
+    "failed",
+    "blocked",
+    "cancelled",
+    "no-change",
+    "ineligible",
+];
+const terminalOutcomeSet = new Set(terminalOutcomes);
+const whitespace = /\s+/gu;
+const maximumPayloadBytes = 256;
+const notificationPrefix = "agent-workflows: ";
+export class ExecutionNotificationObserver {
+    writer;
+    seeded = false;
+    observedTerminalExecutionIds = new Set();
+    constructor(writer) {
+        this.writer = writer;
+    }
+    observe(runs) {
+        for (const run of runs) {
+            for (const execution of run.executions ?? []) {
+                if (!this.seeded) {
+                    if (isTerminal(execution.outcome))
+                        this.observedTerminalExecutionIds.add(execution.id);
+                    continue;
+                }
+                if (this.observedTerminalExecutionIds.has(execution.id) ||
+                    !isTerminal(execution.outcome))
+                    continue;
+                this.observedTerminalExecutionIds.add(execution.id);
+                try {
+                    this.writer.notify({
+                        project: run.projectId,
+                        issue: `#${run.issue.number}`,
+                        outcome: execution.outcome,
+                    });
+                }
+                catch {
+                    // Execution notifications are advisory and never affect monitoring.
+                }
+            }
+        }
+        this.seeded = true;
+    }
+}
+export function createTerminalNotificationWriter({ write = writeTerminal, tmux = Boolean(process.env.TMUX), } = {}) {
+    return {
+        notify(notification) {
+            const suffix = ` · ${sanitize(notification.issue)} · ${notification.outcome}`;
+            const projectBytes = Math.max(0, maximumPayloadBytes -
+                Buffer.byteLength(notificationPrefix + suffix, "utf8"));
+            const message = `${notificationPrefix}${truncateUtf8(sanitize(notification.project), projectBytes)}${suffix}`;
+            const osc = `\u001b]9;${message}\u001b\\`;
+            const sequence = tmux
+                ? `\u001bPtmux;${osc.replaceAll("\u001b", "\u001b\u001b")}\u001b\\`
+                : osc;
+            try {
+                const pending = write(sequence);
+                if (pending)
+                    void pending.catch(() => undefined);
+            }
+            catch {
+                // Execution notifications are advisory and never affect monitoring.
+            }
+        },
+    };
+}
+function isTerminal(outcome) {
+    return terminalOutcomeSet.has(outcome);
+}
+function sanitize(value) {
+    return [...value]
+        .filter((character) => {
+        const codePoint = character.codePointAt(0);
+        return !(codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f));
+    })
+        .join("")
+        .replace(whitespace, " ")
+        .trim();
+}
+function writeTerminal(value) {
+    return new Promise((resolve, reject) => {
+        writeFileDescriptor(process.stdout.fd, value, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}
+function truncateUtf8(value, maximumBytes) {
+    let result = "";
+    let bytes = 0;
+    for (const character of value) {
+        const characterBytes = Buffer.byteLength(character, "utf8");
+        if (bytes + characterBytes > maximumBytes)
+            break;
+        result += character;
+        bytes += characterBytes;
+    }
+    return result;
+}

package/dist/src/tui/text.d.ts

@@ -0,0 +1,3 @@
+export declare function terminalText(text: string): string;
+/** Literal smart-case match, returning a UTF-16 offset for string slicing. */
+export declare function matchIndex(text: string, query: string): number;

package/dist/src/tui/text.js

@@ -0,0 +1,10 @@
+import { stripVTControlCharacters } from "node:util";
+export function terminalText(text) {
+    return stripVTControlCharacters(text).replace(
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: remove control bytes from untrusted terminal output.
+    /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+}
+/** Literal smart-case match, returning a UTF-16 offset for string slicing. */
+export function matchIndex(text, query) {
+    return (query === query.toLowerCase() ? text.toLowerCase() : text).indexOf(query);
+}

package/dist/src/tui/use-log-controller.d.ts

@@ -0,0 +1,27 @@
+/** Owned by one keyed log screen; unmount cancels polling and search. */
+export declare function useLogController(path: string, columns: number, rows: number): {
+    height: number;
+    following: boolean;
+    horizontal: number;
+    raw: boolean;
+    lines: string[];
+    total: number;
+    message: string;
+    editing: boolean;
+    draft: string;
+    query: string;
+    searching: boolean;
+    position: number;
+    scroll: (delta: number) => void;
+    dismissSearch(): boolean;
+    beginSearch(): void;
+    applySearch(): void;
+    repeatSearch(direction: 1 | -1): void;
+    eraseDraft(): void;
+    appendDraft(input: string): void;
+    follow(): void;
+    toggleRaw(): void;
+    firstPage(): void;
+    lastPage(): void;
+    pan(delta: number): void;
+};

package/dist/src/tui/use-log-controller.js

@@ -0,0 +1,192 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import stringWidth from "string-width";
+import { screenChromeRows, tuiRefreshIntervalMs } from "./constants.js";
+import { LogFile, presentLogLine } from "./log-file.js";
+import { matchIndex, terminalText } from "./text.js";
+/** Owned by one keyed log screen; unmount cancels polling and search. */
+export function useLogController(path, columns, rows) {
+    const file = useMemo(() => new LogFile(path), [path]);
+    const height = Math.max(1, rows - screenChromeRows);
+    const [following, setFollowing] = useState(true);
+    const [top, setTop] = useState(0);
+    const [horizontal, setHorizontal] = useState(0);
+    const [raw, setRaw] = useState(false);
+    const [lines, setLines] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [message, setMessage] = useState("Loading log…");
+    const [editing, setEditing] = useState(false);
+    const [draft, setDraft] = useState("");
+    const [query, setQuery] = useState("");
+    const [searching, setSearching] = useState(false);
+    const searchController = useRef(undefined);
+    const position = useRef(0);
+    useEffect(() => () => searchController.current?.abort(), []);
+    useEffect(() => {
+        const controller = new AbortController();
+        let busy = false;
+        const update = async () => {
+            if (busy)
+                return;
+            busy = true;
+            try {
+                await file.refresh(controller.signal);
+                const nextTop = following
+                    ? Math.max(0, file.count - height)
+                    : Math.min(top, Math.max(0, file.count - 1));
+                const page = await file.page(nextTop, height, controller.signal);
+                if (controller.signal.aborted)
+                    return;
+                position.current = nextTop;
+                if (!following && nextTop !== top)
+                    setTop(nextTop);
+                setTotal(file.count);
+                setLines(page);
+                setMessage((current) => !file.count
+                    ? "No output yet; waiting for log data"
+                    : /^(Loading log|Log unavailable|No output yet)/.test(current)
+                        ? ""
+                        : current);
+            }
+            catch (error) {
+                if (!controller.signal.aborted) {
+                    setLines([]);
+                    setMessage(`Log unavailable: ${String(error)}`);
+                }
+            }
+            finally {
+                busy = false;
+            }
+        };
+        void update();
+        const timer = setInterval(() => void update(), tuiRefreshIntervalMs);
+        return () => {
+            controller.abort();
+            clearInterval(timer);
+        };
+    }, [file, following, top, height]);
+    const search = async (value, direction, first = false) => {
+        if (!value)
+            return;
+        searchController.current?.abort();
+        const controller = new AbortController();
+        searchController.current = controller;
+        setFollowing(false);
+        setQuery(value);
+        setSearching(true);
+        try {
+            const match = await file.search({
+                query: value,
+                from: first ? position.current - 1 : position.current,
+                direction,
+                raw,
+                signal: controller.signal,
+            });
+            if (controller.signal.aborted)
+                return;
+            if (match === undefined)
+                setMessage(`No matches: ${value}`);
+            else {
+                position.current = match;
+                setTop(match);
+                const [line] = await file.page(match, 1, controller.signal);
+                if (controller.signal.aborted)
+                    return;
+                const text = presentLogLine(line ?? "", raw);
+                const at = matchIndex(text, value);
+                setHorizontal(stringWidth(text.slice(0, at + value.length)) > columns
+                    ? Math.max(0, stringWidth(text.slice(0, at)) - 8)
+                    : 0);
+                setMessage(`Match on line ${match + 1} (wraps at file boundary)`);
+            }
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                setMessage(`Search failed: ${String(error)}`);
+        }
+        finally {
+            if (!controller.signal.aborted)
+                setSearching(false);
+        }
+    };
+    const scroll = (delta) => {
+        setFollowing(false);
+        const next = Math.max(0, Math.min(Math.max(0, total - 1), position.current + delta));
+        position.current = next;
+        setTop(next);
+    };
+    const cancelSearch = () => {
+        searchController.current?.abort();
+        setSearching(false);
+    };
+    return {
+        height,
+        following,
+        horizontal,
+        raw,
+        lines,
+        total,
+        message,
+        editing,
+        draft,
+        query,
+        searching,
+        position: position.current,
+        scroll,
+        dismissSearch() {
+            cancelSearch();
+            if (!editing && !query)
+                return false;
+            setEditing(false);
+            setQuery("");
+            setDraft("");
+            return true;
+        },
+        beginSearch() {
+            setFollowing(false);
+            setTop(position.current);
+            setDraft("");
+            setEditing(true);
+        },
+        applySearch() {
+            setEditing(false);
+            void search(draft, 1, true);
+        },
+        repeatSearch(direction) {
+            void search(query, direction);
+        },
+        eraseDraft() {
+            setDraft((value) => Array.from(value).slice(0, -1).join(""));
+        },
+        appendDraft(input) {
+            setDraft((value) => value +
+                terminalText(input)
+                    .replaceAll("\n", "")
+                    .replaceAll("\r", "")
+                    .replaceAll("\t", ""));
+        },
+        follow() {
+            cancelSearch();
+            setQuery("");
+            setFollowing(true);
+            setHorizontal(0);
+        },
+        toggleRaw() {
+            cancelSearch();
+            setRaw(!raw);
+            setQuery("");
+        },
+        firstPage() {
+            setFollowing(false);
+            position.current = 0;
+            setTop(0);
+        },
+        lastPage() {
+            setFollowing(false);
+            position.current = Math.max(0, total - height);
+            setTop(position.current);
+        },
+        pan(delta) {
+            setHorizontal((value) => Math.max(0, value + delta));
+        },
+    };
+}

package/dist/src/tui/views.d.ts

@@ -0,0 +1,25 @@
+import type { RunRecord } from "../domain.js";
+import type { EventRecord, InvocationRecord } from "../store.js";
+type AvailableActions = {
+    stop: boolean;
+    retry: boolean;
+    recover: boolean;
+};
+export declare function wrapDetailLines(lines: string[], width: number): string[];
+export declare function summaryLines(run: RunRecord, now: number, event?: EventRecord): string[];
+export declare function detailLines(run: RunRecord, sessions: InvocationRecord[], now: number, recoveryReason?: string | undefined, width?: number, available?: AvailableActions): string[];
+export declare function Lines({ lines, width, height, offset, outcome, }: {
+    lines: string[];
+    width: number;
+    height: number;
+    offset?: number;
+    outcome?: string;
+}): import("react").JSX.Element;
+export declare function RunList({ runs, selected, width, height, now, }: {
+    runs: RunRecord[];
+    selected?: string;
+    width: number;
+    height: number;
+    now: number;
+}): import("react").JSX.Element;
+export {};