140 lines
4.9 KiB
TypeScript
140 lines
4.9 KiB
TypeScript
// Generates the README Registry tables from models/*.json. CI runs this in
|
|
// --check mode so the public README cannot drift from the source data.
|
|
import { readFileSync, readdirSync, writeFileSync } from 'node:fs'
|
|
import { dirname, join } from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
|
|
const root = join(dirname(fileURLToPath(import.meta.url)), '..')
|
|
const modelsDir = join(root, 'models')
|
|
const checkOnly = process.argv.includes('--check')
|
|
|
|
const START = '<!-- registry:start -->'
|
|
const END = '<!-- registry:end -->'
|
|
|
|
type RunJson = { file?: unknown }
|
|
type ModelJson = {
|
|
label?: unknown
|
|
vendor?: unknown
|
|
harness?: unknown
|
|
effort?: unknown
|
|
order?: unknown
|
|
runs?: Record<string, RunJson | RunJson[]>
|
|
}
|
|
|
|
type HarnessEntry = {
|
|
label: string
|
|
order: number
|
|
}
|
|
|
|
type RegistryGroup = {
|
|
label: string
|
|
vendor: string
|
|
order: number
|
|
runs: number
|
|
harnesses: Map<string, HarnessEntry>
|
|
}
|
|
|
|
function requiredString(value: unknown, field: string, file: string): string {
|
|
if (typeof value !== 'string' || !value.trim()) throw new Error(`models/${file}: "${field}" is required`)
|
|
return value.trim()
|
|
}
|
|
|
|
function runCount(runs: ModelJson['runs']): number {
|
|
return Object.values(runs ?? {}).reduce((sum, run) => sum + (Array.isArray(run) ? run.length : 1), 0)
|
|
}
|
|
|
|
function harnessLabel(def: ModelJson): string {
|
|
const harness = typeof def.harness === 'string' ? def.harness.trim() : ''
|
|
const effort = typeof def.effort === 'string' ? def.effort.trim() : ''
|
|
if (!harness && !effort) return 'Default'
|
|
if (!harness) return effort
|
|
return effort ? `${harness} · ${effort}` : harness
|
|
}
|
|
|
|
function escapeCell(value: string): string {
|
|
return value.replace(/\|/g, '\\|').replace(/\n/g, ' ')
|
|
}
|
|
|
|
function registryGroups(): RegistryGroup[] {
|
|
const groups = new Map<string, RegistryGroup>()
|
|
for (const file of readdirSync(modelsDir).filter((name) => name.endsWith('.json')).sort()) {
|
|
const def = JSON.parse(readFileSync(join(modelsDir, file), 'utf8')) as ModelJson
|
|
const label = requiredString(def.label, 'label', file)
|
|
const vendor = requiredString(def.vendor, 'vendor', file)
|
|
const order = typeof def.order === 'number' ? def.order : Number.MAX_SAFE_INTEGER
|
|
const key = `${label}\0${vendor}`
|
|
let group = groups.get(key)
|
|
if (!group) {
|
|
group = { label, vendor, order, runs: 0, harnesses: new Map() }
|
|
groups.set(key, group)
|
|
}
|
|
|
|
group.order = Math.min(group.order, order)
|
|
group.runs += runCount(def.runs)
|
|
const harness = harnessLabel(def)
|
|
const existing = group.harnesses.get(harness)
|
|
if (!existing || order < existing.order) group.harnesses.set(harness, { label: harness, order })
|
|
}
|
|
|
|
return [...groups.values()].sort((a, b) => a.order - b.order || a.label.localeCompare(b.label))
|
|
}
|
|
|
|
function table(lang: 'zh' | 'en'): string {
|
|
const groups = registryGroups()
|
|
const tested = groups.filter((group) => group.runs > 0)
|
|
const pending = groups.filter((group) => group.runs === 0).map((group) => escapeCell(group.label))
|
|
const note =
|
|
lang === 'zh'
|
|
? '> 此表由 `bun scripts/update-registry.ts` 从 `models/*.json` 自动生成；CI 会检查它是否最新。'
|
|
: '> This table is generated from `models/*.json` by `bun scripts/update-registry.ts`; CI checks that it stays current.'
|
|
const header =
|
|
lang === 'zh'
|
|
? '| 模型 | 厂商 | 运行环境（Harness）× 思考配额 | 产出 |'
|
|
: '| Model | Vendor | Harness x Effort | Runs |'
|
|
|
|
const rows = tested.map((group) => {
|
|
const harnesses = [...group.harnesses.values()]
|
|
.sort((a, b) => a.order - b.order || a.label.localeCompare(b.label))
|
|
.map((entry) => escapeCell(entry.label))
|
|
.join('<br>')
|
|
return `| ${escapeCell(group.label)} | ${escapeCell(group.vendor)} | ${harnesses} | ${String(group.runs).padStart(2, '0')} |`
|
|
})
|
|
|
|
const lines = [START, note, '', header, '|---|---|---|---|', ...rows]
|
|
if (pending.length) {
|
|
lines.push(
|
|
'',
|
|
lang === 'zh'
|
|
? `待测：${pending.join(' · ')}（欢迎 PR 补充）`
|
|
: `Pending: ${pending.join(' · ')} (PRs welcome)`,
|
|
)
|
|
}
|
|
lines.push(END)
|
|
return lines.join('\n')
|
|
}
|
|
|
|
function replaceRegistry(path: string, generated: string): boolean {
|
|
const original = readFileSync(path, 'utf8')
|
|
const start = original.indexOf(START)
|
|
const end = original.indexOf(END)
|
|
if (start === -1 || end === -1 || end < start) {
|
|
throw new Error(`${path.replace(`${root}/`, '')}: missing ${START} / ${END} markers`)
|
|
}
|
|
const next = `${original.slice(0, start)}${generated}${original.slice(end + END.length)}`
|
|
if (next === original) return false
|
|
if (!checkOnly) writeFileSync(path, next)
|
|
return true
|
|
}
|
|
|
|
const changed = [
|
|
replaceRegistry(join(root, 'README.md'), table('zh')),
|
|
replaceRegistry(join(root, 'README.en.md'), table('en')),
|
|
].some(Boolean)
|
|
|
|
if (checkOnly && changed) {
|
|
console.error('Registry tables are stale. Run: bun scripts/update-registry.ts')
|
|
process.exit(1)
|
|
}
|
|
|
|
console.log(changed ? 'Registry tables updated' : 'Registry tables OK')
|