@solaqua/gji 0.14.0 → 0.15.0

package/dist/cli/commands/clean.d.ts

@@ -7,6 +7,7 @@ export interface CleanCommandOptions {
     dryRun?: boolean;
     force?: boolean;
     json?: boolean;
+    paths?: string[];
     stale?: boolean;
     runtime?: CliRuntime<"git" | "config" | "configStore" | "slots" | "repositoryContext" | "repositoryRegistry" | "worktrees" | "worktreeInfo" | "worktreeLifecycle" | "worktreeCatalog">;
     stderr: (chunk: string) => void;

package/dist/cli/commands/clean.js

@@ -1,7 +1,11 @@
+import { realpath } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
 import { confirm, isCancel } from "@clack/prompts";
 import { loadLinkedWorktrees, } from "../../application/worktree/catalog.js";
 import { deduplicateWorktreeSources, listRegisteredWorktreeSources, } from "../../application/worktree/sources.js";
 import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
+import { createWorktreePathFilter, escapePathPattern, findGlobIndex, unescapePathPattern, } from "../../domain/worktree/path-filter.js";
+import { expandTildeInPath } from "../../domain/worktree/policy.js";
 import { buildWorktreePromptEntries, promptForMultipleWorktrees, } from "../../presentation/worktree/picker.js";
 import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "../../presentation/worktree/prompts.js";
 import { defaultCliDependencies, } from "../dependencies.js";
@@ -35,8 +39,27 @@ export function createCleanCommand(dependencies = {}) {
         const { formatLastCommit, formatUpstreamState, readWorktreeInfos, serializeWorktreeInfo, } = runtime.worktreeInfo;
         const { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeWorktree, } = runtime.worktreeLifecycle;
         const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd, sourceDependencies);
+        const pathPatterns = await canonicalizePathPatterns(options.cwd, options.paths ?? []);
+        const matchesPathFilter = createWorktreePathFilter(pathPatterns);
+        // An explicit path may point at another registered repository, so
+        // --path starts in the all-repositories scope.
+        const searchAllRepositories = pathPatterns.length > 0;
+        let allSourceCount = 0;
+        const emitNoCandidates = (sourceCount) => {
+            if (pathPatterns.length > 0 && sourceCount === 0) {
+                emitError(options, "No linked worktrees match --path");
+                return 1;
+            }
+            if (options.stale) {
+                emitNoStaleCandidates(options);
+                return 0;
+            }
+            emitError(options, "No linked worktrees to clean");
+            return 1;
+        };
         const currentSources = linkedWorktrees
-            .filter((worktree) => worktree.path !== repository.currentRoot)
+            .filter((worktree) => worktree.path !== repository.currentRoot &&
+            matchesPathFilter(worktree.path))
             .map((worktree) => ({
             repoName: repository.repoName,
             repoRoot: repository.repoRoot,
@@ -77,7 +100,9 @@ export function createCleanCommand(dependencies = {}) {
                 ...registered.sources,
             ]).filter((source) => source.repoRoot !== undefined &&
                 source.worktree.path !== source.repoRoot &&
-                source.worktree.path !== repository.currentRoot);
+                source.worktree.path !== repository.currentRoot &&
+                matchesPathFilter(source.worktree.path));
+            allSourceCount = sources.length;
             const otherRepositorySources = sources.filter((source) => source.repoRoot !== repository.repoRoot);
             const otherRepositoryCandidates = await resolveCleanupCandidates({
                 sources: otherRepositorySources,
@@ -110,28 +135,19 @@ export function createCleanCommand(dependencies = {}) {
                 };
             },
         };
-        if (currentCandidates.length === 0 && interactiveSelection) {
+        if (searchAllRepositories ||
+            (interactiveSelection && currentCandidates.length === 0)) {
             const loadedAllCandidates = await loadAllCandidates();
             if (loadedAllCandidates.length === 0) {
-                if (options.stale) {
-                    emitNoStaleCandidates(options);
-                    return 0;
-                }
-                emitError(options, "No linked worktrees to clean");
-                return 1;
+                return emitNoCandidates(allSourceCount);
             }
             currentScope = false;
             activeCandidates = loadedAllCandidates;
             scope.label = "all repositories";
             scope.toggleLabel = "current repository";
         }
-        if (currentCandidates.length === 0 && !interactiveSelection) {
-            if (options.stale) {
-                emitNoStaleCandidates(options);
-                return 0;
-            }
-            emitError(options, "No linked worktrees to clean");
-            return 1;
+        else if (currentCandidates.length === 0) {
+            return emitNoCandidates(currentSources.length);
         }
         if (!options.dryRun && !options.force && (options.json || isHeadless())) {
             const message = "--force is required";
@@ -314,6 +330,29 @@ export function createCleanCommand(dependencies = {}) {
     };
 }
 export const runCleanCommand = createCleanCommand();
+async function canonicalizePathPatterns(cwd, patterns) {
+    return Promise.all(patterns.map((pattern) => canonicalizeLiteralPrefix(resolve(cwd, expandTildeInPath(pattern)))));
+}
+// Git records canonical worktree paths, so resolve symlinks in the pattern's
+// longest existing literal prefix before matching.
+async function canonicalizeLiteralPrefix(pattern) {
+    const globIndex = findGlobIndex(pattern);
+    let prefix = globIndex === -1 ? pattern : dirname(`${pattern.slice(0, globIndex)}x`);
+    let suffix = pattern.slice(prefix.length);
+    for (;;) {
+        try {
+            const canonicalPrefix = escapePathPattern(await realpath(unescapePathPattern(prefix)));
+            return `${canonicalPrefix}${suffix}`.replace(/^\/\//, "/");
+        }
+        catch {
+            const parent = dirname(prefix);
+            if (parent === prefix)
+                return pattern;
+            suffix = join("/", basename(prefix), suffix);
+            prefix = parent;
+        }
+    }
+}
 async function resolveCleanupCandidates(options, dependencies) {
     const { sources, stale, stderr, signal } = options;
     const grouped = new Map();

package/dist/cli/program.js

@@ -295,6 +295,7 @@ function registerCommands(program) {
         .description("interactively prune linked worktrees")
         .option("-f, --force", "bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches")
         .option("--stale", "only target clean worktrees whose upstream is gone and branch is merged into the default branch")
+        .option("--path <pattern>", "only target worktrees under a directory or matching a path glob (repeatable)", collectOption)
         .option("--dry-run", "show what would be deleted without removing anything")
         .option("--json", "emit JSON on success or error instead of human-readable output")
         .action(notImplemented("clean"));
@@ -638,6 +639,7 @@ function attachCommandActions(program, options) {
             dryRun: commandOptions.dryRun,
             force: commandOptions.force,
             json: commandOptions.json,
+            paths: commandOptions.path,
             stale: commandOptions.stale,
             runtime: options.dependencies,
             stderr: options.stderr,
@@ -752,6 +754,9 @@ function requireCommand(parent, name) {
     }
     return command;
 }
+function collectOption(value, previous = []) {
+    return [...previous, value];
+}
 function notImplemented(commandName) {
     return () => {
         throw new Error(`'${commandName}' is not implemented yet.`);

package/dist/domain/worktree/path-filter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Builds a predicate that matches worktree paths against any of the absolute
+ * patterns. A pattern without glob characters matches that directory and
+ * anything inside it. A pattern with `*` (within one segment), `**` (across
+ * segments), or `?` (one character) must match the whole path. A backslash
+ * makes the next character literal, so `\*` and `\?` match themselves. No
+ * patterns match every path.
+ */
+export declare function createWorktreePathFilter(patterns: readonly string[]): (worktreePath: string) => boolean;
+/** Returns the index of the first unescaped glob character, or -1. */
+export declare function findGlobIndex(pattern: string): number;
+export declare function escapePathPattern(path: string): string;
+export declare function unescapePathPattern(pattern: string): string;

package/dist/domain/worktree/path-filter.js

@@ -0,0 +1,72 @@
+/**
+ * Builds a predicate that matches worktree paths against any of the absolute
+ * patterns. A pattern without glob characters matches that directory and
+ * anything inside it. A pattern with `*` (within one segment), `**` (across
+ * segments), or `?` (one character) must match the whole path. A backslash
+ * makes the next character literal, so `\*` and `\?` match themselves. No
+ * patterns match every path.
+ */
+export function createWorktreePathFilter(patterns) {
+    const matchers = patterns.map(createPathMatcher);
+    if (matchers.length === 0)
+        return () => true;
+    return (worktreePath) => matchers.some((matches) => matches(worktreePath));
+}
+/** Returns the index of the first unescaped glob character, or -1. */
+export function findGlobIndex(pattern) {
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === "\\")
+            index += 1;
+        else if (character === "*" || character === "?")
+            return index;
+    }
+    return -1;
+}
+export function escapePathPattern(path) {
+    return path.replace(/[\\*?]/g, "\\$&");
+}
+export function unescapePathPattern(pattern) {
+    return pattern.replace(/\\(.)/g, "$1");
+}
+function createPathMatcher(pattern) {
+    if (findGlobIndex(pattern) !== -1) {
+        const regExp = globToRegExp(pattern);
+        return (path) => regExp.test(path);
+    }
+    const literal = unescapePathPattern(pattern);
+    const prefix = literal === "/" ? "/" : `${literal}/`;
+    return (path) => path === literal || path.startsWith(prefix);
+}
+function globToRegExp(pattern) {
+    let source = "";
+    for (let index = 0; index < pattern.length; index += 1) {
+        let character = pattern[index];
+        if (character === "*") {
+            if (pattern[index + 1] === "*") {
+                index += 1;
+                if (pattern[index + 1] === "/") {
+                    index += 1;
+                    source += "(?:.*/)?";
+                }
+                else {
+                    source += ".*";
+                }
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (character === "?") {
+            source += "[^/]";
+        }
+        else {
+            if (character === "\\" && index + 1 < pattern.length) {
+                index += 1;
+                character = pattern[index];
+            }
+            source += character.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        }
+    }
+    return new RegExp(`^${source}$`);
+}

package/dist/domain/worktree/policy.d.ts

@@ -1,2 +1,3 @@
 export declare function resolveWorktreePath(repoRoot: string, branch: string, basePath?: string): string;
 export declare function validateBranchName(name: string): string | null;
+export declare function expandTildeInPath(path: string): string;

package/dist/domain/worktree/policy.js

@@ -49,7 +49,7 @@ export function validateBranchName(name) {
     }
     return null;
 }
-function expandTildeInPath(path) {
+export function expandTildeInPath(path) {
     if (path === "~")
         return homedir();
     if (path.startsWith("~/"))