@effect-agent/pr-review 0.1.0-beta.8 → 0.1.0-beta.80

package/dist/Review.d.mts

@@ -0,0 +1,295 @@
+import { i as ReviewRepository, n as ReviewContextError, o as ReviewSearchResult, r as ReviewFileList, s as ReviewSource } from "./ReviewRepository-Wd_4qCaO.mjs";
+import { Effect, Layer, Schema } from "effect";
+import * as Agent from "effect-agent/Agent";
+import * as AgentRuntime from "effect-agent/AgentRuntime";
+import { ContextCompactor } from "effect-agent/ContextCompactor";
+import { IdGenerator } from "effect-agent/IdGenerator";
+import { RunCostEstimator } from "effect-agent/RunOptions";
+import { ThreadHistory } from "effect-agent/ThreadHistory";
+import { LanguageModel, Model, Tool } from "effect/unstable/ai";
+declare namespace Review_d_exports {
+  export { MAX_REVIEW_FILES, MAX_REVIEW_PATCH_CHARS, MAX_REVIEW_TOTAL_PATCH_CHARS, ReviewCategory, ReviewChange, ReviewCompaction, ReviewCompactionEvent, ReviewContextTokenLimit, ReviewCostControl, ReviewCostSnapshot, ReviewFinding, ReviewFollowUp, ReviewOutcome, ReviewReport, ReviewRequest, ReviewResearchConcurrency, ReviewResearchStats, ReviewResolution, ReviewSeverity, ReviewUsage, ReviewVerificationError, ReviewerOptions, isCommentableLine, makeReviewer };
+}
+/** Host admission bounds, independent of the model's working context. */
+declare const MAX_REVIEW_FILES = 1000;
+declare const MAX_REVIEW_PATCH_CHARS = 2000000;
+declare const MAX_REVIEW_TOTAL_PATCH_CHARS = 8000000;
+/** Native strategies share the same review ledger and execution budgets. */
+declare const ReviewCompaction: Schema.Literals<readonly ["prune", "rollover"]>;
+type ReviewCompaction = typeof ReviewCompaction.Type;
+/** Working-context bound for pressure experiments; it never widens host input admission. */
+declare const ReviewContextTokenLimit: Schema.Int;
+/** Emitted native compaction evidence, without source, summaries, or handoff text. */
+declare const ReviewCompactionEvent: Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["clear-tool-results", "summarize", "rollover"]>;
+  readonly turn: Schema.Int;
+  readonly tokensBeforeEstimate: Schema.Natural;
+  readonly tokensAfterEstimate: Schema.Natural;
+}>;
+type ReviewCompactionEvent = typeof ReviewCompactionEvent.Type;
+declare const ReviewResearchConcurrency: Schema.Literals<readonly [1, 2]>;
+/** Measured native delegation events and incomplete child results; contains no child prose. */
+declare const ReviewResearchStats: Schema.Struct<{
+  readonly delegations: Schema.Natural;
+  readonly started: Schema.Natural;
+  readonly completed: Schema.Natural;
+  readonly failed: Schema.Natural;
+  readonly interrupted: Schema.Natural;
+  readonly incomplete: Schema.Natural;
+}>;
+declare const ReviewChange_base: Schema.Class<ReviewChange, Schema.Struct<{
+  readonly path: Schema.NonEmptyString;
+  readonly patch: Schema.NonEmptyString;
+}>, {}>;
+/** One complete textual patch supplied by the host. */
+declare class ReviewChange extends ReviewChange_base {}
+declare const ReviewFollowUp_base: Schema.Class<ReviewFollowUp, Schema.Struct<{
+  readonly id: Schema.NonEmptyString;
+  readonly description: Schema.NonEmptyString;
+}>, {}>;
+/** Complete prior feedback selected by the host for fix verification, not new defect discovery. */
+declare class ReviewFollowUp extends ReviewFollowUp_base {}
+declare const ReviewResolution_base: Schema.Class<ReviewResolution, Schema.Struct<{
+  readonly id: Schema.NonEmptyString;
+  readonly evidence: Schema.NonEmptyString;
+}>, {}>;
+/** A positive, source-backed assessment. The host still owns authorization and publication. */
+declare class ReviewResolution extends ReviewResolution_base {}
+declare const ReviewRequest_base: Schema.Class<ReviewRequest, Schema.Struct<{
+  readonly title: Schema.String;
+  readonly description: Schema.String;
+  readonly baseRevision: Schema.NonEmptyString;
+  readonly headRevision: Schema.NonEmptyString;
+  readonly scope: Schema.optionalKey<Schema.Literals<readonly ["full", "incremental"]>>;
+  readonly changes: Schema.$Array<typeof ReviewChange>;
+  readonly unreviewedPaths: Schema.$Array<Schema.NonEmptyString>;
+  readonly followUps: Schema.optionalKey<Schema.$Array<typeof ReviewFollowUp>>;
+}>, {}>;
+/** The provider-neutral input to one review pass. */
+declare class ReviewRequest extends ReviewRequest_base {}
+declare const ReviewSeverity: Schema.Literals<readonly ["blocking", "important", "nit"]>;
+type ReviewSeverity = typeof ReviewSeverity.Type;
+/** A model-claimed problem kind used only to label findings for readers. */
+declare const ReviewCategory: Schema.Literals<readonly ["correctness", "security", "concurrency", "performance", "resources", "reliability", "error-handling", "testing", "maintainability", "docs"]>;
+type ReviewCategory = typeof ReviewCategory.Type;
+declare const ReviewFinding_base: Schema.Class<ReviewFinding, Schema.Struct<{
+  readonly path: Schema.NonEmptyString;
+  readonly line: Schema.optionalKey<Schema.Int>;
+  readonly severity: Schema.Literals<readonly ["blocking", "important", "nit"]>;
+  /** Presentation label only; it never changes review admission or failure policy. */
+  readonly category: Schema.Literals<readonly ["correctness", "security", "concurrency", "performance", "resources", "reliability", "error-handling", "testing", "maintainability", "docs"]>;
+  readonly title: Schema.NonEmptyString;
+  readonly body: Schema.NonEmptyString;
+}>, {}>;
+/** One actionable defect. `line` is a RIGHT-side line in the supplied patch. */
+declare class ReviewFinding extends ReviewFinding_base {}
+declare const ReviewReport_base: Schema.Class<ReviewReport, Schema.Struct<{
+  readonly summary: Schema.NonEmptyString;
+  readonly findings: Schema.$Array<typeof ReviewFinding>;
+}>, {}>;
+/** Host-validated findings with a host-authored summary of the reviewed scope. */
+declare class ReviewReport extends ReviewReport_base {}
+declare const ReviewUsage_base: Schema.Class<ReviewUsage, Schema.Struct<{
+  readonly inputTokens: Schema.Natural;
+  readonly uncachedInputTokens: Schema.Natural;
+  readonly cachedInputTokens: Schema.Natural;
+  readonly cacheWriteInputTokens: Schema.Natural;
+  readonly outputTokens: Schema.Natural;
+  readonly estimatedCostMicrousd: Schema.optionalKey<Schema.Natural>;
+  /** Maximum additional charge for sent requests whose usage remains unknown. */
+  readonly reservedCostMicrousd: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+declare class ReviewUsage extends ReviewUsage_base {}
+declare const ReviewCostSnapshot_base: Schema.Class<ReviewCostSnapshot, Schema.Struct<{
+  /** Spending admission stopped; distinct from the per-request input-token limit. */
+  readonly stopped: Schema.Boolean;
+  /** The host refused a counted input before paid inference. */
+  readonly inputLimitExceeded: Schema.optionalKey<Schema.Literal<true>>;
+  /** Admitted provider attempts, including failed or still-unmetered requests. */
+  readonly modelCalls: Schema.Natural;
+  readonly usage: typeof ReviewUsage;
+}>, {}>;
+/** Host accounting covers every provider attempt, including compaction and failed requests. */
+declare class ReviewCostSnapshot extends ReviewCostSnapshot_base {}
+/**
+ * A host must reserve the full possible charge before provider I/O. If admission
+ * stops, the reviewer delivers recorded findings without another model request.
+ * This port reports that decision; it does not enforce a spending limit itself.
+ * Supplying it replaces the cumulative token quota with the host's admission;
+ * per-context, turn, tool, and duration limits still apply. Accounted attempts
+ * return incomplete outcomes on expected failure, even without findings.
+ * Input-token refusals also return incomplete outcomes without a paid attempt.
+ * Capped hosts own model-visible spending feedback at their provider boundary;
+ * the reviewer's generic turn/tool status is disabled for these runs.
+ */
+interface ReviewCostControl {
+  readonly snapshot: Effect.Effect<ReviewCostSnapshot>;
+}
+declare const ReviewOutcome_base: Schema.Class<ReviewOutcome, Schema.Struct<{
+  readonly report: typeof ReviewReport;
+  readonly turns: Schema.Natural;
+  readonly usage: typeof ReviewUsage;
+  /** Admitted paths with diff ranges never supplied to the model, including partially read files. */
+  readonly pendingPaths: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  /** A constrained final answer preserves findings but cannot establish complete coverage. */
+  readonly exhausted: Schema.optionalKey<Schema.Literals<readonly ["tokens", "tool-calls", "turns", "cost"]>>;
+  /** Unfinished coverage, reported by the model or caused by failure or the report capacity bound. */
+  readonly incomplete: Schema.optionalKey<Schema.Literal<true>>;
+  /** Specific missing evidence reported after all admitted diff ranges were delivered. */
+  readonly blockedOn: Schema.optionalKey<Schema.NonEmptyString>;
+  /** Only returned after complete coverage, with identifiers drawn from the supplied follow-ups. */
+  readonly resolutions: Schema.optionalKey<Schema.$Array<typeof ReviewResolution>>;
+  /** Present for measured runs, including an empty array when no native event was emitted. */
+  readonly compactions: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["clear-tool-results", "summarize", "rollover"]>;
+    readonly turn: Schema.Int;
+    readonly tokensBeforeEstimate: Schema.Natural;
+    readonly tokensAfterEstimate: Schema.Natural;
+  }>>>;
+  readonly research: Schema.optionalKey<Schema.Struct<{
+    readonly delegations: Schema.Natural;
+    readonly started: Schema.Natural;
+    readonly completed: Schema.Natural;
+    readonly failed: Schema.Natural;
+    readonly interrupted: Schema.Natural;
+    readonly incomplete: Schema.Natural;
+  }>>;
+  /** Accepted working-note replacements; the note text stays inside the review's Scope. */
+  readonly notesUpdates: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+declare class ReviewOutcome extends ReviewOutcome_base {}
+declare const ReviewVerificationError_base: Schema.Class<ReviewVerificationError, Schema.TaggedStruct<"ReviewVerificationError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ReviewVerificationError extends ReviewVerificationError_base {}
+declare const isCommentableLine: (patch: string, line: number) => boolean;
+interface ReviewerOptions<Provider, ModelProvides, ModelRequires> {
+  readonly model: Model.Model<Provider, LanguageModel.LanguageModel | ModelProvides, ModelRequires>;
+  readonly guidance?: string | undefined;
+  readonly estimateCostMicrousd?: RunCostEstimator | undefined;
+  readonly costControl?: ReviewCostControl | undefined;
+  readonly compaction?: ReviewCompaction | undefined;
+  readonly contextTokenLimit?: number | undefined;
+  readonly research?: {
+    readonly model: Model.Model<Provider, LanguageModel.LanguageModel | ModelProvides, ModelRequires>;
+    readonly concurrency?: typeof ReviewResearchConcurrency.Type | undefined;
+  } | undefined;
+}
+/** One navigable review with a complete change index and bounded evidence tools. */
+declare const makeReviewer: <Provider, ModelProvides, ModelRequires>(options: ReviewerOptions<Provider, ModelProvides, ModelRequires>) => {
+  readonly review: (request: ReviewRequest) => Effect.Effect<ReviewOutcome, import("@effect-agent/core/AgentError").AgentApprovalDenied | import("@effect-agent/core/AgentError").AgentApprovalPending | AgentRuntime.AgentChildPending | import("@effect-agent/core/AgentError").AgentInputError | import("@effect-agent/core/AgentError").AgentOutputError | import("@effect-agent/core/AgentError").AgentPolicyError | import("@effect-agent/core/AgentError").AgentToolAuthorizationDenied | import("effect/unstable/ai/AiError").AiError | import("effect-agent/RunHooks").BudgetAdapterError | import("effect-agent/Budget").BudgetExceeded | import("effect-agent/ContextCompactor").CompactionError | import("@effect-agent/core/AgentError").ContextBudgetError | import("@effect-agent/core/AgentError").ContextOverflowError | import("@effect-agent/core/MemoryReference").MemoryRecallError | import("@effect-agent/core/AgentError").ModelProtocolError | ReviewVerificationError | AgentRuntime.SubagentDurabilityError | import("effect-agent/ThreadHistory").ThreadHistoryError | AgentRuntime.ToolCallWaiting, ReviewRepository | Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<ModelRequires, AgentRuntime.EngineProvidedToolServices>, import("effect-agent/RunOptions").RunContextPreparation | ThreadHistory>, ContextCompactor | Tool.Handler<"finish_research"> | Tool.Handler<"record_finding"> | import("effect-agent/SubagentReservations").SubagentReservations>, ContextCompactor>, ContextCompactor | IdGenerator | import("effect-agent/RunOptions").RunContextPreparation | ThreadHistory | Tool.HandlersFor<{
+    readonly find_files: Tool.Tool<"find_files", {
+      readonly parameters: Schema.Struct<{
+        readonly query: Schema.String;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+      }>;
+      readonly success: typeof ReviewFileList;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
+    readonly read_file: Tool.Tool<"read_file", {
+      readonly parameters: Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+        readonly startLine: Schema.Int;
+        readonly lineCount: Schema.Int;
+      }>;
+      readonly success: typeof ReviewSource;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
+    readonly search_code: Tool.Tool<"search_code", {
+      readonly parameters: Schema.Struct<{
+        readonly query: Schema.NonEmptyString;
+        readonly path: Schema.String;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+        readonly cursor: Schema.Natural;
+      }>;
+      readonly success: typeof ReviewSearchResult;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
+  }>>, import("effect/Scope").Scope> | Exclude<Exclude<Exclude<Exclude<Exclude<(Agent.ModelServices extends ModelProvides | LanguageModel.LanguageModel | Model.ModelName | Model.ProviderName ? Model.Model<Provider, ModelProvides | LanguageModel.LanguageModel, ModelRequires> : never) extends (infer T_1) ? T_1 extends (Agent.ModelServices extends ModelProvides | LanguageModel.LanguageModel | Model.ModelName | Model.ProviderName ? Model.Model<Provider, ModelProvides | LanguageModel.LanguageModel, ModelRequires> : never) ? T_1 extends Layer.Layer<infer _Provides, infer _Error, infer Services> ? Services : never : never : never, AgentRuntime.EngineProvidedToolServices>, Tool.Handler<"delegate_research"> | Tool.Handler<"record_finding"> | Tool.Handler<"submit_review"> | Tool.HandlersFor<{
+    readonly new_context: Tool.Tool<"new_context", {
+      readonly parameters: Schema.Struct<{
+        readonly handoff: Schema.optionalKey<Schema.NonEmptyString>;
+      }>;
+      readonly success: Schema.Struct<{
+        readonly handoff: Schema.optionalKey<Schema.NonEmptyString>;
+      }>;
+      readonly failure: Schema.Never;
+      readonly failureMode: "error";
+    }, never>;
+    readonly read_diff: Tool.Tool<"read_diff", {
+      readonly parameters: Schema.Struct<{
+        readonly offset: Schema.Natural;
+      }>;
+      readonly success: Schema.Struct<{
+        readonly offset: Schema.Natural;
+        readonly content: Schema.String;
+        readonly nextOffset: Schema.NullOr<Schema.Natural>;
+        readonly totalChars: Schema.Natural;
+      }>;
+      readonly failure: typeof ReviewVerificationError;
+      readonly failureMode: "return";
+    }, never>;
+    readonly review_status: Tool.Tool<"review_status", {
+      readonly parameters: Schema.Struct<{
+        readonly cursor: Schema.optionalKey<Schema.Natural>;
+        readonly notes: Schema.optionalKey<Schema.Struct<{
+          readonly text: Schema.String;
+          readonly expectedRevision: Schema.Natural;
+        }>>;
+      }>;
+      readonly success: Schema.Struct<{
+        readonly pending: Schema.$Array<Schema.Struct<{
+          readonly path: Schema.NonEmptyString;
+          readonly offset: Schema.Natural;
+        }>>;
+        readonly pendingCount: Schema.Natural;
+        readonly findings: Schema.$Array<typeof ReviewFinding>;
+        readonly notes: Schema.Struct<{
+          readonly text: Schema.String;
+          readonly revision: Schema.Natural;
+        }>;
+      }>;
+      readonly failure: typeof ReviewVerificationError;
+      readonly failureMode: "return";
+    }, never>;
+  }>>, ContextCompactor>, ContextCompactor | IdGenerator | import("effect-agent/RunOptions").RunContextPreparation | ThreadHistory | Tool.HandlersFor<{
+    readonly find_files: Tool.Tool<"find_files", {
+      readonly parameters: Schema.Struct<{
+        readonly query: Schema.String;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+      }>;
+      readonly success: typeof ReviewFileList;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
+    readonly read_file: Tool.Tool<"read_file", {
+      readonly parameters: Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+        readonly startLine: Schema.Int;
+        readonly lineCount: Schema.Int;
+      }>;
+      readonly success: typeof ReviewSource;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
+    readonly search_code: Tool.Tool<"search_code", {
+      readonly parameters: Schema.Struct<{
+        readonly query: Schema.NonEmptyString;
+        readonly path: Schema.String;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+        readonly cursor: Schema.Natural;
+      }>;
+      readonly success: typeof ReviewSearchResult;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
+  }>>, import("effect/Scope").Scope>>;
+};
+//#endregion
+export { MAX_REVIEW_FILES, MAX_REVIEW_PATCH_CHARS, MAX_REVIEW_TOTAL_PATCH_CHARS, ReviewCategory, ReviewChange, ReviewCompaction, ReviewCompactionEvent, ReviewContextTokenLimit, ReviewCostControl, ReviewCostSnapshot, ReviewFinding, ReviewFollowUp, ReviewOutcome, ReviewReport, ReviewRequest, ReviewResearchConcurrency, ReviewResearchStats, ReviewResolution, ReviewSeverity, ReviewUsage, ReviewVerificationError, ReviewerOptions, isCommentableLine, makeReviewer, Review_d_exports as t };
+//# sourceMappingURL=Review.d.mts.map