free-coding-models 0.3.69 → 0.3.70

package/src/render-table.js

@@ -103,11 +103,87 @@ export const PROVIDER_COLOR = new Proxy({}, {
   },
 })
 
-// ─── renderTable: mode param controls footer hint text (opencode vs openclaw) ─────────
-export function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilterMode = 0, scrollOffset = 0, terminalRows = 0, terminalCols = 0, originFilterMode = 0, legacyStatus = null, pingMode = 'normal', pingModeSource = 'auto', hideUnconfiguredModels = false, widthWarningStartedAt = null, widthWarningDismissed = false, widthWarningShowCount = 0, settingsUpdateState = 'idle', settingsUpdateLatestVersion = null, legacyFlag = false, startupLatestVersion = null, versionAlertsEnabled = true, favoritesPinnedAndSticky = false, customTextFilter = null, lastReleaseDate = null, legacyFooterHidden = false, verdictFilterMode = 0, healthFilterMode = 0, bestModeOnly = false, routerFooterRunning = false, routerFooterActiveSet = null, routerFooterTodayTokens = 0, routerFooterAllTimeTokens = 0, routerFooterRequests = 0) {
+/**
+ * 📖 renderTable: Render the full TUI table as a string (no side effects).
+ * 📖 Accepts a single options object so adding/removing params never silently breaks call sites.
+ * 📖 `mode` controls footer hint text (opencode vs openclaw).
+ *
+ * @param {{
+ *   results: Array,
+ *   pendingPings: number,
+ *   frame: number,
+ *   cursor: number|null,
+ *   sortColumn: string,
+ *   sortDirection: string,
+ *   pingInterval: number,
+ *   lastPingTime: number,
+ *   mode: string,
+ *   tierFilterMode: number,
+ *   scrollOffset: number,
+ *   terminalRows: number,
+ *   terminalCols: number,
+ *   originFilterMode: number,
+ *   pingMode: string,
+ *   pingModeSource: string,
+ *   hideUnconfiguredModels: boolean,
+ *   widthWarningStartedAt: number|null,
+ *   widthWarningDismissed: boolean,
+ *   settingsUpdateState: string,
+ *   settingsUpdateLatestVersion: string|null,
+ *   startupLatestVersion: string|null,
+ *   versionAlertsEnabled: boolean,
+ *   favoritesPinnedAndSticky: boolean,
+ *   customTextFilter: string|null,
+ *   lastReleaseDate: string|null,
+ *   verdictFilterMode: number,
+ *   healthFilterMode: number,
+ *   bestModeOnly: boolean,
+ *   routerFooterRunning?: boolean,
+ *   routerFooterActiveSet?: string|null,
+ *   routerFooterTodayTokens?: number,
+ *   routerFooterAllTimeTokens?: number,
+ *   routerFooterRequests?: number,
+ * }} opts
+ * @returns {string}
+ */
+export function renderTable({
+  results = [],
+  pendingPings = 0,
+  frame = 0,
+  cursor = null,
+  sortColumn = 'avg',
+  sortDirection = 'asc',
+  pingInterval = PING_INTERVAL,
+  lastPingTime = Date.now(),
+  mode = 'opencode',
+  tierFilterMode = 0,
+  scrollOffset = 0,
+  terminalRows = 0,
+  terminalCols = 0,
+  originFilterMode = 0,
+  pingMode = 'normal',
+  pingModeSource = 'auto',
+  hideUnconfiguredModels = false,
+  widthWarningStartedAt = null,
+  widthWarningDismissed = false,
+  settingsUpdateState = 'idle',
+  settingsUpdateLatestVersion = null,
+  startupLatestVersion = null,
+  versionAlertsEnabled = true,
+  favoritesPinnedAndSticky = false,
+  customTextFilter = null,
+  lastReleaseDate = null,
+  verdictFilterMode = 0,
+  healthFilterMode = 0,
+  bestModeOnly = false,
+  routerFooterRunning = false,
+  routerFooterActiveSet = null,
+  routerFooterTodayTokens = 0,
+  routerFooterAllTimeTokens = 0,
+  routerFooterRequests = 0,
+} = {}) {
   // 📖 Filter out hidden models for display
   const visibleResults = results.filter(r => !r.hidden)
-  void legacyFooterHidden
 
   const up      = visibleResults.filter(r => r.status === 'up').length
   const down    = visibleResults.filter(r => r.status === 'down').length

package/src/tui-filters.js

@@ -0,0 +1,128 @@
+/**
+ * @file tui-filters.js
+ * @description TUI filter logic — tier, origin, verdict, health, text, and usability filters.
+ *
+ * @details
+ *   All the filtering that determines which model rows are visible in the TUI table
+ *   lives here. The main app.js calls applyTierFilter() on each frame and after every
+ *   keypress that changes a filter mode, so the visible set is always consistent.
+ *
+ *   🎯 Filter precedence (first failing check hides the row):
+ *   1. Configure-only mode (E key) — hide models with no API key or bad health
+ *   2. Usable-only mode (E key, second cycle) — only Health UP + verdict Normal/Perfect/Slow
+ *   3. Sticky favorites (Y key) — pinned favorites bypass tier/origin/text filters
+ *   4. Tier filter (T key) — only show models in the selected tier family
+ *   5. Origin filter (O key) — only show models from the selected provider
+ *   6. Verdict filter (V key) — only show models with the selected verdict
+ *   7. Health filter (H key) — only show models with the selected health status
+ *   8. Custom text filter (Ctrl+P) — case-insensitive match on name, ctx, provider
+ *
+ * @functions
+ *   → createTuiFilters(state, deps) — Returns { applyTierFilter, buildOriginCycle }
+ *
+ * @exports createTuiFilters
+ *
+ * @see src/app.js — calls applyTierFilter() on each render frame
+ * @see src/tui-state.js — state shape for filter mode indices
+ */
+
+import { TIER_CYCLE, VERDICT_CYCLE, HEALTH_CYCLE } from './constants.js'
+import { TIER_LETTER_MAP } from './utils.js'
+import { getVerdict } from './utils.js'
+
+/**
+ * 📖 createTuiFilters: Build the filter functions for a given TUI state + dependencies.
+ *
+ * @param {object} state — The TUI state object (from createTuiState)
+ * @param {{
+ *   sources: object,
+ *   getApiKey: function,
+ *   PROVIDER_METADATA: object,
+ * }} deps — External dependencies needed by filter logic
+ * @returns {{ applyTierFilter: () => Array, buildOriginCycle: () => Array }}
+ */
+export function createTuiFilters(state, { sources, getApiKey, PROVIDER_METADATA }) {
+  /**
+   * 📖 applyTierFilter: Apply all active filters to the model results.
+   * 📖 Mutates r.hidden in-place for each result row.
+   * 📖 Returns the results array for chaining.
+   */
+  function applyTierFilter() {
+    const activeTier = TIER_CYCLE[state.tierFilterMode]
+    const activeOrigin = buildOriginCycle()[state.originFilterMode]
+    const activeVerdict = VERDICT_CYCLE[state.verdictFilterMode]
+    const activeHealth = HEALTH_CYCLE[state.healthFilterMode]
+
+    state.results.forEach(r => {
+      const stickyFavorite = state.favoritesPinnedAndSticky && r.isFavorite
+      // 📖 CLI-only tools (rovo, gemini) and Zen models don't need traditional API keys —
+      // 📖 they authenticate via their own CLI login flow, so "configured only" should never hide them.
+      const providerMeta = PROVIDER_METADATA[r.providerKey]
+      const noKeyNeeded = providerMeta?.cliOnly || providerMeta?.zenOnly
+      // 📖 E toggles "Show only configured & working models":
+      // 📖 hide models where provider has no key, or where the health status is noauth/auth_error (but keep timeout and 429)
+      const badHealth = r.status === 'noauth' || r.status === 'auth_error'
+      const unconfiguredHide = state.hideUnconfiguredModels && !noKeyNeeded && (!getApiKey(state.config, r.providerKey) || badHealth)
+      if (unconfiguredHide) {
+        r.hidden = true
+        return
+      }
+      // 📖 Usable only: only show models with Health UP and Verdict Perfect/Normal/Slow
+      if (state.bestModeOnly) {
+        const bmVerdict = getVerdict(r)
+        const bmVerdictOk = ['Perfect', 'Normal', 'Slow'].includes(bmVerdict)
+        const bmHealthOk = r.status === 'up'
+        if (!bmHealthOk || !bmVerdictOk) {
+          r.hidden = true
+          return
+        }
+      }
+      // 📖 Sticky-favorites mode keeps usable favorites visible regardless of
+      // 📖 tier/provider/text filters, but "Usable only" health still wins above.
+      if (stickyFavorite) {
+        r.hidden = false
+        return
+      }
+      // 📖 Apply tier, origin, verdict, and health filters — model is hidden if it fails any
+      const allowedTiers = (activeTier && TIER_LETTER_MAP[activeTier]) ? TIER_LETTER_MAP[activeTier] : [activeTier]
+      const tierHide = activeTier !== null && !allowedTiers.includes(r.tier)
+      const originHide = activeOrigin !== null && r.providerKey !== activeOrigin
+      // 📖 Verdict filter: match against getVerdict(r) when active
+      const rVerdict = getVerdict(r)
+      const verdictHide = activeVerdict !== null && rVerdict !== activeVerdict
+      // 📖 Health filter: match against r.status when active
+      const healthHide = activeHealth !== null && r.status !== activeHealth
+      if (tierHide || originHide || verdictHide || healthHide) {
+        r.hidden = true
+        return
+      }
+      // 📖 Custom text filter — case-insensitive includes match against model name, ctx, provider key, and provider display name.
+      if (state.customTextFilter) {
+        const q = state.customTextFilter.toLowerCase()
+        const providerName = (sources[r.providerKey]?.name || '').toLowerCase()
+        const match = (r.label || '').toLowerCase().includes(q)
+          || (r.ctx || '').toLowerCase().includes(q)
+          || (r.providerKey || '').toLowerCase().includes(q)
+          || providerName.includes(q)
+        r.hidden = !match
+        return
+      }
+      r.hidden = false
+    })
+    return state.results
+  }
+
+  /**
+   * 📖 buildOriginCycle: Build the origin filter cycle array on demand.
+   * 📖 [null, ...providerKeys] — null = "All", then each provider key in sources.js order.
+   * @returns {Array<string|null>}
+   */
+  function buildOriginCycle() {
+    return [null, ...Object.keys(sources)]
+  }
+
+  return {
+    applyTierFilter,
+    buildOriginCycle,
+  }
+}

package/src/tui-state.js

@@ -0,0 +1,265 @@
+/**
+ * @file tui-state.js
+ * @description Factory for the TUI state object — extracted from src/app.js for maintainability.
+ *
+ * @details
+ *   The state object is the single source of truth for the interactive TUI.
+ *   It holds all mutable UI state: cursor position, filter modes, overlay flags,
+ *   ping cadence timing, settings editing buffers, and live result data.
+ *
+ *   🎯 Why a factory instead of inline in app.js?
+ *   - Reduces runApp() from 1,300+ lines — state initialization alone was 250+ lines.
+ *   - Makes state shape inspectable and testable in isolation.
+ *   - Future: could generate TypeScript types from the default values.
+ *
+ *   📖 Ping cadence constants (PING_MODE_INTERVALS, PING_MODE_CYCLE, etc.) live here
+ *   because they are tightly coupled to the state fields they initialize.
+ *
+ * @functions
+ *   → createTuiState(opts) — Build the full initial state object with computed defaults
+ *
+ * @exports createTuiState, PING_MODE_INTERVALS, PING_MODE_CYCLE, SPEED_MODE_DURATION_MS, IDLE_SLOW_AFTER_MS
+ *
+ * @see src/app.js — calls createTuiState() once at startup
+ * @see src/ping-loop.js — reads ping mode fields from the state
+ */
+
+import { WIDTH_WARNING_MIN_COLS } from './constants.js'
+
+// 📖 Ping cadence intervals per mode (ms). Speed = startup burst, normal = steady,
+// 📖 slow = idle throttle, forced = user-triggered fast burst.
+export const PING_MODE_INTERVALS = {
+  speed: 2_000,
+  normal: 10_000,
+  slow: 30_000,
+  forced: 4_000,
+}
+
+// 📖 Ping mode cycle order — used by keyboard handler to cycle through modes.
+export const PING_MODE_CYCLE = ['speed', 'normal', 'slow', 'forced']
+
+// 📖 Speed mode auto-falls back to normal after this duration.
+export const SPEED_MODE_DURATION_MS = 60_000
+
+// 📖 After this much inactivity, the ping loop slows down to save quota.
+export const IDLE_SLOW_AFTER_MS = 5 * 60_000
+
+/**
+ * 📖 intervalToPingMode: Map a raw interval (ms) to the closest ping mode label.
+ * @param {number} intervalMs
+ * @returns {string}
+ */
+export function intervalToPingMode(intervalMs) {
+  if (intervalMs <= 3000) return 'speed'
+  if (intervalMs <= 5000) return 'forced'
+  if (intervalMs >= 30000) return 'slow'
+  return 'normal'
+}
+
+/**
+ * 📖 createTuiState: Build the full initial TUI state object.
+ *
+ * 📖 Accepts pre-computed values (results, config, mode, etc.) that come from runApp's
+ * 📖 startup logic (OpenRouter discovery, key setup, etc.) and fills in all the
+ * 📖 default overlay/ping/filter state that the TUI needs on frame 1.
+ *
+ * @param {{
+ *   results: Array,
+ *   config: object,
+ *   mode: string,
+ *   sessionId: string,
+ *   latestVersion: string|null,
+ *   isDevMode: boolean,
+ * }} opts
+ * @returns {object} The complete TUI state (mutable)
+ */
+export function createTuiState({
+  results,
+  config,
+  mode,
+  sessionId,
+  latestVersion,
+  isDevMode,
+}) {
+  const now = Date.now()
+
+  return {
+    // 📖 Core data: model results (mutated in-place by ping loop)
+    results,
+    pendingPings: 0,
+
+    // 📖 Animation frame counter — incremented each render tick
+    frame: 0,
+
+    // 📖 Cursor position in the visible sorted table
+    cursor: 0,
+    selectedModel: null,
+
+    // 📖 Sorting preferences
+    sortColumn: config.settings?.sortColumn ?? 'avg',
+    sortDirection: (config.settings?.sortAsc ?? true) ? 'asc' : 'desc',
+
+    // 📖 Ping cadence — drives the interval between background ping cycles
+    pingInterval: PING_MODE_INTERVALS.speed,
+    pingMode: 'speed',
+    pingModeSource: 'startup',
+    speedModeUntil: now + SPEED_MODE_DURATION_MS,
+    lastPingTime: now,
+    lastUserActivityAt: now,
+    resumeSpeedOnActivity: false,
+
+    // 📖 Version tracking — startup auto-check + periodic re-check
+    startupLatestVersion: latestVersion,
+    lastReleaseDate: null,
+    versionAlertsEnabled: !isDevMode,
+
+    // 📖 Tool mode — determines which external CLI opens on Enter (opencode, openclaw, crush, etc.)
+    mode,
+
+    // 📖 Filter mode indices — each cycles through a predefined sequence
+    tierFilterMode: 0,
+    originFilterMode: 0,
+    verdictFilterMode: 0,
+    healthFilterMode: 0,
+
+    // 📖 E-key toggle: Normal → Configured only → Usable only
+    hideUnconfiguredModels: config.settings?.hideUnconfiguredModels === true,
+    bestModeOnly: false,
+
+    // 📖 Favorites pinning — Y key toggles pinned+sticky mode
+    favoritesPinnedAndSticky: config.settings?.favoritesPinnedAndSticky === true,
+
+    // 📖 Viewport scroll + terminal dimensions
+    scrollOffset: 0,
+    terminalRows: process.stdout.rows || 24,
+    terminalCols: process.stdout.columns || 80,
+    widthWarningStartedAt: (process.stdout.columns || 80) < WIDTH_WARNING_MIN_COLS ? now : null,
+    widthWarningDismissed: false,
+    widthWarningShowCount: 0, // 📖 No longer used — kept for backward compatibility.
+
+    // 📖 Settings screen state (P key opens it)
+    settingsOpen: false,
+    settingsCursor: 0,
+    settingsEditMode: false,
+    settingsAddKeyMode: false,
+    settingsEditBuffer: '',
+    settingsErrorMsg: null,
+    settingsTestResults: {},
+    settingsTestDetails: {},
+    settingsUpdateState: 'idle',
+    settingsUpdateLatestVersion: null,
+    settingsUpdateError: null,
+
+    // 📖 Live config reference — mutated in-place by save/restore
+    config,
+    sessionId,
+
+    // 📖 Cached visible+sorted models — recomputed each frame by the render loop
+    visibleSorted: [],
+
+    // 📖 Command palette (Ctrl+P)
+    commandPaletteOpen: false,
+    commandPaletteQuery: '',
+    commandPaletteCursor: 0,
+    commandPaletteScrollOffset: 0,
+    commandPaletteResults: [],
+    commandPaletteFrozenTable: null,
+    commandPaletteExpandedIds: new Set(['filters', 'actions']),
+
+    // 📖 Help overlay (K key)
+    helpVisible: false,
+    settingsScrollOffset: 0,
+    helpScrollOffset: 0,
+
+    // 📖 Install Endpoints overlay (opened from Settings or Command Palette)
+    installEndpointsOpen: false,
+    installEndpointsPhase: 'providers',
+    installEndpointsCursor: 0,
+    installEndpointsScrollOffset: 0,
+    installEndpointsProviderKey: null,
+    installEndpointsToolMode: null,
+    installEndpointsConnectionMode: null,
+    installEndpointsScope: null,
+    installEndpointsSelectedModelIds: new Set(),
+    installEndpointsErrorMsg: null,
+    installEndpointsResult: null,
+
+    // 📖 Missing-tool bootstrap overlay
+    toolInstallPromptOpen: false,
+    toolInstallPromptCursor: 0,
+    toolInstallPromptScrollOffset: 0,
+    toolInstallPromptMode: null,
+    toolInstallPromptModel: null,
+    toolInstallPromptPlan: null,
+    toolInstallPromptErrorMsg: null,
+
+    // 📖 Incompatible model fallback overlay
+    incompatibleFallbackOpen: false,
+    incompatibleFallbackCursor: 0,
+    incompatibleFallbackScrollOffset: 0,
+    incompatibleFallbackModel: null,
+    incompatibleFallbackTools: [],
+    incompatibleFallbackSimilarModels: [],
+    incompatibleFallbackSection: 'tools',
+
+    // 📖 Smart Recommend overlay (Q key)
+    recommendOpen: false,
+    recommendPhase: 'questionnaire',
+    recommendCursor: 0,
+    recommendQuestion: 0,
+    recommendAnswers: { taskType: null, priority: null, contextBudget: null },
+    recommendProgress: 0,
+    recommendResults: [],
+    recommendScrollOffset: 0,
+    recommendAnalysisTimer: null,
+    recommendPingTimer: null,
+    recommendedKeys: new Set(),
+
+    // 📖 OpenCode sync status (S key in settings)
+    settingsSyncStatus: null,
+
+    // 📖 Changelog overlay (N key)
+    changelogOpen: false,
+    changelogScrollOffset: 0,
+    changelogPhase: 'index',
+    changelogCursor: 0,
+    changelogSelectedVersion: null,
+
+    // 📖 Installed Models overlay (Command Palette → Installed models)
+    installedModelsOpen: false,
+    installedModelsCursor: 0,
+    installedModelsScrollOffset: 0,
+    installedModelsData: [],
+    installedModelsErrorMsg: null,
+
+    // 📖 Router Dashboard overlay (Shift+R)
+    routerDashboardOpen: false,
+    routerDashboardStatus: 'idle',
+    routerDashboardBaseUrl: null,
+    routerDashboardPort: null,
+    routerDashboardHealth: null,
+    routerDashboardStats: null,
+    routerDashboardError: null,
+    routerDashboardScrollOffset: 0,
+    routerDashboardEvents: [],
+    routerDashboardLiveRequests: [],
+    routerDashboardClearedAt: 0,
+    routerDashboardLastUpdatedAt: null,
+    routerDashboardLastRefreshStartedAt: null,
+    routerDashboardPollTimer: null,
+    routerDashboardEventAbort: null,
+    routerDashboardEventStatus: 'idle',
+    routerDashboardEventError: null,
+    routerDashboardNotice: null,
+    routerDashboardNoticeTimer: null,
+    routerOnboardingScrollOffset: 0,
+    routerDashboardEverOpened: false,
+    routerDashboardCursorIndex: 0,
+
+    // 📖 Custom text filter (Ctrl+P → type text → Enter). Ephemeral — not saved to config.
+    customTextFilter: null,
+
+    // 📖 Token usage overlay scroll state (used when overlay opens from footer)
+    tokenUsageOpen: false,
+  }
+}

package/src/updater.js

@@ -17,12 +17,6 @@
  *     On success, relaunches the process with the same argv.  On failure, prints manual
  *     instructions (using the correct PM command) and exits with code 1.
  *
- *   - `promptUpdateNotification(latestVersion)` — renders a small centered interactive menu
- *     that lets the user choose: Update Now / Read Changelogs / Continue without update.
- *     Uses raw mode readline keypress events (same pattern as the main TUI).
- *     This function is called BEFORE the alt-screen is entered, so it writes to the
- *     normal terminal buffer.
- *
  *   ⚙️ Notes:
  *   - `LOCAL_VERSION` is resolved from package.json via `createRequire` so this module
  *     can be imported independently from the bin entry point.
@@ -39,11 +33,9 @@
  *   → checkForUpdateDetailed()           — Fetch npm latest with explicit error info
  *   → checkForUpdate()                   — Startup wrapper, returns version string or null
  *   → runUpdate(latestVersion)           — Install new version via detected PM + relaunch
- *   → promptUpdateNotification(version)  — Interactive pre-TUI update menu
- *
  * @exports
  *   detectPackageManager, getInstallArgs, getManualInstallCmd,
- *   checkForUpdateDetailed, checkForUpdate, runUpdate, promptUpdateNotification
+ *   checkForUpdateDetailed, checkForUpdate, runUpdate, fetchLastReleaseDate
  *
  * @see bin/free-coding-models.js — calls checkForUpdate() at startup and runUpdate() on confirm
  */
@@ -329,100 +321,4 @@ export function runUpdate(latestVersion) {
   process.exit(1)
 }
 
-/**
- * 📖 promptUpdateNotification: Show a centered interactive menu when a new version is available.
- * 📖 Returns 'update', 'changelogs', or null (continue without update).
- * 📖 Called BEFORE entering the alt-screen so it renders in the normal terminal buffer.
- * @param {string|null} latestVersion
- * @returns {Promise<'update'|'changelogs'|null>}
- */
-export async function promptUpdateNotification(latestVersion) {
-  if (!latestVersion) return null
-
-  return new Promise((resolve) => {
-    let selected = 0
-    const options = [
-      {
-        label: 'Update now',
-        icon: '⬆',
-        description: `Update free-coding-models to v${latestVersion}`,
-      },
-      {
-        label: 'Read Changelogs',
-        icon: '📋',
-        description: 'Open GitHub changelog',
-      },
-      {
-        label: 'Continue without update',
-        icon: '▶',
-        description: '⚠ You will be reminded again in the TUI',
-      },
-    ]
-
-    // 📖 Centered render function
-    const render = () => {
-      process.stdout.write('\x1b[2J\x1b[H') // clear screen + cursor home
-
-      // 📖 Calculate centering
-      const terminalWidth = process.stdout.columns || 80
-      const maxWidth = Math.min(terminalWidth - 4, 70)
-      const centerPad = ' '.repeat(Math.max(0, Math.floor((terminalWidth - maxWidth) / 2)))
-
-      console.log()
-      console.log(centerPad + chalk.bold.rgb(57, 255, 20)('  🚀⬆️ UPDATE AVAILABLE'))
-      console.log(centerPad + chalk.rgb(57, 255, 20)(`  Version ${latestVersion} is ready to install`))
-      console.log()
-      console.log(centerPad + chalk.bold('  ⚡ Free Coding Models') + chalk.dim(` v${LOCAL_VERSION}`))
-      console.log()
-
-      for (let i = 0; i < options.length; i++) {
-        const isSelected = i === selected
-        const bullet = isSelected ? chalk.bold.cyan('  ❯ ') : chalk.dim('    ')
-        const label = isSelected
-          ? chalk.bold.white(options[i].icon + ' ' + options[i].label)
-          : chalk.dim(options[i].icon + ' ' + options[i].label)
-
-        console.log(centerPad + bullet + label)
-        console.log(centerPad + chalk.dim('       ' + options[i].description))
-        console.log()
-      }
-
-      console.log(centerPad + chalk.dim('  ↑↓ Navigate  •  Enter Select  •  Ctrl+C Continue'))
-      console.log()
-    }
-
-    render()
-
-    readline.emitKeypressEvents(process.stdin)
-    // 📖 Ensure stdin is flowing — the shell-env prompt may have paused it
-    process.stdin.resume()
-    if (process.stdin.isTTY) process.stdin.setRawMode(true)
-
-    const onKey = (_str, key) => {
-      if (!key) return
-      if (key.ctrl && key.name === 'c') {
-        if (process.stdin.isTTY) process.stdin.setRawMode(false)
-        process.stdin.removeListener('keypress', onKey)
-        resolve(null) // Continue without update
-        return
-      }
-      if (key.name === 'up' && selected > 0) {
-        selected--
-        render()
-      } else if (key.name === 'down' && selected < options.length - 1) {
-        selected++
-        render()
-      } else if (key.name === 'return') {
-        if (process.stdin.isTTY) process.stdin.setRawMode(false)
-        process.stdin.removeListener('keypress', onKey)
-        process.stdin.pause()
 
-        if (selected === 0) resolve('update')
-        else if (selected === 1) resolve('changelogs')
-        else resolve(null) // Continue without update
-      }
-    }
-
-    process.stdin.on('keypress', onKey)
-  })
-}