@weft-js/cli 0.1.1 → 0.1.2

package/src/cli.mjs

@@ -24,9 +24,55 @@ import { formatGate, gate } from './gate.mjs'
 import { browserCommand } from './browser/cli.mjs'
 import { metaTable } from './meta-table.mjs'
 import { audit } from './audit.mjs'
-import { buildCommand, dbCommand, devCommand, doctorCommand, routesCommand, startCommand, unsafeAllowed } from './start.mjs'
+import {
+  buildCommand,
+  dbCommand,
+  devCommand,
+  doctorCommand,
+  routesCommand,
+  startCommand,
+  unsafeAllowed,
+} from './start.mjs'
 import { deployCommand, formatHosts, hostsCommand, initCommand } from './deploy/index.mjs'
-import { explainTarget, findGroups, formatExplain, formatFind, styleMatrix, writeMatrixFile } from './style.mjs'
+import {
+  explainTarget,
+  findGroups,
+  formatExplain,
+  formatFind,
+  styleMatrix,
+  writeMatrixFile,
+} from './style.mjs'
+
+import {
+  commandLsp,
+  commandTsc,
+  commandCheck,
+  commandDoctor,
+  commandTest,
+  commandBrowser,
+  commandDev,
+  commandBuild,
+  commandAudit,
+  commandDeploy,
+  commandStart,
+  commandDb,
+  commandRoutes,
+  commandSurfaces,
+  commandTasks,
+  commandRun,
+  commandDocs,
+  commandAgentsMd,
+} from './cli/project.mjs'
+import {
+  commandMap,
+  commandIcons,
+  commandAdd,
+  commandPlugins,
+  commandFix,
+  commandTokens,
+  commandStyle,
+  commandMcp,
+} from './cli/authoring.mjs'
 
 const usage = `usage: weft <command> [--json] [--root <dir>]
 
@@ -43,7 +89,7 @@ const usage = `usage: weft <command> [--json] [--root <dir>]
   build [--runtime node|bun|deno] [--preset <p>]  production build to .output, and .weft/contract.json; then the
                       built pages are audited (L-codes) and an error fails the build
                       [--unsafe-allow <codes>]  go past these codes (R002, L003, a family like L, or all): forces a deploy
-  audit [routes…] [--url <u>] [--all] [--max <n>]  the built pages, or a running site, in a clean Chrome at a phone's
+  audit [routes…] [--url <u>] [--indexing public|private|auto] [--all] [--max <n>]  the built pages, or a running site, in a clean Chrome at a phone's
                       and a desktop's width: axe-core's WCAG rules, console, deprecations, head, sideways scroll, shift
   deploy [--prod] [--yes] [--target t]  fit check, build for the target, then the host's own CLI; without --yes a dry
                       run that prints what would run. Netlify, Vercel, Cloudflare, Fly, Render; the live URL at the end
@@ -55,11 +101,13 @@ const usage = `usage: weft <command> [--json] [--root <dir>]
   db live             a migration with change triggers for the tables in \`changes\`
   db listen           the change feed as its own process, for an app on functions
   routes [--meta]     the route table; --meta: every route's merged metadata, tags, card mode and H-diagnostics
+  surfaces            the canvas and WebGL surfaces this project already defines
   tasks               commands and project tasks
   run <task>          run a project task from weft.config.ts
   docs [topic|code]   docs for agents (rules, props, lists, async, testing, config, diagnostics, commands, W014…)
   agents-md [--check] write AGENTS.md (--check: exit 1 when stale; --stdout: print it)
   map [--stdout]      write .weft/map.md and .json: a matrix of what to call in this app
+  icons publish <dir>  every icon and variant as static .svg files with a manifest.json, for a CDN
   add <feature>       install a plugin and wire it into the config; also tailwind, auth, db [engine] [--layer drizzle|prisma|native], and rust [name] [--remote] [--dry-run] [--no-install]
   plugins [list]      plugins, the slots they provide and bind, permissions, diagnostics
   plugins explain <slot>  binding chain: config → plugin → module → .weft/slots/<id>.ts
@@ -70,16 +118,67 @@ const usage = `usage: weft <command> [--json] [--root <dir>]
   style explain <group|selector> [--<axis> <value>] [--states a,b] [--accent intent:token] [--part p]
                       resolved CSS for one variation, and where each value came from
   style matrix        write .weft/styles.json (every group: axes, parts, accents, resolved CSS, uses)
-  mcp                 MCP server on stdio: docs, check, tasks, style_find, style_explain, test_gate, browser_*`
+  mcp                 MCP server on stdio: docs, check, audit, routes_meta, map, tasks, surfaces, style_find,
+                      style_explain, test_gate, browser_*`
 
 /** Flags that take a value (`--base main` or `--base=main`), and boolean flags, beyond the global ones. */
-const valued = new Set(['layer', 'base', 'budget', 'max-mutants', 'concurrency', 'url', 'tab', 'out', 'component', 'from', 'props', 'name', 'scope', 'timeout', 'preset', 'port', 'runtime', 'unsafe-allow', 'max', 'target'])
+const valued = new Set([
+  'layer',
+  'base',
+  'budget',
+  'max-mutants',
+  'concurrency',
+  'url',
+  'indexing',
+  'tab',
+  'out',
+  'component',
+  'from',
+  'props',
+  'name',
+  'scope',
+  'timeout',
+  'preset',
+  'port',
+  'runtime',
+  'unsafe-allow',
+  'max',
+  'target',
+])
 /** `weft style explain` takes the group's own axes as flags (`--status late`); these are its fixed ones. */
 const styleFlags = new Set(['states', 'accent', 'part'])
-const booleans = new Set(['dry-run', 'no-install', 'remote', 'gate', 'refactor', 'no-mutation', 'interactive', 'delta', 'graph-only', 'no-graph', 'headed', 'full', 'reload', 'meta', 'all', 'verbose', 'prod', 'yes', 'force'])
+const booleans = new Set([
+  'dry-run',
+  'no-install',
+  'remote',
+  'gate',
+  'refactor',
+  'no-mutation',
+  'interactive',
+  'delta',
+  'graph-only',
+  'no-graph',
+  'headed',
+  'full',
+  'reload',
+  'meta',
+  'all',
+  'verbose',
+  'prod',
+  'yes',
+  'force',
+])
 
 export function parse(argv) {
-  const out = { command: argv[0], positional: [], json: false, root: process.cwd(), check: false, stdout: false, flags: {} }
+  const out = {
+    command: argv[0],
+    positional: [],
+    json: false,
+    root: process.cwd(),
+    check: false,
+    stdout: false,
+    flags: {},
+  }
   for (let i = 1; i < argv.length; i++) {
     const a = argv[i]
     if (a === '--json') out.json = true
@@ -91,262 +190,134 @@ export function parse(argv) {
       const [name, inline] = a.slice(2).split(/=(.*)/s)
       if (valued.has(name)) out.flags[name] = inline ?? argv[++i]
       else if (booleans.has(name) && inline === undefined) out.flags[name] = true
-      else if (out.command === 'style' && styleFlags.has(name)) out.flags[name] = inline ?? argv[++i]
-      else if (out.command === 'style' && /^[a-z][\w-]*$/i.test(name) && (inline ?? argv[i + 1]) !== undefined) (out.flags.axes ??= {})[name] = inline ?? argv[++i]
+      else if (out.command === 'style' && styleFlags.has(name))
+        out.flags[name] = inline ?? argv[++i]
+      else if (
+        out.command === 'style' &&
+        /^[a-z][\w-]*$/i.test(name) &&
+        (inline ?? argv[i + 1]) !== undefined
+      )
+        (out.flags.axes ??= {})[name] = inline ?? argv[++i]
       else throw Object.assign(new Error(`unknown flag ${a}`), { code: 'E_USAGE' })
     } else out.positional.push(a)
   }
   return out
 }
 
+const dependencies = {
+  fix,
+  writeTokens,
+  createRequire,
+  existsSync,
+  join,
+  resolve,
+  pathToFileURL,
+  addCommand,
+  writeAgentsMd,
+  check,
+  formatHuman,
+  sortDiagnostics,
+  docs,
+  compilerLine,
+  doctor,
+  formatDoctor,
+  formatMap,
+  writeMap,
+  serve,
+  explain,
+  list,
+  sync,
+  approveCommand,
+  auditCommand,
+  formatTrust,
+  loadConfig,
+  listSurfaces,
+  runTask,
+  tasks,
+  formatGate,
+  gate,
+  browserCommand,
+  metaTable,
+  audit,
+  buildCommand,
+  dbCommand,
+  devCommand,
+  doctorCommand,
+  routesCommand,
+  startCommand,
+  unsafeAllowed,
+  deployCommand,
+  formatHosts,
+  hostsCommand,
+  initCommand,
+  explainTarget,
+  findGroups,
+  formatExplain,
+  formatFind,
+  styleMatrix,
+  writeMatrixFile,
+}
+
 export async function main(argv, io = { stdout: process.stdout, stderr: process.stderr }) {
-  const print = data => io.stdout.write(`${JSON.stringify(data, null, 2)}\n`)
-  const say = text => text && io.stderr.write(`${text}\n`)
+  const print = (data) => io.stdout.write(`${JSON.stringify(data, null, 2)}\n`)
+  const say = (text) => text && io.stderr.write(`${text}\n`)
   let args
   try {
     args = parse(argv)
+    const context = { ...dependencies, args, print, say, io }
     switch (args.command) {
-      case 'lsp': {
-        const { lsp } = await import('./infer/lsp.mjs')
-        const out = lsp(args.root)
-        return await new Promise(ok => { out.server.on('exit', () => ok(0)) })
-      }
-      case 'tsc': {
-        const { propTsc } = await import('./props-checks.mjs')
-        const diagnostics = sortDiagnostics(await propTsc(args.root))
-        if (args.json) print({ ok: !diagnostics.some(d => d.severity === 'error'), diagnostics })
-        say(formatHuman(diagnostics))
-        say(`weft tsc: ${diagnostics.filter(d => d.severity === 'error').length} errors`)
-        return diagnostics.some(d => d.severity === 'error') ? 1 : 0
-      }
-      case 'check': {
-        const result = await check(args.root, { files: args.positional, preset: args.flags.preset })
-        if (args.json) print(result)
-        say(formatHuman(result.diagnostics))
-        if (args.flags.verbose) say(compilerLine(doctor(args.root).compiler))
-        say(`weft check: ${result.summary.files} files, ${result.summary.errors} errors, ${result.summary.warnings} warnings (${result.ms} ms)`)
-        return result.ok ? 0 : 1
-      }
-      case 'doctor': {
-        // What this install compiles with, always; what live data does on the target, for an app that has any.
-        const result = doctor(args.root)
-        const plan = args.flags.preset || existsSync(join(args.root, 'src/realtime.server.ts')) ? await doctorCommand(args.root, { preset: args.flags.preset, runtime: args.flags.runtime }) : undefined
-        const hosts = hostsCommand(args.root, (await loadConfig(args.root)).config)
-        if (args.json) print({ ...result, live: plan, deploy: hosts })
-        else say(`${formatDoctor(result)}\n\nweft doctor: deploy${hosts.target ? ` (target ${hosts.target})` : ''}\n${formatHosts(hosts).replace(/^/gm, '  ')}`)
-        if (!plan) return 0
-        say(`weft doctor: ${plan.preset} (${plan.host})\n  live mode: ${plan.mode}\n  ${plan.says}${plan.required.length ? `\n  required: ${plan.required.join(', ')}` : ''}${plan.options.length ? `\n  options:\n${plan.options.map(o => `    - ${o}`).join('\n')}` : ''}`)
-        say(formatHuman(plan.diagnostics))
-        return plan.diagnostics.some(d => d.severity === 'error') ? 1 : 0
-      }
-      case 'test': {
-        if (!args.flags.gate) throw Object.assign(new Error('`weft test` runs the gate with --gate; run the suite itself with vitest'), { code: 'E_USAGE' })
-        const num = name => (args.flags[name] === undefined ? undefined : Number(args.flags[name]))
-        const result = await gate(args.root, {
-          base: args.flags.base, budgetSec: num('budget'), maxMutants: num('max-mutants'), concurrency: num('concurrency'),
-          refactor: !!args.flags.refactor, mutation: !args.flags['no-mutation'], log: line => say(line),
-        })
-        if (args.json) print(result)
-        say(formatHuman(result.diagnostics))
-        say(formatGate(result))
-        say(`weft test --gate: ${result.ok ? 'pass' : 'fail'}, ${result.summary.changedTests} changed tests, ${result.summary.errors} errors, ${result.summary.warnings} warnings (${result.ms} ms)`)
-        return result.ok ? 0 : 1
-      }
+      case 'lsp':
+        return await commandLsp(context)
+      case 'tsc':
+        return await commandTsc(context)
+      case 'check':
+        return await commandCheck(context)
+      case 'doctor':
+        return await commandDoctor(context)
+      case 'test':
+        return await commandTest(context)
       case 'browser':
-        return await browserCommand(args, { print, say, io })
-      case 'dev': {
-        const server = await devCommand(args.root, { port: args.flags.port && Number(args.flags.port) })
-        say(`weft dev: ${server.resolvedUrls.local[0]}`)
-        await new Promise(ok => { process.once('SIGINT', ok) })
-        await server.close()
-        return 0
-      }
-      case 'build': {
-        const result = await buildCommand(args.root, { preset: args.flags.preset, runtime: args.flags.runtime, unsafeAllow: args.flags['unsafe-allow'] })
-        if (args.json) print(result)
-        say(formatHuman(result.diagnostics))
-        say(`weft build: ${result.preset} → ${result.output}, ${result.functions} functions in the contract, ${result.audited} pages audited (${result.ms} ms)`)
-        if (!result.ok) say('weft build: failed. The output is written, but fix the errors above before it ships, or `--unsafe-allow <code>` to force it.')
-        return result.ok ? 0 : 1
-      }
-      case 'audit': {
-        const result = await audit(args.root, { url: args.flags.url, routes: args.positional.length ? args.positional : undefined, all: !!args.flags.all, max: args.flags.max && Number(args.flags.max) })
-        if (args.json) print(result)
-        say(formatHuman(result.diagnostics))
-        say(`weft audit: ${result.skipped ?? `${result.pages.length} pages at a phone's and a desktop's width, ${result.diagnostics.length} findings (${result.ms} ms)`}`)
-        return result.ok ? 0 : 1
-      }
-      case 'deploy': {
-        const loaded = await loadConfig(args.root)
-        const sub = args.positional[0]
-        if (sub === 'hosts') {
-          const result = hostsCommand(args.root, loaded.config)
-          if (args.json) print(result)
-          else say(formatHosts(result))
-          return 0
-        }
-        const unsafe = unsafeAllowed(args.flags['unsafe-allow'], loaded.config)
-        if (sub === 'init') {
-          const result = initCommand(args.root, loaded.config, { target: args.positional[1] ?? args.flags.target, dryRun: !!args.flags['dry-run'], force: !!args.flags.force, unsafe })
-          if (args.json) print(result)
-          say(formatHuman(result.findings))
-          say([`weft deploy init ${result.target}${result.dryRun ? ' (dry run: nothing written)' : ''}:`, ...result.actions.map(a => `  ${a}`), '', 'then, once:', ...result.next.map(n => `  ${n}`)].join('\n'))
-          return 0
-        }
-        if (sub !== undefined) throw Object.assign(new Error(`weft deploy ${sub}: use \`weft deploy\`, \`weft deploy hosts\` or \`weft deploy init [target]\``), { code: 'E_USAGE' })
-        const result = await deployCommand(args.root, loaded.config, { target: args.flags.target, prod: !!args.flags.prod, yes: !!args.flags.yes, unsafe, build: (root, o) => buildCommand(root, { ...o, unsafeAllow: args.flags['unsafe-allow'] }) })
-        if (args.json) print(result)
-        say(formatHuman(result.diagnostics))
-        if (result.dryRun) say([`weft deploy: a dry run for ${result.target}${result.prod ? ' (production)' : ' (a preview)'}. With --yes it runs:`, ...result.steps.map(s => `  ${s.what}${s.reads.length ? `\n      reads ${s.reads.join(', ')} from the environment` : ''}`)].join('\n'))
-        else say(`weft deploy: ${result.target}${result.prod ? ' (production)' : ''} → ${result.url ?? 'deployed; the host printed no URL'}`)
-        return 0
-      }
+        return await commandBrowser(context)
+      case 'dev':
+        return await commandDev(context)
+      case 'build':
+        return await commandBuild(context)
+      case 'audit':
+        return await commandAudit(context)
+      case 'deploy':
+        return await commandDeploy(context)
       case 'start':
-        return await startCommand(args.root, { runtime: args.flags.runtime })
-      case 'db': {
-        const result = await dbCommand(args.root, args.positional[0], args.positional[1])
-        if (args.json) print(result)
-        say(result.output)
-        return 0
-      }
-      case 'routes': {
-        const result = await routesCommand(args.root, { meta: !!args.flags.meta, preset: args.flags.preset })
-        if (args.json) print(result)
-        else say(args.flags.meta ? metaTable(result) : result.routes.map(r => `${r.path.padEnd(24)} ${r.file}`).join('\n'))
-        say(formatHuman(result.diagnostics))
-        return result.ok ? 0 : 1
-      }
-      case 'surfaces': {
-        const surfaces = listSurfaces(args.root)
-        if (args.json) print({ surfaces })
-        else say(surfaces.length ? surfaces.map(x => `${String(x.name).padEnd(20)} ${String(x.kind).padEnd(10)} ${x.file}:${x.line}  props: ${x.props.join(', ') || '(none)'}`).join('\n') : 'No surfaces yet: `weft docs surface`.')
-        return 0
-      }
-      case 'tasks': {
-        const result = await tasks(args.root)
-        if (args.json) print(result)
-        else say(result.tasks.map(t => `${t.available ? ' ' : '·'} ${t.name.padEnd(10)} ${t.description ?? ''}`).join('\n'))
-        say(formatHuman(result.diagnostics))
-        return result.ok ? 0 : 1
-      }
-      case 'run': {
-        if (!args.positional[0]) throw Object.assign(new Error('weft run <task>'), { code: 'E_USAGE' })
-        return await runTask(args.root, args.positional[0])
-      }
-      case 'docs': {
-        const page = await docs(args.root, args.positional[0])
-        if (args.json) print(page)
-        else io.stdout.write(`${page.text}\n`)
-        return 0
-      }
-      case 'agents-md': {
-        const out = await writeAgentsMd(args.root, { check: args.check || args.stdout })
-        if (args.stdout) io.stdout.write(out.text)
-        if (args.json) print({ path: out.path, bytes: out.bytes, limit: 8192, overLimit: out.overLimit, current: out.current, written: out.written })
-        say(`AGENTS.md: ${out.bytes} bytes${out.overLimit ? ' (over the 8 KB limit)' : ''}, ${out.written ? 'written' : out.current ? 'current' : 'stale'}`)
-        return (args.check && !out.current) || out.overLimit ? 1 : 0
-      }
-      case 'map': {
-        const map = await writeMap(args.root)
-        if (args.json) print(map)
-        else if (args.stdout) process.stdout.write(formatMap(map))
-        else say(`.weft/map.md: ${map.rows.length} rows`)
-        return 0
-      }
-      case 'icons': {
-        if (args.positional[0] !== 'publish' || !args.positional[1]) { say('usage: weft icons publish <dir>'); return 1 }
-        const { publish } = await import(pathToFileURL(createRequire(join(args.root, 'package.json')).resolve('@weft-js/warp-icons/compile')).href)
-        const out = await publish(resolve(args.root, args.positional[1]))
-        if (args.json) print(out)
-        else say(`${out.files} files for ${out.icons} icons in ${out.dir}. Nothing was uploaded: host that folder, then set icons({ source }).`)
-        return 0
-      }
-      case 'add': {
-        const result = await addCommand(args.root, args.positional[0], { dryRun: args.flags['dry-run'], install: !args.flags['no-install'], engine: args.positional[1], layer: args.flags.layer, remote: args.flags.remote })
-        if (args.json) print(result)
-        else say(result.already ? `${result.package} is already in ${result.config}` : result.actions.map(a => `${args.flags['dry-run'] ? 'would ' : ''}${a}`).join('\n'))
-        return 0
-      }
-      case 'plugins': {
-        const sub = args.positional[0] ?? 'list'
-        if (sub === 'list') {
-          const result = await list(args.root)
-          if (args.json) print(result)
-          else say(result.plugins.map(p => `${p.name}@${p.version ?? '?'}  ${p.provides.map(s => `${s.slot}${s.key ? `[${s.key}]` : ''}${s.bound ? '' : ' (not bound)'}`).join(', ') || 'no slots'}${p.tokens ? `  tokens --${p.tokens}-*` : ''}`).join('\n') || 'no plugins')
-          say(formatHuman(result.diagnostics))
-          return result.ok ? 0 : 1
-        }
-        if (sub === 'explain') {
-          const result = await explain(args.root, args.positional[1])
-          if (args.json) print(result)
-          else say(JSON.stringify(result.binding, null, 2))
-          return 0
-        }
-        if (sub === 'sync') {
-          const loaded = await loadConfig(args.root)
-          const errors = loaded.diagnostics.filter(d => d.severity === 'error')
-          const written = loaded.diagnostics.some(d => d.code === 'P007') ? [] : sync(args.root, loaded)
-          if (args.json) print({ ok: errors.length === 0, written, diagnostics: loaded.diagnostics })
-          say(formatHuman(loaded.diagnostics))
-          say(`weft plugins sync: ${written.length} files written`)
-          return errors.length ? 1 : 0
-        }
-        if (sub === 'audit') {
-          const loaded = await loadConfig(args.root)
-          const result = auditCommand(args.root, loaded)
-          if (args.json) print(result)
-          else say(result.plugins.map(formatTrust).join('\n') || 'no plugins')
-          say(formatHuman(result.diagnostics))
-          return result.ok ? 0 : 1
-        }
-        if (sub === 'approve') {
-          const result = approveCommand(args.root, await loadConfig(args.root), { names: args.positional.slice(1), all: !!args.flags.all })
-          if (args.json) print(result)
-          else say([...(result.written ? result.approved : result.pending).map(formatTrust), result.written ? `${result.lock}: ${result.approved.length} approved` : result.pending.length ? 'nothing written: name a plugin, or pass --all' : 'nothing waiting', ...result.written ? result.pending.map(p => `still waiting: ${p.name}`) : [], ...(result.gitignore ? ['.gitignore: the lock is no longer ignored, so commit it'] : [])].join('\n'))
-          return result.ok ? 0 : 1
-        }
-        throw Object.assign(new Error(`unknown plugins subcommand ${String(sub)}`), { code: 'E_USAGE' })
-      }
-      case 'fix': {
-        const result = await fix(args.root, { files: args.positional })
-        if (args.json) print(result)
-        else say(result.applied.length ? result.applied.map(a => `${a.file}:${a.span[0]}:${a.span[1]}  ${a.code}`).join('\n') : 'nothing to fix')
-        return 0
-      }
-      case 'tokens': {
-        const result = await writeTokens(args.root)
-        if (args.json) print(result)
-        else say(`${result.dir}: ${result.files.length} files`)
-        return 0
-      }
-      case 'style': {
-        const sub = args.positional[0]
-        if (sub === 'find') {
-          const result = findGroups((await styleMatrix(args.root)).matrix, args.positional.slice(1).join(' '))
-          if (args.json) print(result)
-          else say(formatFind(result))
-          return 0
-        }
-        if (sub === 'explain') {
-          const accent = args.flags.accent ? Object.fromEntries(args.flags.accent.split(/[\s,]+/).filter(Boolean).map(w => w.split(':'))) : undefined
-          const states = args.flags.states?.split(',').map(s => s.trim()).filter(Boolean)
-          const result = explainTarget(await styleMatrix(args.root), args.positional.slice(1).join(' '), { axes: args.flags.axes, states, accent, part: args.flags.part })
-          if (args.json) print(result)
-          else say(formatExplain(result))
-          return 0
-        }
-        if (sub === 'matrix') {
-          const { matrix } = await styleMatrix(args.root)
-          const written = args.stdout ? false : writeMatrixFile(args.root, matrix)
-          if (args.stdout || args.json) print(matrix)
-          say(`.weft/styles.json: ${Object.keys(matrix.groups).length} groups, ${matrix.diagnostics.length} diagnostics, ${args.stdout ? 'not written' : written ? 'written' : 'current'}`)
-          return 0
-        }
-        throw Object.assign(new Error(`weft style ${sub ?? ''}: use find <query>, explain <group|selector> or matrix`), { code: 'E_USAGE' })
-      }
+        return await commandStart(context)
+      case 'db':
+        return await commandDb(context)
+      case 'routes':
+        return await commandRoutes(context)
+      case 'surfaces':
+        return commandSurfaces(context)
+      case 'tasks':
+        return await commandTasks(context)
+      case 'run':
+        return await commandRun(context)
+      case 'docs':
+        return await commandDocs(context)
+      case 'agents-md':
+        return await commandAgentsMd(context)
+      case 'map':
+        return await commandMap(context)
+      case 'icons':
+        return await commandIcons(context)
+      case 'add':
+        return await commandAdd(context)
+      case 'plugins':
+        return await commandPlugins(context)
+      case 'fix':
+        return await commandFix(context)
+      case 'tokens':
+        return await commandTokens(context)
+      case 'style':
+        return await commandStyle(context)
       case 'mcp':
-        await serve(args.root)
-        return 0
+        return await commandMcp(context)
       case undefined:
       case 'help':
       case '--help':
@@ -357,7 +328,8 @@ export async function main(argv, io = { stdout: process.stdout, stderr: process.
     }
   } catch (error) {
     const code = error.code ?? 'E_INTERNAL'
-    if (args?.json || argv.includes('--json')) print({ ok: false, error: { code, message: error.message } })
+    if (args?.json || argv.includes('--json'))
+      print({ ok: false, error: { code, message: error.message } })
     say(`weft: ${error.message}${code === 'E_USAGE' ? `\n\n${usage}` : ''}`)
     return code === 'E_REFUSED' ? 1 : 2
   }

package/src/config.mjs

@@ -2,4 +2,4 @@
 // Apps import it from `@weft-js/core/config`; the CLI's loader falls back here when a project's weft doesn't resolve.
 
 /** @type {import('@weft-js/core/config').defineConfig} */
-export const defineConfig = config => config
+export const defineConfig = (config) => config