@aria-cli/cli 1.0.14

package/dist/history/conversation-message.d.ts

@@ -0,0 +1,181 @@
+/**
+ * ConversationMessage — the single message type for all rendering and resume pipelines.
+ *
+ * Provides:
+ * - Zod schemas + inferred types (ContentBlock, ConversationMessage, ArionRef)
+ * - Factory helpers (createUserMessage, createSystemMessage)
+ * - Bidirectional conversion: toModelMessages / fromModelMessages
+ * - v1 DB migration: fromV1Columns
+ * - Bridge to existing UI: conversationMessageToHistoryMessages
+ * - Extract helpers for backward-compat INSERT
+ */
+import { z } from "zod";
+import type { Message } from "@aria-cli/types";
+import type { HistoryMessage } from "../ui/components/ConversationHistory.js";
+export declare const ContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"thinking">;
+    content: z.ZodString;
+    wordCount: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    verb: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    id: z.ZodString;
+    name: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    thoughtSignature: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    toolUseId: z.ZodString;
+    content: z.ZodString;
+    status: z.ZodEnum<{
+        success: "success";
+        error: "error";
+    }>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    resultData: z.ZodOptional<z.ZodUnknown>;
+    usage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        estimatedCost: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"handoff">;
+    target: z.ZodString;
+    direction: z.ZodEnum<{
+        to: "to";
+        from: "from";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    content: z.ZodString;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export declare const ArionRefSchema: z.ZodObject<{
+    name: z.ZodString;
+    emoji: z.ZodString;
+    color: z.ZodOptional<z.ZodEnum<{
+        cyan: "cyan";
+        magenta: "magenta";
+        yellow: "yellow";
+        green: "green";
+        blue: "blue";
+        red: "red";
+        white: "white";
+    }>>;
+}, z.core.$strip>;
+export declare const ConversationMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+        system: "system";
+        tool: "tool";
+    }>;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"thinking">;
+        content: z.ZodString;
+        wordCount: z.ZodNumber;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        verb: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        thoughtSignature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        toolUseId: z.ZodString;
+        content: z.ZodString;
+        status: z.ZodEnum<{
+            success: "success";
+            error: "error";
+        }>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        resultData: z.ZodOptional<z.ZodUnknown>;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+            estimatedCost: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"handoff">;
+        target: z.ZodString;
+        direction: z.ZodEnum<{
+            to: "to";
+            from: "from";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        content: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    arion: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        emoji: z.ZodString;
+        color: z.ZodOptional<z.ZodEnum<{
+            cyan: "cyan";
+            magenta: "magenta";
+            yellow: "yellow";
+            green: "green";
+            blue: "blue";
+            red: "red";
+            white: "white";
+        }>>;
+    }, z.core.$strip>>;
+    costUSD: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    tokenUsage: z.ZodOptional<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ContentBlock = z.infer<typeof ContentBlockSchema>;
+export type ConversationMessage = z.infer<typeof ConversationMessageSchema>;
+export type ArionRef = z.infer<typeof ArionRefSchema>;
+export declare function createUserMessage(text: string): ConversationMessage;
+export declare function createSystemMessage(text: string): ConversationMessage;
+/**
+ * Synthesize an assistant tool_use + tool result pair that looks like
+ * `check_messages` returned an incoming message.  This lets the LLM see the
+ * message as a tool result — the most natural prompt to reply via send_message.
+ */
+export declare function createIncomingMessagePair(senderName: string, senderAddress: string, content: string, messageId?: string): [ConversationMessage, ConversationMessage];
+export declare function createErrorMessage(text: string, suggestion?: string): ConversationMessage;
+export declare function toModelMessages(msgs: ConversationMessage[]): Message[];
+export declare function fromModelMessages(msgs: Message[], metadata?: {
+    arion?: ArionRef;
+}): ConversationMessage[];
+/** Row shape from the messages table (v1 columns) */
+interface MessageRow {
+    id: number;
+    session_id: string;
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    arion: string | null;
+    tool_call_id: string | null;
+    tool_calls: string | null;
+    thinking: string | null;
+    created_at: string;
+}
+export declare function fromV1Columns(row: MessageRow): ConversationMessage;
+export declare function conversationMessageToHistoryMessages(msgs: ConversationMessage[]): HistoryMessage[];
+/** Join all text blocks into a single string */
+export declare function extractTextContent(msg: ConversationMessage): string;
+/** JSON of tool_use blocks in v1 format, or null if none */
+export declare function extractToolCalls(msg: ConversationMessage): string | null;
+/** JSON of thinking blocks in v1 format [{ id, content, wordCount }], or null if none */
+export declare function extractThinking(msg: ConversationMessage): string | null;
+/** First tool_result's toolUseId, or null if none */
+export declare function extractToolCallId(msg: ConversationMessage): string | null;
+export {};

package/dist/history/index.d.ts

@@ -0,0 +1,8 @@
+export { SessionHistory } from "./SessionHistory.js";
+export { repairToolCallPairing } from "./repair-tool-pairing.js";
+export type { SessionSummary, SessionMessage, SessionContext, LoadedSession, SessionRuntimeStateStatus, SessionInteractionStatus, SessionRuntimeState, SessionInteractionRecord, LoadedSessionState, } from "./SessionHistory.js";
+export { ContentBlockSchema, ArionRefSchema, ConversationMessageSchema, createUserMessage, createSystemMessage, createErrorMessage, createIncomingMessagePair, toModelMessages, fromModelMessages, fromV1Columns, conversationMessageToHistoryMessages, extractTextContent, extractToolCalls, extractThinking, extractToolCallId, } from "./conversation-message.js";
+export type { ContentBlock, ConversationMessage, ArionRef } from "./conversation-message.js";
+export { TurnAccumulator } from "./turn-accumulator.js";
+export type { AccumulatorSignal } from "./turn-accumulator.js";
+export { replaySessionFromJsonl, findJsonlForSession, mergeWithJsonlRecovery, } from "./jsonl-replay.js";

package/dist/history/jsonl-replay.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 type { ConversationMessage } 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 declare function replaySessionFromJsonl(jsonlPath: string): ConversationMessage[];
+/**
+ * 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 declare function mergeWithJsonlRecovery(sqliteMessages: ConversationMessage[], jsonlPath: string | null): {
+    messages: ConversationMessage[];
+    backfillMessages: ConversationMessage[];
+};
+export declare function findJsonlForSession(ariaDir: string, arionName: string, sessionId: string): string | null;

package/dist/history/repair-tool-pairing.d.ts

@@ -0,0 +1,14 @@
+import type { Message } from "@aria-cli/types";
+/**
+ * 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 declare function repairToolCallPairing(messages: Message[]): Message[];

package/dist/history/turn-accumulator.d.ts

@@ -0,0 +1,85 @@
+/**
+ * TurnAccumulator — ingests RunEvent stream events and accumulates them into
+ * ConversationMessage[] for batch persistence and rendering.
+ *
+ * Key behaviors:
+ * - text_delta → single text block on assistant message
+ * - thinking_start/delta/end → thinking block with durationMs, verb, content
+ * - tool_start → tool_use block (deduped via seenToolIds Set)
+ * - tool_args_delta → progressive JSON accumulation on tool_use arguments
+ * - tool_result → SEPARATE ConversationMessage with role="tool"
+ * - handoff_start/result → handoff blocks
+ * - messages_snapshot → stored for getSnapshotMessages()
+ * - turn_complete → returns "flush" signal
+ * - Unknown event types → returns "continue" (default case)
+ * - No error case — event loop throws before accumulator sees errors
+ */
+import type { RunEvent } from "@aria-cli/aria";
+import type { RuntimeRunEvent } from "@aria-cli/tools";
+import type { Message } from "@aria-cli/types";
+import type { ConversationMessage, ArionRef } from "./conversation-message.js";
+/**
+ * "continue" = data ingested, accumulator state updated (caller need not act).
+ * "flush"    = turn boundary — caller must call flush() and commit messages.
+ *
+ * Render scheduling is NOT the accumulator's concern. The consumer (ink-repl)
+ * polls via a fixed-interval render scheduler, making per-event-type throttle
+ * logic unnecessary and eliminating the bug class of "new event type without
+ * throttle causes excessive re-renders."
+ */
+export type AccumulatorSignal = "continue" | "flush";
+export declare class TurnAccumulator {
+    private textParts;
+    private thinkingBlocks;
+    private toolUseBlocks;
+    private handoffBlocks;
+    private toolResultMessages;
+    private seenToolIds;
+    private toolArgsAccumulator;
+    private thinkingInProgress;
+    private pendingThinkingContent;
+    private arion;
+    private verb;
+    private tokenUsage;
+    private snapshotMessages;
+    private previewAssistantId;
+    ingest(event: RunEvent | RuntimeRunEvent): AccumulatorSignal;
+    /**
+     * Flush all accumulated content into ConversationMessage[].
+     * Works anytime (including mid-accumulation for abort scenarios).
+     * Resets all state after flush.
+     */
+    flush(): ConversationMessage[];
+    /**
+     * Returns a read-only view of current accumulated state as ConversationMessage[].
+     * Does NOT reset state (unlike flush). Used for intermediate rendering.
+     * Includes in-progress thinking content and progressive text content.
+     */
+    snapshot(): ConversationMessage[];
+    /** Get snapshot messages from the most recent messages_snapshot event */
+    getSnapshotMessages(): Message[] | undefined;
+    /** Whether there is any pending content that would produce messages on flush */
+    hasPendingContent(): boolean;
+    /** Set the arion reference — propagated to all flushed messages */
+    setArion(arion: ArionRef): void;
+    /** Set the composing verb — used in thinking blocks */
+    setVerb(verb: string): void;
+    /** Accumulate token usage — attached to assistant message on flush */
+    setTokenUsage(usage: {
+        input: number;
+        output: number;
+    }): void;
+    /**
+     * Parse a partial JSON object string by trying progressive closings.
+     * Used in snapshot() to extract displayable args from in-progress tool arg streaming.
+     *
+     * Strategy (ordered by information preserved):
+     * 1. Complete parse (fast path — JSON already valid)
+     * 2. Close object with '}' (last value complete, just needs brace)
+     * 3. Close string + object with '"}' (last string value incomplete)
+     * 4. Scan backward for commas — truncate to last complete pair + close
+     *
+     * Returns undefined when no useful partial extraction is possible.
+     */
+    static tryParsePartialArgs(raw: string): Record<string, unknown> | undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @aria/cli - Simple chat interface for ARIA
+ */
+export { SessionHistory } from "./history/SessionHistory.js";
+export { startInkRepl, startInkRepl as startRepl } from "./ink-repl.js";
+export { program, createArionsCommand, createAuthCommand } from "./commands/index.js";