free-coding-models 0.1.37 → 0.1.39

package/bin/free-coding-models.js

@@ -75,7 +75,7 @@ import chalk from 'chalk'
 import { createRequire } from 'module'
 import { readFileSync, writeFileSync, existsSync, copyFileSync, mkdirSync } from 'fs'
 import { homedir } from 'os'
-import { join } from 'path'
+import { join, dirname } from 'path'
 import { MODELS } from '../sources.js'
 import { patchOpenClawModelsJson } from '../patch-openclaw-models.js'
 import { getAvg, getVerdict, getUptime, sortResults, filterByTier, findBestModel, parseArgs, TIER_ORDER, VERDICT_ORDER, TIER_LETTER_MAP } from '../lib/utils.js'
@@ -421,6 +421,7 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
   // 📖 Column widths (generous spacing with margins)
   const W_RANK = 6
   const W_TIER = 6
+  const W_CTW = 6
   const W_SOURCE = 14
   const W_MODEL = 26
   const W_SWE = 9
@@ -453,6 +454,7 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
   const originH  = 'Origin'
   const modelH   = 'Model'
   const sweH     = sortColumn === 'swe' ? dir + ' SWE%' : 'SWE%'
+  const ctwH     = sortColumn === 'ctw' ? dir + ' CTW' : 'CTW'
   const pingH    = sortColumn === 'ping' ? dir + ' Latest Ping' : 'Latest Ping'
   const avgH     = sortColumn === 'avg' ? dir + ' Avg Ping' : 'Avg Ping'
   const healthH  = sortColumn === 'condition' ? dir + ' Health' : 'Health'
@@ -475,14 +477,15 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
   const originH_c  = sortColumn === 'origin' ? chalk.bold.cyan(originH.padEnd(W_SOURCE)) : colorFirst(originH, W_SOURCE)
   const modelH_c   = colorFirst(modelH, W_MODEL)
   const sweH_c     = sortColumn === 'swe' ? chalk.bold.cyan(sweH.padEnd(W_SWE)) : colorFirst(sweH, W_SWE)
+  const ctwH_c     = sortColumn === 'ctw' ? chalk.bold.cyan(ctwH.padEnd(W_CTW)) : colorFirst(ctwH, W_CTW)
   const pingH_c    = sortColumn === 'ping' ? chalk.bold.cyan(pingH.padEnd(W_PING)) : colorFirst('Latest Ping', W_PING)
   const avgH_c     = sortColumn === 'avg' ? chalk.bold.cyan(avgH.padEnd(W_AVG)) : colorFirst('Avg Ping', W_AVG)
   const healthH_c  = sortColumn === 'condition' ? chalk.bold.cyan(healthH.padEnd(W_STATUS)) : colorFirst('Health', W_STATUS)
   const verdictH_c = sortColumn === 'verdict' ? chalk.bold.cyan(verdictH.padEnd(W_VERDICT)) : colorFirst(verdictH, W_VERDICT)
   const uptimeH_c  = sortColumn === 'uptime' ? chalk.bold.cyan(uptimeH.padStart(W_UPTIME)) : colorFirst(uptimeH, W_UPTIME, chalk.green)
 
-  // 📖 Header with proper spacing
-  lines.push('  ' + rankH_c + '  ' + tierH_c + '  ' + sweH_c + '  ' + modelH_c + '  ' + originH_c + '  ' + pingH_c + '  ' + avgH_c + '  ' + healthH_c + '  ' + verdictH_c + '  ' + uptimeH_c)
+  // 📖 Header with proper spacing (column order: Rank, Tier, SWE%, CTW, Model, Origin, Latest Ping, Avg Ping, Health, Verdict, Up%)
+  lines.push('  ' + rankH_c + '  ' + tierH_c + '  ' + sweH_c + '  ' + ctwH_c + '  ' + modelH_c + '  ' + originH_c + '  ' + pingH_c + '  ' + avgH_c + '  ' + healthH_c + '  ' + verdictH_c + '  ' + uptimeH_c)
 
   // 📖 Separator line
   lines.push(
@@ -490,6 +493,7 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
     chalk.dim('─'.repeat(W_RANK)) + '  ' +
     chalk.dim('─'.repeat(W_TIER)) + '  ' +
     chalk.dim('─'.repeat(W_SWE)) + '  ' +
+    chalk.dim('─'.repeat(W_CTW)) + '  ' +
     '─'.repeat(W_MODEL) + '  ' +
     '─'.repeat(W_SOURCE) + '  ' +
     chalk.dim('─'.repeat(W_PING)) + '  ' +
@@ -523,6 +527,14 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
       : sweScore !== '—' && parseFloat(sweScore) >= 30
       ? chalk.yellow(sweScore.padEnd(W_SWE))
       : chalk.dim(sweScore.padEnd(W_SWE))
+    
+    // 📖 Context window column - colorized by size (larger = better)
+    const ctwRaw = r.ctw ?? '—'
+    const ctwCell = ctwRaw !== '—' && (ctwRaw.includes('128k') || ctwRaw.includes('200k') || ctwRaw.includes('1m'))
+      ? chalk.greenBright(ctwRaw.padEnd(W_CTW))
+      : ctwRaw !== '—' && (ctwRaw.includes('32k') || ctwRaw.includes('64k'))
+      ? chalk.cyan(ctwRaw.padEnd(W_CTW))
+      : chalk.dim(ctwRaw.padEnd(W_CTW))
 
     // 📖 Latest ping - pings are objects: { ms, code }
     // 📖 Only show response time for successful pings, "—" for errors (error code is in Status column)
@@ -628,8 +640,8 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
       uptimeCell = chalk.red(uptimeStr.padStart(W_UPTIME))
     }
 
-    // 📖 Build row with double space between columns
-    const row = '  ' + num + '  ' + tier + '  ' + sweCell + '  ' + name + '  ' + source + '  ' + pingCell + '  ' + avgCell + '  ' + status + '  ' + speedCell + '  ' + uptimeCell
+    // 📖 Build row with double space between columns (order: Rank, Tier, SWE%, CTW, Model, Origin, Latest Ping, Avg Ping, Health, Verdict, Up%)
+    const row = '  ' + num + '  ' + tier + '  ' + sweCell + '  ' + ctwCell + '  ' + name + '  ' + source + '  ' + pingCell + '  ' + avgCell + '  ' + status + '  ' + speedCell + '  ' + uptimeCell
 
     if (isCursor) {
       lines.push(chalk.bgRgb(139, 0, 139)(row))
@@ -651,7 +663,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/L/A/S/H/V/U Sort  •  W↓/X↑ Interval (${intervalSec}s)  •  T Tier  •  Z Mode  •  Ctrl+C Exit`))
+  lines.push(chalk.dim(`  ↑↓ Navigate  •  `) + actionHint + chalk.dim(`  •  R/T/O/M/L/A/S/C/H/V/U Sort  •  W↓/X↑ Interval (${intervalSec}s)  •  T Tier  •  Z Mode  •  Ctrl+C Exit`))
   lines.push('')
   lines.push(chalk.dim('  Made with ') + '💖 & ☕' + chalk.dim(' by ') + '\x1b]8;;https://github.com/vava-nessa\x1b\\vava-nessa\x1b]8;;\x1b\\' + chalk.dim('  •  ') + '💬 ' + chalk.cyanBright('\x1b]8;;https://discord.gg/WKA3TwYVuZ\x1b\\Join Free-Coding-Models Discord!\x1b]8;;\x1b\\') + chalk.dim('  •  ') + '⭐ ' + '\x1b]8;;https://github.com/vava-nessa/free-coding-models\x1b\\Read the docs on GitHub\x1b]8;;\x1b\\')
   lines.push('')
@@ -690,23 +702,44 @@ async function ping(apiKey, modelId) {
 }
 
 // ─── OpenCode integration ──────────────────────────────────────────────────────
-const OPENCODE_CONFIG = join(homedir(), '.config/opencode/opencode.json')
+// 📖 Platform-specific config path
+const isWindows = process.platform === 'win32'
+const isMac = process.platform === 'darwin'
+const isLinux = process.platform === 'linux'
+
+// 📖 OpenCode config location varies by platform
+// 📖 Windows: %APPDATA%\opencode\opencode.json (or sometimes ~/.config/opencode)
+// 📖 macOS/Linux: ~/.config/opencode/opencode.json
+const OPENCODE_CONFIG = isWindows 
+  ? join(homedir(), 'AppData', 'Roaming', 'opencode', 'opencode.json')
+  : join(homedir(), '.config', 'opencode', 'opencode.json')
+
+// 📖 Fallback to .config on Windows if AppData doesn't exist
+const OPENCODE_CONFIG_FALLBACK = join(homedir(), '.config', 'opencode', 'opencode.json')
+
+function getOpenCodeConfigPath() {
+  if (existsSync(OPENCODE_CONFIG)) return OPENCODE_CONFIG
+  if (isWindows && existsSync(OPENCODE_CONFIG_FALLBACK)) return OPENCODE_CONFIG_FALLBACK
+  return OPENCODE_CONFIG
+}
 
 function loadOpenCodeConfig() {
-  if (!existsSync(OPENCODE_CONFIG)) return { provider: {} }
+  const configPath = getOpenCodeConfigPath()
+  if (!existsSync(configPath)) return { provider: {} }
   try {
-    return JSON.parse(readFileSync(OPENCODE_CONFIG, 'utf8'))
+    return JSON.parse(readFileSync(configPath, 'utf8'))
   } catch {
     return { provider: {} }
   }
 }
 
 function saveOpenCodeConfig(config) {
-  const dir = join(homedir(), '.config/opencode')
+  const configPath = getOpenCodeConfigPath()
+  const dir = dirname(configPath)
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true })
   }
-  writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2))
+  writeFileSync(configPath, JSON.stringify(config, null, 2))
 }
 
 // ─── Check NVIDIA NIM in OpenCode config ───────────────────────────────────────
@@ -739,11 +772,11 @@ async function startOpenCode(model) {
     console.log()
 
     const config = loadOpenCodeConfig()
-    const backupPath = `${OPENCODE_CONFIG}.backup-${Date.now()}`
+    const backupPath = `${getOpenCodeConfigPath()}.backup-${Date.now()}`
 
     // 📖 Backup current config
-    if (existsSync(OPENCODE_CONFIG)) {
-      copyFileSync(OPENCODE_CONFIG, backupPath)
+    if (existsSync(getOpenCodeConfigPath())) {
+      copyFileSync(getOpenCodeConfigPath(), backupPath)
       console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
     }
 
@@ -762,16 +795,28 @@ async function startOpenCode(model) {
 
     saveOpenCodeConfig(config)
 
-    console.log(chalk.green(`  ✓ Default model set to: nvidia/${model.modelId}`))
+    // 📖 Verify config was saved correctly
+    const savedConfig = loadOpenCodeConfig()
+    console.log(chalk.dim(`  📝 Config saved to: ${getOpenCodeConfigPath()}`))
+    console.log(chalk.dim(`  📝 Default model in config: ${savedConfig.model || 'NOT SET'}`))
+    console.log()
+    
+    if (savedConfig.model === config.model) {
+      console.log(chalk.green(`  ✓ Default model set to: nvidia/${model.modelId}`))
+    } else {
+      console.log(chalk.yellow(`  ⚠ Config might not have been saved correctly`))
+    }
     console.log()
     console.log(chalk.dim('  Starting OpenCode…'))
     console.log()
 
     // 📖 Launch OpenCode and wait for it
+    // 📖 Use --model flag to ensure the model is selected
     const { spawn } = await import('child_process')
-    const child = spawn('opencode', [], {
+    const child = spawn('opencode', ['--model', `nvidia/${model.modelId}`], {
       stdio: 'inherit',
-      shell: true
+      shell: true,
+      detached: false
     })
 
     // 📖 Wait for OpenCode to exit
@@ -794,7 +839,8 @@ async function startOpenCode(model) {
     console.log(chalk.dim('  Starting OpenCode with installation prompt…'))
     console.log()
 
-    const installPrompt = `Please install NVIDIA NIM provider in OpenCode by adding this to ~/.config/opencode/opencode.json:
+    const configPath = getOpenCodeConfigPath()
+    const installPrompt = `Please install NVIDIA NIM provider in OpenCode by adding this to ${configPath}:
 
 {
   "provider": {
@@ -809,7 +855,7 @@ async function startOpenCode(model) {
   }
 }
 
-Then set env var: export NVIDIA_API_KEY=your_key_here
+${isWindows ? 'set NVIDIA_API_KEY=your_key_here' : 'export NVIDIA_API_KEY=your_key_here'}
 
 After installation, you can use: opencode --model nvidia/${model.modelId}`
 
@@ -821,7 +867,8 @@ After installation, you can use: opencode --model nvidia/${model.modelId}`
     const { spawn } = await import('child_process')
     const child = spawn('opencode', [], {
       stdio: 'inherit',
-      shell: true
+      shell: true,
+      detached: false
     })
 
     // 📖 Wait for OpenCode to exit
@@ -842,7 +889,7 @@ After installation, you can use: opencode --model nvidia/${model.modelId}`
 
 // ─── Start OpenCode Desktop ─────────────────────────────────────────────────────
 // 📖 startOpenCodeDesktop: Same config logic as startOpenCode, but opens the Desktop app.
-// 📖 OpenCode Desktop (/Applications/OpenCode.app) shares config at ~/.config/opencode/opencode.json.
+// 📖 OpenCode Desktop shares config at the same location as CLI.
 // 📖 No need to wait for exit — Desktop app stays open independently.
 async function startOpenCodeDesktop(model) {
   const hasNim = checkNvidiaNimConfig()
@@ -853,10 +900,10 @@ async function startOpenCodeDesktop(model) {
     console.log()
 
     const config = loadOpenCodeConfig()
-    const backupPath = `${OPENCODE_CONFIG}.backup-${Date.now()}`
+    const backupPath = `${getOpenCodeConfigPath()}.backup-${Date.now()}`
 
-    if (existsSync(OPENCODE_CONFIG)) {
-      copyFileSync(OPENCODE_CONFIG, backupPath)
+    if (existsSync(getOpenCodeConfigPath())) {
+      copyFileSync(getOpenCodeConfigPath(), backupPath)
       console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
     }
 
@@ -871,23 +918,58 @@ async function startOpenCodeDesktop(model) {
 
     saveOpenCodeConfig(config)
 
-    console.log(chalk.green(`  ✓ Default model set to: nvidia/${model.modelId}`))
+    // 📖 Verify config was saved correctly
+    const savedConfig = loadOpenCodeConfig()
+    console.log(chalk.dim(`  📝 Config saved to: ${getOpenCodeConfigPath()}`))
+    console.log(chalk.dim(`  📝 Default model in config: ${savedConfig.model || 'NOT SET'}`))
+    console.log()
+    
+    if (savedConfig.model === config.model) {
+      console.log(chalk.green(`  ✓ Default model set to: nvidia/${model.modelId}`))
+    } else {
+      console.log(chalk.yellow(`  ⚠ Config might not have been saved correctly`))
+    }
     console.log()
     console.log(chalk.dim('  Opening OpenCode Desktop…'))
     console.log()
 
-    // 📖 Launch Desktop app — no need to wait, it stays open independently
+    // 📖 Launch Desktop app based on platform
     const { exec } = await import('child_process')
-    exec('open -a OpenCode', (err) => {
+    
+    let command
+    if (isMac) {
+      command = 'open -a OpenCode'
+    } else if (isWindows) {
+      // 📖 On Windows, try common installation paths
+      // 📖 User installation: %LOCALAPPDATA%\Programs\OpenCode\OpenCode.exe
+      // 📖 System installation: C:\Program Files\OpenCode\OpenCode.exe
+      command = 'start "" "%LOCALAPPDATA%\\Programs\\OpenCode\\OpenCode.exe" 2>nul || start "" "%PROGRAMFILES%\\OpenCode\\OpenCode.exe" 2>nul || start OpenCode'
+    } else if (isLinux) {
+      // 📖 On Linux, try different methods with model flag
+      // 📖 Check if opencode-desktop exists, otherwise try xdg-open
+      command = `opencode-desktop --model nvidia/${model.modelId} 2>/dev/null || flatpak run ai.opencode.OpenCode --model nvidia/${model.modelId} 2>/dev/null || snap run opencode --model nvidia/${model.modelId} 2>/dev/null || xdg-open /usr/share/applications/opencode.desktop 2>/dev/null || echo "OpenCode not found"`
+    }
+
+    exec(command, (err, stdout, stderr) => {
       if (err) {
-        console.error(chalk.red('  ✗ Could not open OpenCode Desktop — is it installed at /Applications/OpenCode.app?'))
+        console.error(chalk.red('  ✗ Could not open OpenCode Desktop'))
+        if (isWindows) {
+          console.error(chalk.dim('    Make sure OpenCode is installed from https://opencode.ai'))
+        } else if (isLinux) {
+          console.error(chalk.dim('    Install via: snap install opencode OR flatpak install ai.opencode.OpenCode'))
+          console.error(chalk.dim('    Or download from https://opencode.ai'))
+        } else {
+          console.error(chalk.dim('    Is it installed at /Applications/OpenCode.app?'))
+        }
       }
     })
   } else {
     console.log(chalk.yellow('  ⚠ NVIDIA NIM not configured in OpenCode'))
     console.log(chalk.dim('  Please configure it first. Config is shared between CLI and Desktop.'))
     console.log()
-    const installPrompt = `Add this to ~/.config/opencode/opencode.json:
+    
+    const configPath = getOpenCodeConfigPath()
+    const installPrompt = `Add this to ${configPath}:
 
 {
   "provider": {
@@ -902,7 +984,7 @@ async function startOpenCodeDesktop(model) {
   }
 }
 
-Then set env var: export NVIDIA_API_KEY=your_key_here`
+${isWindows ? 'set NVIDIA_API_KEY=your_key_here' : 'export NVIDIA_API_KEY=your_key_here'}`
     console.log(chalk.cyan(installPrompt))
     console.log()
   }
@@ -1023,8 +1105,8 @@ async function runFiableMode(apiKey) {
   console.log(chalk.cyan('  ⚡ Analyzing models for reliability (10 seconds)...'))
   console.log()
 
-  let results = MODELS.map(([modelId, label, tier, sweScore], i) => ({
-    idx: i + 1, modelId, label, tier, sweScore,
+  let results = MODELS.map(([modelId, label, tier, sweScore, ctw], i) => ({
+    idx: i + 1, modelId, label, tier, sweScore, ctw,
     status: 'pending',
     pings: [],
     httpCode: null,
@@ -1114,8 +1196,8 @@ async function main() {
   // 📖 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, sweScore], i) => ({
-    idx: i + 1, modelId, label, tier, sweScore,
+  let results = MODELS.map(([modelId, label, tier, sweScore, ctw], i) => ({
+    idx: i + 1, modelId, label, tier, sweScore, ctw,
     status: 'pending',
     pings: [],  // 📖 All ping results (ms or 'TIMEOUT')
     httpCode: null,
@@ -1224,10 +1306,10 @@ async function main() {
   const onKeyPress = async (str, key) => {
     if (!key) return
 
-    // 📖 Sorting keys: R=rank, T=tier, O=origin, M=model, L=latest ping, A=avg ping, S=SWE-bench, H=health, V=verdict, U=uptime
+    // 📖 Sorting keys: R=rank, T=tier, O=origin, M=model, L=latest ping, A=avg ping, S=SWE-bench, C=context window, H=health, V=verdict, U=uptime
     const sortKeys = {
       'r': 'rank', 't': 'tier', 'o': 'origin', 'm': 'model',
-      'l': 'ping', 'a': 'avg', 's': 'swe', 'h': 'condition', 'v': 'verdict', 'u': 'uptime'
+      'l': 'ping', 'a': 'avg', 's': 'swe', 'c': 'ctw', 'h': 'condition', 'v': 'verdict', 'u': 'uptime'
     }
 
     if (sortKeys[key.name]) {

package/lib/utils.js

@@ -136,6 +136,7 @@ export const getUptime = (r) => {
 //   - 'ping'    (L key) — last ping latency (only successful ones count)
 //   - 'avg'     (A key) — average latency across all successful pings
 //   - 'swe'     (S key) — SWE-bench score (higher is better)
+//   - 'ctw'     (C key) — context window size (larger is better)
 //   - 'condition' (H key) — health status (alphabetical)
 //   - 'verdict' (V key) — verdict order (Perfect → Pending)
 //   - 'uptime'  (U key) — uptime percentage
@@ -184,6 +185,27 @@ export const sortResults = (results, sortColumn, sortDirection) => {
         cmp = parseSwe(a.sweScore) - parseSwe(b.sweScore)
         break
       }
+      case 'ctw': {
+        // 📖 Sort by context window size — larger is better
+        // 📖 Parse strings like "128k", "32k", "1m" into numeric tokens
+        const parseCtw = (ctw) => {
+          if (!ctw || ctw === '—') return 0
+          const str = ctw.toLowerCase()
+          // 📖 Handle millions (1m = 1000k)
+          if (str.includes('m')) {
+            const num = parseFloat(str.replace('m', ''))
+            return num * 1000
+          }
+          // 📖 Handle thousands (128k)
+          if (str.includes('k')) {
+            const num = parseFloat(str.replace('k', ''))
+            return num
+          }
+          return 0
+        }
+        cmp = parseCtw(a.ctw) - parseCtw(b.ctw)
+        break
+      }
       case 'condition':
         cmp = a.status.localeCompare(b.status)
         break

package/package.json

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

package/sources.js

@@ -4,20 +4,26 @@
  *
  * @details
  *   This file contains all model definitions organized by provider/source.
- *   Each source has its own models array with [model_id, display_label, tier].
- *   Add new sources here to support additional providers beyond NVIDIA NIM.
+ *   Each source has its own models array with [model_id, display_label, tier, swe_score, ctw].
+ *   - model_id: The model identifier for API calls
+ *   - display_label: Human-friendly name for display
+ *   - tier: Performance tier (S+, S, A+, A, A-, B+, B, C)
+ *   - swe_score: SWE-bench Verified score percentage
+ *   - ctw: Context window size in tokens (e.g., "128k", "32k")
+ *   
+ *   Add new sources here to support additional providers beyond NIM.
  *
- *   🎯 Tier scale (based on Aider Polyglot benchmark):
- *   - S+: 75%+ (elite frontier coders)
- *   - S:  62-74% (excellent)
- *   - A+: 54-62% (great)
- *   - A:  44-54% (good)
- *   - A-: 36-44% (decent)
- *   - B+: 25-36% (average)
- *   - B:  14-25% (below average)
- *   - C:  <14% (lightweight/edge)
+ *   🎯 Tier scale (based on SWE-bench Verified):
+ *   - S+: 70%+ (elite frontier coders)
+ *   - S:  60-70% (excellent)
+ *   - A+: 50-60% (great)
+ *   - A:  40-50% (good)
+ *   - A-: 35-45% (decent)
+ *   - B+: 30-40% (average)
+ *   - B:  20-30% (below average)
+ *   - C:  <20% (lightweight/edge)
  *
- *   📖 Source: https://aider.chat/docs/leaderboards (Polyglot = 225 exercises, 6 languages)
+ *   📖 Source: https://www.swebench.com
  *
  *   @exports Object containing all sources and their models
  */
@@ -25,57 +31,57 @@
 // 📖 NIM source - https://build.nvidia.com
 export const nvidiaNim = [
   // ── S+ tier — SWE-bench Verified ≥70% ──
-  ['deepseek-ai/deepseek-v3.1',                    'DeepSeek V3.1',       'S+', '49.2%'], // 49.2% SWE-bench Verified
-  ['deepseek-ai/deepseek-v3.1-terminus',           'DeepSeek V3.1 Term',  'S+', '49.2%'], // same base V3.1
-  ['deepseek-ai/deepseek-v3.2',                    'DeepSeek V3.2',       'S+', '73.1%'], // 73.1% SWE-bench Verified
-  ['moonshotai/kimi-k2.5',                         'Kimi K2.5',           'S+', '76.8%'], // 76.8% SWE-bench Verified
-  ['mistralai/devstral-2-123b-instruct-2512',      'Devstral 2 123B',     'S+', '62.0%'], // 62.0% SWE-bench (est.)
-  ['nvidia/llama-3.1-nemotron-ultra-253b-v1',      'Nemotron Ultra 253B', 'S+', '56.0%'], // 56.0% SWE-bench (est.)
-  ['mistralai/mistral-large-3-675b-instruct-2512', 'Mistral Large 675B',  'S+', '58.0%'], // 58.0% SWE-bench (est.)
+  ['deepseek-ai/deepseek-v3.1',                    'DeepSeek V3.1',       'S+', '49.2%', '128k'],
+  ['deepseek-ai/deepseek-v3.1-terminus',           'DeepSeek V3.1 Term',  'S+', '49.2%', '128k'],
+  ['deepseek-ai/deepseek-v3.2',                    'DeepSeek V3.2',       'S+', '73.1%', '128k'],
+  ['moonshotai/kimi-k2.5',                         'Kimi K2.5',           'S+', '76.8%', '128k'],
+  ['mistralai/devstral-2-123b-instruct-2512',      'Devstral 2 123B',     'S+', '62.0%', '128k'],
+  ['nvidia/llama-3.1-nemotron-ultra-253b-v1',      'Nemotron Ultra 253B', 'S+', '56.0%', '128k'],
+  ['mistralai/mistral-large-3-675b-instruct-2512', 'Mistral Large 675B',  'S+', '58.0%', '128k'],
   // ── S tier — SWE-bench Verified 50–70% ──
-  ['qwen/qwen2.5-coder-32b-instruct',              'Qwen2.5 Coder 32B',   'S', '46.0%'], // 46.0% SWE-bench Verified
-  ['z-ai/glm5',                                    'GLM 5',               'S', '77.8%'], // 77.8% SWE-bench Verified
-  ['qwen/qwen3.5-397b-a17b',                       'Qwen3.5 400B VLM',    'S', '68.0%'], // 68.0% SWE-bench (est.)
-  ['qwen/qwen3-coder-480b-a35b-instruct',          'Qwen3 Coder 480B',    'S', '72.0%'], // 72.0% SWE-bench (est.)
-  ['qwen/qwen3-next-80b-a3b-thinking',             'Qwen3 80B Thinking',  'S', '68.0%'], // 68.0% SWE-bench (est.)
-  ['meta/llama-3.1-405b-instruct',                 'Llama 3.1 405B',      'S', '44.0%'], // 44.0% SWE-bench (est.)
-  ['minimaxai/minimax-m2.1',                       'MiniMax M2.1',        'S', '70.0%'], // 70.0% SWE-bench (est.)
+  ['qwen/qwen2.5-coder-32b-instruct',              'Qwen2.5 Coder 32B',   'S', '46.0%', '32k'],
+  ['z-ai/glm5',                                    'GLM 5',               'S', '77.8%', '128k'],
+  ['qwen/qwen3.5-397b-a17b',                       'Qwen3.5 400B VLM',    'S', '68.0%', '128k'],
+  ['qwen/qwen3-coder-480b-a35b-instruct',          'Qwen3 Coder 480B',    'S', '72.0%', '128k'],
+  ['qwen/qwen3-next-80b-a3b-thinking',             'Qwen3 80B Thinking',  'S', '68.0%', '128k'],
+  ['meta/llama-3.1-405b-instruct',                 'Llama 3.1 405B',      'S', '44.0%', '128k'],
+  ['minimaxai/minimax-m2.1',                       'MiniMax M2.1',        'S', '70.0%', '128k'],
   // ── A+ tier — SWE-bench Verified 60–70% ──
-  ['moonshotai/kimi-k2-thinking',                  'Kimi K2 Thinking',    'A+', '67.0%'], // 67.0% SWE-bench (est.)
-  ['moonshotai/kimi-k2-instruct',                  'Kimi K2 Instruct',    'A+', '65.8%'], // 65.8% SWE-bench Verified
-  ['qwen/qwen3-235b-a22b',                         'Qwen3 235B',          'A+', '70.0%'], // 70.0% SWE-bench (est.)
-  ['meta/llama-3.3-70b-instruct',                  'Llama 3.3 70B',       'A+', '39.5%'], // 39.5% SWE-bench (est.)
-  ['z-ai/glm4.7',                                  'GLM 4.7',             'A+', '73.8%'], // 73.8% SWE-bench Verified
-  ['qwen/qwen3-next-80b-a3b-instruct',             'Qwen3 80B Instruct',  'A+', '65.0%'], // 65.0% SWE-bench (est.)
+  ['moonshotai/kimi-k2-thinking',                  'Kimi K2 Thinking',    'A+', '67.0%', '128k'],
+  ['moonshotai/kimi-k2-instruct',                  'Kimi K2 Instruct',    'A+', '65.8%', '128k'],
+  ['qwen/qwen3-235b-a22b',                         'Qwen3 235B',          'A+', '70.0%', '128k'],
+  ['meta/llama-3.3-70b-instruct',                  'Llama 3.3 70B',       'A+', '39.5%', '128k'],
+  ['z-ai/glm4.7',                                  'GLM 4.7',             'A+', '73.8%', '128k'],
+  ['qwen/qwen3-next-80b-a3b-instruct',             'Qwen3 80B Instruct',  'A+', '65.0%', '128k'],
   // ── A tier — SWE-bench Verified 45–60% ──
-  ['minimaxai/minimax-m2',                         'MiniMax M2',          'A', '56.5%'], // 56.5% SWE-bench (est.)
-  ['mistralai/mistral-medium-3-instruct',          'Mistral Medium 3',    'A', '48.0%'], // 48.0% SWE-bench (est.)
-  ['mistralai/magistral-small-2506',               'Magistral Small',     'A', '45.0%'], // 45.0% SWE-bench (est.)
-  ['nvidia/nemotron-3-nano-30b-a3b',               'Nemotron Nano 30B',   'A', '43.0%'], // 43.0% SWE-bench (est.)
-  ['deepseek-ai/deepseek-r1-distill-qwen-32b',     'R1 Distill 32B',      'A', '43.9%'], // 43.9% SWE-bench Verified
+  ['minimaxai/minimax-m2',                         'MiniMax M2',          'A', '56.5%', '128k'],
+  ['mistralai/mistral-medium-3-instruct',          'Mistral Medium 3',    'A', '48.0%', '128k'],
+  ['mistralai/magistral-small-2506',               'Magistral Small',     'A', '45.0%', '32k'],
+  ['nvidia/nemotron-3-nano-30b-a3b',               'Nemotron Nano 30B',   'A', '43.0%', '128k'],
+  ['deepseek-ai/deepseek-r1-distill-qwen-32b',     'R1 Distill 32B',      'A', '43.9%', '128k'],
   // ── A- tier — SWE-bench Verified 35–45% ──
-  ['openai/gpt-oss-120b',                          'GPT OSS 120B',        'A-', '60.0%'], // 60.0% SWE-bench (est.)
-  ['nvidia/llama-3.3-nemotron-super-49b-v1.5',     'Nemotron Super 49B',  'A-', '49.0%'], // 49.0% SWE-bench (est.)
-  ['meta/llama-4-scout-17b-16e-instruct',          'Llama 4 Scout',       'A-', '44.0%'], // 44.0% SWE-bench (est.)
-  ['deepseek-ai/deepseek-r1-distill-qwen-14b',     'R1 Distill 14B',      'A-', '37.7%'], // 37.7% SWE-bench (est.)
-  ['igenius/colosseum_355b_instruct_16k',          'Colosseum 355B',      'A-', '52.0%'], // 52.0% SWE-bench (est.)
+  ['openai/gpt-oss-120b',                          'GPT OSS 120B',        'A-', '60.0%', '128k'],
+  ['nvidia/llama-3.3-nemotron-super-49b-v1.5',     'Nemotron Super 49B',  'A-', '49.0%', '128k'],
+  ['meta/llama-4-scout-17b-16e-instruct',          'Llama 4 Scout',       'A-', '44.0%', '128k'],
+  ['deepseek-ai/deepseek-r1-distill-qwen-14b',     'R1 Distill 14B',      'A-', '37.7%', '64k'],
+  ['igenius/colosseum_355b_instruct_16k',          'Colosseum 355B',      'A-', '52.0%', '16k'],
   // ── B+ tier — SWE-bench Verified 30–40% ──
-  ['qwen/qwq-32b',                                 'QwQ 32B',            'B+', '50.0%'], // 50.0% SWE-bench (est.)
-  ['openai/gpt-oss-20b',                           'GPT OSS 20B',        'B+', '42.0%'], // 42.0% SWE-bench (est.)
-  ['stockmark/stockmark-2-100b-instruct',          'Stockmark 100B',     'B+', '36.0%'], // 36.0% SWE-bench (est.)
-  ['bytedance/seed-oss-36b-instruct',              'Seed OSS 36B',       'B+', '38.0%'], // 38.0% SWE-bench (est.)
-  ['stepfun-ai/step-3.5-flash',                    'Step 3.5 Flash',      'B+', '74.4%'], // 74.4% SWE-bench Verified
+  ['qwen/qwq-32b',                                 'QwQ 32B',            'B+', '50.0%', '32k'],
+  ['openai/gpt-oss-20b',                           'GPT OSS 20B',        'B+', '42.0%', '32k'],
+  ['stockmark/stockmark-2-100b-instruct',          'Stockmark 100B',     'B+', '36.0%', '32k'],
+  ['bytedance/seed-oss-36b-instruct',              'Seed OSS 36B',       'B+', '38.0%', '32k'],
+  ['stepfun-ai/step-3.5-flash',                    'Step 3.5 Flash',      'B+', '74.4%', '32k'],
   // ── B tier — SWE-bench Verified 20–35% ──
-  ['meta/llama-4-maverick-17b-128e-instruct',      'Llama 4 Maverick',    'B', '62.0%'], // 62.0% SWE-bench (est.)
-  ['mistralai/mixtral-8x22b-instruct-v0.1',        'Mixtral 8x22B',       'B', '32.0%'], // 32.0% SWE-bench (est.)
-  ['mistralai/ministral-14b-instruct-2512',        'Ministral 14B',       'B', '34.0%'], // 34.0% SWE-bench (est.)
-  ['ibm/granite-34b-code-instruct',                'Granite 34B Code',    'B', '30.0%'], // 30.0% SWE-bench (est.)
-  ['deepseek-ai/deepseek-r1-distill-llama-8b',     'R1 Distill 8B',       'B', '28.2%'], // 28.2% SWE-bench (est.)
+  ['meta/llama-4-maverick-17b-128e-instruct',      'Llama 4 Maverick',    'B', '62.0%', '128k'],
+  ['mistralai/mixtral-8x22b-instruct-v0.1',        'Mixtral 8x22B',       'B', '32.0%', '64k'],
+  ['mistralai/ministral-14b-instruct-2512',        'Ministral 14B',       'B', '34.0%', '32k'],
+  ['ibm/granite-34b-code-instruct',                'Granite 34B Code',    'B', '30.0%', '32k'],
+  ['deepseek-ai/deepseek-r1-distill-llama-8b',     'R1 Distill 8B',       'B', '28.2%', '32k'],
   // ── C tier — SWE-bench Verified <25% or lightweight edge models ──
-  ['deepseek-ai/deepseek-r1-distill-qwen-7b',      'R1 Distill 7B',       'C', '22.6%'], // 22.6% SWE-bench (est.)
-  ['google/gemma-2-9b-it',                         'Gemma 2 9B',          'C', '18.0%'], // 18.0% SWE-bench (est.)
-  ['microsoft/phi-3.5-mini-instruct',              'Phi 3.5 Mini',        'C', '12.0%'], // 12.0% SWE-bench (est.)
-  ['microsoft/phi-4-mini-instruct',                'Phi 4 Mini',          'C', '14.0%'], // 14.0% SWE-bench (est.)
+  ['deepseek-ai/deepseek-r1-distill-qwen-7b',      'R1 Distill 7B',       'C', '22.6%', '32k'],
+  ['google/gemma-2-9b-it',                         'Gemma 2 9B',          'C', '18.0%', '8k'],
+  ['microsoft/phi-3.5-mini-instruct',              'Phi 3.5 Mini',        'C', '12.0%', '128k'],
+  ['microsoft/phi-4-mini-instruct',                'Phi 4 Mini',          'C', '14.0%', '128k'],
 ]
 
 // 📖 All sources combined - used by the main script
@@ -84,21 +90,12 @@ export const sources = {
     name: 'NIM',
     models: nvidiaNim,
   },
-  // 📖 Add more sources here in the future, for example:
-  // openai: {
-  //   name: 'OpenAI',
-  //   models: [...],
-  // },
-  // anthropic: {
-  //   name: 'Anthropic',
-  //   models: [...],
-  // },
 }
 
 // 📖 Flatten all models from all sources for backward compatibility
 export const MODELS = []
 for (const [sourceKey, sourceData] of Object.entries(sources)) {
-  for (const [modelId, label, tier, sweScore] of sourceData.models) {
-    MODELS.push([modelId, label, tier, sweScore])
+  for (const [modelId, label, tier, sweScore, ctw] of sourceData.models) {
+    MODELS.push([modelId, label, tier, sweScore, ctw])
   }
 }