amicus 1.0.0

package/src/utils/model-fetcher.js

@@ -0,0 +1,179 @@
+/**
+ * Model Fetcher
+ *
+ * Fetches available model lists from provider APIs for the dropdown selector.
+ * Uses the same HTTPS pattern as api-key-store.js validateApiKey().
+ */
+
+const https = require('https');
+
+/** Hardcoded Anthropic models (no public listing endpoint) */
+const ANTHROPIC_MODELS = [
+  { id: 'anthropic/claude-opus-4-6', name: 'Claude Opus 4.6', contextLength: null, pricing: null },
+  { id: 'anthropic/claude-sonnet-4-6', name: 'Claude Sonnet 4.6', contextLength: null, pricing: null },
+  { id: 'anthropic/claude-haiku-4-5', name: 'Claude Haiku 4.5', contextLength: null, pricing: null },
+  { id: 'anthropic/claude-sonnet-4-5', name: 'Claude Sonnet 4.5', contextLength: null, pricing: null },
+  { id: 'anthropic/claude-3-5-haiku', name: 'Claude 3.5 Haiku', contextLength: null, pricing: null }
+];
+
+const PROVIDER_FAMILY_NAMES = {
+  openrouter: 'OpenRouter',
+  google: 'Google',
+  openai: 'OpenAI',
+  anthropic: 'Anthropic'
+};
+
+/** Provider API configs for fetching model lists */
+const PROVIDER_FETCH_CONFIG = {
+  openrouter: {
+    url: 'https://openrouter.ai/api/v1/models',
+    // Public endpoint: works keyless; attach auth only when a key exists (F5).
+    authHeader: (key) => (key ? { 'Authorization': `Bearer ${key}` } : {}),
+    normalize: (body) => {
+      const data = JSON.parse(body);
+      return (data.data || []).map(m => ({
+        id: `openrouter/${m.id}`,
+        name: m.name || m.id,
+        contextLength: m.context_length ?? null,
+        pricing: m.pricing
+          ? { prompt: m.pricing.prompt ?? null,
+              completion: m.pricing.completion ?? null }
+          : null
+      }));
+    }
+  },
+  google: {
+    url: null, // built dynamically with key
+    authHeader: () => ({}),
+    buildUrl: (key) => `https://generativelanguage.googleapis.com/v1beta/models?key=${key}`,
+    normalize: (body) => {
+      const data = JSON.parse(body);
+      return (data.models || []).map(m => ({
+        id: `google/${m.name.replace('models/', '')}`,
+        name: m.displayName || m.name.replace('models/', ''),
+        contextLength: m.inputTokenLimit ?? null,
+        pricing: null
+      }));
+    }
+  },
+  openai: {
+    url: 'https://api.openai.com/v1/models',
+    authHeader: (key) => ({ 'Authorization': `Bearer ${key}` }),
+    normalize: (body) => {
+      const data = JSON.parse(body);
+      return (data.data || []).map(m => ({
+        id: `openai/${m.id}`,
+        name: m.id,
+        contextLength: null,
+        pricing: null
+      }));
+    }
+  }
+};
+
+const FETCH_TIMEOUT_MS = 5000;
+
+/**
+ * Fetch models from a single provider API
+ * @param {string} provider - Provider name (openrouter, google, openai, anthropic)
+ * @param {string} key - API key
+ * @returns {Promise<Array<{id: string, name: string, contextLength: number|null, pricing: {prompt: string|null, completion: string|null}|null}>>} Normalized model list
+ */
+function fetchModelsFromProvider(provider, key) {
+  if (provider === 'anthropic') {
+    return Promise.resolve(ANTHROPIC_MODELS);
+  }
+
+  const config = PROVIDER_FETCH_CONFIG[provider];
+  if (!config) {
+    return Promise.resolve([]);
+  }
+
+  const url = config.buildUrl ? config.buildUrl(key) : config.url;
+  const headers = config.authHeader(key);
+
+  return new Promise((resolve) => {
+    let chunks = '';
+    const timer = setTimeout(() => {
+      req.destroy();
+      resolve([]);
+    }, FETCH_TIMEOUT_MS);
+
+    const req = https.get(url, { headers }, (res) => {
+      if (res.statusCode !== 200) {
+        clearTimeout(timer);
+        res.on('data', () => {});
+        res.on('end', () => resolve([]));
+        return;
+      }
+      res.on('data', (chunk) => { chunks += chunk; });
+      res.on('end', () => {
+        clearTimeout(timer);
+        try {
+          resolve(config.normalize(chunks));
+        } catch (_err) {
+          resolve([]);
+        }
+      });
+    });
+    req.on('error', () => {
+      clearTimeout(timer);
+      resolve([]);
+    });
+  });
+}
+
+/** Providers to fetch: every keyed provider + openrouter (keyless-capable) + anthropic. */
+function providersToFetch(keys) {
+  const set = new Set(Object.keys(keys).filter(p => keys[p]));
+  set.add('openrouter');
+  set.add('anthropic');
+  return Array.from(set);
+}
+
+/**
+ * Fetch models from all providers that have keys configured; openrouter is
+ * always included (keyless public endpoint) as is anthropic (hardcoded list).
+ * @param {Object<string, string>} keys - Map of provider → API key string
+ * @returns {Promise<Array<{id: string, name: string, contextLength: number|null, pricing: object|null}>>} Combined model list
+ */
+async function fetchAllModels(keys) {
+  const providers = providersToFetch(keys);
+  const results = await Promise.all(providers.map(p => fetchModelsFromProvider(p, keys[p] || '')));
+  return results.flat();
+}
+
+/**
+ * Group models by provider family for <optgroup> rendering
+ * @param {Array<{id: string, name: string, contextLength: number|null, pricing: {prompt: string|null, completion: string|null}|null}>} models
+ * @returns {Array<{family: string, models: Array<{id: string, name: string}>}>}
+ */
+function groupModelsByFamily(models) {
+  if (models.length === 0) { return []; }
+
+  const groups = new Map();
+
+  for (const model of models) {
+    const prefix = model.id.split('/')[0];
+    const family = PROVIDER_FAMILY_NAMES[prefix] || prefix;
+    if (!groups.has(family)) {
+      groups.set(family, []);
+    }
+    groups.get(family).push(model);
+  }
+
+  return Array.from(groups.entries()).map(([family, familyModels]) => ({
+    family,
+    models: familyModels
+  }));
+}
+
+module.exports = {
+  fetchModelsFromProvider,
+  fetchAllModels,
+  providersToFetch,
+  groupModelsByFamily,
+  ANTHROPIC_MODELS,
+  PROVIDER_FETCH_CONFIG,
+  PROVIDER_FAMILY_NAMES
+};

package/src/utils/model-validator.js

@@ -0,0 +1,207 @@
+/**
+ * Model Validator
+ *
+ * Validates that a direct-API fallback model exists on the provider.
+ * When a model is not found, prompts the user to pick an alternative
+ * (interactive) or fails with available models (headless).
+ */
+
+const readline = require('readline');
+const { fetchModelsFromProvider } = require('./model-fetcher');
+const { readApiKeyValues } = require('./api-key-store');
+const { loadConfig, saveConfig, getConfigPath } = require('./config');
+const { logger } = require('./logger');
+
+/**
+ * Normalize a model ID to include the provider prefix.
+ * @param {string} provider - e.g. 'google', 'openai'
+ * @param {string} id - Model ID, may or may not have provider prefix
+ * @returns {string} Normalized ID with provider prefix
+ */
+function normalizeModelId(provider, id) {
+  if (id.startsWith(provider + '/')) {
+    return id;
+  }
+  return `${provider}/${id}`;
+}
+
+/** Alias-to-search-term mapping for filtering provider model lists */
+const ALIAS_SEARCH_TERMS = {
+  'gemini': 'gemini', 'gemini-pro': 'gemini',
+  'gpt': 'gpt', 'gpt-pro': 'gpt', 'codex': 'gpt',
+  'claude': 'claude', 'sonnet': 'claude', 'opus': 'claude', 'haiku': 'claude',
+  'deepseek': 'deepseek',
+};
+
+/**
+ * Validate a direct-API fallback model exists on the provider.
+ * Returns silently if valid. On failure: prompts (interactive) or throws (headless).
+ *
+ * @param {string} resolvedModel - e.g. 'google/gemini-3.1-flash-lite-preview'
+ * @param {string} alias - Original alias name (e.g. 'gemini')
+ * @param {object} [options]
+ * @param {boolean} [options.headless] - If true, throw instead of prompting
+ * @returns {Promise<string>} Confirmed model string
+ */
+async function validateDirectModel(resolvedModel, alias, options = {}) {
+  const parts = resolvedModel.split('/');
+  if (parts.length < 2) { return resolvedModel; }
+
+  const provider = parts[0];
+  const modelId = parts.slice(1).join('/');
+
+  const keys = readApiKeyValues();
+  const providerKey = keys[provider];
+  if (!providerKey) { return resolvedModel; }
+
+  let models;
+  try {
+    models = await fetchModelsFromProvider(provider, providerKey);
+  } catch (err) {
+    logger.debug({ msg: 'Model fetch failed, skipping validation', error: err.message });
+    return resolvedModel;
+  }
+
+  if (!models || models.length === 0) { return resolvedModel; }
+
+  const found = models.some(m => m.id === resolvedModel || m.id === modelId);
+  if (found) { return resolvedModel; }
+
+  const relevant = filterRelevantModels(models, alias);
+
+  if (options.headless || !process.stdin.isTTY) {
+    const list = relevant.slice(0, 10).map(m => `  ${normalizeModelId(provider, m.id)}`).join('\n');
+    throw new Error(
+      `Model '${modelId}' not found on ${provider} API.\n` +
+      `Available models:\n${list}\n` +
+      `Fix with: amicus setup --add-alias ${alias}=${relevant[0] ? normalizeModelId(provider, relevant[0].id) : 'provider/model'}`
+    );
+  }
+
+  return promptModelSelection(relevant, alias, provider, modelId);
+}
+
+/**
+ * Filter models to those relevant to the alias
+ * @param {Array<{id: string, name: string}>} models
+ * @param {string} alias - e.g. 'gemini', 'gpt', 'opus'
+ * @returns {Array<{id: string, name: string}>} Filtered, sorted, max 15
+ */
+function filterRelevantModels(models, alias) {
+  const term = (ALIAS_SEARCH_TERMS[alias] || alias).toLowerCase();
+
+  let filtered = models.filter(m =>
+    m.id.toLowerCase().includes(term) ||
+    m.name.toLowerCase().includes(term)
+  );
+
+  if (filtered.length === 0) { filtered = models; }
+
+  filtered.sort((a, b) => a.name.localeCompare(b.name));
+  return filtered.slice(0, 15);
+}
+
+/** Interactive prompt — ask user to pick from available models */
+async function promptModelSelection(models, alias, provider, failedModelId) {
+  process.stderr.write(`\n  Model '${failedModelId}' not found on ${provider} API.\n`);
+  process.stderr.write('  Available models:\n');
+  models.forEach((m, i) => {
+    const label = (m.name && m.name !== m.id) ? `${m.name} (${m.id})` : m.id;
+    process.stderr.write(`    ${i + 1}. ${label}\n`);
+  });
+  process.stderr.write('\n');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+
+  const answer = await new Promise(resolve => {
+    rl.question(`  Select a model (1-${models.length}) or press Enter to cancel: `, resolve);
+  });
+  rl.close();
+
+  const idx = parseInt(answer, 10) - 1;
+  if (isNaN(idx) || idx < 0 || idx >= models.length) {
+    throw new Error('Model selection cancelled.');
+  }
+
+  const selected = models[idx];
+  const newModel = normalizeModelId(provider, selected.id);
+
+  let config = loadConfig();
+  if (!config) {
+    const fs = require('fs');
+    const configPath = getConfigPath();
+    if (fs.existsSync(configPath)) {
+      throw new Error(
+        `Cannot save model selection: config file at ${configPath} is malformed. ` +
+        'Fix it manually or run \'amicus setup\'.'
+      );
+    }
+    config = {};
+  }
+  if (!config.aliases) { config.aliases = {}; }
+  config.aliases[alias] = newModel;
+  try {
+    saveConfig(config);
+    process.stderr.write(`  Saved: ${alias} → ${newModel}\n`);
+  } catch (err) {
+    process.stderr.write(`  Warning: Could not save selection (${err.message}). Using for this session only.\n`);
+  }
+  process.stderr.write(`  (To change later: amicus setup --add-alias ${alias}=...)\n\n`);
+
+  return newModel;
+}
+
+/**
+ * Validate an OpenRouter-resolved model against the cached catalog (F3 #18).
+ * Only enforces for `openrouter/`-prefixed models (the catalog is authoritative
+ * there). Graceful when the catalog is empty/unavailable. Fails fast with
+ * suggestions when the model is genuinely absent.
+ *
+ * @param {string} resolvedModel
+ * @param {string} [alias]
+ * @returns {Promise<string>} the model (unchanged) when valid/unverifiable
+ */
+async function validateAgainstCatalog(resolvedModel, alias) {
+  if (!resolvedModel.startsWith('openrouter/')) { return resolvedModel; }
+
+  const { getCatalog } = require('./model-catalog');
+  let catalog;
+  try { catalog = await getCatalog(); } catch { return resolvedModel; }
+  if (!catalog || catalog.length === 0) { return resolvedModel; }
+
+  // Only enforce when the OpenRouter catalog is actually present. If the fetch
+  // was unavailable (e.g. no key reached the fetcher) the catalog won't contain
+  // any openrouter/* ids — degrade gracefully instead of false-rejecting.
+  if (!catalog.some(m => m.id.startsWith('openrouter/'))) { return resolvedModel; }
+
+  if (catalog.some(m => m.id === resolvedModel)) { return resolvedModel; }
+
+  const relevant = filterRelevantModels(catalog, alias || resolvedModel.split('/').pop());
+  const list = relevant.slice(0, 10).map(m => `  ${m.id}`).join('\n');
+  throw new Error(
+    `Model '${resolvedModel}' not found in the OpenRouter catalog.\n` +
+    (list ? `Did you mean:\n${list}\n` : '') +
+    `Fix: amicus setup --add-alias ${alias || '<alias>'}=${relevant[0] ? relevant[0].id : 'openrouter/provider/model'}\n` +
+    'Run \'amicus models --refresh\' to update the catalog, or pass --no-validate-model to skip.'
+  );
+}
+
+/**
+ * Non-blocking advisory check for inherited models (F5: continue/resume).
+ * Same catalog logic as validateAgainstCatalog, but warns on stderr instead
+ * of throwing — a session that already ran with this model must stay openable.
+ * @param {string} model
+ */
+async function warnIfNotInCatalog(model) {
+  if (typeof model !== 'string' || !model) { return; }
+  try {
+    await validateAgainstCatalog(model);
+  } catch (err) {
+    process.stderr.write(
+      `Warning: ${String(err.message).split('\n')[0]} ` +
+      '(continuing anyway — run \'amicus models --check\' to review aliases)\n'
+    );
+  }
+}
+
+module.exports = { validateDirectModel, filterRelevantModels, normalizeModelId, validateAgainstCatalog, warnIfNotInCatalog };

package/src/utils/path-setup.js

@@ -0,0 +1,41 @@
+const path = require('path');
+const os = require('os');
+
+/**
+ * Ensures that the project's node_modules/.bin directory is included in the PATH,
+ * and on Windows also adds the platform-specific native opencode binary directory
+ * so that `spawn('opencode', ...)` without shell:true can resolve the .exe.
+ * The OpenCode SDK spawns the 'opencode' command, and this ensures it can be found.
+ */
+function ensureNodeModulesBinInPath() {
+  const nodeModulesRoot = path.join(__dirname, '..', '..', 'node_modules');
+  const nodeModulesBin = path.join(nodeModulesRoot, '.bin');
+
+  if (!process.env.PATH.includes(nodeModulesBin)) {
+    process.env.PATH = `${nodeModulesBin}${path.delimiter}${process.env.PATH}`;
+  }
+
+  // On Windows, Node's spawn() does not execute .cmd shims without shell:true.
+  // Add the platform-specific native binary directory so `opencode` resolves
+  // to opencode.exe directly (Windows searches PATHEXT-aware when .exe is present).
+  if (os.platform() === 'win32') {
+    const archMap = { x64: 'x64', arm64: 'arm64' };
+    const arch = archMap[os.arch()] || os.arch();
+    const nativeBin = path.join(nodeModulesRoot, `opencode-windows-${arch}`, 'bin');
+    if (!process.env.PATH.includes(nativeBin)) {
+      process.env.PATH = `${nativeBin}${path.delimiter}${process.env.PATH}`;
+    }
+    // Baseline variant: the default build needs AVX2; opencode ships a
+    // -baseline (pre-AVX2) build for older CPUs. Windows resolves the first
+    // PATH entry containing a real opencode.exe, so default-before-baseline
+    // order matters — do not delete this block as "dead code".
+    const nativeBinBaseline = path.join(nodeModulesRoot, `opencode-windows-${arch}-baseline`, 'bin');
+    if (!process.env.PATH.includes(nativeBinBaseline)) {
+      process.env.PATH = `${nativeBinBaseline}${path.delimiter}${process.env.PATH}`;
+    }
+  }
+}
+
+module.exports = {
+  ensureNodeModulesBinInPath,
+};

package/src/utils/port-pid.js

@@ -0,0 +1,39 @@
+/**
+ * Cross-platform listener-PID lookup.
+ *
+ * Finds the PID of the process LISTENING on a local TCP port. Replaces the
+ * Unix-only `lsof` call so the OpenCode Go server can be force-killed on
+ * Windows too (F3 #15).
+ */
+
+const { execFileSync } = require('child_process');
+
+/**
+ * @param {number} port - TCP port to inspect
+ * @returns {number|null} PID of the LISTENING process, or null if none/none found
+ */
+function findListenerPid(port) {
+  try {
+    if (process.platform === 'win32') {
+      const out = execFileSync('netstat', ['-ano', '-p', 'TCP'], {
+        encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      for (const line of out.split(/\r?\n/)) {
+        // Columns: Proto  Local  Foreign  State  PID
+        const m = line.trim().match(/^TCP\s+\S+:(\d+)\s+\S+\s+LISTENING\s+(\d+)$/i);
+        if (m && Number(m[1]) === port) { return Number(m[2]); }
+      }
+      return null;
+    }
+    const out = execFileSync('lsof', ['-ti', `:${port}`, '-sTCP:LISTEN'], {
+      encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    // take only the first PID if multiple processes share the port
+    const pid = parseInt(out.split(/\s+/)[0], 10);
+    return Number.isInteger(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { findListenerPid };

package/src/utils/prompt-source.js

@@ -0,0 +1,53 @@
+// src/utils/prompt-source.js
+'use strict';
+
+/**
+ * @module prompt-source
+ * Resolve the prompt for start/fanout from --prompt XOR --prompt-file (F4).
+ * --prompt-file exists because Windows caps a CLI argument at ~32 KB, which
+ * forced fragile `--prompt "$(cat briefing)"` launches.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * @param {object} args - Parsed CLI args (kebab-case keys, as from parseArgs)
+ * @returns {{prompt: string, promptMeta: {source: 'inline'|'file', file: string|null, chars: number}} | {error: string}}
+ */
+function resolvePromptSource(args) {
+  const inline = args.prompt;
+  const file = args['prompt-file'];
+
+  if (inline !== undefined && file !== undefined) {
+    return { error: 'Error: --prompt and --prompt-file are mutually exclusive' };
+  }
+  if (inline === undefined && file === undefined) {
+    return { error: 'Error: --prompt or --prompt-file is required' };
+  }
+  if (inline === true || file === true) {
+    return { error: 'Error: --prompt/--prompt-file requires a value' };
+  }
+
+  if (file !== undefined) {
+    let text;
+    try {
+      text = fs.readFileSync(file, 'utf-8');
+    } catch (err) {
+      return { error: `Error: cannot read --prompt-file ${file}: ${err.message}` };
+    }
+    if (text.charCodeAt(0) === 0xFEFF) { text = text.slice(1); }
+    if (!text.trim()) {
+      return { error: `Error: --prompt-file ${file} is empty` };
+    }
+    return {
+      prompt: text,
+      promptMeta: { source: 'file', file: path.resolve(file), chars: text.length },
+    };
+  }
+
+  const text = String(inline);
+  return { prompt: text, promptMeta: { source: 'inline', file: null, chars: text.length } };
+}
+
+module.exports = { resolvePromptSource };