ghagga-forge 3.1.0

package/dist/adapters/gitlab/gitlab-forge-adapter.js

@@ -0,0 +1,238 @@
+/**
+ * GitLabForgeAdapter — wraps a GitLab REST client behind the forge-agnostic
+ * {@link ForgeAdapterBase} + {@link InlineCapable} surfaces.
+ *
+ * DEPENDENCY INVERSION (boundary rule R-AGNOSTIC):
+ * `packages/forge` MUST NOT import a concrete HTTP client. This adapter depends
+ * on the injected {@link GitLabClientPort} (declared inside the forge package);
+ * the CLI (P4) constructs the adapter passing a native-fetch implementation:
+ *
+ *   new GitLabForgeAdapter({ client, token, projectId })
+ *
+ * IDENTITY (R-GITLAB):
+ * - {@link RepoRef.nativeId} is the GitLab NUMERIC project id (the group/project
+ *   `path` is mutable → the id is canonical). The adapter is constructed with the
+ *   numeric `projectId` and routes EVERY REST call through it — never the path.
+ * - {@link ChangeRequestRef.iid} is the MR iid (project-scoped). The GitLab MR
+ *   API path is `/projects/:id/merge_requests/:iid/...`.
+ *
+ * CAPABILITIES: reactions ❌ (GitLab reaction-award is not modelled — no
+ * `addReaction`), inlineComments ✅ (publishInline present), graphRead ❌ (no
+ * graph methods). The `capabilities` field is a HINT only (R-CAPABILITY): callers
+ * guard optional methods by method-presence, never by these flags.
+ *
+ * SCOPE — v1 deliverable is the SUMMARY COMMENT (upsertSummaryComment). The
+ * adapter also implements {@link InlineCapable.publishInline} to satisfy
+ * R-LEAK-PUBLISH: it posts N INDEPENDENT inline posts, returning a
+ * {@link PublishReport} where partial failure is FIRST-CLASS (never swallowed).
+ * INLINE POSITIONING: when an {@link InlineComment} carries `position` and the
+ * injected client supports `createMrDiscussion`, v1 posts a TRUE diff-anchored
+ * discussion (`position[position_type]=text` + the three SHAs + old/new line +
+ * old/new path). When `position` is absent (or the client lacks discussion
+ * support) it degrades to a plain MR note carrying the `path:line` prefix in the
+ * body. The public {@link InlineComment} type carries `position` + `oldPath`/
+ * `newPath` regardless, so broadening positioned coverage needs NO API change.
+ *
+ * COMMENT IDs: `upsertSummaryComment` returns PLAIN GitLab-native numeric ids
+ * (boxing happens caller-LOCAL via {@link gitlabCommentId}). `publishInline`
+ * boxes per the {@link PublishReport} contract (CommentId) since the report is
+ * the canonical cross-forge shape.
+ */
+import { gitlabCommentId } from '../../comment-id.js';
+import { ForgeAuthError, getErrorStatus, isForgeAuthError } from '../../errors.js';
+/**
+ * GitLab implementation of the forge adapter.
+ *
+ * Implements the mandatory base (summary-comment + the read methods, the latter
+ * unused by the CLI v1 path and intentionally absent from the client port) plus
+ * {@link InlineCapable}. Deliberately does NOT implement reactions or graph read.
+ */
+export class GitLabForgeAdapter {
+    capabilities = {
+        reactions: false,
+        inlineComments: true,
+        graphRead: false,
+    };
+    #client;
+    #token;
+    #projectId;
+    constructor(deps) {
+        this.#client = deps.client;
+        this.#token = deps.token;
+        this.#projectId = deps.projectId;
+    }
+    /**
+     * Run a client call, reclassifying a 401/403 failure as a {@link ForgeAuthError}
+     * (mirrors the GitHub adapter). With a static PAT a 401 is terminal — there is
+     * nothing to re-mint — but the typed signal keeps the CLI's error reporting
+     * consistent across forges. NON-auth failures rethrow UNCHANGED.
+     */
+    async #mapAuth(call) {
+        try {
+            return await call();
+        }
+        catch (error) {
+            const status = getErrorStatus(error);
+            if (status === 401 || status === 403) {
+                throw new ForgeAuthError(status, error instanceof Error ? error.message : `Forge auth failure (HTTP ${status})`, { cause: error });
+            }
+            throw error;
+        }
+    }
+    // ─── Base: reads ───────────────────────────────────────────────
+    //
+    // The GitLab CLI v1 deliverable is the summary comment; the diff/details/
+    // file-list/commits are sourced LOCALLY by the CLI (same posture as the GitHub
+    // CLI port). These methods are part of the mandatory base surface but are NOT
+    // exercised by the `--mr` flow, so they fail loudly rather than fabricate data.
+    fetchDiff(_ref) {
+        return Promise.reject(new Error('GitLabForgeAdapter.fetchDiff is not supported in the CLI summary-comment path — ' +
+            'the diff is sourced locally. (GitLab read methods are a v2 deliverable.)'));
+    }
+    fetchChangeRequest(_ref) {
+        return Promise.reject(new Error('GitLabForgeAdapter.fetchChangeRequest is not supported (v2 deliverable).'));
+    }
+    fetchFileList(_ref) {
+        return Promise.reject(new Error('GitLabForgeAdapter.fetchFileList is not supported (v2 deliverable).'));
+    }
+    fetchCommits(_ref) {
+        return Promise.reject(new Error('GitLabForgeAdapter.fetchCommits is not supported (v2 deliverable).'));
+    }
+    // ─── Base: upsert summary comment (fold list/delete/create → 1) ──
+    /**
+     * Idempotently upsert the single GHAGGA summary note on an MR.
+     *
+     * Behavior (mirrors the GitHub adapter's delete-all-stale + repost-at-bottom):
+     * 1. list MR notes; match the GHAGGA-owned ones by `marker.html` substring.
+     * 2. delete ALL matches in `[latest, ...stale]` order — BEST-EFFORT: each
+     *    delete is per-note try/catch so a 404 (already gone) OR any other failure
+     *    is tolerated and does NOT block the repost. Only ids that actually deleted
+     *    (no throw) are reported in `deleted`.
+     * 3. create a FRESH note at the bottom — this is the ONLY failure that
+     *    propagates (a failed create means no summary exists, which is fatal).
+     *
+     * "latest" = the LAST marker-matching note in chronological order (GitLab list
+     * returns notes oldest-first), matching the GitHub adapter's convention.
+     *
+     * Returns GitLab-native numeric ids (boxing happens caller-local via
+     * {@link gitlabCommentId}).
+     */
+    async upsertSummaryComment(ref, body, marker) {
+        const notes = await this.#mapAuth(() => this.#client.listMrNotes(this.#projectId, ref.iid, this.#token));
+        const matchIds = notes.filter((n) => n.body.includes(marker.html)).map((n) => n.id);
+        const deleted = [];
+        if (matchIds.length > 0) {
+            // latest = last marker note; the rest are stale. Delete latest FIRST then
+            // stale, mirroring the GitHub adapter's baseline order. (Guaranteed
+            // non-empty inside this `matchIds.length > 0` branch.)
+            const latestId = matchIds[matchIds.length - 1];
+            const staleIds = matchIds.slice(0, -1);
+            const ordered = [latestId, ...staleIds];
+            for (const noteId of ordered) {
+                try {
+                    await this.#client.deleteMrNote(this.#projectId, ref.iid, noteId, this.#token);
+                    deleted.push(noteId);
+                }
+                catch {
+                    // Best-effort: tolerate any delete failure (404 or non-404). A stale
+                    // note that cannot be deleted must NOT block the fresh repost.
+                }
+            }
+        }
+        // Always create a fresh note at the bottom. This is the ONLY error that
+        // propagates. A 401/403 here is reclassified to ForgeAuthError.
+        const created = await this.#mapAuth(() => this.#client.createMrNote(this.#projectId, ref.iid, body, this.#token));
+        if (created?.id == null) {
+            throw new TypeError('GitLabForgeAdapter.upsertSummaryComment: createMrNote returned no id (expected { id: number })');
+        }
+        return { created: created.id, deleted };
+    }
+    // ─── InlineCapable ─────────────────────────────────────────────
+    /**
+     * Publish a batch of inline comments as N INDEPENDENT posts (R-LEAK-PUBLISH).
+     *
+     * PARTIAL FAILURE IS FIRST-CLASS: GitLab posts each comment independently, so
+     * each create is wrapped in its own try/catch. A failure records
+     * `{index, error, status?, authFailure?}` into `failed` and the loop CONTINUES
+     * — failures are NEVER swallowed and never abort the remaining posts. The
+     * `status`/`authFailure` tags let a caller tell an AUTH failure (401/403, a
+     * static PAT cannot recover) from a transient one without string-parsing the
+     * message. Successes are boxed into `CommentId` (kind:'gitlab') and collected
+     * into `posted`.
+     *
+     * POSITION HANDLING (v1):
+     * - When a comment carries `position` AND the injected client implements
+     *   `createMrDiscussion`, the adapter posts a TRUE diff-anchored discussion
+     *   (`position[position_type]=text` with the three SHAs + old/new line +
+     *   old/new path — renames are honored via `oldPath`/`newPath`, defaulting to
+     *   `path`). The boxed id is the discussion's first-note id.
+     * - Otherwise (no `position`, or a client without discussion support) it
+     *   degrades to a plain MR note carrying a `path:line` body prefix so the
+     *   anchor info is not lost. Either way the partial-failure REPORT SHAPE +
+     *   independent-post semantics — the load-bearing R-LEAK-PUBLISH contract —
+     *   hold. The public {@link InlineComment} type carries `position` regardless,
+     *   so no future API change is needed to broaden positioned coverage.
+     */
+    async publishInline(ref, comments) {
+        const posted = [];
+        const failed = [];
+        for (let index = 0; index < comments.length; index++) {
+            const comment = comments[index];
+            if (comment == null)
+                continue;
+            try {
+                const created = await this.#postInline(ref, comment);
+                if (created?.id == null) {
+                    throw new TypeError('inline post returned no id (expected { id: number })');
+                }
+                posted.push(gitlabCommentId(created.id));
+            }
+            catch (error) {
+                // First-class partial failure: record and CONTINUE (never swallow, never
+                // abort the rest). No #mapAuth reclassification here — a per-note failure
+                // is reported, not thrown, so the batch outcome is observable.
+                //
+                // TAG the failure so a caller can distinguish an AUTH failure (401/403 —
+                // a static PAT cannot recover, surface "fix your token") from a transient
+                // one WITHOUT string-parsing `error`. `#postInline` does not run through
+                // `#mapAuth`, so the raw client error still carries its numeric `status`;
+                // `isForgeAuthError` ALSO catches an already-reclassified ForgeAuthError
+                // for robustness.
+                const status = getErrorStatus(error);
+                const authFailure = isForgeAuthError(error) || status === 401 || status === 403;
+                failed.push({
+                    index,
+                    error: error instanceof Error ? error.message : String(error),
+                    ...(status != null ? { status } : {}),
+                    ...(authFailure ? { authFailure: true } : {}),
+                });
+            }
+        }
+        return { posted, failed };
+    }
+    /**
+     * Post a single inline comment: a TRUE diff-anchored discussion when the
+     * comment carries `position` AND the client supports it, else a degraded
+     * `path:line` plain note. Throws on a missing id (the caller records it as a
+     * per-comment failure).
+     */
+    #postInline(ref, comment) {
+        const createDiscussion = this.#client.createMrDiscussion;
+        if (comment.position && typeof createDiscussion === 'function') {
+            return createDiscussion.call(this.#client, this.#projectId, ref.iid, comment.body, {
+                baseSha: comment.position.baseSha,
+                headSha: comment.position.headSha,
+                startSha: comment.position.startSha,
+                // GitLab requires BOTH paths for a text diff note; default to `path`.
+                oldPath: comment.oldPath ?? comment.path,
+                newPath: comment.newPath ?? comment.path,
+                ...(comment.position.oldLine != null ? { oldLine: comment.position.oldLine } : {}),
+                ...(comment.position.newLine != null ? { newLine: comment.position.newLine } : {}),
+            }, this.#token);
+        }
+        // Degrade: encode the anchor in the body as a plain note.
+        const noteBody = `\`${comment.path}:${comment.line}\`\n\n${comment.body}`;
+        return this.#client.createMrNote(this.#projectId, ref.iid, noteBody, this.#token);
+    }
+}
+//# sourceMappingURL=gitlab-forge-adapter.js.map

package/dist/adapters/gitlab/gitlab-forge-adapter.js.map

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

package/dist/comment-id.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Sanctioned comment-id boxing helpers (R-COMMENTID).
+ *
+ * The forge adapters RETURN forge-native primitives (e.g. GitHub numeric
+ * comment ids) — see {@link UpsertSummaryResult}. Boxing those primitives into
+ * the canonical {@link CommentId} ({kind, raw}) happens caller-LOCAL, AFTER the
+ * adapter returns. This module is the ONE blessed place that boxing lives, so
+ * both the server worker (apps/server review.ts) AND the future P3 CLI can reuse
+ * it WITHOUT importing side-effectful modules (review.ts constructs Redis/BullMQ
+ * queue state at import time — unusable from a CLI / from the helper's own test).
+ *
+ * This is a PURE helper using the forge {@link CommentId} type. It does NOT
+ * brand the adapter's return type (the adapter still returns numbers); it is the
+ * sanctioned boxing step the caller applies at the seam.
+ *
+ * Boundary note (R-AGNOSTIC): this file imports only the forge-local
+ * {@link CommentId} type — no `apps/server`, no `ghagga-core` value import — so
+ * it does not breach any package boundary.
+ */
+import type { CommentId } from './types.js';
+/**
+ * BOX a GitHub-native numeric comment id into the canonical {@link CommentId}.
+ *
+ * The `kind: 'github'` tag prevents a GitHub comment id from being
+ * cross-assigned as a GitLab note id — the same numeric value across forges
+ * never collides because the discriminator differs.
+ *
+ * @param raw the GitHub-native numeric comment id.
+ * @returns the boxed `{ kind: 'github', raw: String(raw) }`.
+ */
+export declare function githubCommentId(raw: number): CommentId;
+/**
+ * BOX a GitLab-native numeric note id into the canonical {@link CommentId}.
+ *
+ * GitLab note ids are NUMERIC but MR-scoped — the `kind: 'gitlab'` tag is what
+ * disambiguates them from a GitHub comment id (R-COMMENTID). The SAME numeric
+ * value boxed as `'github'` vs `'gitlab'` never collides because the
+ * discriminator differs, so a GitHub comment id can never be cross-assigned as a
+ * GitLab note id (and vice-versa).
+ *
+ * @param raw the GitLab-native numeric note id.
+ * @returns the boxed `{ kind: 'gitlab', raw: String(raw) }`.
+ */
+export declare function gitlabCommentId(raw: number): CommentId;
+//# sourceMappingURL=comment-id.d.ts.map

package/dist/comment-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-id.d.ts","sourceRoot":"","sources":["../src/comment-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAEtD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAEtD"}

package/dist/comment-id.js

@@ -0,0 +1,48 @@
+/**
+ * Sanctioned comment-id boxing helpers (R-COMMENTID).
+ *
+ * The forge adapters RETURN forge-native primitives (e.g. GitHub numeric
+ * comment ids) — see {@link UpsertSummaryResult}. Boxing those primitives into
+ * the canonical {@link CommentId} ({kind, raw}) happens caller-LOCAL, AFTER the
+ * adapter returns. This module is the ONE blessed place that boxing lives, so
+ * both the server worker (apps/server review.ts) AND the future P3 CLI can reuse
+ * it WITHOUT importing side-effectful modules (review.ts constructs Redis/BullMQ
+ * queue state at import time — unusable from a CLI / from the helper's own test).
+ *
+ * This is a PURE helper using the forge {@link CommentId} type. It does NOT
+ * brand the adapter's return type (the adapter still returns numbers); it is the
+ * sanctioned boxing step the caller applies at the seam.
+ *
+ * Boundary note (R-AGNOSTIC): this file imports only the forge-local
+ * {@link CommentId} type — no `apps/server`, no `ghagga-core` value import — so
+ * it does not breach any package boundary.
+ */
+/**
+ * BOX a GitHub-native numeric comment id into the canonical {@link CommentId}.
+ *
+ * The `kind: 'github'` tag prevents a GitHub comment id from being
+ * cross-assigned as a GitLab note id — the same numeric value across forges
+ * never collides because the discriminator differs.
+ *
+ * @param raw the GitHub-native numeric comment id.
+ * @returns the boxed `{ kind: 'github', raw: String(raw) }`.
+ */
+export function githubCommentId(raw) {
+    return { kind: 'github', raw: String(raw) };
+}
+/**
+ * BOX a GitLab-native numeric note id into the canonical {@link CommentId}.
+ *
+ * GitLab note ids are NUMERIC but MR-scoped — the `kind: 'gitlab'` tag is what
+ * disambiguates them from a GitHub comment id (R-COMMENTID). The SAME numeric
+ * value boxed as `'github'` vs `'gitlab'` never collides because the
+ * discriminator differs, so a GitHub comment id can never be cross-assigned as a
+ * GitLab note id (and vice-versa).
+ *
+ * @param raw the GitLab-native numeric note id.
+ * @returns the boxed `{ kind: 'gitlab', raw: String(raw) }`.
+ */
+export function gitlabCommentId(raw) {
+    return { kind: 'gitlab', raw: String(raw) };
+}
+//# sourceMappingURL=comment-id.js.map

package/dist/comment-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-id.js","sourceRoot":"","sources":["../src/comment-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAAC,GAAW;IACzC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,GAAW;IACzC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;AAC9C,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Forge error taxonomy (SDD forge-agnostic — P2 401-recovery fix).
+ *
+ * The forge boundary throws plain `Error`s on most failures. But the in-job
+ * 401-recovery seam (review.ts postback) needs to distinguish an AUTH failure
+ * (HTTP 401/403 — the cached installation token was revoked/rotated server-side)
+ * from any other failure, GENERICALLY, without sniffing error message strings.
+ *
+ * {@link ForgeAuthError} is that typed signal. The adapter raises it when an
+ * underlying forge call fails with a 401/403 status; the worker catches it via
+ * {@link isForgeAuthError}, invalidates the credential provider's cache, re-mints,
+ * and retries the call ONCE. Non-auth failures stay plain `Error`s (NOT
+ * reclassified) so retry logic only fires for genuine auth failures.
+ */
+/** HTTP statuses that mean "the token is no longer accepted" → re-mint + retry. */
+export declare const FORGE_AUTH_STATUSES: readonly [401, 403];
+/**
+ * A forge call failed because the access token was rejected (HTTP 401/403).
+ *
+ * Carries the originating HTTP `status` and (optionally) the underlying `cause`
+ * so callers can log the real error while reacting to the auth class generically.
+ */
+export declare class ForgeAuthError extends Error {
+    /** The HTTP status that triggered this auth error (401 or 403). */
+    readonly status: number;
+    constructor(status: number, message?: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Type guard: is `e` a {@link ForgeAuthError}?
+ *
+ * Robust to cross-realm / multiple-bundle-copy situations (where `instanceof`
+ * can fail) by ALSO accepting any error shaped like a ForgeAuthError (name +
+ * numeric auth status). Non-auth errors return `false` so they are never
+ * mistaken for a retry-able auth failure.
+ */
+export declare function isForgeAuthError(e: unknown): e is ForgeAuthError;
+/**
+ * Extract an HTTP status from an arbitrary thrown value, if it carries one.
+ *
+ * The `apps/server` GitHub client tags its thrown errors with a numeric
+ * `status` field (see client.ts). The adapter uses this to decide whether a
+ * client failure is an auth failure (401/403) it should reclassify as a
+ * {@link ForgeAuthError}. Returns `undefined` when no usable status is present.
+ */
+export declare function getErrorStatus(e: unknown): number | undefined;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,qBAAsB,CAAC;AAEvD;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAQ5E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,cAAc,CAShE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAI7D"}

package/dist/errors.js

@@ -0,0 +1,67 @@
+/**
+ * Forge error taxonomy (SDD forge-agnostic — P2 401-recovery fix).
+ *
+ * The forge boundary throws plain `Error`s on most failures. But the in-job
+ * 401-recovery seam (review.ts postback) needs to distinguish an AUTH failure
+ * (HTTP 401/403 — the cached installation token was revoked/rotated server-side)
+ * from any other failure, GENERICALLY, without sniffing error message strings.
+ *
+ * {@link ForgeAuthError} is that typed signal. The adapter raises it when an
+ * underlying forge call fails with a 401/403 status; the worker catches it via
+ * {@link isForgeAuthError}, invalidates the credential provider's cache, re-mints,
+ * and retries the call ONCE. Non-auth failures stay plain `Error`s (NOT
+ * reclassified) so retry logic only fires for genuine auth failures.
+ */
+/** HTTP statuses that mean "the token is no longer accepted" → re-mint + retry. */
+export const FORGE_AUTH_STATUSES = [401, 403];
+/**
+ * A forge call failed because the access token was rejected (HTTP 401/403).
+ *
+ * Carries the originating HTTP `status` and (optionally) the underlying `cause`
+ * so callers can log the real error while reacting to the auth class generically.
+ */
+export class ForgeAuthError extends Error {
+    /** The HTTP status that triggered this auth error (401 or 403). */
+    status;
+    constructor(status, message, options) {
+        super(message ?? `Forge auth failure (HTTP ${status})`, options);
+        this.name = 'ForgeAuthError';
+        this.status = status;
+        // Preserve prototype chain across the TS-to-ES5/ES2015 transpile boundary so
+        // `instanceof` keeps working even if a downstream target down-levels classes.
+        Object.setPrototypeOf(this, ForgeAuthError.prototype);
+    }
+}
+/**
+ * Type guard: is `e` a {@link ForgeAuthError}?
+ *
+ * Robust to cross-realm / multiple-bundle-copy situations (where `instanceof`
+ * can fail) by ALSO accepting any error shaped like a ForgeAuthError (name +
+ * numeric auth status). Non-auth errors return `false` so they are never
+ * mistaken for a retry-able auth failure.
+ */
+export function isForgeAuthError(e) {
+    if (e instanceof ForgeAuthError)
+        return true;
+    if (typeof e !== 'object' || e === null)
+        return false;
+    const candidate = e;
+    return (candidate.name === 'ForgeAuthError' &&
+        typeof candidate.status === 'number' &&
+        FORGE_AUTH_STATUSES.includes(candidate.status));
+}
+/**
+ * Extract an HTTP status from an arbitrary thrown value, if it carries one.
+ *
+ * The `apps/server` GitHub client tags its thrown errors with a numeric
+ * `status` field (see client.ts). The adapter uses this to decide whether a
+ * client failure is an auth failure (401/403) it should reclassify as a
+ * {@link ForgeAuthError}. Returns `undefined` when no usable status is present.
+ */
+export function getErrorStatus(e) {
+    if (typeof e !== 'object' || e === null)
+        return undefined;
+    const status = e.status;
+    return typeof status === 'number' ? status : undefined;
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,mFAAmF;AACnF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE,GAAG,CAAU,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,OAAO,cAAe,SAAQ,KAAK;IACvC,mEAAmE;IAC1D,MAAM,CAAS;IAExB,YAAY,MAAc,EAAE,OAAgB,EAAE,OAA6B;QACzE,KAAK,CAAC,OAAO,IAAI,4BAA4B,MAAM,GAAG,EAAE,OAAO,CAAC,CAAC;QACjE,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,6EAA6E;QAC7E,8EAA8E;QAC9E,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;IACxD,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,CAAU;IACzC,IAAI,CAAC,YAAY,cAAc;QAAE,OAAO,IAAI,CAAC;IAC7C,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACtD,MAAM,SAAS,GAAG,CAAyC,CAAC;IAC5D,OAAO,CACL,SAAS,CAAC,IAAI,KAAK,gBAAgB;QACnC,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ;QACnC,mBAAyC,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CACtE,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,CAAU;IACvC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IAC1D,MAAM,MAAM,GAAI,CAA0B,CAAC,MAAM,CAAC;IAClD,OAAO,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AACzD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ghagga-forge — Public API
+ *
+ * Forge-agnostic ports and canonical domain types. The core review engine and
+ * the server talk to these abstractions instead of any concrete forge SDK.
+ *
+ * Architecture invariants (see individual files for detail):
+ * - R-AGNOSTIC: `ghagga-core` MUST NOT import this package (value OR type).
+ *   This package MAY import core in TYPE position only.
+ * - R-PROJECTION / R-COMMENTID / R-CAPABILITY / R-RESOLVE / R-GRAPH are pinned
+ *   by the types and the test suite.
+ */
+export type { Actor, ActorKind, AuthorAssociation, ChangedFile, ChangeKind, ChangeRequest, ChangeRequestRef, CommentId, CommentMarker, Commit, DiffRefs, ForgeCapabilities, ForgeEvent, ForgeKind, NormalizedComment, PublishFailure, PublishReport, RepoRef, TenantHint, UnifiedDiff, UpsertSummaryResult, } from './types.js';
+export { ACTOR_KIND, AUTHOR_ASSOCIATION, CHANGE_KIND, FORGE_KIND, } from './types.js';
+export type { ForgeAdapter, ForgeAdapterBase, GraphReadCapable, InlineCapable, InlineComment, MarkerExtractable, ReactionCapable, ReactionKind, } from './ports/forge-adapter.js';
+export { REACTION_KIND } from './ports/forge-adapter.js';
+export type { CiDispatchRequest, CiDispatchResult, CiRunner, EnsureWorkflowResult, } from './ports/ci-runner.js';
+export { FORGE_AUTH_STATUSES, ForgeAuthError, getErrorStatus, isForgeAuthError } from './errors.js';
+export type { ForgeCredentialProvider } from './ports/credential-provider.js';
+export type { ForgeWebhookCodec } from './ports/webhook-codec.js';
+export type { ForgeRegistry, UnknownForgeErrorContext } from './registry.js';
+export { MapForgeRegistry, UnknownForgeError } from './registry.js';
+export type { GitHubAppCredentialProviderDeps } from './adapters/github/github-app-credential-provider.js';
+export { BUDGET_SECONDS, GitHubAppCredentialProvider, SKEW_SECONDS, } from './adapters/github/github-app-credential-provider.js';
+export type { GitHubClientPort, GitHubInstallationTokenMintWithExpiry, GitHubReactionContent, MintedInstallationToken, } from './adapters/github/github-client-port.js';
+export type { GitHubForgeAdapterDeps } from './adapters/github/github-forge-adapter.js';
+export { GitHubForgeAdapter } from './adapters/github/github-forge-adapter.js';
+export { StaticTokenProvider } from './adapters/github/static-token-provider.js';
+export type { GitLabClientPort, GitLabDiffPosition, GitLabNote, } from './adapters/gitlab/gitlab-client-port.js';
+export type { GitLabForgeAdapterDeps } from './adapters/gitlab/gitlab-forge-adapter.js';
+export { GitLabForgeAdapter } from './adapters/gitlab/gitlab-forge-adapter.js';
+export { githubCommentId, gitlabCommentId } from './comment-id.js';
+export { repoRefEquals } from './ref.js';
+export { toCommitMessages, toFileList, toReviewContext } from './project.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,YAAY,EACV,KAAK,EACL,SAAS,EACT,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,SAAS,EACT,aAAa,EACb,MAAM,EACN,QAAQ,EACR,iBAAiB,EACjB,UAAU,EACV,SAAS,EACT,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,OAAO,EACP,UAAU,EACV,WAAW,EACX,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,WAAW,EACX,UAAU,GACX,MAAM,YAAY,CAAC;AAIpB,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,YAAY,GACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAIzD,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,QAAQ,EACR,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAO9B,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpG,YAAY,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,YAAY,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AASpE,YAAY,EAAE,+BAA+B,EAAE,MAAM,qDAAqD,CAAC;AAC3G,OAAO,EACL,cAAc,EACd,2BAA2B,EAC3B,YAAY,GACb,MAAM,qDAAqD,CAAC;AAC7D,YAAY,EACV,gBAAgB,EAChB,qCAAqC,EACrC,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,yCAAyC,CAAC;AACjD,YAAY,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAOjF,YAAY,EACV,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,GACX,MAAM,yCAAyC,CAAC;AACjD,YAAY,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAQ/E,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAIzC,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,34 @@
+/**
+ * ghagga-forge — Public API
+ *
+ * Forge-agnostic ports and canonical domain types. The core review engine and
+ * the server talk to these abstractions instead of any concrete forge SDK.
+ *
+ * Architecture invariants (see individual files for detail):
+ * - R-AGNOSTIC: `ghagga-core` MUST NOT import this package (value OR type).
+ *   This package MAY import core in TYPE position only.
+ * - R-PROJECTION / R-COMMENTID / R-CAPABILITY / R-RESOLVE / R-GRAPH are pinned
+ *   by the types and the test suite.
+ */
+export { ACTOR_KIND, AUTHOR_ASSOCIATION, CHANGE_KIND, FORGE_KIND, } from './types.js';
+export { REACTION_KIND } from './ports/forge-adapter.js';
+// ─── Ports: credentials & webhooks ──────────────────────────────
+// ─── Errors ─────────────────────────────────────────────────────
+// ForgeAuthError + isForgeAuthError: the typed 401/403 signal the worker catches
+// to drive the in-job credential re-mint + retry (P2 401-recovery seam).
+export { FORGE_AUTH_STATUSES, ForgeAuthError, getErrorStatus, isForgeAuthError } from './errors.js';
+export { MapForgeRegistry, UnknownForgeError } from './registry.js';
+export { BUDGET_SECONDS, GitHubAppCredentialProvider, SKEW_SECONDS, } from './adapters/github/github-app-credential-provider.js';
+export { GitHubForgeAdapter } from './adapters/github/github-forge-adapter.js';
+export { StaticTokenProvider } from './adapters/github/static-token-provider.js';
+export { GitLabForgeAdapter } from './adapters/gitlab/gitlab-forge-adapter.js';
+// ─── Identity helpers ───────────────────────────────────────────
+// ─── Comment-id boxing (R-COMMENTID) ────────────────────────────
+// Sanctioned, side-effect-free boxing helper reusable by both the server
+// worker and the P3 CLI (the adapter still RETURNS native numbers; this is the
+// caller-local boxing step, NOT a branding of the adapter return type).
+export { githubCommentId, gitlabCommentId } from './comment-id.js';
+export { repoRefEquals } from './ref.js';
+// ─── Projection helpers ─────────────────────────────────────────
+export { toCommitMessages, toFileList, toReviewContext } from './project.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA2BH,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,WAAW,EACX,UAAU,GACX,MAAM,YAAY,CAAC;AAcpB,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAWzD,mEAAmE;AAEnE,mEAAmE;AACnE,iFAAiF;AACjF,yEAAyE;AACzE,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAOpG,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAUpE,OAAO,EACL,cAAc,EACd,2BAA2B,EAC3B,YAAY,GACb,MAAM,qDAAqD,CAAC;AAQ7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAajF,OAAO,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAE/E,mEAAmE;AAEnE,mEAAmE;AACnE,yEAAyE;AACzE,+EAA+E;AAC/E,wEAAwE;AACxE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,mEAAmE;AAEnE,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/lint-boundary.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Forge-internal boundary checker (task 0.8).
+ *
+ * Enforces the R-AGNOSTIC import rules that Biome 2.5 cannot express on its own,
+ * specifically the TYPE-vs-VALUE distinction for forge→core imports:
+ *
+ *   - `import type { X } from 'ghagga-core'`            ✅ allowed (type position)
+ *   - `import { type X } from 'ghagga-core'`            ✅ allowed (all specifiers inline-type)
+ *   - `import { X } from 'ghagga-core'`                 ❌ forbidden (value position)
+ *   - `export { X } from 'ghagga-core'`                 ❌ forbidden (re-export = value escape)
+ *   - `import('ghagga-core')` / `require('ghagga-core')` ❌ forbidden (dynamic = value)
+ *   - `ghagga-core/<subpath>` / `@ghagga/core`         ❌ same rules (subpath & scoped alias)
+ *   - any import of `apps/server` / `ghagga-server`    ❌ forbidden outright
+ *
+ * Biome's `noRestrictedImports` is a blunt path ban — it would reject the LEGAL
+ * `import type` forge→core case (false positive). This checker closes that gap
+ * so the boundary test (`lint-boundary.test.ts`) can pin both directions.
+ *
+ * It is deliberately a small, dependency-free scanner over source text rather
+ * than a full AST pass: the boundary rules only care about import-statement
+ * forms, which are matched reliably with focused regexes. The Biome overrides in
+ * `biome.json` cover the forge↛server and core↛forge path bans; this module
+ * adds the type-position nuance for forge→core.
+ *
+ * IMPLEMENTATION LIVES IN A `.mjs` SIBLING (P0 fix F2 hardening):
+ * The actual scanner logic is in `lint-boundary.impl.mjs` (plain JS). The
+ * lint:boundary RUNNER (`scripts/lint-boundary.mjs`) imports that `.mjs`
+ * DIRECTLY, so the gate never imports a `.ts` file at runtime and therefore does
+ * NOT depend on Node's experimental TS type-stripping (Node >= 22.18 / unflagged)
+ * — eliminating the `ERR_UNKNOWN_FILE_EXTENSION` Node-version fragility. This
+ * module re-exports the function with a precise TS type and owns the
+ * {@link BoundaryViolation} interface so the tests keep a fully typed import.
+ */
+export type { BoundaryViolation } from './lint-boundary.impl.mjs';
+export { BANNED_CLIENT_FORGE_FNS, checkForgeBoundary, checkServerForgeClientBoundary, } from './lint-boundary.impl.mjs';
+//# sourceMappingURL=lint-boundary.d.ts.map

package/dist/lint-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint-boundary.d.ts","sourceRoot":"","sources":["../src/lint-boundary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAKH,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EACL,uBAAuB,EACvB,kBAAkB,EAClB,8BAA8B,GAC/B,MAAM,0BAA0B,CAAC"}

package/dist/lint-boundary.impl.d.mts

@@ -0,0 +1,41 @@
+/**
+ * Type surface for the plain-JS boundary checker implementation
+ * ({@link lint-boundary.impl.mjs}). Lets `lint-boundary.ts` import the runtime
+ * function with a precise type WITHOUT enabling `allowJs` for the package.
+ */
+
+/** A single boundary violation. */
+export interface BoundaryViolation {
+  /** The offending import source/module specifier. */
+  module: string;
+  /** Why it violates the boundary. */
+  reason: string;
+}
+
+/**
+ * Scan a single source file's text for forge-boundary violations.
+ *
+ * @param rawSource the file contents to scan.
+ * @returns the list of violations (empty when the file is clean).
+ */
+export function checkForgeBoundary(rawSource: string): BoundaryViolation[];
+
+/** The 11 @internal client.ts forge-adapter fns banned outside the factory. */
+export const BANNED_CLIENT_FORGE_FNS: readonly string[];
+
+/**
+ * Scan an apps/server source file for direct use of the 11 @internal client.ts
+ * forge-adapter fns. Catches NAMED imports, the NAMESPACE-alias member-access
+ * bypass, dynamic `import()`/`require()` member access, re-export laundering
+ * (`export { ... } from` / `export * from`), and destructuring off a namespace
+ * or dynamic-import alias — all the forms Biome's `noRestrictedImports` cannot
+ * see.
+ *
+ * @param filePath the file path (used only in the violation message).
+ * @param rawSource the file contents to scan.
+ * @returns the list of violations (empty when the file is clean).
+ */
+export function checkServerForgeClientBoundary(
+  filePath: string,
+  rawSource: string,
+): BoundaryViolation[];