@paleo/worktree-env 0.4.0 → 0.5.0

package/dist/slots.js

@@ -2,59 +2,56 @@ import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { allPorts, isValidPort } from "./ports.js";
-export const WORKTREES_DIR = ".local/worktrees";
-export const SLOTS_FILE = ".local/worktrees/slots.json";
-export function readSlots(mainWorktree) {
-    const filePath = join(mainWorktree, SLOTS_FILE);
+const SLOTS_FILENAME = "slots.json";
+export function readSlots(mainWorktree, registryDir) {
+    const filePath = join(mainWorktree, registryDir, SLOTS_FILENAME);
     if (!existsSync(filePath))
         return { slots: {} };
     return JSON.parse(readFileSync(filePath, "utf-8"));
 }
-export function writeSlots(mainWorktree, registry) {
-    const filePath = join(mainWorktree, SLOTS_FILE);
-    mkdirSync(join(mainWorktree, WORKTREES_DIR), { recursive: true });
+export function writeSlots(mainWorktree, registryDir, registry) {
+    const filePath = join(mainWorktree, registryDir, SLOTS_FILENAME);
+    mkdirSync(join(mainWorktree, registryDir), { recursive: true });
     writeFileSync(filePath, `${JSON.stringify(registry, undefined, 2)}\n`);
 }
-export function pickSlotPort(args, registry) {
-    const resolvedCurrent = resolve(args.currentWorktree);
-    if (args.slot !== undefined) {
-        const port = Number(args.slot);
-        if (!isValidPort(port, args.scheme)) {
-            console.error(`Error: Slot must be a valid port: ${allPorts(args.scheme).join(", ")}.`);
-            process.exit(1);
-        }
-        const existing = registry.slots[String(port)];
-        if (existing && resolve(existing.worktree) !== resolvedCurrent) {
-            console.error(`Error: Slot ${port} is already taken by ${existing.worktree} (branch: ${existing.branch}).`);
-            process.exit(1);
-        }
-        return port;
-    }
-    const existingEntry = Object.entries(registry.slots).find(([, v]) => resolve(v.worktree) === resolvedCurrent);
-    if (existingEntry)
-        return Number(existingEntry[0]);
-    for (const port of allPorts(args.scheme)) {
-        if (!registry.slots[String(port)])
-            return port;
-    }
-    console.error("Error: All slots are taken. Remove a worktree with --remove first.");
-    process.exit(1);
-}
 export function resolveAndRegisterSlot(input) {
-    const registry = readSlots(input.mainWorktree);
+    const registry = readSlots(input.mainWorktree, input.registryDir);
     const port = pickSlotPort(input, registry);
     const existing = registry.slots[String(port)];
     const owner = input.requestedOwner ?? existing?.owner;
+    const createdAt = existing?.createdAt ?? new Date().toISOString();
+    // Re-runs of `--here` keep a previously finalized slot ready; otherwise reset to pending.
+    const status = existing?.status === "ready" ? "ready" : "pending";
     const entry = {
         worktree: input.currentWorktree,
         branch: input.branch,
+        createdAt,
+        status,
     };
     if (owner !== undefined)
         entry.owner = owner;
     registry.slots[String(port)] = entry;
-    writeSlots(input.mainWorktree, registry);
+    writeSlots(input.mainWorktree, input.registryDir, registry);
     return { port, owner };
 }
+export function markSlotReady(mainWorktree, registryDir, slotPort) {
+    const registry = readSlots(mainWorktree, registryDir);
+    const entry = registry.slots[String(slotPort)];
+    if (!entry)
+        return;
+    entry.status = "ready";
+    delete entry.failure;
+    writeSlots(mainWorktree, registryDir, registry);
+}
+export function markSlotFailed(mainWorktree, registryDir, slotPort, message) {
+    const registry = readSlots(mainWorktree, registryDir);
+    const entry = registry.slots[String(slotPort)];
+    if (!entry)
+        return;
+    entry.status = "failed";
+    entry.failure = { at: new Date().toISOString(), message };
+    writeSlots(mainWorktree, registryDir, registry);
+}
 export function validateSlotAvailability(slotArg, ctx) {
     if (slotArg === undefined)
         return;
@@ -63,43 +60,15 @@ export function validateSlotAvailability(slotArg, ctx) {
         console.error(`Error: Slot must be a valid port: ${allPorts(ctx.scheme).join(", ")}.`);
         process.exit(1);
     }
-    const registry = readSlots(ctx.mainWorktree);
+    const registry = readSlots(ctx.mainWorktree, ctx.registryDir);
     const existing = registry.slots[String(port)];
     if (existing && resolve(existing.worktree) !== resolve(ctx.currentWorktree)) {
         console.error(`Error: Slot ${port} is already taken by ${existing.worktree} (branch: ${existing.branch}).`);
         process.exit(1);
     }
 }
-export function lookupSlotForCwd() {
-    const cwd = resolve(process.cwd());
-    // Reads slots.json relative to cwd's `.local` symlink (so works in linked worktrees too).
-    const filePath = SLOTS_FILE;
-    if (!existsSync(filePath))
-        return undefined;
-    const registry = JSON.parse(readFileSync(filePath, "utf-8"));
-    for (const [port, entry] of Object.entries(registry.slots)) {
-        if (resolve(entry.worktree) === cwd) {
-            return {
-                slot: Number(port),
-                worktree: entry.worktree,
-                branch: entry.branch,
-                owner: entry.owner,
-            };
-        }
-    }
-    return undefined;
-}
-export function synthesizeMainSlot(basePort) {
-    const gitCommonDir = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf-8" }).trim();
-    const mainWorktree = dirname(gitCommonDir);
-    const cwd = resolve(process.cwd());
-    if (resolve(mainWorktree) !== cwd)
-        return undefined;
-    const branch = execFileSync("git", ["branch", "--show-current"], { encoding: "utf-8" }).trim();
-    return { slot: basePort, worktree: cwd, branch };
-}
-export function resolveCurrentSlot(basePort) {
-    const slot = lookupSlotForCwd() ?? synthesizeMainSlot(basePort);
+export function resolveCurrentSlot(basePort, registryDir) {
+    const slot = lookupSlotForCwd(registryDir) ?? synthesizeMainSlot(basePort);
     if (!slot) {
         console.error("Error: No slot found for this worktree. Run setup-worktree first.");
         process.exit(1);
@@ -111,7 +80,7 @@ export function handleSetOwner(input) {
         console.error("Error: --set-owner must be run from a linked worktree.");
         process.exit(1);
     }
-    const registry = readSlots(input.mainWorktree);
+    const registry = readSlots(input.mainWorktree, input.registryDir);
     const resolvedCurrent = resolve(input.currentWorktree);
     const entry = Object.entries(registry.slots).find(([, v]) => resolve(v.worktree) === resolvedCurrent);
     if (!entry) {
@@ -122,10 +91,67 @@ export function handleSetOwner(input) {
     const updated = {
         worktree: slotData.worktree,
         branch: slotData.branch,
+        createdAt: slotData.createdAt,
+        status: slotData.status,
     };
+    if (slotData.failure)
+        updated.failure = slotData.failure;
     if (input.newOwner !== undefined)
         updated.owner = input.newOwner;
     registry.slots[slotPort] = updated;
-    writeSlots(input.mainWorktree, registry);
+    writeSlots(input.mainWorktree, input.registryDir, registry);
     return { slotPort, owner: input.newOwner };
 }
+function pickSlotPort(args, registry) {
+    const resolvedCurrent = resolve(args.currentWorktree);
+    if (args.slot !== undefined) {
+        const port = Number(args.slot);
+        if (!isValidPort(port, args.scheme)) {
+            console.error(`Error: Slot must be a valid port: ${allPorts(args.scheme).join(", ")}.`);
+            process.exit(1);
+        }
+        const existing = registry.slots[String(port)];
+        if (existing && resolve(existing.worktree) !== resolvedCurrent) {
+            console.error(`Error: Slot ${port} is already taken by ${existing.worktree} (branch: ${existing.branch}).`);
+            process.exit(1);
+        }
+        return port;
+    }
+    const existingEntry = Object.entries(registry.slots).find(([, v]) => resolve(v.worktree) === resolvedCurrent);
+    if (existingEntry)
+        return Number(existingEntry[0]);
+    for (const port of allPorts(args.scheme)) {
+        if (!registry.slots[String(port)])
+            return port;
+    }
+    console.error("Error: All slots are taken. Remove a worktree with --remove first.");
+    process.exit(1);
+}
+function lookupSlotForCwd(registryDir) {
+    const cwd = resolve(process.cwd());
+    // Reads slots.json relative to cwd's shared-dir symlink (so works in linked worktrees too).
+    const filePath = join(registryDir, SLOTS_FILENAME);
+    if (!existsSync(filePath))
+        return undefined;
+    const registry = JSON.parse(readFileSync(filePath, "utf-8"));
+    for (const [port, entry] of Object.entries(registry.slots)) {
+        if (resolve(entry.worktree) === cwd) {
+            return {
+                slot: Number(port),
+                worktree: entry.worktree,
+                branch: entry.branch,
+                owner: entry.owner,
+            };
+        }
+    }
+    return undefined;
+}
+function synthesizeMainSlot(basePort) {
+    const gitCommonDir = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf-8" }).trim();
+    const mainWorktree = dirname(gitCommonDir);
+    const cwd = resolve(process.cwd());
+    if (resolve(mainWorktree) !== cwd)
+        return undefined;
+    const branch = execFileSync("git", ["branch", "--show-current"], { encoding: "utf-8" }).trim();
+    return { slot: basePort, worktree: cwd, branch };
+}

package/dist/worktree.d.ts

@@ -7,15 +7,14 @@ export interface RunCtx {
     verbose: boolean;
 }
 export declare function detectWorktree(): WorktreeContext;
-export declare function computeWorktreePath(mainWorktree: string, branch: string): string;
-export declare function branchExists(branch: string): boolean;
-export declare function useExistingBranch(branch: string, ctx: WorktreeContext, run: RunCtx): WorktreeContext;
-export declare function createBranch(requestedBranch: string, ctx: WorktreeContext, run: RunCtx): WorktreeContext;
-export declare function verifyBranchAbsentFromRemote(branch: string, run: RunCtx): void;
-export declare function getCurrentBranch(worktreePath: string): string;
 export declare function enforceWorktreeMode(args: {
     use?: string;
     create?: string;
     here?: boolean;
 }, ctx: WorktreeContext): void;
+export declare function useExistingBranch(branch: string, ctx: WorktreeContext, run: RunCtx): WorktreeContext;
+export declare function createBranch(requestedBranch: string, ctx: WorktreeContext, run: RunCtx): WorktreeContext;
+export declare function verifyBranchAbsentFromRemote(branch: string, run: RunCtx): void;
+export declare function getCurrentBranch(worktreePath: string): string;
 export declare function removeWorktree(worktreePath: string, run: RunCtx): void;
+export declare function computeWorktreePath(mainWorktree: string, branch: string): string;

package/dist/worktree.js

@@ -1,8 +1,5 @@
 import { execFileSync } from "node:child_process";
 import { basename, dirname, join, resolve } from "node:path";
-function stdioFor(ctx) {
-    return ctx.verbose ? "inherit" : "pipe";
-}
 export function detectWorktree() {
     const currentWorktree = execFileSync("git", ["rev-parse", "--show-toplevel"], {
         encoding: "utf-8",
@@ -12,23 +9,17 @@ export function detectWorktree() {
     const isMainWorktree = resolve(currentWorktree) === resolve(mainWorktree);
     return { currentWorktree, mainWorktree, isMainWorktree };
 }
-export function computeWorktreePath(mainWorktree, branch) {
-    const repoName = basename(mainWorktree);
-    const sanitized = branch.replaceAll("/", "-");
-    return join(dirname(mainWorktree), `${repoName}-${sanitized}`);
-}
-export function branchExists(branch) {
-    try {
-        execFileSync("git", ["rev-parse", "--verify", branch], { stdio: "pipe" });
-        return true;
-    }
-    catch {
-        try {
-            execFileSync("git", ["rev-parse", "--verify", `origin/${branch}`], { stdio: "pipe" });
-            return true;
+export function enforceWorktreeMode(args, ctx) {
+    if (args.use || args.create) {
+        if (!ctx.isMainWorktree) {
+            console.error("Error: --use and --create must be run from the main worktree.");
+            process.exit(1);
         }
-        catch {
-            return false;
+    }
+    else if (args.here) {
+        if (ctx.isMainWorktree) {
+            console.error("Error: --here must be run from a linked worktree, not from the main worktree.");
+            process.exit(1);
         }
     }
 }
@@ -54,7 +45,6 @@ export function createBranch(requestedBranch, ctx, run) {
     execFileSync("git", ["worktree", "add", "-b", finalBranch, worktreePath], {
         stdio: stdioFor(run),
     });
-    console.log(`Branch: ${finalBranch}`);
     return { ...ctx, currentWorktree: worktreePath, isMainWorktree: false };
 }
 export function verifyBranchAbsentFromRemote(branch, run) {
@@ -73,20 +63,29 @@ export function getCurrentBranch(worktreePath) {
         cwd: worktreePath,
     }).trim();
 }
-export function enforceWorktreeMode(args, ctx) {
-    if (args.use || args.create) {
-        if (!ctx.isMainWorktree) {
-            console.error("Error: --use and --create must be run from the main worktree.");
-            process.exit(1);
-        }
+export function removeWorktree(worktreePath, run) {
+    execFileSync("git", ["worktree", "remove", "--force", worktreePath], { stdio: stdioFor(run) });
+}
+export function computeWorktreePath(mainWorktree, branch) {
+    const repoName = basename(mainWorktree);
+    const sanitized = branch.replaceAll("/", "-");
+    return join(dirname(mainWorktree), `${repoName}-${sanitized}`);
+}
+function branchExists(branch) {
+    try {
+        execFileSync("git", ["rev-parse", "--verify", branch], { stdio: "pipe" });
+        return true;
     }
-    else if (args.here) {
-        if (ctx.isMainWorktree) {
-            console.error("Error: --here must be run from a linked worktree, not from the main worktree.");
-            process.exit(1);
+    catch {
+        try {
+            execFileSync("git", ["rev-parse", "--verify", `origin/${branch}`], { stdio: "pipe" });
+            return true;
+        }
+        catch {
+            return false;
         }
     }
 }
-export function removeWorktree(worktreePath, run) {
-    execFileSync("git", ["worktree", "remove", "--force", worktreePath], { stdio: stdioFor(run) });
+function stdioFor(ctx) {
+    return ctx.verbose ? "inherit" : "pipe";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paleo/worktree-env",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Worktree-based concurrent local environment kernel.",
   "keywords": [
     "worktree",