@solaqua/gji 0.12.4 → 0.13.0

package/dist/repo.js

@@ -1,161 +0,0 @@
-import { access } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
-import { runGit } from "./git.js";
-export async function detectRepository(cwd) {
-    const currentRoot = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
-    const rawCommonDir = await runGit(cwd, ["rev-parse", "--git-common-dir"]);
-    const gitCommonDir = isAbsolute(rawCommonDir)
-        ? rawCommonDir
-        : resolve(currentRoot, rawCommonDir);
-    const repoRoot = dirname(gitCommonDir);
-    return {
-        currentRoot,
-        gitCommonDir,
-        isWorktree: currentRoot !== repoRoot,
-        repoName: basename(repoRoot),
-        repoRoot,
-    };
-}
-export async function worktreeGitDir(worktreePath) {
-    const rawGitDir = await runGit(worktreePath, ["rev-parse", "--git-dir"]);
-    return isAbsolute(rawGitDir) ? rawGitDir : resolve(worktreePath, rawGitDir);
-}
-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;
-}
-export async function hasLocalBranch(repoRoot, branch) {
-    try {
-        await runGit(repoRoot, [
-            "show-ref",
-            "--verify",
-            "--quiet",
-            `refs/heads/${branch}`,
-        ]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function hasRemoteBranch(repoRoot, remote, branch) {
-    try {
-        await runGit(repoRoot, [
-            "show-ref",
-            "--verify",
-            "--quiet",
-            `refs/remotes/${remote}/${branch}`,
-        ]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function getRepositoryRemoteUrl(repoRoot, remote) {
-    try {
-        return await runGit(repoRoot, ["remote", "get-url", remote]);
-    }
-    catch {
-        return null;
-    }
-}
-function expandTildeInPath(p) {
-    if (p === "~")
-        return homedir();
-    if (p.startsWith("~/"))
-        return join(homedir(), p.slice(2));
-    return p;
-}
-export async function listWorktrees(cwd) {
-    const [output, currentRoot] = await Promise.all([
-        runGit(cwd, ["worktree", "list", "--porcelain"]),
-        runGit(cwd, ["rev-parse", "--show-toplevel"]),
-    ]);
-    const entries = output.split("\n\n").filter(Boolean);
-    const worktrees = entries.flatMap((entry) => {
-        if (findOptionalPorcelainValue(entry, "prunable") !== null)
-            return [];
-        const path = findPorcelainValue(entry, "worktree");
-        const branchRef = findOptionalPorcelainValue(entry, "branch");
-        return [
-            {
-                branch: branchRef ? branchRef.replace("refs/heads/", "") : null,
-                isCurrent: path === currentRoot,
-                path,
-            },
-        ];
-    });
-    const accessible = await Promise.all(worktrees.map(async (worktree) => {
-        try {
-            await access(worktree.path);
-            return worktree;
-        }
-        catch {
-            return null;
-        }
-    }));
-    return accessible.filter((worktree) => worktree !== null);
-}
-function findPorcelainValue(block, key) {
-    const value = findOptionalPorcelainValue(block, key);
-    if (!value) {
-        throw new Error(`Missing '${key}' in git worktree output.`);
-    }
-    return value;
-}
-function findOptionalPorcelainValue(block, key) {
-    const line = block
-        .split("\n")
-        .find((candidate) => candidate.startsWith(`${key} `));
-    if (!line) {
-        return null;
-    }
-    return line.slice(key.length + 1);
-}

package/dist/worktree-bootstrap.d.ts

@@ -1,24 +0,0 @@
-import type { EffectiveGjiConfig } from "./config.js";
-import { type BootstrapCommandRunner, type BootstrapEvent, type DependencyBootstrapMode, type DependencyBootstrapReport, type DependencyBootstrapReporter } from "./dependency-bootstrap.js";
-export interface WorktreeBootstrapOptions {
-    branch: string;
-    config: EffectiveGjiConfig;
-    currentRoot?: string;
-    dependencyDetectionRoot?: string;
-    dependencyMode: DependencyBootstrapMode;
-    runCommand?: BootstrapCommandRunner;
-    commandStdout?: (chunk: string) => void;
-    commandStderr?: (chunk: string) => void;
-    json?: boolean;
-    repoRoot: string;
-    reporter: DependencyBootstrapReporter & {
-        write: (chunk: string) => void;
-    };
-    worktreePath: string;
-}
-export interface WorktreeBootstrapResult {
-    dependencyBootstrap: DependencyBootstrapReport;
-    ready: boolean;
-    syncFileFailures: readonly BootstrapEvent[];
-}
-export declare function bootstrapWorktree(options: WorktreeBootstrapOptions): Promise<WorktreeBootstrapResult>;

package/dist/worktree-info.d.ts

@@ -1,37 +0,0 @@
-import { type WorktreeHealth } from "./git.js";
-import type { WorktreeEntry } from "./repo.js";
-export interface WorktreeInfo extends WorktreeEntry {
-    lastCommitTimestamp: number | null;
-    slot: number | null;
-    status: WorktreeHealth["status"] | "unknown";
-    task: string | null;
-    upstream: UpstreamState;
-}
-export interface SerializedWorktreeInfo {
-    branch: string | null;
-    lastCommitTimestamp: number | null;
-    path: string;
-    slot: number | null;
-    status: WorktreeInfo["status"];
-    task: string | null;
-    upstream: UpstreamState;
-}
-export type UpstreamState = {
-    kind: "detached";
-} | {
-    kind: "no-upstream";
-} | {
-    kind: "stale";
-} | {
-    kind: "tracked";
-    ahead: number;
-    behind: number;
-} | {
-    kind: "unknown";
-};
-export declare function readWorktreeInfos(worktrees: WorktreeEntry[]): Promise<WorktreeInfo[]>;
-export declare function readWorktreeInfo(worktree: WorktreeEntry): Promise<WorktreeInfo>;
-export declare function serializeWorktreeInfo(info: WorktreeInfo): SerializedWorktreeInfo;
-export declare function formatUpstreamState(upstream: UpstreamState): string;
-export declare function formatLastCommit(timestampSeconds: number | null): string;
-export declare function formatRelativeAge(timestampSeconds: number, nowSeconds?: number): string;

package/dist/worktree-info.js

@@ -1,123 +0,0 @@
-import { readBranchLastCommitTimestamp, readWorktreeHealth, } from "./git.js";
-import { getWorktreeSlot } from "./slots.js";
-import { readTask } from "./task.js";
-const MAX_WORKTREE_INFO_READ_CONCURRENCY = 8;
-export async function readWorktreeInfos(worktrees) {
-    return mapWithConcurrency(worktrees, MAX_WORKTREE_INFO_READ_CONCURRENCY, readWorktreeInfo);
-}
-async function mapWithConcurrency(items, limit, mapper) {
-    const results = new Array(items.length);
-    let nextIndex = 0;
-    async function readNext() {
-        for (;;) {
-            const index = nextIndex;
-            nextIndex += 1;
-            if (index >= items.length)
-                return;
-            results[index] = await mapper(items[index]);
-        }
-    }
-    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => readNext()));
-    return results;
-}
-export async function readWorktreeInfo(worktree) {
-    const [healthResult, lastCommitResult, slotResult, taskResult] = await Promise.allSettled([
-        readWorktreeHealth(worktree.path),
-        worktree.branch === null
-            ? null
-            : readBranchLastCommitTimestamp(worktree.path, worktree.branch),
-        getWorktreeSlot(worktree.path),
-        readTask(worktree.path),
-    ]);
-    const health = healthResult.status === "fulfilled" ? healthResult.value : null;
-    const lastCommitTimestamp = lastCommitResult.status === "fulfilled" ? lastCommitResult.value : null;
-    const slot = slotResult.status === "fulfilled" ? slotResult.value : null;
-    const task = taskResult.status === "fulfilled" ? (taskResult.value?.task ?? null) : null;
-    return {
-        ...worktree,
-        lastCommitTimestamp,
-        slot,
-        status: health?.status ?? "unknown",
-        task,
-        upstream: buildUpstreamState(worktree.branch, health),
-    };
-}
-function buildUpstreamState(branch, health) {
-    if (branch === null) {
-        return { kind: "detached" };
-    }
-    if (health === null) {
-        return { kind: "unknown" };
-    }
-    if (!health.hasUpstream) {
-        return { kind: "no-upstream" };
-    }
-    if (health.upstreamGone) {
-        return { kind: "stale" };
-    }
-    return {
-        ahead: health.ahead,
-        behind: health.behind,
-        kind: "tracked",
-    };
-}
-export function serializeWorktreeInfo(info) {
-    return {
-        branch: info.branch,
-        lastCommitTimestamp: info.lastCommitTimestamp,
-        path: info.path,
-        slot: info.slot,
-        status: info.status,
-        task: info.task,
-        upstream: info.upstream,
-    };
-}
-export function formatUpstreamState(upstream) {
-    if (upstream.kind === "detached") {
-        return "n/a";
-    }
-    if (upstream.kind === "no-upstream") {
-        return "no-upstream";
-    }
-    if (upstream.kind === "stale") {
-        return "gone";
-    }
-    if (upstream.kind === "unknown") {
-        return "unknown";
-    }
-    return formatAheadBehind(upstream.ahead, upstream.behind);
-}
-function formatAheadBehind(ahead, behind) {
-    if (ahead === 0 && behind === 0) {
-        return "up to date";
-    }
-    if (ahead === 0) {
-        return `behind ${behind}`;
-    }
-    if (behind === 0) {
-        return `ahead ${ahead}`;
-    }
-    return `ahead ${ahead}, behind ${behind}`;
-}
-export function formatLastCommit(timestampSeconds) {
-    return timestampSeconds === null
-        ? "n/a"
-        : formatRelativeAge(timestampSeconds);
-}
-export function formatRelativeAge(timestampSeconds, nowSeconds = Math.floor(Date.now() / 1000)) {
-    const ageSeconds = Math.max(0, nowSeconds - timestampSeconds);
-    const units = [
-        { label: "y", seconds: 365 * 24 * 60 * 60 },
-        { label: "mo", seconds: 30 * 24 * 60 * 60 },
-        { label: "d", seconds: 24 * 60 * 60 },
-        { label: "h", seconds: 60 * 60 },
-        { label: "m", seconds: 60 },
-    ];
-    for (const unit of units) {
-        const value = Math.floor(ageSeconds / unit.seconds);
-        if (value > 0) {
-            return `${value}${unit.label} ago`;
-        }
-    }
-    return "just now";
-}

package/dist/worktree-sources.d.ts

@@ -1,4 +0,0 @@
-import { type RepoRegistryEntry } from "./repo-registry.js";
-import type { WorktreeSource } from "./worktree-source.js";
-export declare function listRegisteredWorktreeSources(cwd: string, onSkipped?: (entry: RepoRegistryEntry) => void): Promise<WorktreeSource[]>;
-export declare function listDiscoverableWorktreeSources(cwd: string, onSkipped?: (entry: RepoRegistryEntry) => void): Promise<WorktreeSource[]>;