@vypdev/copilot 3.3.0 → 3.5.0

package/build/api/src/domain/bugbot/context.d.ts

@@ -0,0 +1,68 @@
+export type BugbotContextCoverageStatus = "complete" | "partial";
+export type BugbotContextSource = "selection" | "previous-findings" | "human-conversation" | "issue-comments" | "pull-request-comments" | "review-threads" | "diff" | "rules";
+export interface BugbotSourceCoverage {
+    readonly source: BugbotContextSource;
+    readonly status: BugbotContextCoverageStatus;
+    readonly pagesFetched: number;
+    readonly itemsFetched: number;
+    readonly itemsRetained: number;
+    readonly omittedItems: number;
+    readonly truncatedItems: number;
+    readonly limitReached: boolean;
+    /** True when a provider page cap hides an unknown number of older records. */
+    readonly providerLimitReached?: boolean;
+}
+export interface BugbotContextCoverage {
+    readonly status: BugbotContextCoverageStatus;
+    readonly sources: readonly BugbotSourceCoverage[];
+}
+export interface BugbotReviewTarget {
+    readonly repository: {
+        readonly owner: string;
+        readonly name: string;
+        readonly id?: number;
+    };
+    readonly triggerKind: string;
+    readonly issueNumber?: number;
+    readonly headOwner: string;
+    readonly headRef: string;
+    readonly expectedHeadSha?: string;
+    readonly pullRequestSelection: {
+        readonly kind: "event";
+        readonly number?: number;
+    } | {
+        readonly kind: "exact-head";
+        readonly required: boolean;
+    };
+}
+export interface BugbotPullRequestIdentity {
+    readonly number: number;
+    readonly state: "open" | "closed";
+    readonly draft: boolean;
+    readonly baseRepository: {
+        readonly owner: string;
+        readonly name: string;
+        readonly id?: number;
+    };
+    readonly headRepositoryOwner: string;
+    /** Optional for read-only review; repository writes require the provider-owned name. */
+    readonly headRepositoryName?: string;
+    readonly headRef: string;
+    readonly headSha: string;
+}
+export type BugbotCanonicalPullRequestSelection = {
+    readonly kind: "canonical";
+    readonly pullRequest: BugbotPullRequestIdentity;
+    readonly reason: "event" | "exact-head";
+} | {
+    readonly kind: "none";
+} | {
+    readonly kind: "ambiguous";
+    readonly candidateCount: 2;
+} | {
+    readonly kind: "stale";
+    readonly reason: string;
+};
+export declare function selectCanonicalBugbotPullRequest(target: BugbotReviewTarget, candidates: readonly BugbotPullRequestIdentity[], source: "event" | "exact-head"): BugbotCanonicalPullRequestSelection;
+export declare function summarizeBugbotCoverage(sources: readonly BugbotSourceCoverage[]): BugbotContextCoverage;
+export declare function completeBugbotSourceCoverage(source: BugbotContextSource, items: number, pagesFetched?: number): BugbotSourceCoverage;

package/build/api/src/domain/bugbot/finding.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Provider-neutral Bugbot finding and durable identity contracts.
+ *
+ * These types are shared by analysis, reconciliation, and publication. Keeping
+ * them in the domain prevents policies from depending on a particular use-case
+ * folder and gives every adapter one stable semantic vocabulary.
+ */
+export interface BugbotFinding {
+    id: string;
+    title: string;
+    description: string;
+    /** Computed locally; never accepted from the agent as an authority. */
+    fingerprint?: string;
+    /** Location-independent reconciliation identity computed locally. */
+    semanticFingerprint?: string;
+    file?: string;
+    line?: number;
+    endLine?: number;
+    severity?: string;
+    confidence?: number;
+    category?: string;
+    evidence?: string;
+    suggestion?: string;
+    /** Optional enclosing symbol used only to improve local identity. */
+    symbol?: string;
+    /** Short code anchor used only to improve local identity. */
+    codeSnippet?: string;
+    /** Exact replacement text for a suggested change, when safe and local. */
+    suggestedCode?: string;
+}
+export type BugbotFindingResolution = 'fixed' | 'obsolete' | 'dismissed';
+export interface ExistingIssueFindingInfo {
+    commentId: number;
+    resolved: boolean;
+    fingerprint?: string;
+    semanticFingerprint?: string;
+    resolution?: BugbotFindingResolution;
+}
+export interface ExistingPullRequestFindingInfo {
+    commentIdentity: string;
+    pullRequestNumber: number;
+    resolved: boolean;
+    /** Fresh provider thread state when it was available. */
+    threadResolved?: boolean;
+    threadResolvedByLogin?: string;
+    parentReviewIdentity?: string;
+    url?: string;
+    /** Explicitly non-clean when durable marker and native facts disagree. */
+    verificationRequired?: boolean;
+    fingerprint?: string;
+    semanticFingerprint?: string;
+    resolution?: BugbotFindingResolution;
+}
+/** Tracks each durable destination independently so partial failures remain retryable. */
+export interface ExistingFindingInfo {
+    issue?: ExistingIssueFindingInfo;
+    pullRequest?: ExistingPullRequestFindingInfo;
+}
+export type ExistingByFindingId = Record<string, ExistingFindingInfo>;
+export declare function isExistingFindingFullyResolved(finding: ExistingFindingInfo): boolean;
+export declare function findExistingFindingInfo(existingByFindingId: ExistingByFindingId, finding: Pick<BugbotFinding, 'id' | 'fingerprint' | 'semanticFingerprint'>): ExistingFindingInfo | undefined;

package/build/api/src/domain/bugbot/review_projection.d.ts

@@ -0,0 +1,33 @@
+import { type BugbotFindingState, type BugbotFindingStateCounts } from './review_state';
+import type { BugbotContextCoverage } from './context';
+export type BugbotProjectionOutcome = 'complete' | 'partial' | 'failed' | 'superseded' | 'dry-run';
+export interface BugbotProjectedFinding {
+    readonly id: string;
+    readonly state: BugbotFindingState;
+    readonly title?: string;
+    readonly url?: string;
+    readonly parentReviewIdentity?: string;
+}
+export interface BugbotReviewProjection {
+    readonly schemaVersion: 1;
+    readonly pullRequestNumber: number;
+    readonly analyzedHeadSha: string;
+    readonly verifiedHeadSha: string;
+    readonly findings: readonly BugbotProjectedFinding[];
+    readonly counts: Readonly<BugbotFindingStateCounts>;
+    readonly actionableCount: number;
+    readonly outcome: BugbotProjectionOutcome;
+    readonly coverage: BugbotContextCoverage;
+    readonly errors: readonly string[];
+    readonly digest: string;
+}
+export declare function buildBugbotReviewProjection(input: {
+    pullRequestNumber: number;
+    analyzedHeadSha: string;
+    verifiedHeadSha?: string;
+    findings: readonly BugbotProjectedFinding[];
+    errors?: readonly string[];
+    coverage: BugbotContextCoverage;
+    superseded?: boolean;
+    dryRun?: boolean;
+}): BugbotReviewProjection;

package/build/api/src/domain/bugbot/review_state.d.ts

@@ -0,0 +1,29 @@
+export declare const BUGBOT_FINDING_STATES: readonly ["open", "reopened", "fixed", "obsolete", "dismissed", "verification-required", "unknown"];
+export type BugbotFindingState = typeof BUGBOT_FINDING_STATES[number];
+export type BugbotResolvedFindingState = 'fixed' | 'obsolete' | 'dismissed';
+export interface BugbotThreadFact {
+    readonly resolved: boolean;
+    readonly resolvedByLogin?: string;
+}
+export interface BugbotFindingEvidence {
+    readonly markerResolved: boolean;
+    readonly markerResolution?: BugbotResolvedFindingState;
+    readonly thread?: BugbotThreadFact;
+    readonly botLogin?: string;
+    readonly wasResolvedBeforeCurrentAnalysis?: boolean;
+    readonly currentAnalysisReportsFinding?: boolean;
+    readonly trusted?: boolean;
+    readonly malformed?: boolean;
+}
+/**
+ * Resolves one provider-neutral Bugbot lifecycle state from durable marker and
+ * native thread facts. The model is intentionally fail-closed: disagreement
+ * never projects a clean PR unless a human dismissal can be attributed.
+ */
+export declare function classifyBugbotFindingState(evidence: BugbotFindingEvidence): BugbotFindingState;
+export declare function isBugbotActionableState(state: BugbotFindingState): boolean;
+export declare function isBugbotCleanState(state: BugbotFindingState): boolean;
+export declare function isHumanResolver(resolverLogin: string | undefined, botLogin: string | undefined): boolean;
+export type BugbotFindingStateCounts = Record<BugbotFindingState, number>;
+export declare function countBugbotFindingStates(states: Iterable<BugbotFindingState>): BugbotFindingStateCounts;
+export declare function countActionableBugbotFindings(counts: Readonly<BugbotFindingStateCounts>): number;

package/build/api/src/domain/message_catalog.d.ts

@@ -0,0 +1,35 @@
+export declare const MESSAGE_CATALOG_VERSION = "3";
+export type CatalogResolutionSource = 'exact' | 'base' | 'dynamic' | 'fallback';
+export type CatalogFallbackReason = 'dynamic-provider-unavailable' | 'dynamic-response-invalid' | 'dynamic-request-failed';
+export declare const CATALOG_PLURAL_CATEGORIES: readonly ["zero", "one", "two", "few", "many", "other"];
+export type CatalogPluralCategory = typeof CATALOG_PLURAL_CATEGORIES[number];
+export type CatalogPluralMessage = Readonly<Partial<Record<CatalogPluralCategory, string>> & {
+    readonly other: string;
+}>;
+export type CatalogMessage = string | CatalogPluralMessage;
+export interface MessageCatalogDefinition<Id extends string = string> {
+    readonly version: string;
+    readonly locale: string;
+    readonly compatibleBaseLanguage: string;
+    readonly messages: Readonly<Record<Id, CatalogMessage>>;
+}
+export interface ResolvedMessageCatalog<Id extends string = string> {
+    readonly requestedLocale: string;
+    readonly resolvedLocale: string;
+    readonly source: CatalogResolutionSource;
+    readonly messages: Readonly<Record<Id, CatalogMessage>>;
+    readonly fallbackReason?: CatalogFallbackReason;
+}
+export interface CatalogResolutionObservation {
+    readonly requestedLocale: string;
+    readonly resolvedLocale: string;
+    readonly source: CatalogResolutionSource;
+    readonly descriptorCount: number;
+    readonly fallbackReason?: CatalogFallbackReason;
+}
+export declare function selectBundledMessageCatalog<Id extends string>(requestedValue: string, catalogs: readonly MessageCatalogDefinition<Id>[]): ResolvedMessageCatalog<Id> | undefined;
+export declare function validateCatalogDefinition<Id extends string>(catalog: MessageCatalogDefinition<Id>, requiredIds: readonly Id[]): readonly string[];
+export declare function validateDynamicCatalogMessages<Id extends string>(value: unknown, sourceMessages: Readonly<Record<Id, CatalogMessage>>, requiredIds: readonly Id[], targetLocale?: string): value is Readonly<Record<Id, CatalogMessage>>;
+export declare function renderCatalogMessage(message: CatalogMessage, variables?: Readonly<Record<string, string | number>>, locale?: string, count?: number): string;
+export declare function catalogPlaceholders(message: CatalogMessage): readonly string[];
+export declare function catalogPluralCategories(locale: string): readonly CatalogPluralCategory[];

package/build/api/src/tooling/bugbot_analytics.d.ts

@@ -1,4 +1,5 @@
 import type { BugbotReviewOutcome, BugbotReviewTelemetrySnapshot } from '../application/ports/bugbot_telemetry_ports';
+import type { BugbotFindingState } from '../domain/bugbot/review_state';
 export interface BugbotAnalyticsReport {
     readonly reviews: number;
     readonly outcomes: Readonly<Record<BugbotReviewOutcome, number>>;
@@ -14,7 +15,7 @@ export interface BugbotAnalyticsReport {
     readonly averageCandidateFindings: number;
     readonly averagePublishedFindings: number;
     readonly resolutionEvents: number;
-    readonly findingStateObservations: Readonly<Record<'open' | 'fixed' | 'obsolete' | 'dismissed' | 'reopened', number>>;
+    readonly findingStateObservations: Readonly<Record<BugbotFindingState, number>>;
     readonly estimatedInputTokens: number;
     readonly estimatedOutputTokens: number;
     readonly stageP95Ms: Readonly<Record<string, number>>;