@xelauvas/xela-cli 0.3.0 → 0.4.0

package/src/utils/yaml.ts

@@ -1,15 +1,261 @@
 /**
  * YAML parsing wrapper.
  *
- * Uses Bun.YAML (built-in, zero-cost) when running under Bun, otherwise falls
- * back to the `yaml` npm package. The package is lazy-required inside the
- * non-Bun branch so native Bun builds never load the ~270KB yaml parser.
+ * Uses Bun.YAML when running under Bun, the `yaml` npm package when it is
+ * installed, and otherwise a built-in parser for the YAML subset that skill
+ * frontmatter and plugin manifests use (block mappings and sequences, flow
+ * arrays, quoted/plain scalars, `|` and `>` block scalars, comments). Before
+ * this fallback existed a missing package silently produced empty frontmatter,
+ * so every skill lost its description.
  */
 
 export function parseYaml(input: string): unknown {
   if (typeof Bun !== 'undefined') {
     return Bun.YAML.parse(input)
   }
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  return (require('yaml') as typeof import('yaml')).parse(input)
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require('yaml') as { parse?: (s: string) => unknown }
+    if (mod && typeof mod.parse === 'function') {
+      const out = mod.parse(input)
+      // The missing-module stub returns its argument unchanged
+      if (out !== input) return out
+    }
+  } catch {
+    // fall through to the built-in parser
+  }
+  return parseYamlSubset(input)
+}
+
+type Line = { indent: number; text: string; raw: string }
+
+function splitLines(input: string): Line[] {
+  const lines: Line[] = []
+  for (const raw of input.replace(/\r\n?/g, '\n').split('\n')) {
+    const text = stripComment(raw).replace(/\s+$/, '')
+    if (text.trim() === '') continue
+    const indent = raw.length - raw.replace(/^[ \t]*/, '').length
+    lines.push({ indent, text: text.trim(), raw })
+  }
+  return lines
+}
+
+function stripComment(line: string): string {
+  let inSingle = false
+  let inDouble = false
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i]
+    if (ch === "'" && !inDouble) inSingle = !inSingle
+    else if (ch === '"' && !inSingle) inDouble = !inDouble
+    else if (ch === '#' && !inSingle && !inDouble && (i === 0 || /\s/.test(line[i - 1]!))) {
+      return line.slice(0, i)
+    }
+  }
+  return line
+}
+
+function parseScalar(text: string): unknown {
+  const t = text.trim()
+  if (t === '' || t === '~' || t === 'null' || t === 'Null' || t === 'NULL') return null
+  if (t === 'true' || t === 'True' || t === 'TRUE') return true
+  if (t === 'false' || t === 'False' || t === 'FALSE') return false
+  if (/^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?$/.test(t)) return Number(t)
+  if (/^0x[0-9a-fA-F]+$/.test(t)) return parseInt(t, 16)
+  if (t.startsWith('"') && t.endsWith('"') && t.length >= 2) {
+    try {
+      return JSON.parse(t)
+    } catch {
+      return t.slice(1, -1)
+    }
+  }
+  if (t.startsWith("'") && t.endsWith("'") && t.length >= 2) {
+    return t.slice(1, -1).replace(/''/g, "'")
+  }
+  if (t.startsWith('[') && t.endsWith(']')) return parseFlowArray(t)
+  if (t.startsWith('{') && t.endsWith('}')) return parseFlowMap(t)
+  return t
+}
+
+function splitFlow(inner: string): string[] {
+  const parts: string[] = []
+  let depth = 0
+  let quote: string | null = null
+  let current = ''
+  for (const ch of inner) {
+    if (quote) {
+      current += ch
+      if (ch === quote) quote = null
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+      current += ch
+    } else if (ch === '[' || ch === '{') {
+      depth++
+      current += ch
+    } else if (ch === ']' || ch === '}') {
+      depth--
+      current += ch
+    } else if (ch === ',' && depth === 0) {
+      parts.push(current)
+      current = ''
+    } else {
+      current += ch
+    }
+  }
+  if (current.trim() !== '') parts.push(current)
+  return parts
+}
+
+function parseFlowArray(text: string): unknown[] {
+  const inner = text.slice(1, -1).trim()
+  if (inner === '') return []
+  return splitFlow(inner).map(p => parseScalar(p))
+}
+
+function parseFlowMap(text: string): Record<string, unknown> {
+  const inner = text.slice(1, -1).trim()
+  const out: Record<string, unknown> = {}
+  if (inner === '') return out
+  for (const part of splitFlow(inner)) {
+    const idx = part.indexOf(':')
+    if (idx < 0) continue
+    out[parseScalar(part.slice(0, idx)) as string] = parseScalar(part.slice(idx + 1))
+  }
+  return out
+}
+
+/** Splits "key: value" at the first colon that is followed by a space or end. */
+function splitKeyValue(text: string): { key: string; value: string } | null {
+  let quote: string | null = null
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]
+    if (quote) {
+      if (ch === quote) quote = null
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+      continue
+    }
+    if (ch === ':' && (i === text.length - 1 || text[i + 1] === ' ')) {
+      return { key: String(parseScalar(text.slice(0, i))), value: text.slice(i + 1).trim() }
+    }
+  }
+  return null
+}
+
+function parseBlock(lines: Line[], start: number, indent: number): { value: unknown; next: number } {
+  if (start >= lines.length) return { value: null, next: start }
+  if (lines[start]!.text.startsWith('- ') || lines[start]!.text === '-') {
+    return parseSequence(lines, start, indent)
+  }
+  return parseMapping(lines, start, indent)
+}
+
+function parseBlockScalar(lines: Line[], start: number, indent: number, style: '|' | '>'): { value: string; next: number } {
+  const collected: string[] = []
+  let i = start
+  let base = -1
+  while (i < lines.length && lines[i]!.indent > indent) {
+    const raw = lines[i]!.raw.replace(/\s+$/, '')
+    if (base < 0) base = lines[i]!.indent
+    collected.push(raw.slice(Math.min(base, raw.length - raw.trimStart().length)))
+    i++
+  }
+  const text = style === '|' ? collected.join('\n') : collected.join(' ').replace(/\s+/g, ' ')
+  return { value: text, next: i }
+}
+
+function parseMapping(lines: Line[], start: number, indent: number): { value: Record<string, unknown>; next: number } {
+  const out: Record<string, unknown> = {}
+  let i = start
+  while (i < lines.length) {
+    const line = lines[i]!
+    if (line.indent < indent) break
+    if (line.indent > indent) {
+      i++
+      continue
+    }
+    const kv = splitKeyValue(line.text)
+    if (!kv) {
+      i++
+      continue
+    }
+    if (kv.value === '' ) {
+      // nested block or empty
+      if (i + 1 < lines.length && lines[i + 1]!.indent > indent) {
+        const nested = parseBlock(lines, i + 1, lines[i + 1]!.indent)
+        out[kv.key] = nested.value
+        i = nested.next
+      } else if (i + 1 < lines.length && lines[i + 1]!.indent === indent && lines[i + 1]!.text.startsWith('- ')) {
+        // sequence at the same indentation as its key (common YAML style)
+        const nested = parseSequence(lines, i + 1, indent)
+        out[kv.key] = nested.value
+        i = nested.next
+      } else {
+        out[kv.key] = null
+        i++
+      }
+    } else if (kv.value === '|' || kv.value === '>' || kv.value === '|-' || kv.value === '>-') {
+      const block = parseBlockScalar(lines, i + 1, indent, kv.value[0] as '|' | '>')
+      out[kv.key] = kv.value.endsWith('-') ? block.value.replace(/\n+$/, '') : block.value
+      i = block.next
+    } else {
+      out[kv.key] = parseScalar(kv.value)
+      i++
+    }
+  }
+  return { value: out, next: i }
+}
+
+function parseSequence(lines: Line[], start: number, indent: number): { value: unknown[]; next: number } {
+  const out: unknown[] = []
+  let i = start
+  while (i < lines.length) {
+    const line = lines[i]!
+    if (line.indent < indent) break
+    if (line.indent > indent || !(line.text.startsWith('- ') || line.text === '-')) {
+      i++
+      continue
+    }
+    const rest = line.text === '-' ? '' : line.text.slice(2).trim()
+    if (rest === '') {
+      if (i + 1 < lines.length && lines[i + 1]!.indent > indent) {
+        const nested = parseBlock(lines, i + 1, lines[i + 1]!.indent)
+        out.push(nested.value)
+        i = nested.next
+      } else {
+        out.push(null)
+        i++
+      }
+      continue
+    }
+    const kv = splitKeyValue(rest)
+    if (kv && !rest.startsWith('"') && !rest.startsWith("'") && !rest.startsWith('[') && !rest.startsWith('{')) {
+      // "- key: value" starts an inline mapping whose other keys follow at indent + 2
+      const item: Record<string, unknown> = {}
+      item[kv.key] = kv.value === '' ? null : parseScalar(kv.value)
+      let j = i + 1
+      const childIndent = indent + 2
+      if (j < lines.length && lines[j]!.indent >= childIndent) {
+        const more = parseMapping(lines, j, lines[j]!.indent)
+        Object.assign(item, more.value)
+        j = more.next
+      }
+      out.push(item)
+      i = j
+    } else {
+      out.push(parseScalar(rest))
+      i++
+    }
+  }
+  return { value: out, next: i }
+}
+
+export function parseYamlSubset(input: string): unknown {
+  const lines = splitLines(input)
+  if (lines.length === 0) return null
+  const first = lines[0]!
+  return parseBlock(lines, 0, first.indent).value
 }

package/src/utils/model/providerModels.ts

@@ -1,168 +0,0 @@
-import OpenAI from 'openai'
-import { MODEL_ALIASES } from './aliases.js'
-
-export type ProviderModel = {
-  id: string
-  name: string
-}
-
-export type ProviderName =
-  | 'openai'
-  | 'groq'
-  | 'openrouter'
-  | 'deepseek'
-  | 'mistral'
-  | 'together'
-  | 'ollama'
-  | 'fireworks'
-  | 'moonshot'
-  | 'unknown'
-
-/**
- * Returns true if the model name is a Claude model name or alias.
- * These don't exist on OpenAI-compatible providers, so the adapter
- * should fall back to the provider default.
- */
-export function isClaudeModelName(model: string): boolean {
-  const lower = model.toLowerCase().trim()
-  if (lower.includes('claude')) return true
-  return (MODEL_ALIASES as readonly string[]).includes(lower)
-}
-
-/**
- * Detect which OpenAI-compatible provider is configured.
- */
-export function detectOpenAIProvider(): ProviderName {
-  const key = process.env.OPENAI_API_KEY || ''
-  const baseURL = process.env.OPENAI_BASE_URL || ''
-
-  if (baseURL.includes('groq.com') || key.startsWith('gsk_')) return 'groq'
-  if (baseURL.includes('openrouter.ai') || key.startsWith('sk-or-')) return 'openrouter'
-  if (baseURL.includes('deepseek.com')) return 'deepseek'
-  if (baseURL.includes('mistral.ai')) return 'mistral'
-  if (baseURL.includes('together.xyz')) return 'together'
-  if (baseURL.includes('localhost') || baseURL.includes('127.0.0.1')) return 'ollama'
-  if (baseURL.includes('fireworks.ai')) return 'fireworks'
-  if (baseURL.includes('moonshot.cn') || baseURL.includes('moonshot.ai')) return 'moonshot'
-  if (!baseURL || baseURL.includes('openai.com')) return 'openai'
-  return 'unknown'
-}
-
-const CURATED_MODELS: Record<ProviderName, ProviderModel[]> = {
-  openai: [
-    { id: 'gpt-4o', name: 'GPT-4o' },
-    { id: 'gpt-4o-mini', name: 'GPT-4o Mini' },
-    { id: 'gpt-4.1', name: 'GPT-4.1' },
-    { id: 'gpt-4.1-mini', name: 'GPT-4.1 Mini' },
-    { id: 'o3', name: 'o3' },
-    { id: 'o4-mini', name: 'o4 Mini' },
-  ],
-  groq: [
-    { id: 'llama-3.3-70b-versatile', name: 'Llama 3.3 70B' },
-    { id: 'llama-3.1-8b-instant', name: 'Llama 3.1 8B Instant' },
-    { id: 'gemma2-9b-it', name: 'Gemma 2 9B' },
-    { id: 'mixtral-8x7b-32768', name: 'Mixtral 8x7B' },
-  ],
-  openrouter: [
-    { id: 'google/gemini-2.0-flash-001', name: 'Gemini 2.0 Flash' },
-    { id: 'openai/gpt-4o', name: 'GPT-4o' },
-    { id: 'meta-llama/llama-3.3-70b', name: 'Llama 3.3 70B' },
-  ],
-  deepseek: [
-    { id: 'deepseek-chat', name: 'DeepSeek Chat' },
-    { id: 'deepseek-reasoner', name: 'DeepSeek Reasoner' },
-  ],
-  mistral: [
-    { id: 'mistral-large-latest', name: 'Mistral Large' },
-    { id: 'mistral-small-latest', name: 'Mistral Small' },
-    { id: 'codestral-latest', name: 'Codestral' },
-  ],
-  together: [
-    { id: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', name: 'Llama 3.3 70B Turbo' },
-    { id: 'Qwen/Qwen2.5-72B-Instruct-Turbo', name: 'Qwen 2.5 72B Turbo' },
-  ],
-  ollama: [
-    { id: 'llama3.2', name: 'Llama 3.2' },
-    { id: 'qwen2.5-coder', name: 'Qwen 2.5 Coder' },
-    { id: 'deepseek-r1', name: 'DeepSeek R1' },
-    { id: 'mistral', name: 'Mistral' },
-  ],
-  fireworks: [
-    { id: 'accounts/fireworks/models/llama-v3p3-70b-instruct', name: 'Llama 3.3 70B' },
-  ],
-  moonshot: [
-    { id: 'moonshot-v1-32k', name: 'Moonshot V1 32K' },
-    { id: 'moonshot-v1-128k', name: 'Moonshot V1 128K' },
-  ],
-  unknown: [],
-}
-
-export function getCuratedModels(provider: ProviderName): ProviderModel[] {
-  return CURATED_MODELS[provider] ?? []
-}
-
-let cachedModels: ProviderModel[] | null = null
-
-/**
- * Fetch all available models from the provider via GET /v1/models.
- * Results are cached in memory for the session.
- * Returns curated fallback list on failure.
- */
-export async function fetchProviderModels(): Promise<ProviderModel[]> {
-  if (cachedModels !== null) {
-    return cachedModels
-  }
-
-  const provider = detectOpenAIProvider()
-
-  try {
-    const client = new OpenAI({
-      apiKey: process.env.OPENAI_API_KEY,
-      ...(process.env.OPENAI_BASE_URL ? { baseURL: process.env.OPENAI_BASE_URL } : {}),
-      ...(provider === 'groq' && !process.env.OPENAI_BASE_URL
-        ? { baseURL: 'https://api.groq.com/openai/v1' }
-        : {}),
-      ...(provider === 'openrouter' && !process.env.OPENAI_BASE_URL
-        ? { baseURL: 'https://openrouter.ai/api/v1' }
-        : {}),
-    })
-
-    const response = await client.models.list({}, { timeout: 5000 })
-    const models: ProviderModel[] = []
-
-    for await (const model of response) {
-      models.push({ id: model.id, name: model.id })
-    }
-
-    models.sort((a, b) => a.id.localeCompare(b.id))
-    cachedModels = models
-    return models
-  } catch {
-    const fallback = getCuratedModels(provider)
-    cachedModels = fallback
-    return fallback
-  }
-}
-
-/**
- * Check if a model ID exists in the cached provider model list.
- * Returns false if the cache hasn't been populated yet.
- */
-export function isKnownProviderModel(modelId: string): boolean {
-  if (!cachedModels) return false
-  return cachedModels.some(m => m.id === modelId)
-}
-
-/**
- * Returns true if the app is using an OpenAI-compatible backend.
- */
-export function isOpenAIBackend(): boolean {
-  return !!process.env.OPENAI_API_KEY
-}
-
-/**
- * Get the startup default model for the current OpenAI provider.
- */
-export function getOpenAIDefaultModel(): string {
-  return process.env.OPENAI_MODEL || 'gpt-4o'
-}