@quickchatai/pi-quickreview 0.0.0-stage → 1.1.0

package/dist/src/plankey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plankey.js","sourceRoot":"","sources":["../../src/plankey.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,wEAAwE;AACxE,0FAA0F;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;sEACsE;AACtE,MAAM,UAAU,OAAO,CAAC,KAAc;IACpC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACvF,CAAC"}

package/dist/src/planner.d.ts

@@ -0,0 +1,375 @@
+import type { CoreConfig } from "./reviewconfig.js";
+import { type Ecosystem } from "./ecosystem.js";
+import type { PrFileEntry } from "./githubcore.js";
+import type { HeuristicsExtension } from "./heuristics.js";
+import { type CiLinter } from "./lintconfig.js";
+import type { MigrationCollision } from "./migrations.js";
+import { type PrOwnedDelta, type PrOwnedDeltaFile } from "./prdelta.js";
+import type { PriorFindingsList } from "./priorfindings.js";
+import type { LedgerCarry, PassPlanEntry, PassTier, RoundDelta, RoundOrder, RoundRecoveryContext, RoundType } from "./types.js";
+/** A plan's lens names, each once, in plan order — the compatibility list
+ * the rounds table, the event log and every order carry (a lens with several
+ * rows, the sweep, once). */
+export declare function lensesOf(plan: readonly PassPlanEntry[]): string[];
+/** The head a round reviews: the prepared tree's, else the PR row's (a
+ * caller with no worktree seam). The one rule the round row, the posting key
+ * and the prompt all name their head by. */
+export declare function reviewedHeadOf(tree: Pick<PreparedTree, "head_sha"> | undefined, row: Pick<PlannedPr, "head_sha">): string;
+/**
+ * The tier the round's validator runs at: its own tier, the configured
+ * `validate_tier` under the profile's `min_tier` for it, whatever tier or
+ * effort any lens runs at. It is never raised to match a lens: a finding the
+ * validator cannot stand behind is kept as `doubted` in the findings record
+ * (never posted, shown in the TUI), not discarded, so a cheaper validator
+ * cannot make a stronger lens's finding vanish. Lens tiers are deliberately
+ * not an input.
+ */
+export declare function validatorTier(cfg: Pick<CoreConfig, "lenses" | "models">): PassTier;
+/**
+ * The tier a lens ADDED by the session runs at (the round templates' add
+ * rule): a risk pass exists only as `sol-high`; every other lens at `sol-med`,
+ * or at the profile's `min_tier` for it when that is higher.
+ */
+export declare function addTierOf(cfg: CoreConfig, lens: string): PassTier;
+/** The facts a prepared worktree hands the round — the tree's own, less
+ * where it lives (the app's worktree facts add the path). */
+export interface PreparedTree {
+    /** The sha the worktree is actually checked out at — the authority for the
+     * round. It is the just-fetched `refs/pull/<n>/head`, or the caller's
+     * `expectedHead` when that ref lags behind it. */
+    head_sha: string;
+    /** Branch the PR targets; "" when the caller did not supply one. */
+    base_ref: string;
+    /** Tip of base_ref at fetch time; "" when no base_ref was fetched. */
+    base_sha: string;
+    /** merge-base(base_sha, head_sha); "" when unavailable. */
+    merge_base: string;
+    /** Set when GitHub's `refs/pull/<n>/head` lagged the head the caller expected
+     * and the worktree holds that head instead: the stale commit the ref named. */
+    pull_ref_sha?: string;
+}
+/** The PR a round is planned for: the fields of its state row the plan reads. */
+export interface PlannedPr {
+    number: number;
+    head_sha: string;
+    title: string;
+}
+/** What `buildPassPlan` returns. */
+export interface PassPlan {
+    pass_plan: PassPlanEntry[];
+    addable_lenses: string[];
+    sweep_unswept: string[];
+    /** Files the behaviour-delta lens would read but its group cap left out —
+     * present only when the cap cut something, so a capped lens never reads
+     * as covering the change. */
+    behaviour_unread?: string[];
+}
+/** Deterministic per-round pass plan (agent = `${lens}--${tier}`):
+ * - risk passes are always "sol-high", single variant, not raisable;
+ * - pass-validate runs at validatorTier() — its own configured tier, never
+ *   raised to match a lens — is not raisable, and is always last;
+ * - every other selected lens gets the passTier() tier and may be raised to
+ *   any higher tier's variant (ascending order).
+ * addable_lenses = every known pass not already in the plan.
+ * The rows come back in launch order, slowest first (`slowestFirst`).
+ *
+ * The profile's per-lens tuning (`cfg.lenses`) wins over all of
+ * that: a `min_tier` floors the lens's row (and so its `raisable_to`) and the
+ * sweep rows; `enabled = false` removes a lens from the plan AND the addable
+ * list whatever selected it — the validator included, when the round
+ * has no validator row at all; `enabled = true` on a lever-gated lens switches
+ * it on whatever its `[review]` lever says. */
+export declare function buildPassPlan(cfg: CoreConfig, files: PrFileEntry[], intent?: {
+    title?: string | null;
+    body?: string | null;
+}, 
+/** Whose tier-forcing gate applies. Default Django; `none` never forces
+ * sol-med off a migrations path. */
+ecosystem?: Ecosystem, 
+/** Profile lens-heuristics extension; absent ⇒ generic core. */
+heuristics?: HeuristicsExtension, 
+/** The repo's written style guide references (packages/pi-plugin/src/styleguide.ts); empty or
+ * absent ⇒ the style lens only on the profile's guide, if any. */
+styleGuide?: readonly string[], 
+/** The linters and formatters a CI job of the repo runs (packages/pi-plugin/src/lintconfig.ts);
+ * empty or absent ⇒ no lint-conformance row. */
+ciLinters?: readonly CiLinter[], 
+/** `tierFiles` — the files the round's default TIER is chosen from, when
+ * the plan is built over fewer files than the PR (a follow-up round plans
+ * from the delta, but a small fix push keeps the PR's tier and its
+ * migration floor). Absent ⇒ `files`. */
+opts?: {
+    tierFiles?: PrFileEntry[];
+}): PassPlan;
+/**
+ * The plan's rows in LAUNCH order — the expected-slowest first.
+ *
+ * The session launches a turn's rows in table order, and the lens runner
+ * (packages/pi-plugin/src/engine/lens/runlens.ts) runs them under a process-wide cap in that order,
+ * so a 15–27 row plan runs in waves: a slow row listed late starts in the
+ * last wave and sets the round's critical path (typically pass-baseline,
+ * sol-high sweep and behaviour-delta rows). The order:
+ * pass-baseline; then by tier, highest first; within a tier the risk passes,
+ * then the focused rows (behaviour-delta, then sweep) by the changed lines
+ * their focus covers, larger first, then every other lens, then the cheap
+ * conditional lenses (`CHEAP_LAST_PASSES`); pass-validate stays last. Ties
+ * keep their planned order (a stable sort).
+ *
+ * Only the ORDER moves — the same rows, each byte-identical. Every consumer
+ * that indexes rows (the task files, `lenses`, lesson rows, the recorded
+ * pass_plan) reads this one array, so they agree. Exported for
+ * `planFollowUp`, which splices a carried row into an already-ordered plan.
+ */
+export declare function slowestFirst(rows: readonly PassPlanEntry[], files: readonly PrFileEntry[], risk: ReadonlySet<string>): PassPlanEntry[];
+/** Why a non-first round runs as a full re-review: every doubt is a full
+ * round, never a quieter one. */
+export type FollowUpFullReason = "follow_up_full" | "no-reviewed-head" | "no-adapter" | "delta-too-large" | "baseline-unplanned" | "delta-threw" | "patch-write-failed" | Exclude<PrOwnedDelta, {
+    ok: true;
+}>["reason"];
+/** A follow-up round's plan, decided before the round row exists. */
+export interface FollowUpDecision {
+    delta: Extract<PrOwnedDelta, {
+        ok: true;
+    }>;
+    /** The reviewed head the delta was computed from. */
+    fromSha: string;
+    deltaFiles: PrFileEntry[];
+    plan: PassPlan;
+    /** The pre-approval sweep's plan — the whole PR's full plan — when owed. */
+    sweepPlan?: PassPlanEntry[];
+    /** The full plan's files left over the per-round sweep cap — carried with
+     * `sweepPlan`, so the sweep is told what it does not cover, as round 1 is. */
+    sweepUnswept?: string[];
+    sweepBehaviourUnread?: string[];
+    /** `follow_up_extent = "session"`: the full delta plan's rows the
+     * lean core left out — per-file sweep rows, quality and style lenses —
+     * offered to the session as optional rows. */
+    optionalPlan?: PassPlanEntry[];
+}
+/**
+ * The reads a follow-up decision makes of the PR's review history — exactly
+ * these, so the planner holds no store. The bot passes its state store, which
+ * answers both.
+ */
+export interface FollowUpHistory {
+    /** The PR's rounds (only these fields are read). */
+    roundsFor(pr: number): ReadonlyArray<{
+        backfilled: number;
+        head_sha: string | null;
+        merge_base: string | null;
+        verdict: string | null;
+        round_no: number;
+    }>;
+    /** Has a full look happened since the PR's first round? */
+    fullLookSinceFirst(pr: number): boolean;
+}
+/** The PR-owned delta between two reviewed heads, as the decision asks for it. */
+export type PrOwnedDeltaReader = (q: {
+    pr: number;
+    from: string;
+    to: string;
+    mergeBase: string;
+    baseSha?: string;
+    /** The merge base the reviewed round recorded, when known. */
+    fromMergeBase?: string;
+}) => Promise<PrOwnedDelta>;
+/**
+ * Decide whether a non-first round is a FOLLOW-UP round
+ * (docs/follow-up-rounds.md), and plan it. Total: any doubt — the knob, no
+ * reviewed-head mark, no git seam, a delta git could not compute, a delta
+ * above `follow_up_max_delta_ratio` of the PR's diff lines, a delta plan
+ * without pass-baseline — answers `{full: reason}`, and the caller runs a
+ * full re-review.
+ *
+ * The plan is built over the DELTA's files with the intent text arms off
+ * (the title and body did not change since the last review), its tier chosen
+ * from the WHOLE PR. The sweep is owed as `followUpSweepOwed` decides (the
+ * standing verdict not APPROVE and no full look since the first round, or a
+ * large enough post-approval delta); its plan is
+ * the whole PR's full plan, exactly as a full round would run it.
+ */
+export declare function decideFollowUp(deps: {
+    cfg: CoreConfig;
+    history: FollowUpHistory;
+    /** The PR-owned delta reader (`WorktreeManager.prOwnedDelta`). Absent ⇒
+     * `{full: "no-adapter"}`. */
+    prOwnedDelta?: PrOwnedDeltaReader;
+    heuristics?: HeuristicsExtension;
+}, args: {
+    pr: number;
+    markHead: string | null | undefined;
+    tree: {
+        head_sha: string;
+        base_sha: string;
+        merge_base: string;
+    } | undefined;
+    files: PrFileEntry[];
+    fullPlan: PassPlan;
+    standing: string | null;
+    /** An approval-withheld mark stood when this round was picked up: the
+     * standing APPROVE never reached GitHub, so it is not an approval the
+     * sweep may rely on (a withheld approval is an approval yet to be posted). */
+    approvalWithheld?: boolean;
+    ecosystem: Ecosystem;
+    styleGuide: readonly string[];
+    ciLinters: readonly CiLinter[];
+}): Promise<{
+    kind: "delta";
+    decision: FollowUpDecision;
+} | {
+    kind: "full";
+    reason: FollowUpFullReason;
+    detail?: Record<string, unknown>;
+}>;
+/**
+ * Whether a follow-up round owes the pre-approval sweep, the
+ * `[review] follow_up_sweep` knob aside. Before a posted approval (a withheld
+ * one never reached GitHub, so it counts as none): owed until a full look has
+ * happened since the first round. After a posted approval: owed only when the
+ * change since it reaches `follow_up_post_approval_sweep_lines` — a large push
+ * onto an approved PR is where live re-reviews found blockers outside the
+ * change; a small one stays delta-only.
+ */
+export declare function followUpSweepOwed(cfg: CoreConfig, args: {
+    standing: string | null;
+    approvalWithheld: boolean;
+    fullLookSinceFirst: () => boolean;
+    deltaLines: number;
+}): boolean;
+/**
+ * The PURE half of `decideFollowUp`: given a computed delta, plan
+ * the follow-up round — or answer `{full: reason}`. The daemon reaches it
+ * through `decideFollowUp`; the bench's follow-up replay (src/bench/
+ * followup.ts) calls it directly with a delta computed by the same
+ * `WorktreeManager.prOwnedDelta` over its replay tree, so the two never
+ * disagree about what a follow-up round plans.
+ *
+ * `sweepOwed` is consulted only when the `[review] follow_up_sweep` knob is on
+ * and the plan stands: the daemon's answer reads the standing verdict and the
+ * store; the bench's is the recorded case's.
+ */
+export declare function planFollowUp(cfg: CoreConfig, heuristics: HeuristicsExtension | undefined, args: {
+    delta: Extract<PrOwnedDelta, {
+        ok: true;
+    }>;
+    fromSha: string;
+    files: PrFileEntry[];
+    fullPlan: PassPlan;
+    ecosystem: Ecosystem;
+    styleGuide: readonly string[];
+    ciLinters: readonly CiLinter[];
+    /** Handed the delta's line count. */
+    sweepOwed: (deltaLines: number) => boolean;
+}): {
+    kind: "delta";
+    decision: FollowUpDecision;
+} | {
+    kind: "full";
+    reason: FollowUpFullReason;
+    detail?: Record<string, unknown>;
+};
+/** The lenses a lean follow-up plan offers as addable instead of planning. */
+export declare const LEAN_ADDABLE_PASSES: readonly string[];
+/**
+ * The LEAN follow-up plan: the plan without its per-file
+ * pass-sweep rows, and with the quality and style lenses moved to
+ * `addable_lenses`. Every other row — baseline, the triggered risk lenses,
+ * the validator — is kept as planned, and so is a quality or style row the
+ * plan marks `required` (one the operator made a risk pass): a required row
+ * is an obligation, never an offer. No lens leaves the round: a session that
+ * sees a quality or style question in the change adds the lens.
+ */
+export declare function leanFollowUpPlan(plan: PassPlan): PassPlan;
+/** A delta's files as one git-style patch (the hunks `prOwnedDelta` read,
+ * each under its file header). */
+export declare function renderDeltaPatch(files: readonly PrOwnedDeltaFile[]): string;
+/** The order's view of a delta (types.ts `RoundDelta`). */
+export declare function roundDeltaOf(d: FollowUpDecision, patchFile: string): RoundDelta;
+/** The order the follow-up round's OPTIONAL rows render their task files
+ * from: the follow-up order itself — the change since the last
+ * review stays their scope — with `optional_plan` as its plan. Prior
+ * findings ride the core rows only (their assignment indexes `pass_plan`),
+ * so none ride here. Pure. */
+export declare function optionalOrderOf(order: RoundOrder, optionalPlan: PassPlanEntry[]): RoundOrder;
+/** The order the pre-approval sweep's task files render from: the
+ * follow-up order minus its follow-up fields, planned with the whole PR's
+ * full plan — exactly the order a full round would hand its lenses. Pure;
+ * the daemon and the bench's follow-up replay render the sweep's tasks from
+ * it alike. */
+export declare function sweepOrderOf(order: RoundOrder, sweepPlan: PassPlanEntry[]): RoundOrder;
+/** Build the round order for one PR — pure once the files list is in hand. */
+export declare function buildRoundOrder(args: {
+    cfg: CoreConfig;
+    row: PlannedPr;
+    files: PrFileEntry[];
+    roundId: number;
+    roundNo: number;
+    /** Prior VERDICTED rounds + 1 — the PR's review age. Drives the nit cap;
+     * failed (cancelled/overdue) rounds advance round_no but not this. */
+    reviewNo?: number;
+    roundType: RoundType;
+    worktree: string;
+    settledDigest: string;
+    /** The PR's mirrored ledger; absent ⇒ no `ledger_carry`. */
+    ledgerCarry?: LedgerCarry;
+    issuedAt: string;
+    /** Facts established by preparing the worktree. Absent only for callers with
+     * no worktree seam (the stub-wired daemon core and unit tests), which fall
+     * back to the PR row's sha and an unknown base. */
+    tree?: PreparedTree;
+    /** Collisions the pre-check found — delivered as a COMMENT unless
+     * `migrationCollisionsUndelivered` says the COMMENT did not reach the PR. */
+    migrationCollisions?: MigrationCollision[];
+    /** True when the collisions' COMMENT was withheld, refused or failed: the
+     * gate note then hands the remedy to the session. */
+    migrationCollisionsUndelivered?: boolean;
+    /** True when the PR touches migrations and the pre-check could NOT run —
+     * the prompt must tell the session to check collisions itself. */
+    migrationPrecheckDegraded?: boolean;
+    /** First-party directive files + the picked escalation mention. */
+    firstPartyDirectives?: {
+        files: string[];
+        mention: string;
+    };
+    /** The PR body as GitHub returned it: pass-intent's whole intent
+     * artifact and the substance-bar input. Absent (stub-wired core, unit tests
+     * without an adapter body) ⇒ the intent lens is never selected. */
+    prBody?: string;
+    /** The round's ecosystem. Absent ⇒ Django. */
+    ecosystem?: Ecosystem;
+    /** Exact predecessor identity for a pre-fanout recovery successor. */
+    recovery?: RoundRecoveryContext;
+    /** Profile lens-heuristics extension; absent ⇒ generic core. */
+    heuristics?: HeuristicsExtension;
+    /** The names the order launches lenses in (`SessionHooks.lensRuntime`): the
+     * worker host's engine tools. Absent ⇒ native, the tmux host's. */
+    lensRuntime?: "engine";
+    /** The rendered third-party-sources block (packages/pi-plugin/src/depsources.ts). */
+    dependencyNote?: string;
+    /** The repo's written style guide references (packages/pi-plugin/src/styleguide.ts). */
+    styleGuide?: readonly string[];
+    /** The linters a CI job of the repo runs (packages/pi-plugin/src/lintconfig.ts). */
+    ciLinters?: readonly CiLinter[];
+    /** The plan, already built by the caller (dispatch builds it once and
+     * records the same plan on the round row). Absent ⇒ built here from
+     * `files`, the PR body, the style guide and the linters. */
+    plan?: PassPlan;
+    /** A FOLLOW-UP round's facts: the delta, the prior findings note, the owed
+     * sweep's plan. The coverage check then holds the round to the delta's
+     * files. Absent ⇒ a full round's order. */
+    followUp?: {
+        delta: RoundDelta;
+        deltaFiles: PrFileEntry[];
+        priorFindingsNote: string;
+        /** The listed prior findings: each is assigned to the plan row that owns
+         * it and written into that row's task file. Absent (the list could not be
+         * assembled) ⇒ the session assigns them. */
+        priorFindings?: Pick<PriorFindingsList, "findings" | "round_no">;
+        /** The optional rows the session decides (`optional_plan`). */
+        optionalPlan?: PassPlanEntry[];
+        sweepPlan?: PassPlanEntry[];
+        sweepUnswept?: string[];
+        sweepBehaviourUnread?: string[];
+    };
+}): RoundOrder;
+//# sourceMappingURL=planner.d.ts.map

package/dist/src/planner.d.ts.map

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