@boxxy/pepys 0.0.0-stage → 0.1.3

package/dist/queries/build-cost-to-land-query.d.ts

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+import type { ForeignReads, GithubPullRequestConsumer, TelemetryModelRequestConsumer, TelemetryTurnCostConsumer } from './types.ts';
+export declare function buildCostToLandQuery(foreign: ForeignReads): import("@pepys/kit").QueryDefinition<"boxxy_cost_to_land", z.ZodObject<{
+    item: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    item: z.ZodString;
+    landedAt: z.ZodNullable<z.ZodString>;
+    attempts: z.ZodNumber;
+    lines: z.ZodArray<z.ZodObject<{
+        phase: z.ZodString;
+        rework: z.ZodBoolean;
+        product: z.ZodString;
+        model: z.ZodNullable<z.ZodString>;
+        requests: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheCreationTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        costBasis: z.ZodEnum<{
+            none: "none";
+            reported: "reported";
+            turn: "turn";
+        }>;
+    }, z.core.$strip>>;
+    totals: z.ZodObject<{
+        requests: z.ZodNumber;
+        costUSD: z.ZodNumber;
+        reworkCostUSD: z.ZodNumber;
+        requestsWithoutCost: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, readonly [import("@pepys/kit").ConsumerDeclaration<"boxxy_work", {
+    readonly boxxy_item: import("@pepys/kit").TableDeclaration<{
+        readonly id: {
+            readonly kind: "entityID";
+        };
+        readonly kind: {
+            readonly kind: "text";
+        };
+        readonly repo: {
+            readonly kind: "text";
+        };
+        readonly title: {
+            readonly kind: "text";
+        };
+        readonly design_mode: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly filed_at: {
+            readonly kind: "timestamp";
+        };
+        readonly closed_at: {
+            readonly kind: "timestamp";
+            readonly nullable: true;
+        };
+        readonly close_reason: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly updated_at: {
+            readonly kind: "timestamp";
+        };
+    }>;
+    readonly boxxy_attempt: import("@pepys/kit").TableDeclaration<{
+        readonly id: {
+            readonly kind: "entityID";
+        };
+        readonly item_id: {
+            readonly kind: "entityID";
+        };
+        readonly phase: {
+            readonly kind: "text";
+        };
+        readonly number: {
+            readonly kind: "integer";
+        };
+        readonly round: {
+            readonly kind: "integer";
+        };
+        readonly mode: {
+            readonly kind: "text";
+        };
+        readonly pool: {
+            readonly kind: "text";
+        };
+        readonly recipe_hash: {
+            readonly kind: "text";
+        };
+        readonly rules_version: {
+            readonly kind: "text";
+        };
+        readonly atc_session: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly state: {
+            readonly kind: "text";
+        };
+        readonly outcome: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly failure: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly claimed_at: {
+            readonly kind: "timestamp";
+        };
+        readonly started_at: {
+            readonly kind: "timestamp";
+            readonly nullable: true;
+        };
+        readonly closed_out_at: {
+            readonly kind: "timestamp";
+            readonly nullable: true;
+        };
+        readonly ended_at: {
+            readonly kind: "timestamp";
+            readonly nullable: true;
+        };
+        readonly sleeps: {
+            readonly kind: "json";
+        };
+        readonly updated_at: {
+            readonly kind: "timestamp";
+        };
+    }>;
+    readonly boxxy_attempt_session: import("@pepys/kit").TableDeclaration<{
+        readonly attempt_id: {
+            readonly kind: "entityID";
+        };
+        readonly session_id: {
+            readonly kind: "entityID";
+        };
+        readonly key: {
+            readonly kind: "text";
+        };
+        readonly product: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly caller_issuer: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly caller_subject: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly bound_at: {
+            readonly kind: "timestamp";
+        };
+    }>;
+}, import("@pepys/kit").LinkTypeDeclaration<"attempt_of", "boxxy:attempt", "boxxy:item"> | import("@pepys/kit").LinkTypeDeclaration<"produced", "boxxy:attempt", "github:pull_request"> | import("@pepys/kit").LinkTypeDeclaration<"ran_in", "boxxy:attempt", "telemetry:session">>, TelemetryModelRequestConsumer, TelemetryTurnCostConsumer, GithubPullRequestConsumer]>;

package/dist/queries/build-cost-to-land.d.ts

@@ -0,0 +1,12 @@
+import type { CostToLand } from '@boxxy/model';
+import type { AttemptReadRow, BindingReadRow, PullRequestReadRow, RequestReadRow, TurnReadRow } from './types.ts';
+interface CostParts {
+    readonly item: string;
+    readonly attempts: readonly AttemptReadRow[];
+    readonly bindings: readonly BindingReadRow[];
+    readonly requests: readonly RequestReadRow[];
+    readonly turns: readonly TurnReadRow[];
+    readonly pullRequests: readonly PullRequestReadRow[];
+}
+export declare function buildCostToLand(parts: CostParts): CostToLand;
+export {};

package/dist/queries/build-stage-time-query.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import type { DeliveryReads, StageTimeReads } from './types.ts';
+export declare function buildStageTimeQuery(delivery: DeliveryReads): import("@pepys/kit").QueryDefinition<"boxxy_stage_time", z.ZodObject<{
+    item: z.ZodString;
+    environment: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    item: z.ZodString;
+    environment: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        step: z.ZodEnum<{
+            build: "build";
+            deploy: "deploy";
+            design: "design";
+            merge: "merge";
+            release: "release";
+            review: "review";
+            triage: "triage";
+        }>;
+        minutes: z.ZodNullable<z.ZodNumber>;
+        endedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    rework: z.ZodObject<{
+        count: z.ZodNumber;
+        minutes: z.ZodNumber;
+    }, z.core.$strip>;
+    reviewWaitMinutes: z.ZodNullable<z.ZodNumber>;
+    sleepMinutes: z.ZodNumber;
+    pullRequests: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, StageTimeReads>;

package/dist/queries/build-stage-time.d.ts

@@ -0,0 +1,10 @@
+import type { StageTime } from '@boxxy/model';
+import type { AttemptReadRow, DeliveryReadRow } from './types.ts';
+interface StageParts {
+    readonly item: string;
+    readonly environment: string;
+    readonly attempts: readonly AttemptReadRow[];
+    readonly deliveries: readonly DeliveryReadRow[];
+}
+export declare function buildStageTime(parts: StageParts): StageTime;
+export {};

package/dist/queries/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const noCapacityFailure = "no-capacity";
+export declare const outcomeNames: {
+    readonly built: 'built';
+    readonly passed: 'passed';
+    readonly changesRequested: 'changes-requested';
+};

package/dist/queries/find-item-entity-id.d.ts

@@ -0,0 +1,2 @@
+import type { EntityID } from '@pepys/kit';
+export declare function findItemEntityID(text: string): EntityID | undefined;

package/dist/queries/types.d.ts

@@ -0,0 +1,109 @@
+import type { ColumnKind, ConsumerDeclaration, EntityID, QueryCall, TableDeclaration } from '@pepys/kit';
+import type { boxxyWorkConsumer } from '../work/boxxy-work-consumer.ts';
+export interface AttemptReadRow {
+    id: string;
+    phase: string;
+    number: number;
+    round: number;
+    state: string;
+    outcome: string | null;
+    failure: string | null;
+    claimed_at: string;
+    ended_at: string | null;
+    sleeps: unknown;
+}
+export interface BindingReadRow {
+    attempt_id: string;
+    session_id: string;
+    bound_at: string;
+    caller_issuer: string | null;
+    caller_subject: string | null;
+}
+interface TelemetryReadRow {
+    session_id: string;
+    origin_issuer: string | null;
+    origin_subject: string | null;
+    product: string;
+    at: string;
+}
+export interface RequestReadRow extends TelemetryReadRow {
+    model: string;
+    cost_basis: string;
+    cost_usd: number | null;
+    input_tokens: number;
+    cache_read_tokens: number;
+    cache_creation_tokens: number;
+    output_tokens: number;
+}
+export interface TurnReadRow extends TelemetryReadRow {
+    model: string | null;
+    cost_usd: number;
+}
+export interface PullRequestReadRow {
+    id: string;
+    merged_at: string | null;
+}
+export interface DeliveryReadRow {
+    pullRequest: string;
+    mergedAt: string | null;
+    release: {
+        at: string;
+    } | null;
+    deploy: {
+        at: string;
+    } | null;
+}
+interface Column<Kind extends ColumnKind> {
+    readonly kind: Kind;
+}
+interface NullableColumn<Kind extends ColumnKind> {
+    readonly kind: Kind;
+    readonly nullable: true;
+}
+type TelemetryColumns = Readonly<{
+    session_id: Column<'entityID'>;
+    origin_issuer: NullableColumn<'text'>;
+    origin_subject: NullableColumn<'text'>;
+    product: Column<'text'>;
+    at: Column<'timestamp'>;
+}>;
+export type TelemetryModelRequestConsumer = ConsumerDeclaration<'telemetry_model_request', {
+    readonly telemetry_model_request: TableDeclaration<TelemetryColumns & {
+        readonly model: Column<'text'>;
+        readonly cost_basis: Column<'text'>;
+        readonly cost_usd: NullableColumn<'real'>;
+        readonly input_tokens: Column<'integer'>;
+        readonly cache_read_tokens: Column<'integer'>;
+        readonly cache_creation_tokens: Column<'integer'>;
+        readonly output_tokens: Column<'integer'>;
+    }>;
+}>;
+export type TelemetryTurnCostConsumer = ConsumerDeclaration<'telemetry_turn_cost', {
+    readonly telemetry_turn_cost: TableDeclaration<TelemetryColumns & {
+        readonly model: NullableColumn<'text'>;
+        readonly cost_usd: Column<'real'>;
+    }>;
+}>;
+export type GithubPullRequestConsumer = ConsumerDeclaration<'github_pull_request', {
+    readonly github_pull_request: TableDeclaration<{
+        readonly id: Column<'entityID'>;
+        readonly merged_at: NullableColumn<'timestamp'>;
+    }>;
+}>;
+export type OpaqueConsumer = ConsumerDeclaration<string, Readonly<Record<`opaque:${string}`, TableDeclaration>>>;
+export type StageTimeReads = readonly [typeof boxxyWorkConsumer, ...OpaqueConsumer[]];
+export interface DeliveryInput {
+    readonly item: EntityID;
+    readonly environment: string;
+}
+export interface DeliveryReads {
+    readonly consumers: readonly OpaqueConsumer[];
+    readonly readDeliveries: (db: QueryCall<unknown, StageTimeReads>['db'], input: DeliveryInput) => Promise<readonly DeliveryReadRow[]>;
+}
+export interface ForeignReads {
+    readonly telemetryModelRequest: TelemetryModelRequestConsumer;
+    readonly telemetryTurnCost: TelemetryTurnCostConsumer;
+    readonly githubPullRequest: GithubPullRequestConsumer;
+    readonly delivery: DeliveryReads;
+}
+export {};

package/dist/sink/is-outgoing-fact.d.ts

@@ -0,0 +1,3 @@
+import type { FactBatchBody, OutgoingFact } from '@pepys/kit';
+import type { boxxySource } from '../boxxy-source.ts';
+export declare function isOutgoingFact(fact: FactBatchBody['facts'][number]): fact is OutgoingFact<typeof boxxySource>;

package/dist/sink/pick-sink-answer.d.ts

@@ -0,0 +1,7 @@
+import type { SinkAnswer } from '@boxxy/model';
+import type { Result, SendFailure } from '@pepys/kit';
+type SendResult = Result<{
+    stored: number;
+}, SendFailure>;
+export declare function pickSinkAnswer(sent: SendResult | 'timeout', timeoutMs: number): SinkAnswer;
+export {};

package/dist/sink/to-wire-fact.d.ts

@@ -0,0 +1,5 @@
+import type { OutboxFact } from '@boxxy/model';
+import type { FactBatchBody } from '@pepys/kit';
+type WireFact = FactBatchBody['facts'][number];
+export declare function toWireFact(fact: OutboxFact): WireFact;
+export {};

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+import type { PluginClient } from '@pepys/kit';
+import type { buildBoxxyPlugin } from './build-boxxy-plugin.ts';
+export type BoxxyQueryClient = PluginClient<ReturnType<typeof buildBoxxyPlugin>>;
+export type UncheckedQueryClient = {
+    readonly [Query in keyof BoxxyQueryClient]: (input: Parameters<BoxxyQueryClient[Query]>[0]) => Promise<unknown>;
+};