parallel-codex-tui 0.1.0

package/dist/tui/chat-input.js

@@ -0,0 +1,37 @@
+export function applyChatInputChunk(currentValue, chunk) {
+    if (chunk === "\x03") {
+        return {
+            value: currentValue,
+            submit: null,
+            exit: true
+        };
+    }
+    let value = currentValue;
+    let submit = null;
+    const visible = chunk
+        .replaceAll("\x1b[200~", "")
+        .replaceAll("\x1b[201~", "")
+        .replace(/\x1b\[M[\s\S]{3}/g, "")
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\x1bO./g, "");
+    for (const char of visible) {
+        if (char === "\r" || char === "\n") {
+            submit = value;
+            value = "";
+        }
+        else if (char === "\x7f" || char === "\b") {
+            value = dropLastCodePoint(value);
+        }
+        else if (char >= " " && char !== "\x1b") {
+            value += char;
+        }
+    }
+    return {
+        value,
+        submit,
+        exit: false
+    };
+}
+function dropLastCodePoint(value) {
+    return [...value].slice(0, -1).join("");
+}

package/dist/tui/display-width.js

@@ -0,0 +1,132 @@
+export function displayWidth(value) {
+    let width = 0;
+    for (const char of Array.from(value)) {
+        width += charDisplayWidth(char);
+    }
+    return width;
+}
+export function compactEndByDisplayWidth(value, maxWidth) {
+    if (maxWidth <= 0) {
+        return "";
+    }
+    if (displayWidth(value) <= maxWidth) {
+        return value;
+    }
+    if (maxWidth <= 3) {
+        return takeStartByDisplayWidth(value, maxWidth);
+    }
+    return `${takeStartByDisplayWidth(value, maxWidth - 3)}...`;
+}
+export function compactTailByDisplayWidth(value, maxWidth) {
+    if (maxWidth <= 0) {
+        return "";
+    }
+    if (displayWidth(value) <= maxWidth) {
+        return value;
+    }
+    const prefix = maxWidth <= 3 ? "" : "...";
+    const tailWidth = Math.max(1, maxWidth - displayWidth(prefix));
+    return `${prefix}${takeEndByDisplayWidth(value, tailWidth)}`;
+}
+export function wrapByDisplayWidth(value, maxWidth) {
+    if (maxWidth <= 0) {
+        return [""];
+    }
+    if (!value) {
+        return [""];
+    }
+    if (displayWidth(value) <= maxWidth) {
+        return [value];
+    }
+    const chunks = [];
+    let rest = value;
+    while (displayWidth(rest) > maxWidth) {
+        const splitAtWidth = sliceEndIndexByDisplayWidth(rest, maxWidth);
+        const hardSlice = rest.slice(0, splitAtWidth);
+        const breakAt = Math.max(hardSlice.lastIndexOf(" "), hardSlice.lastIndexOf("/"));
+        const breakWidth = breakAt >= 0 ? displayWidth(hardSlice.slice(0, breakAt + 1)) : 0;
+        const splitAt = rest[splitAtWidth] === " "
+            ? splitAtWidth
+            : breakWidth > Math.floor(maxWidth * 0.3)
+                ? breakAt + 1
+                : splitAtWidth;
+        chunks.push(rest.slice(0, splitAt).trimEnd());
+        rest = rest.slice(splitAt).trimStart();
+    }
+    chunks.push(rest);
+    return chunks;
+}
+function takeStartByDisplayWidth(value, maxWidth) {
+    let result = "";
+    let width = 0;
+    for (const char of Array.from(value)) {
+        const charWidth = charDisplayWidth(char);
+        if (width + charWidth > maxWidth) {
+            break;
+        }
+        result += char;
+        width += charWidth;
+    }
+    return result;
+}
+function takeEndByDisplayWidth(value, maxWidth) {
+    let result = "";
+    let width = 0;
+    const chars = Array.from(value);
+    for (let index = chars.length - 1; index >= 0; index -= 1) {
+        const char = chars[index] ?? "";
+        const charWidth = charDisplayWidth(char);
+        if (width + charWidth > maxWidth) {
+            break;
+        }
+        result = `${char}${result}`;
+        width += charWidth;
+    }
+    return result;
+}
+function sliceEndIndexByDisplayWidth(text, maxWidth) {
+    let width = 0;
+    let endIndex = 0;
+    for (const char of Array.from(text)) {
+        const charWidth = charDisplayWidth(char);
+        if (width + charWidth > maxWidth && endIndex > 0) {
+            break;
+        }
+        endIndex += char.length;
+        width += charWidth;
+        if (width >= maxWidth) {
+            break;
+        }
+    }
+    return endIndex || text.length;
+}
+function charDisplayWidth(char) {
+    const codePoint = char.codePointAt(0) ?? 0;
+    if (codePoint === 0 || codePoint < 32 || (codePoint >= 0x7f && codePoint < 0xa0)) {
+        return 0;
+    }
+    if (isCombiningCodePoint(codePoint)) {
+        return 0;
+    }
+    return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isCombiningCodePoint(codePoint) {
+    return ((codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe20 && codePoint <= 0xfe2f));
+}
+function isWideCodePoint(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6)));
+}

package/dist/tui/keyboard.js

@@ -0,0 +1,38 @@
+export function isLogsShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "w") || input === "\u0017";
+}
+export function isAttachShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "o") || input === "\u000f";
+}
+export function isExitShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "c") || input === "\u0003";
+}
+export function scrollDelta(input, key, pageSize) {
+    if (key.pageUp || (key.ctrl === true && input.toLowerCase() === "u")) {
+        return pageSize;
+    }
+    if (key.pageDown || (key.ctrl === true && input.toLowerCase() === "d")) {
+        return -pageSize;
+    }
+    return 0;
+}
+export function mouseScrollDelta(input, linesPerWheel = 3) {
+    let delta = 0;
+    for (const match of input.matchAll(/\x1b\[<(\d+);\d+;\d+[mM]/g)) {
+        delta += wheelButtonDelta(Number(match[1]), linesPerWheel);
+    }
+    for (const match of input.matchAll(/\x1b\[M([\s\S])[\s\S]{2}/g)) {
+        delta += wheelButtonDelta(match[1].charCodeAt(0) - 32, linesPerWheel);
+    }
+    return delta;
+}
+function wheelButtonDelta(button, linesPerWheel) {
+    const wheel = button & 0b11;
+    if (button >= 64 && wheel === 0) {
+        return linesPerWheel;
+    }
+    if (button >= 64 && wheel === 1) {
+        return -linesPerWheel;
+    }
+    return 0;
+}

package/dist/tui/native-input.js

@@ -0,0 +1,120 @@
+const NATIVE_ATTACH_DETACH = "\x1d";
+export function applyNativeInputKey(currentDraft, input, key) {
+    if ((key.ctrl && input === "]") || input === NATIVE_ATTACH_DETACH) {
+        return {
+            draft: "",
+            outbound: null,
+            exit: true
+        };
+    }
+    if (key.escape) {
+        return {
+            draft: currentDraft,
+            outbound: "\x1b",
+            exit: false
+        };
+    }
+    if (key.return) {
+        return {
+            draft: "",
+            outbound: "\r",
+            exit: false
+        };
+    }
+    if (key.backspace || key.delete) {
+        return {
+            draft: dropLastCodePoint(currentDraft),
+            outbound: "\x7f",
+            exit: false
+        };
+    }
+    if (key.tab) {
+        return {
+            draft: `${currentDraft}\t`,
+            outbound: "\t",
+            exit: false
+        };
+    }
+    if (key.ctrl && input.length === 1) {
+        return {
+            draft: currentDraft,
+            outbound: controlLetter(input),
+            exit: false
+        };
+    }
+    const arrow = arrowSequence(key);
+    if (arrow) {
+        return {
+            draft: currentDraft,
+            outbound: arrow,
+            exit: false
+        };
+    }
+    return {
+        draft: `${currentDraft}${input}`,
+        outbound: input || null,
+        exit: false
+    };
+}
+export function applyNativeInputChunk(currentDraft, chunk, pageSize = 0) {
+    if (chunk === NATIVE_ATTACH_DETACH) {
+        return {
+            draft: "",
+            outbound: null,
+            exit: true,
+            scrollDelta: 0
+        };
+    }
+    return {
+        draft: visibleDraftAfterChunk(currentDraft, chunk),
+        outbound: chunk || null,
+        exit: false,
+        scrollDelta: 0
+    };
+}
+function controlLetter(input) {
+    const code = input.toLowerCase().charCodeAt(0);
+    if (code < 97 || code > 122) {
+        return null;
+    }
+    return String.fromCharCode(code - 96);
+}
+function visibleDraftAfterChunk(currentDraft, chunk) {
+    let draft = currentDraft;
+    const visible = chunk
+        .replaceAll("\x1b[200~", "")
+        .replaceAll("\x1b[201~", "")
+        .replace(/\x1b\[M[\s\S]{3}/g, "")
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\x1bO./g, "");
+    for (const char of visible) {
+        if (char === "\r" || char === "\n") {
+            draft = "";
+        }
+        else if (char === "\x7f" || char === "\b") {
+            draft = dropLastCodePoint(draft);
+        }
+        else if (char >= " " && char !== "\x1b") {
+            draft += char;
+        }
+    }
+    return draft;
+}
+function dropLastCodePoint(value) {
+    return [...value].slice(0, -1).join("");
+}
+function arrowSequence(key) {
+    if (key.upArrow) {
+        return "\x1b[A";
+    }
+    if (key.downArrow) {
+        return "\x1b[B";
+    }
+    if (key.rightArrow) {
+        return "\x1b[C";
+    }
+    if (key.leftArrow) {
+        return "\x1b[D";
+    }
+    return null;
+}

package/dist/tui/raw-input-decoder.js

@@ -0,0 +1,18 @@
+import { StringDecoder } from "node:string_decoder";
+export function createRawInputDecoder() {
+    const decoder = new StringDecoder("utf8");
+    return {
+        write(chunk) {
+            if (chunk == null) {
+                return "";
+            }
+            if (Buffer.isBuffer(chunk)) {
+                return decoder.write(chunk);
+            }
+            return chunk;
+        },
+        end() {
+            return decoder.end();
+        }
+    };
+}

package/dist/tui/scrolling.js

@@ -0,0 +1,25 @@
+export function selectViewportLines(text, height, offsetFromBottom) {
+    const lines = splitLines(text);
+    const viewportHeight = Math.max(1, height);
+    const maxOffset = Math.max(0, lines.length - viewportHeight);
+    const clampedOffset = clamp(offsetFromBottom, 0, maxOffset);
+    const end = lines.length - clampedOffset;
+    const start = Math.max(0, end - viewportHeight);
+    return {
+        lines: lines.slice(start, end),
+        clampedOffset,
+        maxOffset
+    };
+}
+export function nextScrollOffset(current, delta, maxOffset) {
+    return clamp(current + delta, 0, Math.max(0, maxOffset));
+}
+function splitLines(text) {
+    if (!text) {
+        return [];
+    }
+    return text.replace(/\n$/, "").split("\n");
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}

package/dist/tui/status-line.js

@@ -0,0 +1,90 @@
+export function formatStatusLine(state) {
+    if (!state) {
+        return "idle";
+    }
+    const parts = [compactTaskId(state.taskId)];
+    if (state.workers?.length) {
+        parts.push(formatWorkerSummary(state.workers));
+        return parts.join(" | ");
+    }
+    if (state.main) {
+        parts.push(`main ${compactStatus(state.main)}`);
+    }
+    if (state.judge) {
+        parts.push(`judge ${compactStatus(state.judge)}`);
+    }
+    if (state.actor) {
+        parts.push(`actor ${compactStatus(state.actor)}`);
+    }
+    if (state.critic) {
+        parts.push(`critic ${compactStatus(state.critic)}`);
+    }
+    return parts.join(" | ");
+}
+export function formatSelectedWorkerStatus(state, selectedIndex) {
+    const worker = state?.workers?.[selectedIndex];
+    if (!worker) {
+        return "";
+    }
+    return `${compactWorkerLabel(worker.label)} ${compactStatus(worker.status)}`;
+}
+export function formatWorkerRuntimeStatus(status) {
+    const native = status.native_session_id ? ` native:${compactNativeSessionId(status.native_session_id)}` : "";
+    const detail = `${status.state}/${status.phase}${native}: ${status.summary.trim() || "no summary"}`;
+    return detail.length > 96 ? `${detail.slice(0, 93)}...` : detail;
+}
+export function formatFooterHelp(mode = "chat") {
+    if (mode === "native") {
+        return "wheel/Pg · ^] detach";
+    }
+    if (mode === "worker") {
+        return "wheel/Pg · Tab worker · ^O attach · Esc chat";
+    }
+    return "^W logs · Tab worker · ^O attach";
+}
+function compactNativeSessionId(sessionId) {
+    return sessionId.length > 12 ? `${sessionId.slice(0, 8)}...` : sessionId;
+}
+function formatWorkerSummary(workers) {
+    const counts = new Map();
+    for (const worker of workers) {
+        const state = compactStatus(worker.status);
+        counts.set(state, (counts.get(state) ?? 0) + 1);
+    }
+    const priority = ["fail", "run", "wait", "done"];
+    const orderedStates = [
+        ...priority.filter((state) => counts.has(state)),
+        ...Array.from(counts.keys()).filter((state) => !priority.includes(state)).sort()
+    ];
+    const summary = orderedStates.map((state) => `${state} ${counts.get(state)}`).join(" ");
+    return `workers ${workers.length}${summary ? ` | ${summary}` : ""}`;
+}
+function compactStatus(status) {
+    const trimmed = status.trim();
+    if (!trimmed) {
+        return "idle";
+    }
+    const state = trimmed.split(/[/: ]/, 1)[0]?.trim().toLowerCase();
+    if (state === "running") {
+        return "run";
+    }
+    if (state === "failed" || state === "error") {
+        return "fail";
+    }
+    if (state === "waiting" || state === "queued") {
+        return "wait";
+    }
+    return state || "idle";
+}
+function compactTaskId(taskId) {
+    const withoutPrefix = taskId.startsWith("task-") ? taskId.slice("task-".length) : taskId;
+    const dated = withoutPrefix.match(/^\d{8}-(.+)$/);
+    return dated?.[1] ?? withoutPrefix;
+}
+function compactWorkerLabel(label) {
+    const match = label.match(/^\s*([^(]+?)\s*\(([^)]+)\)\s*$/);
+    if (match) {
+        return `${match[1].trim().toLowerCase()}/${match[2].trim().toLowerCase()}`;
+    }
+    return label.trim().toLowerCase().replace(/\s+/g, "/");
+}

package/dist/tui/task-memory.js

@@ -0,0 +1,26 @@
+export function chooseSubmitTarget(state, route) {
+    if (state.activeTaskId && state.activeMode === "complex") {
+        if (route?.mode === "simple") {
+            return {
+                kind: "task-question",
+                taskId: state.activeTaskId
+            };
+        }
+        return {
+            kind: "task-turn",
+            taskId: state.activeTaskId
+        };
+    }
+    return {
+        kind: "new-request"
+    };
+}
+export function nextSubmitMemoryState(current, target, result) {
+    if (target.kind === "task-question") {
+        return current;
+    }
+    return {
+        activeMode: result.mode,
+        activeTaskId: result.mode === "complex" ? result.taskId : null
+    };
+}

package/dist/tui/terminal-screen.js

@@ -0,0 +1,168 @@
+import * as xtermHeadless from "@xterm/headless";
+const xtermRuntime = xtermHeadless;
+const Terminal = resolveTerminalConstructor(xtermRuntime);
+export class NativeTerminalScreen {
+    terminal;
+    constructor(options = {}) {
+        this.terminal = new Terminal({
+            allowProposedApi: true,
+            cols: options.cols ?? 120,
+            rows: options.rows ?? 24,
+            scrollback: options.scrollback ?? 1000
+        });
+    }
+    write(chunk) {
+        return new Promise((resolve) => {
+            this.terminal.write(chunk, resolve);
+        });
+    }
+    snapshot() {
+        return this.snapshotLines().join("\n");
+    }
+    snapshotLines() {
+        return this.styledSnapshotLines().map((line) => line.chunks.map((chunk) => chunk.text).join(""));
+    }
+    styledSnapshotLines(options = {}) {
+        const buffer = this.terminal.buffer.active;
+        const lines = [];
+        const cursorY = options.showCursor ? buffer.baseY + buffer.cursorY : null;
+        const cursorX = options.showCursor ? Math.min(buffer.cursorX, this.terminal.cols - 1) : null;
+        for (let row = 0; row < this.terminal.rows; row += 1) {
+            const absoluteY = buffer.viewportY + row;
+            const line = buffer.getLine(absoluteY);
+            lines.push(line
+                ? styledLineFromBufferLine(line, buffer.getNullCell(), absoluteY === cursorY ? cursorX : null)
+                : { chunks: [] });
+        }
+        return trimTrailingBlankTerminalLines(lines);
+    }
+    scrollLines(amount) {
+        this.terminal.scrollLines(amount);
+    }
+    scrollPages(pageCount) {
+        this.terminal.scrollPages(pageCount);
+    }
+    scrollToBottom() {
+        this.terminal.scrollToBottom();
+    }
+    scrollState() {
+        const buffer = this.terminal.buffer.active;
+        return {
+            offset: Math.max(0, buffer.baseY - buffer.viewportY),
+            maxOffset: Math.max(0, buffer.baseY)
+        };
+    }
+}
+function styledLineFromBufferLine(line, reusableCell, cursorColumn) {
+    const chunks = [];
+    let pendingStyle = null;
+    let pendingText = "";
+    const trimmedText = line.translateToString(true);
+    const cursorLimit = cursorColumn === null ? -1 : cursorColumn + 1;
+    let visibleTextLength = 0;
+    for (let column = 0; column < line.length && (visibleTextLength < trimmedText.length || column < cursorLimit); column += 1) {
+        const cell = line.getCell(column, reusableCell);
+        if (!cell || cell.getWidth() === 0) {
+            continue;
+        }
+        const text = cell.getChars() || " ";
+        visibleTextLength += text.length;
+        const style = styleFromCell(cell);
+        if (cursorColumn === column) {
+            style.cursor = true;
+            style.inverse = true;
+        }
+        if (pendingStyle && sameStyle(pendingStyle, style)) {
+            pendingText += text;
+            continue;
+        }
+        if (pendingStyle) {
+            chunks.push({ text: pendingText, style: pendingStyle });
+        }
+        pendingStyle = style;
+        pendingText = text;
+    }
+    if (pendingStyle) {
+        chunks.push({ text: pendingText, style: pendingStyle });
+    }
+    return { chunks };
+}
+function styleFromCell(cell) {
+    const style = {};
+    const color = colorFromCell(cell, "fg");
+    const backgroundColor = colorFromCell(cell, "bg");
+    if (color) {
+        style.color = color;
+    }
+    if (backgroundColor) {
+        style.backgroundColor = backgroundColor;
+    }
+    if (cell.isBold()) {
+        style.bold = true;
+    }
+    if (cell.isDim()) {
+        style.dimColor = true;
+    }
+    if (cell.isInverse()) {
+        style.inverse = true;
+    }
+    if (cell.isItalic()) {
+        style.italic = true;
+    }
+    if (cell.isStrikethrough()) {
+        style.strikethrough = true;
+    }
+    if (cell.isUnderline()) {
+        style.underline = true;
+    }
+    return style;
+}
+function colorFromCell(cell, kind) {
+    if (kind === "fg") {
+        if (cell.isFgRGB()) {
+            return rgbHex(cell.getFgColor());
+        }
+        if (cell.isFgPalette()) {
+            return `ansi256(${cell.getFgColor()})`;
+        }
+        return undefined;
+    }
+    if (cell.isBgRGB()) {
+        return rgbHex(cell.getBgColor());
+    }
+    if (cell.isBgPalette()) {
+        return `ansi256(${cell.getBgColor()})`;
+    }
+    return undefined;
+}
+function rgbHex(value) {
+    return `#${value.toString(16).padStart(6, "0")}`;
+}
+function sameStyle(left, right) {
+    return (left.backgroundColor === right.backgroundColor &&
+        left.bold === right.bold &&
+        left.color === right.color &&
+        left.cursor === right.cursor &&
+        left.dimColor === right.dimColor &&
+        left.inverse === right.inverse &&
+        left.italic === right.italic &&
+        left.strikethrough === right.strikethrough &&
+        left.underline === right.underline);
+}
+function trimTrailingBlankTerminalLines(lines) {
+    let end = lines.length;
+    while (end > 0 && terminalLineText(lines[end - 1]).trim() === "") {
+        end -= 1;
+    }
+    return lines.slice(0, end);
+}
+function terminalLineText(line) {
+    return line.chunks.map((chunk) => chunk.text).join("");
+}
+function resolveTerminalConstructor(runtime) {
+    const constructor = runtime.Terminal ?? runtime.default?.Terminal ?? runtime["module.exports"]?.Terminal;
+    if (!constructor) {
+        throw new Error("Unable to load @xterm/headless Terminal export.");
+    }
+    return constructor;
+}

package/dist/version.js

@@ -0,0 +1 @@
+export const version = "0.1.0";