mini-coder 0.7.3 → 0.8.0

package/src/oauth.ts

@@ -1,157 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import readline from "node:readline";
-
-import { getEnvApiKey, getProviders } from "@earendil-works/pi-ai";
-import {
-  getOAuthApiKey,
-  getOAuthProvider,
-  getOAuthProviders,
-  type OAuthLoginCallbacks,
-  type OAuthPrompt,
-  type OAuthProviderId,
-  type OAuthSelectPrompt,
-} from "@earendil-works/pi-ai/oauth";
-import { AUTH_PATH as AUTH_FILE, DATA_DIR } from "./shared";
-import type { CliOptions, SavedOAuthCreds } from "./types";
-
-type ReadlineInterface = ReturnType<typeof readline.createInterface>;
-
-function ask(rl: ReadlineInterface, question: string): Promise<string> {
-  return new Promise((resolve) => rl.question(question, resolve));
-}
-
-function formatPrompt(prompt: OAuthPrompt): string {
-  const placeholder = prompt.placeholder ? ` (${prompt.placeholder})` : "";
-  return `${prompt.message}${placeholder}: `;
-}
-
-async function selectOption(
-  rl: ReadlineInterface,
-  prompt: OAuthSelectPrompt,
-): Promise<string | undefined> {
-  console.log(prompt.message);
-  for (let i = 0; i < prompt.options.length; i++) {
-    console.log(`${i + 1}. ${prompt.options[i]?.label}`);
-  }
-
-  const choice = await ask(rl, `Enter number (1-${prompt.options.length}): `);
-  const index = Number.parseInt(choice, 10) - 1;
-  return prompt.options[index]?.id;
-}
-
-function createLoginCallbacks(rl: ReadlineInterface): OAuthLoginCallbacks {
-  return {
-    onAuth: ({ url, instructions }) => {
-      console.log(`Open: ${url}`);
-      if (instructions) console.log(instructions);
-    },
-    onDeviceCode: ({ userCode, verificationUri }) => {
-      console.log(`Open: ${verificationUri}`);
-      console.log(`Enter code: ${userCode}`);
-    },
-    onPrompt: (prompt) => ask(rl, formatPrompt(prompt)),
-    onProgress: (message) => console.log(message),
-    onSelect: (prompt) => selectOption(rl, prompt),
-  };
-}
-
-export function isOAuthProvider(provider: string): boolean {
-  return getOAuthProviders().some(
-    (oauthProvider) => oauthProvider.id === provider,
-  );
-}
-
-export async function getAvailableProviders(): Promise<string[]> {
-  const auth = await readCreds();
-  const loggedInOAuthProviders = getOAuthProviders()
-    .map((provider) => provider.id)
-    .filter((provider) => auth[provider]);
-  const envKeyProviders = getProviders().filter(
-    (provider) => !!getEnvApiKey(provider),
-  );
-  const providers: string[] = [];
-  const providerIds = new Set<string>();
-
-  for (const provider of [...loggedInOAuthProviders, ...envKeyProviders]) {
-    if (providerIds.has(provider)) continue;
-
-    providers.push(provider);
-    providerIds.add(provider);
-  }
-
-  return providers;
-}
-
-export async function loginOAuth(provider: OAuthProviderId) {
-  const oauthProvider = getOAuthProvider(provider);
-  if (!oauthProvider) throw new Error(`Unknown OAuth provider: ${provider}`);
-
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  try {
-    const creds = await oauthProvider.login(createLoginCallbacks(rl));
-
-    await writeCreds({ [provider]: { type: "oauth", ...creds } });
-  } finally {
-    rl.close();
-  }
-
-  return await readCreds();
-}
-
-export async function getApiKey(options: CliOptions) {
-  const provider = options.model.provider;
-  const auth = await readCreds();
-
-  if (isOAuthProvider(provider)) {
-    const result = await getOAuthApiKey(provider, auth);
-    if (result) {
-      auth[provider] = { type: "oauth", ...result.newCredentials };
-      await writeCreds(auth);
-
-      return result.apiKey;
-    }
-  }
-
-  const envApiKey = getEnvApiKey(provider);
-  if (envApiKey) return envApiKey;
-
-  const knownProviders = getProviders() as string[];
-  if (!knownProviders.includes(provider)) {
-    if (options.model.api === "openai-completions") {
-      // pi-ai requires a truthy apiKey for OpenAI-compatible local providers like Ollama.
-      return "dummy";
-    }
-
-    return undefined;
-  }
-
-  throw new Error("Not logged in");
-}
-
-export async function readCreds(): Promise<SavedOAuthCreds> {
-  const file = Bun.file(AUTH_FILE);
-  if (await file.exists()) {
-    try {
-      return JSON.parse(await file.text());
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new Error(`Invalid auth JSON: ${message}`);
-    }
-  }
-
-  return {};
-}
-
-async function writeCreds(creds: SavedOAuthCreds) {
-  await mkdir(DATA_DIR, { recursive: true });
-  await Bun.write(AUTH_FILE, JSON.stringify(await mergeCreds(creds)));
-}
-
-async function mergeCreds(newCreds: SavedOAuthCreds) {
-  const oldCreds = await readCreds();
-  return { ...oldCreds, ...newCreds };
-}

package/src/shared.ts

@@ -1,119 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { parseDocument } from "yaml";
-
-// Mixed bag of helpers that can be shared across the codebase
-
-export const DATA_DIR =
-  Bun.env.MINI_CODER_DATA_DIR ?? join(homedir(), ".config", "mini-coder");
-export const SESSIONS_DIR = join(DATA_DIR, "sessions");
-export const AUTH_PATH = join(DATA_DIR, "auth.json");
-export const SETTINGS_PATH = join(DATA_DIR, "settings.json");
-
-export function secureRandomString(
-  length: number,
-  chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
-): string {
-  const result: string[] = [];
-  const charsLength = chars.length;
-  const maxValid = Math.floor(256 / charsLength) * charsLength;
-  const randomBytes = new Uint8Array(length * 2);
-
-  while (result.length < length) {
-    crypto.getRandomValues(randomBytes);
-
-    for (const byte of randomBytes) {
-      if (byte < maxValid) {
-        result.push(chars[byte % charsLength]);
-        if (result.length === length) break;
-      }
-    }
-  }
-
-  return result.join("");
-}
-
-export function elapsedTime(seconds: number): string {
-  if (seconds < 60) return `${seconds}s`;
-
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) return `${minutes}m`;
-
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24) return `${hours}h`;
-
-  const days = Math.floor(hours / 24);
-  if (days < 7) return `${days}d`;
-
-  const weeks = Math.floor(days / 7);
-  if (weeks < 4) return `${weeks}w`;
-
-  const months = Math.floor(days / 30);
-  if (months < 12) return `${months}mo`;
-
-  const years = Math.floor(days / 365);
-  return `${years}y`;
-}
-
-export function relativeTime(timestamp: number): string {
-  const seconds = Math.floor((Date.now() - timestamp) / 1000);
-  return elapsedTime(seconds);
-}
-
-export function onceEvery<T extends unknown[]>(
-  n: number,
-  fn: (...args: T) => void,
-) {
-  let calls = 0;
-
-  return (...args: T) => {
-    calls++;
-
-    if (calls % n === 0) {
-      fn(...args);
-    }
-  };
-}
-
-export function takeTail<T>(arr: T[], x: number): T[] {
-  return x <= 0 ? [] : arr.slice(-x);
-}
-
-export function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 4);
-}
-
-export function parseSkillFrontmatter(content: string) {
-  const match = /^---\s*\n([\s\S]*?)\n---/.exec(content);
-
-  if (!match) {
-    return undefined;
-  }
-
-  const doc = parseDocument(match[1]);
-  const data = doc.toJS() as unknown;
-
-  if (!data || typeof data !== "object") {
-    return undefined;
-  }
-
-  const record = data as Record<string, unknown>;
-  const name = typeof record.name === "string" ? record.name.trim() : "";
-  const description =
-    typeof record.description === "string" ? record.description.trim() : "";
-
-  if (!name || !description) {
-    return undefined;
-  }
-
-  return { name, description };
-}
-
-export function formatTimestamp(timestampMs: number): string {
-  return new Date(timestampMs).toLocaleTimeString("en-GB", {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false,
-  });
-}

package/src/themes.ts

@@ -1,234 +0,0 @@
-import type { SyntaxHighlightTheme } from "@cel-tui/components";
-import type { Color, Theme } from "@cel-tui/core";
-
-export const TUI_THEME_IDS = [
-  "ansi16",
-  "molokai-dark",
-  "molokai-light",
-] as const;
-
-export type TUIThemeId = (typeof TUI_THEME_IDS)[number];
-
-export interface TUIThemeDefinition {
-  id: TUIThemeId;
-  label: string;
-  palette: Theme;
-  syntax: SyntaxHighlightTheme;
-  rootFgColor?: Color;
-  rootBgColor?: Color;
-  userMessageBgColor?: Color;
-}
-
-const ANSI_SLOT_HEX: Record<Color, string> = {
-  color00: "#000000",
-  color01: "#cd3131",
-  color02: "#0dbc79",
-  color03: "#e5e510",
-  color04: "#2472c8",
-  color05: "#bc3fbc",
-  color06: "#11a8cd",
-  color07: "#e5e5e5",
-  color08: "#666666",
-  color09: "#f14c4c",
-  color10: "#23d18b",
-  color11: "#f5f543",
-  color12: "#3b8eea",
-  color13: "#d670d6",
-  color14: "#29b8db",
-  color15: "#ffffff",
-};
-
-export const theme = {
-  black: "color00",
-  red: "color01",
-  green: "color02",
-  yellow: "color03",
-  blue: "color04",
-  magenta: "color05",
-  cyan: "color06",
-  white: "color07",
-  bblack: "color08",
-  bred: "color09",
-  bgreen: "color10",
-  byellow: "color11",
-  bblue: "color12",
-  bmagenta: "color13",
-  bcyan: "color14",
-  bwhite: "color15",
-} as const satisfies Record<string, Color>;
-
-const ansi16Palette: Theme = {
-  color00: 0,
-  color01: 1,
-  color02: 2,
-  color03: 3,
-  color04: 4,
-  color05: 5,
-  color06: 6,
-  color07: 7,
-  color08: 8,
-  color09: 9,
-  color10: 10,
-  color11: 11,
-  color12: 12,
-  color13: 13,
-  color14: 14,
-  color15: 15,
-};
-
-const molokaiDarkPalette: Theme = {
-  color00: "#272822",
-  color01: "#f92672",
-  color02: "#a6e22e",
-  color03: "#e6db74",
-  color04: "#66d9ef",
-  color05: "#f92672",
-  color06: "#66d9ef",
-  color07: "#f8f8f2",
-  color08: "#6f705f",
-  color09: "#ff6188",
-  color10: "#a6e22e",
-  color11: "#ffd866",
-  color12: "#78dce8",
-  color13: "#ae81ff",
-  color14: "#66d9ef",
-  color15: "#ffffff",
-};
-
-const molokaiLightPalette: Theme = {
-  color00: "#272822",
-  color01: "#ff5f87",
-  color02: "#8bcf26",
-  color03: "#c7a100",
-  color04: "#61aeee",
-  color05: "#d16dff",
-  color06: "#00a8b5",
-  color07: "#f2efe4",
-  color08: "#5f6060",
-  color09: "#b0003a",
-  color10: "#3f7d00",
-  color11: "#725f00",
-  color12: "#005f9f",
-  color13: "#7f2caf",
-  color14: "#007885",
-  color15: "#fffdf5",
-};
-
-const slotColor = (slot: Color) => ANSI_SLOT_HEX[slot];
-
-function syntaxScope(
-  scope: string | readonly string[],
-  foreground: Color,
-  fontStyle?: string,
-) {
-  return {
-    scope,
-    settings: {
-      foreground: slotColor(foreground),
-      ...(fontStyle ? { fontStyle } : {}),
-    },
-  };
-}
-
-const molokaiDarkSyntax = {
-  name: "mini-coder-molokai-dark",
-  type: "dark",
-  fg: slotColor("color07"),
-  tokenColors: [
-    syntaxScope(["comment", "markup.quote"], "color08", "italic"),
-    syntaxScope(["keyword", "operator"], "color05"),
-    syntaxScope(["string", "escape", "markup.list"], "color03"),
-    syntaxScope(["number", "regexp"], "color13"),
-    syntaxScope(["function", "command", "markup.code"], "color10"),
-    syntaxScope(["builtin", "property", "type", "meta"], "color06"),
-    syntaxScope("markup.heading", "color04", "bold"),
-    syntaxScope(["diff.deleted", "diff.file.old"], "color09"),
-    syntaxScope(["diff.inserted", "diff.file.new"], "color10"),
-    syntaxScope("diff.hunk", "color13"),
-    syntaxScope(["diff.header", "diff.no-newline"], "color08"),
-  ],
-} as const satisfies SyntaxHighlightTheme;
-
-const molokaiLightSyntax = {
-  name: "mini-coder-molokai-light",
-  type: "light",
-  fg: slotColor("color00"),
-  tokenColors: [
-    syntaxScope(["comment", "markup.quote"], "color08", "italic"),
-    syntaxScope(["keyword", "operator"], "color13"),
-    syntaxScope(["string", "escape", "markup.list"], "color11"),
-    syntaxScope(["number", "regexp"], "color09"),
-    syntaxScope(["function", "command", "markup.code"], "color10"),
-    syntaxScope(["builtin", "property", "type", "meta"], "color14"),
-    syntaxScope("markup.heading", "color12", "bold"),
-    syntaxScope(["diff.deleted", "diff.file.old"], "color09"),
-    syntaxScope(["diff.inserted", "diff.file.new"], "color10"),
-    syntaxScope("diff.hunk", "color13"),
-    syntaxScope(["diff.header", "diff.no-newline"], "color08"),
-  ],
-} as const satisfies SyntaxHighlightTheme;
-
-export const DEFAULT_TUI_THEME_ID: TUIThemeId = "ansi16";
-
-export const TUI_THEMES = {
-  ansi16: {
-    id: "ansi16",
-    label: "ansi16",
-    palette: ansi16Palette,
-    syntax: "default",
-    userMessageBgColor: theme.bblack,
-  },
-  "molokai-dark": {
-    id: "molokai-dark",
-    label: "molokai dark",
-    palette: molokaiDarkPalette,
-    syntax: molokaiDarkSyntax,
-    rootFgColor: theme.bwhite,
-    rootBgColor: theme.black,
-    userMessageBgColor: theme.bblack,
-  },
-  "molokai-light": {
-    id: "molokai-light",
-    label: "molokai light",
-    palette: molokaiLightPalette,
-    syntax: molokaiLightSyntax,
-    rootFgColor: theme.black,
-    rootBgColor: theme.bwhite,
-    userMessageBgColor: theme.white,
-  },
-} as const satisfies Record<TUIThemeId, TUIThemeDefinition>;
-
-export const activeTuiTheme: Theme = { ...ansi16Palette };
-
-export function applyTUITheme(id: TUIThemeId): void {
-  Object.assign(activeTuiTheme, TUI_THEMES[id].palette);
-}
-
-export function getTUITheme(id: TUIThemeId): TUIThemeDefinition {
-  return TUI_THEMES[id];
-}
-
-export function textColorForBackground(
-  bgColor: Color,
-  themeId: TUIThemeId,
-): Color {
-  if (bgColor === theme.bblack) return theme.bwhite;
-
-  if (
-    themeId === "molokai-light" &&
-    (
-      [
-        theme.bred,
-        theme.bgreen,
-        theme.byellow,
-        theme.bblue,
-        theme.bmagenta,
-        theme.bcyan,
-      ] as readonly Color[]
-    ).includes(bgColor)
-  ) {
-    return theme.bwhite;
-  }
-
-  return theme.black;
-}

package/src/tool-bash.ts

@@ -1,77 +0,0 @@
-import { type Tool, Type } from "@earendil-works/pi-ai";
-import type { ToolRunnerEvent } from "./types";
-
-const description = `Bash CLI tool
-
-Execute shell commands on the user's environment.
-
-- Chain commands **only** when failure should stop the flow. Avoid long chains, **2 to 3 maximum**.
-- Avoid overly complex one-liners; readability matters.
-- Quote filenames: use \`"$file"\` not \`$file\`.
-- Be careful with spaces in filenames.
-
-Commands run in: ${process.cwd()}
-`;
-
-export const bash: Tool = {
-  name: "bash",
-  description,
-  parameters: Type.Object({
-    command: Type.String({
-      description:
-        "Shell command to execute. Prefer simple, focused commands over complex one-liners.",
-    }),
-  }),
-};
-
-export async function* runBashTool(
-  args: Record<string, any>,
-  signal?: AbortSignal,
-): AsyncGenerator<ToolRunnerEvent> {
-  // Redirect stderr into stdout for the whole shell session.
-  const proc = Bun.spawn(["bash", "-c", `exec 2>&1; ${args.command}`], {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: {
-      ...Bun.env,
-      NO_COLOR: "1",
-    },
-    signal,
-  });
-
-  const decoder = new TextDecoder();
-  const reader = proc.stdout.getReader();
-
-  let output = "";
-  while (true) {
-    const { done, value } = await reader.read();
-
-    if (done) {
-      const remaining = Bun.stripANSI(decoder.decode());
-
-      if (remaining.length) {
-        output += remaining;
-        yield { type: "output", text: remaining };
-      }
-      break;
-    }
-
-    const text = Bun.stripANSI(decoder.decode(value, { stream: true }));
-
-    if (text.length) {
-      output += text;
-      yield { type: "output", text: text };
-    }
-  }
-
-  const exitCode = await proc.exited;
-
-  const result = `${output.length ? output : "(no output)"}\n\nExit code: ${exitCode}`;
-
-  yield {
-    type: "result",
-    text: result,
-  };
-
-  return result;
-}

package/src/tool-edit.ts

@@ -1,121 +0,0 @@
-import { isAbsolute, join } from "node:path";
-import { type Tool, Type } from "@earendil-works/pi-ai";
-import { createPatch } from "diff";
-import type { ToolRunnerEvent } from "./types";
-
-const description = `Edit tool
-
-A find-and-replace file editor. Use it to create new files or modify existing ones safely. Always prefer this tool over bash editing methods (sed, awk, etc).
-
-Rules
-
-- The tool refuses to edit on multiple matches of \`oldText\`. Be specific with your matching text.
-- Prefer patch-based edits (small targeted replacements) for multi-line or semantic changes.
-- Do NOT reproduce entire files. Use shell file operations (\`cp\`, \`mv\`, etc) for wholesale file replacement instead.
-
-Failure modes
-
-- If \`oldText\` is not found, the edit fails. Verify the exact text first.
-- If \`oldText\` matches multiple locations, the edit fails. Narrow your match and retry.
-- If the file does not exist and \`oldText\` is non-empty, the edit fails.
-`;
-
-export const edit: Tool = {
-  name: `edit`,
-  description,
-  parameters: Type.Object({
-    path: Type.String({
-      description:
-        "File path. Absolute or relative to the current working directory.",
-    }),
-    oldText: Type.String({
-      description:
-        'Exact text to find and replace. Empty string means "create new file".',
-    }),
-    newText: Type.String({
-      description: "Replacement text (or full content for new files)",
-    }),
-  }),
-};
-
-function findAllIndexes(text: string, sub: string): number[] {
-  if (sub.length === 0) return [];
-
-  const indexes: number[] = [];
-
-  let pos = text.indexOf(sub, 0);
-  while (pos !== -1) {
-    indexes.push(pos);
-    pos += sub.length; // use pos += 1 if you want overlapping matches
-    pos = text.indexOf(sub, pos);
-  }
-
-  return indexes;
-}
-
-export async function* runEditTool(
-  args: Record<string, any>,
-  signal?: AbortSignal,
-): AsyncGenerator<ToolRunnerEvent> {
-  const filePath = isAbsolute(args.path)
-    ? args.path
-    : join(process.cwd(), args.path);
-  const file = Bun.file(filePath);
-  const exists = await file.exists();
-
-  if (args.oldText === "") {
-    if (exists) {
-      yield { type: "result", text: `File already exists: ${filePath}` };
-      return;
-    }
-
-    await Bun.write(file, args.newText);
-    yield {
-      type: "result",
-      text: `File written: ${filePath}\n\n${args.newText}`,
-    };
-    return;
-  }
-
-  if (!exists) {
-    yield { type: "result", text: `File not found: ${filePath}` };
-    return;
-  }
-
-  const content = await file.text();
-  const matches = findAllIndexes(content, args.oldText);
-
-  if (matches.length === 0) {
-    yield { type: "result", text: `Old text not found in: ${filePath}` };
-    return;
-  }
-
-  if (matches.length > 1) {
-    yield {
-      type: "result",
-      text: `Multiple matches found in ${filePath}: ${matches.length} matches, be more specific and try again`,
-    };
-    return;
-  }
-
-  const idx = matches[0];
-  const updated =
-    content.slice(0, idx) +
-    args.newText +
-    content.slice(idx + args.oldText.length);
-
-  if (signal?.aborted) {
-    yield { type: "result", text: "Aborted before write." };
-    return;
-  }
-
-  await file.write(updated);
-  const patch = createPatch(filePath, content, updated);
-
-  yield {
-    type: "result",
-    text: patch,
-  };
-
-  return;
-}