free-coding-models 0.1.82 → 0.1.84

package/src/log-reader.js

@@ -0,0 +1,174 @@
+/**
+ * @file lib/log-reader.js
+ * @description Pure functions to load recent request-log entries from
+ *   ~/.free-coding-models/request-log.jsonl, newest-first, bounded by a
+ *   configurable row limit.
+ *
+ * Design principles:
+ *   - Bounded reads only — never slurp the entire log for every TUI repaint.
+ *   - Tolerates malformed / partially-written JSONL lines by skipping them.
+ *   - No shared mutable state (pure functions, injectable file path for tests).
+ *   - No new npm dependencies — uses only Node.js built-ins.
+ *
+ * Default path:
+ *   ~/.free-coding-models/request-log.jsonl
+ *
+ * Row object shape returned from loadRecentLogs():
+ *   {
+ *     time:     string   // ISO timestamp string  (from entry.timestamp)
+ *     requestType: string // e.g. "chat.completions"
+ *     model:    string   // e.g. "llama-3.3-70b-instruct"
+ *     provider: string   // e.g. "nvidia"
+ *     status:   string   // e.g. "200" | "429" | "error"
+ *     tokens:   number   // promptTokens + completionTokens (0 if unknown)
+ *     latency:  number   // ms (0 if unknown)
+ *   }
+ *
+ * @exports loadRecentLogs
+ * @exports parseLogLine
+ */
+
+import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const DEFAULT_LOG_FILE = join(homedir(), '.free-coding-models', 'request-log.jsonl')
+
+/** Maximum bytes to read from the tail of the file to avoid OOM on large logs. */
+const MAX_READ_BYTES = 128 * 1024 // 128 KB
+
+function normalizeTimestamp(raw) {
+  if (typeof raw === 'number' && Number.isFinite(raw)) {
+    return new Date(raw).toISOString()
+  }
+  if (typeof raw === 'string') {
+    const numeric = Number(raw)
+    if (Number.isFinite(numeric)) return new Date(numeric).toISOString()
+    const parsed = new Date(raw)
+    if (!Number.isNaN(parsed.getTime())) return parsed.toISOString()
+  }
+  return null
+}
+
+function inferProvider(entry) {
+  if (entry.providerKey || entry.provider) {
+    return String(entry.providerKey ?? entry.provider)
+  }
+  if (typeof entry.accountId === 'string' && entry.accountId.includes('/')) {
+    return entry.accountId.split('/')[0] || 'unknown'
+  }
+  return 'unknown'
+}
+
+function inferStatus(entry) {
+  if (entry.statusCode !== undefined || entry.status !== undefined) {
+    return String(entry.statusCode ?? entry.status)
+  }
+  if (typeof entry.success === 'boolean') {
+    return entry.success ? '200' : 'error'
+  }
+  return 'unknown'
+}
+
+function inferRequestType(entry) {
+  if (entry.requestType !== undefined || entry.type !== undefined) {
+    return String(entry.requestType ?? entry.type)
+  }
+  if (typeof entry.url === 'string') {
+    if (entry.url.includes('/chat/completions')) return 'chat.completions'
+    if (entry.url.includes('/models')) return 'models'
+  }
+  return 'chat.completions'
+}
+
+/**
+ * Parse a single JSONL line into a normalised log row object.
+ *
+ * Returns `null` for any line that is blank, not valid JSON, or missing
+ * the required `timestamp` field.
+ *
+ * @param {string} line - A single text line from the JSONL file.
+ * @returns {{ time: string, requestType: string, model: string, provider: string, status: string, tokens: number, latency: number } | null}
+ */
+export function parseLogLine(line) {
+  const trimmed = line.trim()
+  if (!trimmed) return null
+  let entry
+  try {
+    entry = JSON.parse(trimmed)
+  } catch {
+    return null
+  }
+  if (!entry || typeof entry !== 'object') return null
+  if (!entry.timestamp) return null
+
+  const normalizedTime = normalizeTimestamp(entry.timestamp)
+  if (!normalizedTime) return null
+
+  const model    = String(entry.modelId    ?? entry.model    ?? 'unknown')
+  const provider = inferProvider(entry)
+  const status   = inferStatus(entry)
+  const requestType = inferRequestType(entry)
+  const tokens   = (Number(entry.usage?.prompt_tokens ?? entry.promptTokens ?? 0) +
+                    Number(entry.usage?.completion_tokens ?? entry.completionTokens ?? 0)) || 0
+  const latency  = Number(entry.latencyMs ?? entry.latency ?? 0) || 0
+
+  return {
+    time: normalizedTime,
+    requestType,
+    model,
+    provider,
+    status,
+    tokens,
+    latency,
+  }
+}
+
+/**
+ * Load the N most-recent log entries from the JSONL file, newest-first.
+ *
+ * Only reads up to MAX_READ_BYTES from the end of the file to avoid
+ * loading the entire log history.  Malformed lines are silently skipped.
+ *
+ * @param {object}  [opts]
+ * @param {string}  [opts.logFile]  - Path to request-log.jsonl (injectable for tests)
+ * @param {number}  [opts.limit]    - Maximum rows to return (default 200)
+ * @returns {Array<{ time: string, requestType: string, model: string, provider: string, status: string, tokens: number, latency: number }>}
+ */
+export function loadRecentLogs({ logFile = DEFAULT_LOG_FILE, limit = 200 } = {}) {
+  try {
+    if (!existsSync(logFile)) return []
+
+    const fileSize = statSync(logFile).size
+    if (fileSize === 0) return []
+
+    // 📖 Read only the tail of the file (bounded by MAX_READ_BYTES) to avoid
+    // 📖 reading multi-megabyte logs on every TUI repaint.
+    const readBytes = Math.min(fileSize, MAX_READ_BYTES)
+    const fileOffset = fileSize - readBytes
+
+    const buf = Buffer.allocUnsafe(readBytes)
+    const fd = openSync(logFile, 'r')
+    try {
+      readSync(fd, buf, 0, readBytes, fileOffset)
+    } finally {
+      closeSync(fd)
+    }
+
+    const text = buf.toString('utf8')
+
+    // 📖 Split on newlines; if we started mid-line (fileOffset > 0), drop
+    // 📖 the first (potentially incomplete) line to avoid corrupt JSON.
+    const rawLines = text.split('\n')
+    const lines = fileOffset > 0 ? rawLines.slice(1) : rawLines
+
+    const rows = []
+    for (let i = lines.length - 1; i >= 0 && rows.length < limit; i--) {
+      const row = parseLogLine(lines[i])
+      if (row) rows.push(row)
+    }
+    return rows
+  } catch {
+    return []
+  }
+}

package/src/model-merger.js

@@ -0,0 +1,78 @@
+const TIER_RANK = { 'S+': 0, 'S': 1, 'A+': 2, 'A': 3, 'A-': 4, 'B+': 5, 'B': 6, 'C': 7 }
+
+function parseCtxK(ctx) {
+  if (!ctx) return 0
+  const s = ctx.toLowerCase()
+  if (s.endsWith('m')) return parseFloat(s) * 1000
+  return parseFloat(s) || 0
+}
+
+function parseSwePercent(swe) {
+  return parseFloat(swe) || 0
+}
+
+/**
+ * Generate a unique slug from a label.
+ * "DeepSeek V3.2" → "deepseek-v3-2"
+ * Appends suffix if collision detected.
+ */
+function slugify(label, existingSlugs) {
+  let base = label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+  let slug = base
+  let i = 2
+  while (existingSlugs.has(slug)) {
+    slug = `${base}-${i++}`
+  }
+  existingSlugs.add(slug)
+  return slug
+}
+
+/**
+ * Build merged model list from flat MODELS array.
+ * Groups by display label. Each merged entry contains all providers.
+ *
+ * @param {Array} models - Flat array of [modelId, label, tier, sweScore, ctx, providerKey]
+ * @returns {Array<MergedModel>}
+ *
+ * MergedModel: {
+ *   slug: string,           // unique URL-safe identifier
+ *   label: string,          // display name
+ *   tier: string,           // best tier across providers
+ *   sweScore: string,       // highest SWE score
+ *   ctx: string,            // largest context window
+ *   providerCount: number,
+ *   providers: Array<{ modelId: string, providerKey: string, tier: string }>
+ * }
+ */
+export function buildMergedModels(models) {
+  const groups = new Map()
+
+  for (const [modelId, label, tier, sweScore, ctx, providerKey] of models) {
+    if (!groups.has(label)) {
+      groups.set(label, { label, tier, sweScore, ctx, providers: [] })
+    }
+
+    const group = groups.get(label)
+    group.providers.push({ modelId, providerKey, tier })
+
+    // Keep best tier
+    if ((TIER_RANK[tier] ?? 99) < (TIER_RANK[group.tier] ?? 99)) {
+      group.tier = tier
+    }
+    // Keep highest SWE score
+    if (parseSwePercent(sweScore) > parseSwePercent(group.sweScore)) {
+      group.sweScore = sweScore
+    }
+    // Keep largest context
+    if (parseCtxK(ctx) > parseCtxK(group.ctx)) {
+      group.ctx = ctx
+    }
+  }
+
+  const existingSlugs = new Set()
+  return Array.from(groups.values()).map(g => ({
+    ...g,
+    slug: slugify(g.label, existingSlugs),
+    providerCount: g.providers.length,
+  }))
+}

package/src/openclaw.js

@@ -0,0 +1,131 @@
+/**
+ * @file openclaw.js
+ * @description OpenClaw config helpers for setting NVIDIA NIM defaults.
+ *
+ * @details
+ *   This module owns the OpenClaw integration logic:
+ *   - Read/write ~/.openclaw/openclaw.json
+ *   - Ensure the NVIDIA provider block exists under models.providers
+ *   - Patch the OpenClaw allowlist for NVIDIA models when needed
+ *   - Set the selected model as the default primary model
+ *
+ *   → Functions:
+ *   - `loadOpenClawConfig` — read OpenClaw config as JSON
+ *   - `saveOpenClawConfig` — persist OpenClaw config safely
+ *   - `startOpenClaw` — set NVIDIA model as OpenClaw default
+ *
+ * @exports { loadOpenClawConfig, saveOpenClawConfig, startOpenClaw }
+ * @see ../patch-openclaw-models.js
+ */
+
+import chalk from 'chalk'
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+import { patchOpenClawModelsJson } from '../patch-openclaw-models.js'
+
+// 📖 OpenClaw config: ~/.openclaw/openclaw.json (JSON format, may be JSON5 in newer versions)
+const OPENCLAW_CONFIG = join(homedir(), '.openclaw', 'openclaw.json')
+
+export function loadOpenClawConfig() {
+  if (!existsSync(OPENCLAW_CONFIG)) return {}
+  try {
+    // 📖 JSON.parse works for standard JSON; OpenClaw may use JSON5 but base config is valid JSON
+    return JSON.parse(readFileSync(OPENCLAW_CONFIG, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+export function saveOpenClawConfig(config) {
+  const dir = join(homedir(), '.openclaw')
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+  writeFileSync(OPENCLAW_CONFIG, JSON.stringify(config, null, 2))
+}
+
+// 📖 startOpenClaw: sets the selected NVIDIA NIM model as default in OpenClaw config.
+// 📖 Also ensures the nvidia provider block is present with the NIM base URL.
+// 📖 Does NOT launch OpenClaw — OpenClaw runs as a daemon, so config changes are picked up on restart.
+export async function startOpenClaw(model, apiKey) {
+  console.log(chalk.rgb(255, 100, 50)(`  🦞 Setting ${chalk.bold(model.label)} as OpenClaw default…`))
+  console.log(chalk.dim(`  Model: nvidia/${model.modelId}`))
+  console.log()
+
+  const config = loadOpenClawConfig()
+
+  // 📖 Backup existing config before touching it
+  if (existsSync(OPENCLAW_CONFIG)) {
+    const backupPath = `${OPENCLAW_CONFIG}.backup-${Date.now()}`
+    copyFileSync(OPENCLAW_CONFIG, backupPath)
+    console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
+  }
+
+  // 📖 Patch models.json to add all NVIDIA models (fixes "not allowed" errors)
+  const patchResult = patchOpenClawModelsJson()
+  if (patchResult.wasPatched) {
+    console.log(chalk.dim(`  ✨ Added ${patchResult.added} NVIDIA models to allowlist (${patchResult.total} total)`))
+    if (patchResult.backup) {
+      console.log(chalk.dim(`  💾 models.json backup: ${patchResult.backup}`))
+    }
+  }
+
+  // 📖 Ensure models.providers section exists with nvidia NIM block.
+  // 📖 Per OpenClaw docs (docs.openclaw.ai/providers/nvidia), providers MUST be nested under
+  // 📖 "models.providers", NOT at the config root. Root-level "providers" is ignored by OpenClaw.
+  // 📖 API key is NOT stored in the provider block — it's read from env var NVIDIA_API_KEY.
+  // 📖 If needed, it can be stored under the root "env" key: { env: { NVIDIA_API_KEY: "nvapi-..." } }
+  if (!config.models) config.models = {}
+  if (!config.models.providers) config.models.providers = {}
+  if (!config.models.providers.nvidia) {
+    config.models.providers.nvidia = {
+      baseUrl: 'https://integrate.api.nvidia.com/v1',
+      api: 'openai-completions',
+      models: [],
+    }
+    console.log(chalk.dim('  ➕ Added nvidia provider block to OpenClaw config (models.providers.nvidia)'))
+  }
+  // 📖 Ensure models array exists even if the provider block was created by an older version
+  if (!Array.isArray(config.models.providers.nvidia.models)) {
+    config.models.providers.nvidia.models = []
+  }
+
+  // 📖 Store API key in the root "env" section so OpenClaw can read it as NVIDIA_API_KEY env var.
+  // 📖 Only writes if not already set to avoid overwriting an existing key.
+  const resolvedKey = apiKey || process.env.NVIDIA_API_KEY
+  if (resolvedKey) {
+    if (!config.env) config.env = {}
+    if (!config.env.NVIDIA_API_KEY) {
+      config.env.NVIDIA_API_KEY = resolvedKey
+      console.log(chalk.dim('  🔑 Stored NVIDIA_API_KEY in config env section'))
+    }
+  }
+
+  // 📖 Set as the default primary model for all agents.
+  // 📖 Format: "provider/model-id" — e.g. "nvidia/deepseek-ai/deepseek-v3.2"
+  if (!config.agents) config.agents = {}
+  if (!config.agents.defaults) config.agents.defaults = {}
+  if (!config.agents.defaults.model) config.agents.defaults.model = {}
+  config.agents.defaults.model.primary = `nvidia/${model.modelId}`
+
+  // 📖 REQUIRED: OpenClaw requires the model to be explicitly listed in agents.defaults.models
+  // 📖 (the allowlist). Without this entry, OpenClaw rejects the model with "not allowed".
+  // 📖 See: https://docs.openclaw.ai/gateway/configuration-reference
+  if (!config.agents.defaults.models) config.agents.defaults.models = {}
+  config.agents.defaults.models[`nvidia/${model.modelId}`] = {}
+
+  saveOpenClawConfig(config)
+
+  console.log(chalk.rgb(255, 140, 0)(`  ✓ Default model set to: nvidia/${model.modelId}`))
+  console.log()
+  console.log(chalk.dim('  📄 Config updated: ' + OPENCLAW_CONFIG))
+  console.log()
+  // 📖 "openclaw restart" does NOT exist. The gateway auto-reloads on config file changes.
+  // 📖 To apply manually: use "openclaw models set" or "openclaw configure"
+  // 📖 See: https://docs.openclaw.ai/gateway/configuration
+  console.log(chalk.dim('  💡 OpenClaw will reload config automatically (gateway.reload.mode).'))
+  console.log(chalk.dim('     To apply manually: openclaw models set nvidia/' + model.modelId))
+  console.log(chalk.dim('     Or run the setup wizard: openclaw configure'))
+  console.log()
+}

package/src/opencode-sync.js

@@ -0,0 +1,159 @@
+import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { randomBytes } from 'node:crypto'
+
+const OC_CONFIG_DIR = join(homedir(), '.config', 'opencode')
+const OC_CONFIG_PATH = join(OC_CONFIG_DIR, 'opencode.json')
+const OC_BACKUP_PATH = join(OC_CONFIG_DIR, 'opencode.json.bak')
+const FCM_PROVIDER_ID = 'fcm-proxy'
+const DEFAULT_PROXY_BASE_URL = 'http://127.0.0.1:8045/v1'
+
+function generateProxyToken() {
+  return `fcm_${randomBytes(24).toString('hex')}`
+}
+
+function ensureV1BaseUrl(baseURL) {
+  if (typeof baseURL !== 'string' || baseURL.length === 0) {
+    return DEFAULT_PROXY_BASE_URL
+  }
+  const trimmed = baseURL.replace(/\/+$/, '')
+  return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`
+}
+
+/**
+ * Load existing OpenCode config, or return empty object.
+ */
+export function loadOpenCodeConfig() {
+  try {
+    if (existsSync(OC_CONFIG_PATH)) {
+      return JSON.parse(readFileSync(OC_CONFIG_PATH, 'utf8'))
+    }
+  } catch {}
+  return {}
+}
+
+/**
+ * Save OpenCode config with automatic backup.
+ * Creates backup of current config before overwriting.
+ */
+export function saveOpenCodeConfig(config) {
+  mkdirSync(OC_CONFIG_DIR, { recursive: true })
+  // Backup existing config before saving
+  if (existsSync(OC_CONFIG_PATH)) {
+    copyFileSync(OC_CONFIG_PATH, OC_BACKUP_PATH)
+  }
+  writeFileSync(OC_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n')
+}
+
+/**
+ * Restore OpenCode config from backup.
+ * @returns {boolean} true if restored, false if no backup exists
+ */
+export function restoreOpenCodeBackup() {
+  if (!existsSync(OC_BACKUP_PATH)) return false
+  copyFileSync(OC_BACKUP_PATH, OC_CONFIG_PATH)
+  return true
+}
+
+/**
+ * Pure merge: apply FCM provider entry into an existing OpenCode config object.
+ *
+ * This function contains the merge logic without any filesystem I/O so it can
+ * be unit-tested in isolation. It is exported for tests and used internally by
+ * syncToOpenCode.
+ *
+ * CRITICAL: This function ONLY adds/updates the fcm-proxy provider entry.
+ * It PRESERVES all existing providers (antigravity-manager, openai, iflow, etc.)
+ * and all other top-level keys ($schema, mcp, plugin, command, model).
+ *
+ * proxyInfo should only carry runtime port/token when the proxy is actively
+ * running (running === true). Callers MUST NOT pass stale values from a stopped
+ * proxy — use undefined/omit the fields instead so we fall back to the existing
+ * persisted provider options cleanly.
+ *
+ * @param {Object} ocConfig - Existing OpenCode config object (will be mutated in-place)
+ * @param {Array} mergedModels - Output of buildMergedModels()
+ * @param {{ proxyPort?: number, proxyToken?: string, availableModelSlugs?: Set<string>|string[] }} proxyInfo
+ *   availableModelSlugs: when provided, only models whose slug is in this set are written
+ *   to the OpenCode catalog. Use this to prevent "ghost" entries for models with no API keys.
+ * @returns {Object} The mutated ocConfig
+ */
+export function mergeOcConfig(ocConfig, mergedModels, proxyInfo = {}) {
+  ocConfig.provider = ocConfig.provider || {}
+
+  const existingProvider = ocConfig.provider[FCM_PROVIDER_ID] || {}
+  const existingOptions = existingProvider.options || {}
+
+  // Only use the runtime proxyPort if it is a valid positive integer.
+  // A null/undefined/0 port means the proxy is not running — fall back to
+  // the existing persisted baseURL so we don't write a broken URL.
+  const hasValidPort = Number.isInteger(proxyInfo.proxyPort) && proxyInfo.proxyPort > 0
+  const baseURL = ensureV1BaseUrl(
+    hasValidPort
+      ? `http://127.0.0.1:${proxyInfo.proxyPort}`
+      : existingOptions.baseURL
+  )
+
+  // Keep token stable unless caller provides a runtime token.
+  // A non-string or empty proxyToken is treated as absent.
+  const hasValidToken = typeof proxyInfo.proxyToken === 'string' && proxyInfo.proxyToken.length > 0
+  const hasExistingToken =
+    typeof existingOptions.apiKey === 'string' &&
+    existingOptions.apiKey.length > 0 &&
+    existingOptions.apiKey !== 'fcm-proxy-token'
+  const apiKey = hasValidToken ? proxyInfo.proxyToken : (hasExistingToken ? existingOptions.apiKey : generateProxyToken())
+
+  const slugFilter = proxyInfo.availableModelSlugs
+    ? new Set(proxyInfo.availableModelSlugs)
+    : null
+
+  const models = {}
+  for (const m of mergedModels) {
+    if (slugFilter && !slugFilter.has(m.slug)) continue
+    models[m.slug] = { name: m.label }
+  }
+
+  ocConfig.provider[FCM_PROVIDER_ID] = {
+    npm: '@ai-sdk/openai-compatible',
+    name: 'FCM Rotation Proxy',
+    options: {
+      ...existingOptions,
+      baseURL,
+      apiKey,
+    },
+    models,
+  }
+
+  return ocConfig
+}
+
+/**
+ * MERGE the single FCM proxy provider into OpenCode config.
+ *
+ * CRITICAL: This function ONLY adds/updates the fcm-proxy provider entry.
+ * It PRESERVES all existing providers (antigravity-manager, openai, iflow, etc.)
+ * and all other top-level keys ($schema, mcp, plugin, command, model).
+ *
+ * proxyInfo should only carry runtime port/token when the proxy is actively
+ * running (running === true). Callers MUST NOT pass stale values from a stopped
+ * proxy — use undefined/omit the fields instead so we fall back to the existing
+ * persisted provider options cleanly.
+ *
+ * @param {Object} fcmConfig - FCM config (from loadConfig())
+ * @param {Object} _sources - PROVIDERS object from sources.js (unused, kept for signature compatibility)
+ * @param {Array} mergedModels - Output of buildMergedModels()
+ * @param {{ proxyPort?: number, proxyToken?: string, availableModelSlugs?: Set<string>|string[] }} proxyInfo
+ *   availableModelSlugs: slugs of models that have real API key accounts. When provided,
+ *   only those models appear in the OpenCode catalog, preventing ghost entries.
+ */
+export function syncToOpenCode(fcmConfig, _sources, mergedModels, proxyInfo = {}) {
+  const oc = loadOpenCodeConfig()
+  const merged = mergeOcConfig(oc, mergedModels, proxyInfo)
+  saveOpenCodeConfig(merged)
+  return {
+    providerKey: FCM_PROVIDER_ID,
+    modelCount: Object.keys(merged.provider[FCM_PROVIDER_ID].models).length,
+    path: OC_CONFIG_PATH,
+  }
+}