mini-coder 0.7.3 → 0.8.0

package/src/tui.ts

@@ -1,314 +0,0 @@
-import { cel, HStack, ProcessTerminal, VStack } from "@cel-tui/core";
-import type {
-  AssistantMessage,
-  ToolResultMessage,
-} from "@earendil-works/pi-ai";
-import { streamAgent } from "./agent";
-import { getBranchLabel } from "./git";
-import {
-  buildSystemPrompt,
-  injectEnvReminder,
-  insertToolUsageReminder,
-  MAIN_PROMPT,
-} from "./prompt";
-import { updateSession } from "./session";
-import { estimateTokens, formatTimestamp, secureRandomString } from "./shared";
-import { activeTuiTheme, applyTUITheme, getTUITheme } from "./themes";
-import { bash, runBashTool } from "./tool-bash";
-import { edit, runEditTool } from "./tool-edit";
-import { read, runReadTool } from "./tool-read";
-import {
-  ActivityPill,
-  ContextPill,
-  GitPill,
-  ModelPill,
-  Spinner,
-  TextPill,
-  theme,
-} from "./tui-components";
-import { Conversation, emptyState } from "./tui-conversation";
-import { Editor } from "./tui-editor";
-import { mainMenu } from "./tui-overlay";
-import type { AgentContex, ToolAndRunner, TUIMessage, TUIState } from "./types";
-import { getAvailableUpdate } from "./update";
-
-async function refreshAvailableUpdate(state: TUIState): Promise<void> {
-  state.availableUpdate = await getAvailableUpdate();
-}
-
-function clearOrAbort(state: TUIState) {
-  // Are we mid stream? Abort it.
-  if (state.streaming) {
-    state.abortController?.abort();
-  }
-
-  // Is the user clearing a state prompt?
-  if (state.prompt?.length) {
-    state.prompt = "";
-  }
-}
-
-export function initTUI(state: TUIState, leave: (s: string) => void) {
-  // TODO: Cleanup accumulated sessions for this cwd.
-  const { spinnerEvery, currentSpinner } = Spinner();
-  void refreshAvailableUpdate(state);
-
-  // Stable 60fps rendering.
-  // This ensure Xfps, and excessive calls get coalesced in cel-tui.
-  const fps = 60;
-  const baseFramerateIntervalId = setInterval(() => {
-    if (state.streaming) {
-      spinnerEvery();
-    }
-    cel.setTitle(
-      `mc ${state.streaming ? currentSpinner() : ">"} ../${state.cwd}`,
-    );
-    cel.render();
-  }, 1000 / fps);
-
-  let menu = mainMenu(state);
-
-  const onWindowKeyPress = (key: string) => {
-    if (key === "ctrl+q" || key === "ctrl+c" || key === "ctrl+d") {
-      // Quit
-      clearInterval(baseFramerateIntervalId);
-      cel.stop();
-      leave("Done.");
-    } else if (key === "escape") {
-      // Abort or clear prompt
-      clearOrAbort(state);
-    } else if (key === "ctrl+p") {
-      menu = mainMenu(state);
-      state.overlay = true;
-    } else if (key === "ctrl+f") {
-      menu = mainMenu(state, "fork");
-      state.overlay = true;
-    }
-  };
-
-  const onChange = (value: string) => {
-    state.prompt = value;
-  };
-
-  const onEditorKeyPress = (key: string) => {
-    const submit = async () => {
-      await streamAgentTUI(state);
-    };
-    // onKeyPress
-    if (key === "enter") {
-      if (state.prompt === ":q") {
-        clearInterval(baseFramerateIntervalId);
-        cel.stop();
-        leave("Done. I like vim too.");
-        return false;
-      }
-      if (state.prompt === ":n" || state.prompt === "/new") {
-        state.sessionId = undefined;
-        state.messages = [];
-        state.tuiMessages = [];
-        state.prompt = "";
-        state.contextSize = 0;
-        state.scrollOffset = 0;
-        state.stickToBottom = true;
-        return false;
-      }
-      if (state.prompt && !state.streaming) submit();
-      return false;
-    }
-  };
-
-  applyTUITheme(state.options.theme);
-  cel.init(new ProcessTerminal(), { theme: activeTuiTheme });
-  cel.viewport(() => {
-    const activeTheme = getTUITheme(state.options.theme);
-    const layers = [
-      VStack(
-        {
-          height: "100%",
-          gap: 1,
-          padding: { x: 1, y: 1 },
-          onKeyPress: onWindowKeyPress,
-          fgColor: activeTheme.rootFgColor,
-          bgColor: activeTheme.rootBgColor,
-          italic: state.forceThemeRefresh,
-        },
-        [
-          state.messages.length ? Conversation(state) : emptyState(state),
-          HStack({ gap: 1 }, [
-            ModelPill(state),
-            TextPill(`../${state.cwd}`, theme.bwhite, theme.bblack),
-            GitPill(state),
-            VStack({ flex: 1 }, []),
-            ActivityPill(state, currentSpinner()),
-            ContextPill(state),
-          ]),
-
-          Editor(state, onChange, onEditorKeyPress),
-        ],
-      ),
-    ];
-    if (state.overlay) {
-      layers.push(menu());
-    }
-
-    return layers;
-  });
-}
-
-async function streamAgentTUI(state: TUIState) {
-  // Just as a defensive thought, callers should set this ahead of time if doing other
-  // ops before starting the stream.
-  state.streaming = true;
-
-  const abortController = new AbortController();
-  state.abortController = abortController;
-
-  const tools: ToolAndRunner[] = [
-    { tool: bash, runner: runBashTool },
-    { tool: edit, runner: runEditTool },
-    { tool: read, runner: runReadTool },
-  ];
-
-  let userContent = state.prompt;
-  if (state.messages.length === 0) {
-    const envReminder = await injectEnvReminder();
-    userContent = `${envReminder}\n\n${userContent}`;
-  }
-  state.messages.push({
-    role: "user",
-    content: userContent,
-    timestamp: Date.now(),
-  });
-  state.tuiMessages.push({
-    timestamp: formatTimestamp(Date.now()),
-    role: "user",
-    text: state.prompt,
-  });
-  state.prompt = "";
-
-  const systemPrompt = await buildSystemPrompt(MAIN_PROMPT);
-  const ctx: AgentContex = {
-    systemPrompt,
-    tools,
-    messages: state.messages,
-    options: state.options,
-    signal: state.abortController?.signal,
-  };
-
-  const toTUIMessage = (partial: AssistantMessage) => {
-    const text = partial.content
-      .filter((c) => c.type === "text")
-      .map((c) => c.text)
-      .join("")
-      .trim();
-    const thinking = partial.content
-      .filter((c) => c.type === "thinking")
-      .map((c) => c.thinking)
-      .join("")
-      .trim();
-    const toolCalls = partial.content
-      .filter((c) => c.type === "toolCall")
-      .map((c) => {
-        return {
-          id: c.id,
-          tool: c.name,
-          args: c.arguments,
-          output: "",
-        };
-      });
-
-    return {
-      timestamp: formatTimestamp(partial.timestamp),
-      role: "assistant" as const,
-      text,
-      thinking,
-      toolCalls,
-    };
-  };
-
-  const updateToolCall = (
-    partial: ToolResultMessage,
-    tuiMessages: TUIMessage[],
-  ) => {
-    tuiMessages.forEach((c) => {
-      const parentCall = c.toolCalls?.find((t) => t.id === partial.toolCallId);
-      if (parentCall) {
-        parentCall.output = partial.content
-          .filter((c) => c.type === "text")
-          .map((c) => c.text)
-          .join("")
-          .trim();
-      }
-    });
-  };
-
-  const agent = streamAgent(ctx);
-  try {
-    for await (const ev of agent) {
-      switch (ev.type) {
-        case "message_start":
-          state.tuiMessages.push(toTUIMessage(ev.partial));
-          break;
-        case "message_update":
-          state.tuiMessages[state.tuiMessages.length - 1] = toTUIMessage(
-            ev.partial,
-          );
-          break;
-        case "message_end": {
-          state.tuiMessages[state.tuiMessages.length - 1] = toTUIMessage(
-            ev.message,
-          );
-          const { systemPrompt, tools, messages } = ctx;
-          state.contextSize = estimateTokens(
-            JSON.stringify({ systemPrompt, tools, messages }),
-          );
-          break;
-        }
-
-        case "tool_message_start":
-          updateToolCall(ev.partial, state.tuiMessages);
-          break;
-        case "tool_message_update":
-          updateToolCall(ev.partial, state.tuiMessages);
-          break;
-        case "tool_message_end": {
-          updateToolCall(ev.message, state.tuiMessages);
-          const withReminder = insertToolUsageReminder(
-            state.messages,
-            ev.message,
-          );
-
-          const idx = state.messages.findIndex(
-            (m) =>
-              m.role === "toolResult" &&
-              m.toolCallId === withReminder.toolCallId,
-          );
-          if (idx >= 0) {
-            state.messages[idx] = withReminder;
-          }
-
-          const { systemPrompt, tools, messages } = ctx;
-          state.contextSize = estimateTokens(
-            JSON.stringify({ systemPrompt, tools, messages }),
-          );
-        }
-      }
-    }
-  } catch (error) {
-    const text = error instanceof Error ? error.message : String(error);
-    state.tuiMessages.push({
-      timestamp: formatTimestamp(Date.now()),
-      role: "assistant",
-      text,
-    });
-  } finally {
-    state.streaming = false;
-    if (!state.sessionId) {
-      const id = secureRandomString(10);
-      state.sessionId = id;
-    }
-    await updateSession(state.sessionId, state.messages);
-  }
-
-  state.gitBranch = await getBranchLabel();
-}

package/src/types.ts

@@ -1,194 +0,0 @@
-import {
-  type Api,
-  type AssistantMessage,
-  type Message,
-  type Model,
-  type Static,
-  type ThinkingLevel,
-  type Tool,
-  type ToolResultMessage,
-  Type,
-} from "@earendil-works/pi-ai";
-import type { OAuthCredentials } from "@earendil-works/pi-ai/oauth";
-import { TUI_THEME_IDS, type TUIThemeId } from "./themes";
-
-const ThinkingLevelSchema = Type.Unsafe<ThinkingLevel>(
-  Type.Union([
-    Type.Literal("minimal"),
-    Type.Literal("low"),
-    Type.Literal("medium"),
-    Type.Literal("high"),
-    Type.Literal("xhigh"),
-  ]),
-);
-
-const ModelSchema = Type.Unsafe<Model<Api>>(
-  Type.Object({
-    id: Type.String(),
-    name: Type.String(),
-    api: Type.String(),
-    provider: Type.String(),
-    baseUrl: Type.String(),
-    reasoning: Type.Boolean(),
-    input: Type.Array(
-      Type.Union([Type.Literal("text"), Type.Literal("image")]),
-    ),
-    cost: Type.Object({
-      input: Type.Number(),
-      output: Type.Number(),
-      cacheRead: Type.Number(),
-      cacheWrite: Type.Number(),
-    }),
-    contextWindow: Type.Number(),
-    maxTokens: Type.Number(),
-    headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-    compat: Type.Optional(Type.Unknown()),
-  }),
-);
-
-const TUIThemeIdSchema = Type.Unsafe<TUIThemeId>(
-  Type.Union(TUI_THEME_IDS.map((id) => Type.Literal(id))),
-);
-
-export const SettingsSchema = Type.Object({
-  provider: Type.String(),
-  model: Type.String(),
-  effort: ThinkingLevelSchema,
-  customProviders: Type.Optional(Type.Array(ModelSchema)),
-  theme: Type.Optional(TUIThemeIdSchema),
-});
-export type Settings = Static<typeof SettingsSchema>;
-
-export const CliOptionsSchema = Type.Object({
-  provider: Type.String(),
-  model: ModelSchema,
-  effort: ThinkingLevelSchema,
-  prompt: Type.Optional(Type.String()),
-  customProviders: Type.Optional(Type.Array(ModelSchema)),
-  theme: TUIThemeIdSchema,
-});
-export type CliOptions = Static<typeof CliOptionsSchema>;
-
-type SavedOAuthAuth = OAuthCredentials & {
-  type: "oauth";
-};
-export type SavedOAuthCreds = Record<string, SavedOAuthAuth>;
-
-export const MessageSchema = Type.Unsafe<Message>({});
-export const SessionSchema = Type.Object({
-  id: Type.String(),
-  cwd: Type.String(),
-  messages: Type.Array(MessageSchema),
-});
-export type Session = Static<typeof SessionSchema>;
-export type Sessions = Session[];
-
-export type TUIToolCall = {
-  id: string;
-  tool: string;
-  args: Record<string, any>;
-  output: string;
-};
-
-export type TUIMessage = {
-  timestamp: string;
-  role: "user" | "assistant";
-  text: string;
-  thinking?: string;
-  toolCalls?: TUIToolCall[];
-};
-
-export type AvailableUpdate = {
-  currentVersion: string;
-  latestVersion: string;
-};
-
-export type TUIState = {
-  options: CliOptions;
-  prompt: string;
-  messages: Message[]; // Context messages
-  tuiMessages: TUIMessage[];
-  contextSize?: number;
-  stickToBottom: boolean;
-  scrollOffset: number;
-  streaming: boolean;
-  abortController?: AbortController;
-  cwd: string;
-  gitBranch?: string;
-  availableUpdate?: AvailableUpdate | undefined;
-  overlay?: boolean | undefined;
-  forceThemeRefresh?: boolean | undefined;
-  sessionId?: string | undefined;
-};
-
-export type AgentContex = {
-  systemPrompt: string;
-  tools: ToolAndRunner[];
-  messages: Message[];
-  options: CliOptions;
-  signal?: AbortSignal | undefined;
-};
-
-export type AgentEvent =
-  | {
-      type: "message_start" | "message_update";
-      partial: AssistantMessage;
-    }
-  | {
-      type: "message_end";
-      message: AssistantMessage;
-    }
-  | {
-      type: "tool_message_start" | "tool_message_update";
-      partial: ToolResultMessage;
-    }
-  | {
-      type: "tool_message_end";
-      message: ToolResultMessage;
-    };
-
-export type AgentToolEvent =
-  | {
-      type: "tool_update";
-      partial: ToolResultMessage;
-    }
-  | {
-      type: "tool_result";
-      message: ToolResultMessage;
-    };
-
-export type ToolRunnerEvent =
-  | { type: "output"; text: string }
-  | {
-      type: "result";
-      text: string;
-      image?: { data: string; mimeType: string };
-    };
-
-export type ToolAndRunner = {
-  tool: Tool;
-  runner: (
-    args: Record<string, any>,
-    signal?: AbortSignal,
-  ) => AsyncGenerator<ToolRunnerEvent>;
-};
-
-export type SelectListItem = {
-  label: string;
-  value: string;
-};
-
-export type SelectState = {
-  value: string;
-  selected: string;
-  label: string;
-  list: SelectListItem[];
-};
-
-export type SelectOptions = {
-  filter: string;
-  list: { label: string; value: string }[];
-  label?: string | undefined;
-  onSelect: (s: SelectState) => void | Promise<void>;
-  onCancel: () => void;
-};

package/src/update.ts

@@ -1,171 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import { join } from "node:path";
-
-import { type Static, Type } from "@earendil-works/pi-ai";
-import { Value } from "typebox/value";
-
-import { DATA_DIR } from "./shared";
-import type { AvailableUpdate } from "./types";
-
-const PACKAGE_NAME = "mini-coder";
-const PACKAGE_MANIFEST_URL = new URL("../package.json", import.meta.url);
-const UPDATE_CHECK_CACHE_PATH = join(DATA_DIR, "update-check.json");
-const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-const UPDATE_CHECK_TIMEOUT_MS = 5_000;
-
-const UpdateCheckCacheSchema = Type.Object({
-  checkedAt: Type.Number(),
-  currentVersion: Type.String(),
-  latestVersion: Type.Optional(Type.String()),
-});
-type UpdateCheckCache = Static<typeof UpdateCheckCacheSchema>;
-
-function parseLatestVersion(output: string): string | undefined {
-  const version = output.trim().split(/\s+/)[0];
-
-  if (!version || !isValidVersion(version)) {
-    return;
-  }
-
-  return version;
-}
-
-function isValidVersion(version: string): boolean {
-  try {
-    Bun.semver.order(version, version);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function isNewerVersion(
-  currentVersion: string,
-  latestVersion: string,
-): boolean {
-  try {
-    return Bun.semver.order(latestVersion, currentVersion) === 1;
-  } catch {
-    return false;
-  }
-}
-
-function isFreshUpdateCheck(cache: UpdateCheckCache, now: number): boolean {
-  return now - cache.checkedAt < UPDATE_CHECK_INTERVAL_MS;
-}
-
-function getAvailableUpdateFromLatest(
-  currentVersion: string,
-  latestVersion: string | undefined,
-): AvailableUpdate | undefined {
-  if (!latestVersion || !isNewerVersion(currentVersion, latestVersion)) {
-    return;
-  }
-
-  return { currentVersion, latestVersion };
-}
-
-async function getCurrentVersion(): Promise<string | undefined> {
-  const manifest = (await Bun.file(PACKAGE_MANIFEST_URL).json()) as {
-    version?: unknown;
-  };
-
-  if (typeof manifest.version !== "string") {
-    return;
-  }
-
-  return manifest.version;
-}
-
-async function getLatestVersion(): Promise<string | undefined> {
-  try {
-    const proc = Bun.spawn(["bun", "pm", "view", PACKAGE_NAME, "version"], {
-      stdout: "pipe",
-      stderr: "ignore",
-      timeout: UPDATE_CHECK_TIMEOUT_MS,
-    });
-    const [stdout, exitCode] = await Promise.all([
-      proc.stdout.text(),
-      proc.exited,
-    ]);
-
-    if (exitCode !== 0) {
-      return;
-    }
-
-    return parseLatestVersion(stdout);
-  } catch {
-    return;
-  }
-}
-
-async function readUpdateCheckCache(): Promise<UpdateCheckCache | undefined> {
-  try {
-    const file = Bun.file(UPDATE_CHECK_CACHE_PATH);
-
-    if (!(await file.exists())) {
-      return;
-    }
-
-    const value = (await file.json()) as unknown;
-
-    if (!Value.Check(UpdateCheckCacheSchema, value)) {
-      return;
-    }
-
-    return value;
-  } catch {
-    return;
-  }
-}
-
-async function writeUpdateCheckCache(cache: UpdateCheckCache): Promise<void> {
-  try {
-    await mkdir(DATA_DIR, { recursive: true });
-    await Bun.write(UPDATE_CHECK_CACHE_PATH, JSON.stringify(cache, null, 2));
-  } catch {
-    // Update checks are best-effort and must never interrupt startup.
-  }
-}
-
-export async function getAvailableUpdate(): Promise<
-  AvailableUpdate | undefined
-> {
-  const currentVersion = await getCurrentVersion().catch(() => undefined);
-
-  if (!currentVersion) {
-    return;
-  }
-
-  const now = Date.now();
-  const cache = await readUpdateCheckCache();
-
-  if (cache && isFreshUpdateCheck(cache, now)) {
-    return getAvailableUpdateFromLatest(currentVersion, cache.latestVersion);
-  }
-
-  const latestVersion = await getLatestVersion();
-  await writeUpdateCheckCache({
-    checkedAt: now,
-    currentVersion,
-    latestVersion,
-  });
-
-  return getAvailableUpdateFromLatest(currentVersion, latestVersion);
-}
-
-export async function updateMiniCoder(): Promise<void> {
-  console.log("Updating mini-coder...");
-
-  const proc = Bun.spawn(["bun", "add", "-g", "mini-coder@latest"], {
-    stdout: "inherit",
-    stderr: "inherit",
-  });
-  const exitCode = await proc.exited;
-
-  if (exitCode !== 0) {
-    throw new Error(`Update failed with exit code ${exitCode}`);
-  }
-
-  console.log("mini-coder updated.");
-}