lanekeeper 0.1.1 → 0.1.3

package/README.md

@@ -60,6 +60,7 @@ locally instead of in someone else's billed cloud. 💸
 | `lanekeeper promote` | Ships the integration branch to production. **Human-only** — never in an agent's instructions, never automated. |
 | `lanekeeper preview` | Instantly mirrors a lane's live working tree — uncommitted changes included — onto the main checkout, so you can look at it without a build. |
 | `lanekeeper port` | Prints a lane's dev-server port, derived from its own directory name. |
+| `lanekeeper prune` | Removes already-landed sibling lane worktrees on demand — `land` already does this automatically, this is for "clean these up right now" instead of waiting for the next lane to land something. |
 
 Plus 🔒 a pre-push hook that makes `land` non-optional: a direct `git push`
 straight to the integration branch gets bounced, full stop. Not a lint
@@ -259,6 +260,12 @@ Things a sharp reader should already know before they ask:
   CLAUDE.md tells it to resolve the conflict itself and re-run `land`, the
   same way it'd fix any other bug — `checkCommand` still gates the result
   either way, so a bad resolution gets caught there.
+- **Auto-pruning checks for a live process, via `lsof`.** A merged branch
+  alone isn't enough to prune a lane — a brand-new, zero-commit lane is
+  *trivially* "merged" too (nothing's diverged yet), so pruning also
+  refuses to touch any worktree with a live process's cwd inside it right
+  now. That check needs `lsof` on PATH; if it's missing, pruning fails
+  closed (treats liveness as unknown, never removes) rather than guessing.
 
 ## 🧬 Where this came from
 

package/dist/bin/lanekeeper.js

@@ -17,6 +17,8 @@ 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 { resolveMainCheckout } from "../lib/main-checkout.js";
+import { pruneLandedLanes } from "../lib/prune-lanes.js";
 const [, , command, ...rest] = process.argv;
 async function readStdin() {
     const chunks = [];
@@ -180,6 +182,30 @@ async function main() {
         case "promote":
             process.exit(await promote());
             return;
+        case "prune": {
+            // `land` already does this automatically as a side effect of every
+            // successful landing — this is the on-demand escape hatch for
+            // "clean these up right now" instead of waiting for the next lane to
+            // land something. Same safety rules apply: only already-merged
+            // branches, never anything with a live process inside, never the
+            // worktree this command itself is running from.
+            const root = findRepoRoot();
+            if (!root || !hasConfig(root)) {
+                console.error("lanekeeper prune: no lanekeeper.config found — nothing to do.");
+                process.exit(0);
+            }
+            const cfg = await loadConfig(root);
+            const mainTop = resolveMainCheckout(process.cwd());
+            const pruned = pruneLandedLanes(mainTop, cfg, process.cwd());
+            if (pruned.length === 0) {
+                console.log("lanekeeper prune: nothing to clean up — no already-landed sibling lanes found.");
+            }
+            else {
+                const names = pruned.map((p) => p.split("/").pop()).join(", ");
+                console.log(`lanekeeper prune: removed ${pruned.length} already-landed lane${pruned.length === 1 ? "" : "s"}: ${names}`);
+            }
+            return;
+        }
         case "preview":
             return runPreview(rest);
         case "build-lock": {

package/dist/lib/prune-lanes.d.ts

@@ -5,4 +5,4 @@ import type { LaneKeeperConfig } from "./config.js";
  * worktree (dirty, diverged, busy) just skips that one; this never blocks
  * or fails the `land` it's running as part of.
  */
-export declare function pruneLandedLanes(mainTop: string, cfg: Pick<LaneKeeperConfig, "worktreeSuffix" | "branchPrefix" | "integrationBranch">, currentWorktree: string): string[];
+export declare function pruneLandedLanes(mainTop: string, cfg: Pick<LaneKeeperConfig, "worktreeSuffix" | "branchPrefix" | "integrationBranch" | "regenerableFiles">, currentWorktree: string): string[];

package/dist/lib/prune-lanes.js

@@ -14,9 +14,25 @@
  *      fast-forwarded yet at the exact moment this runs. That's the literal
  *      definition of "nothing to lose": the work already made it upstream
  *      under its own name.
- *   2. `git worktree remove` (no `--force`) refuses on its own if the
+ *   2. Never touch a worktree with a LIVE process currently working in it
+ *      (checked via `lsof -a -d cwd`, see below) — this is NOT redundant
+ *      with the ancestor check. A brand-new lane that hasn't diverged yet
+ *      is *trivially* an ancestor of upstream (its tip IS a commit already
+ *      on the integration branch, just because nothing's been committed
+ *      there yet) — structurally identical, in the git graph alone, to a
+ *      lane whose own real work already landed. Only a liveness check can
+ *      tell "someone's about to start working here" apart from "this is
+ *      truly done." Confirmed live: a fresh, zero-commit lane got swept by
+ *      another lane's land before its own first commit.
+ *   3. `git worktree remove` (no `--force`) refuses on its own if the
  *      worktree has uncommitted changes — dirty work is never discarded
- *      just because its branch happens to be merged.
+ *      just because its branch happens to be merged. The ONE exception,
+ *      matching `sync`/`land`: files listed in `regenerableFiles`
+ *      (next-env.d.ts and the like) are discarded first and the removal
+ *      retried, since a build tool rewriting its own output shouldn't be
+ *      the thing that leaves an otherwise fully-landed lane stuck forever.
+ *      Any OTHER dirty file blocks pruning exactly as before — real
+ *      uncommitted work is never discarded just to tidy up disk space.
  * Deleting the now-redundant local branch (`git branch -d`, never `-D`) is a
  * separate, best-effort tidiness step AFTER the worktree is already gone —
  * it checks merge state against local HEAD rather than origin, so it can
@@ -24,9 +40,31 @@
  * That failure doesn't undo the (already-safe) worktree removal or keep it
  * out of the returned list; it just leaves a harmless leftover branch ref.
  */
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { basename, dirname } from "node:path";
+/**
+ * Is any live process's current working directory inside `dir` right now?
+ * `lsof`'s own exit code is NOT reliable for this — it returns non-zero
+ * both when nothing matches AND when it merely fails to inspect some
+ * unrelated process it lacks permission for (common, e.g. root-owned system
+ * daemons), even while correctly printing real matches. The trustworthy
+ * signal is whether stdout has any content at all: genuinely idle
+ * directories produce completely empty output; a live process's cwd entry
+ * always prints a real row. `-a` ANDs the two filters together (lsof ORs by
+ * default) so this only matches things actually inside `dir`, not every
+ * process on the system.
+ *
+ * If `lsof` isn't available at all, this fails CLOSED — treats liveness as
+ * unknown/possible rather than confirmed-safe, so an unverifiable state
+ * never gets treated the same as a verified-idle one.
+ */
+function hasLiveProcessInside(dir) {
+    const result = spawnSync("lsof", ["-a", "-d", "cwd", "+D", dir], { encoding: "utf8" });
+    if (result.error)
+        return true; // lsof missing/unspawnable — can't verify, assume in use
+    return result.stdout.trim().length > 0;
+}
 // Best-effort realpath — a "current worktree" that's already gone (or was
 // never real to begin with) shouldn't crash the sweep over one path.
 function existsRealpath(path) {
@@ -37,6 +75,15 @@ function existsRealpath(path) {
         return path;
     }
 }
+function tryRemoveWorktree(mainTop, wt) {
+    try {
+        execFileSync("git", ["worktree", "remove", wt], { cwd: mainTop, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function listWorktrees(mainTop) {
     const out = execFileSync("git", ["worktree", "list", "--porcelain"], { cwd: mainTop, encoding: "utf8" });
     const entries = [];
@@ -77,6 +124,7 @@ export function pruneLandedLanes(mainTop, cfg, currentWorktree) {
     const laneDirPrefix = `${basename(mainTopReal)}${cfg.worktreeSuffix}`;
     const parent = dirname(mainTopReal);
     const upstream = `origin/${cfg.integrationBranch}`;
+    const regenerable = new Set(cfg.regenerableFiles);
     let worktrees;
     try {
         worktrees = listWorktrees(mainTop);
@@ -100,12 +148,25 @@ export function pruneLandedLanes(mainTop, cfg, currentWorktree) {
         catch {
             continue; // not safe to touch — leave this lane exactly as it is
         }
-        try {
-            execFileSync("git", ["worktree", "remove", wt], { cwd: mainTop, stdio: "ignore" });
-        }
-        catch {
-            continue; // dirty or busy — worktree remove refused on its own, nothing removed
+        if (hasLiveProcessInside(wt))
+            continue; // someone's actively in here — never touch it
+        let removed = tryRemoveWorktree(mainTop, wt);
+        if (!removed) {
+            // Blocked by dirty files? Only retry if EVERY one of them is a
+            // configured regenerable file — anything else is real uncommitted
+            // work, and this lane is left alone exactly as before.
+            const dirty = execFileSync("git", ["status", "--porcelain"], { cwd: wt, encoding: "utf8" })
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => line.slice(3).trim());
+            const blocking = dirty.filter((f) => !regenerable.has(f));
+            if (dirty.length > 0 && blocking.length === 0) {
+                execFileSync("git", ["checkout", "--", ...dirty], { cwd: wt, stdio: "ignore" });
+                removed = tryRemoveWorktree(mainTop, wt);
+            }
         }
+        if (!removed)
+            continue; // still dirty (real work) or otherwise busy — leave it alone
         // The worktree is gone — this is now unconditionally a pruned lane,
         // regardless of what happens to the branch ref below.
         pruned.push(wt);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lanekeeper",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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",