parallel-codex-tui 0.1.0 → 0.1.4

package/dist/tui/RouterDiagnosticsView.js

@@ -0,0 +1,469 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo } from "react";
+import { basename, resolve } from "node:path";
+import { Box, Text } from "ink";
+import { classifyRouterFailure, diagnoseRouterFailure } from "../core/router-audit.js";
+import { routerCommandLabel, routerProxyContext } from "../core/router.js";
+import { compactEndByDisplayWidth, displayWidth, wrapByDisplayWidth } from "./display-width.js";
+import { formatRouteStatus } from "./status-line.js";
+import { TUI_THEME } from "./theme.js";
+export function routerDiagnosticsPolicy(router, env = process.env) {
+    const proxy = routerProxyContext(router.codex.env, env);
+    return {
+        mode: router.defaultMode,
+        command: routerCommandLabel(router.codex.command),
+        timeoutMs: router.codex.timeoutMs,
+        firstOutputTimeoutMs: router.codex.firstOutputTimeoutMs,
+        idleTimeoutMs: router.codex.idleTimeoutMs,
+        maxOutputBytes: router.codex.maxOutputBytes,
+        maxAttempts: router.codex.maxAttempts,
+        retryDelayMs: router.codex.retryDelayMs,
+        followUpTimeoutMs: router.codex.followUpTimeoutMs,
+        fallback: router.codex.fallback,
+        proxyConfigured: proxy.configured,
+        proxySource: proxy.configured ? proxy.source : null,
+        proxyVariable: proxy.configured ? proxy.variable : null,
+        proxyEndpoint: proxy.configured ? proxy.endpoint : null
+    };
+}
+export function RouterDiagnosticsView({ records, policy, loading = false, error = null, currentWorkspace = "", scope = "all", scrollOffset = 0, height = 20, terminalWidth = process.stdout.columns || 120, onViewportChange }) {
+    const lines = useMemo(() => routerDiagnosticsDisplayLines(records, policy, terminalWidth, {
+        loading,
+        error,
+        currentWorkspace,
+        scope
+    }), [currentWorkspace, error, loading, policy, records, scope, terminalWidth]);
+    const viewportHeight = Math.max(1, height);
+    const maxOffset = Math.max(0, lines.length - viewportHeight);
+    const clampedOffset = Math.min(maxOffset, Math.max(0, Math.trunc(scrollOffset)));
+    const visible = lines.slice(clampedOffset, clampedOffset + viewportHeight);
+    const blankRows = Math.max(0, viewportHeight - visible.length);
+    const contentWidth = routerDiagnosticsContentWidth(terminalWidth);
+    useEffect(() => {
+        onViewportChange?.({ offset: clampedOffset, maxOffset });
+    }, [clampedOffset, maxOffset, onViewportChange]);
+    return (_jsxs(Box, { flexDirection: "column", height: viewportHeight, children: [visible.map((line, index) => (_jsx(RouterDiagnosticRow, { line: line, width: contentWidth }, `${clampedOffset + index}-${line.tone}`))), Array.from({ length: blankRows }, (_, index) => (_jsx(Text, { backgroundColor: TUI_THEME.surface, children: " ".repeat(contentWidth) }, `router-diagnostic-fill-${index}`)))] }));
+}
+export function routerDiagnosticsDisplayLines(records, policy, terminalWidth, state = {}) {
+    const width = routerDiagnosticsContentWidth(terminalWidth);
+    const scope = state.scope ?? "all";
+    const currentWorkspace = state.currentWorkspace ?? "";
+    const visibleRecords = filterRouterAuditRecords(records, currentWorkspace, scope);
+    const codexCount = visibleRecords.filter((record) => record.source === "codex").length;
+    const recoveredCount = visibleRecords.filter((record) => (record.source === "codex" && Boolean(record.router_recovered_from))).length;
+    const retryCount = visibleRecords.filter((record) => (record.source === "fallback" && record.router_fallback_resolution === "auto-retry")).length;
+    const fallbackCount = visibleRecords.filter((record) => (record.source === "fallback" && record.router_fallback_resolution !== "auto-retry")).length;
+    const forcedCount = visibleRecords.filter((record) => record.source === "forced").length;
+    const timeoutCount = visibleRecords.filter((record) => routerAuditFailureKind(record) === "timeout").length;
+    const workspaceCount = new Set(records.map((record) => normalizedWorkspace(record.workspace))).size;
+    const proxyRecordCount = visibleRecords.filter(routerAuditHasProxyContext).length;
+    const budget = routerDiagnosticsBudget(visibleRecords, policy);
+    const health = [
+        `health · codex ${codexCount}`,
+        ...(recoveredCount > 0 ? [`recovered ${recoveredCount}`] : []),
+        `fallback ${fallbackCount}`,
+        ...(retryCount > 0 ? [`retry ${retryCount}`] : []),
+        ...(forcedCount > 0 ? [`forced ${forcedCount}`] : []),
+        ...(timeoutCount > 0 ? [`timeout ${timeoutCount}`] : [])
+    ].join(" · ");
+    const logical = [
+        { text: "Router diagnostics", tone: "heading" },
+        {
+            text: routerDiagnosticsScopeText(scope, currentWorkspace, visibleRecords.length, records.length, workspaceCount),
+            tone: "text"
+        },
+        { text: health, tone: fallbackCount > 0 || retryCount > 0 ? "warning" : "success" },
+        { text: routerDiagnosticsLatencyText(visibleRecords), tone: "muted" },
+        budget,
+        {
+            text: [
+                `policy · ${policy.mode}`,
+                ...(policy.command !== "codex" ? [`runner ${policy.command}`] : []),
+                `total ${formatDiagnosticDuration(policy.timeoutMs)} / ${formatDiagnosticDuration(policy.followUpTimeoutMs)}`,
+                `first ${formatDiagnosticDuration(policy.firstOutputTimeoutMs)}`,
+                `idle ${formatDiagnosticDuration(policy.idleTimeoutMs)}`,
+                `retry ${policy.maxAttempts}x / ${formatDiagnosticDuration(policy.retryDelayMs)}`,
+                `fallback ${policy.fallback}`
+            ].join(" · "),
+            tone: "muted"
+        },
+        {
+            text: `guard · output ${formatDiagnosticBytes(policy.maxOutputBytes)} · ${routerDiagnosticsProxyPolicy(policy, proxyRecordCount)}`,
+            tone: policy.proxyConfigured || proxyRecordCount > 0 ? "warning" : "muted"
+        },
+        { text: "Recent routes", tone: "heading" }
+    ];
+    if (state.loading) {
+        logical.push({ text: "loading route audit", tone: "muted" });
+    }
+    else if (state.error) {
+        logical.push({ text: `error · ${safeDiagnosticText(state.error)}`, tone: "danger" });
+    }
+    else if (visibleRecords.length === 0) {
+        logical.push({
+            text: scope === "workspace" ? "no route records for current workspace" : "no route records",
+            tone: "muted"
+        });
+    }
+    else {
+        for (const record of [...visibleRecords].reverse()) {
+            const workspace = basename(record.workspace) || record.workspace;
+            logical.push({
+                text: routerAuditHeading(record, workspace, width),
+                tone: record.source === "fallback" ? "warning" : record.source === "codex" ? "success" : "muted"
+            });
+            logical.push({ text: `request · ${boundedDiagnosticText(record.request)}`, tone: "text" });
+            const evidence = routerAuditEvidence(record);
+            if (evidence) {
+                logical.push({ text: evidence, tone: "warning" });
+            }
+            const trace = routerAuditTraceLines(record);
+            if (record.source === "fallback") {
+                const diagnosis = diagnoseRouterFailure(record);
+                logical.push({ text: `diagnosis · ${diagnosis.summary}`, tone: "danger" });
+                logical.push({ text: `next · ${diagnosis.action}`, tone: "warning" });
+            }
+            for (const line of trace) {
+                logical.push({ text: line, tone: "muted" });
+            }
+            logical.push({ text: `reason · ${boundedDiagnosticText(record.reason)}`, tone: "muted" });
+        }
+    }
+    return logical.flatMap((line) => wrapDiagnosticLine(line, width));
+}
+export function filterRouterAuditRecords(records, currentWorkspace, scope) {
+    if (scope === "all" || !currentWorkspace.trim()) {
+        return records;
+    }
+    const current = normalizedWorkspace(currentWorkspace);
+    return records.filter((record) => normalizedWorkspace(record.workspace) === current);
+}
+function RouterDiagnosticRow({ line, width }) {
+    const fill = Math.max(0, width - displayWidth(line.text));
+    return (_jsxs(Text, { children: [_jsx(Text, { ...routerDiagnosticLineTheme(line.tone), children: line.text }), fill > 0 ? _jsx(Text, { backgroundColor: TUI_THEME.surface, children: " ".repeat(fill) }) : null] }));
+}
+function routerDiagnosticLineTheme(tone) {
+    return {
+        backgroundColor: TUI_THEME.surface,
+        color: tone === "heading"
+            ? TUI_THEME.accent
+            : tone === "success"
+                ? TUI_THEME.success
+                : tone === "warning"
+                    ? TUI_THEME.warning
+                    : tone === "danger"
+                        ? TUI_THEME.danger
+                        : tone === "muted"
+                            ? TUI_THEME.muted
+                            : TUI_THEME.text,
+        ...(tone === "heading" || tone === "danger" ? { bold: true } : {})
+    };
+}
+function routerAuditStatus(record) {
+    const route = record.router_failure_kind || !record.failure_kind
+        ? record
+        : { ...record, router_failure_kind: record.failure_kind };
+    const formatted = formatRouteStatus(route).replace(/^route\s+/, "");
+    const parts = formatted.split(/\s+·\s+/);
+    if (record.router_command && record.router_command !== "codex") {
+        const sourceIndex = parts.findIndex((part) => part === "codex" || part === "fallback" || part === "forced");
+        parts.splice(Math.max(1, sourceIndex + 1), 0, `runner ${safeDiagnosticText(record.router_command)}`);
+    }
+    if (record.source === "codex") {
+        parts.splice(1, 0, "codex");
+    }
+    return parts.join(" · ");
+}
+function routerAuditHeading(record, workspace, width) {
+    const prefix = `${record.time.slice(11, 19)} · `;
+    const suffix = ` · ${record.scope} · ${routerAuditStatus(record)}`;
+    const safeWorkspace = safeDiagnosticText(workspace);
+    const minimumWorkspaceWidth = Math.min(12, displayWidth(safeWorkspace));
+    const workspaceWidth = Math.max(minimumWorkspaceWidth, width - displayWidth(prefix) - displayWidth(suffix));
+    return `${prefix}${compactEndByDisplayWidth(safeWorkspace, workspaceWidth)}${suffix}`;
+}
+function routerDiagnosticsScopeText(scope, currentWorkspace, visibleCount, totalCount, workspaceCount) {
+    if (scope === "workspace") {
+        const workspace = basename(currentWorkspace) || currentWorkspace || "unknown";
+        return `scope · current · ${safeDiagnosticText(workspace)} · ${visibleCount}/${totalCount} routes`;
+    }
+    return `scope · all · ${visibleCount}/${totalCount} routes · ${workspaceCount} ${workspaceCount === 1 ? "workspace" : "workspaces"}`;
+}
+function routerDiagnosticsLatencyText(records) {
+    const durations = successfulRouterDurations(records);
+    if (durations.length === 0) {
+        return "latency · no successful Codex routes";
+    }
+    return [
+        `latency · successful attempts p50 ${formatDiagnosticDuration(routerDurationPercentile(durations, 0.5))}`,
+        `p95 ${formatDiagnosticDuration(routerDurationPercentile(durations, 0.95))}`,
+        `max ${formatDiagnosticDuration(durations.at(-1) ?? 0)}`,
+        `n ${durations.length}`
+    ].join(" · ");
+}
+export function routerDiagnosticsBudget(records, policy) {
+    const initial = routerBudgetSegment("initial", policy.timeoutMs, successfulRouterDurations(records, "initial"), 20000, 60000);
+    const followUp = routerBudgetSegment("follow-up", policy.followUpTimeoutMs, successfulRouterDurations(records, "follow-up"), 15000, 45000);
+    const states = [initial.state, followUp.state];
+    return {
+        text: `budget · ${initial.text} · ${followUp.text}`,
+        tone: states.some((state) => state === "tight" || state === "high")
+            ? "warning"
+            : states.every((state) => state === "no-data" || state === "learning")
+                ? "muted"
+                : "success"
+    };
+}
+function successfulRouterDurations(records, scope) {
+    return records
+        .filter((record) => record.source === "codex" && (!scope || record.scope === scope))
+        .map((record) => record.duration_ms)
+        .filter((duration) => (typeof duration === "number" && Number.isFinite(duration) && duration > 0))
+        .sort((left, right) => left - right);
+}
+function routerBudgetSegment(label, configuredMs, durations, minimumMs, maximumMs) {
+    if (durations.length === 0) {
+        return {
+            text: `${label} no data · ${formatDiagnosticDuration(configuredMs)}`,
+            state: "no-data"
+        };
+    }
+    const p95 = routerDurationPercentile(durations, 0.95);
+    const recommendedMs = Math.min(maximumMs, Math.max(minimumMs, Math.ceil((p95 * 2) / 1000) * 1000));
+    const state = durations.length < 3
+        ? "learning"
+        : configuredMs < p95 * 1.5
+            ? "tight"
+            : configuredMs > recommendedMs * 2
+                ? "high"
+                : "healthy";
+    return {
+        text: [
+            `${label} ${state}`,
+            `${formatDiagnosticDuration(configuredMs)} / p95 ${formatDiagnosticDuration(p95)}`,
+            `n ${durations.length}`,
+            ...(state === "tight" || state === "high" ? [`consider ${formatDiagnosticDuration(recommendedMs)}`] : [])
+        ].join(" · "),
+        state
+    };
+}
+function routerDurationPercentile(sortedDurations, percentile) {
+    const index = Math.max(0, Math.ceil(sortedDurations.length * percentile) - 1);
+    return sortedDurations[Math.min(sortedDurations.length - 1, index)] ?? 0;
+}
+function routerAuditEvidence(record) {
+    if (record.source !== "fallback") {
+        return null;
+    }
+    const kind = routerAuditFailureKind(record) ?? "unknown";
+    const parts = [`evidence · ${routerFailureKindLabel(kind)}`];
+    if (record.router_command && record.router_command !== "codex") {
+        parts.push(`runner ${safeDiagnosticText(record.router_command)}`);
+    }
+    if (kind === "timeout" && record.router_timeout_kind) {
+        parts.push(record.router_timeout_kind.replaceAll("-", " "));
+    }
+    const stage = routerFailureStageLabel(record);
+    if (stage) {
+        parts.push(stage);
+    }
+    if (kind === "timeout") {
+        const timeoutMs = routerAuditTimeoutLimit(record);
+        if (typeof timeoutMs === "number") {
+            parts.push(`limit ${formatDiagnosticDuration(timeoutMs)}`);
+        }
+    }
+    if (routerAuditHasProxyContext(record)) {
+        parts.push(record.proxy_endpoint ? `via ${record.proxy_endpoint}` : "proxy configured");
+        if (record.proxy_source || record.proxy_variable) {
+            parts.push([
+                record.proxy_source ? routerProxySourceLabel(record.proxy_source) : "proxy",
+                record.proxy_variable
+            ].filter(Boolean).join(" "));
+        }
+        parts.push("cause unproven");
+    }
+    else if (record.proxy_configured === false) {
+        parts.push("direct path");
+    }
+    const resolution = routerFallbackResolutionLabel(record.router_fallback_resolution);
+    if (resolution) {
+        parts.push(resolution);
+    }
+    parts.push(`fallback ${record.mode}`);
+    return parts.join(" · ");
+}
+function routerAuditTimeoutLimit(record) {
+    if (record.router_timeout_kind === "first-output") {
+        return record.router_first_output_timeout_ms ?? record.duration_ms;
+    }
+    if (record.router_timeout_kind === "idle") {
+        return record.router_idle_timeout_ms ?? record.duration_ms;
+    }
+    return record.router_timeout_ms ?? record.duration_ms;
+}
+function routerAuditTraceLines(record) {
+    const stages = [
+        ...(typeof record.router_dispatch_ms === "number"
+            ? [`dispatch ${formatDiagnosticDuration(record.router_dispatch_ms)}`]
+            : []),
+        ...(typeof record.router_spawn_ms === "number"
+            ? [`spawn ${formatDiagnosticDuration(record.router_spawn_ms)}`]
+            : []),
+        ...routerFirstOutputTraceParts(record),
+        ...(typeof record.router_process_ms === "number"
+            ? [`process ${formatDiagnosticDuration(record.router_process_ms)}`]
+            : []),
+        ...(typeof record.router_parse_ms === "number"
+            ? [`parse ${formatDiagnosticDuration(record.router_parse_ms)}`]
+            : [])
+    ];
+    const io = [
+        ...(typeof record.router_stdout_bytes === "number"
+            ? [`stdout ${formatDiagnosticBytes(record.router_stdout_bytes)}`]
+            : []),
+        ...(typeof record.router_stderr_bytes === "number"
+            ? [`stderr ${formatDiagnosticBytes(record.router_stderr_bytes)}`]
+            : [])
+    ];
+    if (stages.length === 0 && io.length === 0) {
+        return [];
+    }
+    if (typeof record.duration_ms === "number") {
+        stages.push(`attempt ${formatDiagnosticDuration(record.duration_ms)}`);
+    }
+    if (typeof record.router_total_duration_ms === "number"
+        && typeof record.router_attempt === "number"
+        && record.router_attempt > 1) {
+        stages.push(`journey ${formatDiagnosticDuration(record.router_total_duration_ms)}`);
+    }
+    return [
+        ...(stages.length > 0 ? [`trace · ${stages.join(" · ")}`] : []),
+        ...(io.length > 0 ? [`io · ${io.join(" · ")}`] : [])
+    ];
+}
+function routerFirstOutputTraceParts(record) {
+    const streams = [
+        ...(typeof record.router_first_stdout_ms === "number"
+            ? [{ at: record.router_first_stdout_ms, text: `first stdout ${formatDiagnosticDuration(record.router_first_stdout_ms)}` }]
+            : []),
+        ...(typeof record.router_first_stderr_ms === "number"
+            ? [{ at: record.router_first_stderr_ms, text: `first stderr ${formatDiagnosticDuration(record.router_first_stderr_ms)}` }]
+            : [])
+    ];
+    if (streams.length > 0) {
+        return streams.sort((left, right) => left.at - right.at).map((stream) => stream.text);
+    }
+    if (typeof record.router_first_output_ms === "number") {
+        return [`first output ${formatDiagnosticDuration(record.router_first_output_ms)}`];
+    }
+    return record.router_failure_stage === "waiting-output" ? ["first output none"] : [];
+}
+function routerAuditFailureKind(record) {
+    return record.failure_kind ?? classifyRouterFailure(record.reason);
+}
+function routerAuditHasProxyContext(record) {
+    if (typeof record.proxy_configured === "boolean") {
+        return record.proxy_configured;
+    }
+    return /\bproxy\b|代理/i.test(record.reason);
+}
+function routerDiagnosticsProxyPolicy(policy, recorded) {
+    if (!policy.proxyConfigured) {
+        return `proxy · direct now · ${recorded} recorded · context only`;
+    }
+    return [
+        "proxy",
+        policy.proxySource ? routerProxySourceLabel(policy.proxySource) : "configured now",
+        policy.proxyVariable,
+        policy.proxyEndpoint,
+        `${recorded} recorded`,
+        "context only"
+    ].filter(Boolean).join(" · ");
+}
+function routerProxySourceLabel(source) {
+    return source === "router-config" ? "router config" : "environment";
+}
+function routerFailureKindLabel(kind) {
+    return kind.replaceAll("-", " ");
+}
+function routerFailureStageLabel(record) {
+    const stage = record.router_failure_stage;
+    if (stage === "waiting-output") {
+        return "waiting output";
+    }
+    if (stage === "streaming") {
+        if (record.router_stdout_bytes && record.router_stdout_bytes > 0) {
+            return "after stdout";
+        }
+        if (record.router_stderr_bytes && record.router_stderr_bytes > 0) {
+            return "after stderr";
+        }
+        return "after output";
+    }
+    if (stage === "response") {
+        return "response parse";
+    }
+    return stage ?? null;
+}
+function routerFallbackResolutionLabel(resolution) {
+    if (resolution === "main") {
+        return "resolved Main";
+    }
+    if (resolution === "parallel") {
+        return "resolved Parallel";
+    }
+    if (resolution === "retry") {
+        return "Router retry requested";
+    }
+    if (resolution === "auto-retry") {
+        return "automatic retry";
+    }
+    if (resolution === "cancelled") {
+        return "cancelled by user";
+    }
+    if (resolution === "configured") {
+        return "configured fallback";
+    }
+    return null;
+}
+function normalizedWorkspace(workspace) {
+    return resolve(workspace.trim());
+}
+function wrapDiagnosticLine(line, width) {
+    if (!line.text) {
+        return [line];
+    }
+    return wrapByDisplayWidth(line.text, width).map((text) => ({ ...line, text }));
+}
+function boundedDiagnosticText(value) {
+    const safe = safeDiagnosticText(value).replace(/\s+/g, " ").trim();
+    const characters = Array.from(safe);
+    return characters.length <= 320
+        ? safe
+        : `${characters.slice(0, 308).join("")} [truncated]`;
+}
+function safeDiagnosticText(value) {
+    return value
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ")
+        .replace(/\b([a-z][a-z0-9+.-]*:\/\/)([^@\s/]+)@/gi, "$1***@");
+}
+function formatDiagnosticDuration(durationMs) {
+    if (durationMs < 1000) {
+        return `${Math.round(durationMs)}ms`;
+    }
+    return `${(durationMs / 1000).toFixed(durationMs % 1000 === 0 ? 0 : 1)}s`;
+}
+function formatDiagnosticBytes(bytes) {
+    if (bytes < 1024) {
+        return `${Math.round(bytes)}B`;
+    }
+    if (bytes >= 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(bytes < 10 * 1024 * 1024 ? 1 : 0).replace(/\.0$/, "")}MB`;
+    }
+    return `${(bytes / 1024).toFixed(bytes < 10 * 1024 ? 1 : 0)}KB`;
+}
+function routerDiagnosticsContentWidth(terminalWidth) {
+    return Math.max(1, terminalWidth - 2);
+}