@aria-cli/cli 1.0.51 → 1.0.54

package/dist/history/turn-accumulator.js

@@ -1,427 +0,0 @@
-/**
- * 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
- */
-export class TurnAccumulator {
-    // --- Accumulated state ---
-    textParts = [];
-    thinkingBlocks = [];
-    toolUseBlocks = [];
-    handoffBlocks = [];
-    toolResultMessages = [];
-    // Dedup tool_start events
-    seenToolIds = new Set();
-    // Progressive JSON accumulation for tool_args_delta
-    toolArgsAccumulator = new Map();
-    // Thinking accumulation (for abort flush of partial thinking)
-    thinkingInProgress = false;
-    pendingThinkingContent = "";
-    // Metadata
-    arion;
-    verb;
-    tokenUsage;
-    // Snapshot messages
-    snapshotMessages;
-    // Stable preview ID for snapshot messages (React reconciliation)
-    previewAssistantId = `preview-${Date.now()}`;
-    // --- Public API ---
-    ingest(event) {
-        switch (event.type) {
-            case "text_delta":
-                this.textParts.push(event.content);
-                return "continue";
-            case "thinking_start":
-                this.thinkingInProgress = true;
-                this.pendingThinkingContent = "";
-                return "continue";
-            case "thinking_delta":
-                this.pendingThinkingContent += event.content;
-                return "continue";
-            case "thinking_end": {
-                this.thinkingInProgress = false;
-                // Field mapping: event.blocks[0].thinking → content
-                const firstBlock = Array.isArray(event.blocks) && event.blocks.length > 0
-                    ? event.blocks[0]
-                    : undefined;
-                const thinking = typeof firstBlock?.thinking === "string"
-                    ? firstBlock.thinking
-                    : this.pendingThinkingContent;
-                const words = thinking.split(/\s+/).filter(Boolean).length;
-                const thinkingBlock = {
-                    type: "thinking",
-                    content: thinking,
-                    wordCount: words,
-                    durationMs: event.durationMs,
-                    verb: this.verb,
-                };
-                this.thinkingBlocks.push(thinkingBlock);
-                this.pendingThinkingContent = "";
-                return "continue";
-            }
-            case "tool_start": {
-                // Dedup via seenToolIds
-                if (this.seenToolIds.has(event.id)) {
-                    return "continue";
-                }
-                this.seenToolIds.add(event.id);
-                // Field mapping: event.input → arguments
-                const toolUseBlock = {
-                    type: "tool_use",
-                    id: event.id,
-                    name: event.name,
-                    arguments: event.input ?? {},
-                };
-                this.toolUseBlocks.push(toolUseBlock);
-                return "continue";
-            }
-            case "tool_args_delta": {
-                // Progressive JSON accumulation
-                const prev = this.toolArgsAccumulator.get(event.id) ?? "";
-                const accumulated = prev + event.args;
-                this.toolArgsAccumulator.set(event.id, accumulated);
-                // Try to parse the accumulated JSON and update the tool_use block
-                try {
-                    const parsed = JSON.parse(accumulated);
-                    const block = this.toolUseBlocks.find((b) => b.type === "tool_use" && b.id === event.id);
-                    if (block) {
-                        block.arguments = parsed;
-                    }
-                }
-                catch {
-                    // Not yet valid JSON — keep accumulating
-                }
-                return "continue";
-            }
-            case "tool_result": {
-                // tool_result carries event.input — the tool's FULL arguments.
-                // tool_start arrives WITHOUT input (args come via tool_args_delta or here).
-                // Update the tool_use block with the authoritative args from tool_result.
-                if (event.input) {
-                    const toolBlock = this.toolUseBlocks.find((b) => b.type === "tool_use" && b.id === event.id);
-                    if (toolBlock) {
-                        const args = typeof event.input === "object" && !Array.isArray(event.input)
-                            ? event.input
-                            : {};
-                        // Only update if current args are empty (from tool_start with no input)
-                        if (Object.keys(toolBlock.arguments).length === 0) {
-                            toolBlock.arguments = args;
-                        }
-                    }
-                }
-                // SEPARATE ConversationMessage per tool result
-                // Field mapping: event.result.message → content, event.result.success → status
-                const resultRecord = event.result;
-                const toolUsage = "usage" in event &&
-                    event.usage &&
-                    typeof event.usage === "object" &&
-                    typeof event.usage.inputTokens === "number" &&
-                    typeof event.usage.outputTokens === "number" &&
-                    typeof event.usage.totalTokens === "number" &&
-                    typeof event.usage.estimatedCost === "number"
-                    ? event.usage
-                    : undefined;
-                const toolResultBlock = {
-                    type: "tool_result",
-                    toolUseId: event.id,
-                    content: typeof resultRecord.message === "string" ? resultRecord.message : "",
-                    status: resultRecord.success === true ? "success" : "error",
-                    durationMs: event.durationMs,
-                    resultData: resultRecord.data,
-                    usage: toolUsage,
-                };
-                const resultMsg = {
-                    id: crypto.randomUUID(),
-                    role: "tool",
-                    content: [toolResultBlock],
-                    arion: this.arion,
-                    createdAt: new Date().toISOString(),
-                };
-                this.toolResultMessages.push(resultMsg);
-                return "continue";
-            }
-            case "handoff_start": {
-                const handoffToBlock = {
-                    type: "handoff",
-                    target: event.target,
-                    direction: "to",
-                };
-                this.handoffBlocks.push(handoffToBlock);
-                return "continue";
-            }
-            case "handoff_result": {
-                const handoffFromBlock = {
-                    type: "handoff",
-                    target: event.target,
-                    direction: "from",
-                };
-                this.handoffBlocks.push(handoffFromBlock);
-                return "continue";
-            }
-            case "turn_complete":
-                return "flush";
-            case "messages_snapshot":
-                this.snapshotMessages = event.messages;
-                return "continue";
-            default: {
-                // Handle tool_end (not in RunEvent type but emitted by model-call.ts)
-                // It carries args as a JSON string that updates the tool_use block
-                // tool_end events are consumed by phase-model-call.ts and don't reach here.
-                // Tool args arrive via tool_args_delta (incremental JSON) which is handled above.
-                return "continue";
-            }
-        }
-    }
-    /**
-     * Flush all accumulated content into ConversationMessage[].
-     * Works anytime (including mid-accumulation for abort scenarios).
-     * Resets all state after flush.
-     */
-    flush() {
-        const messages = [];
-        // Convert in-progress thinking to a partial block (abort mid-thinking)
-        if (this.thinkingInProgress && this.pendingThinkingContent) {
-            const trimmed = this.pendingThinkingContent.trim();
-            const wordCount = trimmed.length === 0 ? 0 : trimmed.split(/\s+/).length;
-            const partialThinking = {
-                type: "thinking",
-                content: this.pendingThinkingContent,
-                wordCount,
-                verb: this.verb,
-            };
-            this.thinkingBlocks.push(partialThinking);
-        }
-        // Build assistant message blocks
-        const blocks = [];
-        // Thinking blocks first
-        blocks.push(...this.thinkingBlocks);
-        // Text content
-        const fullText = this.textParts.join("");
-        if (fullText) {
-            blocks.push({ type: "text", text: fullText });
-        }
-        // Tool use blocks — include all (even orphaned ones from abort)
-        blocks.push(...this.toolUseBlocks);
-        // Handoff blocks
-        blocks.push(...this.handoffBlocks);
-        // Only create assistant message if there's content
-        if (blocks.length > 0) {
-            const assistantMsg = {
-                id: crypto.randomUUID(),
-                role: "assistant",
-                content: blocks,
-                arion: this.arion,
-                tokenUsage: this.tokenUsage,
-                createdAt: new Date().toISOString(),
-            };
-            messages.push(assistantMsg);
-        }
-        // Tool result messages (separate ConversationMessage each)
-        messages.push(...this.toolResultMessages);
-        // Synthesize cancelled results for orphaned tool_use blocks (abort mid-tool).
-        // Without matching tool_result messages, the model sees a tool call it made
-        // but never got a response for — violating the message format invariant.
-        // Only synthesize when some tool results exist (partial completion) to avoid
-        // false positives during early abort or normal flush of tool_start-only state.
-        if (this.toolResultMessages.length > 0 && this.toolUseBlocks.length > 0) {
-            const resultToolIds = new Set(this.toolResultMessages.flatMap((m) => m.content
-                .filter((b) => b.type === "tool_result")
-                .map((b) => b.toolUseId)));
-            for (const block of this.toolUseBlocks) {
-                const toolUseId = block.id;
-                if (toolUseId && !resultToolIds.has(toolUseId)) {
-                    const cancelledResult = {
-                        id: crypto.randomUUID(),
-                        role: "tool",
-                        content: [
-                            {
-                                type: "tool_result",
-                                toolUseId,
-                                content: "Tool execution cancelled by user.",
-                                status: "error",
-                            },
-                        ],
-                        arion: this.arion,
-                        createdAt: new Date().toISOString(),
-                    };
-                    messages.push(cancelledResult);
-                }
-            }
-        }
-        // Reset all state (arion is NOT reset — it's per-session, not per-turn)
-        this.textParts = [];
-        this.thinkingBlocks = [];
-        this.toolUseBlocks = [];
-        this.handoffBlocks = [];
-        this.toolResultMessages = [];
-        this.seenToolIds = new Set();
-        this.toolArgsAccumulator = new Map();
-        this.thinkingInProgress = false;
-        this.pendingThinkingContent = "";
-        this.tokenUsage = undefined;
-        this.verb = undefined;
-        this.previewAssistantId = `preview-${Date.now()}`;
-        return messages;
-    }
-    /**
-     * 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() {
-        const blocks = [];
-        // Completed thinking blocks
-        blocks.push(...this.thinkingBlocks.map((b) => ({ ...b })));
-        // In-progress thinking (streaming)
-        if (this.thinkingInProgress && this.pendingThinkingContent) {
-            const content = this.pendingThinkingContent;
-            const partialThinking = {
-                type: "thinking",
-                content,
-                wordCount: content.split(/\s+/).filter(Boolean).length,
-                verb: this.verb,
-            };
-            blocks.push(partialThinking);
-        }
-        // Text content — render complete lines only (not token-by-token).
-        // Buffer text until a line break (\n) so the UI shows text in meaningful
-        // chunks. Prose paragraphs have no internal \n so they appear as whole
-        // blocks; code appears line by line; list items appear individually.
-        // No length fallback — partial lines are exactly the token-by-token
-        // growth we're eliminating. flush() at turn end returns everything.
-        const fullText = this.textParts.join("");
-        if (fullText) {
-            const lastLineBreak = fullText.lastIndexOf("\n");
-            if (lastLineBreak >= 0) {
-                blocks.push({ type: "text", text: fullText.slice(0, lastLineBreak + 1) });
-            }
-        }
-        // Tool use blocks — enriched with partially-parsed args from streaming.
-        // The execution path (flush) needs complete JSON to dispatch tools.
-        // The display path (snapshot) needs whatever info is available for the UI.
-        // We bridge this gap by trying to parse incomplete JSON from the accumulator.
-        for (const b of this.toolUseBlocks) {
-            const clone = { ...b };
-            if (clone.type === "tool_use" &&
-                Object.keys(clone.arguments).length === 0) {
-                const rawArgs = this.toolArgsAccumulator.get(clone.id);
-                if (rawArgs) {
-                    const partial = TurnAccumulator.tryParsePartialArgs(rawArgs);
-                    if (partial) {
-                        clone.arguments = partial;
-                    }
-                }
-            }
-            blocks.push(clone);
-        }
-        // Handoff blocks
-        blocks.push(...this.handoffBlocks.map((b) => ({ ...b })));
-        const messages = [];
-        if (blocks.length > 0) {
-            messages.push({
-                id: this.previewAssistantId,
-                role: "assistant",
-                content: blocks,
-                arion: this.arion,
-                createdAt: new Date().toISOString(),
-            });
-        }
-        // Tool result messages (clone to prevent mutation leaking)
-        messages.push(...this.toolResultMessages.map((m) => ({ ...m, content: [...m.content] })));
-        return messages;
-    }
-    /** Get snapshot messages from the most recent messages_snapshot event */
-    getSnapshotMessages() {
-        return this.snapshotMessages;
-    }
-    /** Whether there is any pending content that would produce messages on flush */
-    hasPendingContent() {
-        return (this.textParts.length > 0 ||
-            this.thinkingBlocks.length > 0 ||
-            this.toolUseBlocks.length > 0 ||
-            this.handoffBlocks.length > 0 ||
-            this.toolResultMessages.length > 0 ||
-            this.thinkingInProgress);
-    }
-    /** Set the arion reference — propagated to all flushed messages */
-    setArion(arion) {
-        this.arion = arion;
-    }
-    /** Set the composing verb — used in thinking blocks */
-    setVerb(verb) {
-        this.verb = verb;
-    }
-    /** Accumulate token usage — attached to assistant message on flush */
-    setTokenUsage(usage) {
-        if (this.tokenUsage) {
-            this.tokenUsage = {
-                input: this.tokenUsage.input + usage.input,
-                output: this.tokenUsage.output + usage.output,
-            };
-        }
-        else {
-            this.tokenUsage = { ...usage };
-        }
-    }
-    /**
-     * 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) {
-        const s = raw.trim();
-        if (!s.startsWith("{") || s.length < 4)
-            return undefined;
-        // Fast path: already complete JSON
-        try {
-            return JSON.parse(s);
-        }
-        catch { }
-        // Close object — handles: '{"command": "ls -la"' → + '}'
-        try {
-            const result = JSON.parse(s + "}");
-            if (Object.keys(result).length > 0)
-                return result;
-        }
-        catch { }
-        // Close incomplete string value + object — handles: '{"command": "ls' → + '"}'
-        try {
-            const result = JSON.parse(s + '"}');
-            if (Object.keys(result).length > 0)
-                return result;
-        }
-        catch { }
-        // Drop incomplete trailing pair: scan backward for commas, close at last complete pair.
-        // Handles: '{"file_path": "/src/foo.ts", "content": "imp' → truncate → '{"file_path": "/src/foo.ts"}'
-        for (let i = s.length - 1; i > 0; i--) {
-            if (s[i] === ",") {
-                try {
-                    const result = JSON.parse(s.slice(0, i) + "}");
-                    if (Object.keys(result).length > 0)
-                        return result;
-                }
-                catch { }
-            }
-        }
-        return undefined;
-    }
-}
-//# sourceMappingURL=turn-accumulator.js.map

package/dist/index.js

@@ -1,7 +0,0 @@
-/**
- * @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";
-//# sourceMappingURL=index.js.map