mini-coder 0.4.1 → 0.5.0

package/src/submit.ts

@@ -0,0 +1,323 @@
+/**
+ * Shared raw-input resolution and turn submission logic.
+ *
+ * @module
+ */
+
+import { readFileSync } from "node:fs";
+import type { UserMessage } from "@mariozechner/pi-ai";
+import type { AgentEvent } from "./agent.ts";
+import { runAgentLoop } from "./agent.ts";
+import { getGitState } from "./git.ts";
+import {
+  type AppState,
+  buildPrompt,
+  buildToolList,
+  ensureSession,
+  MAX_PROMPT_HISTORY,
+} from "./index.ts";
+import { parseInput } from "./input.ts";
+import {
+  addMessageToStats,
+  appendMessage,
+  appendPromptHistory,
+  filterModelMessages,
+  truncatePromptHistory,
+} from "./session.ts";
+import { executeReadImage } from "./tools.ts";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Result of resolving raw user input into a command, message, or error. */
+export type ResolvedInput =
+  | {
+      /** Empty/whitespace-only input that should be ignored. */
+      type: "empty";
+    }
+  | {
+      /** Parsed slash command. */
+      type: "command";
+      /** Command name without the leading slash. */
+      command: string;
+      /** Raw command arguments after trimming. */
+      args: string;
+    }
+  | {
+      /** Validation or resolution error for the raw input. */
+      type: "error";
+      /** User-facing error message. */
+      message: string;
+    }
+  | {
+      /** Model-visible message content ready for submission. */
+      type: "message";
+      /** Fully resolved user content. */
+      content: UserMessage["content"];
+    };
+
+/** Hooks used by UI and headless mode around a submitted turn. */
+export interface SubmitTurnHooks {
+  /** Called after the user message is persisted and added to state. */
+  onUserMessage?: (state: AppState) => void;
+  /** Called after the run switches into the active streaming state. */
+  onTurnStart?: (state: AppState) => void;
+  /** Called for each agent event emitted during the turn. */
+  onEvent?: (event: AgentEvent, state: AppState) => void;
+  /** Called after the turn finishes or aborts its active state. */
+  onTurnEnd?: (
+    state: AppState,
+    stopReason: "stop" | "length" | "error" | "aborted" | null,
+  ) => void;
+}
+
+// ---------------------------------------------------------------------------
+// Input resolution helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Strip YAML frontmatter from a skill file.
+ *
+ * @param content - Raw `SKILL.md` file content.
+ * @returns The content without a leading frontmatter block.
+ */
+export function stripSkillFrontmatter(content: string): string {
+  const frontmatter = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+  return frontmatter ? content.slice(frontmatter[0].length) : content;
+}
+
+/**
+ * Check whether user content contains any meaningful model-visible payload.
+ *
+ * @param content - User message content to inspect.
+ * @returns `true` when the content is empty or whitespace-only.
+ */
+export function isEmptyUserContent(content: UserMessage["content"]): boolean {
+  if (typeof content === "string") {
+    return content.trim().length === 0;
+  }
+
+  return content.every(
+    (block) => block.type === "text" && block.text.trim().length === 0,
+  );
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function buildSkillMessageContent(
+  skillName: string,
+  userText: string,
+  state: Pick<AppState, "skills">,
+): string | null {
+  const skill = state.skills.find((entry) => entry.name === skillName);
+  if (!skill) {
+    throw new Error(`Unknown skill: ${skillName}`);
+  }
+
+  let skillBody: string;
+  try {
+    skillBody = stripSkillFrontmatter(readFileSync(skill.path, "utf-8")).trim();
+  } catch (error) {
+    throw new Error(
+      `Failed to read skill ${skillName}: ${getErrorMessage(error)}`,
+    );
+  }
+  const parts = [skillBody, userText].filter((part) => part.length > 0);
+  return parts.length > 0 ? parts.join("\n\n") : null;
+}
+
+function buildImageMessageContent(
+  imagePath: string,
+  rawInput: string,
+  state: Pick<AppState, "cwd">,
+): UserMessage["content"] | null {
+  const displayPath = rawInput.trim();
+
+  try {
+    const result = executeReadImage({ path: imagePath }, state.cwd);
+    if (result.isError) {
+      return displayPath || null;
+    }
+
+    return [
+      { type: "text", text: displayPath },
+      ...result.content.filter((block) => block.type === "image"),
+    ];
+  } catch {
+    return displayPath || null;
+  }
+}
+
+/**
+ * Resolve raw submitted input into a command, a model-visible message, or an error.
+ *
+ * This reuses the same parsing rules for interactive and headless input.
+ *
+ * @param raw - Raw user input.
+ * @param state - Current app state needed for skill/image resolution.
+ * @returns The resolved input result.
+ */
+export function resolveRawInput(
+  raw: string,
+  state: Pick<AppState, "model" | "cwd" | "skills">,
+): ResolvedInput {
+  const parsed = parseInput(raw, {
+    supportsImages: state.model?.input.includes("image") ?? false,
+    cwd: state.cwd,
+  });
+
+  switch (parsed.type) {
+    case "command":
+      return {
+        type: "command",
+        command: parsed.command,
+        args: parsed.args,
+      };
+    case "skill": {
+      try {
+        const content = buildSkillMessageContent(
+          parsed.skillName,
+          parsed.userText,
+          state,
+        );
+        return content && !isEmptyUserContent(content)
+          ? { type: "message", content }
+          : { type: "empty" };
+      } catch (error) {
+        return {
+          type: "error",
+          message: getErrorMessage(error),
+        };
+      }
+    }
+    case "image": {
+      const content = buildImageMessageContent(parsed.path, raw, state);
+      return content && !isEmptyUserContent(content)
+        ? { type: "message", content }
+        : { type: "empty" };
+    }
+    case "text":
+      return parsed.text && !isEmptyUserContent(parsed.text)
+        ? { type: "message", content: parsed.text }
+        : { type: "empty" };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Turn submission
+// ---------------------------------------------------------------------------
+
+function handleAgentEvent(event: AgentEvent, state: AppState): void {
+  switch (event.type) {
+    case "assistant_message":
+      state.messages.push(event.message);
+      state.stats = addMessageToStats(state.stats, event.message);
+      break;
+    case "tool_result":
+      state.messages.push(event.message);
+      break;
+    case "text_delta":
+    case "thinking_delta":
+    case "toolcall_start":
+    case "toolcall_delta":
+    case "toolcall_end":
+    case "tool_start":
+    case "tool_delta":
+    case "tool_end":
+    case "done":
+    case "error":
+    case "aborted":
+      break;
+  }
+}
+
+/**
+ * Submit already-resolved user content as one conversational turn.
+ *
+ * Persists the raw prompt, appends the user message, runs the full agent loop,
+ * updates in-memory state as assistant/tool messages arrive, and returns the
+ * final stop reason for the turn.
+ *
+ * @param rawInput - Exact raw submitted prompt text.
+ * @param content - Resolved model-visible user content.
+ * @param state - Mutable application state.
+ * @param hooks - Optional lifecycle hooks for UI/headless integrations.
+ * @returns The terminal stop reason for the turn.
+ */
+export async function submitResolvedInput(
+  rawInput: string,
+  content: UserMessage["content"],
+  state: AppState,
+  hooks?: SubmitTurnHooks,
+): Promise<"stop" | "length" | "error" | "aborted"> {
+  if (!state.model) {
+    throw new Error("No model is available for this run.");
+  }
+  if (state.running) {
+    throw new Error("A turn is already running.");
+  }
+  if (isEmptyUserContent(content)) {
+    throw new Error("Cannot submit empty input.");
+  }
+
+  const session = ensureSession(state);
+  appendPromptHistory(state.db, {
+    text: rawInput,
+    cwd: state.cwd,
+    sessionId: session.id,
+  });
+  truncatePromptHistory(state.db, MAX_PROMPT_HISTORY);
+
+  const userMessage = {
+    role: "user",
+    content,
+    timestamp: Date.now(),
+  } satisfies UserMessage;
+
+  const turn = appendMessage(state.db, session.id, userMessage);
+  state.messages.push(userMessage);
+  hooks?.onUserMessage?.(state);
+
+  state.git = await getGitState(state.cwd);
+
+  const systemPrompt = buildPrompt(state);
+  const { tools, toolHandlers } = buildToolList(state);
+  const modelMessages = filterModelMessages(state.messages);
+
+  state.running = true;
+  state.abortController = new AbortController();
+  hooks?.onTurnStart?.(state);
+
+  let stopReason: "stop" | "length" | "error" | "aborted" | null = null;
+
+  try {
+    const result = await runAgentLoop({
+      db: state.db,
+      sessionId: session.id,
+      turn,
+      model: state.model,
+      systemPrompt,
+      tools,
+      toolHandlers,
+      messages: modelMessages,
+      cwd: state.cwd,
+      apiKey: state.providers.get(state.model.provider),
+      effort: state.effort,
+      signal: state.abortController.signal,
+      onEvent: (event) => {
+        handleAgentEvent(event, state);
+        hooks?.onEvent?.(event, state);
+      },
+    });
+    stopReason = result.stopReason;
+    state.git = await getGitState(state.cwd);
+    return result.stopReason;
+  } finally {
+    state.running = false;
+    state.abortController = null;
+    hooks?.onTurnEnd?.(state, stopReason);
+  }
+}

package/src/theme.ts

@@ -0,0 +1,147 @@
+/**
+ * UI theme definition and default colors.
+ *
+ * All UI colors are read from the active {@link Theme} object — the UI
+ * never hardcodes colors. Plugins can return a `Partial<Theme>` in their
+ * result to override any color. Multiple overrides are merged left-to-right.
+ *
+ * Theme values are cel-tui {@link Color} palette references. The default
+ * theme prefers ANSI 16-color palette entries so it adapts cleanly to the
+ * user's terminal theme while still allowing restrained pill styling.
+ *
+ * @module
+ */
+
+import type { Color } from "@cel-tui/types";
+
+/** A cel-tui palette color or the terminal default when undefined. */
+type ThemeColor = Color | undefined;
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Foreground/background pair for a single status pill tone. */
+export interface StatusTone {
+  /** Pill foreground color. */
+  fg: ThemeColor;
+  /** Pill background color. */
+  bg: ThemeColor;
+}
+
+/**
+ * Complete set of UI colors.
+ *
+ * The default theme uses terminal palette indices so it adapts to the
+ * user's terminal color scheme automatically.
+ */
+export interface Theme {
+  /** User message background. */
+  userMsgBg: ThemeColor;
+  /** Muted informational text, placeholders, and helper copy. */
+  mutedText: ThemeColor;
+  /** Primary accent for important labels and interactive highlights. */
+  accentText: ThemeColor;
+  /** Secondary accent for supplementary labels like git status. */
+  secondaryAccentText: ThemeColor;
+  /** Tool output left border and text. */
+  toolBorder: ThemeColor;
+  /** Tool output text. */
+  toolText: ThemeColor;
+  /** Added/replacement edit preview text. */
+  diffAdded: ThemeColor;
+  /** Removed/original edit preview text. */
+  diffRemoved: ThemeColor;
+  /** Divider line color (idle state). */
+  divider: ThemeColor;
+  /** Divider scanning pulse highlight color (active state). */
+  dividerPulse: ThemeColor;
+  /** Neutral status pill tone for the inner CWD/git pills. */
+  statusSecondary: StatusTone;
+  /** Model/effort pill tones from low/cold to xhigh/warm. */
+  statusEffortScale: readonly [StatusTone, StatusTone, StatusTone, StatusTone];
+  /** Usage/context pill tones from empty/cold to near-full/hot. */
+  statusContextScale: readonly [
+    StatusTone,
+    StatusTone,
+    StatusTone,
+    StatusTone,
+    StatusTone,
+  ];
+  /** Error text. */
+  error: ThemeColor;
+  /** Overlay modal background. */
+  overlayBg: ThemeColor;
+}
+
+// ---------------------------------------------------------------------------
+// Default theme
+// ---------------------------------------------------------------------------
+
+/**
+ * The default theme.
+ *
+ * Uses terminal palette colors so it looks reasonable across light and
+ * dark terminal themes without any configuration. The inner status pills
+ * stay neutral, while the outer pills use stepped ANSI16 tone scales so
+ * reasoning effort and context pressure move through green, cyan, purple,
+ * and red as they trend from cold/dark to warm/bright.
+ */
+export const DEFAULT_THEME: Theme = {
+  userMsgBg: "color08",
+  mutedText: "color08",
+  accentText: "color04",
+  secondaryAccentText: "color05",
+  toolBorder: "color08",
+  toolText: "color08",
+  diffAdded: "color02",
+  diffRemoved: "color01",
+  divider: "color08",
+  dividerPulse: "color04",
+  statusSecondary: {
+    fg: "color15",
+    bg: "color08",
+  },
+  statusEffortScale: [
+    { fg: "color00", bg: "color02" },
+    { fg: "color00", bg: "color06" },
+    { fg: "color15", bg: "color05" },
+    { fg: "color00", bg: "color09" },
+  ],
+  statusContextScale: [
+    { fg: "color00", bg: "color02" },
+    { fg: "color00", bg: "color06" },
+    { fg: "color15", bg: "color05" },
+    { fg: "color15", bg: "color01" },
+    { fg: "color00", bg: "color09" },
+  ],
+  error: "color01",
+  overlayBg: "color08",
+};
+
+// ---------------------------------------------------------------------------
+// Theme merging
+// ---------------------------------------------------------------------------
+
+/**
+ * Merge partial theme overrides on top of a base theme.
+ *
+ * Applies overrides left-to-right — later overrides win for the same key.
+ * This is a shallow merge, so nested status tones and tone scales are
+ * replaced as whole values. Returns a new {@link Theme}; the base is not
+ * mutated.
+ *
+ * @param base - The base theme to start from.
+ * @param overrides - Partial theme objects to merge (from plugins).
+ * @returns A complete {@link Theme} with all overrides applied.
+ */
+export function mergeThemes(
+  base: Theme,
+  ...overrides: Partial<Theme>[]
+): Theme {
+  let merged = { ...base };
+  for (const override of overrides) {
+    merged = { ...merged, ...override };
+  }
+  return merged;
+}