@solaqua/gji 0.13.0 → 0.15.0

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/shared/concurrency.d.ts

@@ -1 +1 @@
-export declare function mapWithConcurrency<Input, Output>(items: readonly Input[], limit: number, mapper: (item: Input) => Promise<Output>): Promise<Output[]>;
+export declare function mapWithConcurrency<Input, Output>(items: readonly Input[], limit: number, mapper: (item: Input) => Promise<Output>, signal?: AbortSignal): Promise<Output[]>;

package/dist/domain/shared/concurrency.js

@@ -1,8 +1,9 @@
-export async function mapWithConcurrency(items, limit, mapper) {
+export async function mapWithConcurrency(items, limit, mapper, signal) {
     const results = new Array(items.length);
     let nextIndex = 0;
     async function readNext() {
         for (;;) {
+            throwIfAborted(signal);
             const index = nextIndex;
             nextIndex += 1;
             if (index >= items.length)
@@ -13,3 +14,7 @@ export async function mapWithConcurrency(items, limit, mapper) {
     await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => readNext()));
     return results;
 }
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new Error("Operation cancelled");
+}

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("~/"))