@bevel-software/platform-core-backend 0.1.0

package/dist/modules/workflow/git/git.service.d.ts

@@ -0,0 +1,427 @@
+import type { AuthUser, BranchInfo, CommitAttribution, IGitService, PrFileStatus, PullRequestFile, ShareChangesRequest, WorkingTreeStatus } from '@bevel-software/platform-shared';
+import type { WorkspaceService } from '../../workspace/workspace.service.js';
+import type { WorkflowHooks } from '../workflow-hooks.js';
+import type { IAccessControl } from '../../access/access-control.interface.js';
+import { WorkspaceMutex } from './mutex.js';
+import { PROTECTED_BRANCHES } from './branch-name.js';
+/**
+ * Git parses `--author="Name <email>"` by scanning for the last `<` and `>` and
+ * taking everything before the `<` as the name. Stray angle brackets, newlines, or
+ * carriage returns in either field break that parser or let a caller forge a
+ * different author line. Reject rather than try to escape.
+ */
+/**
+ * Parse the NUL-delimited output of `git status --porcelain=v1 -z` into a
+ * deduplicated list of paths the next commit would include. For a rename /
+ * copy entry the record spans two NUL-separated fields (new-path, old-path);
+ * we keep the new path and discard the old one.
+ */
+export declare function parsePorcelainZ(stdout: string): string[];
+export declare class GitService implements IGitService {
+    private readonly workspaceService;
+    /**
+     * Workflow lifecycle hooks. This service only consults the ADVISORY
+     * `commitValidation` hooks (registered by the enterprise kb module in the
+     * composition root — the constructor-injected `IKbValidator` this
+     * replaced). No hooks registered = no commit-time validation, which is
+     * safe because validation is advisory and never blocks a commit.
+     */
+    private readonly hooks;
+    private readonly kbDirName;
+    private readonly mutex;
+    private readonly accessControl;
+    private readonly fetchLocks;
+    private readonly lastImplicitFetchAt;
+    private static readonly IMPLICIT_FETCH_TTL_MS;
+    private static readonly MAX_AHEAD_BEHIND_CONCURRENCY;
+    constructor(workspaceService: WorkspaceService, 
+    /**
+     * Workflow lifecycle hooks. This service only consults the ADVISORY
+     * `commitValidation` hooks (registered by the enterprise kb module in the
+     * composition root — the constructor-injected `IKbValidator` this
+     * replaced). No hooks registered = no commit-time validation, which is
+     * safe because validation is advisory and never blocks a commit.
+     */
+    hooks: WorkflowHooks, kbDirName: string, mutex?: WorkspaceMutex, accessControl?: IAccessControl | null);
+    /**
+     * "Does the pending-commits queue hold rows for this workspace?" — used by
+     * `statusInternal` to tell an expected dirty tree (queued saves still
+     * draining) from a genuinely orphaned one. Injected as a narrow probe via
+     * setter (not constructor) because the queue service is constructed after
+     * this one in the composition root; `null` (e.g. in tests) keeps the old
+     * always-warn behavior.
+     */
+    private pendingCommitsProbe;
+    setPendingCommitsProbe(probe: (workspaceId: string) => Promise<boolean>): void;
+    /**
+     * Mark a workspace as freshly fetched. Called by `WorkspaceService` right
+     * after a branch's clone is created — `git clone` already downloaded every
+     * ref, so the first `listBranches` can skip the redundant implicit
+     * `git fetch` (see `fetchOriginIfStale`).
+     */
+    noteWorkspaceFetched(workspaceId: string): void;
+    /**
+     * Run the registered ADVISORY commit-validation hooks at a commit site.
+     * Preserves the semantics of the injected validator this replaced: a
+     * `mustFix` report is logged (via `formatWarning`) but never blocks, and a
+     * hook that throws is caught and logged — we'd rather land the commit than
+     * refuse the save because a validator crashed. Each hook gets its own
+     * try/catch so one crashing hook can't silence another.
+     */
+    private runCommitValidationHooks;
+    /**
+     * Resolve write permission for a list of repo-relative paths against the
+     * access tree at a specific ref. Throws `AccessDeniedError` for the first
+     * path the caller lacks `write` on, with the eligible-roles + users
+     * payload attached so the frontend can render a useful refusal message.
+     *
+     * Always uses an at-ref lookup (never the working tree) so a user can't
+     * grant themselves access by editing `roles.yaml` / `access.md` locally.
+     * Callers pass:
+     *   - `HEAD` for commit / revert gates — the pre-operation state is the
+     *     authoritative source for whether the user can write these paths.
+     *   - `origin/<branch>` for push gates — the published state is the
+     *     authoritative source; local rebases or commit-tree manipulation
+     *     can't slip changes past this check.
+     *
+     * Bootstrap: if the ref doesn't carry usable config (no `roles.yaml` /
+     * malformed / first commit creating the system), `canWriteBatchAtRef`
+     * returns null and we treat that as "no rules in force yet" → allow.
+     * Once config exists at the ref, gating kicks in.
+     *
+     * `accessControl` is optional on the constructor so existing tests that
+     * don't exercise these paths can keep their stub WorkspaceService — when
+     * it's null we skip the check entirely (legacy behaviour, only the
+     * branch-name guards remain). Production wires it up via composition root.
+     */
+    private assertCanWriteAtRef;
+    status(workspaceId: string): Promise<WorkingTreeStatus>;
+    listBranches(workspaceId: string, opts?: {
+        freshFetch?: boolean;
+    }): Promise<BranchInfo[]>;
+    /**
+     * Run `git fetch --prune origin` outside the workspace mutex, with a short
+     * TTL so back-to-back callers (mount + dropdown-open + 30s poll) coalesce
+     * onto a single in-flight fetch instead of each waiting their turn behind
+     * the network round-trip. Failures (offline, bad auth, no remote) are
+     * logged and swallowed so the branch list still serves stale local data
+     * instead of returning 500.
+     *
+     * Safe to keep outside the mutex: fetch only writes remote-tracking refs
+     * and the object store, neither of which checkout/status/commit touch.
+     */
+    private fetchOriginIfStale;
+    createBranch(workspaceId: string, name: string, fromBase?: string): Promise<BranchInfo>;
+    deleteBranch(workspaceId: string, name: string, user: AuthUser, opts?: {
+        onlyIfNoRemote?: boolean;
+    }): Promise<void>;
+    /**
+     * True iff the given ref (e.g. `refs/heads/foo`, `refs/remotes/origin/foo`)
+     * exists in this workspace's clone. Wraps `git show-ref --verify --quiet`
+     * — exits 0 when the ref is present, 1 with no stderr when it's missing.
+     * Any other exit code / stderr means a real failure and is rethrown so
+     * "ref not found" can't silently mask filesystem / repo corruption.
+     *
+     * `this.git()` wraps execFile failures and stores the original exit code on
+     * `wrapped.exitCode` (not `.code`) — check the wrapped property name, or
+     * the "ref not found" path silently becomes "rethrow every show-ref error".
+     */
+    private refExists;
+    commit(workspaceId: string, user: AuthUser, req: ShareChangesRequest): Promise<CommitAttribution>;
+    /**
+     * Commit a single path — bypasses the one-file-per-change guard in
+     * `commit()` because the caller has already scoped the change to one
+     * path (typically the lock-release flow, where the lock itself
+     * guarantees the file is the only one whose edits this user owns).
+     *
+     * `git add <path>` then `git commit` — other dirty paths in the working
+     * tree are left alone. Validation + protected-branch access gating still
+     * run, since `path` could itself be `roles.yaml` / `access.md`.
+     *
+     * Returns `null` when the path has nothing to commit (no diff against
+     * HEAD, not untracked) — keeps lock-release idempotent on "I opened the
+     * editor but didn't actually change anything" flows.
+     */
+    /**
+     * Reset the file's working-tree state to HEAD — used when a write
+     * partially completed but the surrounding flow can't commit it
+     * (validator was advisory so this is rare, but op-throws + push-
+     * blocked-by-access-control still hit this path). Tracked files
+     * `git checkout HEAD --` reverts to the committed content; untracked
+     * files (a half-written new file) are deleted outright. Either way
+     * the working tree returns to a clean state so the next acquirer
+     * doesn't inherit half-finished bytes.
+     *
+     * Idempotent: a path that's already clean stays clean. Missing paths
+     * are silently ignored.
+     */
+    discardPath(workspaceId: string, relativePath: string): Promise<void>;
+    commitFile(workspaceId: string, user: AuthUser, relativePath: string, summary?: string, skipValidator?: boolean): Promise<CommitAttribution | null>;
+    /**
+     * Atomic multi-file commit — commits whatever is currently dirty in the
+     * working tree as ONE commit attributed to `user`, then returns its
+     * attribution (or null when the tree is clean — idempotent re-apply). The
+     * multi-file sibling of `commit()`: same `git add -A` + commit, but WITHOUT
+     * the one-file-per-change guard — the caller has assembled + written + validated
+     * a batch (bulk node upload; the role-rename rewrite via `LockingFilesystem`).
+     *
+     * Deliberately does NOT write file content itself — disk writes are the
+     * caller's job. This is the git layer: it only stages + commits what is already
+     * on disk (the working tree is expected otherwise-clean under save=share, so
+     * `git add -A` stages exactly the caller's batch). Caller pushes separately
+     * (mirrors `commitFile` + `push`).
+     */
+    commitChanges(workspaceId: string, user: AuthUser, summary: string): Promise<CommitAttribution | null>;
+    push(workspaceId: string, user: AuthUser): Promise<void>;
+    /**
+     * Attempt a local merge of `origin/<targetBranch>` into the currently-
+     * checked-out branch. Used by the workflow module to auto-merge target →
+     * source when a change request is opened or refreshed (PLAN §1).
+     *
+     * Two outcomes:
+     *   - `{ kind: 'clean', alreadyUpToDate }` — merge succeeded, possibly as a
+     *     no-op (`alreadyUpToDate: true`) or with a new merge commit attributed
+     *     to `user` with a descriptive subject + body so reviewers can see why
+     *     the merge landed without inspecting the diff.
+     *   - `{ kind: 'conflicts', paths }` — `git merge` reported conflicts. The
+     *     merge is aborted to leave the working tree clean before returning
+     *     the conflicting paths so the caller can route to the agent for
+     *     resolution.
+     *
+     * Requires the source branch to already be checked out and the working
+     * tree clean — both refused with structured errors before any git op runs.
+     */
+    mergeFromOrigin(workspaceId: string, sourceBranch: string, targetBranch: string, user: AuthUser): Promise<{
+        kind: 'clean';
+        alreadyUpToDate: boolean;
+    } | {
+        kind: 'conflicts';
+        paths: string[];
+    }>;
+    /**
+     * Merge a change request locally and publish it to the target branch — the
+     * provider-agnostic replacement for `gh pr merge`. Runs in the *base* branch's
+     * workspace: reset to the published base tip, merge the source's published
+     * tip as a `--no-ff` commit authored by the human triggerer, and push.
+     *
+     * Serialized per base workspace via the mutex, with a bounded retry: if the
+     * push is rejected because the base advanced (a concurrent merge), we reset to
+     * the new base and re-merge on top of it. Conflicts are deterministic — they
+     * return immediately (no retry) so the caller can route into resolution.
+     *
+     * Returns the merge commit SHA, or the conflicting paths.
+     */
+    mergeChangeRequest(baseWorkspaceId: string, sourceBranch: string, targetBranch: string, commit: {
+        subject: string;
+        body: string;
+    }, user: AuthUser): Promise<{
+        kind: 'merged';
+        sha: string;
+    } | {
+        kind: 'conflicts';
+        paths: string[];
+    }>;
+    /** Conflicted paths from a half-done merge, parsed from porcelain status. */
+    private conflictedPaths;
+    /**
+     * Paths changed in commits that exist locally but not on the upstream ref —
+     * i.e. exactly what the next `push` would publish. Falls back to "every
+     * commit not reachable from any remote ref" when there's no upstream yet
+     * (first push).
+     */
+    private unpushedTouchedPaths;
+    fetch(workspaceId: string): Promise<void>;
+    /**
+     * Collapse the clone's drifted tracking config back to one fetch refspec and
+     * one upstream ref, then refresh `refs/remotes/origin/<branch>` through an
+     * explicit refspec — never touching the shared `FETCH_HEAD`. Returns the ref
+     * the caller should operate on.
+     *
+     * Both halves matter, and neither is sufficient alone:
+     *
+     * - The self-heal. A multi-valued `branch.<name>.merge` makes every bare
+     *   fetch in this clone write more than one *for-merge* FETCH_HEAD entry,
+     *   which is the ammunition behind the failure below; a duplicated
+     *   `remote.origin.fetch` refspec is the same class of drift (see
+     *   `clone-config.ts`). `--replace-all` collapses either back to the single
+     *   value the clone was created with. Best effort — the fetch names its refs
+     *   explicitly, so a failure here is harmless.
+     *
+     * - Never reading or writing `FETCH_HEAD`. `git pull` is a two-step
+     *   operation — fetch, then read the rebase target out of `.git/FETCH_HEAD`
+     *   — and `FETCH_HEAD` is a single mutable file shared by every git process
+     *   in the clone. This service is not the only writer: `fetchOriginIfStale`
+     *   (outside the workspace mutex, see `listBranches`) and
+     *   `WorkspaceService.ensureRemotesFetched` (outside it entirely, driven by
+     *   the CR-list poll) both run bare `git fetch --prune origin`, and a bare
+     *   fetch writes one for-merge entry per `branch.<name>.merge` value. Let one
+     *   of those land in the window between the pull's own fetch and its read, on
+     *   a clone whose merge config has drifted to two values, and pull sees two
+     *   merge heads and dies with "Cannot rebase onto multiple branches" — the
+     *   reported failure. (Measured: ~40% of refreshes with one concurrent fetch
+     *   loop. The drifted config alone never breaks it — an explicit
+     *   `pull --rebase origin <branch>` survives every drift shape on its own.)
+     *
+     * So: fetch with an explicit destination refspec, which updates
+     * `refs/remotes/origin/<branch>` regardless of any `remote.origin.fetch`
+     * drift, and let the caller name that ref. `--no-write-fetch-head` (git
+     * 2.29+, asserted at boot by `git-version.ts`) keeps this refresh from
+     * perturbing anyone else's `FETCH_HEAD` in turn. Nothing here reads shared
+     * mutable state, so no concurrent git process can steer or break it.
+     *
+     * Shared by the two refresh paths (`pull`, `resetToRemote`) so they can't
+     * drift apart — which is precisely the failure class this guards against.
+     */
+    private refreshRemoteBranchRef;
+    pull(workspaceId: string): Promise<void>;
+    /**
+     * Hard-reset the workspace's checked-out branch to `origin/<branch>`, fetching
+     * first. This is the break-glass primitive behind roles.yaml recovery: it
+     * makes the local clone EXACTLY match origin, discarding any local divergence
+     * (e.g. a half-finished recovery commit from a prior failed push, or commits
+     * the clone was behind on). The caller then writes its fix on top of the
+     * current origin tip, so the follow-up push fast-forwards instead of being
+     * rejected non-fast-forward.
+     *
+     * Destructive by design and intentionally NOT gated on the protected-branch
+     * rule — it only ever moves the LOCAL ref to match origin (no remote mutation),
+     * and recovery must work precisely on the protected default branch. Under
+     * save=share there is no precious unpushed local work to lose (every save
+     * auto-pushes); the one exception is a failed recovery commit, which the
+     * caller re-creates.
+     */
+    resetToRemote(workspaceId: string, branch: string): Promise<void>;
+    resolveForkBase(workspaceId: string, branch: string): Promise<string | null>;
+    /**
+     * Count commits on `branch` that aren't on `baseBranch`. Identical to the
+     * "ahead" half of `tryAheadBehind` but exposed as a public method because
+     * background callers (the routine runner) need to gate "open a CR or
+     * clean the branch up?" on it. Returns 0 when either ref can't be
+     * resolved — a missing branch can't possibly be ahead of anything, and
+     * misreporting as `> 0` would block legitimate cleanup.
+     */
+    countCommitsAhead(workspaceId: string, branch: string, baseBranch: string): Promise<number>;
+    /**
+     * Whether `head` and `origin/<base>` have any common ancestor. False when
+     * `head` is an orphan branch or was created from an unrelated history —
+     * GitHub refuses PRs in that state with a `no history in common` error,
+     * so PR creation pre-flights this and hands off to the agent on false.
+     */
+    haveSharedHistory(workspaceId: string, base: string, head: string): Promise<boolean>;
+    diffStat(workspaceId: string, base?: string): Promise<string[]>;
+    pendingChanges(workspaceId: string): Promise<string[]>;
+    /**
+     * Repo-relative paths of every VCS-tracked file (NUL-delimited, so paths with
+     * spaces or bracketed prefixes survive intact). Untracked / ignored files are
+     * excluded — the caller gets exactly the working tree's committed contents.
+     */
+    listTrackedFiles(workspaceId: string): Promise<string[]>;
+    revertCommit(workspaceId: string, user: AuthUser, sha: string): Promise<CommitAttribution>;
+    logForFile(workspaceId: string, relativePath: string, limit?: number): Promise<CommitAttribution[]>;
+    diffFileAtCommit(workspaceId: string, relativePath: string, sha: string): Promise<string>;
+    diffFileBetweenBranches(workspaceId: string, relativePath: string, fromBranch: string, toBranch: string): Promise<string>;
+    /**
+     * Head/base commit SHAs for a change request, computed locally — no provider
+     * API. `head` is the source branch tip, `base` the target branch tip, both
+     * resolved on `origin/*` after a fetch so a force-push is reflected. These are
+     * what approvals pin against and what the diff range is built from.
+     */
+    resolvePrShas(workspaceId: string, baseBranch: string, headBranch: string): Promise<{
+        baseSha: string;
+        headSha: string;
+    }>;
+    /**
+     * The changed-file list for a change request, computed locally via three-dot
+     * (merge-base) diff — the same semantics a GitHub PR shows. Replaces the
+     * `gh api …/pulls/:n/files` call so any git host works.
+     *
+     * `--name-status` + `--numstat` (both rename-aware via `-M`) drive the file
+     * list, statuses, and +/- counts; per-file patches are generated for up to
+     * `patchCap` files (default 400) — beyond that `patch` is left undefined,
+     * exactly like the old API's binary/oversized files (the UI renders those with
+     * no inline diff). Patch generation is skipped for binary files.
+     */
+    changedFilesForPr(workspaceId: string, baseBranch: string, headBranch: string, opts?: {
+        patchCap?: number;
+    }): Promise<PullRequestFile[]>;
+    /**
+     * Just the repo-relative paths changed by a change request (three-dot), no
+     * patches — the cheap version used to build CR-list summaries and owner
+     * routing. `changedFilesForPr` is the full version with statuses + diffs.
+     */
+    changedPathsForPr(workspaceId: string, baseBranch: string, headBranch: string): Promise<string[]>;
+    /** Fetch the two branches a CR spans so origin refs reflect the latest push. */
+    private fetchPrRefs;
+    /** Unified-diff patch for one file across the CR range (rename-aware). */
+    private filePatchForPr;
+    /**
+     * Strip the `knowledge-base/` prefix from a workspace-relative path so
+     * it lines up with where git actually runs (`cwd = repoDir`, i.e. inside
+     * `knowledge-base/`). The frontend stores `openFilePath` as a
+     * workspace-relative path including that prefix because the file viewer
+     * reads/writes through `WorkspaceService.readFile`, which resolves from
+     * the workspace root. Git pathspecs, on the other hand, are resolved from
+     * cwd — so without this normalization `git diff -- knowledge-base/X`
+     * silently looks for `knowledge-base/knowledge-base/X` and returns
+     * nothing, which the UI renders as "identical".
+     *
+     * No-op for paths already repo-relative (the agent tools and tests pass
+     * those directly).
+     */
+    private stripRepoPrefix;
+    /**
+     * Resolve a branch name to a concrete ref the local clone knows about.
+     * Tries the local head first, falls back to the matching remote-tracking
+     * ref. The workspace clone fetches all remotes on creation, so protected
+     * branches are reachable through `origin/` even when the user has never
+     * personally checked them out.
+     */
+    private resolveBranchRef;
+    private statusInternal;
+    private currentBranch;
+    /**
+     * Ahead/behind of `ref` (a full ref like `refs/heads/foo` or
+     * `refs/remotes/origin/foo`). When the branch exists locally (`hasLocal`),
+     * prefer its configured upstream; otherwise — or when no upstream is set —
+     * fall back to the nearest protected branch on origin, picking whichever
+     * minimises "ahead" as a proxy for the fork point.
+     */
+    private aheadBehindForBranch;
+    private tryAheadBehind;
+    /**
+     * Read a repo-relative file's contents at an arbitrary git ref (a branch,
+     * `origin/<branch>`, or a sha) WITHOUT checking it out. Returns `null` when
+     * the path does not exist at that ref (mirrors the access resolver's
+     * `showAtRef`) — the caller distinguishes "absent" from "present but empty".
+     * Read-only: `git show <ref>:<path>` never mutates the working tree.
+     */
+    readFileAtRef(workspaceId: string, ref: string, repoRelativePath: string): Promise<string | null>;
+    private repoDir;
+    private isPathUntracked;
+    private git;
+}
+interface NameStatusEntry {
+    status: PrFileStatus;
+    path: string;
+    previousPath?: string;
+}
+/**
+ * Parse `git diff -M -z --name-status` output. NUL-separated tokens: each record
+ * is `<statusLetter>\0<path>`, or for a rename/copy `<Rxxx|Cxxx>\0<old>\0<new>`.
+ */
+export declare function parseNameStatusZ(out: string): NameStatusEntry[];
+interface NumstatEntry {
+    additions: number;
+    deletions: number;
+    isBinary: boolean;
+}
+/**
+ * Parse `git diff -M -z --numstat` output, in the SAME file order as
+ * `--name-status` (both driven by `-M` over the same range). Each record is
+ * `<add>\t<del>\t<path>` for a normal change, or `<add>\t<del>\t\0<old>\0<new>`
+ * for a rename (empty path segment before the two NUL-separated names). Binary
+ * files report `-` for both counts.
+ */
+export declare function parseNumstatZ(out: string): NumstatEntry[];
+export { PROTECTED_BRANCHES };
+//# sourceMappingURL=git.service.d.ts.map

package/dist/modules/workflow/git/git.service.d.ts.map

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