mini-coder 0.7.2 → 0.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-coder",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "type": "module",
   "packageManager": "bun@1.3.13",
   "bin": {

package/src/index.ts

@@ -4,10 +4,18 @@ import { getBranchLabel } from "./git.ts";
 import { streamHeadless } from "./headless.ts";
 import { initTUI } from "./tui.ts";
 import type { TUIState } from "./types.ts";
+import { updateMiniCoder } from "./update.ts";
 
 export async function main(): Promise<void> {
+  const argv = process.argv.slice(2);
+
+  if (argv.includes("--update")) {
+    await updateMiniCoder();
+    return;
+  }
+
   const cwd = basename(process.cwd());
-  const options = await handleArgv(process.argv.slice(2));
+  const options = await handleArgv(argv);
 
   function leave(msg?: string) {
     if (msg) console.log(msg);

package/src/tui-conversation.ts

@@ -14,6 +14,17 @@ export function emptyState(state: TUIState): Node {
     state.options.theme === "ansi16"
       ? randColor
       : textColorForBackground(theme.bblack, state.options.theme);
+  const updateNotice = state.availableUpdate
+    ? [
+        HStack({ gap: 1 }, [
+          TextPill("update", shortcutFgColor, theme.bblack, 13),
+          Text(
+            `mini-coder ${state.availableUpdate.latestVersion} is available. Run mc --update.`,
+            { fgColor: theme.bblack },
+          ),
+        ]),
+      ]
+    : [];
   return HStack({ flex: 1, alignItems: "center" }, [
     VStack({ flex: 1, alignItems: "center", gap: 1 }, [
       HStack({ gap: 1 }, [
@@ -45,6 +56,7 @@ export function emptyState(state: TUIState): Node {
           TextPill("ctrl+c|d|q", shortcutFgColor, theme.bblack, 13),
           Text("Quit.", { fgColor: theme.bblack }),
         ]),
+        ...updateNotice,
       ]),
     ]),
   ]);

package/src/tui.ts

@@ -30,6 +30,11 @@ 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.
@@ -46,6 +51,7 @@ function clearOrAbort(state: TUIState) {
 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.

package/src/types.ts

@@ -98,6 +98,11 @@ export type TUIMessage = {
   toolCalls?: TUIToolCall[];
 };
 
+export type AvailableUpdate = {
+  currentVersion: string;
+  latestVersion: string;
+};
+
 export type TUIState = {
   options: CliOptions;
   prompt: string;
@@ -110,6 +115,7 @@ export type TUIState = {
   abortController?: AbortController;
   cwd: string;
   gitBranch?: string;
+  availableUpdate?: AvailableUpdate | undefined;
   overlay?: boolean | undefined;
   forceThemeRefresh?: boolean | undefined;
   sessionId?: string | undefined;

package/src/update.ts

@@ -0,0 +1,171 @@
+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.");
+}