mini-coder 0.5.6 → 0.5.8

package/src/prompt.ts

@@ -1,9 +1,9 @@
 /**
  * System prompt construction.
  *
- * Assembles the full system prompt from static base instructions and
+ * Assembles the full system prompt from the core prompt template plus
  * dynamic context: AGENTS.md files, skill catalog, plugin suffixes,
- * and a session footer with date, CWD, and git state.
+ * and the current environment block.
  *
  * @module
  */
@@ -30,8 +30,14 @@ export interface AgentsMdFile {
 interface BuildSystemPromptOpts {
   /** Current working directory. */
   cwd: string;
-  /** Current date string (YYYY-MM-DD). */
-  date: string;
+  /** Active provider/model identifier. */
+  modelLabel: string;
+  /** Normalized host OS label (`linux`, `mac`, or `docker`). */
+  os: string;
+  /** Active shell name (for example `bash` or `zsh`). */
+  shell: string;
+  /** Whether the active model supports image input. */
+  supportsImages?: boolean;
   /** Git repository state, or `null`/`undefined` if not in a repo. */
   git?: GitState | null;
   /** Discovered AGENTS.md files, ordered root-to-leaf. */
@@ -153,7 +159,7 @@ export function discoverAgentsMd(
 // ---------------------------------------------------------------------------
 
 /**
- * Format a git state snapshot into a single-line string for the session footer.
+ * Format a git state snapshot into a single-line string for the environment block.
  *
  * Fields are omitted when their values are zero. The git line format:
  * `Git: branch main | 3 staged, 1 modified, 2 untracked | +5 −2 vs origin/main`
@@ -185,67 +191,81 @@ export function formatGitLine(state: GitState): string {
 }
 
 // ---------------------------------------------------------------------------
-// Base instructions
+// Core prompt template
 // ---------------------------------------------------------------------------
 
-const BASE_INSTRUCTIONS = `You are mini-coder, a coding agent running in the user's terminal.
+function buildCorePrompt(opts: BuildSystemPromptOpts): string {
+  const lines = [
+    "You are mini-coder, the best software engineering assistant in the world.",
+    "",
+    "The current environment is:",
+    `- LLM in use: ${opts.modelLabel}`,
+    `- OS: ${opts.os}`,
+    `- Current working directory: ${opts.cwd}`,
+  ];
 
-# Role
-
-You are an autonomous, senior-level coding assistant. When the user gives a direction, proactively gather context, plan with the user, implement, and verify. Bias toward action: plan briefly when needed to clear important assumptions, then continue into implementation. First identify the task contract: required files, names, interfaces, output format, and checks for success. Treat those details as part of correctness, not as polish. Deliver working code, unless you are genuinely blocked.
-
-# Tools
-
-You have these core tools:
-
-- \`shell\` — run commands in the user's shell. Use this to explore the codebase, read tests/verifiers/examples, inspect required outputs, and run targeted checks, builds, or git commands. Prefer \`rg\` over \`grep\` for speed.
-- \`edit\` — make exact-text replacements in files. Provide the file path, the exact text to find, and the replacement text. The old text must match exactly one location in the file. To create a new file, use an empty old text and the full file content as new text. Use this to write the exact final file content the task requires.
-
-You may also have additional tools provided by plugins. Use them when they match the task.
-
-Workflow: **inspect with shell → mutate with edit → verify with shell**.
-
-# Code quality
-
-- Conform to the codebase's existing conventions: patterns, naming, formatting, language idioms.
-- Write correct, clear, minimal code. Prefer the simplest solution that satisfies the task's checks exactly. Don't over-engineer, don't add abstractions for hypothetical futures.
-- Reuse before creating. Search for existing helpers before writing new ones.
-- Tight error handling: no broad try/catch, no silent failures, no swallowed errors.
-- Keep type safety. Avoid \`any\` casts. Use proper types and guards.
-- Only add comments where the logic isn't self-evident.
-
-# Editing discipline
-
-- Read enough context before editing. Batch logical changes together rather than making many small edits.
-- Never revert changes you didn't make unless explicitly asked.
-- Never use destructive git commands (reset --hard, checkout --, clean -fd) unless the user requests it.
-- Default to ASCII. Only use non-ASCII characters when the file already uses them or there's clear justification.
-
-# Exploring the codebase
-
-- Think first: before any tool call, decide all files and information you need.
-- Early in the task, look for acceptance criteria in tests, verifier scripts, eval scripts, examples, and expected-output files. Do not rely on the task text alone when machine-checkable criteria are available.
-- Before relying on a binary, interpreter, or CLI helper you have not yet confirmed, probe availability with focused checks such as \`command -v <tool>\`, \`<tool> --version\`, or \`python3 -m pip --version\`, then adapt to what is actually installed.
-- Batch reads: if you need multiple files, read them together in parallel rather than one at a time.
-- Only make sequential calls when a later call genuinely depends on an earlier result.
+  if (opts.git) {
+    lines.push(`- ${formatGitLine(opts.git)}`);
+  }
 
-# Communication
+  lines.push(
+    `- Shell: ${opts.shell}. Use \`command -v <name>\` to check what is available to you; do not assume environment support.`,
+    "- Edit: Safe exact-text replacement in a single file.",
+  );
 
-- Be concise. Friendly coding teammate tone.
-- After making changes: lead with a quick explanation of what changed and why, then suggest logical next steps if any.
-- Don't dump large file contents you've written — reference file paths.
-- When discussing multiple options, use numbered lists so the user can reply with a number without turning it into a questionnaire.
-- If asked for a review, focus on bugs, risks, regressions, and missing tests. Findings first, ordered by severity.
+  if (opts.supportsImages) {
+    lines.push("- Read Image: Read an image from disk.");
+  }
 
-# Persistence
+  lines.push(
+    "",
+    "## Core working style:",
+    "",
+    "- Be concise, direct, and useful.",
+    "- Use a casual, solution-oriented technical tone. Avoid fluff and performative apologies.",
+    "- When the user gives a clear command, do it without adding extra work they did not ask for.",
+    "- Prefer the minimal implementation that satisfies the request exactly.",
+    "- Use YAGNI. Avoid speculative abstractions, future-proofing, and unnecessary compatibility shims.",
+    "- Preserve working behavior where possible. Prefer targeted fixes over rewrites.",
+    "- Be thorough, use fresh eyes and internal analysis before taking action.",
+    "- Make informed decisions based on the available information and best practices.",
+    "- Always verify the result of your actions.",
+    "",
+    "### Using the shell tool:",
+    "",
+    "- Always execute shell commands in non-interactive mode.",
+    "- Use the appropriate commands and package managers for the specified operating system.",
+    "- Don't assume the environment supports all commands; check before using them.",
+    "- Avoid destructive commands that can discard changes or override edits.",
+    "",
+    "### Working with code:",
+    "",
+    "- Describe changes before implementing them",
+    "- Prefer boring dependable solutions over clever ones",
+    "- Avoid creating extra files, systems or documentation outside of what was asked.",
+    "- Check requirements, and plan your changes before editing code.",
+    "- Implement the necessary changes, following good practices and proper error handling.",
+    "- Always verify your changes using compilation, testing, and manual verification when possible.",
+    "- Do not leave helpers, tests, or any other form of temporary files; clean up after yourself and leave no trace.",
+    "- Ensure you match the requested output exactly. This applies to file names, directory structure, number of files, output formats, and all other details.",
+    '- "Polish" is not optional; it counts just as much as solving the task.',
+    "",
+    "### Task management",
+    "",
+    "- Use `todoWrite` proactively for multi-step or non-trivial tasks.",
+    "- Capture new requirements in the todo list as soon as you understand them.",
+    "- Use `todoRead` when you need to inspect the current list before updating it or when the user asks for the current plan/status.",
+    "- Keep the todo list up-to-date above all; mark tasks `in_progress` before starting them and `completed` as soon as verification succeeds.",
+    "- A todo item is only complete if the requested work is actually finished and verified to the degree the task requires.",
+    "- Use `cancelled` to remove tasks that are no longer relevant.",
+    "- Skip todo tools for single trivial tasks and purely conversational/informational requests.",
+    '- You have the option to delegate tasks to copies of yourself with `mc -p "subtask prompt"` in the shell.',
+    "- Delegate when you are orchestrating a large to-do/plan execution.",
+    "",
+  );
 
-- Carry work through to completion within the current turn. Don't stop at analysis or partial fixes.
-- Once the contract is clear, create the required artifact early, then iterate and improve it. Do not spend most of the turn exploring.
-- Run the narrowest verifier or test as soon as there is a plausible first implementation or artifact. Do not delay the first verification run until the end.
-- When verification is down to a small number of failures, stop broad exploration and focus only on the remaining failing assertions or exact contract gaps until the last detail passes.
-- If you encounter an error, diagnose and fix it rather than reporting it and stopping.
-- Before concluding, run the smallest targeted verification that checks the exact contract: required files exist, names and signatures match, outputs are in the required format, and no forbidden extra artifacts were left behind.
-- Avoid excessive looping: if you're re-reading or re-editing the same files without progress, stop and ask the user.`;
+  return lines.join("\n");
+}
 
 // ---------------------------------------------------------------------------
 // System prompt assembly
@@ -255,30 +275,27 @@ Workflow: **inspect with shell → mutate with edit → verify with shell**.
  * Build the full system prompt.
  *
  * Assembly order:
- * 1. Base instructions (static)
+ * 1. Core prompt template (including the current environment block)
  * 2. AGENTS.md content (project-specific)
  * 3. Skills catalog (XML)
  * 4. Plugin suffixes
- * 5. Session footer (date, CWD, git)
  *
  * @param opts - Prompt construction options.
  * @returns The assembled system prompt string.
  */
 export function buildSystemPrompt(opts: BuildSystemPromptOpts): string {
-  const sections: string[] = [BASE_INSTRUCTIONS];
+  const sections: string[] = [buildCorePrompt(opts)];
 
   // 2. AGENTS.md content
   if (opts.agentsMd && opts.agentsMd.length > 0) {
-    const agentsSection = [
-      "\n# Project Context\n",
-      "Project-specific instructions and guidelines:\n",
-    ];
+    const agentsSection = [];
     for (const file of opts.agentsMd) {
-      agentsSection.push(`## ${file.path}\n`);
+      agentsSection.push(`## ${file.path}`);
+      agentsSection.push("");
       agentsSection.push(file.content);
       agentsSection.push("");
     }
-    sections.push(agentsSection.join("\n"));
+    sections.push(agentsSection.join("\n").trimEnd());
   }
 
   // 3. Skills catalog
@@ -294,14 +311,5 @@ export function buildSystemPrompt(opts: BuildSystemPromptOpts): string {
     }
   }
 
-  // 5. Session footer
-  const footer: string[] = [];
-  footer.push(`Current date: ${opts.date}`);
-  footer.push(`Current working directory: ${opts.cwd}`);
-  if (opts.git) {
-    footer.push(formatGitLine(opts.git));
-  }
-  sections.push(footer.join("\n"));
-
-  return sections.join("\n");
+  return sections.join("\n\n");
 }

package/src/session.ts

@@ -16,6 +16,7 @@ import type {
   ToolResultMessage,
   UserMessage,
 } from "@mariozechner/pi-ai";
+import type { TodoItem } from "./tools.ts";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -94,8 +95,8 @@ interface AppendPromptHistoryOpts {
   sessionId?: string;
 }
 
-/** A persisted UI-only message shown in the conversation log. */
-export interface UiMessage {
+/** 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. */
@@ -106,6 +107,21 @@ export interface UiMessage {
   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;
 
@@ -491,10 +507,27 @@ function isUiMessageRecord(value: unknown): value is UiMessage {
     return false;
   }
 
+  const timestamp = readFiniteNumber(record, "timestamp");
+  if (timestamp === null) {
+    return false;
+  }
+
+  if (record.kind === "info") {
+    return typeof record.content === "string";
+  }
+
   return (
-    record.kind === "info" &&
-    typeof record.content === "string" &&
-    readFiniteNumber(record, "timestamp") !== null
+    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"),
+    )
   );
 }
 
@@ -593,12 +626,12 @@ export function truncateSessions(
 // ---------------------------------------------------------------------------
 
 /**
- * Create a persisted UI message.
+ * Create a persisted UI info message.
  *
  * @param content - Display text shown in the conversation log.
- * @returns A new {@link UiMessage}.
+ * @returns A new {@link UiInfoMessage}.
  */
-export function createUiMessage(content: string): UiMessage {
+export function createUiMessage(content: string): UiInfoMessage {
   return {
     role: "ui",
     kind: "info",
@@ -607,6 +640,21 @@ export function createUiMessage(content: string): UiMessage {
   };
 }
 
+/**
+ * Create a persisted UI todo snapshot message.
+ *
+ * @param todos - Todo snapshot rendered in the conversation log.
+ * @returns A new {@link UiTodoMessage}.
+ */
+export function createUiTodoMessage(todos: readonly TodoItem[]): UiTodoMessage {
+  return {
+    role: "ui",
+    kind: "todo",
+    todos: todos.map((todo) => ({ ...todo })),
+    timestamp: Date.now(),
+  };
+}
+
 /**
  * Check whether a persisted message is a UI-only message.
  *

package/src/submit.ts

@@ -9,7 +9,6 @@ import type { UserMessage } from "@mariozechner/pi-ai";
 import type { AgentEvent } from "./agent.ts";
 import { runAgentLoop } from "./agent.ts";
 import { getErrorMessage } from "./errors.ts";
-import { getGitState } from "./git.ts";
 import {
   type AppState,
   buildPrompt,
@@ -204,12 +203,63 @@ export function resolveRawInput(
   }
 }
 
+function recordRawPromptHistory(
+  rawInput: string,
+  state: Pick<AppState, "db" | "cwd">,
+  sessionId: string,
+): void {
+  appendPromptHistory(state.db, {
+    text: rawInput,
+    cwd: state.cwd,
+    sessionId,
+  });
+  truncatePromptHistory(state.db, MAX_PROMPT_HISTORY);
+}
+
+/**
+ * Queue resolved user content for the next model-request boundary of an active run.
+ *
+ * The raw prompt is recorded immediately in prompt history, but the model-visible
+ * `UserMessage` is only appended to session history when the agent loop consumes it.
+ *
+ * @param rawInput - Exact raw submitted prompt text.
+ * @param content - Resolved model-visible user content.
+ * @param state - Mutable application state.
+ */
+export function queueResolvedInput(
+  rawInput: string,
+  content: UserMessage["content"],
+  state: AppState,
+): void {
+  if (!state.running) {
+    throw new Error("Cannot queue input while no turn is running.");
+  }
+  if (isEmptyUserContent(content)) {
+    throw new Error("Cannot queue empty input.");
+  }
+
+  const session = ensureSession(state);
+  recordRawPromptHistory(rawInput, state, session.id);
+  state.queuedUserMessages.push({
+    role: "user",
+    content,
+    timestamp: Date.now(),
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Turn submission
 // ---------------------------------------------------------------------------
 
 function handleAgentEvent(event: AgentEvent, state: AppState): void {
   switch (event.type) {
+    case "user_message":
+      state.messages.push(event.message);
+      state.contextTokens = addMessageToContextTokens(
+        state.contextTokens,
+        event.message,
+      );
+      break;
     case "assistant_message":
       state.messages.push(event.message);
       state.stats = addMessageToStats(state.stats, event.message);
@@ -270,19 +320,13 @@ export async function submitResolvedInput(
   }
 
   const session = ensureSession(state);
-  appendPromptHistory(state.db, {
-    text: rawInput,
-    cwd: state.cwd,
-    sessionId: session.id,
-  });
-  truncatePromptHistory(state.db, MAX_PROMPT_HISTORY);
+  recordRawPromptHistory(rawInput, state, session.id);
 
   const userMessage = {
     role: "user",
     content,
     timestamp: Date.now(),
   } satisfies UserMessage;
-  const loadGitState = state.loadGitState ?? getGitState;
 
   const turn = appendMessage(state.db, session.id, userMessage);
   state.messages.push(userMessage);
@@ -292,8 +336,6 @@ export async function submitResolvedInput(
   );
   hooks?.onUserMessage?.(state);
 
-  state.git = await loadGitState(state.cwd);
-
   const systemPrompt = buildPrompt(state);
   const { tools, toolHandlers } = buildToolList(state);
   const modelMessages = filterModelMessages(state.messages);
@@ -318,13 +360,13 @@ export async function submitResolvedInput(
       apiKey: state.providers.get(state.model.provider),
       effort: state.effort,
       signal: state.abortController.signal,
+      takeQueuedUserMessage: () => state.queuedUserMessages.shift() ?? null,
       onEvent: (event) => {
         handleAgentEvent(event, state);
         hooks?.onEvent?.(event, state);
       },
     });
     stopReason = result.stopReason;
-    state.git = await loadGitState(state.cwd);
     return result.stopReason;
   } finally {
     state.running = false;