@renaiss-shipflow/cli 0.27.7 → 0.27.9

package/dist/commands/pr.d.ts

@@ -14,22 +14,80 @@ export declare function buildShipFlowHeader(project: string, issueNumber?: numbe
 /** What `pr sync --keep-conflicts` prints as the resolution recipe. NEVER
  *  `git add -A`: the UNMERGED index state is the ONLY thing that makes git
  *  refuse to commit a file still containing `<<<<<<<`, and `add -A` clears
- *  exactly that. Stage the paths you actually resolved, then re-gate. */
-export declare const RESOLUTION_RECIPE: readonly string[];
+ *  exactly that. Stage the paths you actually resolved, then re-gate.
+ *
+ *  A FUNCTION of the base (issue #412, finding 3): the printed gate command has
+ *  to carry `--base`, because the moment `git rebase --continue` commits the
+ *  markers a bare `pr conflict-check` has nothing left to enumerate and reports
+ *  clean. This is also what step 5 of `references/conflict-resolution.md` tells
+ *  the agent to run, so the two now say the same thing.
+ *
+ *  `root` anchors the printed `git add` (see `anchoredGit`) so it runs from a
+ *  subdirectory too — the paths the operator substitutes come from the gate, and
+ *  those are repo-root-relative. Injected, not probed, so the recipe stays pure. */
+export declare function resolutionRecipe(baseRef: string, root?: string | null): readonly string[];
+/** The ONE place the gate's re-check invocation is spelled (PR #434 review).
+ *
+ *  `pr sync` printed a base-less `pr conflict-check` on both of its refusal
+ *  paths while `resolutionRecipe` — three lines away, in the same
+ *  command — threaded the base. That is the vacuous form this PR exists to stop
+ *  recommending: it makes the operator re-resolve a base the caller already
+ *  knows, and auto-resolution can land on a DIFFERENT ref than the one `pr sync`
+ *  actually rebased onto, so the re-check would certify a tree against the wrong
+ *  base. Every printed invocation now goes through here, so the base-less form
+ *  can't reappear in one message while the others are correct. Where no concrete
+ *  ref is in scope, pass the `origin/<base>` placeholder — never nothing. */
+export declare function recheckCommand(baseRef: string): string;
+/** A git command the operator can paste into ANY shell, at ANY depth in the
+ *  worktree (PR #434 review, finding 2).
+ *
+ *  The gate reports **repo-root-relative** paths — `gitPaths` pins its CWD to
+ *  `repoToplevel()` so enumeration and grep share one frame of reference — so a
+ *  printed `git add -- sub/app.ts` pasted from `sub/` resolves `sub/sub/app.ts`
+ *  and dies with `could not open directory 'sub/sub/'`. `-C <root>` puts the
+ *  printed command in the same frame the printed path is expressed in, which is
+ *  the only way one string can be correct from every CWD. (Under the default
+ *  `diff.relative=false` the un-anchored form was already wrong from a subdir;
+ *  anchoring makes every printed path-bearing command runnable, not just this
+ *  one.)
+ *
+ *  Root unknown → print the plain form. A `git -C '' …` would be worse than no
+ *  anchor, and a gate that cannot locate its own toplevel is already failing
+ *  loudly for that reason. */
+export declare function anchoredGit(root: string | null, args: string): string;
+/** The repo root to anchor a PRINTED command to, or `null` when it can't be
+ *  located. `repoToplevel()` throws by design (a gate that cannot find its tree
+ *  has proved nothing); a *hint string* must never be the thing that crashes the
+ *  process, so this degrades to the un-anchored form instead. */
+export declare function printedRoot(): string | null;
 /** One conflict-marker line found in a tracked file. */
 export interface ConflictMarkerHit {
     path: string;
     line: number;
     text: string;
 }
+/** What a `git grep -z -n` stream parse recovered.
+ *
+ *  `hits` are the marker lines of files that carry a REAL conflict. `paths` is
+ *  every path the parse read a well-formed record for — INCLUDING files whose
+ *  only match was a bare `=======`. The two are deliberately different sets, and
+ *  `paths` (never `hits`) is the parser's coverage claim: it is what the
+ *  authoritative files-with-matches pass is checked against in
+ *  `scanConflictMarkers`. Checking against `hits` instead would hard-block every
+ *  push over any file containing a lone 7-equals line — the parser is *designed*
+ *  not to trip on those, and `git grep -l` cannot tell one from a real conflict. */
+export interface ConflictMarkerParse {
+    hits: ConflictMarkerHit[];
+    paths: string[];
+}
 /** The `git grep -E` pattern for the four marker families git can leave behind
  *  (`<<<<<<<`, `|||||||` in diff3 mode, `=======`, `>>>>>>>`). */
 export declare const CONFLICT_MARKER_PATTERN = "^(<{7}|\\|{7}|={7}|>{7})( |$)";
 /**
- * Parse `git grep -z -n` output into marker hits: a file counts as conflicted when
- * it has a `<<<<<<<` start **OR** a `>>>>>>>` end. A bare `=======` (or a lone
- * diff3 `|||||||`) never trips the gate on its own — that's the only line a
- * changelog or a rule of prose plausibly starts with.
+ * Parse `git grep -z -n` output: a file counts as conflicted when it has a
+ * `<<<<<<<` start **OR** a `>>>>>>>` end. A bare `=======` (or a lone diff3
+ * `|||||||`) never trips the gate on its own — that's the only line a changelog
+ * or a rule of prose plausibly starts with.
  *
  * This used to require BOTH arms (the "triad rule"), which let a half-resolved
  * file through: delete one arm, leave `<<<<<<< HEAD` behind, and since `git add`
@@ -49,8 +107,23 @@ export declare const CONFLICT_MARKER_PATTERN = "^(<{7}|\\|{7}|={7}|>{7})( |$)";
  * (PR #394 review). git prints colons in paths unquoted, so no colon-based
  * parse can be correct; NUL is the only unambiguous delimiter.
  *
+ * The walk is POSITIONAL, not a `split("\0")` field walk (issue #412, finding 1).
+ * A `split` treats fields as fixed pairs, so ONE extra NUL anywhere in the stream
+ * shifts parity for everything after it. A matched LINE can legitimately contain
+ * a NUL: git's binary heuristic only inspects the first 8000 bytes, so a >8 KB
+ * text file with an embedded NUL further in is scanned as text and printed
+ * verbatim. Measured: a `======= \0Y` line in a 9.9 KB file desynced the walk and
+ * dropped EVERY later file in sorted-path order — a victim with three live
+ * markers reported CLEAN. `--text` does not fix this; the NUL is still inside the
+ * matched line. Reading each field to its own terminator does: a path cannot
+ * contain a NUL (POSIX), so field 1 ends at the 1st NUL and field 2 at the 2nd,
+ * and a grep match is exactly one line, so the text ends at the next LF —
+ * whatever bytes it contains.
+ *
  * Pure + testable (`pr sync` shells out to gh+git and has no harness).
  */
+export declare function parseConflictMarkerRecords(out: string): ConflictMarkerParse;
+/** The marker hits alone — see `parseConflictMarkerRecords` for the coverage set. */
 export declare function parseConflictMarkerGrep(out: string): ConflictMarkerHit[];
 /** The outcome of enumerating paths for the gate. `ok: false` means the git
  *  command FAILED — which is emphatically NOT the same as "nothing changed".
@@ -67,29 +140,137 @@ export interface PathEnumeration {
  *  pathspecs — which would silently drop that file from the marker scan.
  *  Failure is REPORTED (`ok: false`), never flattened into an empty result:
  *  `scanConflictMarkers([])` is `[]`, so a swallowed error would have read as a
- *  clean tree and let the push through (PR #394 review). */
+ *  clean tree and let the push through (PR #394 review).
+ *
+ *  Runs from `repoToplevel()`, and that is LOAD-BEARING (issue #412, finding 4 —
+ *  PR #434 review). Enumeration and grep are a PAIR and must share one frame of
+ *  reference: `git grep` always runs from the root (see `grepConflictMarkers`),
+ *  so the paths handed to it must be root-relative too. `git diff --name-only`
+ *  honours `diff.relative` — set to true (config, or a `--relative` in the
+ *  command) it emits CWD-relative paths AND drops everything outside the CWD.
+ *  Run the gate from `sub/` and `sub/app.ts` was enumerated as `app.ts`, which
+ *  the root-anchored grep matched nothing for: exit 1 ("no match") read as a
+ *  CLEAN tree over three live markers. Pinning the CWD here fixes it at the
+ *  source, for every call site, and needs no `--no-relative` flag (git ≥2.30):
+ *  at the toplevel, relative and absolute are the same thing.
+ *
+ *  A root that cannot be located degrades to `ok: false` rather than throwing —
+ *  callers rely on this never throwing (`pr sync`'s best-effort listing), and a
+ *  gate that cannot find its tree has enumerated nothing, which is exactly what
+ *  `ok: false` means. */
 export declare function gitPaths(cmd: string): PathEnumeration;
 /** Files this branch changed relative to `baseRef` — the only place a rebase
  *  can have left markers, so the gate never scans (or trips on) unrelated files. */
 export declare function changedPaths(baseRef: string): PathEnumeration;
-/** Scan the working tree for leftover conflict markers in `paths`. `git grep`
- *  exits 1 on "no match" (clean) — any OTHER failure is rethrown so the gate
- *  fails CLOSED rather than silently reporting a clean tree.
- *
- *  `--literal-pathspecs` is load-bearing: `shellQuote` stops the SHELL, but git
- *  still parses each argument as a PATHSPEC. A tracked file whose name begins
- *  with `:` is read as pathspec magic and matches nothing — `git grep` then
- *  exits 1 ("no match") and the file is silently UNSCANNED rather than erroring
- *  (PR #394 review). Note the flag is a main-git option, so it must precede the
- *  subcommand: `git grep --literal-pathspecs` is rejected as an unknown option.
- *
- *  `-z` is load-bearing too: it makes git delimit `path\0line\0text`, so a path
- *  containing `:<digits>:` can't be mis-split by the parser and silently dropped
- *  from the results (PR #394 review — see `parseConflictMarkerGrep`). */
-export declare function scanConflictMarkers(paths: string[]): ConflictMarkerHit[];
+/** The repository root, as the CWD every gate git command runs FROM — BOTH the
+ *  `git diff` that enumerates (`gitPaths`) and the `git grep` that scans
+ *  (`grepConflictMarkers`).
+ *
+ *  Load-bearing (issue #412, finding 4): `git grep` resolves pathspecs relative
+ *  to the CWD, so paths enumerated in one frame and grepped in another match
+ *  nothing — `git grep` exits 1 ("no match"), which the gate reads as CLEAN over
+ *  live markers. Anchoring only one half is worse than anchoring neither: under
+ *  `diff.relative=true` the two halves then disagree where before they at least
+ *  agreed (PR #434 review). It must be a toplevel CWD and NOT a `:(top)`
+ *  pathspec prefix: `--literal-pathspecs`, which the `:leading.ts` regression
+ *  requires, disables pathspec magic outright. Failure to locate the root throws
+ *  — a gate that cannot find the tree it is certifying has proved nothing.
+ *  (`gitPaths` catches that throw and degrades to `ok: false`, its own way of
+ *  saying the same thing.) */
+export declare function repoToplevel(): string;
+/** Split paths into `git grep`-sized batches, budgeting the QUOTED byte length
+ *  actually spent on the command line. A single path over budget still gets its
+ *  own chunk rather than looping forever. Pure, so the budgeting is testable
+ *  without building a 100 KB fixture. */
+export declare function chunkPathspecs(paths: string[], maxFiles?: number, maxBytes?: number): string[][];
+/**
+ * Scan the working tree for leftover conflict markers in `paths`.
+ *
+ * Two passes per chunk, and the split is the point (issue #412, finding 1):
+ *
+ * 1. `-l` — the AUTHORITY on WHICH files match. `-z -l` emits NUL-terminated
+ *    paths, so `split("\0")` is exact and no parse can lose a file.
+ * 2. `-n` — the line/text DETAIL, positionally parsed.
+ *
+ * Then fail CLOSED if the `-l` set is not covered by the paths the `-n` parse
+ * recovered: the detail pass lost a file the authority saw, so this scan cannot
+ * certify anything. The comparison is against `parse.paths` — every path a
+ * record was read for — and emphatically NOT against the filtered `hits`. `-l`
+ * cannot distinguish a bare `=======` from a real conflict and the parser
+ * deliberately does not trip on one, so checking `hits` would make any file
+ * containing a lone 7-equals line permanently unpushable.
+ */
+export declare function scanConflictMarkers(paths: string[], budget?: {
+    maxFiles?: number;
+    maxBytes?: number;
+}): ConflictMarkerHit[];
+/** Files the `-l` authority matched that the `-n` parse recovered no record for.
+ *  Non-empty ⇒ the scan lost coverage and must fail closed.
+ *
+ *  ⚠️ `recovered` is `ConflictMarkerParse.paths` — every path a record was read
+ *  for — and NEVER the filtered hits. `git grep -l` matches a bare `=======` the
+ *  same as a real `<<<<<<<`, while the parser deliberately does not trip on a
+ *  lone separator. Comparing against hits would therefore report every file
+ *  containing a single 7-equals line as "lost", hard-blocking its push forever:
+ *  a repo-wide denial of service on the gate, invisible today only because this
+ *  repo happens to contain zero such lines. */
+export declare function unrecoveredMatches(matched: string[], recovered: string[]): string[];
 /** Which rebase state git has left in this worktree, if any. Reads the
  *  worktree's own git dir, so it is correct inside `git worktree` checkouts. */
 export declare function rebaseInProgress(): "rebase-merge" | "rebase-apply" | null;
+/** The commit an in-flight rebase is replaying ONTO, read from the rebase state
+ *  git itself wrote (`.git/rebase-merge/onto` or `.git/rebase-apply/onto`).
+ *  `rebaseInProgress()` already names the directory, so this is a file read. */
+export declare function rebaseOnto(): string | null;
+/** The remote's default branch, from `refs/remotes/origin/HEAD`. */
+export declare function originHeadRef(): string | null;
+/** Last-ditch default branch when `origin/HEAD` was never set (a plain `git
+ *  clone --depth` or a hand-added remote leaves it unset). */
+export declare function defaultBranchRef(): string | null;
+/** Which ref `conflict-check` diffs against, and where that ref came from. */
+export type BaseSource = "rebase-onto" | "origin-head" | "default-branch" | "explicit";
+export interface ResolvedBase {
+    base: string;
+    source: BaseSource;
+}
+/**
+ * Resolve the base `conflict-check` scans against (issue #412, finding 3).
+ *
+ * Without a base the check is VACUOUS at exactly the moment it matters. Once
+ * `git rebase --continue` has COMMITTED the markers, nothing is unmerged and
+ * nothing differs from HEAD, so both of the local enumeration sources are empty
+ * and the gate prints `{"clean":true,"scanned":0}` and exits 0 — over a tree
+ * whose HEAD blob literally contains `<<<<<<< HEAD`. The same tree with
+ * `--base main` yields 3 hits and exit 8.
+ *
+ * Precedence, most-specific first:
+ *  1. `rebase-onto` — mid-rebase, the commit git is actually replaying onto is
+ *     the true base, whatever anyone typed.
+ *  2. `origin-head` / 3. `default-branch` — the repo's own default branch.
+ *  4. `explicit` — the operator's `--base`.
+ *
+ * NOT `@{upstream}`: that resolves to `origin/<same-branch>`, which is the
+ * branch's own remote copy and not the PR base at all — diffing a branch against
+ * itself is a vacuous scan wearing a base's clothes — and it is unset on any
+ * freshly created branch anyway.
+ *
+ * Ranking `explicit` LAST is deliberate and must stay that way: a stale `--base`
+ * flag must not override the commit git is actually replaying onto mid-rebase,
+ * and ranking it up would change which single ref `base` reports as covered.
+ *
+ * `--base` keeps its documented ADDITIVE contract at the call site: an explicit
+ * ref the precedence didn't pick is still scanned, it just isn't what gets
+ * reported as the resolved base — the caller reports the FULL set it diffed
+ * against as `bases`, so nothing scanned goes unnamed (PR #434 review). Pure
+ * (probes are injected) so the precedence is unit-testable without a rebase
+ * fixture.
+ */
+export declare function resolveScanBase(i: {
+    onto: string | null;
+    originHead: string | null;
+    defaultBranch: string | null;
+    explicit?: string;
+}): ResolvedBase | null;
 export type SyncEntryVerdict = {
     ok: true;
 } | {
@@ -103,11 +284,24 @@ export type SyncEntryVerdict = {
  * misleading `On branch "HEAD" but PR #N is "x"` and every later loop git op
  * failed. Each refusal names the state AND the exact command that clears it.
  * Pure (state is injected) so it's unit-testable without a git fixture.
+ *
+ * `base` is the ref the printed re-check names, and it must be CONCRETE (PR #434
+ * review, finding 1). This branch fires only when a rebase IS in progress, so
+ * the caller always has one — the rebase's own `onto`, else `origin/<the PR's
+ * base>` — and the `origin/<base>` placeholder printed here before was a command
+ * the operator could not run: `conflict-check --base 'origin/<base>'` fails to
+ * resolve the ref and exits 8 via `enumerationFailed`, i.e. the recovery hint
+ * itself reported "the gate proved nothing". The placeholder survives only as
+ * the last resort for a caller that truly has neither source.
+ *
+ * `root` anchors the printed `git add` for a subdirectory shell (`anchoredGit`).
  */
 export declare function syncEntryGuard(i: {
     rebase: "rebase-merge" | "rebase-apply" | null;
     currentBranch: string;
     head: string;
     number: number;
+    base?: string | null;
+    root?: string | null;
 }): SyncEntryVerdict;
 //# sourceMappingURL=pr.d.ts.map

package/dist/commands/pr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pr.d.ts","sourceRoot":"","sources":["../../src/commands/pr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmDzC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6fxD;AA+BD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGxE;AAED;;;kFAGkF;AAClF,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEjD;;;kFAGkF;AAClF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,aAAwB,GAAG,MAAM,CAOxI;AAID;;;yEAGyE;AACzE,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAK9C,CAAC;AAEF,wDAAwD;AACxD,MAAM,WAAW,iBAAiB;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAE/E;kEACkE;AAClE,eAAO,MAAM,uBAAuB,kCAAkC,CAAC;AAKvE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,EAAE,CA2BxE;AAED;;4EAE4E;AAC5E,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,mEAAmE;IACnE,EAAE,EAAE,OAAO,CAAC;IACZ,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;4DAK4D;AAC5D,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAOrD;AAED;oFACoF;AACpF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAE7D;AAED;;;;;;;;;;;;;yEAayE;AACzE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,CAaxE;AAED;gFACgF;AAChF,wBAAgB,gBAAgB,IAAI,cAAc,GAAG,cAAc,GAAG,IAAI,CAUzE;AAED,MAAM,MAAM,gBAAgB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7E;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE;IAChC,MAAM,EAAE,cAAc,GAAG,cAAc,GAAG,IAAI,CAAC;IAC/C,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,gBAAgB,CAiBnB"}
+{"version":3,"file":"pr.d.ts","sourceRoot":"","sources":["../../src/commands/pr.ts"],"names":[],"mappings":"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"}