autonomous-sdlc-harness 0.1.0

package/dist/core/errors.js

@@ -0,0 +1,71 @@
+/**
+ * The CLI's error and exit-code contract.
+ *
+ * Two rules hold across the whole package:
+ *
+ * 1. **Nothing calls `process.exit()`.** A command signals failure by throwing a
+ *    `HarnessError` (or by returning an exit code from `run`); the entry point in
+ *    `cli.ts` is the single place where a thrown value becomes `process.exitCode`.
+ *    Exiting outright can truncate stdout mid-write when it is piped.
+ * 2. **Every non-zero exit carries a message naming its cause.** A bare non-zero exit
+ *    with no explanation is indistinguishable from a crash to the run daemon.
+ */
+/**
+ * The exit codes this CLI produces. Callers that branch on the CLI's result — the run
+ * daemon, CI, the acceptance gates in `docs/development.md` — read these and nothing else.
+ */
+export const EXIT = {
+    /** `0` — success: the command did what it was asked to do, including `--help` and `--version`. */
+    OK: 0,
+    /**
+     * `1` — a command-level refusal or a failed check. Expected and actionable: an unknown
+     * command, bad usage, a `doctor` FAIL, a write refused by the re-run contract. Always
+     * accompanied by a message naming the cause.
+     */
+    FAILURE: 1,
+    /**
+     * `2` — an unexpected internal fault: a thrown value the CLI did not model. Reaching this
+     * code means the CLI hit a bug, not that the adopting repository is misconfigured.
+     */
+    INTERNAL: 2,
+};
+/**
+ * An error the CLI raised deliberately: it carries a message written for the person
+ * running the command and the exit code that message should produce.
+ *
+ * Throw this for anything the CLI anticipated (a refusal, a failed check, bad usage).
+ * Leave every other failure to propagate as-is — `cli.ts` reports those as `(unexpected)`
+ * and exits {@link EXIT.INTERNAL}, which is the signal that the fault is a CLI bug.
+ */
+export class HarnessError extends Error {
+    exitCode;
+    constructor(message, exitCode = EXIT.FAILURE) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = 'HarnessError';
+    }
+}
+/**
+ * The sentence every internal fault ends with: the one thing the reader most needs to know about a
+ * message they cannot act on, which is that they are not the one who has to.
+ */
+const INTERNAL_SUFFIX = 'this is a fault in this CLI rather than in the repository it was run against';
+/**
+ * A fault in this CLI or in the assets it ships — a template disagreeing with the generator that
+ * renders it, a write request the engine cannot satisfy, a value two modules were supposed to agree
+ * on and did not. Exits {@link EXIT.INTERNAL}, with {@link INTERNAL_SUFFIX} appended.
+ *
+ * **Use this rather than `new HarnessError(…, EXIT.INTERNAL)` for anything the adopting repository
+ * cannot fix.** The two codes are read by different audiences — {@link EXIT.FAILURE} says "correct
+ * your configuration and run it again", {@link EXIT.INTERNAL} says "this build is broken" — and the
+ * trailing sentence is what makes the difference legible in the message as well as in the status.
+ * Passing a message that already carries its own version of that sentence would say it twice.
+ *
+ * It lives here rather than in each module that throws one because it was copied into five of them
+ * before it was written down once, and four of those copies had already drifted in punctuation from
+ * the fifth.
+ */
+export function internal(message) {
+    return new HarnessError(`${message}: ${INTERNAL_SUFFIX}`, EXIT.INTERNAL);
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/core/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,kGAAkG;IAClG,EAAE,EAAE,CAAC;IACL;;;;OAIG;IACH,OAAO,EAAE,CAAC;IACV;;;OAGG;IACH,QAAQ,EAAE,CAAC;CACH,CAAC;AASX;;;;;;;GAOG;AACH,MAAM,OAAO,YAAa,SAAQ,KAAK;IAG1B;IAFX,YACE,OAAe,EACN,WAAqB,IAAI,CAAC,OAAO;QAE1C,KAAK,CAAC,OAAO,CAAC,CAAC;QAFN,aAAQ,GAAR,QAAQ,CAAyB;QAG1C,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,eAAe,GAAG,8EAA8E,CAAC;AAEvG;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAe;IACtC,OAAO,IAAI,YAAY,CAAC,GAAG,OAAO,KAAK,eAAe,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC3E,CAAC"}

package/dist/core/git.js

@@ -0,0 +1,537 @@
+/**
+ * Every `git` invocation that reads repository **state or a path**, in one module.
+ *
+ * **The rule this module exists to enforce: no other module probes git for the state of a
+ * repository or for a path derived from one — it calls a function here.** One home means one
+ * definition of each probe, one place a review checks that a probe stayed read-only and issued
+ * bare, and one place a new invocation has to justify itself.
+ *
+ * **The single deliberate exception is `generators/githooks.ts`**, which carries its own private
+ * `runGit` for exactly two calls: reading `core.hooksPath` and writing it. Those read and write a
+ * repository **setting** rather than state or a path — the CLI's only write to git configuration —
+ * and that module's own header argues the split under "Where the filesystem and git are touched,
+ * and why they are split". It is an exception with a boundary, not a precedent: a third invocation
+ * anywhere in the package belongs here.
+ *
+ * Two functions below are a **collapsing view over another's probe rather than a probe of their
+ * own** — {@link resolveRepoRoot} over {@link probeRepoRoot}, {@link currentBranch} over
+ * {@link checkedOutBranch}. Neither adds a git invocation and neither adds an invariant: the rule
+ * above is about the invocation, and each pair issues one.
+ *
+ * Two invariants hold in every git call below:
+ *
+ * 1. **`execFileSync` with an argv array, never a shell string** — no `shell: true`, no
+ *    interpolation, so a path containing a space or a quote cannot become two arguments.
+ * 2. **The repository-root probe is issued bare** — the literal arguments
+ *    `rev-parse --show-toplevel`, with nothing added. An unattended run's permission profile
+ *    can allow-list a literal read-only git command, while the same command wrapped in a shell
+ *    substitution or embedded in a compound statement is a different string and stalls on a
+ *    prompt (`docs/config.md` §1).
+ *
+ * Most of what follows is read-only. The two exceptions — {@link initRepository} and
+ * {@link commitAll} — are the only functions in the CLI that mutate a repository's history, and
+ * each is called from one place, behind an explicit adopter decision.
+ */
+import { execFileSync } from 'node:child_process';
+import { HarnessError } from './errors.js';
+/**
+ * The bare repository-root probe, as one frozen literal. Kept as a named constant so a review
+ * can see at a glance that no flag was added to it (`--path-format`, `-C`, `--git-dir`) — see
+ * invariant 2 in the module header.
+ */
+const GIT_REPO_ROOT_ARGS = Object.freeze(['rev-parse', '--show-toplevel']);
+/** The checked-out-branch probe, read-only and with no flag beyond the two that name the branch. */
+const GIT_CURRENT_BRANCH_ARGS = Object.freeze(['rev-parse', '--abbrev-ref', 'HEAD']);
+/**
+ * The same question asked of `HEAD` itself rather than of the commit it points at: the branch `HEAD`
+ * names, answered without requiring a commit to exist on it.
+ *
+ * It is here because the probe above cannot answer in the state every repository with no commit is
+ * in at the moment detection runs — the one `init --git-init` just created, and the one an adopter
+ * made and has not committed into. `HEAD` is unborn, `rev-parse --abbrev-ref HEAD` exits 128, and
+ * the branch the first commit is about to land on is exactly the value that has to be configured. `--quiet` keeps a detached `HEAD` an exit status rather than an error on stderr.
+ */
+const GIT_SYMBOLIC_HEAD_ARGS = Object.freeze(['symbolic-ref', '--quiet', '--short', 'HEAD']);
+/**
+ * The worktree inventory probe, issued bare: the two literal arguments and nothing added.
+ *
+ * `--porcelain` is deliberately absent. The only caller asks whether this git can answer the
+ * question at all, not what the answer says, and the plain form is the one an unattended run's
+ * permission profile is most likely to already allow as a literal.
+ */
+const GIT_WORKTREE_LIST_ARGS = Object.freeze(['worktree', 'list']);
+/**
+ * "Does `HEAD` name a commit" — `--quiet` so an unborn HEAD prints nothing rather than an error,
+ * leaving the exit status as the whole answer.
+ */
+const GIT_HAS_COMMITS_ARGS = Object.freeze(['rev-parse', '--verify', '--quiet', 'HEAD']);
+/**
+ * Repository creation, as the literal single argument.
+ *
+ * **No `--initial-branch`.** git's own `init.defaultBranch` decides the name, and detection reads
+ * that name back off the unborn `HEAD` this leaves behind ({@link checkedOutBranch}); passing a name
+ * here would pre-empt the value the detection is supposed to read.
+ */
+const GIT_INIT_ARGS = Object.freeze(['init']);
+/** Where `origin` says its own default branch points, or nothing when no remote HEAD is known. */
+const GIT_REMOTE_HEAD_ARGS = Object.freeze([
+    'symbolic-ref',
+    '--quiet',
+    '--short',
+    'refs/remotes/origin/HEAD',
+]);
+/** The configured name `git init` would give a new repository's first branch, when one is set. */
+const GIT_INIT_DEFAULT_BRANCH_ARGS = Object.freeze(['config', '--get', 'init.defaultBranch']);
+/** The remote inventory probe, issued bare: names only, one per line, with no flag added. */
+const GIT_REMOTES_ARGS = Object.freeze(['remote']);
+/**
+ * The ref-existence probe, minus the ref. The full ref name is appended as **one** argv element by
+ * {@link refResolves}; `--quiet` makes the exit status the whole answer.
+ */
+const GIT_VERIFY_REF_ARGS = Object.freeze(['rev-parse', '--verify', '--quiet']);
+/**
+ * The commit-counting probe, minus the range. The `<base>..<tip>` range is appended as **one** argv
+ * element by {@link commitsAhead} (module header, invariant 1), followed by the pathspec separator
+ * below.
+ */
+const GIT_COUNT_RANGE_ARGS = Object.freeze(['rev-list', '--count']);
+/**
+ * What separates revisions from paths on a git command line, appended after the range so a range
+ * that happens to spell a path in the working tree cannot be read as one.
+ */
+const PATHSPEC_SEPARATOR = '--';
+/**
+ * The ignore probe, minus the path. `--quiet` makes the exit status the whole answer, and
+ * {@link PATHSPEC_SEPARATOR} is part of the constant rather than appended by the caller so the path
+ * is always passed after it — a path beginning with `-` can then never be read as an option.
+ */
+const GIT_CHECK_IGNORE_ARGS = Object.freeze([
+    'check-ignore',
+    '--quiet',
+    PATHSPEC_SEPARATOR,
+]);
+/** The prefix `git` prints on a remote-tracking branch, stripped before the name is reported. */
+const ORIGIN_PREFIX = 'origin/';
+/**
+ * Run `git` with a fixed argument vector and return its trimmed stdout.
+ *
+ * stdin is closed and stderr is captured rather than inherited: a git failure is turned into a
+ * `HarnessError` with a message written for the person running the command, so the raw git
+ * text never interleaves with the reporter's output.
+ */
+function runGit(args, cwd) {
+    return execFileSync('git', [...args], {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+    }).trim();
+}
+/** True when a thrown value is a failure to spawn `git` at all, rather than a non-zero status. */
+function isMissingGit(error) {
+    return error?.code === 'ENOENT';
+}
+/**
+ * One captured stream off a thrown `execFileSync` result, decoded and flattened to a single line.
+ *
+ * git answers in paragraphs (`On branch main\nnothing to commit, working tree clean`) and every
+ * consumer of this text is a one-line warning or check detail, so the newlines are collapsed here
+ * rather than in each caller. Nothing is dropped — only the line breaks become spaces.
+ */
+function capturedStream(error, stream) {
+    const value = error?.[stream];
+    const text = typeof value === 'string' ? value : value instanceof Buffer ? value.toString('utf8') : '';
+    return text.replace(/\s+/g, ' ').trim();
+}
+/**
+ * What to tell the adopter about a failed invocation: **git's own account of it**, which is the
+ * sentence that names the actual cause and the only one worth putting in front of them.
+ *
+ * stderr first — that is where a refusal lands (`Author identity unknown`, a rejecting hook).
+ * stdout second, because `git commit` reports the one non-failure failure this CLI actually meets,
+ * `nothing to commit, working tree clean`, on stdout while still exiting non-zero. The thrown
+ * value's own message is the last resort: it is `Command failed: git commit -m <message>`, which
+ * names no cause and echoes the whole commit message back.
+ *
+ * A missing `git` is spelled out rather than passed through, because the raw `ENOENT` text names
+ * `spawnSync` and a file descriptor rather than the thing the reader has to fix.
+ */
+function gitFailureDetail(error) {
+    if (isMissingGit(error))
+        return 'git is not on PATH';
+    const stderr = capturedStream(error, 'stderr');
+    if (stderr !== '')
+        return stderr;
+    const stdout = capturedStream(error, 'stdout');
+    if (stdout !== '')
+        return stdout;
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * The substring every wording of git's "there is no repository here" carries — the parenthesised
+ * `(or any of the parent directories)` form and the `--git-dir` form alike. Matched on stderr
+ * because `rev-parse --show-toplevel` exits non-zero for that answer and for every other refusal
+ * alike, and only this one leaves the directory free for `init` to offer to create one in.
+ */
+const NOT_A_REPOSITORY_STDERR = 'not a git repository';
+/** The one wording of the no-repository refusal, so both branches that reach it read identically. */
+const NOT_A_REPOSITORY_MESSAGE = (cwd) => `not inside a git repository: ${cwd}`;
+/**
+ * The repository root containing `cwd`, or why there is not one — from the same bare
+ * `rev-parse --show-toplevel` as {@link resolveRepoRoot}, which is implemented on top of this.
+ *
+ * The carried messages are the exact strings {@link resolveRepoRoot} throws, so a caller that
+ * cannot act on the distinction can report the failure identically to a caller that never probed.
+ */
+export function probeRepoRoot(cwd) {
+    let output;
+    try {
+        output = runGit(GIT_REPO_ROOT_ARGS, cwd);
+    }
+    catch (error) {
+        if (isMissingGit(error)) {
+            return {
+                kind: 'no-git',
+                message: `git is not on PATH, so the repository root of ${cwd} cannot be resolved`,
+            };
+        }
+        const detail = gitFailureDetail(error);
+        if (detail.toLowerCase().includes(NOT_A_REPOSITORY_STDERR)) {
+            return { kind: 'not-a-repository', message: NOT_A_REPOSITORY_MESSAGE(cwd) };
+        }
+        return {
+            kind: 'git-failed',
+            message: `git could not resolve the repository root of ${cwd}: ${detail}`,
+        };
+    }
+    if (output === '')
+        return { kind: 'not-a-repository', message: NOT_A_REPOSITORY_MESSAGE(cwd) };
+    return { kind: 'repository', root: output };
+}
+/**
+ * `<repo_root>` — the root of the repository containing `cwd`, from a bare
+ * `git rev-parse --show-toplevel`.
+ *
+ * In a git worktree this is the **worktree's** root, not the main checkout's, which is the
+ * whole point of resolving it per run: a worktree run must write into its own checkout.
+ *
+ * Throws a `HarnessError` when `cwd` is not inside a repository, or when `git` is not on PATH.
+ * Both are adopter-fixable, so both carry the default exit code.
+ *
+ * It is a thin refusal on top of {@link probeRepoRoot} so that the root probe is issued from
+ * exactly one place in the package, whether or not the caller can act on the distinction.
+ */
+export function resolveRepoRoot(cwd) {
+    const probe = probeRepoRoot(cwd);
+    if (probe.kind === 'repository')
+        return probe.root;
+    throw new HarnessError(probe.message);
+}
+/**
+ * What `HEAD` names in this checkout — the three answers of {@link HeadProbe}, from the same two
+ * probes {@link currentBranch} is implemented on top of, and **no third git invocation**.
+ *
+ * {@link GIT_CURRENT_BRANCH_ARGS} answers first, and the literal `HEAD` it prints for a detached
+ * checkout is what `'detached'` is decided on; {@link GIT_SYMBOLIC_HEAD_ARGS} answers only where
+ * that one throws, which is the repository whose `HEAD` is unborn. It never throws itself; a caller
+ * that needs the repository at all has already resolved its root through {@link resolveRepoRoot},
+ * which does throw.
+ *
+ * It lives here rather than in the generator that wants it, for the reason in the module header:
+ * every repository-state probe has one definition and one place a review checks that it stayed
+ * read-only.
+ */
+export function checkedOutBranch(repoRoot) {
+    let output;
+    try {
+        output = runGit(GIT_CURRENT_BRANCH_ARGS, repoRoot);
+    }
+    catch {
+        // An unborn HEAD is not a detached one: `symbolic-ref` still names the branch the first commit
+        // will create. A detached HEAD never reaches here — the probe above succeeds and prints the
+        // literal `HEAD` — and a repository the second probe cannot answer for either is `'none'`.
+        try {
+            output = runGit(GIT_SYMBOLIC_HEAD_ARGS, repoRoot);
+        }
+        catch {
+            return { kind: 'none' };
+        }
+        return output === '' ? { kind: 'none' } : { kind: 'branch', name: output };
+    }
+    // `HEAD` is what the first probe prints for a detached checkout: a literal, not a branch name.
+    if (output === 'HEAD')
+        return { kind: 'detached' };
+    return output === '' ? { kind: 'none' } : { kind: 'branch', name: output };
+}
+/**
+ * The name of the checked-out branch, or `undefined` when there is not one to name — the collapsing
+ * view over {@link checkedOutBranch}, for the caller that cannot act on *why* there is no name.
+ *
+ * `'detached'` and `'none'` both come back as `undefined`, because they mean the same thing to
+ * `doctor`'s `--test-notification` probe: no branch to report here, and the configured
+ * `defaultBranch` stands in. The caller that can act on the difference is `init`'s default-branch
+ * detection, which asks {@link checkedOutBranch} directly so its note can name which one it met.
+ */
+export function currentBranch(repoRoot) {
+    const probe = checkedOutBranch(repoRoot);
+    return probe.kind === 'branch' ? probe.name : undefined;
+}
+/**
+ * The checkouts git reports for this repository, one line each, or `undefined` when the probe did
+ * not answer — a git too old for the subcommand, a repository state it refuses to list, or no `git`
+ * at all.
+ *
+ * `undefined` and an empty answer are the same result on purpose: `git worktree list` prints the
+ * main working copy even when there is only one, so nothing to report means the probe did not work
+ * rather than that there are no checkouts. The one caller is `doctor`, which asks whether
+ * worktree-based runs can be prepared here and reports a `warn` either way, so the distinction
+ * between the ways it can fail buys nothing.
+ *
+ * It lives here rather than in that check, for the reason in the module header: every
+ * repository-state probe has one definition and one place a review checks that it stayed read-only.
+ */
+export function worktreeList(repoRoot) {
+    let output;
+    try {
+        output = runGit(GIT_WORKTREE_LIST_ARGS, repoRoot);
+    }
+    catch {
+        return undefined;
+    }
+    const lines = output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '');
+    return lines.length === 0 ? undefined : lines;
+}
+/**
+ * Whether this repository has any commit at all.
+ *
+ * **An unborn HEAD is the answer, not an error**, so every non-zero status is `false`: a freshly
+ * `git init`'d repository is the normal state at the moment `init` runs, and the callers that ask
+ * — the first-commit path and the default-branch check — both have something correct to do with a
+ * `false` and nothing correct to do with a throw.
+ */
+export function hasCommits(repoRoot) {
+    try {
+        runGit(GIT_HAS_COMMITS_ARGS, repoRoot);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create a repository in `dir` — the CLI's one call to `git init`, made only after the adopter has
+ * said yes (a flag, or a prompt that has one).
+ *
+ * Issued bare, for the reason on {@link GIT_INIT_ARGS}: the branch name is git's own
+ * `init.defaultBranch` to decide, and detection reads it back rather than the CLI dictating it.
+ *
+ * Throws a `HarnessError` naming `dir` and git's own stderr. This one throws, unlike
+ * {@link commitAll}, because nothing has been wired yet when it runs: a repository that could not
+ * be created has no partial success to preserve.
+ */
+export function initRepository(dir) {
+    try {
+        runGit(GIT_INIT_ARGS, dir);
+    }
+    catch (error) {
+        throw new HarnessError(`git init failed in ${dir}: ${gitFailureDetail(error)}`);
+    }
+}
+/**
+ * Stage everything and commit it: `add -A`, then `commit -m <message>` with the message as a single
+ * argv element.
+ *
+ * **This never throws.** Its caller has already written the adopter's wiring by the time it runs, so
+ * a throw here would report a failed command for a run that succeeded — the files are on disk and
+ * correct either way. A refusal git can state (`Author identity unknown`, an empty index, a hook
+ * that rejected it) comes back as `committed: false` with git's own trimmed stderr, which the
+ * caller warns with and carries on.
+ */
+export function commitAll(repoRoot, message) {
+    try {
+        runGit(['add', '-A'], repoRoot);
+    }
+    catch (error) {
+        return { committed: false, reason: gitFailureDetail(error) };
+    }
+    try {
+        runGit(['commit', '-m', message], repoRoot);
+    }
+    catch (error) {
+        return { committed: false, reason: gitFailureDetail(error) };
+    }
+    return { committed: true };
+}
+/**
+ * The branch `origin/HEAD` points at, with the `origin/` prefix stripped — the first and most
+ * authoritative rung of default-branch detection, because it is the remote's own answer rather than
+ * a guess from this checkout.
+ *
+ * `undefined` on any non-zero status, which covers both the repository with no remote and the
+ * remote whose HEAD was never fetched (a clone made with `--no-tags`, a manually added remote).
+ * Neither is a fault: the caller falls through to the next rung.
+ */
+export function remoteHeadBranch(repoRoot) {
+    let output;
+    try {
+        output = runGit(GIT_REMOTE_HEAD_ARGS, repoRoot);
+    }
+    catch {
+        return undefined;
+    }
+    const branch = output.startsWith(ORIGIN_PREFIX) ? output.slice(ORIGIN_PREFIX.length) : output;
+    return branch === '' ? undefined : branch;
+}
+/**
+ * The configured `init.defaultBranch`, or `undefined` when it is unset — the last rung of
+ * default-branch detection, and the name git itself would have given a repository
+ * {@link initRepository} created.
+ *
+ * Unset is a non-zero status from `config --get`, which is why every failure collapses to
+ * `undefined` rather than being distinguished: there is nothing else this probe can fail at that
+ * the caller would treat differently.
+ */
+export function configuredInitDefaultBranch(repoRoot) {
+    let output;
+    try {
+        output = runGit(GIT_INIT_DEFAULT_BRANCH_ARGS, repoRoot);
+    }
+    catch {
+        return undefined;
+    }
+    return output === '' ? undefined : output;
+}
+/**
+ * The names of the remotes this repository has configured, in git's own order, or an empty list
+ * when it has none.
+ *
+ * **No remote is the answer, not an error**, the same discipline {@link hasCommits} states: a
+ * repository that has never had one is an ordinary state, and the caller — `doctor`'s remote check
+ * — grades that state itself. Every non-zero status therefore collapses to the empty list, because
+ * a probe that failed some other way leaves that caller with nothing different to do.
+ */
+export function configuredRemotes(repoRoot) {
+    let output;
+    try {
+        output = runGit(GIT_REMOTES_ARGS, repoRoot);
+    }
+    catch {
+        return [];
+    }
+    return output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '');
+}
+/** True when `ref` names something this repository can resolve. The ref is one argv element. */
+function refResolves(repoRoot, ref) {
+    try {
+        runGit([...GIT_VERIFY_REF_ARGS, ref], repoRoot);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Where a branch name resolves in this repository: a local branch, a remote-tracking ref under
+ * `origin/`, or nowhere.
+ *
+ * Both spellings are checked because a configured integration line is legitimately present as
+ * either — a fresh clone with a single checked-out branch has the rest only as remote-tracking
+ * refs, and a repository that has never had a remote has only local ones. `'none'` is the answer
+ * that means the configured name is wrong, and it is the only one a caller grades as a failure.
+ *
+ * The full ref names are built by string join and passed as **one argv element each** (module
+ * header, invariant 1). Prefixing with `refs/heads/` also means a branch name that starts with `-`
+ * can never be read as an option.
+ *
+ * It answers where a name resolves **first**, so it cannot be asked whether a remote-tracking ref
+ * exists: the ordinary repository has both spellings and reads `'local'` here. That question is
+ * {@link remoteTrackingBranchResolves}'.
+ */
+export function branchResolves(repoRoot, branch) {
+    if (refResolves(repoRoot, `refs/heads/${branch}`))
+        return 'local';
+    if (refResolves(repoRoot, `refs/remotes/${ORIGIN_PREFIX}${branch}`))
+        return 'remote';
+    return 'none';
+}
+/**
+ * Whether `origin/<branch>` is a remote-tracking ref in this repository.
+ *
+ * A separate question from {@link branchResolves}, not a narrowing of it: that one stops at the
+ * local spelling, which every checkout of its own integration line has, so it answers `'local'`
+ * exactly where this has to answer `true`. What reads this is the precondition
+ * `create-worktree.sh` branches a run's checkout from, and only the remote-tracking ref satisfies
+ * it — a local branch of the same name does not.
+ *
+ * The ref is built by string join and passed as **one argv element** (module header, invariant 1).
+ */
+export function remoteTrackingBranchResolves(repoRoot, branch) {
+    return refResolves(repoRoot, `refs/remotes/${ORIGIN_PREFIX}${branch}`);
+}
+/**
+ * How many commits `tipRef` has that `baseRef` does not — `rev-list --count <baseRef>..<tipRef>`,
+ * or `undefined` when the count could not be taken.
+ *
+ * **Read-only, and it issues no fetch**, so a caller's answer is the same offline and `doctor`'s
+ * "writes nothing beyond the writability probe's temp file" contract holds through it. The two refs
+ * are compared exactly as they stand in this repository; making them current is the caller's remedy
+ * to name, never this probe's to do.
+ *
+ * `undefined` covers every non-zero status — a ref that does not resolve, a range git read as
+ * ambiguous, no `git` at all — on the discipline {@link configuredRemotes} states: a probe that
+ * failed some other way leaves the caller with nothing different to do. It also covers output that
+ * is not a count, which no answered invocation produces and which no caller could act on either.
+ *
+ * The range is built by string join and passed as **one argv element** (module header, invariant 1),
+ * with {@link PATHSPEC_SEPARATOR} after it.
+ */
+export function commitsAhead(repoRoot, baseRef, tipRef) {
+    let output;
+    try {
+        output = runGit([...GIT_COUNT_RANGE_ARGS, `${baseRef}..${tipRef}`, PATHSPEC_SEPARATOR], repoRoot);
+    }
+    catch {
+        return undefined;
+    }
+    if (output === '')
+        return undefined;
+    const count = Number(output);
+    return Number.isInteger(count) && count >= 0 ? count : undefined;
+}
+/**
+ * Whether git excludes `repoRelativePath` in this working tree — `true` ignored, `false` not, and
+ * `undefined` when git did not answer.
+ *
+ * **The third value is not a boolean and must not be collapsed into one.** `git check-ignore
+ * --quiet` exits **0** when a rule matches, **1** when none does and **128** when it could not run
+ * at all, so reading the third status as either verdict would turn a broken invocation into an
+ * answer — which is exactly the fault `doctor`'s `ignore-rules` check exists to stop committing.
+ * Each caller decides what an unanswerable probe means for it: `ignore-rules` grades the
+ * `undefined` and says it did not measure, and `layer-drift` excludes only on a definite `true`, so
+ * a candidate git could not resolve stays in the report.
+ *
+ * The answer is the **effective** one — every ignore source in force here, and the index with them,
+ * so a path already tracked comes back `false` because `git add` of it succeeds. That is the
+ * question asked: whether a path the harness cares about is excluded right now, not which pattern
+ * in which file decided it. **Read-only**, like every probe above it: it resolves a name against
+ * rules and touches neither the index nor the working tree.
+ *
+ * The path is appended as **one argv element**, after {@link PATHSPEC_SEPARATOR} (module header,
+ * invariant 1).
+ */
+export function pathIsIgnored(repoRoot, repoRelativePath) {
+    try {
+        runGit([...GIT_CHECK_IGNORE_ARGS, repoRelativePath], repoRoot);
+        return true;
+    }
+    catch (error) {
+        return error?.status === 1 ? false : undefined;
+    }
+}
+//# sourceMappingURL=git.js.map

package/dist/core/git.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.js","sourceRoot":"","sources":["../../src/core/git.ts"],"names":[],"mappings":"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"}