@solaqua/gji 0.12.4 → 0.13.0

package/dist/domain/worktree/matching.js

@@ -0,0 +1,79 @@
+export function resolveWorktreeQuery(sources, query) {
+    return resolveWorktreeQueryMatches(sources, query)[0] ?? null;
+}
+export function resolveWorktreeQueryMatches(sources, query) {
+    const normalizedQuery = normalizeQuery(query);
+    if (normalizedQuery === null)
+        return [];
+    const matches = findWorktreeSourceMatches(sources, normalizedQuery);
+    if (isAmbiguousRepoOnlyQuery(matches, normalizedQuery))
+        return [];
+    const bestScore = matches[0]?.matchScore;
+    return matches
+        .filter((match) => match.matchScore === bestScore)
+        .map((match) => match.source);
+}
+export function resolveExactWorktreeQueryMatches(sources, query) {
+    const normalizedQuery = normalizeQuery(query);
+    if (normalizedQuery === null)
+        return [];
+    return sources.filter((source) => scoreWorktreeMatch({
+        ...source.worktree,
+        repoName: source.repoName,
+    }, normalizedQuery) === 1000);
+}
+function findWorktreeSourceMatches(sources, normalizedQuery) {
+    return sources
+        .flatMap((source) => {
+        const matchScore = scoreWorktreeMatch({
+            ...source.worktree,
+            repoName: source.repoName,
+        }, normalizedQuery);
+        return matchScore === null ? [] : [{ matchScore, source }];
+    })
+        .sort(compareQueryMatches);
+}
+function isAmbiguousRepoOnlyQuery(matches, query) {
+    if (matches[0]?.matchScore === 1000)
+        return false;
+    return (matches.filter((match) => match.source.repoName.toLowerCase() === query)
+        .length > 1);
+}
+function compareQueryMatches(a, b) {
+    if (a.matchScore !== b.matchScore) {
+        return b.matchScore - a.matchScore;
+    }
+    if (a.source.worktree.isCurrent && !b.source.worktree.isCurrent)
+        return -1;
+    if (!a.source.worktree.isCurrent && b.source.worktree.isCurrent)
+        return 1;
+    return (a.source.repoName.localeCompare(b.source.repoName) ||
+        (a.source.worktree.branch ?? "").localeCompare(b.source.worktree.branch ?? "") ||
+        a.source.worktree.path.localeCompare(b.source.worktree.path));
+}
+function normalizeQuery(query) {
+    const normalized = query?.trim().toLowerCase();
+    return normalized && normalized.length > 0 ? normalized : null;
+}
+function scoreWorktreeMatch(entry, query) {
+    const branch = entry.branch ?? "detached";
+    const exactCandidates = [
+        branch,
+        entry.path,
+        `${entry.repoName}/${branch}`,
+    ].map((candidate) => candidate.toLowerCase());
+    if (exactCandidates.includes(query)) {
+        return 1000;
+    }
+    return buildSearchText(entry.repoName, entry).includes(query) ? 1 : null;
+}
+function buildSearchText(repoName, worktree) {
+    return [
+        repoName,
+        worktree.branch ?? "detached",
+        worktree.path,
+        `${repoName}/${worktree.branch ?? "detached"}`,
+    ]
+        .join(" ")
+        .toLowerCase();
+}

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

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

package/dist/domain/worktree/policy.js

@@ -0,0 +1,58 @@
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+export function resolveWorktreePath(repoRoot, branch, basePath) {
+    const segments = branch.split("/").filter(Boolean);
+    if (segments.length === 0) {
+        throw new Error("Branch name must not be empty.");
+    }
+    if (segments.some((segment) => segment === "." || segment === "..")) {
+        throw new Error(`Branch name '${branch}' contains an invalid path segment.`);
+    }
+    const base = basePath
+        ? expandTildeInPath(basePath)
+        : join(dirname(repoRoot), "worktrees", basename(repoRoot));
+    return join(base, ...segments);
+}
+export function validateBranchName(name) {
+    if (name.length === 0) {
+        return "Branch name must not be empty.";
+    }
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional control chars to reject in git branch names
+    if (/[\x00-\x1f\x7f ~^:?*[\\\s]/.test(name)) {
+        return `Branch name '${name}' contains an invalid character.`;
+    }
+    if (name.startsWith("-")) {
+        return `Branch name '${name}' must not start with a dash.`;
+    }
+    if (name.startsWith("/") || name.endsWith("/") || name.includes("//")) {
+        return `Branch name '${name}' has invalid slash placement.`;
+    }
+    if (name.includes("..")) {
+        return `Branch name '${name}' must not contain '..'.`;
+    }
+    if (name.endsWith(".")) {
+        return `Branch name '${name}' must not end with '.'.`;
+    }
+    if (name.includes("@{")) {
+        return `Branch name '${name}' must not contain '@{'.`;
+    }
+    if (name === "@") {
+        return "Branch name cannot be '@'.";
+    }
+    for (const segment of name.split("/")) {
+        if (segment.startsWith(".")) {
+            return `Branch name '${name}' contains a path component starting with '.'.`;
+        }
+        if (segment.endsWith(".lock")) {
+            return `Branch name '${name}' contains a path component ending with '.lock'.`;
+        }
+    }
+    return null;
+}
+function expandTildeInPath(path) {
+    if (path === "~")
+        return homedir();
+    if (path.startsWith("~/"))
+        return join(homedir(), path.slice(2));
+    return path;
+}

package/dist/domain/worktree/pr-reference.d.ts

@@ -0,0 +1 @@
+export declare function parsePrInput(input: string): string | null;

package/dist/domain/worktree/pr-reference.js

@@ -0,0 +1,9 @@
+export function parsePrInput(input) {
+    if (/^\d+$/.test(input))
+        return input;
+    const hashMatch = input.match(/^#(\d+)$/);
+    if (hashMatch)
+        return hashMatch[1];
+    const urlMatch = input.match(/(?:\/pull|\/pull-requests|\/merge_requests)\/(\d+)/);
+    return urlMatch?.[1] ?? null;
+}

package/dist/{worktree-source.d.ts → domain/worktree/source.d.ts}

@@ -1,4 +1,4 @@
-import type { WorktreeEntry } from "./repo.js";
+import type { WorktreeEntry } from "./types.js";
 export interface WorktreeSource {
     repoRoot?: string;
     repoName: string;

package/dist/domain/worktree/source.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+export interface WorktreeEntry {
+    branch: string | null;
+    isCurrent: boolean;
+    path: string;
+}

package/dist/domain/worktree/types.js

@@ -0,0 +1 @@
+export {};