ethagent 3.3.3 → 4.0.0

package/src/models/modelPickerViewHelpers.ts

@@ -1,174 +0,0 @@
-import type { SelectOption } from '../ui/Select.js'
-import type { ProviderId } from '../storage/config.js'
-import { defaultModelFor, type EthagentConfig } from '../storage/config.js'
-import type { LlamaCppInstallResult } from './llamacpp.js'
-import { orderGgufFilesForSpec, type GgufMachineFit } from './modelRecommendation.js'
-import {
-  localModelId,
-  type HuggingFaceRepoInfo,
-  type HuggingFaceSibling,
-} from './huggingface.js'
-import {
-  MODEL_PICKER_CLOUD_PROVIDERS,
-  orderModelsForContextFit,
-  type CloudProviderId,
-  type ModelPickerContextFit,
-} from './modelPickerOptions.js'
-import { formatModelDisplayName } from './modelDisplay.js'
-import { contextFitLabel, formatBytes, modelMetadataSubtext } from './modelPickerDisplay.js'
-import type { LoadedModelPickerData as LoadedData, ModelPickerSelection } from './modelPickerTypes.js'
-import type { ModelCatalogResult } from './catalog.js'
-import type { SpecSnapshot } from './runtimeDetection.js'
-
-export function buildCatalogOptions(
-  provider: CloudProviderId,
-  catalog: ModelCatalogResult | undefined,
-  currentProvider: ProviderId,
-  currentModel: string,
-  contextFit?: ModelPickerContextFit | null,
-): SelectOption<string>[] {
-  if (!catalog || catalog.entries.length === 0) {
-    return [{
-      value: `hdr:catalog-empty:${provider}`,
-      label: 'No Models Found',
-      disabled: true,
-      role: 'notice',
-      prefix: 'note',
-    }]
-  }
-  const sourceById = new Map(catalog.entries.map(entry => [entry.id, entry.source]))
-  return orderModelsForContextFit(provider, catalog.entries.map(entry => entry.id), contextFit).map(id => {
-    const active = currentProvider === provider && currentModel === id
-    const suffix = sourceById.get(id) === 'fallback' ? '  fallback' : ''
-    const displayName = formatModelDisplayName(provider, id, { maxLength: 64 })
-    return {
-      value: `full:${provider}:${id}`,
-      label: contextFitLabel(provider, id, `${displayName}${active ? '  *' : ''}${suffix}`, contextFit),
-      role: 'option',
-    }
-  })
-}
-
-export function parseCloudValue(value: string): { provider: CloudProviderId; model: string } | null {
-  if (!value.startsWith('c:')) return null
-  const rest = value.slice(2)
-  const sep = rest.indexOf(':')
-  if (sep === -1) return null
-  const provider = rest.slice(0, sep)
-  const model = rest.slice(sep + 1)
-  if (!isCloudProvider(provider) || !model) return null
-  return { provider, model }
-}
-
-export function localModelOptionIndex(
-  options: SelectOption<string>[],
-  currentProvider: ProviderId,
-  currentModel: string,
-): number {
-  return options.findIndex(opt => {
-    if (opt.disabled) return false
-    if (opt.value.startsWith('hf:')) return opt.value.slice(3) === currentModel && currentProvider === 'llamacpp'
-    if (opt.value.startsWith('uc:')) return opt.value.slice(3) === currentModel && currentProvider === 'llamacpp'
-    return false
-  })
-}
-
-export function localOrCloudOptionIndex(
-  options: SelectOption<string>[],
-  currentProvider: ProviderId,
-  currentModel: string,
-): number {
-  return options.findIndex(opt => {
-    if (opt.disabled) return false
-    if (opt.value.startsWith('hf:')) return opt.value.slice(3) === currentModel && currentProvider === 'llamacpp'
-    if (opt.value.startsWith('uc:')) return opt.value.slice(3) === currentModel && currentProvider === 'llamacpp'
-    const cloud = parseCloudValue(opt.value)
-    return cloud?.provider === currentProvider && cloud.model === currentModel
-  })
-}
-
-export function parseFullCatalogValue(value: string): { provider: CloudProviderId; model: string } | null {
-  if (!value.startsWith('full:')) return null
-  const rest = value.slice(5)
-  const sep = rest.indexOf(':')
-  if (sep === -1) return null
-  const provider = rest.slice(0, sep)
-  const model = rest.slice(sep + 1)
-  if (!isCloudProvider(provider) || !model) return null
-  return { provider, model }
-}
-
-export function parseKeyValue(value: string): { action: 'set' | 'edit' | 'manage'; provider: CloudProviderId } | null {
-  if (!value.startsWith('key:')) return null
-  const parts = value.split(':')
-  if (parts.length !== 3) return null
-  const action = parts[1]
-  const provider = parts[2]
-  if (action !== 'set' && action !== 'edit' && action !== 'manage') return null
-  if (!provider) return null
-  if (!isCloudProvider(provider)) return null
-  return { action, provider }
-}
-
-export function pickFallbackSelection(data: LoadedData, removed: ProviderId): ModelPickerSelection | null {
-  for (const provider of MODEL_PICKER_CLOUD_PROVIDERS) {
-    if (provider === removed) continue
-    if (data.cloudKeys[provider] !== true) continue
-    const catalogModel = data.cloudCatalogs[provider]?.entries[0]?.id
-    const model = catalogModel ?? defaultModelFor(provider)
-    return { kind: 'cloud', provider, model, keyJustSet: false }
-  }
-  if (data.hfModels.length > 0) {
-    return { kind: 'llamacpp', model: data.hfModels[0]!.id }
-  }
-  return null
-}
-
-export function configForProvider(config: EthagentConfig, provider: CloudProviderId): EthagentConfig {
-  return {
-    ...config,
-    provider,
-    model: config.provider === provider ? config.model : defaultModelFor(provider),
-    baseUrl: provider === 'openai' && config.provider === 'openai' ? config.baseUrl : undefined,
-  }
-}
-
-export function buildHfFileOptions(
-  repo: HuggingFaceRepoInfo,
-  files: HuggingFaceSibling[],
-  spec: SpecSnapshot | undefined,
-  installedModelIds: string[] = [],
-): SelectOption<string>[] {
-  const ordered = spec
-    ? orderGgufFilesForSpec(repo, files, spec)
-    : files.map(file => ({ file, fit: 'unknown' as GgufMachineFit, score: 0, budgetBytes: 0 }))
-  const recommended = spec ? ordered[0]?.file.filename : undefined
-  const installed = new Set(installedModelIds)
-  return ordered.map(item => {
-    const size = item.file.sizeBytes ? formatBytes(item.file.sizeBytes) : ''
-    const indicators = [
-      item.file.filename === recommended ? 'Recommended' : '',
-      installed.has(localModelId(repo.repoId, item.file.filename)) ? 'Installed' : '',
-    ]
-    return {
-      value: item.file.filename,
-      label: item.file.filename,
-      subtext: modelMetadataSubtext(size, indicators),
-      role: 'option' as const,
-    }
-  })
-}
-
-export function buildRunnerRecoveryOptions(
-  _result: Extract<LlamaCppInstallResult, { ok: false }>,
-): SelectOption<'stop-and-retry' | 'path' | 'back'>[] {
-  return [
-    { value: 'stop-and-retry', label: 'Stop and Retry', hint: 'Stop background runners and try the install again' },
-    { value: 'path', label: 'Use Existing Runner Path' },
-    { value: 'back', label: 'Back To Picker' },
-  ]
-}
-
-function isCloudProvider(value: string): value is CloudProviderId {
-  return MODEL_PICKER_CLOUD_PROVIDERS.includes(value as CloudProviderId)
-}

package/src/models/modelRecommendation.ts

@@ -1,139 +0,0 @@
-import {
-  fileFormat,
-  quantizationFromFilename,
-  type HuggingFaceRepoInfo,
-  type HuggingFaceSibling,
-} from './huggingface.js'
-import type { SpecSnapshot } from './runtimeDetection.js'
-
-const GB = 1024 * 1024 * 1024
-
-export const FEATURED_HF_REPO = 'HauhauCS/Qwen3.5-9B-Uncensored-HauhauCS-Aggressive'
-export const FEATURED_HF_REPO_URL = `https://huggingface.co/${FEATURED_HF_REPO}`
-
-export type GgufMachineFit = 'fits' | 'tight' | 'too-large' | 'unknown'
-
-export type GgufFileRecommendation = {
-  file: HuggingFaceSibling
-  fit: GgufMachineFit
-  score: number
-  budgetBytes: number
-  estimatedRequiredBytes?: number
-}
-
-export function recommendGgufFile(
-  repo: HuggingFaceRepoInfo,
-  files: HuggingFaceSibling[],
-  spec: SpecSnapshot,
-): GgufFileRecommendation | null {
-  return orderGgufFilesForSpec(repo, files, spec)[0] ?? null
-}
-
-export function orderGgufFilesForSpec(
-  repo: HuggingFaceRepoInfo,
-  files: HuggingFaceSibling[],
-  spec: SpecSnapshot,
-): GgufFileRecommendation[] {
-  return files
-    .filter(file => fileFormat(file.filename) === 'gguf')
-    .map(file => scoreGgufFile(repo, file, spec))
-    .sort((a, b) =>
-      b.score - a.score
-      || fitRank(b.fit) - fitRank(a.fit)
-      || (a.file.sizeBytes ?? Number.MAX_SAFE_INTEGER) - (b.file.sizeBytes ?? Number.MAX_SAFE_INTEGER)
-      || a.file.filename.localeCompare(b.file.filename),
-    )
-}
-
-export function estimateGgufMachineFit(sizeBytes: number | undefined, spec: SpecSnapshot): {
-  fit: GgufMachineFit
-  budgetBytes: number
-  estimatedRequiredBytes?: number
-} {
-  const budgetBytes = ggufBudgetBytes(spec)
-  if (!sizeBytes || sizeBytes <= 0) return { fit: 'unknown', budgetBytes }
-  const estimatedRequiredBytes = Math.ceil(sizeBytes * 1.25 + GB)
-  if (estimatedRequiredBytes <= budgetBytes) return { fit: 'fits', budgetBytes, estimatedRequiredBytes }
-  if (estimatedRequiredBytes <= budgetBytes * 1.15) return { fit: 'tight', budgetBytes, estimatedRequiredBytes }
-  return { fit: 'too-large', budgetBytes, estimatedRequiredBytes }
-}
-
-function scoreGgufFile(
-  repo: HuggingFaceRepoInfo,
-  file: HuggingFaceSibling,
-  spec: SpecSnapshot,
-): GgufFileRecommendation {
-  const fit = estimateGgufMachineFit(file.sizeBytes, spec)
-  const lower = `${repo.repoId} ${file.filename} ${repo.tags.join(' ')}`.toLowerCase()
-  const score =
-    fitScore(fit.fit)
-    + taskScore(lower)
-    + quantizationScore(quantizationFromFilename(file.filename))
-    + sizeScore(file.sizeBytes, fit.fit)
-
-  return {
-    file,
-    fit: fit.fit,
-    budgetBytes: fit.budgetBytes,
-    estimatedRequiredBytes: fit.estimatedRequiredBytes,
-    score,
-  }
-}
-
-function ggufBudgetBytes(spec: SpecSnapshot): number {
-  if (spec.isAppleSilicon) return Math.floor(spec.effectiveRamBytes * 0.7)
-  const cpuBudget = Math.floor(spec.effectiveRamBytes * 0.55)
-  if (spec.gpuVramBytes !== null && spec.gpuVramBytes >= 8 * GB) {
-    return Math.max(cpuBudget, Math.floor(spec.gpuVramBytes * 0.85))
-  }
-  return cpuBudget
-}
-
-function fitScore(fit: GgufMachineFit): number {
-  switch (fit) {
-    case 'fits': return 1000
-    case 'tight': return 600
-    case 'unknown': return 250
-    case 'too-large': return -1000
-  }
-}
-
-function fitRank(fit: GgufMachineFit): number {
-  switch (fit) {
-    case 'fits': return 3
-    case 'tight': return 2
-    case 'unknown': return 1
-    case 'too-large': return 0
-  }
-}
-
-function taskScore(text: string): number {
-  if (/(embed|embedding|rerank)/.test(text)) return -350
-  if (/(vision|vlm|multimodal)/.test(text)) return -250
-  if (/(instruct|chat|assistant)/.test(text)) return 250
-  if (/(code|coder|coding)/.test(text)) return 120
-  if (/(^|[-_\s])base($|[-_\s])/.test(text)) return -100
-  return 0
-}
-
-function quantizationScore(quantization: string | undefined): number {
-  if (!quantization) return 0
-  if (quantization === 'Q8_0') return 210
-  if (quantization === 'Q6_K') return 195
-  if (quantization === 'Q5_K_M') return 185
-  if (quantization === 'Q5_K_S') return 175
-  if (quantization.startsWith('Q5')) return 165
-  if (quantization === 'Q4_K_M') return 155
-  if (quantization === 'Q4_K_S') return 140
-  if (quantization.startsWith('Q4')) return 125
-  if (quantization.startsWith('IQ4')) return 115
-  if (quantization.startsWith('IQ3') || quantization.startsWith('Q3')) return 85
-  if (quantization === 'F16' || quantization === 'BF16') return 150
-  if (quantization === 'F32') return 90
-  return 50
-}
-
-function sizeScore(sizeBytes: number | undefined, fit: GgufMachineFit): number {
-  if (!sizeBytes || fit === 'too-large') return 0
-  return Math.min(sizeBytes / GB, 20) * 4
-}

package/src/models/providerDisplay.ts

@@ -1,16 +0,0 @@
-import type { ProviderId } from '../storage/config.js'
-
-export type CloudProviderId = Exclude<ProviderId, 'llamacpp'>
-
-export function cloudProviderDisplayName(provider: CloudProviderId): string {
-  switch (provider) {
-    case 'openai': return 'OpenAI'
-    case 'anthropic': return 'Anthropic'
-    case 'gemini': return 'Gemini'
-  }
-}
-
-export function providerDisplayName(provider: ProviderId): string {
-  if (provider === 'llamacpp') return 'llama.cpp'
-  return cloudProviderDisplayName(provider)
-}

package/src/models/runtimeDetection.ts

@@ -1,81 +0,0 @@
-import os from 'node:os'
-import { spawn } from 'node:child_process'
-
-export type SpecSnapshot = {
-  platform: NodeJS.Platform
-  arch: string
-  cpuCores: number
-  totalRamBytes: number
-  effectiveRamBytes: number
-  isAppleSilicon: boolean
-  gpuVramBytes: number | null
-}
-
-function runCommand(cmd: string, args: string[], timeoutMs = 2000): Promise<{ code: number; stdout: string; stderr: string } | null> {
-  return new Promise(resolve => {
-    let settled = false
-    let child: ReturnType<typeof spawn>
-    try {
-      child = spawn(cmd, args, { windowsHide: true })
-    } catch {
-      resolve(null)
-      return
-    }
-    let stdout = ''
-    let stderr = ''
-    const timer = setTimeout(() => {
-      if (settled) return
-      settled = true
-      try { child.kill() } catch { void 0 }
-      resolve(null)
-    }, timeoutMs)
-
-    child.stdout?.on('data', d => { stdout += d.toString() })
-    child.stderr?.on('data', d => { stderr += d.toString() })
-    child.on('error', () => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      resolve(null)
-    })
-    child.on('close', code => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      resolve({ code: code ?? -1, stdout, stderr })
-    })
-  })
-}
-
-async function detectNvidiaVram(): Promise<number | null> {
-  const result = await runCommand('nvidia-smi', ['--query-gpu=memory.total', '--format=csv,noheader,nounits'])
-  if (!result || result.code !== 0) return null
-  const firstLine = result.stdout.split('\n').map(l => l.trim()).find(Boolean)
-  if (!firstLine) return null
-  const mib = Number.parseInt(firstLine, 10)
-  if (!Number.isFinite(mib) || mib <= 0) return null
-  return mib * 1024 * 1024
-}
-
-export async function detectSpec(): Promise<SpecSnapshot> {
-  const platform = process.platform
-  const arch = process.arch
-  const cpuCores = os.cpus().length
-  const totalRamBytes = os.totalmem()
-  const isAppleSilicon = platform === 'darwin' && arch === 'arm64'
-  const effectiveRamBytes = isAppleSilicon ? Math.floor(totalRamBytes * 0.75) : totalRamBytes
-
-  const [gpuVramBytes] = await Promise.all([
-    isAppleSilicon ? Promise.resolve(null) : detectNvidiaVram(),
-  ])
-
-  return {
-    platform,
-    arch,
-    cpuCores,
-    totalRamBytes,
-    effectiveRamBytes,
-    isAppleSilicon,
-    gpuVramBytes,
-  }
-}

package/src/models/uncensoredCatalog.ts

@@ -1,86 +0,0 @@
-import {
-  fetchHuggingFaceRepoInfo,
-  ggufFiles,
-  localModelId,
-  type HuggingFaceRepoInfo,
-  type HuggingFaceSibling,
-  type LocalHfModel,
-} from './huggingface.js'
-import {
-  FEATURED_HF_REPO,
-  estimateGgufMachineFit,
-  recommendGgufFile,
-  type GgufMachineFit,
-} from './modelRecommendation.js'
-import type { SpecSnapshot } from './runtimeDetection.js'
-
-export type UncensoredCatalogEntry = {
-  repo: HuggingFaceRepoInfo
-  file: HuggingFaceSibling
-  fit: GgufMachineFit
-  recommended: boolean
-  installed: boolean
-}
-
-type FetchImpl = typeof fetch
-
-const GB = 1024 * 1024 * 1024
-const FEATURED_FILE_ORDER = [
-  { filename: 'Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-BF16.gguf', fallbackSizeBytes: Math.round(17 * GB) },
-  { filename: 'Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-Q8_0.gguf', fallbackSizeBytes: Math.round(8.9 * GB) },
-  { filename: 'Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-Q6_K.gguf', fallbackSizeBytes: Math.round(6.9 * GB) },
-  { filename: 'Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf', fallbackSizeBytes: Math.round(5.3 * GB) },
-  { filename: 'mmproj-Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-BF16.gguf', fallbackSizeBytes: Math.round(0.88 * GB) },
-] as const
-
-export async function fetchUncensoredGgufCatalog(args: {
-  machineSpec?: SpecSnapshot
-  installedModels: LocalHfModel[]
-  fetchImpl?: FetchImpl
-  limit?: number
-}): Promise<UncensoredCatalogEntry[]> {
-  const fetchImpl = args.fetchImpl ?? fetch
-  const repos = await Promise.allSettled([
-    fetchHuggingFaceRepoInfo({ repoId: FEATURED_HF_REPO }, fetchImpl),
-  ])
-  const installed = new Set(args.installedModels.filter(model => model.status === 'ready').map(model => model.id))
-  const entries: UncensoredCatalogEntry[] = []
-
-  for (const result of repos) {
-    if (result.status !== 'fulfilled') continue
-    const repo = result.value
-    if (repo.repoId !== FEATURED_HF_REPO) continue
-    const files = pickFeaturedFiles(repo)
-    if (files.length === 0) continue
-    const runnable = files.filter(file => !isVisionEncoder(file.filename))
-    const recommendedFilename = args.machineSpec
-      ? recommendGgufFile(repo, runnable, args.machineSpec)?.file.filename
-      : undefined
-    for (const file of files.slice(0, args.limit ?? FEATURED_FILE_ORDER.length)) {
-      const recommended = recommendedFilename === file.filename
-      entries.push({
-        repo,
-        file,
-        fit: args.machineSpec ? estimateGgufMachineFit(file.sizeBytes, args.machineSpec).fit : 'unknown',
-        recommended,
-        installed: installed.has(localModelId(repo.repoId, file.filename)),
-      })
-    }
-  }
-
-  return entries
-}
-
-function pickFeaturedFiles(repo: HuggingFaceRepoInfo): HuggingFaceSibling[] {
-  const byName = new Map(ggufFiles(repo).map(file => [file.filename, file] as const))
-  return FEATURED_FILE_ORDER
-    .map(spec => {
-      const file = byName.get(spec.filename)
-      if (file) return file
-      return { filename: spec.filename, sizeBytes: spec.fallbackSizeBytes } satisfies HuggingFaceSibling
-    })
-}
-
-function isVisionEncoder(filename: string): boolean {
-  return filename.toLowerCase().startsWith('mmproj-')
-}