free-coding-models 0.2.0 → 0.2.2

package/src/tool-launchers.js

@@ -16,9 +16,10 @@
  *   fully official. The user still gets a reproducible env/config handoff.
  *
  * @functions
+ *   → `resolveLauncherModelId` — choose the provider-specific id or proxy slug for a launch
  *   → `startExternalTool` — configure and launch the selected external tool mode
  *
- * @exports startExternalTool
+ * @exports resolveLauncherModelId, startExternalTool
  *
  * @see src/tool-metadata.js
  * @see src/provider-metadata.js
@@ -34,7 +35,7 @@ import { sources } from '../sources.js'
 import { getApiKey, getProxySettings } from './config.js'
 import { ENV_VAR_NAMES, isWindows } from './provider-metadata.js'
 import { getToolMeta } from './tool-metadata.js'
-import { ensureProxyRunning } from './opencode.js'
+import { ensureProxyRunning, resolveProxyModelId } from './opencode.js'
 
 function ensureDir(filePath) {
   const dir = dirname(filePath)
@@ -71,6 +72,31 @@ function getProviderBaseUrl(providerKey) {
     .replace(/\/predictions$/i, '')
 }
 
+function applyOpenAiCompatEnv(env, apiKey, baseUrl, modelId) {
+  if (!apiKey || !baseUrl || !modelId) return env
+  env.OPENAI_API_KEY = apiKey
+  env.OPENAI_BASE_URL = baseUrl
+  env.OPENAI_API_BASE = baseUrl
+  env.OPENAI_MODEL = modelId
+  env.LLM_API_KEY = apiKey
+  env.LLM_BASE_URL = baseUrl
+  env.LLM_MODEL = `openai/${modelId}`
+  return env
+}
+
+/**
+ * 📖 resolveLauncherModelId keeps proxy-backed launches on the universal
+ * 📖 `fcm-proxy` catalog slug instead of leaking a provider-specific upstream id.
+ *
+ * @param {{ label?: string, modelId?: string }} model
+ * @param {boolean} useProxy
+ * @returns {string}
+ */
+export function resolveLauncherModelId(model, useProxy = false) {
+  if (useProxy) return resolveProxyModelId(model)
+  return model?.modelId ?? ''
+}
+
 function buildToolEnv(mode, model, config) {
   const providerKey = model.providerKey
   const providerUrl = sources[providerKey]?.url || ''
@@ -233,6 +259,7 @@ function printConfigResult(toolName, result) {
 export async function startExternalTool(mode, model, config) {
   const meta = getToolMeta(mode)
   const { env, apiKey, baseUrl } = buildToolEnv(mode, model, config)
+  const proxySettings = getProxySettings(config)
 
   if (!apiKey && mode !== 'amp') {
     console.log(chalk.yellow(`  ⚠ No API key configured for ${model.providerKey}.`))
@@ -252,27 +279,43 @@ export async function startExternalTool(mode, model, config) {
     let crushApiKey = apiKey
     let crushBaseUrl = baseUrl
     let providerId = 'freeCodingModels'
-    const proxySettings = getProxySettings(config)
+    let launchModelId = resolveLauncherModelId(model, false)
 
     if (proxySettings.enabled) {
       const started = await ensureProxyRunning(config)
       crushApiKey = started.proxyToken
       crushBaseUrl = `http://127.0.0.1:${started.port}/v1`
       providerId = 'freeCodingModelsProxy'
+      launchModelId = resolveLauncherModelId(model, true)
       console.log(chalk.dim(`  📖 Crush will use the local FCM proxy on :${started.port} for this launch.`))
     } else {
       console.log(chalk.dim('  📖 Crush will use the provider directly for this launch.'))
     }
 
-    printConfigResult(meta.label, writeCrushConfig(model, crushApiKey, crushBaseUrl, providerId))
+    const launchModel = { ...model, modelId: launchModelId }
+    applyOpenAiCompatEnv(env, crushApiKey, crushBaseUrl, launchModelId)
+    printConfigResult(meta.label, writeCrushConfig(launchModel, crushApiKey, crushBaseUrl, providerId))
     return spawnCommand('crush', [], env)
   }
 
   if (mode === 'goose') {
-    env.OPENAI_HOST = baseUrl
+    let gooseBaseUrl = baseUrl
+    let gooseApiKey = apiKey
+    let gooseModelId = resolveLauncherModelId(model, false)
+
+    if (proxySettings.enabled) {
+      const started = await ensureProxyRunning(config)
+      gooseApiKey = started.proxyToken
+      gooseBaseUrl = `http://127.0.0.1:${started.port}/v1`
+      gooseModelId = resolveLauncherModelId(model, true)
+      applyOpenAiCompatEnv(env, gooseApiKey, gooseBaseUrl, gooseModelId)
+      console.log(chalk.dim(`  📖 Goose will use the local FCM proxy on :${started.port} for this launch.`))
+    }
+
+    env.OPENAI_HOST = gooseBaseUrl
     env.OPENAI_BASE_PATH = 'v1/chat/completions'
-    env.OPENAI_MODEL = model.modelId
-    console.log(chalk.dim('  📖 Goose uses env-based OpenAI-compatible configuration for this launch.'))
+    env.OPENAI_MODEL = gooseModelId
+    console.log(chalk.dim(`  📖 Goose uses env-based OpenAI-compatible configuration for ${proxySettings.enabled ? 'the proxy' : 'this provider'} launch.`))
     return spawnCommand('goose', [], env)
   }
 

package/src/utils.js

@@ -218,9 +218,11 @@ export const getStabilityScore = (r) => {
 // 📖 sortResults: Sort the results array by any column the user can click/press in the TUI.
 // 📖 Returns a NEW array — never mutates the original (important for React-style re-renders).
 //
-// 📖 Supported columns (matching the keyboard shortcuts in the TUI):
+// 📖 Supported columns in the sorter.
+// 📖 Most map directly to visible TUI sort hotkeys; `tier` remains available internally
+// 📖 even though the live TUI now reserves `Y` for the install-endpoints flow.
 //   - 'rank'      (R key) — original index from sources.js
-//   - 'tier'      (T key) — tier hierarchy (S+ first, C last)
+//   - 'tier'      (internal) — tier hierarchy (S+ first, C last)
 //   - 'origin'    (O key) — provider name (all NIM for now, future-proofed)
 //   - 'model'     (M key) — alphabetical by display label
 //   - 'ping'      (L key) — last ping latency (only successful ones count)
@@ -656,15 +658,17 @@ export function getTopRecommendations(results, taskType, priority, contextBudget
  *   2. proxyStartupStatus.phase === 'running'  → state:'running' with port/accountCount
  *   3. proxyStartupStatus.phase === 'failed'   → state:'failed' with truncated reason
  *   4. isProxyActive (legacy activeProxy flag)  → state:'running' (no port detail)
- *   5. otherwise                               → state:'stopped'
+ *   5. isProxyEnabled                           → state:'configured'
+ *   6. otherwise                               → state:'stopped'
  *
  * 📖 Reason is clamped to 80 characters to keep footer readable (no stack traces).
  *
  * @param {object|null} proxyStartupStatus — state.proxyStartupStatus value
  * @param {boolean} isProxyActive — truthy when the module-level activeProxy is non-null
+ * @param {boolean} [isProxyEnabled=false] — truthy when proxy mode is enabled in settings
  * @returns {{ state: string, port?: number, accountCount?: number, reason?: string }}
  */
-export function getProxyStatusInfo(proxyStartupStatus, isProxyActive) {
+export function getProxyStatusInfo(proxyStartupStatus, isProxyActive, isProxyEnabled = false) {
   const MAX_REASON = 80
 
   if (proxyStartupStatus) {
@@ -693,5 +697,34 @@ export function getProxyStatusInfo(proxyStartupStatus, isProxyActive) {
     return { state: 'running' }
   }
 
+  if (isProxyEnabled) {
+    return { state: 'configured' }
+  }
+
   return { state: 'stopped' }
 }
+
+/**
+ * 📖 getVersionStatusInfo turns the settings update-check state into a compact,
+ * 📖 render-friendly footer descriptor for the main table.
+ *
+ * 📖 Only an explicit `available` state should mark the local install as outdated.
+ * 📖 This avoids showing a scary warning before the user has actually checked npm.
+ *
+ * @param {'idle'|'checking'|'available'|'up-to-date'|'error'|'installing'} updateState
+ * @param {string|null} latestVersion
+ * @returns {{ isOutdated: boolean, latestVersion: string|null }}
+ */
+export function getVersionStatusInfo(updateState, latestVersion) {
+  if (updateState === 'available' && typeof latestVersion === 'string' && latestVersion.trim()) {
+    return {
+      isOutdated: true,
+      latestVersion: latestVersion.trim(),
+    }
+  }
+
+  return {
+    isOutdated: false,
+    latestVersion: null,
+  }
+}