@solaqua/gji 0.8.0 → 0.9.0

package/dist/pull-requests.js

@@ -0,0 +1,384 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const PULL_REQUEST_QUERY_TIMEOUT_MS = 2500;
+export function parsePullRequestRemote(remoteUrl) {
+    const parsed = parseRemoteUrl(remoteUrl.trim());
+    if (parsed === null)
+        return null;
+    const forge = detectForge(parsed.host);
+    if (forge === null)
+        return null;
+    if (forge === "bitbucket" && parsed.host !== "bitbucket.org")
+        return null;
+    const path = parsed.path
+        .replace(/^\/+/, "")
+        .replace(/\.git$/, "")
+        .split("/")
+        .filter(Boolean);
+    if (path.length < 2)
+        return null;
+    if (forge === "gitlab") {
+        const repository = path.at(-1);
+        const namespace = path.slice(0, -1).join("/");
+        if (repository === undefined || namespace.length === 0)
+            return null;
+        return {
+            forge,
+            host: parsed.host,
+            namespace,
+            repository,
+            webBaseUrl: `https://${parsed.host}`,
+        };
+    }
+    const namespace = path.at(-2);
+    const repository = path.at(-1);
+    if (namespace === undefined || repository === undefined)
+        return null;
+    return {
+        forge,
+        host: parsed.host,
+        namespace,
+        repository,
+        webBaseUrl: `https://${parsed.host}`,
+    };
+}
+export function createPullRequestQuery(dependencies = {}) {
+    const runCommand = dependencies.runCommand ?? defaultRunCommand;
+    const fetcher = dependencies.fetch ?? fetch;
+    return {
+        findOpenPullRequest: (repoRoot, number) => findOpenPullRequest(repoRoot, number, runCommand, fetcher),
+        listOpenPullRequests: (repoRoot, sourceBranch) => listOpenPullRequests(repoRoot, sourceBranch, runCommand, fetcher),
+        listOpenPullRequestsForRepository: (repoRoot) => listOpenPullRequestsForRepository(repoRoot, runCommand, fetcher),
+    };
+}
+async function listOpenPullRequests(repoRoot, sourceBranch, runCommand, fetcher) {
+    const remote = await readPullRequestRemote(repoRoot, runCommand);
+    const cliResult = await queryProviderCli(remote, { kind: "branch", sourceBranch }, repoRoot, runCommand);
+    if (cliResult !== null)
+        return sortPullRequests(cliResult);
+    const apiResult = await queryPublicApi(remote, { kind: "branch", sourceBranch }, fetcher);
+    return sortPullRequests(apiResult);
+}
+async function listOpenPullRequestsForRepository(repoRoot, runCommand, fetcher) {
+    const remote = await readPullRequestRemote(repoRoot, runCommand);
+    const cliResult = await queryProviderCli(remote, { kind: "repository" }, repoRoot, runCommand);
+    if (cliResult !== null)
+        return sortPullRequests(cliResult);
+    const apiResult = await queryPublicApi(remote, { kind: "repository" }, fetcher);
+    return sortPullRequests(apiResult);
+}
+async function findOpenPullRequest(repoRoot, number, runCommand, fetcher) {
+    const remote = await readPullRequestRemote(repoRoot, runCommand);
+    const cliResult = await queryProviderCli(remote, { kind: "number", number }, repoRoot, runCommand);
+    if (cliResult !== null)
+        return cliResult[0] ?? null;
+    const apiResult = await queryPublicApi(remote, { kind: "number", number }, fetcher);
+    return apiResult[0] ?? null;
+}
+async function readPullRequestRemote(repoRoot, runCommand) {
+    const result = await runCommand("git", ["remote", "get-url", "origin"], commandOptions(repoRoot));
+    const remote = parsePullRequestRemote(result.stdout);
+    if (remote === null) {
+        throw new Error("origin remote is unsupported or missing");
+    }
+    return remote;
+}
+async function queryProviderCli(remote, query, repoRoot, runCommand) {
+    const providerCommand = providerCliCommand(remote, query);
+    try {
+        const result = await runCommand(providerCommand.command, providerCommand.args, commandOptions(repoRoot));
+        return parseProviderOutput(remote, result.stdout, query);
+    }
+    catch {
+        // Missing CLIs, unauthenticated CLIs, and CLI/network failures all use the public API fallback.
+        return null;
+    }
+}
+async function queryPublicApi(remote, query, fetcher) {
+    const url = publicApiUrl(remote, query);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PULL_REQUEST_QUERY_TIMEOUT_MS);
+    try {
+        const response = await fetcher(url, {
+            headers: { Accept: "application/json" },
+            signal: controller.signal,
+        });
+        if (response.status === 404 && query.kind === "number")
+            return [];
+        if (!response.ok) {
+            throw new Error(`public API returned HTTP ${response.status}`);
+        }
+        const payload = await response.json();
+        return parseApiOutput(remote, payload, query);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function parseRemoteUrl(remoteUrl) {
+    const scpMatch = remoteUrl.match(/^[^@]+@([^:]+):(.+)$/);
+    if (scpMatch) {
+        return { host: scpMatch[1].toLowerCase(), path: scpMatch[2] };
+    }
+    try {
+        const url = new URL(remoteUrl);
+        if (!url.hostname)
+            return null;
+        return { host: url.hostname.toLowerCase(), path: url.pathname };
+    }
+    catch {
+        return null;
+    }
+}
+function detectForge(host) {
+    if (host === "github.com" || host.includes("github"))
+        return "github";
+    if (host === "gitlab.com" || host.includes("gitlab"))
+        return "gitlab";
+    if (host === "bitbucket.org" || host.includes("bitbucket")) {
+        return "bitbucket";
+    }
+    return null;
+}
+function providerCliCommand(remote, query) {
+    const coordinate = providerRepositoryCoordinate(remote);
+    const sourceBranch = query.sourceBranch ?? "";
+    switch (remote.forge) {
+        case "github": {
+            if (query.kind === "number") {
+                return {
+                    args: [
+                        "pr",
+                        "view",
+                        String(query.number),
+                        "--json",
+                        "number,url,headRefName,state",
+                        "--repo",
+                        coordinate,
+                    ],
+                    command: "gh",
+                };
+            }
+            return {
+                args: [
+                    "pr",
+                    "list",
+                    "--state",
+                    "open",
+                    ...(query.kind === "branch" ? ["--head", sourceBranch] : []),
+                    "--json",
+                    "number,url,headRefName,state",
+                    "--limit",
+                    "100",
+                    "--repo",
+                    coordinate,
+                ],
+                command: "gh",
+            };
+        }
+        case "gitlab": {
+            if (query.kind === "number") {
+                return {
+                    args: [
+                        "mr",
+                        "view",
+                        String(query.number),
+                        "--output",
+                        "json",
+                        "--repo",
+                        coordinate,
+                    ],
+                    command: "glab",
+                };
+            }
+            return {
+                args: [
+                    "mr",
+                    "list",
+                    "--state",
+                    "opened",
+                    ...(query.kind === "branch" ? ["--source-branch", sourceBranch] : []),
+                    "--output",
+                    "json",
+                    "--per-page",
+                    "100",
+                    "--repo",
+                    coordinate,
+                ],
+                command: "glab",
+            };
+        }
+        case "bitbucket": {
+            if (query.kind === "number") {
+                return {
+                    args: [
+                        "pr",
+                        "view",
+                        String(query.number),
+                        "--format",
+                        "json",
+                        "--repo",
+                        coordinate,
+                    ],
+                    command: "bb",
+                };
+            }
+            return {
+                args: [
+                    "pr",
+                    "list",
+                    "--state",
+                    "OPEN",
+                    ...(query.kind === "branch" ? ["--source", sourceBranch] : []),
+                    "--format",
+                    "json",
+                    "--repo",
+                    coordinate,
+                ],
+                command: "bb",
+            };
+        }
+    }
+}
+function providerRepositoryCoordinate(remote) {
+    const coordinate = `${remote.namespace}/${remote.repository}`;
+    return remote.host === "github.com" || remote.host === "bitbucket.org"
+        ? coordinate
+        : `${remote.host}/${coordinate}`;
+}
+function parseProviderOutput(remote, stdout, query) {
+    const payload = JSON.parse(stdout);
+    const values = remote.forge === "bitbucket" && isRecord(payload)
+        ? Array.isArray(payload.values)
+            ? payload.values
+            : []
+        : Array.isArray(payload)
+            ? payload
+            : [payload];
+    return values
+        .map((value) => normalizePullRequest(value, query))
+        .filter((value) => value !== null)
+        .filter((value) => query.kind === "branch"
+        ? value.sourceBranch === query.sourceBranch
+        : query.kind === "number"
+            ? value.number === query.number
+            : true);
+}
+function parseApiOutput(remote, payload, query) {
+    const values = remote.forge === "bitbucket" && isRecord(payload)
+        ? Array.isArray(payload.values)
+            ? payload.values
+            : []
+        : query.kind === "number"
+            ? [payload]
+            : Array.isArray(payload)
+                ? payload
+                : [];
+    return values
+        .map((value) => normalizePullRequest(value, query))
+        .filter((value) => value !== null)
+        .filter((value) => query.kind === "branch"
+        ? value.sourceBranch === query.sourceBranch
+        : query.kind === "number"
+            ? value.number === query.number
+            : true);
+}
+function normalizePullRequest(value, query) {
+    if (!isRecord(value))
+        return null;
+    const number = numberValue(value.number ?? value.iid ?? value.id);
+    const head = isRecord(value.head) ? value.head : null;
+    const source = isRecord(value.source) ? value.source : null;
+    const sourceBranch = stringValue(value.headRefName ??
+        (head !== null ? head.ref : undefined) ??
+        value.source_branch ??
+        (source !== null && isRecord(source.branch)
+            ? source.branch.name
+            : undefined));
+    const url = stringValue(value.html_url ??
+        value.web_url ??
+        value.url ??
+        (isRecord(value.links) && isRecord(value.links.html)
+            ? value.links.html.href
+            : undefined));
+    const state = stringValue(value.state)?.toLowerCase();
+    if (number === null || url === null)
+        return null;
+    if (query.kind !== "number" && sourceBranch === null)
+        return null;
+    if (query.kind === "number" && number !== query.number)
+        return null;
+    if (state !== undefined && !["open", "opened"].includes(state))
+        return null;
+    return {
+        number,
+        sourceBranch: sourceBranch ?? "",
+        url,
+    };
+}
+function publicApiUrl(remote, query) {
+    const branch = encodeURIComponent(query.sourceBranch ?? "");
+    const number = query.number === undefined ? "" : String(query.number);
+    switch (remote.forge) {
+        case "github": {
+            const coordinate = `${encodeURIComponent(remote.namespace)}/${encodeURIComponent(remote.repository)}`;
+            const apiBase = remote.host === "github.com"
+                ? "https://api.github.com"
+                : `https://${remote.host}/api/v3`;
+            if (query.kind === "number") {
+                return `${apiBase}/repos/${coordinate}/pulls/${number}`;
+            }
+            return `${apiBase}/repos/${coordinate}/pulls?state=open&per_page=100`;
+        }
+        case "gitlab": {
+            const project = encodeURIComponent(`${remote.namespace}/${remote.repository}`);
+            if (query.kind === "number") {
+                return `${remote.webBaseUrl}/api/v4/projects/${project}/merge_requests/${number}`;
+            }
+            return query.kind === "branch"
+                ? `${remote.webBaseUrl}/api/v4/projects/${project}/merge_requests?state=opened&source_branch=${branch}&per_page=100`
+                : `${remote.webBaseUrl}/api/v4/projects/${project}/merge_requests?state=opened&per_page=100`;
+        }
+        case "bitbucket": {
+            const coordinate = `${encodeURIComponent(remote.namespace)}/${encodeURIComponent(remote.repository)}`;
+            if (query.kind === "number") {
+                return `https://api.bitbucket.org/2.0/repositories/${coordinate}/pullrequests/${number}`;
+            }
+            return query.kind === "branch"
+                ? `https://api.bitbucket.org/2.0/repositories/${coordinate}/pullrequests?state=OPEN&source.branch.name=${branch}&pagelen=100`
+                : `https://api.bitbucket.org/2.0/repositories/${coordinate}/pullrequests?state=OPEN&pagelen=100`;
+        }
+    }
+}
+function sortPullRequests(pullRequests) {
+    return [...pullRequests].sort((a, b) => a.number - b.number);
+}
+function commandOptions(cwd) {
+    return {
+        cwd,
+        env: {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: "0",
+            GH_PROMPT_DISABLED: "1",
+            GLAB_NON_INTERACTIVE: "1",
+        },
+        timeout: PULL_REQUEST_QUERY_TIMEOUT_MS,
+    };
+}
+async function defaultRunCommand(command, args, options) {
+    return execFileAsync(command, args, options);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function numberValue(value) {
+    if (typeof value === "number" && Number.isInteger(value))
+        return value;
+    if (typeof value === "string" && /^\d+$/.test(value))
+        return Number(value);
+    return null;
+}

package/dist/remove.js

@@ -4,7 +4,7 @@ import { loadEffectiveConfig } from "./config.js";
 import { isHeadless } from "./headless.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { writeShellOutput } from "./shell-handoff.js";
-import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeDirtyError, loadLinkedWorktrees, removeWorktree, } from "./worktree-management.js";
+import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeForceRemovalError, loadLinkedWorktrees, removeWorktree, } from "./worktree-management.js";
 import { buildWorktreePromptEntries, promptForSingleWorktree, } from "./worktree-picker.js";
 import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "./worktree-prompts.js";
 const REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
@@ -83,7 +83,7 @@ export function createRemoveCommand(dependencies = {}) {
             await removeWorktree(repository.repoRoot, worktree.path);
         }
         catch (error) {
-            if (!isWorktreeDirtyError(error)) {
+            if (!isWorktreeForceRemovalError(error)) {
                 throw error;
             }
             if (!options.force &&

package/dist/repo-registry.d.ts

@@ -3,6 +3,11 @@ export interface RepoRegistryEntry {
     name: string;
     path: string;
 }
+export interface RegistryRemovalResult {
+    removedPaths: string[];
+    skippedPaths: string[];
+}
 export declare function REGISTRY_FILE_PATH(home?: string): string;
 export declare function loadRegistry(home?: string): Promise<RepoRegistryEntry[]>;
 export declare function registerRepo(repoPath: string, home?: string): Promise<void>;
+export declare function removeMissingRegistryEntries(paths: ReadonlySet<string>, home?: string): Promise<RegistryRemovalResult>;

package/dist/repo-registry.js

@@ -1,9 +1,12 @@
-import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, realpath, rename, rm, writeFile, } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { GLOBAL_CONFIG_DIRECTORY } from "./config.js";
 const REGISTRY_FILE_NAME = "repos.json";
 const MAX_REGISTRY_ENTRIES = 100;
+const registryLocks = new Map();
 export function REGISTRY_FILE_PATH(home = homedir()) {
     const configDir = process.env.GJI_CONFIG_DIR;
     if (configDir) {
@@ -34,20 +37,90 @@ async function canonicalizeRepoPath(repoPath) {
 }
 export async function registerRepo(repoPath, home = homedir()) {
     const registryPath = REGISTRY_FILE_PATH(home);
-    const existing = await normalizeRegistryForWrite(await loadRegistry(home));
-    const canonicalRepoPath = await canonicalizeRepoPath(repoPath);
-    // Skip write if this repo is already the most-recently-used entry (common case).
-    if (existing.length > 0 && existing[0].path === canonicalRepoPath)
-        return;
-    const entry = {
-        lastUsed: Date.now(),
-        name: basename(canonicalRepoPath),
-        path: canonicalRepoPath,
-    };
-    const filtered = existing.filter((e) => e.path !== canonicalRepoPath);
-    const next = [entry, ...filtered].slice(0, MAX_REGISTRY_ENTRIES);
+    await withRegistryLock(registryPath, async () => {
+        const existing = await normalizeRegistryForWrite(await loadRegistry(home));
+        const canonicalRepoPath = await canonicalizeRepoPath(repoPath);
+        // Skip write if this repo is already the most-recently-used entry (common case).
+        if (existing.length > 0 && existing[0].path === canonicalRepoPath)
+            return;
+        const entry = {
+            lastUsed: Date.now(),
+            name: basename(canonicalRepoPath),
+            path: canonicalRepoPath,
+        };
+        const filtered = existing.filter((e) => e.path !== canonicalRepoPath);
+        const next = [entry, ...filtered].slice(0, MAX_REGISTRY_ENTRIES);
+        await writeRegistry(next, registryPath);
+    });
+}
+export async function removeMissingRegistryEntries(paths, home = homedir()) {
+    if (paths.size === 0)
+        return { removedPaths: [], skippedPaths: [] };
+    const registryPath = REGISTRY_FILE_PATH(home);
+    return withRegistryLock(registryPath, async () => {
+        const entries = await loadRegistry(home);
+        const candidates = entries.filter((entry) => paths.has(entry.path));
+        const status = await Promise.all(candidates.map(async (entry) => ({
+            entry,
+            missing: await isMissingPath(entry.path),
+        })));
+        const removedPaths = status
+            .filter(({ missing }) => missing)
+            .map(({ entry }) => entry.path);
+        const skippedPaths = status
+            .filter(({ missing }) => !missing)
+            .map(({ entry }) => entry.path);
+        if (removedPaths.length > 0) {
+            await writeRegistry(entries.filter((entry) => !removedPaths.includes(entry.path)), registryPath);
+        }
+        return { removedPaths, skippedPaths };
+    });
+}
+async function withRegistryLock(registryPath, operation) {
+    const previous = registryLocks.get(registryPath);
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    registryLocks.set(registryPath, current);
+    if (previous)
+        await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (registryLocks.get(registryPath) === current) {
+            registryLocks.delete(registryPath);
+        }
+    }
+}
+async function isMissingPath(path) {
+    try {
+        await access(path, constants.F_OK);
+        return false;
+    }
+    catch (error) {
+        return isMissingPathError(error);
+    }
+}
+function isMissingPathError(error) {
+    if (!(error instanceof Error) || !("code" in error))
+        return false;
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+async function writeRegistry(entries, registryPath) {
     await mkdir(dirname(registryPath), { recursive: true });
-    await writeFile(registryPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    const temporaryPath = `${registryPath}.tmp-${process.pid}-${randomUUID()}`;
+    try {
+        await writeFile(temporaryPath, `${JSON.stringify(entries, null, 2)}\n`, "utf8");
+        await rename(temporaryPath, registryPath);
+    }
+    catch (error) {
+        await rm(temporaryPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
 }
 async function normalizeRegistryForWrite(entries) {
     const normalized = [];