rvlib-shipkit 0.28.0 → 0.29.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.29.0
+
+- **Creation output states facts instead of listing chores.** A fresh `start` ended on five lines that meant nothing to the person reading them: `skip: lint/typecheck/test (no … script)` about scripts a repo born one second ago has no use for, plus `next:` nags to fill venues and mint identity assets, neither of which anybody has decided on yet. `init` now reports the gate floor as ONE line naming what resolved, and `start` closes with one measured summary (`<name> is ready — N file(s) committed, pushed to <remote>`). Venues raise themselves through the contract checker the day one is declared, and identity through rule SK002 the day the repo grows a public surface. An output that lists undecided work trains the reader to skip all of it.
+
 ## 0.28.0
 
 - **The `.claude/` policy files are OPT-IN.** 0.27.0 wrote a pre-approved shell allowlist (`curl *`, `git push*`, `./deploy.sh`) and an attribution silencer into every started repo, gitignored and therefore invisible to review. Those are decisions about what an agent can do in a repo and what its git history says, so they now require the caller to declare a house (`claudePolicy`, which `start` enables when it seeds CLAUDE.md include lines), and the grant prints once by name when it lands. The verify skill still lands for everyone.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "0.28.0",
+    "version": "0.29.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/init-repo.ts

@@ -99,11 +99,15 @@ export async function initRepo(root: string, opts: InitOpts = {}): Promise<numbe
     // `shipkit check --fix SK004`, one code path
     const g = await gitignorePolicy.fix!({ root, config: defineRepo({ name }) })
     p(`ok: .gitignore policy block ${g.changed ? 'written' : 'already current'}`)
-    // show what the gate actually is — a thin floor must be seen at init
-    // time, not discovered after a bad commit slipped through
+    // what the gate actually runs, in ONE line: a thin floor must be seen at
+    // init time rather than discovered after a bad commit slipped through.
+    // The per-task resolution is diagnostics, and a `skip:` naming a script
+    // this repo has no use for yet reads as a chore list on a repo that was
+    // born a second ago. `shipkit ci` reports the same facts when they
+    // matter, and reports them about a repo that has code in it
     const floor = resolveFloor(defineRepo({ name }), root)
-    for (const t of floor.tasks) p(`ok: floor ${t.id} ← ${floor.sources[t.id] ?? 'unknown'}`)
-    for (const u of floor.unfilled) p(`skip: ${u.id} (${u.reason})`)
+    if (floor.tasks.length > 0) p(`ok: gate floor: ${floor.tasks.map((t) => t.id).join(', ')}`)
+    else p(`WARN the gate would check NOTHING here (${floor.unfilled.map((u) => u.id).join(', ')} all unresolved) — see \`shipkit rules\``)
     // every verb comes from the `shipkit` bin — dead on arrival unless the
     // package is actually installed (bunx runs without adding the dep)
     if (opts.bin == null) {
@@ -116,7 +120,11 @@ export async function initRepo(root: string, opts: InitOpts = {}): Promise<numbe
     }
     // last, so the first commit carries repo.config.ts and the scripts above
     if (wired && opts.noPublish !== true) await publishRepo(root, { github: opts.github, gh: opts.gh, print: p })
-    p('next: fill venues/social in repo.config.ts, then `shipkit ci`')
-    p('next: identity+assets — mint .rv-identity/brand.ts + .rv-assets/kit.ts, `shipkit assets identity` (the identity contract expects public/ favicon+og+logo)')
+    // no chore list here. Venues belong in repo.config the day a venue is
+    // CHOSEN, and the contract checker fails the gate from that day on.
+    // Identity is needed once the repo has a public surface, and rule SK002
+    // warns exactly then. Both told at creation time are noise about a
+    // decision nobody has made yet. `start` owns the one closing line
+    if (opts.noPublish !== true) p('next: `shipkit ci` is the gate — run it to check your work')
     return 0
 }

package/src/start-repo.ts

@@ -148,6 +148,7 @@ export async function startRepo(name: string, opts: StartOpts = {}): Promise<num
         }
         // last line, so what to do next is the last thing read
         if (unscaffolded) console.error(`next: scaffold the app in ${dir} (package.json), then \`shipkit init\` inside it — the commit gates arm on the first ci run`)
+        else console.error(`ok: ${name} is ready — ${await summarize(dir)}`)
     }
     // a child process cannot cd its parent shell, so the dir goes to stdout
     // and a sourced wrapper does the move. Without one, say the move out
@@ -157,3 +158,20 @@ export async function startRepo(name: string, opts: StartOpts = {}): Promise<num
     console.log(dir)
     return 0
 }
+
+/** the one closing fact: what this repo IS now, measured rather than
+ *  narrated. Everything a repo still needs is reported by the gate, about a
+ *  repo with code in it, on the day it matters */
+async function summarize(dir: string): Promise<string> {
+    const git = runner('git', dir, 30_000)
+    const files = (await git(['ls-files'])).out.trim().split('\n').filter((l) => l !== '').length
+    const head = await git(['log', '-1', '--format=%h'])
+    // git merges stderr into stdout, so a missing remote answers with its
+    // error text: only a zero exit means that output is a url
+    const origin = await git(['remote', 'get-url', 'origin'])
+    const pushed = (await git(['rev-parse', '--verify', '@{upstream}'])).code === 0
+    const bits = [head.code === 0 ? `${files} file(s) committed` : 'not committed yet']
+    if (origin.code === 0) bits.push(pushed ? `pushed to ${origin.out.trim()}` : `remote wired, nothing pushed yet`)
+    else bits.push('local only, no remote')
+    return bits.join(', ')
+}