@boxxy/pepys 0.1.4 → 0.1.5

package/dist/generated/boxxy-work-boundary.d.ts

@@ -51,7 +51,7 @@ export interface BoxxyItemFiledPayloadAcceptanceItem {
     evidence: string[];
 }
 export interface BoxxyItemFiledPayloadFields {
-    designMode: unknown;
+    designMode?: 'agent' | 'attended';
 }
 export interface BoxxyItemNotedPayload {
     seq: number;
@@ -59,15 +59,23 @@ export interface BoxxyItemNotedPayload {
     storeVersion: number;
 }
 export interface BoxxyItemEditedPayload {
-    title: unknown;
-    outcome: unknown;
-    acceptance: unknown;
-    kind: unknown;
-    fields: unknown;
-    labels: unknown;
+    title?: string;
+    outcome?: string;
+    acceptance?: BoxxyItemEditedPayloadAcceptanceItem[];
+    kind?: string;
+    fields?: BoxxyItemEditedPayloadFields;
+    labels?: string[];
     byAttempt: string | null;
     storeVersion: number;
 }
+export interface BoxxyItemEditedPayloadAcceptanceItem {
+    id: string;
+    text: string;
+    evidence: string[];
+}
+export interface BoxxyItemEditedPayloadFields {
+    designMode?: 'agent' | 'attended';
+}
 export interface BoxxyItemClosedPayload {
     reason: string;
     byAttempt: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boxxy/pepys",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "The pepys plug-in of boxxy, its fact sink and its report reader",
   "homepage": "https://github.com/zgeoff/boxxy/tree/main/packages/pepys#readme",
   "bugs": "https://github.com/zgeoff/boxxy/issues",
@@ -40,22 +40,45 @@
     "typecheck": "tsrs --noEmit"
   },
   "dependencies": {
-    "@boxxy/model": "0.1.4"
+    "@boxxy/model": "0.1.5"
   },
   "devDependencies": {
-    "@pepys/cli": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-cli-0.0.1.tgz",
-    "@pepys/kit": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-kit-0.0.1.tgz",
-    "@pepys/kysely-turso": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-kysely-turso-0.0.1.tgz",
-    "@pepys/schema": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-schema-0.0.1.tgz",
-    "@pepys/testing": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-testing-0.0.1.tgz",
+    "@orpc/client": "2.0.0-beta.50",
+    "@pepys/api": "0.1.0",
+    "@pepys/cli": "0.1.0",
+    "@pepys/ingest": "0.1.0",
+    "@pepys/kit": "0.1.0",
+    "@pepys/source-github": "0.1.0",
+    "@pepys/source-telemetry": "0.1.0",
+    "@pepys/testing": "0.1.0",
     "zod": "4.6.7"
   },
   "peerDependencies": {
-    "@pepys/kit": "0.0.1",
-    "@pepys/testing": "0.0.1",
+    "@orpc/client": "2.0.0-beta.50",
+    "@pepys/api": "^0.1.0",
+    "@pepys/ingest": "^0.1.0",
+    "@pepys/kit": "^0.1.0",
+    "@pepys/source-github": "^0.1.0",
+    "@pepys/source-telemetry": "^0.1.0",
+    "@pepys/testing": "^0.1.0",
     "zod": "4.6.7"
   },
   "peerDependenciesMeta": {
+    "@orpc/client": {
+      "optional": true
+    },
+    "@pepys/api": {
+      "optional": true
+    },
+    "@pepys/ingest": {
+      "optional": true
+    },
+    "@pepys/source-github": {
+      "optional": true
+    },
+    "@pepys/source-telemetry": {
+      "optional": true
+    },
     "@pepys/testing": {
       "optional": true
     }

package/src/generated/boxxy-work-boundary.ts

@@ -125,7 +125,7 @@ export interface BoxxyItemFiledPayloadAcceptanceItem {
 }
 
 export interface BoxxyItemFiledPayloadFields {
-  designMode: unknown;
+  designMode?: 'agent' | 'attended';
 }
 
 export interface BoxxyItemNotedPayload {
@@ -135,16 +135,26 @@ export interface BoxxyItemNotedPayload {
 }
 
 export interface BoxxyItemEditedPayload {
-  title: unknown;
-  outcome: unknown;
-  acceptance: unknown;
-  kind: unknown;
-  fields: unknown;
-  labels: unknown;
+  title?: string;
+  outcome?: string;
+  acceptance?: BoxxyItemEditedPayloadAcceptanceItem[];
+  kind?: string;
+  fields?: BoxxyItemEditedPayloadFields;
+  labels?: string[];
   byAttempt: string | null;
   storeVersion: number;
 }
 
+export interface BoxxyItemEditedPayloadAcceptanceItem {
+  id: string;
+  text: string;
+  evidence: string[];
+}
+
+export interface BoxxyItemEditedPayloadFields {
+  designMode?: 'agent' | 'attended';
+}
+
 export interface BoxxyItemClosedPayload {
   reason: string;
   byAttempt: string | null;
@@ -955,10 +965,15 @@ function decodeBoxxyItemFiledPayloadFields(value: unknown): BoxxyItemFiledPayloa
     return undefined;
   }
 
-  const field0 = 'designMode' in value ? value.designMode : undefined;
+  const raw0 = 'designMode' in value ? value.designMode : undefined;
+  const field0 = raw0 === undefined ? undefined : raw0 === 'agent' || raw0 === 'attended' ? raw0 : undefined;
+
+  if (raw0 !== undefined && field0 === undefined) {
+    return undefined;
+  }
 
   return {
-    designMode: field0,
+    ...(field0 === undefined ? {} : { designMode: field0 }),
   };
 }
 
@@ -1021,17 +1036,47 @@ function decodeBoxxyItemEditedPayload(value: unknown): BoxxyItemEditedPayload |
     return undefined;
   }
 
-  const field0 = 'title' in value ? value.title : undefined;
+  const raw0 = 'title' in value ? value.title : undefined;
+  const field0 = raw0 === undefined ? undefined : typeof raw0 === 'string' ? raw0 : undefined;
+
+  if (raw0 !== undefined && field0 === undefined) {
+    return undefined;
+  }
+
+  const raw1 = 'outcome' in value ? value.outcome : undefined;
+  const field1 = raw1 === undefined ? undefined : typeof raw1 === 'string' ? raw1 : undefined;
+
+  if (raw1 !== undefined && field1 === undefined) {
+    return undefined;
+  }
+
+  const raw2 = 'acceptance' in value ? value.acceptance : undefined;
+  const field2 = raw2 === undefined ? undefined : decodeBoxxyItemEditedPayloadAcceptance(raw2);
 
-  const field1 = 'outcome' in value ? value.outcome : undefined;
+  if (raw2 !== undefined && field2 === undefined) {
+    return undefined;
+  }
 
-  const field2 = 'acceptance' in value ? value.acceptance : undefined;
+  const raw3 = 'kind' in value ? value.kind : undefined;
+  const field3 = raw3 === undefined ? undefined : typeof raw3 === 'string' ? raw3 : undefined;
 
-  const field3 = 'kind' in value ? value.kind : undefined;
+  if (raw3 !== undefined && field3 === undefined) {
+    return undefined;
+  }
 
-  const field4 = 'fields' in value ? value.fields : undefined;
+  const raw4 = 'fields' in value ? value.fields : undefined;
+  const field4 = raw4 === undefined ? undefined : decodeBoxxyItemEditedPayloadFields(raw4);
 
-  const field5 = 'labels' in value ? value.labels : undefined;
+  if (raw4 !== undefined && field4 === undefined) {
+    return undefined;
+  }
+
+  const raw5 = 'labels' in value ? value.labels : undefined;
+  const field5 = raw5 === undefined ? undefined : decodeBoxxyItemEditedPayloadLabels(raw5);
+
+  if (raw5 !== undefined && field5 === undefined) {
+    return undefined;
+  }
 
   const raw6 = 'byAttempt' in value ? value.byAttempt : undefined;
   const field6 = raw6 === null ? null : typeof raw6 === 'string' ? raw6 : undefined;
@@ -1048,17 +1093,130 @@ function decodeBoxxyItemEditedPayload(value: unknown): BoxxyItemEditedPayload |
   }
 
   return {
-    title: field0,
-    outcome: field1,
-    acceptance: field2,
-    kind: field3,
-    fields: field4,
-    labels: field5,
+    ...(field0 === undefined ? {} : { title: field0 }),
+    ...(field1 === undefined ? {} : { outcome: field1 }),
+    ...(field2 === undefined ? {} : { acceptance: field2 }),
+    ...(field3 === undefined ? {} : { kind: field3 }),
+    ...(field4 === undefined ? {} : { fields: field4 }),
+    ...(field5 === undefined ? {} : { labels: field5 }),
     byAttempt: field6,
     storeVersion: field7,
   };
 }
 
+function decodeBoxxyItemEditedPayloadAcceptance(value: unknown): BoxxyItemEditedPayloadAcceptanceItem[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+
+  const items: BoxxyItemEditedPayloadAcceptanceItem[] = [];
+
+  for (let index = 0; index < value.length; index += 1) {
+    const element: unknown = value[index];
+    const item = decodeBoxxyItemEditedPayloadAcceptanceItem(element);
+
+    if (item === undefined) {
+      return undefined;
+    }
+
+    items.push(item);
+  }
+
+  return items;
+}
+
+function decodeBoxxyItemEditedPayloadAcceptanceItem(value: unknown): BoxxyItemEditedPayloadAcceptanceItem | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const raw0 = 'id' in value ? value.id : undefined;
+  const field0 = typeof raw0 === 'string' ? raw0 : undefined;
+
+  if (field0 === undefined) {
+    return undefined;
+  }
+
+  const raw1 = 'text' in value ? value.text : undefined;
+  const field1 = typeof raw1 === 'string' ? raw1 : undefined;
+
+  if (field1 === undefined) {
+    return undefined;
+  }
+
+  const raw2 = 'evidence' in value ? value.evidence : undefined;
+  const field2 = decodeBoxxyItemEditedPayloadAcceptanceItemEvidence(raw2);
+
+  if (field2 === undefined) {
+    return undefined;
+  }
+
+  return {
+    id: field0,
+    text: field1,
+    evidence: field2,
+  };
+}
+
+function decodeBoxxyItemEditedPayloadAcceptanceItemEvidence(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+
+  const items: string[] = [];
+
+  for (let index = 0; index < value.length; index += 1) {
+    const element: unknown = value[index];
+    const item = typeof element === 'string' ? element : undefined;
+
+    if (item === undefined) {
+      return undefined;
+    }
+
+    items.push(item);
+  }
+
+  return items;
+}
+
+function decodeBoxxyItemEditedPayloadFields(value: unknown): BoxxyItemEditedPayloadFields | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const raw0 = 'designMode' in value ? value.designMode : undefined;
+  const field0 = raw0 === undefined ? undefined : raw0 === 'agent' || raw0 === 'attended' ? raw0 : undefined;
+
+  if (raw0 !== undefined && field0 === undefined) {
+    return undefined;
+  }
+
+  return {
+    ...(field0 === undefined ? {} : { designMode: field0 }),
+  };
+}
+
+function decodeBoxxyItemEditedPayloadLabels(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+
+  const items: string[] = [];
+
+  for (let index = 0; index < value.length; index += 1) {
+    const element: unknown = value[index];
+    const item = typeof element === 'string' ? element : undefined;
+
+    if (item === undefined) {
+      return undefined;
+    }
+
+    items.push(item);
+  }
+
+  return items;
+}
+
 function decodeBoxxyItemClosedPayload(value: unknown): BoxxyItemClosedPayload | undefined {
   if (typeof value !== 'object' || value === null || Array.isArray(value)) {
     return undefined;

package/src/test-utils/create-real-pepys.ts

@@ -0,0 +1,286 @@
+import { createORPCClient } from '@orpc/client';
+import { RPCLink } from '@orpc/client/fetch';
+import { buildQueryContext, createApp } from '@pepys/api';
+import { createFakeSenderProof, createIngest, createMemoryFactLog } from '@pepys/ingest';
+import { checkDeployment, parseStreamName } from '@pepys/kit';
+import type {
+  FactBatchBody,
+  FactEnvelope,
+  Sender,
+  SourceDefinition,
+  StreamName,
+  StreamOffset,
+} from '@pepys/kit';
+import {
+  githubDeliveryConsumers,
+  githubPlugin,
+  githubPullRequestConsumer,
+  parsePullRequestDeliveries,
+  selectPullRequestDelivery,
+} from '@pepys/source-github';
+import {
+  telemetryModelRequestConsumer,
+  telemetryPlugin,
+  telemetryTurnCostConsumer,
+} from '@pepys/source-telemetry';
+import { createTestStore } from '@pepys/testing';
+import type { AppliedFact } from '@pepys/testing';
+import { buildBoxxyPlugin } from '../build-boxxy-plugin.ts';
+import type { DeliveryReads, ForeignReads } from '../queries/types.ts';
+import type { UncheckedQueryClient } from '../types.ts';
+import type { TelemetryRequest, TestPepys, TestPepysOptions } from './create-test-pepys.ts';
+
+// The pull requests that the item's attempts produced, as boxxy's own rows give them, and then
+// the GitHub plug-in's delivery module on those pull requests.
+const delivery: DeliveryReads = {
+  consumers: [...githubDeliveryConsumers],
+  readDeliveries: async (db, input) => {
+    const produced = await db
+      .selectFrom('link_effective as produced')
+      .innerJoin('boxxy_attempt as attempt', 'attempt.id', 'produced.from_id')
+      .where('produced.type', '=', 'produced')
+      .where('attempt.item_id', '=', input.item)
+      .select('produced.to_id as id')
+      .distinct()
+      .execute();
+
+    const [first, ...rest] = produced.map((row) => row.id);
+
+    if (first === undefined) {
+      return [];
+    }
+
+    const result = await selectPullRequestDelivery({
+      pullRequests: [first, ...rest],
+      environment: input.environment,
+    }).execute(db);
+
+    return parsePullRequestDeliveries(result.rows).map((row) => ({
+      pullRequest: row.pullRequest,
+      mergedAt: row.mergedAt,
+      release: row.release === null ? null : { at: row.release.at },
+      deploy: row.deploy === null ? null : { at: row.deploy.at },
+    }));
+  },
+};
+
+const foreign: ForeignReads = {
+  telemetryModelRequest: telemetryModelRequestConsumer,
+  telemetryTurnCost: telemetryTurnCostConsumer,
+  githubPullRequest: githubPullRequestConsumer,
+  delivery,
+};
+
+const telemetryToken = 'telemetry-test-token';
+
+// The real pepys ingest, the GitHub, telemetry and boxxy plug-ins, and the real query API, in
+// process. Ingest appends to its memory fact log. A host applies the log to the store; here each
+// query first applies what is new to the kit's test store, which the API then reads.
+export async function createRealPepys(options: TestPepysOptions): Promise<TestPepys> {
+  const plugins = [buildBoxxyPlugin(foreign), githubPlugin, telemetryPlugin];
+  const checked = checkDeployment({ name: 'boxxy-system-test', plugins });
+
+  if (!checked.ok) {
+    throw new Error(`the deployment does not check: ${JSON.stringify(checked.failure)}`);
+  }
+
+  const deployment = checked.value;
+
+  const streams = deployment.sources
+    .flatMap((source) => source.families.map((family) => family.stream))
+    .filter((stream) => isStreamName(stream));
+
+  const log = createMemoryFactLog(streams);
+  const senders: Record<string, Sender> = {};
+
+  const ingest = createIngest({
+    deployment,
+    secrets: {
+      PEPYS_BOXXY_SIGNING_SECRET: options.boxxySecret,
+      PEPYS_GITHUB_WEBHOOK_SECRET: options.webhookSecret,
+      PEPYS_TELEMETRY_TOKEN: telemetryToken,
+      PEPYS_GITHUB_APP_ID: '1',
+      PEPYS_GITHUB_APP_PRIVATE_KEY: 'unused',
+    },
+    log,
+    senderProof: createFakeSenderProof(senders),
+    appendRetry: { maxAttempts: 1, retryDelayMs: 0 },
+    now: () => Date.now(),
+  });
+
+  const store = await createTestStore({ plugins });
+
+  const applied = new Map<StreamName, StreamOffset>();
+
+  for (const stream of streams) {
+    const tail = await log.readTail(stream);
+
+    if (tail.ok) {
+      applied.set(stream, tail.value);
+    }
+  }
+
+  const applyLog = async () => {
+    for (const source of deployment.sources) {
+      for (const stream of source.families.map((family) => family.stream)) {
+        await applyStream(source, stream);
+      }
+    }
+  };
+
+  const applyStream = async (source: SourceDefinition, name: string) => {
+    const from = isStreamName(name) ? applied.get(name) : undefined;
+
+    if (!isStreamName(name) || from === undefined) {
+      throw new Error(`the log holds no stream ${name}`);
+    }
+
+    const tail = await log.readTail(name);
+
+    const read = tail.ok ? await log.read(name, from, tail.value - from) : tail;
+
+    if (!tail.ok || !read.ok) {
+      throw new Error(`the log refused a read of ${name}`);
+    }
+
+    const facts = read.value
+      .map((stored) => toOutgoingFact(source.name, stored.fact))
+      .filter((fact) => isAppliedFact(source, fact));
+
+    if (facts.length !== read.value.length) {
+      throw new Error(`the log holds a fact of ${name} that the source's families refuse`);
+    }
+
+    if (facts.length > 0) {
+      await store.apply(source, facts);
+    }
+
+    applied.set(name, tail.value);
+  };
+
+  const app = createApp(buildQueryContext(store.reader, deployment));
+  const sendRequest = (url: string, init: RequestInit) => app.handle(new Request(url, init));
+
+  const api = createORPCClient<UncheckedQueryClient>(
+    new RPCLink({ origin: 'http://pepys.test', url: '/rpc', fetch: sendRequest }),
+  );
+
+  return {
+    handleRequest: (request) => ingest.handleRequest(request),
+    client: {
+      boxxy_cost_to_land: async (input) => {
+        await applyLog();
+
+        return api.boxxy_cost_to_land(input);
+      },
+      boxxy_stage_time: async (input) => {
+        await applyLog();
+
+        return api.boxxy_stage_time(input);
+      },
+    },
+    writeTelemetry: async (requests) => {
+      for (const request of requests) {
+        const token = `token-${request.origin.issuer}-${request.origin.subject}`;
+
+        senders[token] = { ...request.origin, name: request.origin.subject };
+
+        const body = JSON.stringify(buildOTLPLogs(request));
+
+        const answer = await ingest.handleRequest(
+          new Request('http://pepys.test/v1/logs', {
+            method: 'POST',
+            headers: {
+              authorization: `Bearer ${telemetryToken}`,
+              'imp-identity': token,
+              'content-type': 'application/json',
+            },
+            body,
+          }),
+        );
+
+        if (answer.status !== 200) {
+          throw new Error(`telemetry answered ${answer.status}: ${await answer.text()}`);
+        }
+      }
+    },
+    [Symbol.asyncDispose]: () => store[Symbol.asyncDispose](),
+  };
+}
+
+// The kit tags a stream name it has parsed; a declared family stream always parses.
+function isStreamName(name: string): name is StreamName {
+  return parseStreamName(name).ok;
+}
+
+type WireFact = FactBatchBody['facts'][number];
+
+// The fact of a batch that ingest built the envelope from; the event is the envelope's ID less
+// the source's prefix.
+function toOutgoingFact(sourceName: string, fact: FactEnvelope<unknown>): WireFact {
+  return {
+    type: fact.type,
+    event: fact.id.replace(`event:${sourceName}:`, ''),
+    entity: fact.entity,
+    ...(fact.actor === undefined ? {} : { actor: fact.actor }),
+    at: fact.at,
+    payload: fact.payload,
+  };
+}
+
+// The check that ingest made before it stored the fact: a type of one of the source's families,
+// with a payload that the type's schema accepts.
+function isAppliedFact(
+  source: SourceDefinition,
+  fact: WireFact,
+): fact is WireFact & AppliedFact<SourceDefinition> {
+  return source.families.some(
+    (family) =>
+      Object.hasOwn(family.types, fact.type) &&
+      family.types[fact.type]?.safeParse(fact.payload).success === true,
+  );
+}
+
+// One Claude Code `api_request` log record in an OTLP logs body, as the telemetry route reads it.
+function buildOTLPLogs(request: TelemetryRequest) {
+  const nanos = `${Date.parse(request.at)}000000`;
+
+  const record = {
+    timeUnixNano: nanos,
+    observedTimeUnixNano: nanos,
+    body: { stringValue: 'event' },
+    attributes: buildOTLPAttributes({
+      'event.name': 'api_request',
+      'session.id': `agent-of-${request.session}`,
+      'event.timestamp': request.at,
+      request_id: request.id,
+      model: request.model,
+      cost_usd: request.costUSD,
+      input_tokens: request.inputTokens,
+      cache_read_tokens: 0,
+      cache_creation_tokens: 0,
+      output_tokens: request.outputTokens,
+      duration_ms: 1000,
+    }),
+  };
+
+  const scope = { scope: { name: 'com.anthropic.claude_code.events' }, logRecords: [record] };
+  const resource = { attributes: buildOTLPAttributes({ 'atc.session.id': request.session }) };
+
+  return { resourceLogs: [{ resource, scopeLogs: [scope] }] };
+}
+
+function buildOTLPAttributes(values: Record<string, string | number>) {
+  return Object.entries(values).map(([key, value]) => ({ key, value: toOTLPValue(key, value) }));
+}
+
+// OTLP sends an integer as text; the cost is a double even when it is whole.
+function toOTLPValue(key: string, value: string | number) {
+  if (typeof value === 'string') {
+    return { stringValue: value };
+  }
+
+  return Number.isInteger(value) && key !== 'cost_usd'
+    ? { intValue: String(value) }
+    : { doubleValue: value };
+}