mini-coder 0.5.10 → 0.5.12

package/src/index.ts

@@ -50,8 +50,7 @@ import {
 } from "./prompt.ts";
 import {
   appendMessage,
-  computeContextTokens,
-  computeStats,
+  createConversationSnapshot,
   createSession,
   filterModelMessages,
   type loadMessages,
@@ -69,14 +68,18 @@ import {
 import { discoverSkills, type Skill } from "./skills.ts";
 import { DEFAULT_THEME, mergeThemes, type Theme } from "./theme.ts";
 import {
+  createTodoReadToolHandler,
+  createTodoWriteToolHandler,
   editTool,
-  executeEdit,
-  executeReadImage,
-  executeShell,
-  executeTodoRead,
-  executeTodoWrite,
+  editToolHandler,
+  grepTool,
+  grepToolHandler,
   readImageTool,
+  readImageToolHandler,
+  readTool,
+  readToolHandler,
   shellTool,
+  shellToolHandler,
   todoReadTool,
   todoWriteTool,
 } from "./tools.ts";
@@ -359,26 +362,6 @@ function selectModel(
 // Tool wiring
 // ---------------------------------------------------------------------------
 
-/** Built-in tool handlers keyed by tool name. */
-const BUILTIN_HANDLERS: Record<string, ToolHandler> = {
-  edit: (args, cwd) =>
-    executeEdit(
-      {
-        path: args.path as string,
-        oldText: args.oldText as string,
-        newText: args.newText as string,
-      },
-      cwd,
-    ),
-  shell: (args, cwd, signal, onUpdate) =>
-    executeShell({ command: args.command as string }, cwd, {
-      ...(signal ? { signal } : {}),
-      ...(onUpdate ? { onUpdate } : {}),
-    }),
-  readImage: (args, cwd) =>
-    executeReadImage({ path: args.path as string }, cwd),
-};
-
 /**
  * Build tool definitions and handler map for the current model.
  *
@@ -390,32 +373,27 @@ function buildTools(
   plugins: LoadedPlugin[],
   messages: AppState["messages"],
 ): { tools: Tool[]; toolHandlers: Map<string, ToolHandler> } {
-  const tools: Tool[] = [editTool, shellTool, todoWriteTool, todoReadTool];
+  const tools: Tool[] = [
+    shellTool,
+    readTool,
+    grepTool,
+    editTool,
+    todoWriteTool,
+    todoReadTool,
+  ];
   const toolHandlers = new Map<string, ToolHandler>([
-    [editTool.name, BUILTIN_HANDLERS.edit!],
-    [shellTool.name, BUILTIN_HANDLERS.shell!],
-    [
-      todoWriteTool.name,
-      (args) =>
-        executeTodoWrite(
-          {
-            todos: Array.isArray(args.todos)
-              ? (args.todos as Array<{
-                  content: string;
-                  status: "pending" | "in_progress" | "completed" | "cancelled";
-                }>)
-              : [],
-          },
-          messages,
-        ),
-    ],
-    [todoReadTool.name, () => executeTodoRead(messages)],
+    [shellTool.name, shellToolHandler],
+    [readTool.name, readToolHandler],
+    [grepTool.name, grepToolHandler],
+    [editTool.name, editToolHandler],
+    [todoWriteTool.name, createTodoWriteToolHandler(messages)],
+    [todoReadTool.name, createTodoReadToolHandler(messages)],
   ]);
 
   // Conditionally register readImage for vision-capable models
   if (model.input.includes("image")) {
     tools.push(readImageTool);
-    toolHandlers.set(readImageTool.name, BUILTIN_HANDLERS.readImage!);
+    toolHandlers.set(readImageTool.name, readImageToolHandler);
   }
 
   // Add plugin tools
@@ -635,21 +613,22 @@ export async function init(): Promise<AppState> {
   // Open database. Sessions are created lazily on the first user message.
   const db = openDatabase(DB_PATH);
   const effort = startup.effort;
-  const messages: ReturnType<typeof loadMessages> = [];
-  const stats = computeStats(messages);
-  const contextTokens = computeContextTokens(messages);
-  const promptContext = await loadPromptContext(filterModelMessages(messages), {
-    cwd,
-  });
+  const conversation = createConversationSnapshot();
+  const promptContext = await loadPromptContext(
+    filterModelMessages(conversation.messages),
+    {
+      cwd,
+    },
+  );
 
   return {
     db,
     session: null,
     model,
     effort,
-    messages,
-    stats,
-    contextTokens,
+    messages: conversation.messages,
+    stats: conversation.stats,
+    contextTokens: conversation.contextTokens,
     agentsMd: promptContext.agentsMd,
     skills: promptContext.skills,
     plugins: promptContext.plugins,

package/src/prompt.ts

@@ -210,6 +210,8 @@ function buildCorePrompt(opts: BuildSystemPromptOpts): string {
 
   lines.push(
     `- Shell: ${opts.shell}. Use \`command -v <name>\` to check what is available to you; do not assume environment support.`,
+    "- Read: Read a text file from disk with offset/limit support.",
+    "- Grep: Search file contents with ripgrep-style options and structured results.",
     "- Edit: Safe exact-text replacement in a single file.",
   );
 
@@ -238,6 +240,12 @@ function buildCorePrompt(opts: BuildSystemPromptOpts): string {
     "- Don't assume the environment supports all commands; check before using them.",
     "- Avoid destructive commands that can discard changes or override edits.",
     "",
+    "### Choosing tools:",
+    "",
+    "- Prefer `read` for reading file contents instead of `cat`, `sed`, `head`, or `tail`.",
+    "- Prefer `grep` for content search instead of raw `grep` / `rg`.",
+    "- Use shell `ls` and `fd` for lightweight exploration when you just need to inspect directories or discover candidate files.",
+    "",
     "### Working with code:",
     "",
     "- Describe changes before implementing them",

package/src/session-message.ts

@@ -0,0 +1,393 @@
+/**
+ * Persisted session-message types and parsing/validation helpers.
+ *
+ * @module
+ */
+
+import type {
+  AssistantMessage,
+  Message,
+  ToolResultMessage,
+  UserMessage,
+} from "@mariozechner/pi-ai";
+import {
+  readBoolean,
+  readFiniteNumber,
+  readString,
+  toRecord,
+} from "./shared.ts";
+import { collapseWhitespaceToNull, joinTextBlocks } from "./text.ts";
+import type { TodoItem } from "./tools.ts";
+
+/** Rich-text format hints supported by persisted UI info messages. */
+export type UiInfoFormat = "markdown";
+
+/** A persisted UI-only info message shown in the conversation log. */
+export interface UiInfoMessage {
+  /** Identifies this as an internal UI message. */
+  role: "ui";
+  /** UI message category for rendering and future behavior. */
+  kind: "info";
+  /** Display text shown in the conversation log. */
+  content: string;
+  /** Optional rich-text format hint for the content. */
+  format?: UiInfoFormat;
+  /** Unix timestamp in milliseconds. */
+  timestamp: number;
+}
+
+/** A persisted UI-only todo snapshot shown in the conversation log. */
+export interface UiTodoMessage {
+  /** Identifies this as an internal UI message. */
+  role: "ui";
+  /** UI message category for rendering and future behavior. */
+  kind: "todo";
+  /** Todo snapshot rendered in the conversation pane. */
+  todos: TodoItem[];
+  /** Unix timestamp in milliseconds. */
+  timestamp: number;
+}
+
+/** A persisted UI-only message shown in the conversation log. */
+export type UiMessage = UiInfoMessage | UiTodoMessage;
+
+/** Any message persisted in session history. */
+export type PersistedMessage = Message | UiMessage;
+
+const EMPTY_ASSISTANT_USAGE: AssistantMessage["usage"] = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    total: 0,
+  },
+};
+
+function getMultipartUserPreview(
+  content: Extract<Message, { role: "user" }>["content"],
+): string | null {
+  if (typeof content === "string") {
+    return collapseWhitespaceToNull(content);
+  }
+
+  return collapseWhitespaceToNull(joinTextBlocks(content));
+}
+
+function isTextContentBlock(
+  value: unknown,
+): value is { type: "text"; text: string } {
+  const record = toRecord(value);
+  return (
+    record !== null &&
+    record.type === "text" &&
+    readString(record, "text") !== null
+  );
+}
+
+function isImageContentBlock(
+  value: unknown,
+): value is { type: "image"; data: string; mimeType: string } {
+  const record = toRecord(value);
+  return (
+    record !== null &&
+    record.type === "image" &&
+    readString(record, "data") !== null &&
+    readString(record, "mimeType") !== null
+  );
+}
+
+function isThinkingContentBlock(
+  value: unknown,
+): value is Extract<AssistantMessage["content"][number], { type: "thinking" }> {
+  const record = toRecord(value);
+  return (
+    record !== null &&
+    record.type === "thinking" &&
+    readString(record, "thinking") !== null
+  );
+}
+
+function isToolCallContentBlock(
+  value: unknown,
+): value is Extract<AssistantMessage["content"][number], { type: "toolCall" }> {
+  const record = toRecord(value);
+  return (
+    record !== null &&
+    record.type === "toolCall" &&
+    readString(record, "id") !== null &&
+    readString(record, "name") !== null &&
+    toRecord(record.arguments) !== null
+  );
+}
+
+function isAssistantUsage(value: unknown): value is AssistantMessage["usage"] {
+  const usageRecord = toRecord(value);
+  const costRecord = toRecord(usageRecord?.cost);
+  return (
+    usageRecord !== null &&
+    costRecord !== null &&
+    readFiniteNumber(usageRecord, "input") !== null &&
+    readFiniteNumber(usageRecord, "output") !== null &&
+    readFiniteNumber(usageRecord, "cacheRead") !== null &&
+    readFiniteNumber(usageRecord, "cacheWrite") !== null &&
+    readFiniteNumber(usageRecord, "totalTokens") !== null &&
+    readFiniteNumber(costRecord, "input") !== null &&
+    readFiniteNumber(costRecord, "output") !== null &&
+    readFiniteNumber(costRecord, "cacheRead") !== null &&
+    readFiniteNumber(costRecord, "cacheWrite") !== null &&
+    readFiniteNumber(costRecord, "total") !== null
+  );
+}
+
+function isStopReason(value: unknown): value is AssistantMessage["stopReason"] {
+  return (
+    value === "stop" ||
+    value === "length" ||
+    value === "toolUse" ||
+    value === "error" ||
+    value === "aborted"
+  );
+}
+
+function isUserMessageRecord(value: unknown): value is UserMessage {
+  const record = toRecord(value);
+  if (!record || record.role !== "user") {
+    return false;
+  }
+
+  return (
+    readFiniteNumber(record, "timestamp") !== null &&
+    (typeof record.content === "string" ||
+      (Array.isArray(record.content) &&
+        record.content.every(
+          (block) => isTextContentBlock(block) || isImageContentBlock(block),
+        )))
+  );
+}
+
+function parseAssistantMessageRecord(value: unknown): AssistantMessage | null {
+  const record = toRecord(value);
+  if (!record || record.role !== "assistant") {
+    return null;
+  }
+
+  const timestamp = readFiniteNumber(record, "timestamp");
+  const api = readString(record, "api");
+  const provider = readString(record, "provider");
+  const model = readString(record, "model");
+  const errorMessage = readString(record, "errorMessage");
+  if (
+    !Array.isArray(record.content) ||
+    !record.content.every(
+      (block) =>
+        isTextContentBlock(block) ||
+        isThinkingContentBlock(block) ||
+        isToolCallContentBlock(block),
+    ) ||
+    api === null ||
+    provider === null ||
+    model === null ||
+    !isStopReason(record.stopReason) ||
+    (record.errorMessage !== undefined && errorMessage === null) ||
+    timestamp === null
+  ) {
+    return null;
+  }
+
+  return {
+    role: "assistant",
+    content: record.content,
+    api,
+    provider,
+    model,
+    usage: isAssistantUsage(record.usage)
+      ? record.usage
+      : structuredClone(EMPTY_ASSISTANT_USAGE),
+    stopReason: record.stopReason,
+    ...(errorMessage !== null ? { errorMessage } : {}),
+    timestamp,
+  };
+}
+
+function isToolResultMessageRecord(value: unknown): value is ToolResultMessage {
+  const record = toRecord(value);
+  if (!record || record.role !== "toolResult") {
+    return false;
+  }
+
+  return (
+    readString(record, "toolCallId") !== null &&
+    readString(record, "toolName") !== null &&
+    readBoolean(record, "isError") !== null &&
+    Array.isArray(record.content) &&
+    record.content.every(
+      (block) => isTextContentBlock(block) || isImageContentBlock(block),
+    ) &&
+    readFiniteNumber(record, "timestamp") !== null
+  );
+}
+
+function isUiMessageRecord(value: unknown): value is UiMessage {
+  const record = toRecord(value);
+  if (!record || record.role !== "ui") {
+    return false;
+  }
+
+  const timestamp = readFiniteNumber(record, "timestamp");
+  if (timestamp === null) {
+    return false;
+  }
+
+  if (record.kind === "info") {
+    return (
+      typeof record.content === "string" &&
+      (record.format === undefined || record.format === "markdown")
+    );
+  }
+
+  return (
+    record.kind === "todo" &&
+    Array.isArray(record.todos) &&
+    record.todos.every(
+      (todo) =>
+        typeof todo === "object" &&
+        todo !== null &&
+        typeof (todo as { content?: unknown }).content === "string" &&
+        ((todo as { status?: unknown }).status === "pending" ||
+          (todo as { status?: unknown }).status === "in_progress" ||
+          (todo as { status?: unknown }).status === "completed"),
+    )
+  );
+}
+
+/**
+ * Parse one persisted message row from SQLite JSON.
+ *
+ * Invalid or unsupported rows return `null` so callers can skip corrupt data
+ * without crashing session loading.
+ *
+ * @param data - Raw JSON-serialized message row.
+ * @returns The validated persisted message, or `null` when invalid.
+ */
+export function parsePersistedMessage(data: string): PersistedMessage | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(data) as unknown;
+  } catch {
+    return null;
+  }
+
+  if (
+    isUserMessageRecord(parsed) ||
+    isToolResultMessageRecord(parsed) ||
+    isUiMessageRecord(parsed)
+  ) {
+    return parsed;
+  }
+
+  return parseAssistantMessageRecord(parsed);
+}
+
+/**
+ * Read the first-user preview cached by the session-list query.
+ *
+ * @param messageData - Raw JSON from the first conversational message row.
+ * @returns A collapsed single-line preview, or `null` when unavailable.
+ */
+export function readFirstUserPreview(
+  messageData: string | null,
+): string | null {
+  if (!messageData) {
+    return null;
+  }
+
+  const message = parsePersistedMessage(messageData);
+  if (!message || message.role !== "user") {
+    return null;
+  }
+
+  return getMultipartUserPreview(message.content);
+}
+
+/**
+ * Check whether a persisted message is a UI-only message.
+ *
+ * @param message - Message to inspect.
+ * @returns `true` when the message is a {@link UiMessage}.
+ */
+export function isUiMessage(message: PersistedMessage): message is UiMessage {
+  return message.role === "ui";
+}
+
+/**
+ * Return an assistant message's usage when the persisted shape is valid.
+ *
+ * Session rows are treated as untrusted at runtime because older builds or
+ * external tooling may have stored assistant messages without a `usage`
+ * payload. Invalid or missing usage is ignored instead of crashing session
+ * loading or stats calculations.
+ *
+ * @param message - Message to inspect.
+ * @returns The assistant usage payload, or `null` when it is missing/invalid.
+ */
+export function getAssistantUsage(
+  message: PersistedMessage | Message,
+): AssistantMessage["usage"] | null {
+  if (message.role !== "assistant") {
+    return null;
+  }
+
+  const messageRecord = toRecord(message);
+  const usageRecord = toRecord(messageRecord?.usage);
+  const costRecord = toRecord(usageRecord?.cost);
+  if (!usageRecord || !costRecord) {
+    return null;
+  }
+
+  const input = readFiniteNumber(usageRecord, "input");
+  const output = readFiniteNumber(usageRecord, "output");
+  const cacheRead = readFiniteNumber(usageRecord, "cacheRead");
+  const cacheWrite = readFiniteNumber(usageRecord, "cacheWrite");
+  const totalTokens = readFiniteNumber(usageRecord, "totalTokens");
+  const costInput = readFiniteNumber(costRecord, "input");
+  const costOutput = readFiniteNumber(costRecord, "output");
+  const costCacheRead = readFiniteNumber(costRecord, "cacheRead");
+  const costCacheWrite = readFiniteNumber(costRecord, "cacheWrite");
+  const costTotal = readFiniteNumber(costRecord, "total");
+
+  if (
+    input === null ||
+    output === null ||
+    cacheRead === null ||
+    cacheWrite === null ||
+    totalTokens === null ||
+    costInput === null ||
+    costOutput === null ||
+    costCacheRead === null ||
+    costCacheWrite === null ||
+    costTotal === null
+  ) {
+    return null;
+  }
+
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    totalTokens,
+    cost: {
+      input: costInput,
+      output: costOutput,
+      cacheRead: costCacheRead,
+      cacheWrite: costCacheWrite,
+      total: costTotal,
+    },
+  };
+}