lanekeeper 0.1.6 → 0.1.8

package/README.md

@@ -102,17 +102,11 @@ This does the whole setup, not just the config file:
 - **`.husky/pre-push`** — created or appended to, *if* you already have
   Husky. If you don't, `init` tells you so instead of silently writing to
   the untracked, not-shared-with-your-team `.git/hooks/pre-push`.
+- **`package.json` scripts** — `land`, `sync`, `promote`, `preview`, and
+  `preview:restore` added, skipping any you've already defined yourself.
 
-**Commit everything it wrote.** Then add to `package.json`:
-```json
-"scripts": {
-  "land": "lanekeeper land",
-  "sync": "lanekeeper sync",
-  "promote": "lanekeeper promote",
-  "preview": "lanekeeper preview",
-  "preview:restore": "lanekeeper preview --restore"
-}
-```
+**Commit everything it wrote**, then you're running. Two steps, not a setup
+guide.
 
 If `init` couldn't detect a `checkCommand` (no matching script in
 package.json), every push is **blocked** until you set one — see 🧰 What's

package/dist/bin/lanekeeper.js

@@ -16,7 +16,7 @@ import { runWorktreeCreateHook } from "../hooks/worktree-create.js";
 import { lanePort } from "../lib/lane-port.js";
 import { claudeMdSnippet, MARKER } from "../lib/claude-md-snippet.js";
 import { detectCheckCommand, runCheckCommand } from "../lib/check-command.js";
-import { wireClaudeSettings, wireHuskyPrePush, ensureHooksPath } from "../lib/wire-hooks.js";
+import { wireClaudeSettings, wireHuskyPrePush, ensureHooksPath, wirePackageJsonScripts } from "../lib/wire-hooks.js";
 import { resolveMainCheckout } from "../lib/main-checkout.js";
 import { pruneLandedLanes } from "../lib/prune-lanes.js";
 const [, , command, ...rest] = process.argv;
@@ -34,10 +34,15 @@ async function init() {
     }
     const { writeFileSync, readFileSync: read, existsSync, appendFileSync } = await import("node:fs");
     const { join } = await import("node:path");
+    // What actually got newly written or modified this run — only these need
+    // committing. If everything below was already wired from a previous run,
+    // there's nothing new to tell you to commit.
+    const writtenFiles = [];
     if (hasConfig(root)) {
         console.log("lanekeeper init: lanekeeper.config.mjs already exists — leaving it alone.");
     }
     else {
+        writtenFiles.push("lanekeeper.config.mjs");
         const detectedBranch = detectCurrentBranch(root);
         const detectedCheck = detectCheckCommand(root);
         const generated = {
@@ -80,10 +85,12 @@ export default ${JSON.stringify(generated, null, 2)};
     if (!existsSync(claudeMdPath)) {
         writeFileSync(claudeMdPath, `# Project instructions for Claude Code\n\n${snippet}`);
         console.log(`lanekeeper init: wrote ${claudeMdPath}`);
+        writtenFiles.push("CLAUDE.md");
     }
     else if (!read(claudeMdPath, "utf8").includes(MARKER)) {
         appendFileSync(claudeMdPath, `\n${snippet}`);
         console.log(`lanekeeper init: appended the LaneKeeper workflow section to ${claudeMdPath}`);
+        writtenFiles.push("CLAUDE.md");
     }
     else {
         console.log(`lanekeeper init: ${claudeMdPath} already has the LaneKeeper workflow section — leaving it alone.`);
@@ -92,9 +99,11 @@ export default ${JSON.stringify(generated, null, 2)};
     switch (claudeSettingsResult) {
         case "created":
             console.log(`lanekeeper init: wrote ${join(root, ".claude", "settings.json")} with the WorktreeCreate hook.`);
+            writtenFiles.push(".claude/settings.json");
             break;
         case "merged":
             console.log(`lanekeeper init: added the WorktreeCreate hook to your existing ${join(root, ".claude", "settings.json")}.`);
+            writtenFiles.push(".claude/settings.json");
             break;
         case "already-wired":
             console.log("lanekeeper init: .claude/settings.json already has the WorktreeCreate hook — leaving it alone.");
@@ -108,9 +117,11 @@ export default ${JSON.stringify(generated, null, 2)};
     switch (prePushResult) {
         case "created":
             console.log("lanekeeper init: wrote .husky/pre-push.");
+            writtenFiles.push(".husky/pre-push");
             break;
         case "merged":
             console.log("lanekeeper init: appended LaneKeeper's checks to your existing .husky/pre-push.");
+            writtenFiles.push(".husky/pre-push");
             break;
         case "already-wired":
             console.log("lanekeeper init: .husky/pre-push already wired — leaving it alone.");
@@ -139,13 +150,33 @@ export default ${JSON.stringify(generated, null, 2)};
                 break;
         }
     }
+    const scriptsResult = wirePackageJsonScripts(root);
+    switch (scriptsResult.result) {
+        case "added":
+            console.log(`lanekeeper init: added "${scriptsResult.added.join('", "')}" to package.json scripts.`);
+            writtenFiles.push("package.json");
+            break;
+        case "already-wired":
+            console.log("lanekeeper init: package.json already has all five scripts — leaving them alone.");
+            break;
+        case "no-package-json":
+            console.log("lanekeeper init: no package.json found — scripts NOT wired automatically.");
+            console.log('  Add "land"/"sync"/"promote"/"preview"/"preview:restore" -> "lanekeeper <name>" yourself.');
+            break;
+        case "unparseable":
+            console.log("lanekeeper init: package.json exists but isn't valid JSON — left untouched. Wire the scripts manually.");
+            break;
+    }
     console.log("");
     console.log("Next steps:");
-    console.log("  1. Check lanekeeper.config.mjs — integrationBranch/checkCommand were auto-detected;");
-    console.log("     set productionBranch too if you run a two-stage model.");
-    console.log('  2. Add to package.json "scripts": land, sync, promote, preview -> "lanekeeper <name>".');
-    console.log("  3. Commit lanekeeper.config.mjs, CLAUDE.md, .claude/settings.json, and .husky/pre-push.");
-    console.log("  4. claude --worktree <name> — the agent takes it from there.");
+    if (writtenFiles.length > 0) {
+        console.log(`  1. Commit what it wrote — ${writtenFiles.join(", ")}.`);
+        console.log("  2. claude --worktree <name> — the agent takes it from there.");
+    }
+    else {
+        console.log("  1. claude --worktree <name> — the agent takes it from there.");
+        console.log("     (everything was already wired — nothing new to commit)");
+    }
 }
 async function main() {
     switch (command) {

package/dist/hooks/worktree-create.d.ts

@@ -11,4 +11,5 @@ export declare function createLane(mainTop: string, cfg: LaneKeeperConfig): {
     lane: number;
 };
 export declare function isEphemeralNpxCopy(selfPath: string): boolean;
+export declare function expectsLocalInstall(mainTop: string): boolean;
 export declare function runWorktreeCreateHook(): Promise<void>;

package/dist/hooks/worktree-create.js

@@ -24,7 +24,7 @@
  * automatically — nothing to release by hand.
  */
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, symlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, symlinkSync } from "node:fs";
 import { dirname, join, basename, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadConfig, hasConfig, DEFAULTS } from "../lib/config.js";
@@ -140,6 +140,25 @@ export function createLane(mainTop, cfg) {
 export function isEphemeralNpxCopy(selfPath) {
     return selfPath.includes(`${sep}_npx${sep}`);
 }
+// The guard above only makes sense for a host project that's an npm project
+// with lanekeeper as a real dependency — hola, say. A non-Node host repo
+// (a Haskell/Lua/Rust/whatever project with no package.json at all) has
+// nowhere to install lanekeeper INTO; npx's ephemeral cache is the only way
+// it can ever run lanekeeper commands, not a fallback masking a broken
+// local install. Only expect a local install — and therefore only treat
+// ephemeral execution as suspicious — when the host's own package.json
+// actually lists lanekeeper as a dependency. No package.json, or one that
+// doesn't mention lanekeeper: ephemeral execution is completely normal.
+export function expectsLocalInstall(mainTop) {
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(join(mainTop, "package.json"), "utf8"));
+    }
+    catch {
+        return false; // no package.json, or unreadable/invalid — nothing "expected" to be there
+    }
+    return Boolean(pkg.dependencies?.lanekeeper || pkg.devDependencies?.lanekeeper);
+}
 async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin)
@@ -156,11 +175,11 @@ export async function runWorktreeCreateHook() {
     }
     const fromCwd = input.cwd ?? process.cwd();
     try {
-        if (isEphemeralNpxCopy(fileURLToPath(import.meta.url))) {
+        const mainTop = resolveMainCheckout(fromCwd);
+        if (expectsLocalInstall(mainTop) && isEphemeralNpxCopy(fileURLToPath(import.meta.url))) {
             throw new Error("running from npx's ephemeral cache, not this project's own installed dependency — " +
                 "node_modules is missing or broken. Run `npm install` in the main checkout and try again.");
         }
-        const mainTop = resolveMainCheckout(fromCwd);
         const cfg = hasConfig(mainTop) ? await loadConfig(mainTop) : { ...DEFAULTS };
         const { wt } = createLane(mainTop, cfg);
         process.stdout.write(wt + "\n");

package/dist/lib/wire-hooks.d.ts

@@ -24,3 +24,16 @@ export type HooksPathResult = "set" | "already-set" | "custom-path";
  * husky's own next real install corrects it to `.husky/_`.
  */
 export declare function ensureHooksPath(root: string): HooksPathResult;
+export type ScriptsWireResult = "added" | "already-wired" | "unparseable" | "no-package-json";
+/**
+ * The last "copy this yourself" step `init` used to leave on the table:
+ * Quickstart told you to hand-add five scripts to package.json instead of
+ * just adding them. Same additive/idempotent contract as the rest of this
+ * file — only ever fills in scripts that don't exist yet, never overwrites
+ * one you've customized (e.g. if `land` already runs something of yours
+ * first), and does nothing if all five are already there.
+ */
+export declare function wirePackageJsonScripts(root: string): {
+    result: ScriptsWireResult;
+    added: string[];
+};

package/dist/lib/wire-hooks.js

@@ -15,6 +15,13 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 const HOOK_COMMAND = "npx lanekeeper hook worktree-create";
 const PRE_PUSH_MARKER = "lanekeeper check-push";
+const PACKAGE_SCRIPTS = {
+    land: "lanekeeper land",
+    sync: "lanekeeper sync",
+    promote: "lanekeeper promote",
+    preview: "lanekeeper preview",
+    "preview:restore": "lanekeeper preview --restore",
+};
 export function wireClaudeSettings(root) {
     const dir = join(root, ".claude");
     const path = join(dir, "settings.json");
@@ -121,3 +128,35 @@ export function ensureHooksPath(root) {
     execFileSync("git", ["config", "core.hooksPath", ".husky"], { cwd: root });
     return "set";
 }
+/**
+ * The last "copy this yourself" step `init` used to leave on the table:
+ * Quickstart told you to hand-add five scripts to package.json instead of
+ * just adding them. Same additive/idempotent contract as the rest of this
+ * file — only ever fills in scripts that don't exist yet, never overwrites
+ * one you've customized (e.g. if `land` already runs something of yours
+ * first), and does nothing if all five are already there.
+ */
+export function wirePackageJsonScripts(root) {
+    const path = join(root, "package.json");
+    if (!existsSync(path))
+        return { result: "no-package-json", added: [] };
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return { result: "unparseable", added: [] };
+    }
+    pkg.scripts ??= {};
+    const added = [];
+    for (const [name, command] of Object.entries(PACKAGE_SCRIPTS)) {
+        if (!(name in pkg.scripts)) {
+            pkg.scripts[name] = command;
+            added.push(name);
+        }
+    }
+    if (added.length === 0)
+        return { result: "already-wired", added: [] };
+    writeFileSync(path, JSON.stringify(pkg, null, 2) + "\n");
+    return { result: "added", added };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lanekeeper",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "The local, zero-cost merge queue for parallel Claude Code agents. Plugs into Claude Code's native worktree isolation; one build at a time, one landing at a time, zero races.",
   "type": "module",
   "license": "MIT",