@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/store/digest.ts

@@ -0,0 +1,102 @@
+/**
+ * The shared build-digest derivation (AUT-487): every BuildStore adapter
+ * answers `getRepoBuildDigests` by fetching only the digest-relevant event
+ * types from its existing event table and running this one pure function per
+ * build — identical results by construction, and the digest's `terminal` can
+ * never drift from `reduceBuild`'s terminal rule because this is the same
+ * in-order-overwrite of the latest terminal fact (§15.5). AUT-521 widens the
+ * projection with the observation timestamps and merge facts the harvest
+ * pressure gate needs, keeping that gate's cost flat in accumulated build
+ * history.
+ */
+import type { AbEvent } from '../events/catalog'
+import { defineReducer, type IncrementalReducer } from '../kernel/incremental'
+import type { BuildDigest } from './types'
+
+/** The event types a digest is derived from. Adapters filter their event
+ * rows to exactly these, so a per-build type-filtered index keeps the scan's
+ * cost growing with the actual signal, not with total history. */
+export const DIGEST_EVENT_TYPES = [
+  'build.completed',
+  'build.aborted',
+  'observation.recorded',
+  'pr.merged',
+  'pr-attachment.hosted',
+  'pr-attachment.reclaimed',
+  'execution.started',
+  'execution.ended',
+] as const
+
+/** The digest-relevant slice of one event row. Adapters ship `hostedSeq` for
+ * `pr-attachment.reclaimed` rows and `instance` for `execution.started` /
+ * `execution.ended` rows instead of whole payloads. */
+export type DigestEventRow = Pick<AbEvent, 'type' | 'seq' | 'ts'> & {
+  hostedSeq?: number
+  instance?: string
+}
+
+/** The digest-relevant projection of one build's events, in log order.
+ * `terminal` follows `reduceBuild` exactly: `build.completed` sets `done`,
+ * `build.aborted` sets `aborted`, latest wins (in-order overwrite) — and
+ * `merged` follows the same overwrite pattern for `pr.merged` timestamps.
+ * The events carry no slug, so the result is slug-less; every adapter attaches
+ * `slug` itself when grouping its per-build event rows. */
+export type DigestEvent = DigestEventRow
+
+/** The carried accumulator for `reduceBuildDigest`. */
+export interface DigestAcc {
+  terminal?: BuildDigest['terminal']
+  merged?: string
+  observations: { seq: number; ts: string }[]
+  /** `pendingPrAttachmentReclaims`: seqs of hosted events. */
+  hosted: number[]
+  /** Hosted seqs named by a reclaimed event with a later seq. */
+  reclaimed: number[]
+  /** `openExecution`: the latest start's instance, cleared only by an instance-matched end. */
+  openInstance: string | null
+}
+
+/** Bump when `DigestAcc`'s shape or fold semantics change. */
+export const BUILD_DIGEST_REDUCER_VERSION = 2
+
+export const buildDigestReducer: IncrementalReducer<
+  DigestAcc,
+  DigestEvent,
+  Omit<BuildDigest, 'slug'>
+> = defineReducer({
+  version: BUILD_DIGEST_REDUCER_VERSION,
+  initial: (): DigestAcc => ({ observations: [], hosted: [], reclaimed: [], openInstance: null }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'build.completed') acc.terminal = 'done'
+      else if (event.type === 'build.aborted') acc.terminal = 'aborted'
+      else if (event.type === 'pr.merged') acc.merged = event.ts
+      else if (event.type === 'observation.recorded')
+        acc.observations.push({ seq: event.seq, ts: event.ts })
+      else if (event.type === 'pr-attachment.hosted') acc.hosted.push(event.seq)
+      else if (event.type === 'pr-attachment.reclaimed') {
+        if (event.hostedSeq !== undefined && event.seq > event.hostedSeq)
+          acc.reclaimed.push(event.hostedSeq)
+      } else if (event.type === 'execution.started') acc.openInstance = event.instance ?? null
+      else if (event.type === 'execution.ended') {
+        if (acc.openInstance !== null && event.instance === acc.openInstance)
+          acc.openInstance = null
+      }
+    }
+  },
+  finish: ({ terminal, merged, observations, hosted, reclaimed, openInstance }) => {
+    const reclaimedSet = new Set(reclaimed)
+    const reclaimPending = hosted.some((seq) => !reclaimedSet.has(seq))
+    return {
+      observations: [...observations],
+      ...(merged !== undefined ? { merged } : {}),
+      ...(terminal !== undefined ? { terminal } : {}),
+      ...(reclaimPending ? { reclaimPending: true as const } : {}),
+      ...(openInstance !== null ? { executionOpen: true as const } : {}),
+    }
+  },
+})
+
+export function reduceBuildDigest(events: DigestEvent[]): Omit<BuildDigest, 'slug'> {
+  return buildDigestReducer.reduce(events)
+}

package/packages/core/src/store/local/schema.ts

@@ -9,9 +9,10 @@
  * be kept in lockstep with this schema (this file is the drizzle-kit source
  * of truth).
  */
-import { integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { index, integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core'
 import type { Actor } from '../../events/envelope'
 import type { TicketRef } from '../../ontology'
+import type { TicketAssetEntry } from '../ticket-assets'
 import type { StreamPart } from '../streams/types'
 
 export const builds = sqliteTable('builds', {
@@ -39,7 +40,12 @@ export const events = sqliteTable(
     type: text('type').notNull(),
     payload: text('payload', { mode: 'json' }).notNull(),
   },
-  (t) => [primaryKey({ columns: [t.build, t.seq] })],
+  // Mirrors the BOOTSTRAP_DDL digest-scan index (AUT-487), type-leading so the
+  // digest query's cost grows with digest-relevant events, not total history.
+  (t) => [
+    primaryKey({ columns: [t.build, t.seq] }),
+    index('events_type_build_seq').on(t.type, t.build, t.seq),
+  ],
 )
 
 export const repoStreams = sqliteTable('repo_streams', {
@@ -78,6 +84,44 @@ export const repoArtifacts = sqliteTable(
   (t) => [primaryKey({ columns: [t.repo, t.kind, t.revision] })],
 )
 
+/** Ticket assets (SPEC §7.1): one row per revision, manifest as JSON, file
+ * bytes in the BlobStore. A removal is a tombstone row (`removed`, empty
+ * manifest) taking the next revision. No FK to `repo_streams`: assets can
+ * precede any repo-journal row. */
+export const ticketAssets = sqliteTable(
+  'ticket_assets',
+  {
+    repo: text('repo').notNull(),
+    ticketId: text('ticket_id').notNull(),
+    kind: text('kind').notNull(),
+    name: text('name').notNull(),
+    revision: integer('revision').notNull(),
+    layout: text('layout').notNull().$type<'file' | 'tree'>(),
+    manifest: text('manifest', { mode: 'json' }).notNull().$type<TicketAssetEntry[]>(),
+    size: integer('size').notNull(),
+    removed: integer('removed').notNull(),
+    createdAt: text('created_at').notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.repo, t.ticketId, t.kind, t.name, t.revision] })],
+)
+
+/** Reducer snapshots (store/snapshots.ts): a cache of one reducer's state as of
+ * a log cursor, per scope (`scope_kind` build|repo, `scope_key` the slug or
+ * repo). Never an authority — the log regenerates any row. */
+export const reducerSnapshots = sqliteTable(
+  'reducer_snapshots',
+  {
+    scopeKind: text('scope_kind').notNull(),
+    scopeKey: text('scope_key').notNull(),
+    reducer: text('reducer').notNull(),
+    version: integer('version').notNull(),
+    cursor: integer('cursor').notNull(),
+    state: text('state').notNull(),
+    updatedAt: text('updated_at').notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.scopeKind, t.scopeKey, t.reducer] })],
+)
+
 /** Operator sessions (SPEC §7.1.1): hosted-only durable orchestrator
  * conversation state. Adapters implement the contract uniformly; nothing
  * local creates one. */