@golba98/codexa 1.0.2 → 1.0.4

package/src/core/terminal/terminalTitle.test.ts

@@ -1,328 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  acquireTerminalTitleGuard,
-  buildTerminalTitleSequence,
-  computeTerminalTitle,
-  deriveTerminalTitle,
-  formatTerminalTitleLabel,
-  getIntendedTerminalTitle,
-  normalizeTerminalTitle,
-  reassertTerminalTitle,
-  reassertIntendedTerminalTitle,
-  sanitizeTerminalTitle,
-  setIntendedTerminalTitle,
-  setTerminalTitle,
-  startTerminalTitleStartupGuard,
-  beginColdStartSequence,
-  createTerminalTitleSequenceStripper,
-  stripTerminalTitleSequences,
-  stripTerminalTitleSequencesFromChunk,
-  traceTerminalTitleSequences,
-  writeCodexaTerminalTitle,
-  writeGuardedTerminalOutput,
-  __resetTerminalTitleCache,
-} from "./terminalTitle.js";
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-test("buildTerminalTitleSequence emits OSC 0 and OSC 2 with sanitized title text", () => {
-  const sequence = buildTerminalTitleSequence("Codexa\u0007!");
-  assert.equal(sequence, "\x1b]0;Codexa !\x07\x1b]2;Codexa !\x07");
-  assert.equal(sanitizeTerminalTitle("  Codexa  "), "Codexa");
-});
-
-test("title normalization never exposes raw Windows paths", () => {
-  assert.equal(normalizeTerminalTitle("C:\\WINDOWS\\system"), "Codexa");
-  assert.equal(normalizeTerminalTitle("c:/Users/example"), "Codexa");
-  assert.equal(normalizeTerminalTitle("\\\\server\\share"), "Codexa");
-  assert.equal(buildTerminalTitleSequence("C:\\WINDOWS\\system"), buildTerminalTitleSequence("Codexa"));
-});
-
-test("stripTerminalTitleSequences removes OSC 0 title sequences with BEL terminator", () => {
-  assert.equal(
-    stripTerminalTitleSequences("hello\x1b]0;C:\\WINDOWS\\system\x07world"),
-    "helloworld",
-  );
-});
-
-test("stripTerminalTitleSequences removes OSC 2 title sequences with BEL terminator", () => {
-  assert.equal(
-    stripTerminalTitleSequences("hello\x1b]2;Codex\x07world"),
-    "helloworld",
-  );
-});
-
-test("stripTerminalTitleSequences preserves normal ANSI SGR colour sequences", () => {
-  const input = "\x1b[31mred\x1b[0m";
-  assert.equal(stripTerminalTitleSequences(input), input);
-});
-
-test("stripTerminalTitleSequences removes title OSC from mixed output while preserving SGR", () => {
-  assert.equal(
-    stripTerminalTitleSequences("start\x1b]0;C:\\WINDOWS\\system\x07middle\x1b[32mok\x1b[0mend"),
-    "startmiddle\x1b[32mok\x1b[0mend",
-  );
-});
-
-test("stripTerminalTitleSequences removes OSC title sequences with ST terminator", () => {
-  assert.equal(
-    stripTerminalTitleSequences("hello\x1b]0;C:\\WINDOWS\\system\x1b\\world"),
-    "helloworld",
-  );
-});
-
-test("stripTerminalTitleSequencesFromChunk handles Buffer input", () => {
-  assert.equal(
-    stripTerminalTitleSequencesFromChunk(Buffer.from("hello\x1b]0;C:\\WINDOWS\\system\x07world", "utf8")),
-    "helloworld",
-  );
-});
-
-test("createTerminalTitleSequenceStripper removes title sequences split across chunks", () => {
-  const stripper = createTerminalTitleSequenceStripper({
-    source: "test",
-    stream: "stdout",
-    origin: "child",
-  });
-
-  assert.equal(stripper.process("hello\x1b]0;C:\\WINDOWS"), "hello");
-  assert.equal(stripper.process("\\system\x07world"), "world");
-  assert.equal(stripper.flush(), "");
-});
-
-test("formatTerminalTitleLabel follows the workspace leaf and app-name rules", () => {
-  assert.equal(
-    formatTerminalTitleLabel("C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal", "dir"),
-    "13-Custom-CLI-Normal",
-  );
-  assert.equal(
-    formatTerminalTitleLabel("C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal", "name"),
-    "Codexa",
-  );
-  assert.equal(
-    formatTerminalTitleLabel("C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal", "simple"),
-    "Codexa",
-  );
-});
-
-test("deriveTerminalTitle follows terminal title mode on startup", () => {
-  const workspaceRoot = "C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal";
-
-  assert.equal(deriveTerminalTitle(workspaceRoot, "dir"), "13-Custom-CLI-Normal");
-  assert.equal(deriveTerminalTitle(workspaceRoot, "name"), "Codexa");
-  assert.equal(deriveTerminalTitle(workspaceRoot, "simple"), "Codexa");
-});
-
-test("computeTerminalTitle follows the requested mapping", () => {
-  const workspaceName = "13-Custom-CLI-Normal";
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "dir", workspaceName }), "13-Custom-CLI-Normal");
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "name" }), "Codexa");
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "simple" }), "Codexa");
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "dir", appName: "Other" }), "Other");
-});
-
-test("reassertTerminalTitle writes both title sequences without mutating process title", () => {
-  const writes: string[] = [];
-  const originalTitle = process.title;
-
-  try {
-    reassertTerminalTitle("Codexa", (chunk) => {
-      writes.push(chunk);
-    });
-
-    assert.equal(process.title, originalTitle);
-    assert.deepEqual(writes, [buildTerminalTitleSequence("Codexa")]);
-  } finally {
-    process.title = originalTitle;
-  }
-});
-
-test("acquireTerminalTitleGuard asserts immediately, ticks while active, and reasserts on release", async () => {
-  let calls = 0;
-  const release = acquireTerminalTitleGuard(10, () => {
-    calls += 1;
-  });
-
-  await sleep(35);
-  release();
-
-  const callsAfterRelease = calls;
-  await sleep(20);
-
-  assert.ok(callsAfterRelease >= 3, `expected at least 3 title assertions, got ${callsAfterRelease}`);
-  assert.equal(calls, callsAfterRelease);
-});
-
-test("acquireTerminalTitleGuard release is idempotent", () => {
-  let calls = 0;
-  const release = acquireTerminalTitleGuard(50, () => {
-    calls += 1;
-  });
-
-  release();
-  const callsAfterFirstRelease = calls;
-  release();
-
-  assert.equal(callsAfterFirstRelease, 2);
-  assert.equal(calls, callsAfterFirstRelease);
-});
-
-test("setTerminalTitle deduplicates identical title writes", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setTerminalTitle("Codexa", { write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Codexa", { write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Other", { write: (chunk) => writes.push(chunk) });
-
-  assert.equal(writes.length, 2);
-  assert.equal(writes[0], buildTerminalTitleSequence("Codexa"));
-  assert.equal(writes[1], buildTerminalTitleSequence("Other"));
-});
-
-test("writeCodexaTerminalTitle delegates to central title writer with force support", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  writeCodexaTerminalTitle("Codexa", { force: true, reason: "test", write: (chunk) => writes.push(chunk) });
-
-  assert.deepEqual(writes, [buildTerminalTitleSequence("Codexa")]);
-});
-
-test("intended terminal title fallback is safe and later replaced by workspace title", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setIntendedTerminalTitle("C:\\WINDOWS\\system", {
-    force: true,
-    reason: "test-fallback",
-    write: (chunk) => writes.push(chunk),
-  });
-  assert.equal(getIntendedTerminalTitle(), "Codexa");
-  assert.equal(writes.at(-1), buildTerminalTitleSequence("Codexa"));
-
-  setIntendedTerminalTitle("13-Custom-CLI-Normal", {
-    force: true,
-    reason: "test-workspace",
-    write: (chunk) => writes.push(chunk),
-  });
-  assert.equal(getIntendedTerminalTitle(), "13-Custom-CLI-Normal");
-  assert.equal(writes.at(-1), buildTerminalTitleSequence("13-Custom-CLI-Normal"));
-});
-
-test("busy idle reassertion keeps the same intended title", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setIntendedTerminalTitle("13-Custom-CLI-Normal", {
-    force: true,
-    write: (chunk) => writes.push(chunk),
-  });
-  reassertIntendedTerminalTitle({ reason: "busy-start", write: (chunk) => writes.push(chunk) });
-  reassertIntendedTerminalTitle({ reason: "busy-end", write: (chunk) => writes.push(chunk) });
-
-  assert.equal(getIntendedTerminalTitle(), "13-Custom-CLI-Normal");
-  assert.deepEqual(writes, [
-    buildTerminalTitleSequence("13-Custom-CLI-Normal"),
-    buildTerminalTitleSequence("13-Custom-CLI-Normal"),
-    buildTerminalTitleSequence("13-Custom-CLI-Normal"),
-  ]);
-});
-
-test("writeGuardedTerminalOutput strips external title OSC and preserves SGR", () => {
-  const writes: string[] = [];
-  const result = writeGuardedTerminalOutput(
-    (chunk) => {
-      writes.push(chunk);
-      return true;
-    },
-    "start\x1b]0;C:\\WINDOWS\\system\x07middle\x1b[32mok\x1b[0mend",
-    { source: "test", stream: "stdout", origin: "child" },
-  );
-
-  assert.equal(result, true);
-  assert.deepEqual(writes, ["startmiddle\x1b[32mok\x1b[0mend"]);
-});
-
-test("setTerminalTitle force option bypasses dedup", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setTerminalTitle("Codexa", { write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Codexa", { force: true, write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Codexa", { force: true, write: (chunk) => writes.push(chunk) });
-
-  assert.equal(writes.length, 3);
-  writes.forEach((w) => assert.equal(w, buildTerminalTitleSequence("Codexa")));
-});
-
-test("beginColdStartSequence writes immediately then retries", async () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  const cancel = beginColdStartSequence("Codexa", { write: (chunk) => writes.push(chunk) });
-  
-  assert.equal(writes.length, 1, "should write immediately");
-  
-  await sleep(60);
-  assert.equal(writes.length, 2, "should have retried at 50ms");
-  
-  cancel();
-  await sleep(300);
-  assert.equal(writes.length, 2, "should not have retried further after cancel");
-});
-
-test("startup guard reasserts intended title until cancelled", async () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setIntendedTerminalTitle("13-Custom-CLI-Normal", {
-    force: true,
-    write: (chunk) => writes.push(chunk),
-  });
-  const cancel = startTerminalTitleStartupGuard({
-    intervalMs: 10,
-    durationMs: 100,
-    write: (chunk) => writes.push(chunk),
-  });
-
-  await sleep(25);
-  cancel();
-  const writesAfterCancel = writes.length;
-  await sleep(25);
-
-  assert.ok(writesAfterCancel >= 3, `expected guard to reassert title, got ${writesAfterCancel} writes`);
-  assert.equal(writes.length, writesAfterCancel);
-  assert.ok(writes.every((chunk) => chunk === buildTerminalTitleSequence("13-Custom-CLI-Normal")));
-});
-
-test("stripTerminalTitleSequences handles very long unterminated OSC without hanging", () => {
-  const long = "\x1b]0;" + "A".repeat(100_000);
-  const start = Date.now();
-  const result = stripTerminalTitleSequences(long);
-  assert.ok(Date.now() - start < 100, "must complete in under 100 ms");
-  assert.ok(result.includes("\x1b]0;"), "unterminated sequence passes through unchanged");
-});
-
-test("stripTerminalTitleSequences strips OSC sequence with empty title", () => {
-  assert.equal(stripTerminalTitleSequences("pre\x1b]0;\x07post"), "prepost");
-  assert.equal(stripTerminalTitleSequences("pre\x1b]2;\x1b\\post"), "prepost");
-});
-
-test("createTerminalTitleSequenceStripper handles OSC split across chunks with ST terminator", () => {
-  const stripper = createTerminalTitleSequenceStripper({ source: "test", stream: "stdout", origin: "child" });
-  assert.equal(stripper.process("hello\x1b]2;MyTitle"), "hello");
-  assert.equal(stripper.process("\x1b\\world"), "world");
-  assert.equal(stripper.flush(), "");
-});
-
-test("traceTerminalTitleSequences does not hang on crafted adversarial input", () => {
-  const crafted = "\x1b]0;" + "X".repeat(10_000) + "\x1b]2;" + "Y".repeat(10_000);
-  const start = Date.now();
-  const found = traceTerminalTitleSequences(crafted, { source: "test", stream: "stdout", origin: "child" });
-  assert.ok(Date.now() - start < 100, "must complete in under 100 ms");
-  assert.equal(found, false, "no complete sequences in adversarial input");
-});

package/src/core/updateCheck.test.ts

@@ -1,194 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  CODEXA_NPM_REGISTRY_URL,
-  CODEXA_UPDATE_COMMAND,
-  checkForUpdates,
-  compareSemver,
-  formatUpdateInstructions,
-  isNewerVersion,
-  type NpmRegistryMetadata,
-} from "./updateCheck.js";
-import { isCacheValid, type UpdateCheckCache } from "../config/updateCheckCache.js";
-
-function metadata(version: string): NpmRegistryMetadata {
-  return { "dist-tags": { latest: version } };
-}
-
-test("checkForUpdates returns update-available when installed version is lower than npm latest", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.1",
-      fetchNpmMetadataFn: async (url) => {
-        assert.equal(url, CODEXA_NPM_REGISTRY_URL);
-        return metadata("1.0.2");
-      },
-    },
-  );
-
-  assert.equal(result.status, "update-available");
-  assert.equal(result.currentVersion, "1.0.1");
-  assert.equal(result.latestVersion, "1.0.2");
-});
-
-test("checkForUpdates returns up-to-date when installed version equals npm latest", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.2",
-      fetchNpmMetadataFn: async () => metadata("1.0.2"),
-    },
-  );
-
-  assert.equal(result.status, "up-to-date");
-});
-
-test("checkForUpdates does not show update available when installed version is higher than npm latest", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.3",
-      fetchNpmMetadataFn: async () => metadata("1.0.2"),
-    },
-  );
-
-  assert.equal(result.status, "up-to-date");
-});
-
-test("checkForUpdates returns error status instead of throwing when npm request fails", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.1",
-      fetchNpmMetadataFn: async () => {
-        throw new Error("network unavailable");
-      },
-    },
-  );
-
-  assert.equal(result.status, "error");
-  assert.match(result.errorMessage ?? "", /network unavailable/);
-});
-
-test("checkForUpdates returns error when npm latest is missing", async () => {
-  const result = await checkForUpdates(
-    {},
-    {
-      currentVersion: "1.0.1",
-      fetchNpmMetadataFn: async () => ({ "dist-tags": {} }),
-    },
-  );
-
-  assert.equal(result.status, "error");
-  assert.match(result.errorMessage ?? "", /dist-tags\.latest/);
-});
-
-test("checkForUpdates returns unknown immediately when enabled=false", async () => {
-  let called = false;
-  const result = await checkForUpdates(
-    { enabled: false },
-    {
-      currentVersion: "1.0.1",
-      fetchNpmMetadataFn: async () => {
-        called = true;
-        return metadata("1.0.2");
-      },
-    },
-  );
-
-  assert.equal(result.status, "unknown");
-  assert.equal(called, false, "should not call npm when disabled");
-});
-
-test("semver comparison handles numeric and prerelease ordering", () => {
-  assert.equal(isNewerVersion("1.0.10", "1.0.2"), true);
-  assert.equal(isNewerVersion("1.0.2", "1.0.10"), false);
-  assert.equal(compareSemver("1.0.2", "1.0.2"), 0);
-  assert.equal(isNewerVersion("1.0.2", "1.0.2-beta.1"), true);
-  assert.equal(isNewerVersion("1.0.2-beta.1", "1.0.2"), false);
-});
-
-test("isCacheValid returns true when cache is within the interval", () => {
-  const cache: UpdateCheckCache = {
-    lastChecked: Date.now() - 1000 * 60 * 30,
-    currentVersion: "1.0.1",
-    latestVersion: "1.0.1",
-    updateAvailable: false,
-  };
-  assert.equal(isCacheValid(cache, 6), true);
-});
-
-test("isCacheValid returns false when cache is older than the interval", () => {
-  const cache: UpdateCheckCache = {
-    lastChecked: Date.now() - 1000 * 60 * 60 * 7,
-    currentVersion: "1.0.1",
-    latestVersion: "1.0.1",
-    updateAvailable: false,
-  };
-  assert.equal(isCacheValid(cache, 6), false);
-});
-
-test("formatUpdateInstructions formats update-available npm status", () => {
-  const result = formatUpdateInstructions({
-    status: "update-available",
-    currentVersion: "1.0.1",
-    latestVersion: "1.0.2",
-    checkedAt: Date.now(),
-  });
-
-  assert.match(result, /Current installed version: 1\.0\.1/);
-  assert.match(result, /npm latest version:\s+1\.0\.2/);
-  assert.match(result, /Update available: Codexa 1\.0\.2 is available\. You are using 1\.0\.1\./);
-  assert.match(result, new RegExp(`Run: ${CODEXA_UPDATE_COMMAND.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
-});
-
-test("formatUpdateInstructions formats up-to-date npm status", () => {
-  const result = formatUpdateInstructions({
-    status: "up-to-date",
-    currentVersion: "1.0.2",
-    latestVersion: "1.0.2",
-    checkedAt: Date.now(),
-  });
-
-  assert.match(result, /Already up to date/);
-  assert.match(result, /npm install -g @golba98\/codexa@latest/);
-});
-
-test("formatUpdateInstructions formats manual npm errors", () => {
-  const result = formatUpdateInstructions({
-    status: "error",
-    currentVersion: "1.0.1",
-    latestVersion: null,
-    errorMessage: "Connection timed out",
-    checkedAt: Date.now(),
-  });
-
-  assert.match(result, /Error checking npm update status: Connection timed out/);
-});
-
-test("/update check path bypasses cache by performing a fresh npm check", async () => {
-  const validCache: UpdateCheckCache = {
-    lastChecked: Date.now(),
-    currentVersion: "1.0.1",
-    latestVersion: "1.0.1",
-    updateAvailable: false,
-  };
-  assert.equal(isCacheValid(validCache, 6), true);
-
-  let calls = 0;
-  const result = await checkForUpdates(
-    { enabled: true },
-    {
-      currentVersion: validCache.currentVersion,
-      fetchNpmMetadataFn: async () => {
-        calls += 1;
-        return metadata("1.0.2");
-      },
-    },
-  );
-
-  assert.equal(calls, 1);
-  assert.equal(result.status, "update-available");
-  assert.equal(result.latestVersion, "1.0.2");
-});

package/src/core/updateCheck.ts

@@ -1,172 +0,0 @@
-import { APP_VERSION } from "../config/settings.js";
-
-export type UpdateStatus = "up-to-date" | "update-available" | "unknown" | "error";
-
-export interface UpdateCheckResult {
-  status: UpdateStatus;
-  currentVersion: string;
-  latestVersion: string | null;
-  errorMessage?: string;
-  checkedAt: number;
-}
-
-export interface NpmRegistryMetadata {
-  "dist-tags"?: {
-    latest?: unknown;
-  };
-}
-
-export interface UpdateCheckOverrides {
-  fetchNpmMetadataFn?: (url: string, init: RequestInit) => Promise<NpmRegistryMetadata>;
-  currentVersion?: string;
-  now?: () => number;
-}
-
-export const CODEXA_NPM_PACKAGE = "@golba98/codexa";
-export const CODEXA_NPM_REGISTRY_URL = "https://registry.npmjs.org/@golba98%2Fcodexa";
-export const CODEXA_UPDATE_COMMAND = "npm install -g @golba98/codexa@latest";
-
-const REMOTE_TIMEOUT_MS = 3000;
-
-interface ParsedSemver {
-  major: number;
-  minor: number;
-  patch: number;
-  prerelease: string[];
-}
-
-function parseSemver(version: string): ParsedSemver | null {
-  const match = version.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
-  if (!match) return null;
-
-  return {
-    major: Number(match[1]),
-    minor: Number(match[2]),
-    patch: Number(match[3]),
-    prerelease: match[4]?.split(".") ?? [],
-  };
-}
-
-function comparePrerelease(left: string[], right: string[]): number {
-  if (left.length === 0 && right.length === 0) return 0;
-  if (left.length === 0) return 1;
-  if (right.length === 0) return -1;
-
-  const max = Math.max(left.length, right.length);
-  for (let index = 0; index < max; index += 1) {
-    const a = left[index];
-    const b = right[index];
-    if (a === undefined) return -1;
-    if (b === undefined) return 1;
-    if (a === b) continue;
-
-    const aNumeric = /^\d+$/.test(a);
-    const bNumeric = /^\d+$/.test(b);
-    if (aNumeric && bNumeric) return Number(a) > Number(b) ? 1 : -1;
-    if (aNumeric) return -1;
-    if (bNumeric) return 1;
-    return a > b ? 1 : -1;
-  }
-
-  return 0;
-}
-
-export function compareSemver(leftVersion: string, rightVersion: string): number {
-  const left = parseSemver(leftVersion);
-  const right = parseSemver(rightVersion);
-  if (!left || !right) {
-    throw new Error(`Invalid semver version: ${!left ? leftVersion : rightVersion}`);
-  }
-
-  for (const key of ["major", "minor", "patch"] as const) {
-    if (left[key] !== right[key]) return left[key] > right[key] ? 1 : -1;
-  }
-
-  return comparePrerelease(left.prerelease, right.prerelease);
-}
-
-export function isNewerVersion(latestVersion: string, currentVersion: string): boolean {
-  return compareSemver(latestVersion, currentVersion) > 0;
-}
-
-async function fetchNpmMetadata(url: string, init: RequestInit): Promise<NpmRegistryMetadata> {
-  const res = await fetch(url, init);
-  if (!res.ok) {
-    throw new Error(`npm registry responded with HTTP ${res.status}`);
-  }
-  return await res.json() as NpmRegistryMetadata;
-}
-
-export async function getNpmLatestVersion(
-  fetchMetadata: (url: string, init: RequestInit) => Promise<NpmRegistryMetadata> = fetchNpmMetadata,
-): Promise<string> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), REMOTE_TIMEOUT_MS);
-  try {
-    const data = await fetchMetadata(CODEXA_NPM_REGISTRY_URL, {
-      signal: controller.signal,
-      headers: { "User-Agent": "Codexa-Update-Checker/1.0" },
-    });
-    const latest = data?.["dist-tags"]?.latest;
-    if (typeof latest !== "string" || !latest.trim()) {
-      throw new Error("npm registry response did not include dist-tags.latest");
-    }
-    return latest.trim();
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export async function checkForUpdates(
-  opts?: { enabled?: boolean },
-  overrides?: UpdateCheckOverrides,
-): Promise<UpdateCheckResult> {
-  const now = overrides?.now ?? Date.now;
-  const currentVersion = overrides?.currentVersion ?? APP_VERSION;
-
-  if (opts?.enabled === false) {
-    return { status: "unknown", currentVersion, latestVersion: null, checkedAt: now() };
-  }
-
-  try {
-    const latestVersion = await getNpmLatestVersion(overrides?.fetchNpmMetadataFn);
-    return {
-      status: isNewerVersion(latestVersion, currentVersion) ? "update-available" : "up-to-date",
-      currentVersion,
-      latestVersion,
-      checkedAt: now(),
-    };
-  } catch (err) {
-    return {
-      status: "error",
-      currentVersion,
-      latestVersion: null,
-      errorMessage: err instanceof Error ? err.message : String(err),
-      checkedAt: now(),
-    };
-  }
-}
-
-export function formatUpdateInstructions(result: UpdateCheckResult | null): string {
-  const current = result?.currentVersion ?? APP_VERSION;
-  const latest = result?.latestVersion ?? "unknown";
-
-  let statusLine: string;
-  if (result?.status === "update-available" && result.latestVersion) {
-    statusLine = `Update available: Codexa ${result.latestVersion} is available. You are using ${current}.`;
-  } else if (result?.status === "up-to-date") {
-    statusLine = "Already up to date.";
-  } else if (result?.status === "error") {
-    statusLine = `Error checking npm update status: ${result.errorMessage || "unknown error"}`;
-  } else {
-    statusLine = "Status unknown - could not read npm latest version.";
-  }
-
-  return [
-    `Current installed version: ${current}`,
-    `npm latest version:       ${latest}`,
-    `Status:                   ${statusLine}`,
-    "",
-    `Run: ${CODEXA_UPDATE_COMMAND}`,
-  ].join("\n");
-}