mohdel 0.90.0

package/src/cli/check.js

@@ -0,0 +1,123 @@
+import { label, err, warn, ok } from './colors.js'
+import providers from '../lib/providers.js'
+import { validate, isValidTag } from '../lib/schema.js'
+import { getCuratedModels, loadDefaultEnv } from '../lib/common.js'
+
+// --- Local validation ---
+
+const checkLocal = (curated) => {
+  const errors = []
+  const warnings = []
+  const knownProviders = new Set(Object.keys(providers))
+
+  for (const [key, spec] of Object.entries(curated)) {
+    const [keyProvider] = key.split('/')
+
+    if (spec.deprecated) {
+      if (!curated[spec.deprecated]) {
+        errors.push(`${key}: deprecated target '${spec.deprecated}' not in curated`)
+      }
+      continue
+    }
+
+    for (const issue of validate(spec, key)) {
+      if (issue.severity === 'error') errors.push(`${key}: ${issue.field} — ${issue.message}`)
+      else warnings.push(`${key}: ${issue.field} — ${issue.message}`)
+    }
+
+    if (!knownProviders.has(keyProvider)) {
+      errors.push(`${key}: provider '${keyProvider}' not in providers.js`)
+    }
+    if (spec.provider && spec.provider !== keyProvider) {
+      errors.push(`${key}: spec.provider '${spec.provider}' doesn't match key prefix '${keyProvider}'`)
+    }
+
+    const providerConfig = providers[keyProvider]
+    if (providerConfig && spec.sdk && spec.sdk !== providerConfig.sdk) {
+      errors.push(`${key}: spec.sdk '${spec.sdk}' doesn't match provider sdk '${providerConfig.sdk}'`)
+    }
+
+    if (!spec.label) warnings.push(`${key}: missing label`)
+
+    for (const priceField of ['inputPrice', 'outputPrice', 'thinkingPrice']) {
+      const val = spec[priceField]
+      if (val != null && typeof val === 'object' && val.default == null) {
+        errors.push(`${key}: ${priceField} is tiered but missing 'default' key`)
+      }
+    }
+
+    if (spec.thinkingEffortLevels && !spec.defaultThinkingEffort) {
+      warnings.push(`${key}: has thinkingEffortLevels but no defaultThinkingEffort`)
+    }
+
+    if (Array.isArray(spec.tags)) {
+      for (const t of spec.tags) {
+        if (!isValidTag(t)) warnings.push(`${key}: invalid tag "${t}" — must match /^[a-zA-Z][a-zA-Z0-9._-]{0,31}$/`)
+      }
+    }
+  }
+
+  return { errors, warnings }
+}
+
+// --- CLI ---
+
+export async function runCheck (args) {
+  if (args.includes('-h') || args.includes('--help')) {
+    console.log(`mohdel model check — validate curated catalog
+
+Usage:
+  model check [options]
+
+Options:
+  --json               Output as JSON
+
+Checks:
+  Schema types, required fields, deprecated targets, provider/sdk
+  consistency, tiered pricing, thinking config.
+
+Note: 0.90 drops the upstream-drift check that piggybacked on the
+legacy per-provider SDK factory. If you need upstream drift
+detection, file an issue — it'll be rebuilt on the /session stack.`)
+    process.exit(0)
+  }
+
+  loadDefaultEnv()
+
+  const json = args.includes('--json')
+
+  const curated = await getCuratedModels()
+  const active = Object.values(curated).filter(s => !s.deprecated).length
+  const deprecated = Object.values(curated).length - active
+
+  if (!json) {
+    console.log(`${label('Catalog:')} ${active} active, ${deprecated} deprecated\n`)
+  }
+
+  const { errors, warnings: localWarnings } = checkLocal(curated)
+
+  if (!json) {
+    if (errors.length) {
+      console.log(err(`${errors.length} error(s):`))
+      for (const e of errors) console.log(`  ${err('✗')} ${e}`)
+    }
+    if (localWarnings.length) {
+      console.log(warn(`${localWarnings.length} warning(s):`))
+      for (const w of localWarnings) console.log(`  ${warn('!')} ${w}`)
+    }
+    if (!errors.length && !localWarnings.length) {
+      console.log(ok('Local validation passed'))
+    }
+  }
+
+  if (json) {
+    console.log(JSON.stringify({
+      active,
+      deprecated,
+      errors,
+      warnings: localWarnings
+    }, null, 2))
+  }
+
+  if (errors.length) process.exit(1)
+}

package/src/cli/colored-logger.js

@@ -0,0 +1,67 @@
+/**
+ * CLI-only colored stderr logger. Extracted from `src/lib/logger.js`
+ * so that library consumers (who use `silent` or pass their own pino
+ * logger) don't pay for loading chalk. Only CLI code imports this.
+ *
+ * Matches the logger interface contract
+ * `{ trace, debug, info, warn, error, fatal, child }`. Filters by minimum
+ * level so noise stays out of the user's view.
+ *
+ * @module cli/colored-logger
+ */
+
+import chalk from 'chalk'
+
+const noop = () => {}
+
+const LEVELS = { trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60 }
+
+const COLORS = {
+  trace: chalk.dim,
+  debug: chalk.cyan,
+  info: chalk.white,
+  warn: chalk.yellow,
+  error: chalk.red,
+  fatal: chalk.bold.red
+}
+
+const LABELS = {
+  trace: 'TRC',
+  debug: 'DBG',
+  info: 'INF',
+  warn: 'WRN',
+  error: 'ERR',
+  fatal: 'FTL'
+}
+
+/**
+ * Build a colored stderr logger filtered by minimum level.
+ *
+ * @param {string} [minLevel='warn'] — minimum level to print: trace|debug|info|warn|error|fatal
+ * @returns {object} logger object
+ */
+export function cliLogger (minLevel = 'warn') {
+  const threshold = LEVELS[minLevel] ?? LEVELS.warn
+  const lg = {}
+
+  for (const level of Object.keys(LEVELS)) {
+    if (LEVELS[level] < threshold) {
+      lg[level] = noop
+    } else {
+      const color = COLORS[level]
+      const label = color(LABELS[level])
+      lg[level] = (...args) => {
+        // Pino-style: first arg may be an object with structured fields
+        if (args.length && typeof args[0] === 'object' && args[0] !== null) {
+          const [, ...rest] = args
+          console.error(label, ...rest)
+        } else {
+          console.error(label, ...args)
+        }
+      }
+    }
+  }
+
+  lg.child = () => lg
+  return lg
+}

package/src/cli/colors.js

@@ -0,0 +1,13 @@
+// Semantic color roles for CLI output.
+import chalk from 'chalk'
+
+export const id = chalk.cyan // model IDs, provider names
+export const label = chalk.bold // display names, titles
+export const tag = chalk.yellow // tags
+export const price = chalk.green // money values
+export const meta = chalk.dim // counts, field labels, headers, separators
+export const missing = chalk.dim('—') // null/absent values
+export const err = chalk.red // errors
+export const warn = chalk.yellow // warnings
+export const ok = chalk.green // success, ● dots
+export const inactive = chalk.dim // unconfigured, ○ dots

package/src/cli/default.js

@@ -0,0 +1,39 @@
+import { intro, outro, select, isCancel, cancel } from '@clack/prompts'
+import { getCuratedModels, CONFIG_PATH, saveConfig } from '../lib/common.js'
+import providers from '../lib/providers.js'
+
+export async function runDefault () {
+  intro('Mohdel — Set Default Model')
+
+  const curated = await getCuratedModels()
+  const modelOptions = Object.entries(curated).map(([modelId, info]) => ({
+    value: modelId,
+    label: `${info.label} (${modelId})`
+  }))
+  modelOptions.sort((a, b) => a.label.localeCompare(b.label))
+
+  const selectedModelId = await select({
+    message: 'Select your default model:',
+    options: modelOptions
+  })
+
+  if (isCancel(selectedModelId)) {
+    cancel('Cancelled')
+    process.exit(0)
+  }
+
+  const [providerName] = selectedModelId.split('/')
+
+  try {
+    const config = { defaultModel: selectedModelId }
+    const apiKeyEnv = providers[providerName]?.apiKeyEnv
+    if (apiKeyEnv) {
+      config.apiKeyInfo = `Set ${apiKeyEnv} environment variable for this provider`
+    }
+    await saveConfig(config)
+    outro(`Default set to ${selectedModelId} — saved to ${CONFIG_PATH}`)
+  } catch (err) {
+    cancel(`Error: ${err.message}`)
+    process.exit(1)
+  }
+}

package/src/cli/index.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+/**
+ * mohdel CLI — model management (noun-verb pattern).
+ *
+ * Nouns: model, provider, creator, tag, ratelimit
+ * Each noun supports: list, show, and noun-specific verbs.
+ *
+ * Aliases: ls → model list, rl → ratelimit
+ */
+
+const [command, ...args] = process.argv.slice(2)
+
+if (!command) {
+  const { runOnboard } = await import('./onboard.js')
+  await runOnboard()
+  process.exit(0)
+}
+
+if (command === '-h' || command === '--help') {
+  console.log(`mohdel — model catalog management
+
+Commands:
+  model list [--sort price|context|name]  List all curated models
+  model search <term>                     Filter models by name/label
+  model stats                             Catalog summary
+  model show <model>                      Show model details
+  model get <model> <key>                 Get a field value
+  model set <model> <key> <value>         Set a field
+  model rm <model> <key>                  Remove a field
+  model add <provider>/<model-id>         Add a model manually
+  model check [--local]                   Validate catalog
+  model rank [--use-case <name>]          Rank models by benchmarks
+  model bench <model>                     Benchmark with live inference
+  model curate [provider]                 Add upstream models to catalog
+
+  provider list                           List all providers
+  provider list <provider>                List models from a provider
+  provider setup <provider>               Configure API key (interactive)
+  provider rm <provider>                  Remove API key
+
+  creator list                            List all creators
+  creator list <creator>                  List models by a creator
+
+  tag list                                List all unique tags
+  tag list <model>                        Show tags on a model
+  tag show <tag>                          List models with a tag
+  tag add <model> <tag>                   Add a tag
+  tag rm <model> <tag>                    Remove a tag
+
+  ratelimit show <model|provider>         Show effective limits
+  ratelimit set <model> [rpm] [tpm]       Set model-level limits
+  ratelimit rm <model>                    Remove model-level limits
+  ratelimit provider set <p> [rpm] [tpm]  Set provider-level limits
+  ratelimit provider rm <p>               Remove provider-level limits
+
+  ask <provider/model> [prompt]           One-shot inference (pipeable)
+
+  default                                 Set default model (interactive)
+
+Aliases:
+  models                model list
+  providers             provider list
+  creators              creator list
+  tags                  tag list
+  ls                    model list
+  show <model>          model show <model>
+  search <term>         model search <term>
+  stats                 model stats
+  check                 model check
+  setup <provider>      provider setup <provider>
+  rank                  model rank
+  bench <model>         model bench <model>
+  curate [provider]     model curate [provider]
+  rl                    ratelimit
+
+Global flags:
+  --json [fields]       Output as JSON (omit fields to list available)
+
+Environment:
+  API keys are loaded from ~/.config/mohdel/environment (KEY=value format).
+  Run "mo" with no arguments to configure interactively.
+
+  ANTHROPIC_API_SK      Anthropic API key
+  OPENAI_API_SK         OpenAI API key
+  GEMINI_API_SK         Google Gemini API key
+  GROQ_API_SK           Groq API key
+  CEREBRAS_API_SK       Cerebras API key
+  XAI_API_SK            xAI API key
+  MISTRAL_API_SK        Mistral API key
+  DEEPSEEK_API_SK       DeepSeek API key
+  FIREWORKS_API_SK      Fireworks API key
+  OPENROUTER_API_SK     OpenRouter API key
+  NOVITA_API_SK         Novita API key
+
+Configuration:
+  ~/.config/mohdel/environment      API keys (loaded automatically)
+  ~/.config/mohdel/curated.json     Model catalog
+  ~/.config/mohdel/providers.json   Provider-level rate limits
+  ~/.config/mohdel/default.json     Default model selection`)
+  process.exit(0)
+}
+
+// Alias resolution: short commands → noun + verb
+const ALIASES = {
+  models: { noun: 'model', inject: ['list'] },
+  providers: { noun: 'provider', inject: ['list'] },
+  creators: { noun: 'creator', inject: ['list'] },
+  tags: { noun: 'tag', inject: ['list'] },
+  ls: { noun: 'model', inject: ['list'] },
+  show: { noun: 'model', inject: ['show'] },
+  search: { noun: 'model', inject: ['search'] },
+  stats: { noun: 'model', inject: ['stats'] },
+  check: { noun: 'model', inject: ['check'] },
+  setup: { noun: 'provider', inject: ['setup'] },
+  rank: { noun: 'model', inject: ['rank'] },
+  bench: { noun: 'model', inject: ['bench'] },
+  curate: { noun: 'model', inject: ['curate'] },
+  rl: { noun: 'ratelimit', inject: [] }
+}
+
+const alias = ALIASES[command]
+const resolved = alias ? alias.noun : command
+const resolvedArgs = alias ? [...alias.inject, ...args] : args
+
+if (resolved === 'default') {
+  const { runDefault } = await import('./default.js')
+  await runDefault()
+} else if (resolved === 'ask') {
+  const { runAsk } = await import('./ask.js')
+  await runAsk(resolvedArgs)
+} else if (resolved === 'model') {
+  const { runModel } = await import('./model.js')
+  await runModel(resolvedArgs)
+} else if (resolved === 'provider') {
+  const { runProvider } = await import('./model.js')
+  await runProvider(resolvedArgs)
+} else if (resolved === 'creator') {
+  const { runCreator } = await import('./model.js')
+  await runCreator(resolvedArgs)
+} else if (resolved === 'tag') {
+  const { runTag } = await import('./tag.js')
+  await runTag(resolvedArgs)
+} else if (resolved === 'ratelimit' || resolved === 'rl') {
+  const { runRateLimit } = await import('./ratelimit.js')
+  await runRateLimit(resolvedArgs)
+} else {
+  console.error(`Unknown command: ${command}. Run "mo --help" for usage.`)
+  process.exit(1)
+}

package/src/cli/json-output.js

@@ -0,0 +1,60 @@
+// --json flag support (gh-style):
+//   --json           → list available fields
+//   --json f1,f2,f3  → output only those fields
+
+/**
+ * Extract --json flag and its value from args.
+ * Returns { json: false } or { json: true, fields: null } (list fields)
+ * or { json: true, fields: ['f1','f2'] } (filter).
+ * Mutates args in place to remove consumed --json [value].
+ */
+export function parseJsonFlag (args) {
+  const idx = args.indexOf('--json')
+  if (idx === -1) return { json: false }
+
+  args.splice(idx, 1)
+
+  // Next arg is the field list (if it exists and doesn't look like a flag)
+  const next = args[idx]
+  if (next && !next.startsWith('-')) {
+    args.splice(idx, 1)
+    return { json: true, fields: next.split(',').map(f => f.trim()).filter(Boolean) }
+  }
+
+  return { json: true, fields: null }
+}
+
+/**
+ * Print available fields for a --json call with no field list.
+ */
+export function printAvailableFields (fields) {
+  console.log('Available JSON fields:')
+  for (const f of fields) console.log(`  ${f}`)
+}
+
+/**
+ * Pick selected fields from an object.
+ */
+function pick (obj, fields) {
+  const out = {}
+  for (const f of fields) {
+    if (f in obj) out[f] = obj[f]
+  }
+  return out
+}
+
+/**
+ * Output a list of objects as JSON, optionally filtered to specific fields.
+ */
+export function jsonOutput (items, fields) {
+  const out = fields ? items.map(item => pick(item, fields)) : items
+  console.log(JSON.stringify(out, null, 2))
+}
+
+/**
+ * Output a single object as JSON, optionally filtered to specific fields.
+ */
+export function jsonOutputOne (item, fields) {
+  const out = fields ? pick(item, fields) : item
+  console.log(JSON.stringify(out, null, 2))
+}