@cjhyy/code-shell-core 0.7.1 → 0.8.0

package/dist/git/utils.js

@@ -1,161 +0,0 @@
-/**
- * Git utility functions for the git workflow commands.
- *
- * Every call goes through execFileSync with an argv array — no command
- * strings, no shell interpolation. Even arguments that look "safe" (already
- * quoted, hard-coded) are passed as separate argv tokens so a future caller
- * can't accidentally widen the attack surface by interpolating user input
- * into the string form.
- */
-import { execFileSync } from "node:child_process";
-import { realpathSync } from "node:fs";
-import { parseGitLog } from "./parse-log.js";
-import { resolveExecutable, resolveGit } from "../utils/exec.js";
-// Resolve git/gh through PATH×PATHEXT on Windows so a .cmd/.exe shim is found
-// (bare execFile doesn't walk PATHEXT). No-op on POSIX. See utils/exec.ts.
-const GH_BIN = resolveExecutable("gh");
-/** Run git with an argv array and return its trimmed stdout. */
-function git(cwd, args, timeoutMs = 10000) {
-    return execFileSync(resolveGit(), args, { cwd, encoding: "utf-8", timeout: timeoutMs }).trim();
-}
-/** Run gh with an argv array and return its trimmed stdout. */
-function gh(cwd, args, timeoutMs = 10000) {
-    return execFileSync(GH_BIN, args, { cwd, encoding: "utf-8", timeout: timeoutMs }).trim();
-}
-export function isGitRepo(cwd) {
-    try {
-        git(cwd, ["rev-parse", "--is-inside-work-tree"], 5000);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Resolve a directory to its PROJECT ROOT: the enclosing git repository's
- * top-level dir if `cwd` is inside a git repo, otherwise `cwd` unchanged.
- *
- * This is the project-boundary rule the desktop uses when adding/identifying a
- * project: picking a SUBDIRECTORY of a git repo should belong to that one repo
- * (its root), not spawn a separate project per subdir — mirrors how editors
- * (and Claude Code) treat a repo as one workspace. A non-git folder is its own
- * project (returned as-is). Never throws; on any git failure falls back to cwd.
- * Returns the git-reported toplevel (already absolute, forward-slashed on win).
- */
-export function resolveProjectRoot(cwd) {
-    let realCwd = cwd;
-    try {
-        realCwd = realpathSync(cwd);
-    }
-    catch {
-        // Non-existent paths are allowed to fall back unchanged below.
-    }
-    try {
-        const top = git(realCwd, ["rev-parse", "--show-toplevel"], 5000);
-        return top ? realpathSync(top) : realCwd;
-    }
-    catch {
-        return realCwd;
-    }
-}
-export function getCurrentBranch(cwd) {
-    return git(cwd, ["branch", "--show-current"], 5000);
-}
-export function getGitStatus(cwd) {
-    const raw = git(cwd, ["status", "--porcelain"], 10000);
-    if (!raw)
-        return [];
-    return raw.split("\n").map((line) => ({
-        status: line.slice(0, 2).trim(),
-        path: line.slice(3),
-    }));
-}
-export function getGitDiff(cwd, opts) {
-    const args = ["diff", "--no-color"];
-    if (opts?.staged)
-        args.push("--staged");
-    // `--` terminates option parsing so a file path starting with `-` can't
-    // be re-interpreted as a flag.
-    if (opts?.file)
-        args.push("--", opts.file);
-    return git(cwd, args, 30000);
-}
-export function getGitDiffStat(cwd, opts) {
-    const args = ["diff", "--stat", "--no-color"];
-    if (opts?.staged)
-        args.push("--staged");
-    if (opts?.file)
-        args.push("--", opts.file);
-    return git(cwd, args, 10000);
-}
-export function getGitLog(cwd, n = 10) {
-    // `n` is numeric — coerce/validate to keep the argv clean even if a caller
-    // hands us a string.
-    const count = Number.isFinite(n) && n > 0 ? Math.floor(n) : 10;
-    const raw = git(cwd, ["log", "--oneline", "--format=%H|%s|%an|%ci", `-${count}`], 10000);
-    if (!raw)
-        return [];
-    return parseGitLog(raw);
-}
-export function getRemoteUrl(cwd) {
-    try {
-        return git(cwd, ["remote", "get-url", "origin"], 5000);
-    }
-    catch {
-        return undefined;
-    }
-}
-export function gitAdd(cwd, files = ["."]) {
-    // `--` ensures a path starting with `-` cannot be parsed as a flag.
-    // Each file is its own argv token, so spaces / quotes / non-ASCII pass
-    // through verbatim with no shell parsing.
-    execFileSync(resolveGit(), ["add", "--", ...files], { cwd, timeout: 10000 });
-}
-export function gitCommit(cwd, message) {
-    // Pre-fix this used `JSON.stringify(message)` which only happened to be
-    // safe because JSON.stringify covers most shell metacharacters — but it's
-    // not real escaping. The argv form is.
-    return execFileSync(resolveGit(), ["commit", "-m", message], {
-        cwd,
-        encoding: "utf-8",
-        timeout: 30000,
-    }).trim();
-}
-export function gitListBranches(cwd) {
-    const raw = git(cwd, ["branch", "--no-color"], 5000);
-    if (!raw)
-        return [];
-    return raw.split("\n").map((line) => ({
-        current: line.startsWith("*"),
-        name: line.replace(/^\*?\s+/, "").trim(),
-    }));
-}
-export function gitCheckout(cwd, branch, create = false) {
-    // argv form defeats shell injection. We additionally reject branch names
-    // that start with `-` so a value like `--orphan` can't slip through git's
-    // own option parser (the trailing `--` trick doesn't help on checkout:
-    // git interprets it as the option's value, not as an option terminator).
-    if (typeof branch !== "string" || branch.length === 0) {
-        throw new Error("branch must be a non-empty string");
-    }
-    if (branch.startsWith("-")) {
-        throw new Error(`refusing branch name that starts with '-': ${branch}`);
-    }
-    const args = create ? ["checkout", "-b", branch] : ["checkout", branch];
-    execFileSync(resolveGit(), args, { cwd, timeout: 10000 });
-}
-export function ghAvailable() {
-    try {
-        execFileSync(GH_BIN, ["--version"], { encoding: "utf-8", timeout: 5000 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function ghPrComments(cwd, prUrl) {
-    // Pre-fix `gh pr view ${prUrl}` interpolated the URL directly. argv form
-    // means even a value like "$(rm -rf ~)" is sent to gh as a literal
-    // positional argument (which gh will then reject as a bad PR URL).
-    return gh(cwd, ["pr", "view", prUrl, "--comments", "--json", "comments", "-q", ".comments[].body"], 30000);
-}

package/dist/git/worktree/crud.d.ts

@@ -1,72 +0,0 @@
-import type { SandboxBackend } from "../../tool-system/sandbox/index.js";
-export interface WorktreeSession {
-    originalCwd: string;
-    worktreePath: string;
-    worktreeName: string;
-    worktreeBranch: string;
-    originalBranch?: string;
-    sessionId: string;
-    createdAt: number;
-}
-/** Per-platform setup/cleanup scripts (a project's localEnvironment). */
-export interface PlatformScripts {
-    default?: string;
-    macos?: string;
-    linux?: string;
-    windows?: string;
-}
-export interface CreateWorktreeOptions {
-    prefix?: string;
-    signal?: AbortSignal;
-}
-/** Best-effort rollback for an aborted `git worktree add`. */
-export declare function cleanupAbortedWorktree(gitRoot: string, worktreePath: string, branchName: string): Promise<void>;
-/**
- * Pick the setup/cleanup script for the running platform, falling back to
- * `default`. Empty/whitespace-only scripts are treated as absent so a project
- * can leave a platform key blank without spawning an empty shell. `platform`
- * defaults to `process.platform` so callers usually omit it; tests pass a
- * fixed value.
- */
-export declare function selectPlatformScript(scripts: PlatformScripts | undefined, platform?: NodeJS.Platform): string | undefined;
-/**
- * Create an isolated git worktree for an agent session.
- */
-export declare function createWorktree(cwd: string, slug: string, sessionId: string, opts?: CreateWorktreeOptions): Promise<WorktreeSession>;
-export interface WorktreeSetupResult {
-    /** True if no setup script was configured for this platform (nothing ran). */
-    skipped: boolean;
-    /** True if a script ran and exited 0. */
-    ok: boolean;
-    /** Combined stdout/stderr, for surfacing to the user on failure. */
-    output: string;
-    /** Exit code when a script ran; undefined when skipped. */
-    exitCode?: number | null;
-}
-/**
- * Run a project's `localEnvironment.setupScripts` once, in the freshly-created
- * worktree's root, right after `git worktree add`.
- */
-export declare function runWorktreeSetup(worktreePath: string, script: string | undefined, opts?: {
-    sandbox?: SandboxBackend;
-    shellEnv?: Record<string, string>;
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}): Promise<WorktreeSetupResult>;
-export interface RemoveWorktreeResult {
-    /** True once `git worktree remove` completed and the directory is gone. */
-    dirRemoved: boolean;
-    /** The branch targeted for deletion when removeBranch=true. */
-    branch?: string;
-    /** True when removeBranch=true and branch deletion completed. */
-    branchDeleted?: boolean;
-    /** Non-empty when the worktree directory is gone but branch deletion failed. */
-    branchError?: string;
-}
-export interface RemoveWorktreeOptions {
-    prefix?: string;
-}
-/**
- * Remove a worktree and optionally its branch.
- */
-export declare function removeWorktree(worktreePath: string, removeBranch?: boolean, opts?: RemoveWorktreeOptions): RemoveWorktreeResult;

package/dist/git/worktree/crud.js

@@ -1,235 +0,0 @@
-import { existsSync, lstatSync, mkdirSync, readdirSync, symlinkSync } from "node:fs";
-import { rm } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { safeSpawnShell } from "../../runtime/safe-spawn.js";
-import { buildSandboxEnv, defaultShellBinary, mergeShellEnv } from "../../runtime/spawn-common.js";
-import { execGit, execGitSync, gitErrorMessage } from "./git-exec.js";
-import { assertBranchNotCheckedOut, currentBranch, findGitRoot } from "./query.js";
-import { applyPrefix, isManagedWorktreeBranch, validateWorktreeSlug } from "./slug.js";
-function throwIfAborted(signal) {
-    signal?.throwIfAborted();
-}
-/** Best-effort rollback for an aborted `git worktree add`. */
-export async function cleanupAbortedWorktree(gitRoot, worktreePath, branchName) {
-    try {
-        await execGit(gitRoot, ["worktree", "remove", worktreePath, "--force"], 30_000);
-    }
-    catch {
-        await rm(worktreePath, { recursive: true, force: true }).catch(() => { });
-        await execGit(gitRoot, ["worktree", "prune"], 10_000).catch(() => { });
-    }
-    await execGit(gitRoot, ["branch", "-D", branchName], 10_000).catch(() => { });
-}
-/**
- * Pick the setup/cleanup script for the running platform, falling back to
- * `default`. Empty/whitespace-only scripts are treated as absent so a project
- * can leave a platform key blank without spawning an empty shell. `platform`
- * defaults to `process.platform` so callers usually omit it; tests pass a
- * fixed value.
- */
-export function selectPlatformScript(scripts, platform = process.platform) {
-    if (!scripts)
-        return undefined;
-    const key = platform === "darwin" ? "macos" : platform === "win32" ? "windows" : "linux";
-    // A blank platform key shouldn't shadow a real `default` — fall through.
-    const platformScript = scripts[key]?.trim() ? scripts[key] : undefined;
-    const candidate = platformScript ?? scripts.default;
-    const trimmed = candidate?.trim();
-    return trimmed ? candidate : undefined;
-}
-/**
- * Create an isolated git worktree for an agent session.
- */
-export async function createWorktree(cwd, slug, sessionId, opts = {}) {
-    validateWorktreeSlug(slug);
-    throwIfAborted(opts.signal);
-    const gitRoot = await findGitRoot(cwd);
-    throwIfAborted(opts.signal);
-    const branchName = applyPrefix(opts.prefix, slug, sessionId);
-    const worktreePath = resolve(gitRoot, "..", `.worktrees/${slug}-${sessionId.slice(0, 8)}`);
-    await assertBranchNotCheckedOut(gitRoot, branchName);
-    throwIfAborted(opts.signal);
-    const originalBranch = await currentBranch(gitRoot);
-    throwIfAborted(opts.signal);
-    // The argv form keeps branchName/worktreePath as literal positional
-    // arguments even if a future caller bypasses validateWorktreeSlug.
-    try {
-        await execGit(gitRoot, ["worktree", "add", "-b", branchName, worktreePath], 30_000, opts.signal);
-        throwIfAborted(opts.signal);
-        // Symlink large directories to avoid disk bloat.
-        symlinkLargeDirectories(gitRoot, worktreePath);
-        throwIfAborted(opts.signal);
-    }
-    catch (error) {
-        if (opts.signal?.aborted) {
-            await cleanupAbortedWorktree(gitRoot, worktreePath, branchName);
-        }
-        throw error;
-    }
-    return {
-        originalCwd: cwd,
-        worktreePath,
-        worktreeName: slug,
-        worktreeBranch: branchName,
-        originalBranch,
-        sessionId,
-        createdAt: Date.now(),
-    };
-}
-/**
- * Run a project's `localEnvironment.setupScripts` once, in the freshly-created
- * worktree's root, right after `git worktree add`.
- */
-export async function runWorktreeSetup(worktreePath, script, opts = {}) {
-    const trimmed = script?.trim();
-    if (!trimmed)
-        return { skipped: true, ok: true, output: "" };
-    const shell = defaultShellBinary();
-    const backend = opts.sandbox;
-    const baseEnv = backend && backend.name !== "off" ? buildSandboxEnv() : { ...process.env };
-    const env = mergeShellEnv(baseEnv, opts.shellEnv);
-    const result = await safeSpawnShell(trimmed, {
-        cwd: worktreePath,
-        env,
-        timeoutMs: opts.timeoutMs ?? 120_000,
-        maxOutputBytes: 1024 * 1024,
-        sandbox: backend,
-        shell,
-        signal: opts.signal,
-    });
-    const parts = [];
-    if (result.stdout)
-        parts.push(result.stdout);
-    if (result.stderr)
-        parts.push(result.stderr);
-    const output = parts.join("\n").trim();
-    if (result.aborted)
-        return { skipped: false, ok: false, output: output || "setup aborted" };
-    if (result.timedOut)
-        return { skipped: false, ok: false, output: output || "setup timed out" };
-    if (result.spawnFailed) {
-        return { skipped: false, ok: false, output: result.error ?? "failed to spawn setup script" };
-    }
-    return { skipped: false, ok: result.exitCode === 0, output, exitCode: result.exitCode };
-}
-/**
- * Remove a worktree and optionally its branch.
- */
-export function removeWorktree(worktreePath, removeBranch = false, opts = {}) {
-    // The MAIN repo root, not the worktree's own toplevel. `git rev-parse
-    // --show-toplevel` from inside a worktree returns the worktree path, which
-    // is about to be deleted; the branch-delete must run from the main repo,
-    // which outlives the worktree. Derive it from the common git dir.
-    let mainRoot;
-    try {
-        const commonDir = execGitSync(worktreePath, ["rev-parse", "--path-format=absolute", "--git-common-dir"], 5000).trim();
-        mainRoot = dirname(commonDir);
-    }
-    catch (err) {
-        throw new Error(`failed to inspect worktree ${worktreePath}: ${gitErrorMessage(err)}`, {
-            cause: err,
-        });
-    }
-    // Capture the worktree's branch BEFORE removing the worktree — afterwards
-    // the directory is gone and `git branch --show-current` in it would fail.
-    let branch = "";
-    if (removeBranch) {
-        try {
-            branch = execGitSync(worktreePath, ["branch", "--show-current"], 5000).trim();
-        }
-        catch (err) {
-            throw new Error(`failed to determine branch for worktree ${worktreePath}: ${gitErrorMessage(err)}`, { cause: err });
-        }
-        if (!branch) {
-            throw new Error(`failed to determine branch for worktree ${worktreePath}`);
-        }
-        if (!isManagedWorktreeBranch(branch, opts.prefix)) {
-            throw new Error(`refusing to delete non-CodeShell worktree branch ${branch}`);
-        }
-    }
-    try {
-        execGitSync(mainRoot, ["worktree", "remove", worktreePath, "--force"], 30000);
-    }
-    catch (err) {
-        throw new Error(`failed to remove worktree ${worktreePath}: ${gitErrorMessage(err)}`, {
-            cause: err,
-        });
-    }
-    if (removeBranch) {
-        try {
-            execGitSync(mainRoot, ["branch", "-D", branch], 10000);
-        }
-        catch (err) {
-            return {
-                dirRemoved: true,
-                branch,
-                branchDeleted: false,
-                branchError: gitErrorMessage(err),
-            };
-        }
-    }
-    return removeBranch ? { dirRemoved: true, branch, branchDeleted: true } : { dirRemoved: true };
-}
-/**
- * Symlink large directories (node_modules, .venv, etc.) from main repo to
- * worktree. Also links each monorepo workspace package's private
- * `node_modules` (e.g. `packages/desktop/node_modules`, where bun keeps
- * un-hoisted deps like electron) so a fresh worktree can build/run the whole
- * workspace, not just the packages whose deps happen to be hoisted to the root.
- */
-function symlinkLargeDirectories(sourceRoot, worktreePath) {
-    const largeDirs = ["node_modules", ".venv", "vendor", ".pnpm-store"];
-    for (const dir of largeDirs) {
-        linkDir(join(sourceRoot, dir), join(worktreePath, dir));
-    }
-    // Monorepo workspace packages keep private node_modules that are NOT hoisted
-    // to the root. Link `<pkg>/node_modules` for each package under `packages/`.
-    const packagesDir = join(sourceRoot, "packages");
-    if (!dirExists(packagesDir))
-        return;
-    let pkgNames;
-    try {
-        pkgNames = readdirSync(packagesDir);
-    }
-    catch {
-        return;
-    }
-    for (const pkg of pkgNames) {
-        const source = join(packagesDir, pkg, "node_modules");
-        if (!dirExists(source))
-            continue;
-        const targetPkgDir = join(worktreePath, "packages", pkg);
-        // The worktree only has package dirs that exist in this branch's tree; a
-        // package present in the main repo but not checked out here is skipped.
-        if (!dirExists(targetPkgDir)) {
-            try {
-                mkdirSync(targetPkgDir, { recursive: true });
-            }
-            catch {
-                continue;
-            }
-        }
-        linkDir(source, join(targetPkgDir, "node_modules"));
-    }
-}
-function dirExists(path) {
-    try {
-        return lstatSync(path).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-function linkDir(source, target) {
-    // Windows directory symlinks need admin/Developer Mode and throw EPERM for a
-    // normal user; NTFS junctions don't and behave the same for our purpose.
-    const linkType = process.platform === "win32" ? "junction" : "dir";
-    if (dirExists(source) && !existsSync(target)) {
-        try {
-            symlinkSync(source, target, linkType);
-        }
-        catch {
-            // Symlink/junction might fail on some systems — non-fatal.
-        }
-    }
-}

package/dist/git/worktree/diff.d.ts

@@ -1,14 +0,0 @@
-export interface WorktreeDiffSummary {
-    /** Best-effort base used for the branch comparison, usually main/master. */
-    baseRef?: string;
-    /** Unique files changed either by commits ahead of base or by uncommitted changes. */
-    changedFiles: number;
-    /** Commits reachable from HEAD but not from baseRef. */
-    aheadCommits: number;
-    /** True when `git status --porcelain` reports local changes. */
-    hasUncommittedChanges: boolean;
-}
-export declare function getWorktreeDiff(worktreePath: string, baseRef?: string): Promise<WorktreeDiffSummary>;
-export declare function worktreeHasUncommittedChanges(worktreePath: string): Promise<boolean>;
-export declare function worktreeHasUncommittedOrAheadChanges(worktreePath: string, baseRef?: string): Promise<boolean>;
-export declare function findComparisonBaseRef(cwd: string): Promise<string | undefined>;

package/dist/git/worktree/diff.js

@@ -1,82 +0,0 @@
-import { gitOutput } from "./git-exec.js";
-export async function getWorktreeDiff(worktreePath, baseRef) {
-    const comparisonBase = baseRef && (await commitRefExists(worktreePath, baseRef))
-        ? baseRef
-        : await findComparisonBaseRef(worktreePath);
-    return diffSummary(worktreePath, comparisonBase);
-}
-export async function worktreeHasUncommittedChanges(worktreePath) {
-    const out = await gitOutput(worktreePath, ["status", "--porcelain"], 10000);
-    return (out?.trim().length ?? 0) > 0;
-}
-export async function worktreeHasUncommittedOrAheadChanges(worktreePath, baseRef) {
-    if (await worktreeHasUncommittedChanges(worktreePath))
-        return true;
-    const comparisonBase = baseRef && (await commitRefExists(worktreePath, baseRef))
-        ? baseRef
-        : await findComparisonBaseRef(worktreePath);
-    return comparisonBase ? (await aheadCommitCount(worktreePath, comparisonBase)) > 0 : false;
-}
-export async function findComparisonBaseRef(cwd) {
-    for (const ref of ["main", "master", "origin/main", "origin/master"]) {
-        if (await commitRefExists(cwd, ref))
-            return ref;
-    }
-    return undefined;
-}
-async function commitRefExists(cwd, ref) {
-    const out = await gitOutput(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], 5000);
-    return out !== undefined;
-}
-async function diffSummary(cwd, baseRef) {
-    const [dirtyFiles, committedFiles, aheadCommits] = await Promise.all([
-        statusFileSet(cwd),
-        baseRef ? changedFilesSinceBase(cwd, baseRef) : Promise.resolve(new Set()),
-        baseRef ? aheadCommitCount(cwd, baseRef) : Promise.resolve(0),
-    ]);
-    const changedFiles = new Set([...dirtyFiles, ...committedFiles]);
-    return {
-        ...(baseRef ? { baseRef } : {}),
-        changedFiles: changedFiles.size,
-        aheadCommits,
-        hasUncommittedChanges: dirtyFiles.size > 0,
-    };
-}
-async function changedFilesSinceBase(cwd, baseRef) {
-    const out = await gitOutput(cwd, ["diff", "--name-only", `${baseRef}...HEAD`]);
-    const raw = out ?? (await gitOutput(cwd, ["diff", "--name-only", `${baseRef}..HEAD`])) ?? "";
-    return new Set(raw
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean));
-}
-async function aheadCommitCount(cwd, baseRef) {
-    const out = await gitOutput(cwd, ["rev-list", "--count", `${baseRef}..HEAD`]);
-    const n = Number.parseInt(out?.trim() ?? "0", 10);
-    return Number.isFinite(n) ? n : 0;
-}
-async function statusFileSet(cwd) {
-    const raw = (await gitOutput(cwd, ["status", "--porcelain=v1"])) ?? "";
-    const files = new Set();
-    for (const line of raw.split("\n")) {
-        if (!line.trim())
-            continue;
-        const path = line.slice(3).trim();
-        if (!path)
-            continue;
-        const renameTarget = path.includes(" -> ") ? path.split(" -> ").at(-1) : path;
-        if (renameTarget)
-            files.add(unquoteGitPath(renameTarget));
-    }
-    return files;
-}
-function unquoteGitPath(path) {
-    if (!path.startsWith('"') || !path.endsWith('"'))
-        return path;
-    try {
-        return JSON.parse(path);
-    }
-    catch {
-        return path.slice(1, -1);
-    }
-}

package/dist/git/worktree/git-exec.d.ts

@@ -1,7 +0,0 @@
-export declare const GIT_BIN: string;
-export declare function execGit(cwd: string, args: string[], timeout?: number, signal?: AbortSignal): Promise<string>;
-export declare function execGitSync(cwd: string, args: string[], timeout?: number): string;
-export declare function gitOutput(cwd: string, args: string[], timeout?: number, signal?: AbortSignal): Promise<string | undefined>;
-export declare function gitOutputSync(cwd: string, args: string[], timeout?: number): string | undefined;
-export declare function gitErrorMessage(err: unknown): string;
-export declare function normalizeBranchName(branch: string): string;

package/dist/git/worktree/git-exec.js

@@ -1,87 +0,0 @@
-import { execFile, execFileSync } from "node:child_process";
-import { killChildTree } from "../../runtime/spawn-common.js";
-import { resolveExecutable } from "../../utils/exec.js";
-// git resolved via PATH×PATHEXT on Windows (.cmd/.exe shim); no-op on POSIX.
-export const GIT_BIN = resolveExecutable("git");
-export async function execGit(cwd, args, timeout = 10000, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(signal.reason);
-            return;
-        }
-        let settled = false;
-        const child = execFile(GIT_BIN, args, { cwd, encoding: "utf-8" }, (error, stdout, stderr) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            if (error) {
-                Object.assign(error, { stdout, stderr });
-                reject(error);
-            }
-            else {
-                resolve(stdout);
-            }
-        });
-        const terminate = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            killChildTree(child, 1000);
-            reject(error);
-        };
-        const onAbort = () => terminate(signal?.reason ?? Object.assign(new Error("Git command aborted"), { name: "AbortError" }));
-        const timer = setTimeout(() => {
-            terminate(Object.assign(new Error(`Git command timed out after ${timeout}ms`), {
-                code: "ETIMEDOUT",
-            }));
-        }, timeout);
-        const cleanup = () => {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", onAbort);
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
-        if (signal?.aborted)
-            onAbort();
-    });
-}
-export function execGitSync(cwd, args, timeout = 10000) {
-    return execFileSync(GIT_BIN, args, {
-        cwd,
-        encoding: "utf-8",
-        timeout,
-    });
-}
-export async function gitOutput(cwd, args, timeout = 10000, signal) {
-    try {
-        return await execGit(cwd, args, timeout, signal);
-    }
-    catch (error) {
-        if (signal?.aborted)
-            throw error;
-        return undefined;
-    }
-}
-export function gitOutputSync(cwd, args, timeout = 10000) {
-    try {
-        return execGitSync(cwd, args, timeout);
-    }
-    catch {
-        return undefined;
-    }
-}
-export function gitErrorMessage(err) {
-    const stderr = err.stderr;
-    if (Buffer.isBuffer(stderr)) {
-        const msg = stderr.toString("utf-8").trim();
-        if (msg)
-            return msg;
-    }
-    if (typeof stderr === "string" && stderr.trim())
-        return stderr.trim();
-    return err instanceof Error ? err.message : String(err);
-}
-export function normalizeBranchName(branch) {
-    return branch.replace(/^refs\/heads\//, "");
-}

package/dist/git/worktree/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./git-exec.js";
-export * from "./slug.js";
-export * from "./diff.js";
-export * from "./query.js";
-export * from "./crud.js";

package/dist/git/worktree/index.js

@@ -1,5 +0,0 @@
-export * from "./git-exec.js";
-export * from "./slug.js";
-export * from "./diff.js";
-export * from "./query.js";
-export * from "./crud.js";