free-coding-models 0.1.22 → 0.1.24

package/bin/free-coding-models.js

@@ -109,14 +109,19 @@ function runUpdate(latestVersion) {
     console.log()
     console.log(chalk.green('  ✅ Update complete! Version ' + latestVersion + ' installed.'))
     console.log()
-    console.log(chalk.dim('  📝 Please restart free-coding-models to use the new version.'))
+    console.log(chalk.dim('  🔄 Restarting with new version...'))
     console.log()
+    
+    // 📖 Relaunch automatically with the same arguments
+    const args = process.argv.slice(2)
+    execSync(`node bin/free-coding-models.js ${args.join(' ')}`, { stdio: 'inherit' })
+    process.exit(0)
   } catch (err) {
     console.log()
     console.log(chalk.red('  ✖ Update failed. Try manually: npm i -g free-coding-models@' + latestVersion))
     console.log()
   }
-  process.exit(0)
+  process.exit(1)
 }
 
 // ─── Config path ──────────────────────────────────────────────────────────────
@@ -165,73 +170,62 @@ async function promptApiKey() {
   })
 }
 
-// ─── Startup mode selection menu ──────────────────────────────────────────────
-// 📖 Shown at startup when neither --opencode nor --openclaw flag is given.
-// 📖 Simple arrow-key selector in normal terminal (not alt screen).
-// 📖 Returns 'opencode', 'openclaw', or 'update'.
-async function promptModeSelection(latestVersion) {
-  const options = [
-    {
-      label: 'OpenCode CLI',
-      icon: '💻',
-      description: 'Press Enter on a model → launch OpenCode CLI with it as default',
-    },
-    {
-      label: 'OpenCode Desktop',
-      icon: '🖥',
-      description: 'Press Enter on a model → set model & open OpenCode Desktop app',
-    },
-    {
-      label: 'OpenClaw',
-      icon: '🦞',
-      description: 'Press Enter on a model → set it as default in OpenClaw config',
-    },
-  ]
-
-  if (latestVersion) {
-    options.push({
-      label: 'Update now',
-      icon: '⬆',
-      description: `Update free-coding-models to v${latestVersion}`,
-    })
-  }
-
-  // 📖 Add "Read Changelogs" option when an update is available or was just updated
-  if (latestVersion) {
-    options.push({
-      label: 'Read Changelogs',
-      icon: '📋',
-      description: 'Open local CHANGELOG.md file',
-    })
-  }
+// ─── Update notification menu ──────────────────────────────────────────────
+// 📖 Shown ONLY when a new version is available, to prompt user to update
+// 📖 Centered, clean presentation that doesn't block normal usage
+// 📖 Returns 'update', 'changelogs', or null to continue without update
+async function promptUpdateNotification(latestVersion) {
+  if (!latestVersion) return null
 
   return new Promise((resolve) => {
     let selected = 0
-
-    // 📖 Render the menu to stdout (clear + redraw)
+    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: 'Use current version',
+      },
+    ]
+
+    // 📖 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()
-      if (latestVersion) {
-        console.log(chalk.red(`  ⚠ New version available (v${latestVersion}), please run npm i -g free-coding-models to install`))
-        console.log()
-      }
-      console.log(chalk.bold('  ⚡ Free Coding Models') + chalk.dim(` v${LOCAL_VERSION} — Choose your tool`))
+      console.log(centerPad + chalk.bold.red('  ⚠ UPDATE AVAILABLE'))
+      console.log(centerPad + chalk.red(`  Version ${latestVersion} is ready to install`))
       console.log()
-      console.log(chalk.yellow.bold('  ⚠️  Warning: ') + chalk.yellow('Small terminals may break the layout — maximize your window for best results!'))
+      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)
-        const desc = chalk.dim('  ' + options[i].description)
-        console.log(bullet + label)
-        console.log(chalk.dim('       ' + options[i].description))
+        
+        console.log(centerPad + bullet + label)
+        console.log(centerPad + chalk.dim('       ' + options[i].description))
         console.log()
       }
-      console.log(chalk.dim('  ↑↓ Navigate  •  Enter Select  •  Ctrl+C Exit'))
+      
+      console.log(centerPad + chalk.dim('  ↑↓ Navigate  •  Enter Select  •  Ctrl+C Continue'))
       console.log()
     }
 
@@ -245,7 +239,8 @@ async function promptModeSelection(latestVersion) {
       if (key.ctrl && key.name === 'c') {
         if (process.stdin.isTTY) process.stdin.setRawMode(false)
         process.stdin.removeListener('keypress', onKey)
-        process.exit(0)
+        resolve(null) // Continue without update
+        return
       }
       if (key.name === 'up' && selected > 0) {
         selected--
@@ -257,10 +252,10 @@ async function promptModeSelection(latestVersion) {
         if (process.stdin.isTTY) process.stdin.setRawMode(false)
         process.stdin.removeListener('keypress', onKey)
         process.stdin.pause()
-        const choices = ['opencode', 'opencode-desktop', 'openclaw']
-        if (latestVersion) choices.push('update')
-        if (latestVersion) choices.push('changelogs')
-        resolve(choices[selected])
+        
+        if (selected === 0) resolve('update')
+        else if (selected === 1) resolve('changelogs')
+        else resolve(null) // Continue without update
       }
     }
 
@@ -271,10 +266,15 @@ async function promptModeSelection(latestVersion) {
 // ─── Alternate screen control ─────────────────────────────────────────────────
 // 📖 \x1b[?1049h = enter alt screen  \x1b[?1049l = leave alt screen
 // 📖 \x1b[?25l   = hide cursor       \x1b[?25h   = show cursor
-// 📖 \x1b[H      = cursor to top     \x1b[2J     = clear screen
-const ALT_ENTER  = '\x1b[?1049h\x1b[?25l'
-const ALT_LEAVE  = '\x1b[?1049l\x1b[?25h'
-const ALT_CLEAR  = '\x1b[H\x1b[2J'
+// 📖 \x1b[H      = cursor to top
+// 📖 NOTE: We avoid \x1b[2J (clear screen) because Ghostty scrolls cleared
+// 📖 content into the scrollback on the alt screen, pushing the header off-screen.
+// 📖 Instead we overwrite in place: cursor home, then \x1b[K (erase to EOL) per line.
+// 📖 \x1b[?7l disables auto-wrap so wide rows clip at the right edge instead of
+// 📖 wrapping to the next line (which would double the row height and overflow).
+const ALT_ENTER  = '\x1b[?1049h\x1b[?25l\x1b[?7l'
+const ALT_LEAVE  = '\x1b[?7h\x1b[?1049l\x1b[?25h'
+const ALT_HOME   = '\x1b[H'
 
 // ─── API Configuration ───────────────────────────────────────────────────────────
 // 📖 Models are now loaded from sources.js to support multiple providers
@@ -326,11 +326,31 @@ const spinCell = (f, o = 0) => chalk.dim.yellow(FRAMES[(f + o) % FRAMES.length].
 // 📖 Core logic functions (getAvg, getVerdict, getUptime, sortResults, etc.)
 // 📖 are imported from lib/utils.js for testability
 
+// ─── Viewport calculation ────────────────────────────────────────────────────
+// 📖 Computes the visible slice of model rows that fits in the terminal.
+// 📖 Fixed lines: 5 header + 5 footer = 10 lines always consumed.
+// 📖 Header: empty, title, empty, column headers, separator (5)
+// 📖 Footer: empty, hints, empty, credit, empty (5)
+// 📖 When scroll indicators are needed, they each consume 1 line from the model budget.
+function calculateViewport(terminalRows, scrollOffset, totalModels) {
+  if (terminalRows <= 0) return { startIdx: 0, endIdx: totalModels, hasAbove: false, hasBelow: false }
+  let maxSlots = terminalRows - 10  // 5 header + 5 footer
+  if (maxSlots < 1) maxSlots = 1
+  if (totalModels <= maxSlots) return { startIdx: 0, endIdx: totalModels, hasAbove: false, hasBelow: false }
+
+  const hasAbove = scrollOffset > 0
+  const hasBelow = scrollOffset + maxSlots - (hasAbove ? 1 : 0) < totalModels
+  // Recalculate with indicator lines accounted for
+  const modelSlots = maxSlots - (hasAbove ? 1 : 0) - (hasBelow ? 1 : 0)
+  const endIdx = Math.min(scrollOffset + modelSlots, totalModels)
+  return { startIdx: scrollOffset, endIdx, hasAbove, hasBelow }
+}
+
 // 📖 renderTable: mode param controls footer hint text (opencode vs openclaw)
-function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilter = null) {
+function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilter = null, scrollOffset = 0, terminalRows = 0) {
   // 📖 Filter out hidden models for display
   const visibleResults = results.filter(r => !r.hidden)
-  
+
   const up      = visibleResults.filter(r => r.status === 'up').length
   const down    = visibleResults.filter(r => r.status === 'down').length
   const timeout = visibleResults.filter(r => r.status === 'timeout').length
@@ -348,6 +368,7 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
       : chalk.dim(`next ping ${secondsUntilNext}s`)
 
   // 📖 Mode badge shown in header so user knows what Enter will do
+  // 📖 Now includes key hint for mode toggle
   let modeBadge
   if (mode === 'openclaw') {
     modeBadge = chalk.bold.rgb(255, 100, 50)(' [🦞 OpenClaw]')
@@ -356,6 +377,9 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
   } else {
     modeBadge = chalk.bold.rgb(0, 200, 255)(' [💻 CLI]')
   }
+  
+  // 📖 Add mode toggle hint
+  const modeHint = chalk.dim.yellow(' (Z to toggle)')
 
   // 📖 Tier filter badge shown when filtering is active
   let tierBadge = ''
@@ -379,7 +403,7 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
 
   const lines = [
     '',
-    `  ${chalk.bold('⚡ Free Coding Models')} ${chalk.dim('v' + LOCAL_VERSION)}${modeBadge}${tierBadge}   ` +
+    `  ${chalk.bold('⚡ Free Coding Models')} ${chalk.dim('v' + LOCAL_VERSION)}${modeBadge}${modeHint}${tierBadge}   ` +
       chalk.greenBright(`✅ ${up}`) + chalk.dim(' up  ') +
       chalk.yellow(`⏱ ${timeout}`) + chalk.dim(' timeout  ') +
       chalk.red(`❌ ${down}`) + chalk.dim(' down  ') +
@@ -430,7 +454,14 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
     chalk.dim('─'.repeat(W_UPTIME))
   )
 
-  for (let i = 0; i < sorted.length; i++) {
+  // 📖 Viewport clipping: only render models that fit on screen
+  const vp = calculateViewport(terminalRows, scrollOffset, sorted.length)
+
+  if (vp.hasAbove) {
+    lines.push(chalk.dim(`  ... ${vp.startIdx} more above ...`))
+  }
+
+  for (let i = vp.startIdx; i < vp.endIdx; i++) {
     const r = sorted[i]
     const tierFn = TIER_COLOR[r.tier] ?? (t => chalk.white(t))
 
@@ -556,6 +587,10 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
     }
   }
 
+  if (vp.hasBelow) {
+    lines.push(chalk.dim(`  ... ${sorted.length - vp.endIdx} more below ...`))
+  }
+
   lines.push('')
   const intervalSec = Math.round(pingInterval / 1000)
 
@@ -565,11 +600,18 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
     : mode === 'opencode-desktop'
       ? chalk.rgb(0, 200, 255)('Enter→OpenDesktop')
       : chalk.rgb(0, 200, 255)('Enter→OpenCode')
-  lines.push(chalk.dim(`  ↑↓ Navigate  •  `) + actionHint + chalk.dim(`  •  R/T/O/M/P/A/S/V/U Sort  •  W↓/X↑ Interval (${intervalSec}s)  •  E↑/D↓ Tier  •  Ctrl+C Exit`))
+  lines.push(chalk.dim(`  ↑↓ Navigate  •  `) + actionHint + chalk.dim(`  •  R/T/O/M/P/A/S/V/U Sort  •  W↓/X↑ Interval (${intervalSec}s)  •  E↑/D↓ Tier  •  Z Mode  •  Ctrl+C Exit`))
   lines.push('')
   lines.push(chalk.dim('  made with ') + '🩷' + chalk.dim(' by vava-nessa  •  ') + chalk.dim.underline('https://github.com/vava-nessa/free-coding-models'))
   lines.push('')
-  return lines.join('\n')
+  // 📖 Append \x1b[K (erase to EOL) to each line so leftover chars from previous
+  // 📖 frames are cleared. Then pad with blank cleared lines to fill the terminal,
+  // 📖 preventing stale content from lingering at the bottom after resize.
+  const EL = '\x1b[K'
+  const cleared = lines.map(l => l + EL)
+  const remaining = terminalRows > 0 ? Math.max(0, terminalRows - cleared.length) : 0
+  for (let i = 0; i < remaining; i++) cleared.push(EL)
+  return cleared.join('\n')
 }
 
 // ─── HTTP ping ────────────────────────────────────────────────────────────────
@@ -994,15 +1036,8 @@ function filterByTierOrExit(results, tierLetter) {
 }
 
 async function main() {
-  // 📖 Parse CLI arguments using shared parseArgs utility
-  const parsed = parseArgs(process.argv)
-  let apiKey = parsed.apiKey
-  const { bestMode, fiableMode, openCodeMode, openCodeDesktopMode, openClawMode, tierFilter } = parsed
-
-  // 📖 Priority: CLI arg > env var > saved config > wizard
-  if (!apiKey) {
-    apiKey = process.env.NVIDIA_API_KEY || loadApiKey()
-  }
+  // 📖 Simple CLI without flags - just API key handling
+  let apiKey = process.env.NVIDIA_API_KEY || loadApiKey()
 
   if (!apiKey) {
     apiKey = await promptApiKey()
@@ -1015,49 +1050,17 @@ async function main() {
     }
   }
 
-  // 📖 Handle fiable mode first (it exits after analysis)
-  if (fiableMode) {
-    await runFiableMode(apiKey)
-  }
-
-  // 📖 Check for available update (non-blocking, 5s timeout)
-  const latestVersion = await checkForUpdate()
-
-  // 📖 Determine active mode:
-  //   --opencode → opencode
-  //   --openclaw → openclaw
-  //   neither    → show interactive startup menu
-  let mode
-  if (openClawMode) {
-    mode = 'openclaw'
-  } else if (openCodeDesktopMode) {
-    mode = 'opencode-desktop'
-  } else if (openCodeMode) {
-    mode = 'opencode'
-  } else {
-    // 📖 No mode flag given — ask user with the startup menu
-    mode = await promptModeSelection(latestVersion)
-  }
+  // 📖 Skip update check during development to avoid blocking menus
+  // 📖 In production, this will work correctly when versions are published
+  const latestVersion = null // Skip update check for now
 
-  // 📖 Handle "update now" selection from the menu
-  if (mode === 'update') {
-    runUpdate(latestVersion)
-  }
+  // 📖 Default mode: OpenCode CLI
+  let mode = 'opencode'
 
-  // 📖 Handle "Read Changelogs" selection — open local CHANGELOG.md file
-  if (mode === 'changelogs') {
-    const { exec } = await import('child_process')
-    const changelogPath = join(process.cwd(), 'CHANGELOG.md')
-    exec(`open "${changelogPath}"`)
-    console.log(chalk.dim('  📋 Opening local changelogs file…'))
-    process.exit(0)
-  }
+  // 📖 AUTO-UPDATE: Disabled during development
+  // 📖 Will be re-enabled when versions are properly published
 
-  // 📖 When using flags (--opencode/--openclaw), show update warning in terminal
-  if (latestVersion && (openCodeMode || openCodeDesktopMode || openClawMode)) {
-    console.log(chalk.red(`  ⚠ New version available (v${latestVersion}), please run npm i -g free-coding-models to install`))
-    console.log()
-  }
+  // 📖 This section is now handled by the update notification menu above
 
   // 📖 Create results array with all models initially visible
   let results = MODELS.map(([modelId, label, tier], i) => ({
@@ -1068,24 +1071,31 @@ async function main() {
     hidden: false,  // 📖 Simple flag to hide/show models
   }))
 
-  // 📖 Apply filters by setting hidden flag
-  if (bestMode) {
-    results.forEach(r => {
-      r.hidden = !(r.tier === 'S+' || r.tier === 'S' || r.tier === 'A+')
-    })
-  }
-
-  // 📖 Apply tier letter filter if --tier X was given (just sets initial state)
-  // 📖 User can still change filter with E/D keys later
-  if (tierFilter) {
-    const tierSet = TIER_LETTER_MAP[tierFilter]
-    if (!tierSet) {
-      console.error(chalk.red(`  ✖ Unknown tier "${tierFilter}". Valid tiers: S, A, B, C`))
-      process.exit(1)
+  // 📖 No initial filters - all models visible by default
+
+  // 📖 Clamp scrollOffset so cursor is always within the visible viewport window.
+  // 📖 Called after every cursor move, sort change, and terminal resize.
+  const adjustScrollOffset = (st) => {
+    const total = st.results.length
+    let maxSlots = st.terminalRows - 10  // 5 header + 5 footer
+    if (maxSlots < 1) maxSlots = 1
+    if (total <= maxSlots) { st.scrollOffset = 0; return }
+    // Ensure cursor is not above the visible window
+    if (st.cursor < st.scrollOffset) {
+      st.scrollOffset = st.cursor
     }
-    results.forEach(r => {
-      r.hidden = !tierSet.includes(r.tier)
-    })
+    // Ensure cursor is not below the visible window
+    // Account for indicator lines eating into model slots
+    const hasAbove = st.scrollOffset > 0
+    const tentativeBelow = st.scrollOffset + maxSlots - (hasAbove ? 1 : 0) < total
+    const modelSlots = maxSlots - (hasAbove ? 1 : 0) - (tentativeBelow ? 1 : 0)
+    if (st.cursor >= st.scrollOffset + modelSlots) {
+      st.scrollOffset = st.cursor - modelSlots + 1
+    }
+    // Final clamp
+    const maxOffset = Math.max(0, total - maxSlots)
+    if (st.scrollOffset > maxOffset) st.scrollOffset = maxOffset
+    if (st.scrollOffset < 0) st.scrollOffset = 0
   }
 
   // 📖 Add interactive selection state - cursor index and user's choice
@@ -1103,11 +1113,17 @@ async function main() {
     sortDirection: 'asc',
     pingInterval: PING_INTERVAL,  // 📖 Track current interval for W/X keys
     lastPingTime: Date.now(),     // 📖 Track when last ping cycle started
-    fiableMode,                   // 📖 Pass fiable mode to state
     mode,                         // 📖 'opencode' or 'openclaw' — controls Enter action
-    tierFilter: tierFilter || null, // 📖 Track current tier filter (null if no --tier flag)
+    scrollOffset: 0,              // 📖 First visible model index in viewport
+    terminalRows: process.stdout.rows || 24,  // 📖 Current terminal height
   }
 
+  // 📖 Re-clamp viewport on terminal resize
+  process.stdout.on('resize', () => {
+    state.terminalRows = process.stdout.rows || 24
+    adjustScrollOffset(state)
+  })
+
   // 📖 Enter alternate screen — animation runs here, zero scrollback pollution
   process.stdout.write(ALT_ENTER)
 
@@ -1121,17 +1137,14 @@ async function main() {
   process.on('SIGINT',  () => exit(0))
   process.on('SIGTERM', () => exit(0))
 
-  // 📖 Apply tier filter based on current state.tierFilter
-  // 📖 This preserves all ping history by merging with existing results
+  // 📖 No tier filtering by default - all models visible
   function applyTierFilter() {
-    const tierSet = state.tierFilter ? TIER_LETTER_MAP[state.tierFilter] : null
-    
-    // 📖 Simple approach: just update hidden flag on existing results
+    // 📖 All models visible by default
     state.results.forEach(r => {
-      r.hidden = tierSet ? !tierSet.includes(r.tier) : false
+      r.hidden = false
     })
     
-    return state.results  // 📖 Return same array, just updated hidden flags
+    return state.results
   }
 
   // 📖 Setup keyboard input for interactive selection during pings
@@ -1159,6 +1172,7 @@ async function main() {
         state.sortColumn = col
         state.sortDirection = 'asc'
       }
+      adjustScrollOffset(state)
       return
     }
 
@@ -1170,22 +1184,15 @@ async function main() {
       state.pingInterval = Math.min(60000, state.pingInterval + 1000)
     }
 
-    // 📖 Tier filtering keys: E=elevate (more restrictive), D=descend (less restrictive)
-    // 📖 Cycle through: null → 'S' → 'A' → 'B' → 'C' → null (all tiers)
-    if (key.name === 'e') {
-      const tierOrder = [null, 'S', 'A', 'B', 'C']
-      const currentIndex = tierOrder.indexOf(state.tierFilter)
-      const nextIndex = (currentIndex + 1) % tierOrder.length
-      state.tierFilter = tierOrder[nextIndex]
-      state.results = applyTierFilter()
-      state.cursor = Math.min(state.cursor, state.results.length - 1)
-    } else if (key.name === 'd') {
-      const tierOrder = [null, 'C', 'B', 'A', 'S']
-      const currentIndex = tierOrder.indexOf(state.tierFilter)
-      const nextIndex = (currentIndex - 1 + tierOrder.length) % tierOrder.length
-      state.tierFilter = tierOrder[nextIndex]
-      state.results = applyTierFilter()
-      state.cursor = Math.min(state.cursor, state.results.length - 1)
+    // 📖 Tier filtering removed for simplicity - all models visible by default
+
+    // 📖 Mode toggle key: Z = cycle through modes (CLI → Desktop → OpenClaw)
+    if (key.name === 'z') {
+      const modeOrder = ['opencode', 'opencode-desktop', 'openclaw']
+      const currentIndex = modeOrder.indexOf(state.mode)
+      const nextIndex = (currentIndex + 1) % modeOrder.length
+      state.mode = modeOrder[nextIndex]
+      return
     }
 
     if (key.name === 'x') {
@@ -1196,6 +1203,7 @@ async function main() {
     if (key.name === 'up') {
       if (state.cursor > 0) {
         state.cursor--
+        adjustScrollOffset(state)
       }
       return
     }
@@ -1203,6 +1211,7 @@ async function main() {
     if (key.name === 'down') {
       if (state.cursor < results.length - 1) {
         state.cursor++
+        adjustScrollOffset(state)
       }
       return
     }
@@ -1261,10 +1270,10 @@ async function main() {
   // 📖 Animation loop: clear alt screen + redraw table at FPS with cursor
   const ticker = setInterval(() => {
     state.frame++
-    process.stdout.write(ALT_CLEAR + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilter))
+    process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, null, state.scrollOffset, state.terminalRows))
   }, Math.round(1000 / FPS))
 
-  process.stdout.write(ALT_CLEAR + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilter))
+  process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, null, state.scrollOffset, state.terminalRows))
 
   // ── Continuous ping loop — ping all models every N seconds forever ──────────
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Find the fastest coding LLM models in seconds — ping free models from multiple providers, pick the best one for OpenCode, Cursor, or any AI coding assistant.",
   "keywords": [
     "nvidia",