rvlib-shipkit 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 0.4.0 — 2026-07-22
+
+New (wave 1 of the shipkit expansion — uniform repo setup):
+
+- built-in `package.json` probe in `shipkit check`
+  (`core/package-json-check.ts`): FAILs on `license` present / `private` not
+  true / missing capability-required scripts (repo.config → ci check
+  contracts tui hub; `.rv-assets/kit.ts` → assets; `.rv-identity/brand.ts`
+  → assets:identity; `.rv-comfy/` → comfy:up; `deploy.sh` → up; ask dir →
+  asks); WARNs on banned aliases (`serve`→`hub`, `identity`→
+  `assets:identity`, `pretty`→`fmt`, `check-types`→`typecheck`; body-matched
+  so an unrelated `serve` is left alone) and a missing `test`/`lint`/`fmt`
+  baseline. rvlib-* roots invert (MIT required, private banned). Spec:
+  wiki `meta/rv-conventions/package-json.md`. Doctor surface only — not in
+  the ci gate.
+- `init` scaffolds the full canonical script set: `ci check contracts tui
+  hub` (hub runs `shipkit serve`) + a `test: bun test` baseline — was
+  ci/check/contracts only.
+- upgraders from 0.3.x: the probe FAILs on the missing `tui`/`hub` scripts —
+  re-run `shipkit init` (non-clobber, it only adds the gaps) and rename any
+  `serve` hub-script to `hub`.
+
+## 0.3.1 — 2026-07-22
+
+- fix: `react-dom` was missing from dependencies AND the CLI entry loaded
+  the react/ink chain eagerly — every command crashed in a fresh consumer
+  repo without react-dom (found by the rabbits-vs-sheeps swap in the field,
+  confirmed against the 0.3.0 tarball). tui now lazy-loads its body; deps
+  carry react-dom. Proven by a fresh-repo install test (init → ci green in
+  a react-less repo).
+- fix: `init` warns loudly when rvlib-shipkit is not installed in the repo
+  (the minted scripts call its bin — previously exit 127 with no hint).
+
 ## 0.3.0 — 2026-07-22
 
 New:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "All-in-one repo companion: ci gate (task DAG), auto-discovered health checks, release-contract fulfillness, asks queue, md-wiki tools, asset atelier, live tui",
     "license": "MIT",
     "type": "module",
@@ -29,6 +29,7 @@
         "mobx": "^6.16.1",
         "mobx-react-lite": "^4.1.1",
         "react": "^19.2.7",
+        "react-dom": "^19.2.7",
         "rvlib-ts-tools": "^0.2.0",
         "sharp": "^0.35.3"
     }

package/src/cli/cmd_Tui.ts

@@ -1,15 +1,10 @@
 // shipkit tui — the live dashboard: Tasks (the ci gate, streamed through
 // the DAG runner) + Checks (contracts + discovered *.check.ts) built in,
 // repo extras injected via repo.config `tui: { panels: [...] }`.
-import React from 'react'
-import { render } from 'ink'
-import { configure } from 'mobx'
+// The body lives in src/tui/run-tui.ts and is loaded ONLY when the command
+// runs: the react/ink chain must never load for `shipkit ci` in a repo
+// without react-dom.
 import { Command } from 'clipanion'
-import { loadRepoConfig } from '../repo-config.ts'
-import { checksPanel } from '../tui/checks-panel.ts'
-import { tasksPanel } from '../tui/tasks-panel.ts'
-import { TuiApp } from '../tui/tui-app.tsx'
-import { TuiStore } from '../tui/tui-store.ts'
 
 export class TuiCommand extends Command {
     static override paths = [['tui']]
@@ -21,16 +16,7 @@ export class TuiCommand extends Command {
     })
 
     async execute(): Promise<number> {
-        const root = process.cwd()
-        const c = await loadRepoConfig(root)
-        // playbook (build/mobx): enforceActions warns on stray mutations — the
-        // only signal. Read-warning flags stay off: useInput handler reads are
-        // legitimately untracked and would false-positive.
-        configure({ enforceActions: 'always' })
-        const store = new TuiStore(c.name, [tasksPanel(root, c), checksPanel(root), ...(c.tui?.panels ?? [])])
-        store.refresh() // instant static paint; results stream in
-        const app = render(React.createElement(TuiApp, { store }))
-        await app.waitUntilExit()
-        return 0
+        const { runTui } = await import('../tui/run-tui.ts')
+        return runTui(process.cwd())
     }
 }

package/src/core/package-json-check.ts

@@ -0,0 +1,87 @@
+// built-in `package.json` probe for `shipkit check` — enforces the canonical
+// shape (meta/rv-conventions/package-json.md): private:true, no license,
+// capability-required script names FAIL, banned aliases + missing baseline
+// trio WARN. Doctor surface only — never wired into the ci gate. Pure local
+// fs, no TTL.
+import { existsSync } from 'fs'
+import { join } from 'path'
+import type { CheckCtx } from './check-ctx.ts'
+import type { RepoConfig } from '../repo-config.ts'
+
+type Pkg = { name?: string; private?: boolean; license?: string; scripts?: Record<string, string> }
+
+// alias → { canonical, bodyMatch } — WARN only when the body proves the
+// alias really is the canonical capability (a `serve` that serves a dist/
+// folder must not be told to rename)
+const ALIASES: Record<string, { canonical: string; bodyMatch: RegExp }> = {
+    'serve': { canonical: 'hub', bodyMatch: /(shipkit|cli\.ts) serve\b/ },
+    'identity': { canonical: 'assets:identity', bodyMatch: /assets(:| )identity\b/ },
+    'pretty': { canonical: 'fmt', bodyMatch: /./ },
+    'check-types': { canonical: 'typecheck', bodyMatch: /./ },
+}
+
+const BASELINE = ['test', 'lint', 'fmt'] as const
+
+export async function evaluatePackageJson(t: CheckCtx, root: string, c: RepoConfig): Promise<void> {
+    const spec = `${c.docsBase ?? ''}meta/rv-conventions/package-json.md`
+    let pkg: Pkg
+    try {
+        pkg = (await Bun.file(join(root, 'package.json')).json()) as Pkg
+    } catch (e) {
+        t.fail(`package.json unreadable (${String(e).slice(0, 120)})`, spec)
+        return
+    }
+    const scripts = pkg.scripts ?? {}
+    // rvlib-* as a probe ROOT is theoretical (libs live as sub-packages and
+    // the probe only runs where repo.config.ts loads) — field inversion is
+    // still handled so a future lib-root repo fails correctly, not absurdly
+    const isLib = pkg.name?.startsWith('rvlib-') === true
+
+    // published rvlib-* roots invert the field rules (distribute/npm owns them)
+    if (isLib) {
+        if (pkg.license !== 'MIT') t.fail(`package.json: rvlib-* package must carry license MIT`, spec)
+        if (pkg.private === true) t.fail(`package.json: rvlib-* package must not be private`, spec)
+    } else {
+        if (pkg.private !== true) t.fail(`package.json: "private": true is required`, spec)
+        if (pkg.license != null) t.fail(`package.json: license field is banned on project repos (rvlib-* sub-packages excepted)`, spec)
+    }
+
+    // aliases first — an alias satisfies the requirement but earns a WARN,
+    // never a double report (alias WARN + missing-canonical FAIL). A banned
+    // alias lingering NEXT TO its canonical still WARNs (sweep on sight),
+    // it just doesn't satisfy anything.
+    const aliased = new Set<string>()
+    for (const [name, a] of Object.entries(ALIASES)) {
+        const body = scripts[name]
+        if (body == null || !a.bodyMatch.test(body)) continue
+        if (scripts[a.canonical] == null) aliased.add(a.canonical)
+        t.warn(`package.json: script '${name}' is the house '${a.canonical}' — ${scripts[a.canonical] == null ? 'rename it' : `delete it ('${a.canonical}' exists)`}`, spec)
+    }
+
+    const has = (name: string): boolean => scripts[name] != null || aliased.has(name)
+
+    // capability → required script names (FAIL); repo.config.ts existence is
+    // implied — this probe only runs under `shipkit check`
+    const required: Array<{ name: string; why: string }> = [
+        { name: 'ci', why: 'shipkit repo' },
+        { name: 'check', why: 'shipkit repo' },
+        { name: 'contracts', why: 'shipkit repo' },
+        { name: 'tui', why: 'shipkit repo' },
+        { name: 'hub', why: 'shipkit repo' },
+    ]
+    if (existsSync(join(root, '.rv-assets/kit.ts'))) required.push({ name: 'assets', why: '.rv-assets/kit.ts exists' })
+    if (existsSync(join(root, '.rv-identity/brand.ts'))) required.push({ name: 'assets:identity', why: '.rv-identity/brand.ts exists' })
+    if (existsSync(join(root, '.rv-comfy'))) required.push({ name: 'comfy:up', why: '.rv-comfy/ exists' })
+    if (existsSync(join(root, 'deploy.sh'))) required.push({ name: 'up', why: 'deploy.sh exists' })
+    if (existsSync(join(root, c.asks?.dir ?? 'asks'))) required.push({ name: 'asks', why: 'ask queue exists' })
+
+    const missing = required.filter((r) => !has(r.name))
+    for (const m of missing) t.fail(`package.json: missing script '${m.name}' (${m.why})`, spec)
+
+    const missingBaseline = BASELINE.filter((n) => !has(n))
+    if (missingBaseline.length > 0)
+        t.warn(`package.json: missing baseline script(s): ${missingBaseline.join(', ')}`, spec)
+
+    if (!t.failed && !t.warned)
+        t.ok(`package.json shape ok (private, no license, ${required.length} required scripts present)`)
+}

package/src/core/run-check.ts

@@ -9,6 +9,7 @@ import { CheckSuite, type CheckOutcome } from './check-suite.ts'
 import { discoverChecks } from './discover-checks.ts'
 import { spawnWithTimeout } from './spawn-timeout.ts'
 import { activeContracts, applyContractsResult, contractsConfigFrom, loadRepoConfig } from '../repo-config.ts'
+import { evaluatePackageJson } from './package-json-check.ts'
 import { evaluateContracts } from '../contracts/contracts-engine.ts'
 import { formatLine, parseWireOutput } from './wire.ts'
 import { writeStatus } from './write-status.ts'
@@ -40,6 +41,12 @@ export async function runCheck(root: string, o: CheckOpts = {}): Promise<number>
             applyContractsResult(t, await evaluateContracts(activeContracts(c), contractsConfigFrom(c, root)))
         },
     })
+    // built-in shape probe (meta/rv-conventions/package-json.md) — doctor
+    // surface only, deliberately absent from the ci gate
+    suite.addCheck({
+        name: 'package.json',
+        logic: (t) => evaluatePackageJson(t, root, c),
+    })
     const childEnv: Record<string, string | undefined> = {
         ...process.env,
         ...(o.fresh === true ? { SHIPKIT_FRESH: '1', RV_CHECK_FRESH: '1' } : {}),

package/src/init-repo.ts

@@ -40,11 +40,17 @@ export async function initRepo(root: string, opts: InitOpts = {}): Promise<numbe
     pkg.scripts ??= {}
     const run = (cmd: string): string => (opts.bin != null ? `bun ${opts.bin} ${cmd}` : `shipkit ${cmd}`)
     let added = 0
-    for (const k of ['ci', 'check', 'contracts'] as const) {
-        const v = run(k)
+    // canonical script NAME → shipkit command (hub runs `shipkit serve`) —
+    // vocabulary owned by meta/rv-conventions/package-json.md
+    const CANONICAL = { ci: 'ci', check: 'check', contracts: 'contracts', tui: 'tui', hub: 'serve' } as const
+    for (const [k, cmd] of Object.entries(CANONICAL)) {
+        const v = run(cmd)
         if (pkg.scripts[k] == null) { pkg.scripts[k] = v; added++ }
         else if (pkg.scripts[k] !== v) console.log(`skip: package.json script '${k}' exists — left untouched`)
     }
+    // baseline `test` is universal (bun test) — lint/fmt bodies are
+    // stack-specific, the scaffold pages own those
+    if (pkg.scripts['test'] == null) { pkg.scripts['test'] = 'bun test'; added++ }
     if (added > 0) {
         writeFileSync(pkgPath, JSON.stringify(pkg, null, indent) + '\n')
         console.log(`ok: ${added} package.json script(s) added`)
@@ -54,6 +60,16 @@ export async function initRepo(root: string, opts: InitOpts = {}): Promise<numbe
     const floor = resolveFloor(defineRepo({ name }), root)
     for (const t of floor.tasks) console.log(`ok: floor ${t.id} ← ${floor.sources[t.id] ?? 'unknown'}`)
     for (const u of floor.unfilled) console.log(`skip: ${u.id} (${u.reason})`)
+    // scripts call the `shipkit` bin — dead on arrival unless the package is
+    // actually installed (field bug 2026-07-22: init via bunx, no dep, exit 127)
+    if (opts.bin == null) {
+        try {
+            Bun.resolveSync('rvlib-shipkit', root)
+        } catch {
+            console.log('WARN rvlib-shipkit not installed here — the scripts above call its bin and will exit 127')
+            console.log('      fix: bun add -d rvlib-shipkit')
+        }
+    }
     console.log('next: fill venues/social in repo.config.ts, then `bun run ci`')
     console.log('next: identity+assets — mint .rv-identity/brand.ts + .rv-assets/kit.ts, `shipkit assets identity` (the identity contract expects public/ favicon+og+logo)')
     return 0

package/src/tui/run-tui.ts

@@ -0,0 +1,25 @@
+// The tui command body — a separate module so cli.ts NEVER loads
+// react/ink/mobx for non-tui commands (a fresh consumer running `shipkit ci`
+// must not touch the react dependency chain; field bug 2026-07-22: 0.3.0
+// crashed every command on repos without react-dom).
+import React from 'react'
+import { render } from 'ink'
+import { configure } from 'mobx'
+import { loadRepoConfig } from '../repo-config.ts'
+import { checksPanel } from './checks-panel.ts'
+import { tasksPanel } from './tasks-panel.ts'
+import { TuiApp } from './tui-app.tsx'
+import { TuiStore } from './tui-store.ts'
+
+export async function runTui(root: string): Promise<number> {
+    const c = await loadRepoConfig(root)
+    // playbook (build/mobx): enforceActions warns on stray mutations — the
+    // only signal. Read-warning flags stay off: useInput handler reads are
+    // legitimately untracked and would false-positive.
+    configure({ enforceActions: 'always' })
+    const store = new TuiStore(c.name, [tasksPanel(root, c), checksPanel(root), ...(c.tui?.panels ?? [])])
+    store.refresh() // instant static paint; results stream in
+    const app = render(React.createElement(TuiApp, { store }))
+    await app.waitUntilExit()
+    return 0
+}