mini-coder 0.7.4 → 0.8.0

package/src/models.ts

@@ -1,191 +0,0 @@
-import type {
-  Api,
-  Credential,
-  CredentialStore,
-  KnownApi,
-  KnownProvider,
-  Model,
-  ProviderStreams,
-} from "@earendil-works/pi-ai";
-import { createProvider } from "@earendil-works/pi-ai";
-import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
-import { azureOpenAIResponsesApi } from "@earendil-works/pi-ai/api/azure-openai-responses.lazy";
-import { bedrockConverseStreamApi } from "@earendil-works/pi-ai/api/bedrock-converse-stream.lazy";
-import { googleGenerativeAIApi } from "@earendil-works/pi-ai/api/google-generative-ai.lazy";
-import { googleVertexApi } from "@earendil-works/pi-ai/api/google-vertex.lazy";
-import { mistralConversationsApi } from "@earendil-works/pi-ai/api/mistral-conversations.lazy";
-import { openAICodexResponsesApi } from "@earendil-works/pi-ai/api/openai-codex-responses.lazy";
-import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
-import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
-import {
-  builtinModels,
-  getBuiltinModels,
-  getBuiltinProviders,
-} from "@earendil-works/pi-ai/providers/all";
-import { AUTH_PATH } from "./shared.ts";
-
-const API_STREAMS: Record<KnownApi, () => ProviderStreams> = {
-  "anthropic-messages": anthropicMessagesApi,
-  "azure-openai-responses": azureOpenAIResponsesApi,
-  "bedrock-converse-stream": bedrockConverseStreamApi,
-  "google-generative-ai": googleGenerativeAIApi,
-  "google-vertex": googleVertexApi,
-  "mistral-conversations": mistralConversationsApi,
-  "openai-codex-responses": openAICodexResponsesApi,
-  "openai-completions": openAICompletionsApi,
-  "openai-responses": openAIResponsesApi,
-};
-
-type SavedCredentials = Record<string, Credential>;
-
-async function readCredentials(): Promise<SavedCredentials> {
-  const file = Bun.file(AUTH_PATH);
-  if (await file.exists()) {
-    return JSON.parse(await file.text()) as SavedCredentials;
-  }
-
-  return {};
-}
-
-async function writeCredentials(credentials: SavedCredentials) {
-  await Bun.write(AUTH_PATH, JSON.stringify(credentials));
-}
-
-export function createCredentialStore(): CredentialStore {
-  return {
-    async read(providerId) {
-      const credentials = await readCredentials();
-      return credentials[providerId];
-    },
-
-    async modify(providerId, fn) {
-      const credentials = await readCredentials();
-      const next = await fn(credentials[providerId]);
-
-      if (next) {
-        credentials[providerId] = next;
-        await writeCredentials(credentials);
-      }
-
-      return credentials[providerId];
-    },
-
-    async delete(providerId) {
-      const credentials = await readCredentials();
-      delete credentials[providerId];
-      await writeCredentials(credentials);
-    },
-  };
-}
-
-export function isBuiltinProvider(provider: string): provider is KnownProvider {
-  return getBuiltinProviders().includes(provider as KnownProvider);
-}
-
-export function findModelConfig(
-  modelId: string,
-  provider: string,
-  customProviders?: Model<Api>[],
-) {
-  if (isBuiltinProvider(provider)) {
-    const models = getBuiltinModels(provider);
-    if (models.length === 0) throw new Error("Provider has no models");
-    return models.find((m) => m.id === modelId);
-  }
-  return customProviders?.find(
-    (m) => m.provider === provider && m.id === modelId,
-  );
-}
-
-export function getFirstModelConfig(
-  provider: string,
-  customProviders?: Model<Api>[],
-): Model<Api> {
-  if (isBuiltinProvider(provider)) {
-    const models = getBuiltinModels(provider);
-    if (models.length > 0) return models[0];
-  }
-  const custom = customProviders?.find((m) => m.provider === provider);
-  if (custom) return custom;
-  throw new Error("Provider has no models");
-}
-
-export function getFallbackModel(
-  provider: string,
-  explicitModel: boolean,
-  providerChanged: boolean,
-  customProviders?: Model<Api>[],
-): Model<Api> {
-  if (explicitModel) {
-    throw new Error("Model not found");
-  }
-
-  if (!providerChanged) {
-    throw new Error("Model not found");
-  }
-
-  return getFirstModelConfig(provider, customProviders);
-}
-
-export function getProviderModels(
-  provider: string,
-  customProviders?: Model<Api>[],
-): Model<Api>[] {
-  const builtIn = isBuiltinProvider(provider) ? getBuiltinModels(provider) : [];
-  const custom = customProviders?.filter((m) => m.provider === provider) ?? [];
-
-  return [...builtIn, ...custom];
-}
-
-export function createAppModels(customProviders?: Model<Api>[]) {
-  const models = builtinModels({ credentials: createCredentialStore() });
-  const customProviderGroups = new Map<string, Model<Api>[]>();
-
-  for (const model of customProviders ?? []) {
-    const group = customProviderGroups.get(model.provider) ?? [];
-    group.push(model);
-    customProviderGroups.set(model.provider, group);
-  }
-
-  for (const [provider, providerModels] of customProviderGroups) {
-    models.setProvider(
-      createProvider({
-        id: provider,
-        name: provider,
-        models: providerModels,
-        auth: {
-          apiKey: {
-            name: provider,
-            resolve: async () => ({ auth: { apiKey: "dummy" } }),
-          },
-        },
-        api: Object.fromEntries(
-          Object.entries(API_STREAMS)
-            .filter(([api]) =>
-              providerModels.some((model) => model.api === api),
-            )
-            .map(([api, createStreams]) => [api, createStreams()]),
-        ),
-      }),
-    );
-  }
-
-  return models;
-}
-
-export async function getConfiguredBuiltinProviders(): Promise<string[]> {
-  const models = builtinModels({ credentials: createCredentialStore() });
-  const providers: string[] = [];
-
-  for (const provider of models.getProviders()) {
-    const model = provider.getModels()[0];
-    if (!model) continue;
-
-    try {
-      const auth = await models.getAuth(model);
-      if (auth) providers.push(provider.id);
-    } catch {}
-  }
-
-  return providers;
-}

package/src/oauth.ts

@@ -1,147 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import readline from "node:readline";
-
-import {
-  getOAuthProvider,
-  getOAuthProviders,
-  type OAuthLoginCallbacks,
-  type OAuthPrompt,
-  type OAuthProviderId,
-  type OAuthSelectPrompt,
-} from "@earendil-works/pi-ai/oauth";
-import {
-  createAppModels,
-  getConfiguredBuiltinProviders,
-  isBuiltinProvider,
-} from "./models.ts";
-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 = await getConfiguredBuiltinProviders();
-  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 models = createAppModels(options.customProviders);
-  const auth = await models.getAuth(options.model);
-
-  if (auth?.auth.apiKey) return auth.auth.apiKey;
-
-  if (!isBuiltinProvider(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;
-}