@paleo/workspace 0.17.0 → 0.19.0

package/dist/cli.d.ts

@@ -2,6 +2,7 @@ export type WorkspaceCommand = {
     kind: "setup";
     branch?: string;
     newBranch: boolean;
+    from?: string;
     owner?: string;
     slot?: string;
     force: boolean;
@@ -9,7 +10,7 @@ export type WorkspaceCommand = {
 } | {
     kind: "remove";
     branch?: string;
-    noRemoteCheck: boolean;
+    force: boolean;
 } | {
     kind: "list";
 } | {

package/dist/cli.js

@@ -43,6 +43,7 @@ function parseSetup(tokens) {
         args: tokens,
         options: {
             "new-branch": { type: "boolean", short: "c" },
+            from: { type: "string" },
             owner: { type: "string" },
             slot: { type: "string", short: "s" },
             force: { type: "boolean" },
@@ -57,11 +58,15 @@ function parseSetup(tokens) {
     if (newBranch && branch === undefined) {
         throw new ConfigError("`workspace setup <branch> -c` requires a branch name.");
     }
+    if (values.from !== undefined && !newBranch) {
+        throw new ConfigError("`--from` requires `-c`/`--new-branch`.");
+    }
     return {
         command: {
             kind: "setup",
             branch,
             newBranch,
+            from: values.from,
             owner: values.owner,
             slot: values.slot,
             force: values.force ?? false,
@@ -74,7 +79,7 @@ function parseRemove(tokens) {
     const { values, positionals } = parseArgs({
         args: tokens,
         options: {
-            "no-remote-check": { type: "boolean" },
+            force: { type: "boolean" },
             verbose: { type: "boolean", short: "v" },
         },
         allowPositionals: true,
@@ -82,7 +87,7 @@ function parseRemove(tokens) {
     });
     const branch = takeOptionalPositional(positionals, "remove");
     return {
-        command: { kind: "remove", branch, noRemoteCheck: values["no-remote-check"] ?? false },
+        command: { kind: "remove", branch, force: values.force ?? false },
         verbose: values.verbose ?? false,
     };
 }
@@ -176,13 +181,15 @@ export function printWorkspaceHelp() {
         "Manage workspaces: a git worktree plus its own dev setup (ports, config, database, dev server).",
         "",
         "Commands:",
-        "  setup [<branch>] [-c|--new-branch] [--owner <name>] [-s|--slot <port>] [--force] [--wait]",
+        "  setup [<branch>] [-c|--new-branch] [--from <ref>] [--owner <name>] [-s|--slot <port>] [--force] [--wait]",
         "      Set up the workspace. With <branch>, create a sibling worktree for it",
         "      (add -c to create the branch first). Without, set up the current worktree",
         "      (idempotent; bootstrap and retry path).",
+        "      With -c, the new branch starts at the current worktree's HEAD, or at <ref> with --from.",
         "      Finalize runs in the background; add --wait to block until it reaches READY.",
-        "  remove [<branch>] [--no-remote-check]",
+        "  remove [<branch>] [--force]",
         "      Remove a workspace by branch, or the current one when omitted.",
+        "      Refuses on uncommitted changes unless --force.",
         "  list",
         "      List all registered workspaces (slot, status, branch, path, owner, created).",
         "  status [-s|--slot <port>]",

package/dist/slots.d.ts

@@ -1,5 +1,5 @@
 import { type PortScheme } from "./ports.js";
-export declare const REGISTRY_SUBDIR = "shared-registry";
+export declare const REGISTRY_SUBDIR = "workspace-registry";
 export declare function registryDirFor(runtimeDir: string): string;
 /** `registryDir` is gone from the config types but may linger in a consumer's config file. */
 export declare function warnLegacyRegistryDir(config: {

package/dist/slots.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { allPorts, isValidPort } from "./ports.js";
 import { getWorktreeBranch } from "./worktree.js";
-export const REGISTRY_SUBDIR = "shared-registry";
+export const REGISTRY_SUBDIR = "workspace-registry";
 const SLOTS_FILENAME = "slots.json";
 export function registryDirFor(runtimeDir) {
     return join(runtimeDir, REGISTRY_SUBDIR);

package/dist/workspace.js

@@ -8,7 +8,7 @@ import { copyAndPatchFile, formatDuration, setupLogPath, } from "./helpers.js";
 import { isProcessAlive } from "./process-control.js";
 import { defaultComputePorts, isValidPort, resolvePortScheme } from "./ports.js";
 import { handleSetOwner, markSlotFailed, markSlotReady, mergeSlots, readSlots, REGISTRY_SUBDIR, registryDirFor, resolveAndRegisterSlot, resolveCurrentSlot, validateSlotAvailability, warnLegacyRegistryDir, writeSlots, } from "./slots.js";
-import { createBranch, detectWorktree, enforceWorktreeMode, getWorktreeBranch, removeWorktree, useExistingBranch, verifyBranchAbsentFromRemote, } from "./worktree.js";
+import { createBranch, detectWorktree, getWorktreeBranch, isWorktreeDirty, removeWorktree, useExistingBranch, } from "./worktree.js";
 export async function runWorkspace(config) {
     let command;
     let verbose;
@@ -53,7 +53,6 @@ export async function runWorkspace(config) {
             return;
     }
     const ctx = detectWorktree();
-    enforceWorktreeMode(command, ctx);
     const run = { verbose };
     switch (command.kind) {
         case "remove":
@@ -123,7 +122,7 @@ async function runSetup(command, ctx, run, config, registryDir) {
         });
     }
     linkSharedDirectories(setupCtx, config.sharedDirs, verboseLog);
-    linkSharedRegistry(setupCtx, config.runtimeDir, verboseLog);
+    linkWorkspaceRegistry(setupCtx, config.runtimeDir, verboseLog);
     generateConfigFiles(setupCtx, config.configFiles, slot, ports, command.force, verboseLog);
     teeLog(config.printSummary({
         slot,
@@ -390,9 +389,6 @@ async function handleRemove(command, ctx, run, config, registryDir) {
             `Run 'workspace wait --slot ${target.slotPort}' to wait for it to finish (or fail), then retry the removal.`);
         process.exit(1);
     }
-    if (!command.noRemoteCheck) {
-        verifyBranchAbsentFromRemote(target.branch, run);
-    }
     const ownerSuffix = target.owner ? `, owner ${target.owner}` : "";
     if (!existsSync(target.worktreePath)) {
         console.warn(`Warning: Worktree directory ${target.worktreePath} not found. Cleaning up registry only.`);
@@ -401,6 +397,10 @@ async function handleRemove(command, ctx, run, config, registryDir) {
         console.log(`Removed registry entry for branch "${target.branch}" (slot ${target.slotPort}${ownerSuffix}).`);
         return;
     }
+    if (!command.force && isWorktreeDirty(target.worktreePath)) {
+        console.error(`Error: Uncommitted changes in ${target.worktreePath}. Commit or stash them, or pass --force.`);
+        process.exit(1);
+    }
     const targetEntry = findOwnEntry(ctx.mainWorktree, registryDir, target.worktreePath);
     if (targetEntry) {
         stopTargetDevServer(config.devServerScript, target.worktreePath, verboseLog);
@@ -459,7 +459,7 @@ function handleSetOwnerMode(command, ctx, registryDir) {
     }
     console.log(`Owner for slot ${slotPort}: ${newOwner ?? "(none)"}`);
 }
-/** Transitional (0.16 only): merge a pre-0.16 registry into `${runtimeDir}/shared-registry`. */
+/** Transitional (0.16 only): merge a pre-0.16 registry into `${runtimeDir}/workspace-registry`. */
 function handleMigrate(command, config, newRel) {
     const ctx = detectWorktree();
     const oldRel = command.oldRegistryDir;
@@ -504,7 +504,7 @@ function relinkWorktrees(slots, mainWorktree, runtimeDir) {
             console.warn(`Warning: worktree ${entry.worktree} not found; skipping symlink.`);
             continue;
         }
-        linkSharedRegistry({ currentWorktree: entry.worktree, mainWorktree, isMainWorktree: false }, runtimeDir, console.log, { force: true });
+        linkWorkspaceRegistry({ currentWorktree: entry.worktree, mainWorktree, isMainWorktree: false }, runtimeDir, console.log, { force: true });
         ++count;
     }
     return count;
@@ -513,7 +513,7 @@ function ensureWorktree(command, ctx, run, dirNameFn) {
     if (command.branch === undefined)
         return ctx;
     if (command.newBranch)
-        return createBranch(command.branch, ctx, run, dirNameFn);
+        return createBranch(command.branch, ctx, run, dirNameFn, command.from);
     return useExistingBranch(command.branch, ctx, run, dirNameFn);
 }
 function linkSharedDirectories(ctx, dirs, log) {
@@ -534,11 +534,11 @@ function linkSharedDirectories(ctx, dirs, log) {
     }
 }
 /**
- * Symlinks the linked worktree's `${runtimeDir}/shared-registry` to the main worktree's, so the
+ * Symlinks the linked worktree's `${runtimeDir}/workspace-registry` to the main worktree's, so the
  * cwd-relative registry read in `resolveCurrentSlot` reaches main. `runtimeDir` is per-worktree and
  * not in `sharedDirs`, so this is distinct from {@link linkSharedDirectories}.
  */
-function linkSharedRegistry(ctx, runtimeDir, log, opts) {
+function linkWorkspaceRegistry(ctx, runtimeDir, log, opts) {
     if (ctx.isMainWorktree)
         return;
     const mainDir = join(ctx.mainWorktree, runtimeDir, REGISTRY_SUBDIR);
@@ -551,17 +551,17 @@ function linkSharedRegistry(ctx, runtimeDir, log, opts) {
     const linkStat = lstatSync(link, { throwIfNoEntry: false });
     if (linkStat) {
         if (!linkStat.isSymbolicLink()) {
-            log("Skipped shared-registry symlink (a real directory exists here).");
+            log("Skipped workspace-registry symlink (a real directory exists here).");
             return;
         }
         if (!opts?.force && existsSync(link)) {
-            log("Skipped shared-registry symlink (already exists).");
+            log("Skipped workspace-registry symlink (already exists).");
             return;
         }
         rmSync(link);
     }
     symlinkSync(relative(runtimeRoot, mainDir), link);
-    log("Created shared-registry symlink → main worktree.");
+    log("Created workspace-registry symlink → main worktree.");
 }
 function generateConfigFiles(ctx, entries, slot, ports, force, log) {
     for (const entry of entries) {

package/dist/worktree.d.ts

@@ -1,4 +1,3 @@
-import type { WorkspaceCommand } from "./cli.js";
 export interface WorktreeContext {
     currentWorktree: string;
     mainWorktree: string;
@@ -8,10 +7,9 @@ export interface RunCtx {
     verbose: boolean;
 }
 export declare function detectWorktree(): WorktreeContext;
-export declare function enforceWorktreeMode(command: WorkspaceCommand, ctx: WorktreeContext): void;
 export declare function useExistingBranch(branch: string, ctx: WorktreeContext, run: RunCtx, dirNameFn?: WorktreeDirNameFn): WorktreeContext;
-export declare function createBranch(requestedBranch: string, ctx: WorktreeContext, run: RunCtx, dirNameFn?: WorktreeDirNameFn): WorktreeContext;
-export declare function verifyBranchAbsentFromRemote(branch: string, run: RunCtx): void;
+export declare function createBranch(requestedBranch: string, ctx: WorktreeContext, run: RunCtx, dirNameFn?: WorktreeDirNameFn, from?: string): WorktreeContext;
+export declare function isWorktreeDirty(worktreePath: string): boolean;
 export declare function getWorktreeBranch(worktreePath: string): string | undefined;
 export declare function removeWorktree(worktreePath: string, run: RunCtx): void;
 /** Pure function that produces the basename of a worktree directory from a branch. */

package/dist/worktree.js

@@ -10,14 +10,6 @@ export function detectWorktree() {
     const isMainWorktree = resolve(currentWorktree) === resolve(mainWorktree);
     return { currentWorktree, mainWorktree, isMainWorktree };
 }
-export function enforceWorktreeMode(command, ctx) {
-    // Adding a worktree for a branch must happen from the main worktree. A branch-less
-    // `workspace setup` runs anywhere: linked worktree (retry path) or main (initial bootstrap).
-    if (command.kind === "setup" && command.branch !== undefined && !ctx.isMainWorktree) {
-        console.error("Error: Adding a workspace for a branch must be run from the main worktree.");
-        process.exit(1);
-    }
-}
 export function useExistingBranch(branch, ctx, run, dirNameFn = defaultWorktreeDirName) {
     if (!branchExists(branch)) {
         console.error(`Error: Branch "${branch}" does not exist locally or on the remote.`);
@@ -27,7 +19,9 @@ export function useExistingBranch(branch, ctx, run, dirNameFn = defaultWorktreeD
     execFileSync("git", ["worktree", "add", worktreePath, branch], { stdio: stdioFor(run) });
     return { ...ctx, currentWorktree: worktreePath, isMainWorktree: false };
 }
-export function createBranch(requestedBranch, ctx, run, dirNameFn = defaultWorktreeDirName) {
+export function createBranch(requestedBranch, ctx, run, dirNameFn = defaultWorktreeDirName, from) {
+    if (from !== undefined)
+        verifyFromRef(from);
     let finalBranch = requestedBranch;
     if (branchExists(finalBranch)) {
         let suffix = 2;
@@ -38,18 +32,36 @@ export function createBranch(requestedBranch, ctx, run, dirNameFn = defaultWorkt
         console.warn(`Warning: Branch "${requestedBranch}" already exists; using "${finalBranch}" instead.`);
     }
     const worktreePath = dedupeWorktreePath(computeWorktreePath(ctx.mainWorktree, finalBranch, dirNameFn));
-    execFileSync("git", ["worktree", "add", "-b", finalBranch, worktreePath], {
-        stdio: stdioFor(run),
-    });
+    const addArgs = ["worktree", "add", "-b", finalBranch, "--end-of-options", worktreePath];
+    if (from !== undefined)
+        addArgs.push(from);
+    execFileSync("git", addArgs, { stdio: stdioFor(run) });
     return { ...ctx, currentWorktree: worktreePath, isMainWorktree: false };
 }
-export function verifyBranchAbsentFromRemote(branch, run) {
-    execFileSync("git", ["fetch"], { stdio: stdioFor(run) });
-    const remoteBranches = execFileSync("git", ["branch", "-r", "--list", `origin/${branch}`], {
-        encoding: "utf-8",
-    }).trim();
-    if (remoteBranches.length > 0) {
-        console.error(`Error: Branch "${branch}" still exists on the remote. Use --no-remote-check to skip this verification.`);
+function verifyFromRef(from) {
+    try {
+        // `^{commit}` accepts any commit-ish: branch, origin/x, tag, SHA.
+        // `--end-of-options` guards against option-like refs (rev-parse treats args after `--` as paths).
+        execFileSync("git", ["rev-parse", "--verify", "--end-of-options", `${from}^{commit}`], {
+            stdio: "pipe",
+        });
+    }
+    catch {
+        console.error(`Error: --from ref "${from}" does not resolve to a commit.`);
+        process.exit(1);
+    }
+}
+export function isWorktreeDirty(worktreePath) {
+    try {
+        const out = execFileSync("git", ["status", "--porcelain"], {
+            stdio: "pipe",
+            cwd: worktreePath,
+            encoding: "utf-8",
+        });
+        return out.trim().length > 0;
+    }
+    catch {
+        console.error(`Error: Cannot check for uncommitted changes in ${worktreePath}. Pass --force to remove anyway.`);
         process.exit(1);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paleo/workspace",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Run multiple git-worktree dev environments side by side.",
   "keywords": [
     "workspace",