@aria-cli/cli 1.0.51 → 1.0.54

package/dist/history/conversation-message.js

@@ -1,112 +0,0 @@
-/**
- * ConversationMessage — CLI-specific UI bridge.
- *
- * Re-exports all core types and functions from @aria-cli/aria,
- * and provides the UI-specific bridge function for rendering.
- */
-// Re-export everything from the aria package
-export * from "@aria-cli/aria/history/conversation-message.js";
-// ---------------------------------------------------------------------------
-// UI Bridge - converts ConversationMessage[] to HistoryMessage[] for rendering
-// ---------------------------------------------------------------------------
-/**
- * Convert ConversationMessage[] to the legacy HistoryMessage[] format
- * used by the existing CLI UI components.
- *
- * This bridges the new unified message format to the old rendering pipeline.
- */
-export function conversationMessageToHistoryMessages(messages) {
-    const items = [];
-    for (const msg of messages) {
-        for (const block of msg.content) {
-            switch (block.type) {
-                case "thinking":
-                    items.push({
-                        id: `thinking-${crypto.randomUUID()}`,
-                        role: "thinking_history",
-                        content: block.content,
-                        wordCount: block.wordCount,
-                        durationSeconds: block.durationMs != null ? block.durationMs / 1000 : undefined,
-                        verb: block.verb,
-                        arionName: msg.arion?.name,
-                        arionEmoji: msg.arion?.emoji,
-                        arionColor: msg.arion?.color,
-                    });
-                    break;
-                case "tool_use":
-                    items.push({
-                        id: `tool-${crypto.randomUUID()}`,
-                        role: "tool_history",
-                        tool: {
-                            id: block.id,
-                            name: block.name,
-                            args: block.arguments,
-                            status: "pending",
-                            startTime: undefined,
-                            endTime: undefined,
-                        },
-                    });
-                    break;
-                case "tool_result": {
-                    // Find matching tool_history across ALL messages and update its result/status
-                    let toolItem;
-                    for (let idx = items.length - 1; idx >= 0; idx--) {
-                        const item = items[idx];
-                        if (item.role === "tool_history" &&
-                            item.tool.id === block.toolUseId) {
-                            toolItem = item;
-                            break;
-                        }
-                    }
-                    if (toolItem) {
-                        toolItem.tool.status = block.status === "error" ? "error" : "complete";
-                        if (block.status === "error") {
-                            toolItem.tool.error = block.content;
-                        }
-                        else {
-                            toolItem.tool.result = block.content;
-                        }
-                        if (block.resultData !== undefined) {
-                            toolItem.tool.resultData = block.resultData;
-                        }
-                        if (block.durationMs !== undefined) {
-                            toolItem.tool.durationMs = block.durationMs;
-                        }
-                        if (block.usage !== undefined) {
-                            toolItem.tool.usage = block.usage;
-                        }
-                    }
-                    break;
-                }
-                case "handoff":
-                    items.push({
-                        id: `handoff-${crypto.randomUUID()}`,
-                        role: "handoff_history",
-                        target: block.target,
-                        direction: block.direction,
-                    });
-                    break;
-                case "error":
-                    items.push({
-                        id: `error-${crypto.randomUUID()}`,
-                        role: "error",
-                        content: block.content,
-                        suggestion: block.suggestion,
-                    });
-                    break;
-                case "text":
-                    items.push({
-                        id: `msg-${crypto.randomUUID()}`,
-                        role: msg.role,
-                        content: block.text,
-                        arion: msg.arion
-                            ? { name: msg.arion.name, emoji: msg.arion.emoji, color: msg.arion.color }
-                            : undefined,
-                    });
-                    break;
-            }
-        }
-    }
-    return items;
-}
-//# sourceMappingURL=conversation-message.js.map

package/dist/history/index.js

@@ -1,8 +0,0 @@
-// packages/cli/src/history/index.ts
-export { SessionHistory } from "./SessionHistory.js";
-export { SessionHistoryClient } from "./SessionHistoryClient.js";
-export { repairToolCallPairing } from "./repair-tool-pairing.js";
-export { ContentBlockSchema, ArionRefSchema, ConversationMessageSchema, createUserMessage, createSystemMessage, createErrorMessage, createIncomingMessagePair, toModelMessages, fromModelMessages, fromV1Columns, conversationMessageToHistoryMessages, extractTextContent, extractToolCalls, extractThinking, extractToolCallId, } from "./conversation-message.js";
-export { TurnAccumulator } from "./turn-accumulator.js";
-export { replaySessionFromJsonl, findJsonlForSession, mergeWithJsonlRecovery, } from "./jsonl-replay.js";
-//# sourceMappingURL=index.js.map

package/dist/history/jsonl-replay.js

@@ -1,154 +0,0 @@
-/**
- * JSONL Replay — reconstructs ConversationMessage[] from a JSONL event log.
- *
- * The JsonlEventLogger writes every RunEvent to disk as newline-delimited JSON.
- * This module reads those logs back and feeds them through a TurnAccumulator
- * to reconstruct the conversation messages for crash recovery and session resume.
- *
- * Each JSONL line has the shape: { ts: string, event: RunEvent }
- */
-import { readFileSync, existsSync } from "node:fs";
-import { TurnAccumulator } from "./turn-accumulator.js";
-import { createUserMessage } from "./conversation-message.js";
-/**
- * Replay a JSONL event log file and reconstruct ConversationMessage[].
- *
- * Feeds each RunEvent through a fresh TurnAccumulator. On turn boundaries
- * (turn_complete events), the accumulator flushes and messages are collected.
- * Any remaining pending content is flushed at the end (handles mid-turn crashes).
- *
- * Returns user + assistant + tool messages. User messages are captured via
- * synthetic `user_message` events logged before each LLM call.
- */
-export function replaySessionFromJsonl(jsonlPath) {
-    if (!existsSync(jsonlPath))
-        return [];
-    const raw = readFileSync(jsonlPath, "utf-8");
-    const lines = raw.split("\n").filter((line) => line.trim().length > 0);
-    const accumulator = new TurnAccumulator();
-    const allMessages = [];
-    for (const line of lines) {
-        let entry;
-        try {
-            entry = JSON.parse(line);
-        }
-        catch {
-            // Malformed line (truncated on crash) — skip
-            continue;
-        }
-        if (!entry.event || typeof entry.event.type !== "string")
-            continue;
-        // User messages are logged as synthetic events — not RunEvents.
-        // Convert them directly to ConversationMessage without the accumulator.
-        if (entry.event.type === "user_message") {
-            // Flush any pending assistant content before the user message
-            if (accumulator.hasPendingContent()) {
-                allMessages.push(...accumulator.flush());
-            }
-            const content = entry.event.content ?? "";
-            const id = entry.event.id;
-            const userMsg = createUserMessage(content);
-            if (id)
-                userMsg.id = id;
-            allMessages.push(userMsg);
-            continue;
-        }
-        // Feed the RunEvent through the accumulator
-        const signal = accumulator.ingest(entry.event);
-        if (signal === "flush") {
-            const turnMessages = accumulator.flush();
-            allMessages.push(...turnMessages);
-        }
-    }
-    // Flush any remaining pending content (mid-turn crash recovery)
-    if (accumulator.hasPendingContent()) {
-        const partial = accumulator.flush();
-        allMessages.push(...partial);
-    }
-    return allMessages;
-}
-/**
- * Find the JSONL log file for a session within an Arion's log directory.
- * Returns the file path if found, null otherwise.
- *
- * JSONL files are named {sessionId}.jsonl under the Arion's logs/ directory.
- */
-/**
- * Extract a content fingerprint from a ConversationMessage for identity-based dedup.
- *
- * Uses API-assigned identifiers (tool_use IDs, tool_result references) when available —
- * these are stable across replays. Falls back to role+content text for messages without
- * tool blocks (user text, assistant text), since their UUIDs are regenerated on replay.
- */
-function extractContentFingerprint(msg) {
-    for (const block of msg.content) {
-        if (block.type === "tool_use" && block.id) {
-            return `tool_use:${block.id}`;
-        }
-        if (block.type === "tool_result" && block.toolUseId) {
-            return `tool_result:${block.toolUseId}`;
-        }
-    }
-    // Text-only messages: fingerprint by role + text content (stable across replays)
-    const text = msg.content
-        .filter((b) => b.type === "text")
-        .map((b) => b.text)
-        .join("");
-    return `${msg.role}:${text}`;
-}
-/**
- * Merge SQLite messages with JSONL-replayed messages for crash recovery.
- *
- * Strategy: SQLite is the primary store; JSONL fills gaps from crash recovery.
- * Uses content-based identity (tool_use IDs, tool_result references) to detect
- * which JSONL messages are truly missing from SQLite, avoiding the position-based
- * counting that breaks when JSONL accumulates events across multiple session runs
- * with different message coalescing boundaries.
- *
- * Returns { messages, backfillMessages } where backfillMessages are the
- * messages JSONL had that SQLite was missing (for SQLite index backfill).
- */
-export function mergeWithJsonlRecovery(sqliteMessages, jsonlPath) {
-    if (!jsonlPath) {
-        return { messages: sqliteMessages, backfillMessages: [] };
-    }
-    let jsonlMessages;
-    try {
-        jsonlMessages = replaySessionFromJsonl(jsonlPath);
-    }
-    catch {
-        return { messages: sqliteMessages, backfillMessages: [] };
-    }
-    if (jsonlMessages.length === 0) {
-        return { messages: sqliteMessages, backfillMessages: [] };
-    }
-    // If SQLite already has at least as many messages, it's complete.
-    if (sqliteMessages.length >= jsonlMessages.length) {
-        return { messages: sqliteMessages, backfillMessages: [] };
-    }
-    // JSONL has more messages than SQLite — crash recovery needed.
-    // Use content-based identity to find which JSONL messages are truly missing.
-    // Tool_use IDs and tool_result references are API-assigned and stable across replays.
-    const sqliteFingerprints = new Set(sqliteMessages.map(extractContentFingerprint));
-    const backfillMessages = [];
-    for (const msg of jsonlMessages) {
-        const fp = extractContentFingerprint(msg);
-        if (!sqliteFingerprints.has(fp)) {
-            backfillMessages.push(msg);
-        }
-    }
-    // Combine: SQLite messages (primary, in persisted order) + truly new JSONL messages
-    const messages = [...sqliteMessages, ...backfillMessages];
-    return { messages, backfillMessages };
-}
-export function findJsonlForSession(ariaDir, arionName, sessionId) {
-    const perArionPath = `${ariaDir}/arions/${arionName}/logs/${sessionId}.jsonl`;
-    if (existsSync(perArionPath))
-        return perArionPath;
-    // Fallback: check legacy global path
-    const globalPath = `${ariaDir}/logs/${sessionId}.jsonl`;
-    if (existsSync(globalPath))
-        return globalPath;
-    return null;
-}
-//# sourceMappingURL=jsonl-replay.js.map

package/dist/history/repair-tool-pairing.js

@@ -1,84 +0,0 @@
-function hasMeaningfulAssistantContent(content) {
-    return typeof content !== "string" || content.trim().length > 0;
-}
-function stripToolCalls(msg) {
-    const { toolCalls, ...rest } = msg;
-    return rest;
-}
-function hasToolResultLater(messages, startIdx, toolCallId) {
-    for (let i = startIdx; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role === "tool" && msg.toolCallId === toolCallId) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Repair tool call/result pairing in a message sequence.
- *
- * Ensures:
- * 1. Every tool result has a matching tool call (removes orphans)
- * 2. Every tool call has a matching result (adds synthetic "interrupted" result)
- * 3. Synthetic results are placed AFTER real results for the same assistant (R2-C3)
- * 4. Tool messages without toolCallId are removed (R2 F-10)
- * 5. thoughtSignature is preserved on tool calls (Gemini requirement)
- *
- * Inspired by Codex's normalize_history() and OpenClaw's repairToolUseResultPairing().
- */
-export function repairToolCallPairing(messages) {
-    const result = [];
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role === "assistant" && msg.toolCalls?.length) {
-            const toolCallIds = new Set(msg.toolCalls.map((tc) => tc.id));
-            const immediateResultIds = new Set();
-            const immediateToolResults = [];
-            let cursor = i + 1;
-            while (cursor < messages.length && messages[cursor].role === "tool") {
-                const toolMsg = messages[cursor];
-                if (toolMsg.toolCallId &&
-                    toolCallIds.has(toolMsg.toolCallId) &&
-                    !immediateResultIds.has(toolMsg.toolCallId)) {
-                    immediateResultIds.add(toolMsg.toolCallId);
-                    immediateToolResults.push(toolMsg);
-                }
-                cursor++;
-            }
-            const keptToolCalls = msg.toolCalls.filter((tc) => {
-                if (immediateResultIds.has(tc.id)) {
-                    return true;
-                }
-                return !hasToolResultLater(messages, cursor, tc.id);
-            });
-            const syntheticCalls = keptToolCalls.filter((tc) => !immediateResultIds.has(tc.id));
-            if (keptToolCalls.length === msg.toolCalls.length) {
-                result.push(msg);
-            }
-            else if (keptToolCalls.length > 0) {
-                result.push({ ...msg, toolCalls: keptToolCalls });
-            }
-            else if (hasMeaningfulAssistantContent(msg.content)) {
-                result.push(stripToolCalls(msg));
-            }
-            result.push(...immediateToolResults);
-            for (const tc of syntheticCalls) {
-                result.push({
-                    role: "tool",
-                    content: `[Tool execution interrupted — no result for ${tc.name}]`,
-                    toolCallId: tc.id,
-                });
-            }
-            i = cursor - 1;
-            continue;
-        }
-        // Tool messages are only valid when consumed as part of the immediate
-        // assistant -> tool_result boundary handled above.
-        if (msg.role === "tool") {
-            continue;
-        }
-        result.push(msg);
-    }
-    return result;
-}
-//# sourceMappingURL=repair-tool-pairing.js.map

package/dist/history/stall-phase-bridge.js

@@ -1,11 +0,0 @@
-/**
- * Bridge between SessionHistory's injectable stall-phase callbacks and
- * the CLI's event-loop watchdog.
- */
-import { setStallPhase, clearStallPhase, getStallPhase } from "../event-loop-watchdog.js";
-export const cliStallPhase = {
-    get: getStallPhase,
-    set: setStallPhase,
-    clear: clearStallPhase,
-};
-//# sourceMappingURL=stall-phase-bridge.js.map