free-coding-models 0.1.19 → 0.1.21

package/README.md

@@ -56,7 +56,7 @@
 - **🎨 Clean output** — Zero scrollback pollution, interface stays open until Ctrl+C
 - **📶 Status indicators** — UP ✅ · Timeout ⏳ · Overloaded 🔥 · Not Found 🚫
 - **🔧 Multi-source support** — Extensible architecture via `sources.js` (add new providers easily)
-- **🏷 Tier filtering** — Filter models by tier letter (S, A, B, C) with `--tier`
+- **🏷 Tier filtering** — Filter models by tier letter (S, A, B, C) with `--tier` flag or dynamically with E/D keys
 
 ---
 
@@ -226,6 +226,15 @@ free-coding-models --tier B     # Only B+, B (lightweight options)
 free-coding-models --tier C     # Only C (edge/minimal models)
 ```
 
+#### Dynamic tier filtering with E/D keys
+
+During runtime, use **E** and **D** keys to dynamically adjust the tier filter:
+
+- **E** (Elevate) — Show fewer, higher-tier models (cycle: All → S → A → B → C → All)
+- **D** (Descend) — Show more, lower-tier models (cycle: All → C → B → A → S → All)
+
+Current tier filter is shown in the header badge (e.g., `[Tier S]`)
+
 ---
 
 ## 🔌 OpenCode Integration
@@ -439,6 +448,8 @@ This script:
 - **R/T/O/M/P/A/S/V/U** — Sort by Rank/Tier/Origin/Model/Ping/Avg/Status/Verdict/Uptime
 - **W** — Decrease ping interval (faster pings)
 - **X** — Increase ping interval (slower pings)
+- **E** — Elevate tier filter (show fewer, higher-tier models)
+- **D** — Descend tier filter (show more, lower-tier models)
 - **Ctrl+C** — Exit
 
 ---

package/bin/free-coding-models.js

@@ -327,11 +327,14 @@ const spinCell = (f, o = 0) => chalk.dim.yellow(FRAMES[(f + o) % FRAMES.length].
 // 📖 are imported from lib/utils.js for testability
 
 // 📖 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') {
-  const up      = results.filter(r => r.status === 'up').length
-  const down    = results.filter(r => r.status === 'down').length
-  const timeout = results.filter(r => r.status === 'timeout').length
-  const pending = results.filter(r => r.status === 'pending').length
+function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilter = null) {
+  // 📖 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
+  const pending = visibleResults.filter(r => r.status === 'pending').length
 
   // 📖 Calculate seconds until next ping
   const timeSinceLastPing = Date.now() - lastPingTime
@@ -354,6 +357,12 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
     modeBadge = chalk.bold.rgb(0, 200, 255)(' [💻 CLI]')
   }
 
+  // 📖 Tier filter badge shown when filtering is active
+  let tierBadge = ''
+  if (tierFilter) {
+    tierBadge = chalk.bold.rgb(255, 200, 0)(` [Tier ${tierFilter}]`)
+  }
+
   // 📖 Column widths (generous spacing with margins)
   const W_RANK = 6
   const W_TIER = 6
@@ -366,11 +375,11 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
   const W_UPTIME = 6
 
   // 📖 Sort models using the shared helper
-  const sorted = sortResults(results, sortColumn, sortDirection)
+  const sorted = sortResults(visibleResults, sortColumn, sortDirection)
 
   const lines = [
     '',
-    `  ${chalk.bold('⚡ Free Coding Models')} ${chalk.dim('v' + LOCAL_VERSION)}${modeBadge}   ` +
+    `  ${chalk.bold('⚡ Free Coding Models')} ${chalk.dim('v' + LOCAL_VERSION)}${modeBadge}${tierBadge}   ` +
       chalk.greenBright(`✅ ${up}`) + chalk.dim(' up  ') +
       chalk.yellow(`⏱ ${timeout}`) + chalk.dim(' timeout  ') +
       chalk.red(`❌ ${down}`) + chalk.dim(' down  ') +
@@ -556,7 +565,7 @@ 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)  •  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  •  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('')
@@ -1049,27 +1058,40 @@ async function main() {
     console.log()
   }
 
-  // 📖 Filter models to only show top tiers if BEST mode is active
+  // 📖 Create results array with all models initially visible
   let results = MODELS.map(([modelId, label, tier], i) => ({
     idx: i + 1, modelId, label, tier,
     status: 'pending',
     pings: [],  // 📖 All ping results (ms or 'TIMEOUT')
     httpCode: null,
+    hidden: false,  // 📖 Simple flag to hide/show models
   }))
 
+  // 📖 Apply filters by setting hidden flag
   if (bestMode) {
-    results = results.filter(r => r.tier === 'S+' || r.tier === 'S' || r.tier === 'A+')
+    results.forEach(r => {
+      r.hidden = !(r.tier === 'S+' || r.tier === 'S' || r.tier === 'A+')
+    })
   }
 
-  // 📖 Apply tier letter filter if --tier X was given
+  // 📖 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) {
-    results = filterByTierOrExit(results, 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)
+    }
+    results.forEach(r => {
+      r.hidden = !tierSet.includes(r.tier)
+    })
   }
 
   // 📖 Add interactive selection state - cursor index and user's choice
   // 📖 sortColumn: 'rank'|'tier'|'origin'|'model'|'ping'|'avg'|'status'|'verdict'|'uptime'
   // 📖 sortDirection: 'asc' (default) or 'desc'
   // 📖 pingInterval: current interval in ms (default 2000, adjustable with W/X keys)
+  // 📖 tierFilter: current tier filter letter (null = all, 'S' = S+/S, 'A' = A+/A/A-, etc.)
   const state = {
     results,
     pendingPings: 0,
@@ -1082,6 +1104,7 @@ async function main() {
     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)
   }
 
   // 📖 Enter alternate screen — animation runs here, zero scrollback pollution
@@ -1097,6 +1120,19 @@ 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
+  function applyTierFilter() {
+    const tierSet = state.tierFilter ? TIER_LETTER_MAP[state.tierFilter] : null
+    
+    // 📖 Simple approach: just update hidden flag on existing results
+    state.results.forEach(r => {
+      r.hidden = tierSet ? !tierSet.includes(r.tier) : false
+    })
+    
+    return state.results  // 📖 Return same array, just updated hidden flags
+  }
+
   // 📖 Setup keyboard input for interactive selection during pings
   // 📖 Use readline with keypress event for arrow key handling
   process.stdin.setEncoding('utf8')
@@ -1129,7 +1165,26 @@ async function main() {
     // 📖 Minimum 1s, maximum 60s
     if (key.name === 'w') {
       state.pingInterval = Math.max(1000, state.pingInterval - 1000)
-      return
+    } else if (key.name === 'x') {
+      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)
     }
 
     if (key.name === 'x') {
@@ -1205,10 +1260,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))
+    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))
   }, 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))
+  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))
 
   // ── Continuous ping loop — ping all models every N seconds forever ──────────
 
@@ -1233,14 +1288,14 @@ async function main() {
   }
 
   // 📖 Initial ping of all models
-  const initialPing = Promise.all(results.map(r => pingModel(r)))
+  const initialPing = Promise.all(state.results.map(r => pingModel(r)))
 
   // 📖 Continuous ping loop with dynamic interval (adjustable with W/X keys)
   const schedulePing = () => {
     state.pingIntervalObj = setTimeout(async () => {
       state.lastPingTime = Date.now()
 
-      results.forEach(r => {
+      state.results.forEach(r => {
         pingModel(r).catch(() => {
           // Individual ping failures don't crash the loop
         })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "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",