rvlib-shipkit 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # 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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "0.3.1",
+    "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",

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`)