free-coding-models 0.1.1 → 0.1.2

package/README.md

@@ -83,6 +83,12 @@ bunx free-coding-models YOUR_API_KEY
 ```bash
 # Just run it — will prompt for API key if not set
 free-coding-models
+
+# Show only top-tier models (A+, S, S+)
+free-coding-models --best
+
+# Analyze for 10 seconds and output the most reliable model
+free-coding-models --fiable
 ```
 
 **How it works:**
@@ -288,6 +294,10 @@ OpenCode will automatically detect this file when launched and guide you through
 - **Ping interval**: 2 seconds between complete re-pings of all models (adjustable with W/X keys)
 - **Monitor mode**: Interface stays open forever, press Ctrl+C to exit
 
+**Flags:**
+- **--best** — Show only top-tier models (A+, S, S+)
+- **--fiable** — Analyze for 10 seconds and output the most reliable model in format `provider/model_id`
+
 **Keyboard shortcuts:**
 - **↑↓** — Navigate models
 - **Enter** — Select model and launch OpenCode

package/bin/free-coding-models.js

@@ -615,15 +615,111 @@ After installation, you can use: opencode --model nvidia/${model.modelId}`
   }
 }
 
-// ─── Main ─────────────────────────────────────────────────────────────────────
+// ─── Helper function to find best model after analysis ────────────────────────
+function findBestModel(results) {
+  // 📖 Sort by avg ping (fastest first), then by uptime percentage (most reliable)
+  const sorted = [...results].sort((a, b) => {
+    const avgA = getAvg(a)
+    const avgB = getAvg(b)
+    const uptimeA = getUptime(a)
+    const uptimeB = getUptime(b)
+    
+    // 📖 Priority 1: Models that are up (status === 'up')
+    if (a.status === 'up' && b.status !== 'up') return -1
+    if (a.status !== 'up' && b.status === 'up') return 1
+    
+    // 📖 Priority 2: Fastest average ping
+    if (avgA !== avgB) return avgA - avgB
+    
+    // 📖 Priority 3: Highest uptime percentage
+    return uptimeB - uptimeA
+  })
+  
+  return sorted.length > 0 ? sorted[0] : null
+}
+
+// ─── Function to run in fiable mode (10-second analysis then output best model) ──
+async function runFiableMode(apiKey) {
+  console.log(chalk.cyan('  ⚡ Analyzing models for reliability (10 seconds)...'))
+  console.log()
+  
+  let results = MODELS.map(([modelId, label, tier], i) => ({
+    idx: i + 1, modelId, label, tier,
+    status: 'pending',
+    pings: [],
+    httpCode: null,
+  }))
+  
+  const startTime = Date.now()
+  const analysisDuration = 10000 // 10 seconds
+  
+  // 📖 Run initial pings
+  const pingPromises = results.map(r => ping(apiKey, r.modelId).then(({ code, ms }) => {
+    r.pings.push({ ms, code })
+    if (code === '200') {
+      r.status = 'up'
+    } else if (code === '000') {
+      r.status = 'timeout'
+    } else {
+      r.status = 'down'
+      r.httpCode = code
+    }
+  }))
+  
+  await Promise.allSettled(pingPromises)
+  
+  // 📖 Continue pinging for the remaining time
+  const remainingTime = Math.max(0, analysisDuration - (Date.now() - startTime))
+  if (remainingTime > 0) {
+    await new Promise(resolve => setTimeout(resolve, remainingTime))
+  }
+  
+  // 📖 Find best model
+  const best = findBestModel(results)
+  
+  if (!best) {
+    console.log(chalk.red('  ✖ No reliable model found'))
+    process.exit(1)
+  }
+  
+  // 📖 Output in format: provider/name
+  const provider = 'nvidia' // Always NVIDIA NIM for now
+  console.log(chalk.green(`  ✓ Most reliable model:`))
+  console.log(chalk.bold(`    ${provider}/${best.modelId}`))
+  console.log()
+  console.log(chalk.dim(`  📊 Stats:`))
+  console.log(chalk.dim(`    Avg ping: ${getAvg(best)}ms`))
+  console.log(chalk.dim(`    Uptime: ${getUptime(best)}%`))
+  console.log(chalk.dim(`    Status: ${best.status === 'up' ? '✅ UP' : '❌ DOWN'}`))
+  
+  process.exit(0)
+}
 
 async function main() {
+  // 📖 Parse CLI arguments properly
+  const args = process.argv.slice(2)
+  
+  // 📖 Extract API key (first non-flag argument) and flags
+  let apiKey = null
+  const flags = []
+  
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      flags.push(arg.toLowerCase())
+    } else if (!apiKey) {
+      apiKey = arg
+    }
+  }
+  
   // 📖 Priority: CLI arg > env var > saved config > wizard
-  let apiKey = process.argv[2] || process.env.NVIDIA_API_KEY || loadApiKey()
+  if (!apiKey) {
+    apiKey = process.env.NVIDIA_API_KEY || loadApiKey()
+  }
+  
+  // 📖 Check for CLI flags
+  const bestMode = flags.includes('--best')
+  const fiableMode = flags.includes('--fiable') || flags.includes('--fiable') // Support both
   
-  // 📖 Check for BEST flag - only show top tiers (A+, S, S+)
-  const bestMode = process.argv.includes('--BEST') || process.argv.includes('--best')
-
   if (!apiKey) {
     apiKey = await promptApiKey()
     if (!apiKey) {
@@ -634,6 +730,11 @@ async function main() {
       process.exit(1)
     }
   }
+  
+  // 📖 Handle fiable mode first (it exits after analysis)
+  if (fiableMode) {
+    await runFiableMode(apiKey)
+  }
 
   // 📖 Filter models to only show top tiers if BEST mode is active
   let results = MODELS.map(([modelId, label, tier], i) => ({
@@ -660,7 +761,8 @@ async function main() {
     sortColumn: 'avg',
     sortDirection: 'asc',
     pingInterval: PING_INTERVAL,  // 📖 Track current interval for C/V keys
-    lastPingTime: Date.now()  // 📖 Track when last ping cycle started
+    lastPingTime: Date.now(),  // 📖 Track when last ping cycle started
+    fiableMode  // 📖 Pass fiable mode to state
   }
 
   // 📖 Enter alternate screen — animation runs here, zero scrollback pollution
@@ -841,4 +943,4 @@ main().catch((err) => {
   process.stdout.write(ALT_LEAVE)
   console.error(err)
   process.exit(1)
-})
+})

package/package.json

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