@golba98/codexa 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@golba98/codexa",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Terminal UI for Codexa — TypeScript + Bun + Ink",
   "type": "module",
   "bin": {
@@ -13,7 +13,8 @@
     "test": "bun test",
     "audit:codexa-gap": "node scripts/audit-codexa-capabilities.mjs",
     "smoke:terminal-bench": "node scripts/smoke-terminal-bench.mjs",
-    "build": "bun run typecheck",
+    "gen-build-info": "node scripts/gen-build-info.mjs",
+    "build": "bun run gen-build-info && bun run typecheck",
     "prepublishOnly": "npm run typecheck && npm test"
   },
   "dependencies": {

package/scripts/gen-build-info.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// Writes src/config/buildInfo.ts with package/build metadata.
+// Used by `bun run build` so the embed is up-to-date at install time.
+
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const outFile = resolve(__dirname, "..", "src", "config", "buildInfo.ts");
+const packageFile = resolve(__dirname, "..", "package.json");
+
+let commit = "unknown";
+try {
+  commit = execSync("git rev-parse HEAD", { encoding: "utf-8", timeout: 5000 }).trim();
+} catch {
+  // Not a git repo or git unavailable — keep default.
+}
+
+let version = "0.0.0";
+try {
+  const pkg = JSON.parse(readFileSync(packageFile, "utf-8"));
+  if (typeof pkg.version === "string" && pkg.version.trim()) {
+    version = pkg.version.trim();
+  }
+} catch {
+  // Keep default.
+}
+
+const content = `// Generated by scripts/gen-build-info.mjs — do not edit manually.\nexport const BUILD_COMMIT = ${JSON.stringify(commit)} as const;\nexport const BUILD_VERSION = ${JSON.stringify(version)} as const;\n`;
+writeFileSync(outFile, content, "utf-8");
+console.log(`[gen-build-info] BUILD_COMMIT = ${commit.slice(0, 8)} BUILD_VERSION = ${version}`);

package/src/app.tsx

@@ -228,9 +228,17 @@ import {
 } from "./ui/themeFlow.js";
 import { isBusy as isUiBusy } from "./session/types.js";
 import { AppShell } from "./ui/AppShell.js";
+import { checkForUpdates, formatUpdateInstructions, type UpdateCheckResult } from "./core/updateCheck.js";
+import {
+  isCacheValid,
+  loadUpdateCheckCache,
+  saveUpdateCheckCache,
+} from "./config/updateCheckCache.js";
+import { DEFAULT_UPDATE_CHECK_SETTINGS } from "./config/persistence.js";
 
 // ─── Module Constants & Helpers ────────────────────────────────────────────────
 
+
 let nextEventId = 0;
 let nextTurnId = 0;
 // 50ms keeps assistant text live while avoiding frame-wide terminal repaint
@@ -397,6 +405,7 @@ export function App({ launchArgs }: AppProps) {
   const [verboseMode, setVerboseMode] = useState(false);
   const [planFlow, setPlanFlow] = useState<PlanFlowState>(createInitialPlanFlowState);
   const [initialRevisionText, setInitialRevisionText] = useState("");
+  const [updateCheckResult, setUpdateCheckResult] = useState<UpdateCheckResult | null>(null);
   // Mouse reporting defaults to the persisted terminalMouseMode setting.
   // "wheel" (default) enables SGR mouse reporting so the timeline can receive
   // wheel events; native drag-select then requires Shift in Windows Terminal.
@@ -1054,6 +1063,7 @@ export function App({ launchArgs }: AppProps) {
         preference: authPreference,
       },
       header: headerConfig,
+      updateCheck: initialSettings.current.updateCheck,
     });
   }, [authPreference, customTheme, showBusyLoader, terminalMouseMode, terminalTitleMode, themeSelection.committedTheme, workspaceDisplayMode]);
 
@@ -1350,6 +1360,46 @@ export function App({ launchArgs }: AppProps) {
     appendSystemEvent("Launch mode", devLaunchNotice);
   }, [appendSystemEvent, launchContext]);
 
+  // Non-blocking background update check — runs once at startup.
+  useEffect(() => {
+    const ucSettings = initialSettings.current.updateCheck ?? DEFAULT_UPDATE_CHECK_SETTINGS;
+    if (!ucSettings.enabled) return;
+
+    const timer = setTimeout(() => {
+      void (async () => {
+        try {
+          const cache = loadUpdateCheckCache();
+          if (cache && isCacheValid(cache, ucSettings.intervalHours)) {
+            if (cache.updateAvailable) {
+              setUpdateCheckResult({
+                status: "update-available",
+                currentVersion: cache.currentVersion,
+                latestVersion: cache.latestVersion,
+                checkedAt: cache.lastChecked,
+              });
+            }
+            return;
+          }
+          const result = await checkForUpdates({ enabled: true });
+          if (result.status !== "error") {
+            setUpdateCheckResult(result);
+            saveUpdateCheckCache({
+              lastChecked: result.checkedAt,
+              currentVersion: result.currentVersion,
+              latestVersion: result.latestVersion,
+              updateAvailable: result.status === "update-available",
+            });
+          }
+        } catch {
+          // Never crash the TUI on a failed update check.
+        }
+      })();
+    }, 2000);
+
+    return () => clearTimeout(timer);
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   // Track clear epoch to suppress stale command result events
   useEffect(() => {
     clearEpochRef.current = sessionState.clearEpoch;
@@ -3999,6 +4049,30 @@ export function App({ launchArgs }: AppProps) {
             appendSystemEvent("Command", commandResult.message);
           }
           return;
+        case "update": {
+          const arg = commandResult.value ?? "status";
+          void (async () => {
+            let freshResult = updateCheckResult;
+            if (arg === "check" || freshResult === null) {
+              try {
+                freshResult = await checkForUpdates({ enabled: true });
+                setUpdateCheckResult(freshResult);
+                if (freshResult.status !== "error") {
+                  saveUpdateCheckCache({
+                    lastChecked: freshResult.checkedAt,
+                    currentVersion: freshResult.currentVersion,
+                    latestVersion: freshResult.latestVersion,
+                    updateAvailable: freshResult.status === "update-available",
+                  });
+                }
+              } catch {
+                freshResult = null;
+              }
+            }
+            appendSystemEvent("Update", formatUpdateInstructions(freshResult));
+          })();
+          return;
+        }
         case "help":
         case "unknown":
           if (commandResult.message) {
@@ -4154,6 +4228,32 @@ export function App({ launchArgs }: AppProps) {
   const composerReasoningLevel = activeProviderRoute.providerId === "anthropic"
     ? ""
     : activeProviderRoute.reasoning ?? reasoningLevel;
+  const headerRuntimeSummary = useMemo(() => {
+    const contextLabel = activeContextMetadata?.contextLength != null
+      ? `${formatContextCompact(estimateTokens(conversationChars))} / ${activeContextMetadata.confidence === "estimated" ? "~" : ""}${formatContextCompact(activeContextMetadata.contextLength)}`
+      : "Unknown";
+
+    return {
+      ...runtimeSummary,
+      providerLabel: activeRouteProvider?.displayName ?? runtimeSummary.providerLabel,
+      modelLabel: modelDisplayName,
+      contextLabel,
+    };
+  }, [
+    activeContextMetadata?.confidence,
+    activeContextMetadata?.contextLength,
+    activeRouteProvider?.displayName,
+    conversationChars,
+    modelDisplayName,
+    runtimeSummary,
+  ]);
+  const effectiveHeaderConfig = useMemo<HeaderConfig>(() => ({
+    ...headerConfig,
+    showProvider: true,
+    showModel: false,
+    showReasoning: false,
+    showContext: false,
+  }), [headerConfig]);
 
   // Memoize the composer element so AppShell's memo check (prev.composer ===
   // next.composer) passes during streaming. Without this, a new JSX element is
@@ -4285,7 +4385,7 @@ export function App({ launchArgs }: AppProps) {
         authState={authStatus.state}
         workspaceLabel={workspaceLabel}
         workspaceRoot={workspaceRoot}
-        runtimeSummary={runtimeSummary}
+        runtimeSummary={headerRuntimeSummary}
         staticEvents={staticEvents}
         activeEvents={activeEvents}
         uiState={uiState}
@@ -4294,7 +4394,8 @@ export function App({ launchArgs }: AppProps) {
         onMouseActivity={resetMouseIdle}
         selectionProfile={selectionProfile}
         clearCount={sessionState.clearCount}
-        headerConfig={headerConfig}
+        headerConfig={effectiveHeaderConfig}
+        updateCheckResult={updateCheckResult}
         panel={
           <>
             {screen === "backend-picker" && (

package/src/commands/handler.test.ts

@@ -617,6 +617,7 @@ test("every command documented in help is recognized by the parser", () => {
     ["workspace relaunch .", "workspace_relaunch"],
     ["providers", "open_provider_picker"],
     ["route", "route_status"],
+    ["update check", "update"],
   ] as const;
   for (const [cmd, expectedAction] of multiWord) {
     const result = runCommand(`/${cmd}`);
@@ -641,3 +642,14 @@ test("non-command text without / or ? prefix returns null", () => {
   const result = runCommand("hello world");
   assert.equal(result, null);
 });
+
+test("parses /update and /update check commands", () => {
+  const resultStatus = runCommand("/update");
+  assert.equal(resultStatus?.action, "update");
+  assert.equal(resultStatus?.value, "status");
+
+  const resultCheck = runCommand("/update check");
+  assert.equal(resultCheck?.action, "update");
+  assert.equal(resultCheck?.value, "check");
+});
+

package/src/commands/handler.ts

@@ -97,6 +97,7 @@ export type CommandAction =
   | "runtime_personality"
   | "diagnose_github"
   | "diagnose_providers"
+  | "update"
   | "unknown";
 
 export interface CommandResult {
@@ -395,6 +396,7 @@ function buildHelpMessage(context: CommandContext): string {
     `  Current reasoning: ${formatReasoningLabel(context.runtime.reasoningLevel)}`,
     `  Current plan mode: ${context.runtime.planMode ? "Enabled" : "Disabled"}`,
     "  /copy              Copy last response to clipboard",
+    "  /update [check]    Show update status and instructions for updating Codexa",
     "  /help              Show this help",
     "",
     "Install on Windows:",
@@ -854,6 +856,9 @@ export function handleCommand(text: string, context: CommandContext): CommandRes
       case "help":
         return { action: "help", message: buildHelpMessage(context) };
 
+      case "update":
+        return { action: "update", value: normalizedArg || "status" };
+
       default:
         return {
           action: "unknown",

package/src/config/buildInfo.ts

@@ -0,0 +1,3 @@
+// Generated by scripts/gen-build-info.mjs — do not edit manually.
+export const BUILD_COMMIT = "6ef3a8a85efef3a525472973403a628a84804c4d" as const;
+export const BUILD_VERSION = "1.0.2" as const;

package/src/config/launchArgs.test.ts

@@ -156,3 +156,34 @@ test("parses arguments after -- as an initial prompt", () => {
   assert.equal(parsed.value.initialPrompt, "--help as text");
   assert.deepEqual(parsed.value.passthroughArgs, []);
 });
+
+test("--no-clear sets noClear to true", () => {
+  const parsed = parseLaunchArgs(["--no-clear"]);
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+  assert.equal(parsed.value.noClear, true);
+});
+
+test("noClear defaults to false when --no-clear is absent", () => {
+  const parsed = parseLaunchArgs(["--profile", "review"]);
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+  assert.equal(parsed.value.noClear, false);
+});
+
+test("--no-clear does not consume the next argument as a value", () => {
+  const parsed = parseLaunchArgs(["--no-clear", "my prompt here"]);
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+  assert.equal(parsed.value.noClear, true);
+  assert.equal(parsed.value.initialPrompt, "my prompt here");
+});
+
+test("--no-clear can be combined with other flags", () => {
+  const parsed = parseLaunchArgs(["--no-clear", "--profile", "fast", "do something"]);
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+  assert.equal(parsed.value.noClear, true);
+  assert.equal(parsed.value.profile, "fast");
+  assert.equal(parsed.value.initialPrompt, "do something");
+});

package/src/config/launchArgs.ts

@@ -7,6 +7,7 @@ const FLAG_CONFIG = "--config";
 const FLAG_CONFIG_SHORT = "-c";
 const FLAG_MODEL = "--model";
 const FLAG_MODEL_SHORT = "-m";
+const FLAG_NO_CLEAR = "--no-clear";
 
 export interface LaunchArgs {
   help: boolean;
@@ -17,6 +18,8 @@ export interface LaunchArgs {
   passthroughArgs: string[];
   /** Explicitly set when --model / -m was passed on the command line. Null when no model flag was given. */
   modelOverride: string | null;
+  /** True when --no-clear was passed. Suppresses the startup terminal clear. */
+  noClear: boolean;
 }
 
 export type LaunchArgsParseResult =
@@ -53,6 +56,7 @@ export function parseLaunchArgs(argv: readonly string[]): LaunchArgsParseResult
   const promptArgs: string[] = [];
   let help = false;
   let version = false;
+  let noClear = false;
   let profile: string | null = null;
   let modelOverride: string | null = null;
 
@@ -77,6 +81,11 @@ export function parseLaunchArgs(argv: readonly string[]): LaunchArgsParseResult
       continue;
     }
 
+    if (arg === FLAG_NO_CLEAR) {
+      noClear = true;
+      continue;
+    }
+
     // --profile <value> and --profile=<value> both supported.
     if (arg === FLAG_PROFILE) {
       const value = normalizeProfileValue(argv[index + 1]);
@@ -181,6 +190,7 @@ export function parseLaunchArgs(argv: readonly string[]): LaunchArgsParseResult
       configOverrides,
       passthroughArgs,
       modelOverride,
+      noClear,
     },
   };
 }

package/src/config/persistence.test.ts

@@ -39,12 +39,16 @@ test("keeps UI and auth settings separate from runtime persistence", () => {
     header: {
       showBrand: true,
       showWorkspace: true,
-      showProvider: false,
-      showModel: false,
+      showProvider: true,
+      showModel: true,
       showReasoning: false,
       showContext: false,
       showAuthStatus: false,
     },
+    updateCheck: {
+      enabled: true,
+      intervalHours: 6,
+    },
   };
 
   const serialized = serializeSettings(initial);

package/src/config/persistence.ts

@@ -47,10 +47,21 @@ export interface AuthSettings {
   preference: AuthPreference;
 }
 
+export interface UpdateCheckSettings {
+  enabled: boolean;
+  intervalHours: number;
+}
+
+export const DEFAULT_UPDATE_CHECK_SETTINGS: UpdateCheckSettings = {
+  enabled: true,
+  intervalHours: 6,
+};
+
 export interface AppSettings {
   ui: UiSettings;
   auth: AuthSettings;
   header: HeaderConfig;
+  updateCheck: UpdateCheckSettings;
 }
 
 // Pick the first string value found under the camelCase or snake_case key.
@@ -106,6 +117,17 @@ function normalizeHeaderConfig(input: Partial<HeaderConfig> | null | undefined):
   };
 }
 
+function normalizeUpdateCheckSettings(
+  input: Partial<UpdateCheckSettings> | null | undefined,
+): UpdateCheckSettings {
+  return {
+    enabled: typeof input?.enabled === "boolean" ? input.enabled : DEFAULT_UPDATE_CHECK_SETTINGS.enabled,
+    intervalHours: typeof input?.intervalHours === "number" && input.intervalHours > 0
+      ? input.intervalHours
+      : DEFAULT_UPDATE_CHECK_SETTINGS.intervalHours,
+  };
+}
+
 export function getDefaultSettings(): AppSettings {
   return {
     ui: normalizeUiSettings(null),
@@ -113,6 +135,7 @@ export function getDefaultSettings(): AppSettings {
       preference: DEFAULT_AUTH_PREFERENCE,
     },
     header: normalizeHeaderConfig(null),
+    updateCheck: normalizeUpdateCheckSettings(null),
   };
 }
 
@@ -211,6 +234,12 @@ export function parseSettingsData(data: unknown): AppSettings {
     ? record.header as Record<string, unknown>
     : {};
 
+  const updateCheckSource = typeof record.updateCheck === "object" && record.updateCheck !== null
+    ? record.updateCheck as Record<string, unknown>
+    : typeof record.update_check === "object" && record.update_check !== null
+      ? record.update_check as Record<string, unknown>
+      : {};
+
   return {
     ui: normalizeUiSettings({
       layoutStyle: pickStr(uiSource, "layoutStyle", "layout_style") ?? defaults.ui.layoutStyle,
@@ -233,6 +262,14 @@ export function parseSettingsData(data: unknown): AppSettings {
       showContext: pickBool(headerSource, "showContext", "show_context"),
       showAuthStatus: pickBool(headerSource, "showAuthStatus", "show_auth_status"),
     }),
+    updateCheck: normalizeUpdateCheckSettings({
+      enabled: pickBool(updateCheckSource, "enabled", "enabled"),
+      intervalHours: typeof updateCheckSource.intervalHours === "number"
+        ? updateCheckSource.intervalHours
+        : typeof updateCheckSource.interval_hours === "number"
+          ? updateCheckSource.interval_hours
+          : undefined,
+    }),
   };
 }
 
@@ -259,6 +296,10 @@ export function serializeSettings(settings: AppSettings): Record<string, unknown
       show_context: settings.header.showContext,
       show_auth_status: settings.header.showAuthStatus,
     },
+    update_check: {
+      enabled: settings.updateCheck.enabled,
+      interval_hours: settings.updateCheck.intervalHours,
+    },
   };
 }
 

package/src/config/runtimeConfig.ts

@@ -110,8 +110,11 @@ export interface RuntimeStatusContext {
 }
 
 export interface RuntimeSummary {
+  providerLabel: string;
   model: AvailableModel;
+  modelLabel?: string;
   reasoningLabel: string;
+  contextLabel?: string;
   modeLabel: string;
   sandboxLabel: string;
   approvalLabel: string;
@@ -439,6 +442,7 @@ export function formatPersonalityLabel(value: RuntimePersonality): string {
 
 export function buildRuntimeSummary(runtime: ResolvedRuntimeConfig): RuntimeSummary {
   return {
+    providerLabel: formatBackendLabel(runtime.provider),
     model: runtime.model,
     reasoningLabel: formatReasoningLabel(runtime.reasoningLevel),
     modeLabel: formatModeLabel(runtime.mode),

package/src/config/settings.ts

@@ -1,5 +1,6 @@
-import { homedir } from "os";
-import { basename, join, parse, win32 } from "path";
+import { homedir } from "os";
+import { basename, join, parse, win32 } from "path";
+import { BUILD_VERSION } from "./buildInfo.js";
 
 function isWindowsStylePath(p: string): boolean {
   return /^[A-Za-z]:[\\/]/.test(p) || /^\\\\/.test(p);
@@ -9,8 +10,8 @@ function smartJoin(base: string, ...parts: string[]): string {
   return isWindowsStylePath(base) ? win32.join(base, ...parts) : join(base, ...parts);
 }
 
-export const APP_NAME = "Codexa";
-export const APP_VERSION = "1.0.1";
+export const APP_NAME = "Codexa";
+export const APP_VERSION = BUILD_VERSION;
 export const DEFAULT_BACKEND = "codex-subprocess";
 export const DEFAULT_MODEL = "gpt-5.4";
 export const DEFAULT_MODE = "full-auto";
@@ -377,8 +378,8 @@ export interface HeaderConfig {
 export const HEADER_CONFIG_DEFAULTS: HeaderConfig = {
   showBrand: true,
   showWorkspace: true,
-  showProvider: false,
-  showModel: false,
+  showProvider: true,
+  showModel: true,
   showReasoning: false,
   showContext: false,
   showAuthStatus: false,

package/src/config/updateCheckCache.ts

@@ -0,0 +1,45 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+export interface UpdateCheckCache {
+  lastChecked: number;
+  currentVersion: string;
+  latestVersion: string | null;
+  updateAvailable: boolean;
+}
+
+const CACHE_FILE = join(homedir(), ".codexa-update-check.json");
+
+export function loadUpdateCheckCache(): UpdateCheckCache | null {
+  try {
+    const text = readFileSync(CACHE_FILE, "utf-8");
+    const data = JSON.parse(text) as Record<string, unknown>;
+    if (typeof data.lastChecked !== "number") return null;
+    if (typeof data.currentVersion !== "string") return null;
+    return {
+      lastChecked: data.lastChecked,
+      currentVersion: data.currentVersion,
+      latestVersion: typeof data.latestVersion === "string" ? data.latestVersion : null,
+      updateAvailable: data.updateAvailable === true,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function saveUpdateCheckCache(cache: UpdateCheckCache): void {
+  try {
+    mkdirSync(dirname(CACHE_FILE), { recursive: true });
+    const tmp = `${CACHE_FILE}.tmp`;
+    writeFileSync(tmp, JSON.stringify(cache, null, 2), "utf-8");
+    renameSync(tmp, CACHE_FILE);
+  } catch {
+    // Best-effort — never crash on cache write failure.
+  }
+}
+
+export function isCacheValid(cache: UpdateCheckCache, intervalHours: number): boolean {
+  const maxAgeMs = intervalHours * 60 * 60 * 1000;
+  return Date.now() - cache.lastChecked < maxAgeMs;
+}