muonroi-cli 1.2.0

package/src/storage/tool-results.ts

@@ -0,0 +1,56 @@
+import type { ToolResult } from "../types/index";
+
+export function extractToolResultFromOutput(output: unknown): ToolResult | null {
+  if (!output || typeof output !== "object") return null;
+
+  if ("success" in output) {
+    const result = output as ToolResult;
+    return {
+      success: Boolean(result.success),
+      output: result.output,
+      error: result.error,
+      diff: result.diff,
+      plan: result.plan,
+      task: result.task,
+      delegation: result.delegation,
+      backgroundProcess: result.backgroundProcess,
+      media: result.media,
+      computer: result.computer,
+    };
+  }
+
+  if ("type" in output && output.type === "json" && "value" in output) {
+    return extractToolResultFromOutput((output as { value: unknown }).value);
+  }
+
+  if ("type" in output && output.type === "error-text" && "value" in output) {
+    return {
+      success: false,
+      error: String((output as { value: unknown }).value),
+    };
+  }
+
+  if ("type" in output && output.type === "text" && "value" in output) {
+    return {
+      success: true,
+      output: String((output as { value: unknown }).value),
+    };
+  }
+
+  return null;
+}
+
+export function getOutputKind(output: unknown): string {
+  if (output && typeof output === "object" && "type" in output && typeof output.type === "string") {
+    return output.type;
+  }
+  return "json";
+}
+
+export function isOutputSuccess(output: unknown): boolean {
+  if (!output || typeof output !== "object") return true;
+  if ("type" in output) {
+    return !String(output.type).startsWith("error");
+  }
+  return true;
+}

package/src/storage/transcript-view.ts

@@ -0,0 +1,45 @@
+import type { ModelMessage } from "ai";
+import { createCompactionSummaryMessage } from "../orchestrator/compaction";
+
+export interface PersistedCompaction {
+  firstKeptSeq: number;
+  summary: string;
+  tokensBefore: number;
+  createdAt: Date;
+}
+
+export interface LoadedTranscriptState {
+  messages: ModelMessage[];
+  seqs: Array<number | null>;
+  timestamps: Date[];
+  compaction: PersistedCompaction | null;
+}
+
+export function buildEffectiveTranscript(
+  messages: ModelMessage[],
+  seqs: number[],
+  timestamps: Date[],
+  compaction: PersistedCompaction | null,
+): LoadedTranscriptState {
+  if (!compaction) {
+    return {
+      messages: [...messages],
+      seqs: [...seqs],
+      timestamps: [...timestamps],
+      compaction: null,
+    };
+  }
+
+  const firstKeptIndex = seqs.findIndex((seq) => seq >= compaction.firstKeptSeq);
+  const keptIndex = firstKeptIndex >= 0 ? firstKeptIndex : messages.length;
+  const keptMessages = messages.slice(keptIndex);
+  const keptSeqs = seqs.slice(keptIndex);
+  const keptTimestamps = timestamps.slice(keptIndex);
+
+  return {
+    messages: [createCompactionSummaryMessage(compaction.summary), ...keptMessages],
+    seqs: [null, ...keptSeqs],
+    timestamps: [compaction.createdAt, ...keptTimestamps],
+    compaction,
+  };
+}

package/src/storage/transcript.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import type { ToolResult } from "../types/index";
+import { extractToolResultFromOutput } from "./tool-results";
+
+describe("transcript media tool results", () => {
+  it("preserves media metadata when stored tool output is normalized", () => {
+    const mediaResult: ToolResult = {
+      success: true,
+      output: "Generated 1 image.\n- /tmp/example.png",
+      media: [
+        {
+          kind: "image",
+          path: "/tmp/example.png",
+          url: "https://example.com/generated.png",
+          sourcePath: "/tmp/source.png",
+          prompt: "Create a new hero image",
+          modelId: "muonroi-test-image",
+        },
+      ],
+    };
+
+    expect(extractToolResultFromOutput(mediaResult)).toEqual(mediaResult);
+  });
+});

package/src/storage/transcript.ts

@@ -0,0 +1,358 @@
+import type { ModelMessage } from "ai";
+import { getCompactionSummaryText } from "../orchestrator/compaction";
+import type { ChatEntry, ToolCall, ToolResult } from "../types/index";
+import { getDatabase, withTransaction } from "./db";
+import { extractToolResultFromOutput, getOutputKind, isOutputSuccess } from "./tool-results";
+import { buildEffectiveTranscript, type LoadedTranscriptState, type PersistedCompaction } from "./transcript-view";
+
+interface MessageRow {
+  session_id: string;
+  seq: number;
+  role: string;
+  message_json: string;
+  created_at: string;
+}
+
+interface StoredToolCallRow {
+  id: number;
+  tool_call_id: string;
+  tool_name: string;
+  args_json: string;
+}
+
+interface StoredToolResultRow {
+  tool_call_id: string;
+  output_json: string;
+}
+
+interface CompactionRow {
+  session_id: string;
+  first_kept_seq: number;
+  summary: string;
+  tokens_before: number;
+  created_at: string;
+}
+
+interface EffectiveMessageRecord {
+  message: ModelMessage;
+  seq: number | null;
+  timestamp: Date;
+}
+
+function loadMessageRows(sessionId: string): MessageRow[] {
+  return getDatabase()
+    .prepare(`
+    SELECT session_id, seq, role, message_json, created_at
+    FROM messages
+    WHERE session_id = ?
+    ORDER BY seq ASC
+  `)
+    .all(sessionId) as MessageRow[];
+}
+
+function toPersistedCompaction(row: CompactionRow | undefined): PersistedCompaction | null {
+  if (!row) return null;
+  return {
+    firstKeptSeq: row.first_kept_seq,
+    summary: row.summary,
+    tokensBefore: row.tokens_before,
+    createdAt: new Date(row.created_at),
+  };
+}
+
+export function loadLatestCompaction(sessionId: string): PersistedCompaction | null {
+  const row = getDatabase()
+    .prepare(`
+    SELECT session_id, first_kept_seq, summary, tokens_before, created_at
+    FROM compactions
+    WHERE session_id = ?
+    ORDER BY id DESC
+    LIMIT 1
+  `)
+    .get(sessionId) as CompactionRow | undefined;
+
+  return toPersistedCompaction(row);
+}
+
+function buildEffectiveMessageRecords(sessionId: string): EffectiveMessageRecord[] {
+  const rows = loadMessageRows(sessionId);
+  const messages = rows.map((row) => JSON.parse(row.message_json) as ModelMessage);
+  const seqs = rows.map((row) => row.seq);
+  const timestamps = rows.map((row) => new Date(row.created_at));
+  const transcript = buildEffectiveTranscript(messages, seqs, timestamps, loadLatestCompaction(sessionId));
+
+  return transcript.messages.map((message, index) => ({
+    message,
+    seq: transcript.seqs[index],
+    timestamp: transcript.timestamps[index],
+  }));
+}
+
+export function loadRawTranscript(sessionId: string): ModelMessage[] {
+  return loadMessageRows(sessionId).map((row) => JSON.parse(row.message_json) as ModelMessage);
+}
+
+export function loadTranscriptState(sessionId: string): LoadedTranscriptState {
+  const rows = loadMessageRows(sessionId);
+  return buildEffectiveTranscript(
+    rows.map((row) => JSON.parse(row.message_json) as ModelMessage),
+    rows.map((row) => row.seq),
+    rows.map((row) => new Date(row.created_at)),
+    loadLatestCompaction(sessionId),
+  );
+}
+
+export function loadTranscript(sessionId: string): ModelMessage[] {
+  return loadTranscriptState(sessionId).messages;
+}
+
+export function getNextMessageSequence(sessionId: string): number {
+  return getNextSequence(getDatabase(), sessionId);
+}
+
+export function appendMessages(sessionId: string, messages: ModelMessage[]): number[] {
+  if (messages.length === 0) return [];
+
+  const insertedSeqs: number[] = [];
+  withTransaction((db) => {
+    const nextSeq = getNextSequence(db, sessionId);
+    const insertMessage = db.prepare(`
+      INSERT INTO messages (session_id, seq, role, message_json, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    const insertToolCall = db.prepare(`
+      INSERT OR IGNORE INTO tool_calls (
+        session_id, message_seq, tool_call_id, tool_name, args_json, status, started_at, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const updateToolCall = db.prepare(`
+      UPDATE tool_calls
+      SET tool_name = ?, args_json = ?, status = ?, completed_at = ?
+      WHERE session_id = ? AND tool_call_id = ?
+    `);
+    const selectToolCall = db.prepare(`
+      SELECT id, tool_call_id, tool_name, args_json
+      FROM tool_calls
+      WHERE session_id = ? AND tool_call_id = ?
+    `);
+    const insertToolResult = db.prepare(`
+      INSERT INTO tool_results (tool_call_row_id, output_kind, output_json, success, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    const updateSession = db.prepare(`
+      UPDATE sessions
+      SET updated_at = ?
+      WHERE id = ?
+    `);
+
+    messages.forEach((message, index) => {
+      const seq = nextSeq + index;
+      const createdAt = new Date().toISOString();
+      insertedSeqs.push(seq);
+      insertMessage.run(sessionId, seq, message.role, JSON.stringify(message), createdAt);
+
+      if (message.role === "assistant" && Array.isArray(message.content)) {
+        for (const part of message.content) {
+          if (part.type !== "tool-call") continue;
+          insertToolCall.run(
+            sessionId,
+            seq,
+            part.toolCallId,
+            part.toolName,
+            JSON.stringify(part.input ?? {}),
+            "completed",
+            createdAt,
+            createdAt,
+          );
+          updateToolCall.run(
+            part.toolName,
+            JSON.stringify(part.input ?? {}),
+            "completed",
+            createdAt,
+            sessionId,
+            part.toolCallId,
+          );
+        }
+      }
+
+      if (message.role === "tool" && Array.isArray(message.content)) {
+        for (const part of message.content) {
+          if (part.type !== "tool-result") continue;
+          let toolCall = selectToolCall.get(sessionId, part.toolCallId) as StoredToolCallRow | undefined;
+          if (!toolCall) {
+            insertToolCall.run(sessionId, seq, part.toolCallId, part.toolName, "{}", "completed", createdAt, createdAt);
+            toolCall = selectToolCall.get(sessionId, part.toolCallId) as StoredToolCallRow | undefined;
+          }
+          if (!toolCall) continue;
+
+          const extracted = extractToolResultFromOutput(part.output);
+          insertToolResult.run(
+            toolCall.id,
+            getOutputKind(part.output),
+            JSON.stringify(extracted ?? part.output),
+            extracted ? Number(extracted.success) : Number(isOutputSuccess(part.output)),
+            createdAt,
+          );
+        }
+      }
+    });
+
+    updateSession.run(new Date().toISOString(), sessionId);
+  });
+
+  return insertedSeqs;
+}
+
+export function appendSystemMessage(sessionId: string, content: string): number | null {
+  return appendMessages(sessionId, [{ role: "system", content }])[0] ?? null;
+}
+
+export function appendCompaction(sessionId: string, firstKeptSeq: number, summary: string, tokensBefore: number): void {
+  withTransaction((db) => {
+    db.prepare(`
+      INSERT INTO compactions (session_id, first_kept_seq, summary, tokens_before, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(sessionId, firstKeptSeq, summary, tokensBefore, new Date().toISOString());
+
+    db.prepare(`
+      UPDATE sessions
+      SET updated_at = ?
+      WHERE id = ?
+    `).run(new Date().toISOString(), sessionId);
+  });
+}
+
+export function buildChatEntries(sessionId: string): ChatEntry[] {
+  const toolResults = loadStoredToolResults(sessionId);
+  const callMap = new Map<string, ToolCall>();
+  const entries: ChatEntry[] = [];
+
+  for (const row of buildEffectiveMessageRecords(sessionId)) {
+    const { message, timestamp } = row;
+
+    if (message.role === "user") {
+      const content = renderUserContent(message.content);
+      if (content) {
+        entries.push({ type: "user", content, timestamp });
+      }
+      continue;
+    }
+
+    if (message.role === "system") {
+      const content =
+        getCompactionSummaryText(message) ?? (typeof message.content === "string" ? message.content.trim() : "");
+      if (content) {
+        entries.push({ type: "assistant", content, timestamp });
+      }
+      continue;
+    }
+
+    if (message.role === "assistant") {
+      const text = renderAssistantContent(message.content, callMap);
+      if (text) {
+        entries.push({ type: "assistant", content: text, timestamp });
+      }
+      continue;
+    }
+
+    if (message.role === "tool" && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (part.type !== "tool-result") continue;
+        const toolCall = callMap.get(part.toolCallId) ?? toFallbackToolCall(part.toolCallId, part.toolName);
+        const toolResult = toolResults.get(part.toolCallId) ??
+          extractToolResultFromOutput(part.output) ?? {
+            success: isOutputSuccess(part.output),
+            output: JSON.stringify(part.output),
+          };
+        entries.push({
+          type: "tool_result",
+          content: toolResult.success ? toolResult.output || "Success" : toolResult.error || "Error",
+          timestamp,
+          toolCall,
+          toolResult,
+        });
+      }
+    }
+  }
+
+  return entries;
+}
+
+function getNextSequence(db: ReturnType<typeof getDatabase>, sessionId: string): number {
+  const row = db
+    .prepare(`
+    SELECT COALESCE(MAX(seq), 0) AS max_seq
+    FROM messages
+    WHERE session_id = ?
+  `)
+    .get(sessionId) as { max_seq: number } | undefined;
+
+  return (row?.max_seq ?? 0) + 1;
+}
+
+function renderUserContent(content: ModelMessage["content"]): string {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+
+  return content
+    .map((part) => {
+      if (part.type === "text") return part.text;
+      if (part.type === "image") return "[Image]";
+      if (part.type === "file") return part.filename ? `[File: ${part.filename}]` : "[File]";
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+}
+
+function renderAssistantContent(content: ModelMessage["content"], callMap: Map<string, ToolCall>): string {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+
+  const textParts: string[] = [];
+  for (const part of content) {
+    if (part.type === "text") {
+      textParts.push(part.text);
+      continue;
+    }
+
+    if (part.type === "tool-call") {
+      callMap.set(part.toolCallId, {
+        id: part.toolCallId,
+        type: "function",
+        function: {
+          name: part.toolName,
+          arguments: JSON.stringify(part.input ?? {}),
+        },
+      });
+    }
+  }
+
+  return textParts.join("").trim();
+}
+
+function loadStoredToolResults(sessionId: string): Map<string, ToolResult> {
+  const rows = getDatabase()
+    .prepare(`
+    SELECT tc.tool_call_id, tr.output_json
+    FROM tool_results tr
+    JOIN tool_calls tc ON tc.id = tr.tool_call_row_id
+    WHERE tc.session_id = ?
+    ORDER BY tr.id ASC
+  `)
+    .all(sessionId) as StoredToolResultRow[];
+
+  return new Map(rows.map((row) => [row.tool_call_id, JSON.parse(row.output_json) as ToolResult]));
+}
+
+function toFallbackToolCall(toolCallId: string, toolName: string): ToolCall {
+  return {
+    id: toolCallId,
+    type: "function",
+    function: {
+      name: toolName,
+      arguments: "{}",
+    },
+  };
+}

package/src/storage/usage-cap.test.ts

@@ -0,0 +1,59 @@
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { atomicWriteJSON } from "./atomic-io.js";
+import { loadUsage, saveUsage } from "./usage-cap.js";
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "usage-test-"));
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+function currentMonthUTC(): string {
+  const d = new Date();
+  const yyyy = d.getUTCFullYear();
+  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+  return `${yyyy}-${mm}`;
+}
+
+describe("loadUsage", () => {
+  it("Test 7: bootstraps usage.json when absent", async () => {
+    const state = await loadUsage(tmpDir);
+    expect(state.current_month_utc).toBe(currentMonthUTC());
+    expect(state.current_usd).toBe(0);
+    expect(state.reservations).toEqual([]);
+
+    // File must be written
+    const raw = await fs.readFile(path.join(tmpDir, "usage.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    expect(parsed.current_usd).toBe(0);
+  });
+
+  it("Test 9: auto-resets on stale month", async () => {
+    // Write a state with a past month
+    await atomicWriteJSON(path.join(tmpDir, "usage.json"), {
+      current_month_utc: "2026-03",
+      current_usd: 5.5,
+      reservations: [],
+    });
+
+    const state = await loadUsage(tmpDir);
+    expect(state.current_month_utc).toBe(currentMonthUTC());
+    expect(state.current_usd).toBe(0);
+  });
+});
+
+describe("saveUsage", () => {
+  it("Test 8: round-trips via loadUsage", async () => {
+    const initial = await loadUsage(tmpDir);
+    await saveUsage({ ...initial, current_usd: 1.23 }, tmpDir);
+    const loaded = await loadUsage(tmpDir);
+    expect(loaded.current_usd).toBe(1.23);
+  });
+});

package/src/storage/usage-cap.ts

@@ -0,0 +1,81 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { atomicReadJSON, atomicWriteJSON } from "./atomic-io.js";
+
+/**
+ * TUI-owned monthly usage state stored at ~/.muonroi-cli/usage.json.
+ *
+ * Phase 0 scope: schema + atomic IO + boot read + month-rollover only.
+ * No enforcement, no thresholds, no auto-downgrade — those land in Phase 1 USAGE-02..05/07.
+ *
+ * Architecture anti-pattern 4: this file is owned exclusively by the TUI process.
+ */
+export interface UsageState {
+  current_month_utc: string; // "YYYY-MM" e.g. "2026-04"
+  current_usd: number; // running spend this month
+  reservations: Array<{
+    id: string;
+    usd: number;
+    createdAtMs: number;
+    model?: string;
+    provider?: string;
+    est_input_tokens?: number;
+    est_output_tokens?: number;
+  }>; // Phase 1 fills
+  thresholds_fired_this_month?: number[]; // e.g. [50, 80] -- used by thresholds.ts to dedupe per month
+}
+
+function currentMonthUTC(d: Date = new Date()): string {
+  const yyyy = d.getUTCFullYear();
+  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+  return `${yyyy}-${mm}`;
+}
+
+/**
+ * Resolve the ~/.muonroi-cli/ home directory.
+ * Priority: explicit override → MUONROI_CLI_HOME env → os.homedir()/.muonroi-cli
+ */
+function muonroiHome(override?: string): string {
+  return override ?? process.env.MUONROI_CLI_HOME ?? path.join(os.homedir(), ".muonroi-cli");
+}
+
+function defaultState(): UsageState {
+  return { current_month_utc: currentMonthUTC(), current_usd: 0, reservations: [], thresholds_fired_this_month: [] };
+}
+
+/**
+ * Load usage state from ~/.muonroi-cli/usage.json.
+ * - If absent: writes and returns a fresh default state.
+ * - If month has rolled over: resets current_usd to 0 and rewrites the file.
+ * Accepts an optional homeOverride for test isolation.
+ */
+export async function loadUsage(homeOverride?: string): Promise<UsageState> {
+  const filePath = path.join(muonroiHome(homeOverride), "usage.json");
+  const existing = await atomicReadJSON<UsageState>(filePath);
+  if (!existing) {
+    const state = defaultState();
+    await atomicWriteJSON(filePath, state);
+    return state;
+  }
+  // Month rollover: reset spend if the stored month is stale
+  if (existing.current_month_utc !== currentMonthUTC()) {
+    const reset: UsageState = {
+      current_month_utc: currentMonthUTC(),
+      current_usd: 0,
+      reservations: [],
+      thresholds_fired_this_month: [],
+    };
+    await atomicWriteJSON(filePath, reset);
+    return reset;
+  }
+  return existing;
+}
+
+/**
+ * Persist usage state atomically to ~/.muonroi-cli/usage.json.
+ * Accepts an optional homeOverride for test isolation.
+ */
+export async function saveUsage(state: UsageState, homeOverride?: string): Promise<void> {
+  const filePath = path.join(muonroiHome(homeOverride), "usage.json");
+  await atomicWriteJSON(filePath, state);
+}