mini-coder 0.7.4 → 0.8.1

package/src/cli.ts

@@ -0,0 +1,99 @@
+import process from "node:process";
+import { clampThinkingLevel, type AssistantMessage, type Message, type UserMessage } from "@earendil-works/pi-ai";
+import { loadConfig, resolveModel } from "./config.ts";
+import { buildSystemPrompt } from "./prompt.ts";
+import { acceptsImages, toolSchemas } from "./tools/index.ts";
+import { Session } from "./session.ts";
+import { NO_INTERACTION, assistantText, runAgentTurn, type AgentOptions } from "./agent.ts";
+import { runTui } from "./tui/tui.ts";
+
+function parseArgs(argv: string[]): { print: string | null } {
+  let print: string | null = null;
+  for (let i = 0; i < argv.length; i++) {
+    const match = /^(?:-p|--print)(?:=(.*))?$/.exec(argv[i]);
+    if (match === null) throw new Error(`unknown argument: ${argv[i]}`);
+    const value = match[1] ?? argv[++i];
+    if (value === undefined) throw new Error(`${argv[i - 1]} requires a prompt`);
+    print = value;
+  }
+  return { print };
+}
+
+async function runPrint(prompt: string, ctx: AgentOptions): Promise<number> {
+  const messages: Message[] = [];
+  const user: UserMessage = { role: "user", content: prompt, timestamp: Date.now() };
+  messages.push(user);
+  ctx.session.appendMessage(user);
+
+  const controller = new AbortController();
+  const onSignal = () => controller.abort();
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+
+  let failed = false;
+  let cancelled = false;
+  try {
+    await runAgentTurn({
+      ...ctx,
+      messages,
+      signal: controller.signal,
+      interaction: NO_INTERACTION,
+      onEvent: (event) => {
+        if (event.type === "toolCall") process.stderr.write(`[tool] ${event.name}\n`);
+        else if (event.type === "toolOutput") process.stderr.write(event.chunk);
+        else if (event.type === "error") {
+          failed = true;
+          process.stderr.write(`[error] ${event.message}\n`);
+        } else if (event.type === "cancelled") {
+          cancelled = true;
+          process.stderr.write("[cancelled]\n");
+        }
+      },
+    });
+  } catch (error) {
+    failed = true;
+    process.stderr.write(`[error] ${(error as Error).message}\n`);
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    ctx.session.close();
+  }
+
+  const last = messages.filter((message): message is AssistantMessage => message.role === "assistant").at(-1);
+  if (!failed && !cancelled && last !== undefined) {
+    const text = assistantText(last);
+    if (text !== "") process.stdout.write(text.endsWith("\n") ? text : `${text}\n`);
+  }
+  return failed || cancelled ? 1 : 0;
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  const config = loadConfig();
+  const { models, model } = resolveModel(config);
+  const session = new Session(config.sessionsDir, process.cwd());
+  const ctx: AgentOptions = {
+    models,
+    model,
+    systemPrompt: buildSystemPrompt(config),
+    tools: toolSchemas(config.tools, acceptsImages(model)),
+    toolNames: config.tools,
+    thinkingEffort: clampThinkingLevel(model, config.thinkingEffort),
+    session,
+  };
+
+  if (args.print !== null) {
+    process.exitCode = await runPrint(args.print, ctx);
+    return;
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("interactive mode requires a TTY; use -p for non-interactive mode");
+  }
+  await runTui(ctx);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${(error as Error).message}\n`);
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,179 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+  createProvider,
+  envApiKeyAuth,
+  Type,
+  type Api,
+  type Model,
+  type ModelThinkingLevel,
+  type MutableModels,
+  type Static,
+} from "@earendil-works/pi-ai";
+import { Value } from "typebox/value";
+import { builtinModels } from "@earendil-works/pi-ai/providers/all";
+import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { googleGenerativeAIApi } from "@earendil-works/pi-ai/api/google-generative-ai.lazy";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import { createCredentialStore } from "./auth.ts";
+
+const ToolNameSchema = Type.Union([Type.Literal("edit"), Type.Literal("read"), Type.Literal("bash")]);
+export type ToolName = Static<typeof ToolNameSchema>;
+
+const CustomApiSchema = Type.Union([
+  Type.Literal("openai-completions"),
+  Type.Literal("openai-responses"),
+  Type.Literal("anthropic-messages"),
+  Type.Literal("google-generative-ai"),
+]);
+type CustomApi = Static<typeof CustomApiSchema>;
+
+const CustomProviderSchema = Type.Object(
+  {
+    id: Type.String({ minLength: 1 }),
+    name: Type.Optional(Type.String()),
+    baseUrl: Type.String({ minLength: 1 }),
+    api: CustomApiSchema,
+    models: Type.Array(Type.String(), { minItems: 1 }),
+    envKeys: Type.Optional(Type.Array(Type.String())),
+    headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+  },
+  { additionalProperties: false },
+);
+
+const ConfigSchema = Type.Object(
+  {
+    sessionsDir: Type.String({ default: join(process.cwd(), "sessions") }),
+    authFile: Type.String({ default: join(configDir(), "auth.json") }),
+    systemPrompt: Type.String({ default: "" }),
+    discoverAgentFiles: Type.Boolean({ default: true }),
+    skillsDirs: Type.Array(Type.String(), { default: [] }),
+    tools: Type.Array(ToolNameSchema, { default: ["edit", "read", "bash"] }),
+    provider: Type.String(),
+    model: Type.String(),
+    thinkingEffort: Type.Union(
+      [
+        Type.Literal("off"),
+        Type.Literal("minimal"),
+        Type.Literal("low"),
+        Type.Literal("medium"),
+        Type.Literal("high"),
+        Type.Literal("xhigh"),
+        Type.Literal("max"),
+      ],
+      { default: "medium" },
+    ),
+    customProviders: Type.Array(CustomProviderSchema, { default: [] }),
+  },
+  { additionalProperties: false },
+);
+export type Config = Static<typeof ConfigSchema>;
+
+function configDir(): string {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "mini-coder");
+}
+
+function configPath(): string {
+  return join(configDir(), "config.json");
+}
+
+function readJson(path: string): unknown {
+  let text: string;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw new Error(`config ${path}: ${(error as Error).message}`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`config ${path}: ${(error as Error).message}`);
+  }
+}
+
+export function loadConfig(): Config {
+  const path = configPath();
+  const filled = Value.Default(ConfigSchema, readJson(path));
+  try {
+    return Value.Parse(ConfigSchema, filled);
+  } catch {
+    const first = [...Value.Errors(ConfigSchema, filled)][0];
+    throw new Error(`config ${path}: ${first ? `${first.instancePath || "/"} ${first.message}` : "invalid"}`);
+  }
+}
+
+/**
+ * Persist a patch to the global config, leaving every other key untouched.
+ * Written atomically: a temp file, then a rename over the target.
+ */
+export function saveConfig(patch: {
+  provider?: string;
+  model?: string;
+  thinkingEffort?: ModelThinkingLevel;
+}): void {
+  const path = configPath();
+  const existing = readJson(path);
+  if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+    throw new Error(`config ${path}: not an object`);
+  }
+  const next = { ...existing, ...patch };
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = join(dirname(path), `.${process.pid}.${Date.now()}.tmp`);
+  writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`);
+  renameSync(temp, path);
+}
+
+const API_FACTORY: Record<CustomApi, () => ReturnType<typeof openAICompletionsApi>> = {
+  "openai-completions": openAICompletionsApi,
+  "openai-responses": openAIResponsesApi,
+  "anthropic-messages": anthropicMessagesApi,
+  "google-generative-ai": googleGenerativeAIApi,
+};
+
+export function resolveModel(config: Config): { models: MutableModels; model: Model<Api> } {
+  const models = builtinModels({ credentials: createCredentialStore(config.authFile) });
+  for (const provider of config.customProviders) {
+    const name = provider.name ?? provider.id;
+    models.setProvider(
+      createProvider({
+        id: provider.id,
+        name,
+        baseUrl: provider.baseUrl,
+        headers: provider.headers,
+        auth: {
+          apiKey: provider.envKeys?.length
+            ? envApiKeyAuth(name, provider.envKeys)
+            : { name, resolve: async () => ({ auth: { apiKey: "unused" } }) },
+        },
+        api: API_FACTORY[provider.api](),
+        models: provider.models.map((id) => ({
+          id,
+          name: id,
+          api: provider.api,
+          provider: provider.id,
+          baseUrl: provider.baseUrl,
+          reasoning: false,
+          input: ["text"] satisfies ("text" | "image")[],
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: 200_000,
+          maxTokens: 32_768,
+        })),
+      }),
+    );
+  }
+
+  const model = models.getModel(config.provider, config.model);
+  if (!model) {
+    const known = models
+      .getModels(config.provider)
+      .map((m) => m.id)
+      .slice(0, 12);
+    const hint = known.length ? ` (available: ${known.join(", ")})` : "";
+    throw new Error(`config model: unknown model "${config.model}" for provider "${config.provider}"${hint}`);
+  }
+  return { models, model };
+}

package/src/prompt.ts

@@ -1,232 +1,79 @@
-import { promises } from "node:fs";
-import { readdir } from "node:fs/promises";
-import { homedir, platform } from "node:os";
-import { join } from "node:path";
-import type { Message, ToolResultMessage } from "@earendil-works/pi-ai";
-import { getGitStatus } from "./git";
-import { parseSkillFrontmatter } from "./shared";
-
-export const MAIN_PROMPT = `You are a coding agent interacting with users via the mini-coder harness. You help users by reading files, executing commands, and editting code.
-
-- Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without unnecessary superlatives, praise, or emotional validation.
-- User messages and Tool results may include <system-reminder> tags. These contain system-generated reminders and bear no direct relation to the specific tool result in which they appear.
-- You have access to bash, read and edit tools. Prefer using read and edit for file operations, use bash for finding read candidates or to run development commands.
-- Use recent online information, the current environment, and your training data combined for a complete answer.
-- Ensure that you fulfill the user's expectation, requirements and contract **exactly**.
-- Do not overstate what changed or what was verified. Summaries must match the diff.
-- Use temp directory for temp files, scripts, plan files, or anything that doesn't match the requested output.
-- Be concise. Use a professional colleague tone: direct, never condescending, and never rude.
-`;
-
-async function getDir() {
-  const ignoreFile = Bun.file(".gitignore");
-  let ignoreContent = "";
-  if (await ignoreFile.exists()) {
-    ignoreContent = await ignoreFile.text();
-  }
-  const ignored = ignoreContent.split("\n");
-  const dir = [];
-  const glob = promises.glob(["*", "*/*"], { exclude: ignored });
-  for await (const file of glob) {
-    dir.push(file);
-  }
-  return dir;
-}
-
-async function getEnvPrompt() {
-  // TODO: What else do the agents always check before answering every time?
-  const gitStatus = await getGitStatus();
-  const envKeys = ["PATH", "USER", "LANG", "HOME", "SHELL", "BUN_INSTALL"];
-  const env: Record<string, string> = {};
-  for (const key of envKeys) {
-    const v = Bun.env[key];
-
-    if (v !== undefined) {
-      env[key] = v;
-    }
-  }
-
-  const envStatus = JSON.stringify(
-    {
-      os: platform(),
-      env,
-      cwd: process.cwd(),
-      dir: await getDir(),
-      git: gitStatus,
-    },
-    null,
-    4,
-  );
-
-  const text = `### Environment status and information
-
-\`\`\`json
-  ${envStatus}
-\`\`\`
-`;
-
-  return text;
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import type { Config } from "./config.ts";
+
+interface Skill {
+  name: string;
+  description: string;
+  path: string;
 }
 
-// `AGENTS.md` support: find it in current folder (./AGENTS.md) and a global one. (`.agents/AGENTS.md`)
-export async function getAGENTSFiles() {
-  const content: string[] = [];
-
-  const globalPath = join(homedir(), ".agents/AGENTS.md");
-  const globalFile = Bun.file(globalPath);
-
-  if (await globalFile.exists()) {
-    content.push(await globalFile.text());
-  }
-
-  const localPath = join(process.cwd(), "AGENTS.md");
-  const localFile = Bun.file(localPath);
-
-  if (await localFile.exists()) {
-    content.push(await localFile.text());
+function frontmatter(text: string): { name?: string; description?: string } {
+  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+  const out: { name?: string; description?: string } = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const separator = line.indexOf(":");
+    if (separator < 0) continue;
+    const key = line.slice(0, separator).trim();
+    const value = line.slice(separator + 1).trim().replace(/^["']|["']$/g, "");
+    if (key === "name") out.name = value;
+    if (key === "description") out.description = value;
   }
-
-  return content.join("\n\n").trim();
+  return out;
 }
 
-// `SKILLS.md` discovery from [~|.]/agents/skills/*/SKILL.md
-export async function getSkills(): Promise<string> {
-  let skillsBlock: string = "";
-  const skillRoots = [
-    join(homedir(), ".agents", "skills"),
-    join(process.cwd(), ".agents", "skills"),
-  ];
-
-  for (const root of skillRoots) {
+function discoverSkills(dirs: string[]): Skill[] {
+  const skills: Skill[] = [];
+  for (const root of dirs) {
     let entries: string[];
-
     try {
-      entries = await readdir(root);
+      entries = readdirSync(root);
     } catch {
       continue;
     }
-
     for (const entry of entries) {
-      const path = join(root, entry, "SKILL.md");
-      const file = Bun.file(path);
-
-      if (!(await file.exists())) {
-        continue;
-      }
-
-      const parsed = parseSkillFrontmatter(await file.text());
-
-      if (!parsed) {
-        continue;
-      }
-
-      skillsBlock += `## ${parsed.name}
-
-> Absolute file path to read: ${path}
-
-${parsed.description}
-
-`;
+      const path = resolve(root, entry, "SKILL.md");
+      if (!existsSync(path)) continue;
+      const meta = frontmatter(readFileSync(path, "utf8"));
+      if (!meta.name) continue;
+      skills.push({ name: meta.name, description: meta.description ?? "", path });
     }
   }
-
-  if (!skillsBlock.length) return "";
-
-  const skills = `# Skills
-
-- The following skills provide specialized instructions for specific tasks.
-- Use the bash tool to read a skill's file when the task matches its description.
-- Use the skill provided absolute file path instead of guessing or constructing one.
-- Skills can be global (in ~/.agents/skills) or local to the directory (./agents/skills)
-
-${skillsBlock}`;
-
-  return skills.trim();
+  return skills;
 }
 
-export async function buildSystemPrompt(systemPrompt: string) {
-  const agentsContent = await getAGENTSFiles();
-  const skillsContent = await getSkills();
-  let complete = systemPrompt;
-
-  if (skillsContent) {
-    complete += `\n${skillsContent}`;
-  }
-
-  if (agentsContent) {
-    complete += `\n${agentsContent}`;
+function agentFiles(): { path: string; text: string }[] {
+  const roots = [join(homedir(), ".agents"), process.cwd()];
+  const found: { path: string; text: string }[] = [];
+  for (const root of roots) {
+    for (const name of ["AGENTS.md", "CLAUDE.md"]) {
+      const path = join(root, name);
+      if (existsSync(path)) found.push({ path, text: readFileSync(path, "utf8").trim() });
+    }
   }
-
-  return complete;
-}
-
-export async function injectEnvReminder(): Promise<string> {
-  const envStatus = await getEnvPrompt();
-  return `<system-reminder>\n${envStatus}\n</system-reminder>`;
+  return found;
 }
 
-const doomLoopReminder = `<system-reminder>
-You may be entering a tool-call doom loop: recent tool usage is repetitive or not clearly progressing.
+export function buildSystemPrompt(config: Config): string {
+  const sections: string[] = [];
+  if (config.systemPrompt.trim()) sections.push(config.systemPrompt.trim());
 
-- Stop repeating the same or similar tool call unless new evidence requires it.
-- Re-read the user's request and summarize what is known, what failed, and what is still needed.
-- Change strategy before calling more tools: narrow the next check, use a different source of evidence, or ask the user if blocked.
-- If the request is complete, stop calling tools and provide the final answer.
-</system-reminder>`;
-
-// Checks recent tool usage for simple repeated-call patterns and inserts an
-// anti-doom-loop reminder when the agent appears stuck.
-export function insertToolUsageReminder(
-  messages: Message[],
-  toolMessage: ToolResultMessage,
-): ToolResultMessage {
-  const lastReminderIdx = messages.findLastIndex((m) => {
-    return (
-      m.role === "toolResult" &&
-      m.content.find(
-        (b) => b.type === "text" && b.text.includes(doomLoopReminder),
-      )
-    );
-  });
-  const lastUserMessageIdx = messages.findLastIndex((m) => {
-    return m.role === "user";
-  });
-  const messagesSinceLast = messages.slice(
-    Math.max(lastReminderIdx, lastUserMessageIdx) + 1,
-  );
-  const minMessagesForReminder = 4;
-
-  if (messagesSinceLast.length < minMessagesForReminder) return toolMessage;
-
-  let errorCount = 0;
-  let sameToolCount = 0;
-  const seenArgs = new Set<string>();
-
-  for (const msg of messagesSinceLast) {
-    if (msg.role === "toolResult" && msg.isError) errorCount++;
-
-    if (msg.role === "assistant") {
-      const calls = msg.content.filter((b) => b.type === "toolCall");
-      for (const c of calls) {
-        const args = JSON.stringify(c.arguments);
-        if (seenArgs.has(args)) sameToolCount++;
-        seenArgs.add(args);
-      }
+  if (config.skillsDirs.length > 0) {
+    const skills = discoverSkills(config.skillsDirs);
+    if (skills.length > 0) {
+      sections.push(
+        "## Skills\n\n" + skills.map((s) => `- ${s.name}: ${s.description} (${s.path})`).join("\n"),
+      );
     }
   }
 
-  if (
-    errorCount >= minMessagesForReminder ||
-    sameToolCount >= minMessagesForReminder
-  ) {
-    return {
-      ...toolMessage,
-      content: [
-        ...toolMessage.content,
-        { type: "text", text: doomLoopReminder },
-      ],
-    };
+  if (config.discoverAgentFiles) {
+    for (const file of agentFiles()) {
+      sections.push(`## ${file.path}\n\n${file.text}`);
+    }
   }
 
-  return toolMessage;
+  return sections.join("\n\n");
 }