@review-agent/sdk 0.0.0-stage → 0.2.1

package/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Cristian Moldovan
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

package/README.md

@@ -1,3 +1,26 @@
-# Temporary Holding Version
+# @review-agent/sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Embed [review-agent](https://github.com/crissmoldovan/review-agent), an AI pull-request reviewer you run inside your
+own environment, in your own Node.js service or script: one call reviews a pull request and returns what it found —
+the same review the GitHub App and the CLI run.
+
+```ts
+import { reviewPullRequest } from '@review-agent/sdk'
+
+const result = await reviewPullRequest({
+  repo: 'acme/widgets',
+  pr: 128,
+  github: { token: process.env.GITHUB_TOKEN! },
+  credential: { apiKey: process.env.ANTHROPIC_API_KEY! },
+})
+if (result.kind === 'reviewed') console.log(result.findings)
+```
+
+Posts nothing unless asked (`post: true`). Needs Node.js 22+ and
+[Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed. It starts no server and stores nothing.
+
+- [The SDK guide](https://github.com/crissmoldovan/review-agent/blob/main/docs/sdk.md) — every option, every result,
+  credentials, and examples
+- [The library reference](https://github.com/crissmoldovan/review-agent/blob/main/docs/library.md) — every export
+
+Apache-2.0.

package/dist/index.d.ts

@@ -0,0 +1,294 @@
+import { Octokit } from '@octokit/core';
+import { ReviewRecord, Finding, ReportMode, Lens, SecretValue, Tier, Effort, TierSettings, SeverityBands, DeploymentConfig, SkillSource } from '@review-agent/core';
+export { DeploymentConfig, Effort, Finding, Lens, ReportMode, ReviewRecord, SecretValue, Tier, Usage, defaultDeploymentConfig } from '@review-agent/core';
+import { SessionStage, StoppedBy, ReportKind, CheckConclusion, PostedComment, PublishCounts, ReportWant } from '@review-agent/github';
+export { CheckConclusion, DEFAULT_SESSION_DEADLINE_MS, PostedComment, PublishCounts, ReportKind, ReportWant, SessionStage, StoppedBy, pushAccessOf } from '@review-agent/github';
+
+/** How the outcome was reported on the reviewed commit (spec 0.2.0 §2.2, §4.3). */
+type ReportResult = {
+    /** What actually reported: `report: 'auto'` can start as a check run and fall back to a status. */
+    kind: ReportKind;
+    /** What a check run concluded — for a commit status too, whose own state says it differently: a
+     *  review that did not run is `neutral`, which a status says as `success` with a description saying
+     *  it is not a verdict (decision §14.2). `null` when the report was opened and could not be
+     *  completed: it may still say pending on the commit. */
+    conclusion: CheckConclusion | null;
+    /** The check run's page; for a commit status, the summary comment it links to. */
+    url: string | null;
+    /** The check run's id; null for a commit status. */
+    id: number | null;
+};
+/** What was posted on the pull request (spec 0.2.0 §4.3). */
+type PostedSummary = {
+    /** The mode it was published in, after the repository's own file and `check-only`-without-a-check-run
+     *  (decision §14.3) had their say. */
+    mode: ReportMode;
+    /** The summary comment's page, as GitHub gave it; null when none was written (`check-only`,
+     *  `silent`) or GitHub's answer carried none. */
+    summaryUrl: string | null;
+    summaryCommentId: number | null;
+    /** The review that carries the inline comments; null when none was posted. */
+    reviewId: number | null;
+    /** The inline comment each posted finding became — what a reply hangs off. */
+    comments: PostedComment[];
+    /** How many findings went where, and what the re-review did to earlier comments. */
+    counts: PublishCounts;
+};
+/** The review ran and said something — possibly that it found nothing. */
+type ReviewedResult = {
+    kind: 'reviewed';
+    /** Everything about the review: request, settings, the model's whole output, every check verdict,
+     *  usage and `costUsd` (model spend at per-token API prices, as the Claude Code CLI reports it — on
+     *  a subscription token the same figure is drawn from its allowance instead of billed). */
+    record: ReviewRecord;
+    /** What the review SAYS: after the disprove-it pass — a refuted finding is not here, the rest are at
+     *  the check's severity — with duplicates said once and paths checked against the code. Posted, it
+     *  is what was posted; not posted, what would have been, said as a first review is (no earlier
+     *  review is read). An empty list is a review that found nothing, which is a success. The model's
+     *  unfiltered list is `record.output.findings`. */
+    findings: Finding[];
+    /** What was posted; null when not posting. */
+    posted: PostedSummary | null;
+    /** How it was reported on the commit; null when not posting, with `report: 'none'`, or in `silent`. */
+    report: ReportResult | null;
+};
+/** The model ran and produced nothing usable, or was stopped before it could (spec 0.2.0 §4.3). */
+type UnfinishedResult = {
+    kind: 'unfinished';
+    record: ReviewRecord;
+    /** One sentence, already scanned for secrets: safe to show anyone who can see the pull request. */
+    reason: string;
+    /** `record.costUsd`: what was spent for nothing usable. */
+    spentUsd: number;
+    /** Whether running it again could not pay for the model twice: nothing was spent, and it was not
+     *  stopped on purpose. A retry policy reads this. */
+    retryable: boolean;
+    /** Who stopped it: its deadline, or the `signal`. Null when it stopped on its own. */
+    stopped: StoppedBy | null;
+    /** The "This review did not complete" summary, when posting; null otherwise, and for a stopped
+     *  review, which says so on its report alone. */
+    posted: PostedSummary | null;
+    report: ReportResult | null;
+};
+/** `authorize` said no. Nothing was downloaded, nothing was written, nothing was spent. */
+type RefusedResult = {
+    kind: 'refused';
+    reason: string;
+};
+/** The review did not produce one, and `stage` says how far it got (spec 0.2.0 §4.3):
+ *  - `before-model`: nothing was spent — GitHub would not answer, the report could not be opened
+ *    (`report: 'check-run'` with a token that cannot create one), `authorize` threw, the archive would
+ *    not download, or it was cancelled before the model started;
+ *  - `model`: the model ran, and the review failed or was stopped after that;
+ *  - `withheld`: the output matched a secret pattern, so nothing of it is said anywhere;
+ *  - `publish`: the review ran and was paid for, and GitHub would not take it. `record` and `findings`
+ *    carry it, so it is not lost. */
+type FailedResult = {
+    kind: 'failed';
+    stage: SessionStage;
+    /** One sentence, already scanned for secrets: safe to show anyone who can see the pull request. */
+    reason: string;
+    /** Model spend known to be gone, at per-token API prices: the record's figure where there is one,
+     *  what was watched going out where there is not — a lower bound when a pass was cut off. */
+    spentUsd: number;
+    retryable: boolean;
+    stopped: StoppedBy | null;
+    /** The finished review that could not be posted (`stage: 'publish'`); null otherwise. */
+    record: ReviewRecord | null;
+    /** What that review would have said, as `ReviewedResult.findings`; null with no `record`. */
+    findings: Finding[] | null;
+    report: ReportResult | null;
+    /** The error as it was thrown, for the host's own logs. Never scanned and never shown to anyone by
+     *  this package: `reason` is the sentence that is safe to repeat. */
+    cause: unknown;
+};
+type ReviewResult = ReviewedResult | UnfinishedResult | RefusedResult | FailedResult;
+
+/** Where a review has got to (spec 0.2.0 §4.2, `onProgress`). In the order a posted review passes
+ *  them: `preparing` (reading the pull request and its settings), `downloading`, `reviewing`,
+ *  `checking`, `rechecking` (a re-review of a pull request reviewed before), `publishing`,
+ *  `reporting` (finishing the check run or commit status), `done`. A review skips what it does not
+ *  do: a printed one never publishes or reports, a first review never re-checks. */
+type ProgressStage = 'preparing' | 'downloading' | 'reviewing' | 'checking' | 'rechecking' | 'publishing' | 'reporting' | 'done';
+type About = {
+    /** `'owner/name'`, so one handler can follow several reviews. */
+    repo: string;
+    pr: number;
+};
+/** The review has reached `stage`. `note` is absent, which is how these are told from a `NoteEvent`. */
+type StageEvent = About & {
+    note?: undefined;
+} & ({
+    stage: 'preparing';
+} | {
+    stage: 'downloading';
+}
+/** Once per reviewer: on a multi-reviewer review, once per focus as it starts, with its `focus`;
+ *  otherwise once, with `focus: null`. */
+ | {
+    stage: 'reviewing';
+    focus: Lens | null;
+}
+/** `findings`: how many the disprove-it pass is checking. */
+ | {
+    stage: 'checking';
+    findings: number;
+}
+/** `findings`: how many earlier findings the re-review pass is asked about. */
+ | {
+    stage: 'rechecking';
+    findings: number;
+} | {
+    stage: 'publishing';
+} | {
+    stage: 'reporting';
+    report: ReportKind;
+}
+/** The last event of every call that returns: the result's kind. Sent once the checkout is gone. */
+ | {
+    stage: 'done';
+    result: ReviewResult['kind'];
+});
+/** A line of progress inside the stage the review last reached — the lines the CLI prints on stderr
+ *  (credential files removed from the checkout, a focused reviewer that failed, a report that could
+ *  not be completed). Not a new stage. `details` are the fields the line was logged with, `{}` when
+ *  none; meant for the host's own logs. */
+type NoteEvent = About & {
+    stage: ProgressStage;
+    note: string;
+    details: Record<string, unknown>;
+};
+type ProgressEvent = StageEvent | NoteEvent;
+
+/** How to reach GitHub (spec 0.2.0 §4.2): a token, from which a client is built with the API version
+ *  every way in was proven against (`octokitFor`), or a client the host already has. `baseUrl` is a
+ *  GitHub Enterprise Server's API root, `https://<host>/api/v3`; left out, github.com. */
+type GitHubAccess = {
+    token: string;
+    baseUrl?: string;
+} | {
+    octokit: Octokit;
+};
+/** The model credential (spec 0.2.0 §2.3): an Anthropic API key — the normal path, and the only one
+ *  for a service that reviews for other people — a subscription token from `claude setup-token`, for
+ *  your own use, or this machine's `claude login`. A value may be passed already wrapped in a
+ *  `SecretValue`; a bare string is wrapped on the way in, so nothing this package hands on prints it. */
+type CredentialOption = {
+    apiKey: string | SecretValue;
+} | {
+    oauthToken: string | SecretValue;
+} | 'claude-login';
+/** The deployment settings (docs/configuration.md in the repository), any of them left out — at any
+ *  depth. `settings: { report: { checkRunName: 'review' } }` changes the one name and keeps
+ *  every other report setting; see `mergeSettings` for why the merge goes exactly this deep.
+ *
+ *  Every `Partial<DeploymentConfig>` is one of these (spec 0.2.0 §4.2 names that type), so a host can
+ *  pass a whole deployment object it already keeps. `command` and `autoReview` are read only by the
+ *  App's receiver, and are accepted here and ignored. */
+type ReviewSettings = {
+    command?: string;
+    model?: string;
+    effort?: Effort;
+    tiers?: {
+        [T in Tier]?: Partial<TierSettings>;
+    };
+    severity?: {
+        bands?: Partial<SeverityBands>;
+        postInlineAtOrAbove?: number;
+    };
+    report?: Partial<DeploymentConfig['report']>;
+    skills?: SkillSource[];
+    instructions?: string;
+    autoReview?: DeploymentConfig['autoReview'];
+    allowMulti?: boolean;
+};
+/** What `authorize` is asked about, before anything is spent (spec 0.2.0 §4.2). It carries what
+ *  `pushAccessOf` reads — `octokit`, `owner`, `repo`, `username` — so `authorize: pushAccessOf` is the
+ *  App's own gate, as it is. */
+type AuthorizeRequest = {
+    /** The client this review reads GitHub with. */
+    octokit: Octokit;
+    owner: string;
+    repo: string;
+    pr: number;
+    /** `requestedBy`: the login whose request this is. */
+    username: string;
+    /** The commit this review would read, as GitHub answered just now. */
+    headSha: string;
+};
+/** Several focused reviewers instead of one (spec 0.2.0 §8.3), and how many of them run at once: all
+ *  three when `true`. Each is a Claude process of its own, and one review peaks around 400 MiB, so a
+ *  host short of memory says `{ concurrency: 1 }`. */
+type MultiOption = boolean | {
+    concurrency: number;
+};
+type ReviewOptions = {
+    /** The repository, `'owner/name'`. */
+    repo: string;
+    /** The pull request's number. */
+    pr: number;
+    github: GitHubAccess;
+    /** Left out: from this process's environment, exactly one of `ANTHROPIC_API_KEY` and
+     *  `CLAUDE_CODE_OAUTH_TOKEN` (`modelCredentialFromEnv`, as the App's runner reads it). */
+    credential?: CredentialOption;
+    /** Post the review, its inline comments and its summary, and report on the commit. Default `false`:
+     *  review, return the result, and write nothing to GitHub at all. */
+    post?: boolean;
+    /** How to report the outcome on the commit when posting (spec 0.2.0 §2.2). `'auto'`, the default:
+     *  a check run when the token can create one, a commit status when it cannot. `'check-run'` with a
+     *  token that cannot create one is a `failed` result before any money is spent. Read only when
+     *  posting. */
+    report?: ReportWant;
+    /** This request, as the CLI's flags say it; the settings' own when left out. */
+    tier?: Tier;
+    effort?: Effort;
+    /** The model's name, e.g. `claude-opus-5`. */
+    model?: string;
+    /** Run the disprove-it pass, whatever the tier says (`true`), or skip it (`false`). */
+    check?: boolean;
+    /** Extra context for the reviewer. It is data, never instruction. */
+    brief?: string;
+    /** Lower this review's budget, in US dollars at per-token API prices. It can never be raised past
+     *  the tier's. */
+    budgetUsd?: number;
+    multi?: MultiOption;
+    settings?: ReviewSettings;
+    /** Whose request this is: the login `authorize` is asked about, and `record.request.requestedBy`. */
+    requestedBy?: string;
+    /** A gate asked after the pull request is read and before anything is downloaded or spent. `false`
+     *  is a `refused` result. It must answer `true` or `false`; it needs `requestedBy`. */
+    authorize?: (who: AuthorizeRequest) => boolean | Promise<boolean>;
+    /** Which Claude Code to run: an absolute path. Left out, `REVIEW_AGENT_CLAUDE_BIN`, else `claude`
+     *  on `PATH`. */
+    claude?: {
+        bin?: string;
+    };
+    /** Where checkouts go, each in a new directory of its own that is removed when the review ends.
+     *  Absolute. Left out, the OS temp directory. */
+    workDir?: string;
+    /** Where skills are cached. Absolute. Left out, this OS's cache directory. */
+    skillCacheDir?: string;
+    /** The review stops itself this long after it starts — after the pull request has been read.
+     *  Default 30 minutes. */
+    deadlineMs?: number;
+    signal?: AbortSignal;
+    onProgress?: (event: ProgressEvent) => void;
+};
+
+/** Reviews one pull request, and returns what happened (spec 0.2.0 §4): the same review the GitHub
+ *  App and the CLI run — `prepareReview` then `runReviewSession`, in `@review-agent/github` — called
+ *  from a host's own code.
+ *
+ *  It RETURNS every outcome — `reviewed`, `unfinished`, `refused`, `failed` — so a host can tell "the
+ *  reviewer found nothing" from "the reviewer did not run" (§4.3). It THROWS only what is the
+ *  programmer's to fix, before anything is fetched or spent: a missing or wrong-typed option
+ *  (`TypeError`), or a process no review can run in — no model credential, two, or
+ *  `ANTHROPIC_BASE_URL` set (`Error`). One more `TypeError` can come later, still before anything is
+ *  spent: an `authorize` that answers something other than `true` or `false`.
+ *
+ *  Nothing is shared between calls but the skill cache (§4.4): each builds its own client, credential
+ *  and checkout, and this module keeps no state. Every checkout it made is removed before it returns,
+ *  whichever way the review ended. */
+declare function reviewPullRequest(options: ReviewOptions): Promise<ReviewResult>;
+
+export { type AuthorizeRequest, type CredentialOption, type FailedResult, type GitHubAccess, type MultiOption, type NoteEvent, type PostedSummary, type ProgressEvent, type ProgressStage, type RefusedResult, type ReportResult, type ReviewOptions, type ReviewResult, type ReviewSettings, type ReviewedResult, type StageEvent, type UnfinishedResult, reviewPullRequest };

package/dist/index.js

@@ -0,0 +1,606 @@
+// src/review.ts
+import {
+  defaultRunReviewDeps,
+  prepareReview,
+  removeCheckout,
+  reporterFor,
+  runReviewSession,
+  saidSafely,
+  tokenIdentityOf
+} from "@review-agent/github";
+
+// src/options.ts
+import { isAbsolute } from "path";
+import {
+  defaultDeploymentConfig,
+  gatewayBaseUrlRefusal,
+  modelCredentialFromEnv,
+  SecretValue
+} from "@review-agent/core";
+import { DEFAULT_SESSION_DEADLINE_MS, octokitFor } from "@review-agent/github";
+var TIER_SET = { basic: true, normal: true, thorough: true };
+var EFFORT_SET = { low: true, medium: true, high: true, xhigh: true, max: true };
+var MODE_SET = {
+  "inline+summary": true,
+  "summary-only": true,
+  "check-only": true,
+  silent: true
+};
+var AUTO_REVIEW_SET = { "open+ready": true, off: true };
+var REPORT_SET = { auto: true, "check-run": true, "commit-status": true, none: true };
+var TIERS = Object.keys(TIER_SET);
+var EFFORTS = Object.keys(EFFORT_SET);
+var MODES = Object.keys(MODE_SET);
+var AUTO_REVIEWS = Object.keys(AUTO_REVIEW_SET);
+var REPORTS = Object.keys(REPORT_SET);
+var OPTION_KEYS = /* @__PURE__ */ new Set([
+  "repo",
+  "pr",
+  "github",
+  "credential",
+  "post",
+  "report",
+  "tier",
+  "effort",
+  "model",
+  "check",
+  "brief",
+  "budgetUsd",
+  "multi",
+  "settings",
+  "requestedBy",
+  "authorize",
+  "claude",
+  "workDir",
+  "skillCacheDir",
+  "deadlineMs",
+  "signal",
+  "onProgress"
+]);
+var MAX_DEADLINE_MS = 2147483647;
+var REPO = /^([A-Za-z0-9](?:[A-Za-z0-9-]{0,38}))\/([A-Za-z0-9._-]{1,100})$/;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isPlainObject = (v) => {
+  if (!isRecord(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+};
+var oneOf = (name, v, allowed) => {
+  if (typeof v !== "string" || !allowed.includes(v)) {
+    throw new TypeError(`${name} must be one of ${allowed.join(", ")}, got ${JSON.stringify(v) ?? String(v)}`);
+  }
+  return v;
+};
+var nonEmptyString = (name, v) => {
+  if (typeof v !== "string" || v === "") throw new TypeError(`${name} must be a non-empty string`);
+  return v;
+};
+var absolutePath = (name, v) => {
+  const s = nonEmptyString(name, v);
+  if (!isAbsolute(s)) throw new TypeError(`${name} must be an absolute path, got ${JSON.stringify(s)}`);
+  return s;
+};
+var onlyKeys = (name, v, allowed) => {
+  for (const k of Object.keys(v)) {
+    if (!allowed.includes(k)) throw new TypeError(`${name}.${k} is not an option; ${name} takes ${allowed.join(", ")}`);
+  }
+};
+var secretOf = (name, v) => {
+  if (isRecord(v) && typeof v.reveal === "function") {
+    const s = v;
+    if (typeof s.reveal() !== "string" || s.reveal() === "") throw new TypeError(`${name} is empty`);
+    return s;
+  }
+  if (typeof v !== "string" || v === "") {
+    throw new TypeError(`${name} must be a non-empty string or a SecretValue (its value is not shown)`);
+  }
+  return new SecretValue(v);
+};
+var credentialOf = (c, env) => {
+  let credential;
+  if (c === void 0) {
+    return modelCredentialFromEnv(env, { allowLogin: false });
+  } else if (c === "claude-login") {
+    credential = { kind: "claude-login" };
+  } else if (isRecord(c)) {
+    const keys = Object.keys(c);
+    if (keys.length !== 1 || keys[0] !== "apiKey" && keys[0] !== "oauthToken") {
+      throw new TypeError("credential must be exactly one of { apiKey }, { oauthToken } or 'claude-login'");
+    }
+    credential = keys[0] === "apiKey" ? { kind: "api-key", value: secretOf("credential.apiKey", c.apiKey) } : { kind: "oauth-token", value: secretOf("credential.oauthToken", c.oauthToken) };
+  } else {
+    throw new TypeError("credential must be { apiKey }, { oauthToken } or 'claude-login'");
+  }
+  const gateway = gatewayBaseUrlRefusal(env);
+  if (gateway !== null) throw new Error(gateway);
+  return credential;
+};
+var octokitOf = (g) => {
+  if (!isRecord(g)) throw new TypeError("github must be { token, baseUrl? } or { octokit }");
+  if (Object.hasOwn(g, "octokit")) {
+    onlyKeys("github", g, ["octokit"]);
+    if (!isRecord(g.octokit) || typeof g.octokit.request !== "function") {
+      throw new TypeError("github.octokit must be an Octokit client");
+    }
+    return g.octokit;
+  }
+  onlyKeys("github", g, ["token", "baseUrl"]);
+  if (typeof g.token !== "string" || g.token === "") {
+    throw new TypeError("github.token must be a non-empty string (its value is not shown)");
+  }
+  if (g.baseUrl === void 0) return octokitFor({ token: g.token });
+  const baseUrl = nonEmptyString("github.baseUrl", g.baseUrl);
+  let protocol;
+  try {
+    protocol = new URL(baseUrl).protocol;
+  } catch {
+    throw new TypeError(`github.baseUrl must be a URL, got ${JSON.stringify(baseUrl)}`);
+  }
+  if (protocol !== "https:" && protocol !== "http:") {
+    throw new TypeError(`github.baseUrl must be an http(s) URL, got ${JSON.stringify(baseUrl)}`);
+  }
+  return octokitFor({ token: g.token, baseUrl });
+};
+var ABSENT_BY_DEFAULT = { instructions: "string" };
+var ENUM_AT = {
+  effort: EFFORTS,
+  "report.mode": MODES,
+  autoReview: AUTO_REVIEWS,
+  "tiers.basic.effort": EFFORTS,
+  "tiers.normal.effort": EFFORTS,
+  "tiers.thorough.effort": EFFORTS
+};
+var NULLABLE_NUMBER_AT = /* @__PURE__ */ new Set(["report.failAtOrAbove"]);
+var leafOf = (base, over, path) => {
+  const at = path.join(".");
+  const name = `settings.${at}`;
+  const allowed = ENUM_AT[at];
+  if (allowed !== void 0) return oneOf(name, over, allowed);
+  if (ABSENT_BY_DEFAULT[at] === "string") {
+    if (typeof over !== "string") throw new TypeError(`${name} must be a string`);
+    return over;
+  }
+  if (NULLABLE_NUMBER_AT.has(at)) {
+    if (over !== null && (typeof over !== "number" || !Number.isFinite(over))) throw new TypeError(`${name} must be a number or null`);
+    return over;
+  }
+  if (Array.isArray(base)) {
+    if (!Array.isArray(over)) throw new TypeError(`${name} must be an array`);
+    return [...over];
+  }
+  if (typeof base === "number") {
+    if (typeof over !== "number" || !Number.isFinite(over)) throw new TypeError(`${name} must be a finite number`);
+    return over;
+  }
+  if (typeof over !== typeof base) throw new TypeError(`${name} must be a ${typeof base}`);
+  return over;
+};
+var mergeAt = (base, over, path) => {
+  if (over === void 0) return base;
+  if (isPlainObject(base)) {
+    const name = path.length === 0 ? "settings" : `settings.${path.join(".")}`;
+    if (!isPlainObject(over)) throw new TypeError(`${name} must be an object`);
+    const out = { ...base };
+    for (const [key, value] of Object.entries(over)) {
+      const at = [...path, key];
+      if (!Object.hasOwn(base, key) && !Object.hasOwn(ABSENT_BY_DEFAULT, at.join("."))) {
+        throw new TypeError(`settings.${at.join(".")} is not a setting`);
+      }
+      out[key] = mergeAt(base[key], value, at);
+    }
+    return out;
+  }
+  return leafOf(base, over, path);
+};
+var mergeSettings = (over) => {
+  const base = defaultDeploymentConfig();
+  if (over === void 0) return base;
+  return mergeAt(base, over, []);
+};
+var normalise = (options, env) => {
+  if (!isRecord(options)) throw new TypeError("reviewPullRequest takes one options object");
+  for (const k of Object.keys(options)) {
+    if (!OPTION_KEYS.has(k)) throw new TypeError(`${k} is not an option of reviewPullRequest`);
+  }
+  const o = options;
+  if (typeof o.repo !== "string") throw new TypeError("repo must be 'owner/name'");
+  const where = REPO.exec(o.repo);
+  if (where === null || where[2] === "." || where[2] === "..") {
+    throw new TypeError(`repo must be 'owner/name', got ${JSON.stringify(o.repo)}`);
+  }
+  const [, owner, repo] = where;
+  if (typeof o.pr !== "number" || !Number.isInteger(o.pr) || o.pr <= 0) {
+    throw new TypeError(`pr must be a pull request number, got ${JSON.stringify(o.pr) ?? String(o.pr)}`);
+  }
+  if (o.github === void 0) throw new TypeError("github is required: { token, baseUrl? } or { octokit }");
+  const octokit = octokitOf(o.github);
+  if (o.post !== void 0 && typeof o.post !== "boolean") throw new TypeError("post must be true or false");
+  const report = o.report === void 0 ? "auto" : oneOf("report", o.report, REPORTS);
+  let focusConcurrency = null;
+  let multi = false;
+  if (o.multi !== void 0 && o.multi !== false) {
+    if (o.multi === true) {
+      multi = true;
+    } else if (isRecord(o.multi)) {
+      onlyKeys("multi", o.multi, ["concurrency"]);
+      const c = o.multi.concurrency;
+      if (typeof c !== "number" || !Number.isInteger(c) || c < 1) {
+        throw new TypeError(`multi.concurrency must be a whole number of at least 1, got ${JSON.stringify(c) ?? String(c)}`);
+      }
+      multi = true;
+      focusConcurrency = c;
+    } else {
+      throw new TypeError("multi must be true, false or { concurrency }");
+    }
+  }
+  if (o.check !== void 0 && typeof o.check !== "boolean") throw new TypeError("check must be true or false");
+  if (o.brief !== void 0 && typeof o.brief !== "string") throw new TypeError("brief must be a string");
+  if (o.budgetUsd !== void 0 && (typeof o.budgetUsd !== "number" || !Number.isFinite(o.budgetUsd) || o.budgetUsd <= 0)) {
+    throw new TypeError(`budgetUsd must be a positive number of US dollars, got ${JSON.stringify(o.budgetUsd) ?? String(o.budgetUsd)}`);
+  }
+  const requestedBy = o.requestedBy === void 0 ? null : nonEmptyString("requestedBy", o.requestedBy);
+  const ask = {
+    ...o.tier !== void 0 && { tier: oneOf("tier", o.tier, TIERS) },
+    ...o.effort !== void 0 && { effort: oneOf("effort", o.effort, EFFORTS) },
+    ...o.model !== void 0 && { model: nonEmptyString("model", o.model) },
+    ...o.check !== void 0 && { check: o.check },
+    ...o.brief !== void 0 && { brief: o.brief },
+    ...o.budgetUsd !== void 0 && { budgetUsd: o.budgetUsd },
+    // Only `true` is carried, as `refuseUnbuilt` carries it: false and absent mean the same.
+    ...multi && { multi: true },
+    ...requestedBy !== null && { requestedBy }
+  };
+  const deployment = mergeSettings(o.settings);
+  if (o.authorize !== void 0 && typeof o.authorize !== "function") throw new TypeError("authorize must be a function");
+  if (o.authorize !== void 0 && requestedBy === null) {
+    throw new TypeError("authorize needs requestedBy: the login whose request it decides");
+  }
+  let bin = null;
+  if (o.claude !== void 0) {
+    if (!isRecord(o.claude)) throw new TypeError("claude must be { bin? }");
+    onlyKeys("claude", o.claude, ["bin"]);
+    if (o.claude.bin !== void 0) bin = absolutePath("claude.bin", o.claude.bin);
+  }
+  const workDir = o.workDir === void 0 ? null : absolutePath("workDir", o.workDir);
+  const skillCacheDir = o.skillCacheDir === void 0 ? null : absolutePath("skillCacheDir", o.skillCacheDir);
+  const deadlineMs = o.deadlineMs ?? DEFAULT_SESSION_DEADLINE_MS;
+  if (typeof deadlineMs !== "number" || !Number.isFinite(deadlineMs) || deadlineMs <= 0 || deadlineMs > MAX_DEADLINE_MS) {
+    throw new TypeError(`deadlineMs must be a positive number of milliseconds, at most ${MAX_DEADLINE_MS}, got ${JSON.stringify(o.deadlineMs) ?? String(o.deadlineMs)}`);
+  }
+  if (o.signal !== void 0) {
+    const s = o.signal;
+    if (!isRecord(s) || typeof s.aborted !== "boolean" || typeof s.addEventListener !== "function") {
+      throw new TypeError("signal must be an AbortSignal");
+    }
+  }
+  if (o.onProgress !== void 0 && typeof o.onProgress !== "function") throw new TypeError("onProgress must be a function");
+  const credential = credentialOf(o.credential, env);
+  return {
+    owner,
+    repo,
+    pr: o.pr,
+    octokit,
+    credential,
+    post: o.post ?? false,
+    report,
+    ask,
+    deployment,
+    requestedBy,
+    authorize: o.authorize ?? null,
+    bin,
+    workDir,
+    skillCacheDir,
+    focusConcurrency,
+    deadlineMs,
+    signal: o.signal ?? null,
+    onProgress: o.onProgress ?? null
+  };
+};
+
+// src/progress.ts
+import {
+  REVIEW_LENSES,
+  reviewSystemPrompt
+} from "@review-agent/core";
+import {
+  publishReview
+} from "@review-agent/github";
+var progressFor = (a) => {
+  const about = { repo: a.repo, pr: a.pr };
+  let current = "preparing";
+  const send = (e) => {
+    if (a.onProgress === null) return;
+    try {
+      const r = a.onProgress(e);
+      if (typeof r === "object" && r !== null && typeof r.then === "function") {
+        r.then(void 0, () => {
+        });
+      }
+    } catch {
+    }
+  };
+  return {
+    stage: (e) => {
+      current = e.stage;
+      send({ ...about, ...e });
+    },
+    note: (line) => {
+      send({ ...about, stage: current, note: line, details: {} });
+    },
+    log: (message, fields) => {
+      send({ ...about, stage: current, note: message, details: { ...fields } });
+    }
+  };
+};
+var focusOf = (input) => {
+  if (!input.settings.multi) return null;
+  return REVIEW_LENSES.find((lens) => reviewSystemPrompt({ settings: input.settings, lens }) === input.systemPrompt) ?? null;
+};
+var watchedDeps = (base, progress, made) => ({
+  ...base,
+  makeCheckoutDir: async () => {
+    const dir = await base.makeCheckoutDir();
+    made.push(dir);
+    return dir;
+  },
+  downloadArchive: async (a) => {
+    progress.stage({ stage: "downloading" });
+    return base.downloadArchive(a);
+  },
+  runEngine: async (input) => {
+    progress.stage({ stage: "reviewing", focus: focusOf(input) });
+    return base.runEngine(input);
+  },
+  runCheckPass: async (x) => {
+    if (x.findings.length > 0) progress.stage({ stage: "checking", findings: x.findings.length });
+    return base.runCheckPass(x);
+  },
+  runRecheckPass: async (x) => {
+    progress.stage({ stage: "rechecking", findings: x.previous.length });
+    return base.runRecheckPass(x);
+  }
+});
+var watchedPublish = (progress) => async (a) => {
+  progress.stage({ stage: "publishing" });
+  return publishReview(a);
+};
+var watchedReporter = (reporter, progress) => ({
+  kind: reporter.kind,
+  start: async (s) => {
+    const handle = await reporter.start(s);
+    if (handle === null) return null;
+    const watched = {
+      get kind() {
+        return handle.kind;
+      },
+      get id() {
+        return handle.id;
+      },
+      get url() {
+        return handle.url;
+      },
+      finish: async (f) => {
+        progress.stage({ stage: "reporting", report: handle.kind });
+        return handle.finish(f);
+      }
+    };
+    return watched;
+  }
+});
+
+// src/result.ts
+import {
+  writesSummaryComment
+} from "@review-agent/core";
+import {
+  anchorFindings,
+  duplicatesIn,
+  postedCommentsOf,
+  selectForPosting
+} from "@review-agent/github";
+var wouldSay = (review2) => {
+  const output = review2.result.output;
+  if (output === null) return [];
+  const { findings } = output;
+  const completed = review2.result.failure === null;
+  const mode = review2.settings.report.mode;
+  const sayingMode = !completed ? "summary-only" : writesSummaryComment(mode) ? mode : "inline+summary";
+  const checked = review2.check === null ? null : { findings, verdicts: review2.check.verdicts };
+  const duplicates = duplicatesIn(checked);
+  const anchored = anchorFindings({
+    findings: findings.filter((_, i) => !duplicates.has(i)),
+    pr: review2.pr,
+    checkoutDir: review2.checkoutDir
+  });
+  const plan = selectForPosting({
+    anchored,
+    settings: { ...review2.settings, report: { ...review2.settings.report, mode: sayingMode } },
+    previous: null,
+    check: checked
+  });
+  return [...plan.inline.map((x) => x.finding), ...plan.summaryOnly];
+};
+var reportOf = (r) => r === null ? null : { kind: r.kind, conclusion: r.conclusion, url: r.url, id: r.id };
+var postedOf = (p) => ({
+  mode: p.mode,
+  summaryUrl: p.summaryUrl,
+  summaryCommentId: p.summaryCommentId,
+  reviewId: p.reviewId,
+  comments: postedCommentsOf(p),
+  counts: { ...p.counts }
+});
+var resultOf = (s) => {
+  switch (s.kind) {
+    case "reviewed":
+      return {
+        kind: "reviewed",
+        record: s.record,
+        findings: s.published === null ? wouldSay(s.review) : s.published.findings,
+        posted: s.published === null ? null : postedOf(s.published),
+        report: reportOf(s.report)
+      };
+    case "unfinished":
+      return {
+        kind: "unfinished",
+        record: s.record,
+        reason: s.reason,
+        spentUsd: s.spentUsd,
+        retryable: s.retryable,
+        stopped: s.stopped,
+        posted: s.published === null ? null : postedOf(s.published),
+        report: reportOf(s.report)
+      };
+    case "failed":
+      return {
+        kind: "failed",
+        stage: s.stage,
+        reason: s.reason,
+        spentUsd: s.spentUsd,
+        retryable: s.retryable,
+        stopped: s.stopped,
+        record: s.review?.record ?? null,
+        findings: s.review === null ? null : wouldSay(s.review),
+        report: reportOf(s.report),
+        cause: s.cause
+      };
+  }
+};
+
+// src/review.ts
+var messageOf = (e) => e instanceof Error ? e.message : String(e);
+var failedBeforeModel = (reason, cause) => ({
+  kind: "failed",
+  stage: "before-model",
+  reason,
+  spentUsd: 0,
+  retryable: true,
+  stopped: null,
+  record: null,
+  findings: null,
+  report: null,
+  cause
+});
+var cancelled = () => ({
+  kind: "failed",
+  stage: "before-model",
+  reason: "the review was cancelled before it started",
+  spentUsd: 0,
+  retryable: false,
+  stopped: "cancelled",
+  record: null,
+  findings: null,
+  report: null,
+  cause: void 0
+});
+var fromPrepare = (f) => ({
+  kind: "failed",
+  stage: f.stage,
+  reason: f.reason,
+  spentUsd: f.spentUsd,
+  retryable: f.retryable,
+  stopped: f.stopped,
+  record: null,
+  findings: null,
+  report: null,
+  cause: f.cause
+});
+async function reviewPullRequest(options) {
+  const o = normalise(options, process.env);
+  const progress = progressFor({ repo: `${o.owner}/${o.repo}`, pr: o.pr, onProgress: o.onProgress });
+  const result = await review(o, progress);
+  progress.stage({ stage: "done", result: result.kind });
+  return result;
+}
+var review = async (o, progress) => {
+  const aborted = () => o.signal?.aborted === true;
+  const made = [];
+  try {
+    if (aborted()) return cancelled();
+    progress.stage({ stage: "preparing" });
+    const prepared = await prepareReview({
+      octokit: o.octokit,
+      owner: o.owner,
+      repo: o.repo,
+      number: o.pr,
+      deployment: o.deployment,
+      ask: o.ask
+    });
+    if (prepared.kind === "failed") return fromPrepare(prepared);
+    if (aborted()) return cancelled();
+    if (o.authorize !== null && o.requestedBy !== null) {
+      let allowed;
+      try {
+        allowed = await o.authorize({
+          octokit: o.octokit,
+          owner: o.owner,
+          repo: o.repo,
+          pr: o.pr,
+          username: o.requestedBy,
+          headSha: prepared.pr.headSha
+        });
+      } catch (e) {
+        return failedBeforeModel(`the review could not be authorized: ${saidSafely(messageOf(e))}`, e);
+      }
+      if (typeof allowed !== "boolean") {
+        throw new TypeError(`authorize must answer true or false, and answered ${typeof allowed}`);
+      }
+      if (!allowed) {
+        return { kind: "refused", reason: `authorize did not allow @${o.requestedBy}'s request; nothing was downloaded or spent` };
+      }
+      if (aborted()) return cancelled();
+    }
+    let reporter;
+    let selfLogin;
+    if (o.post) {
+      try {
+        const identity = await tokenIdentityOf(o.octokit);
+        reporter = watchedReporter(await reporterFor({ octokit: o.octokit, want: o.report, identity }), progress);
+        if (identity.kind === "user") selfLogin = identity.login;
+      } catch (e) {
+        return failedBeforeModel(`GitHub would not say whose token this is: ${saidSafely(messageOf(e))}`, e);
+      }
+    }
+    const runReviewDeps = watchedDeps(defaultRunReviewDeps({
+      note: progress.note,
+      ...o.workDir !== null && { workDir: o.workDir },
+      ...o.skillCacheDir !== null && { skillCacheDir: o.skillCacheDir },
+      ...o.focusConcurrency !== null && { concurrency: o.focusConcurrency }
+    }), progress, made);
+    const session = await runReviewSession({
+      prepared,
+      post: o.post,
+      ...reporter !== void 0 && { reporter },
+      via: { kind: "sdk" },
+      ...selfLogin !== void 0 && { selfLogin },
+      // The credential travels with this review and no other (spec 0.2.0 §3.2): the Claude process
+      // gets it and nothing ambient. Never written to `process.env`, where a concurrent review would
+      // read it.
+      runtime: { credential: o.credential, ...o.bin !== null && { bin: o.bin } },
+      ...o.signal !== null && { signal: o.signal },
+      deadlineMs: o.deadlineMs,
+      // Removed below, with every other checkout this review made.
+      keepCheckout: true,
+      deps: { runReviewDeps, publishReview: watchedPublish(progress), log: progress.log }
+    });
+    return resultOf(session);
+  } finally {
+    for (const dir of made) await removeCheckout(dir);
+  }
+};
+
+// src/index.ts
+import {
+  DEFAULT_SESSION_DEADLINE_MS as DEFAULT_SESSION_DEADLINE_MS2,
+  pushAccessOf
+} from "@review-agent/github";
+import {
+  defaultDeploymentConfig as defaultDeploymentConfig2,
+  SecretValue as SecretValue2
+} from "@review-agent/core";
+export {
+  DEFAULT_SESSION_DEADLINE_MS2 as DEFAULT_SESSION_DEADLINE_MS,
+  SecretValue2 as SecretValue,
+  defaultDeploymentConfig2 as defaultDeploymentConfig,
+  pushAccessOf,
+  reviewPullRequest
+};

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@review-agent/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.1",
+  "license": "Apache-2.0",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/crissmoldovan/review-agent.git",
+    "directory": "packages/sdk"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@octokit/core": "^7.0.8",
+    "@review-agent/core": "0.2.1",
+    "@review-agent/github": "0.2.1"
+  },
+  "devDependencies": {
+    "tar": "^7.4.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "types": "./dist/index.d.ts"
 }