rvlib-shipkit 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.26.0
+
+- **start means START: the full bootstrap runs on any dir with no commit history.** 0.25.0 widened the scaffold to empty dirs and commitless husks, and the very next field run hit the remaining wall: a folder holding one stray readme was still refused. The gate is now commit history alone: no commits means the dir is startable, and loose files simply ride in the first commit as the repo's first backup. What start still refuses is structural: a repo with real history is never scaffolded or pushed over, a subdirectory of another work tree gets nothing, a temp dir never mints a github repo, and the risky-file refusal still blocks a first commit carrying a `.env` or `node_modules` anywhere in the tree.
+
 ## 0.25.0
 
 - **A pre-existing EMPTY dir (or a commitless git-only husk) starts like a brand-new one.** The full-bootstrap scaffold keyed on "this run created the dir", so `mkdir foo` followed by `shipkit start foo`, or a re-run over the husk an older shipkit left, still ended in git-only plus manual next steps. The everyday-cd guard exists to protect a folder holding files, and an empty folder holds none: emptiness (junk like `.DS_Store` aside) now counts as starting intent, a `.git` with no commits counts too, and a git dir with real history stays untouched. A folder with files keeps the old behavior exactly.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "0.25.0",
+    "version": "0.26.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/cli/cmd_Start.ts

@@ -9,7 +9,7 @@ export class StartCommand extends Command {
 
     static override usage = Command.Usage({
         category: 'Setup',
-        description: 'create (or enter) ~/dev/<name> from ANY cwd, READY to work in: ensures the dir, seeds CLAUDE.md include lines, and on a BRAND-NEW dir scaffolds a minimal package.json + src/index.ts + the rvlib-shipkit dev dep, wires shipkit (repo.config.ts via init), then runs the whole bootstrap chain: git init, first commit, PRIVATE github repo, push. A pre-existing folder counts as brand new when it is EMPTY or a commitless git husk. One holding files gets git only, never a scaffold (--github forces only the github half for it). Prints the dir on stdout so a shell alias can cd there. cwd-only sibling: `shipkit init`',
+        description: 'create (or enter) ~/dev/<name> from ANY cwd, READY to work in: ensures the dir, seeds CLAUDE.md include lines, scaffolds a minimal package.json + src/index.ts + the rvlib-shipkit dev dep on any dir with no commit history (loose files ride in the first commit), wires shipkit (repo.config.ts via init), then runs the whole bootstrap chain: git init, first commit, PRIVATE github repo, push. Only a repo with real history is left as it is. Prints the dir on stdout so a shell alias can cd there. cwd-only sibling: `shipkit init`',
         examples: [
             ['create or enter ~/dev/pong: dir, package.json, shipkit wiring, git, first commit, private github repo, push', 'shipkit start pong'],
             ['seed CLAUDE.md includes', "shipkit start pong --include '@~/wiki/index.md' --include '@./agent/index.md'"],

package/src/start-repo.ts

@@ -4,7 +4,7 @@
 // output is the resolved dir, so a sourced shell alias can
 // `cd "$(shipkit start <name>)"` (the one thing a child process can't do
 // for its parent shell).
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { homedir } from 'os'
 import { join } from 'path'
 import { ensureGitRepo, firstGhLine, IGNORE_BASELINE, isScratch, publishRepo, runner, type Run } from './git-bootstrap.ts'
@@ -35,18 +35,7 @@ export async function startRepo(name: string, opts: StartOpts = {}): Promise<num
         return 2
     }
     const dir = join(opts.root ?? join(homedir(), 'dev'), name)
-    // this run creating the dir is the strongest signal that a repo is being
-    // STARTED, which is what the scaffold and the github half key on:
-    // `ship <name>` is also the everyday cd into a folder that already
-    // exists. A pre-existing dir with NOTHING in it carries the same intent
-    // (there are no files to protect), and so does a git-only husk with no
-    // commits (what an interrupted start leaves behind). Captured here,
-    // BEFORE the include seeding writes CLAUDE.md into the dir
     const justCreated = !existsSync(dir)
-    const JUNK = new Set(['.DS_Store', '.localized'])
-    const entries = justCreated ? [] : readdirSync(dir).filter((e) => !JUNK.has(e))
-    const emptyDir = !justCreated && entries.length === 0
-    const gitOnlyDir = !justCreated && entries.length === 1 && entries[0] === '.git'
     if (justCreated) {
         mkdirSync(dir, { recursive: true })
         console.error(`ok: created ${dir}`)
@@ -78,14 +67,12 @@ export async function startRepo(name: string, opts: StartOpts = {}): Promise<num
         }
     }
     // start is the from-anywhere verb, and a STARTED repo comes out READY:
-    // a brand-new dir gets a minimal package.json, a first src/index.ts, the
-    // rvlib-shipkit dev dep, repo.config.ts via init, git, first commit,
-    // private github repo, push. A dir that already holds a project
-    // (package.json) gets the same minus the scaffold. A PRE-EXISTING dir
-    // with NO project is the everyday cd into some old folder: git only,
-    // never a scaffold (--github forces only the github half, so it must
-    // never write a package.json into a folder that holds someone's files).
-    // init itself stays cwd-only, like git init.
+    // any dir with no commit history gets a minimal package.json, a first
+    // src/index.ts, the rvlib-shipkit dev dep, repo.config.ts via init, git,
+    // first commit, private github repo, push. A dir that already holds a
+    // project (package.json) gets the same minus the scaffold. Only a repo
+    // with real history is left as it is (git wiring aside): that history
+    // owns the dir. init itself stays cwd-only, like git init.
     // --skip means shipkit NEVER TOUCHES a listed repo (a day-job checkout
     // belongs on that list), not just no CLAUDE.md. And the cd contract survives a
     // failed adoption: the dir always prints, wiring trouble is a WARN.
@@ -98,17 +85,16 @@ export async function startRepo(name: string, opts: StartOpts = {}): Promise<num
         let wired = false
         try { wired = await ensureGitRepo(dir, { print }) }
         catch (e) { console.error(`WARN could not wire git in ${dir}: ${e instanceof Error ? e.message : String(e)} — the dir is still yours`) }
-        // the scaffold fires for a dir this run created, a pre-existing dir
-        // that was EMPTY, or a commitless git-only husk (never --github
-        // alone: forcing the github half on a folder holding files must not
-        // write a project into it), and only where git actually wired (a
-        // subdirectory of another work tree gets nothing): the minimal
-        // package.json lands so init below has its floor and the first
-        // commit carries a working repo, not an empty husk
-        let startable = justCreated || emptyDir
-        if (!startable && gitOnlyDir && wired)
-            startable = (await runner('git', dir, 120_000)(['rev-parse', '--verify', 'HEAD'])).code !== 0
-        if (wired && startable && !existsSync(join(dir, 'package.json')) && !existsSync(join(dir, 'repo.config.ts'))) {
+        // start means START: the scaffold fires for ANY dir with no commit
+        // history (created this run, found empty, found holding loose files,
+        // or the husk an interrupted start left). Pre-existing files simply
+        // ride in the first commit, which backs them up. What it never
+        // touches: a repo with real history (that history owns the dir), a
+        // subdirectory of another work tree (git refused, wired is false),
+        // and the risky-file commit refusal downstream still guards .env and
+        // node_modules
+        const startable = wired && (await runner('git', dir, 120_000)(['rev-parse', '--verify', 'HEAD'])).code !== 0
+        if (startable && !existsSync(join(dir, 'package.json')) && !existsSync(join(dir, 'repo.config.ts'))) {
             const pkg = { name, version: '0.0.0', private: true, type: 'module', scripts: {} }
             writeFileSync(join(dir, 'package.json'), JSON.stringify(pkg, null, 4) + '\n')
             // the first source file, so the ci gate is green from commit one: