mini-coder 0.7.3 → 0.8.0

package/src/config.ts

@@ -0,0 +1,150 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  createProvider,
+  envApiKeyAuth,
+  Type,
+  type Api,
+  type Model,
+  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";
+
+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") }),
+    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("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 configPath(): string {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "mini-coder", "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"}`);
+  }
+}
+
+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();
+  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");
 }

package/src/session.ts

@@ -1,91 +1,146 @@
-import { mkdir } from "node:fs/promises";
+import {
+  closeSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  writeSync,
+} from "node:fs";
+import { randomBytes } from "node:crypto";
 import { join } from "node:path";
-import type { Message } from "@earendil-works/pi-ai";
-import { Value } from "typebox/value";
-import { SESSIONS_DIR } from "./shared";
-import { type Session, SessionSchema } from "./types";
+import type { Message, Tool } from "@earendil-works/pi-ai";
 
-export async function ensureSessionsDir(): Promise<void> {
-  await mkdir(SESSIONS_DIR, { recursive: true });
+interface SessionHeader {
+  type: "session";
+  version: 1;
+  id: string;
+  cwd: string;
+  createdAt: string;
+  title: string;
 }
 
-export async function getSession(id: string): Promise<Session | undefined> {
-  const file = Bun.file(join(SESSIONS_DIR, `${id}.json`));
+interface RequestRecord {
+  type: "request";
+  at: string;
+  provider: string;
+  model: string;
+  api: string;
+  thinkingEffort: string;
+  systemPrompt: string;
+  tools: Tool[];
+}
 
-  if (!(await file.exists())) {
-    return;
-  }
+interface MessageRecord {
+  type: "message";
+  at: string;
+  message: Message;
+}
 
-  try {
-    const sessionJson = await file.text();
-    const parsed = JSON.parse(sessionJson) as unknown;
-    const valid = Value.Check(SessionSchema, parsed);
+type SessionRecord = SessionHeader | RequestRecord | MessageRecord;
 
-    if (valid) return parsed;
-  } catch {
-    return;
-  }
+function slugify(text: string): string {
+  const slug = text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40)
+    .replace(/-+$/, "");
+  return slug || "session";
+}
+
+const ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
 
-  return;
+function shortId(): string {
+  const bytes = randomBytes(6);
+  let out = "";
+  for (let i = 0; i < 6; i++) out += ALPHABET[bytes[i] % 36];
+  return out;
 }
 
-function latestMessageTimestamp(session: Session): number {
-  return Math.max(0, ...session.messages.map((message) => message.timestamp));
+function timestamp(date: Date): string {
+  const p = (n: number) => String(n).padStart(2, "0");
+  return (
+    `${date.getUTCFullYear()}${p(date.getUTCMonth() + 1)}${p(date.getUTCDate())}` +
+    `-${p(date.getUTCHours())}${p(date.getUTCMinutes())}${p(date.getUTCSeconds())}`
+  );
 }
 
-export async function listSessionsForCwd(): Promise<Session[]> {
-  const sessions: Session[] = [];
-  const sessionFiles = new Bun.Glob("*.json");
-  const cwd = process.cwd();
+function titleFor(message: Message): string {
+  if (message.role !== "user") return "session";
+  const text = typeof message.content === "string"
+    ? message.content
+    : message.content.map((block) => (block.type === "text" ? block.text : "")).join(" ");
+  return slugify(text);
+}
 
-  try {
-    for await (const entry of sessionFiles.scan({
-      cwd: SESSIONS_DIR,
-      dot: true,
-    })) {
-      try {
-        const sessionJson = await Bun.file(join(SESSIONS_DIR, entry)).text();
-        const parsed = JSON.parse(sessionJson) as unknown;
-
-        if (Value.Check(SessionSchema, parsed) && cwd === parsed.cwd) {
-          sessions.push(parsed);
-        }
-      } catch {
-        // Ignore invalid session files.
-      }
-    }
-  } catch {
-    return [];
+export class Session {
+  private readonly sessionsDir: string;
+  private readonly cwd: string;
+  id: string | null = null;
+  private fd: number | null = null;
+  private closed = false;
+
+  constructor(sessionsDir: string, cwd: string) {
+    this.sessionsDir = sessionsDir;
+    this.cwd = cwd;
   }
 
-  return sessions.sort(
-    (a, b) => latestMessageTimestamp(b) - latestMessageTimestamp(a),
-  );
-}
+  appendMessage(message: Message): void {
+    if (this.closed) return;
+    this.ensure(titleFor(message));
+    this.write({
+      type: "message",
+      at: new Date().toISOString(),
+      message,
+    });
+  }
 
-export async function saveSession(s: Session) {
-  await ensureSessionsDir();
-  const file = Bun.file(join(SESSIONS_DIR, `${s.id}.json`));
-  await Bun.write(file, JSON.stringify(s));
-}
+  appendRequest(input: Omit<RequestRecord, "type" | "at">): void {
+    if (this.closed) return;
+    this.ensure("session");
+    this.write({ type: "request", at: new Date().toISOString(), ...input });
+  }
 
-export async function updateSession(id: string, messages: Message[]) {
-  const existing = await getSession(id);
-  if (existing) {
-    // Only append new messages, so we don't save compacted messages.
-    if (existing.messages.length < messages.length) {
-      const newMessages = messages.slice(existing.messages.length);
-      existing.messages = [...existing.messages, ...newMessages];
-      await saveSession(existing);
+  close(): void {
+    this.closed = true;
+    if (this.fd !== null) {
+      closeSync(this.fd);
+      this.fd = null;
     }
-    return;
   }
 
-  const s = {
-    id,
-    cwd: process.cwd(),
-    messages,
-  };
+  private ensure(title: string): void {
+    if (this.fd !== null) return;
+    mkdirSync(this.sessionsDir, { recursive: true });
+    const stamp = timestamp(new Date());
+    for (let attempt = 0; attempt < 16; attempt++) {
+      const name = `${stamp}-${title}-${shortId()}`;
+      const dir = join(this.sessionsDir, name);
+      try {
+        mkdirSync(dir);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "EEXIST") continue;
+        throw error;
+      }
+      this.id = name;
+      const logPath = join(dir, "session.jsonl");
+      this.fd = openSync(logPath, "a");
+      const header: SessionHeader = {
+        type: "session",
+        version: 1,
+        id: name,
+        cwd: this.cwd,
+        createdAt: new Date().toISOString(),
+        title,
+      };
+      this.write(header);
+      return;
+    }
+    throw new Error(`session: could not create a unique directory in ${this.sessionsDir}`);
+  }
 
-  await saveSession(s);
+  private write(record: SessionRecord): void {
+    if (this.fd === null) throw new Error("session: append before create");
+    writeSync(this.fd, JSON.stringify(record) + "\n");
+    fsyncSync(this.fd);
+  }
 }