@defrex/autobuild 0.13.0 → 0.14.0

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

@@ -1,3 +1,13 @@
+import { readPersistedBuildDigests } from '../reduced-reads'
+import { assertPublicSnapshotReducer } from '../snapshots'
+import {
+  readReducerValue,
+  resolveReducerValue,
+  type ReducerValueRequest,
+  type ReducerValue,
+} from '../reducer-values'
+import { validateTickFinish } from '../repo-tick'
+import type { RepoTickCompletion, RepoTickFinish, RepoTickObservation } from '../types'
 /**
  * The local BuildStore (SPEC §7.2.1): SQLite + blob directory beneath an
  * explicitly resolved local state root. Repository/default selection belongs
@@ -43,7 +53,6 @@ import { createBuildScopedStore } from '../build-scope'
 import type { ReducerSnapshot, SnapshotScope } from '../snapshots'
 import { validateCreatedEvent } from '../new-build'
 import { createSessionScopedStore } from '../session-handle'
-import { DIGEST_EVENT_TYPES, type DigestEventRow, reduceBuildDigest } from '../digest'
 import {
   REPOSITORY_STATE_EVENT_TYPES,
   REPOSITORY_LATEST_EVENT_TYPES,
@@ -191,7 +200,8 @@ export const BOOTSTRAP_DDL = [
     lease_holder TEXT,
     lease_expires_at TEXT,
     lease_ttl_ms INTEGER,
-    heartbeat_at TEXT
+    heartbeat_at TEXT,
+    tick TEXT
   )`,
   `CREATE TABLE IF NOT EXISTS repo_events (
     repo TEXT NOT NULL,
@@ -337,6 +347,11 @@ export class SqliteBuildStore implements BuildStore {
     // Stores created before `repo_origin` existed keep working: add the column
     // idempotently when a pre-existing table lacks it (the bootstrap DDL above
     // covers fresh stores). No migration framework — one guarded ALTER at open.
+    const repoColumns = this.sqlite.query("PRAGMA table_info('repo_streams')").all() as {
+      name: string
+    }[]
+    if (!repoColumns.some((column) => column.name === 'tick'))
+      this.sqlite.exec('ALTER TABLE repo_streams ADD COLUMN tick TEXT')
     const columns = this.sqlite.query("PRAGMA table_info('builds')").all() as Array<{
       name: string
     }>
@@ -435,6 +450,7 @@ export class SqliteBuildStore implements BuildStore {
 
   private toRepoRecord(row: RepoRow): RepositoryRecord {
     return {
+      ...(row.tick ? { tick: structuredClone(row.tick) } : {}),
       repo: row.repo,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
@@ -496,56 +512,16 @@ export class SqliteBuildStore implements BuildStore {
   }
 
   async getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
-    // From the builds side (AUT-487): the type filter lives in the ON clause
-    // so a build whose log holds none of the digest-relevant event
-    // types still yields its row — a join that starts from `events` would
-    // silently drop such builds and break the operation's completeness
-    // contract. Only the digest-relevant types are fetched, then one shared
-    // derivation
-    // per build, so the answer cannot drift from `reduceBuild`.
-    const rows = this.sqlite
-      .query(
-        `SELECT b.slug AS slug, e.seq AS seq, e.ts AS ts, e.type AS type,
-                CASE WHEN e.type = 'pr-attachment.reclaimed'
-                  THEN json_extract(e.payload, '$.hostedSeq') END AS hostedSeq,
-                CASE WHEN e.type IN ('execution.started', 'execution.ended')
-                  THEN json_extract(e.payload, '$.instance') END AS instance
-         FROM builds b
-         LEFT JOIN events e
-           ON e.build = b.slug AND e.type IN (${DIGEST_EVENT_TYPES.map(() => '?').join(', ')})
-         WHERE b.repo = ?
-         ORDER BY b.slug, e.seq`,
-      )
-      .all(...DIGEST_EVENT_TYPES, repo) as {
-      slug: string
-      seq: number | null
-      ts: string | null
-      type: string | null
-      hostedSeq: number | null
-      instance: string | null
-    }[]
-    const eventsByBuild = new Map<string, DigestEventRow[]>()
-    for (const row of rows) {
-      if (row.seq === null || row.ts === null || row.type === null) continue
-      const events = eventsByBuild.get(row.slug) ?? []
-      events.push({
-        type: row.type as AbEvent['type'],
-        seq: row.seq,
-        ts: row.ts,
-        ...(row.hostedSeq !== null ? { hostedSeq: row.hostedSeq } : {}),
-        ...(row.instance !== null ? { instance: row.instance } : {}),
-      })
-      eventsByBuild.set(row.slug, events)
-    }
-    const digests = new Map<string, BuildDigest>()
-    for (const row of rows) {
-      if (digests.has(row.slug)) continue
-      digests.set(row.slug, {
-        slug: row.slug,
-        ...reduceBuildDigest(eventsByBuild.get(row.slug) ?? []),
-      })
-    }
-    return digests
+    return readPersistedBuildDigests(
+      this,
+      repo,
+      this.db
+        .select()
+        .from(builds)
+        .where(eq(builds.repo, repo))
+        .all()
+        .map((row) => this.toRecord(row)),
+    )
   }
 
   /** Current build-stream tail inside an open transaction. */
@@ -922,9 +898,12 @@ export class SqliteBuildStore implements BuildStore {
     return row ? this.toRepoRecord(row) : null
   }
 
-  private appendRepoInTx(repo: string, validated: RepositoryEventWrite): RepositoryEventEnvelope {
+  private appendRepoInTx(
+    repo: string,
+    validated: RepositoryEventWrite,
+    ts = this.now(),
+  ): RepositoryEventEnvelope {
     this.requireRepo(repo)
-    const ts = this.now()
     const row = this.db
       .select({ max: sql<number | null>`max(${repoEvents.seq})` })
       .from(repoEvents)
@@ -1092,11 +1071,91 @@ export class SqliteBuildStore implements BuildStore {
     return row?.tail
   }
 
+  async getReducerValue(scope: SnapshotScope, request: ReducerValueRequest): Promise<ReducerValue> {
+    // Reject invalid requests before touching storage.
+    resolveReducerValue(scope, request)
+    return readReducerValue(scope, request, {
+      highWater: async () => {
+        const tail = this.snapshotTail(scope)
+        if (tail === undefined) throw new Error('unknown reducer scope')
+        return tail
+      },
+      events: async (since, through) => {
+        const key = scope.kind === 'build' ? scope.slug : scope.repo
+        const rows = this.sqlite
+          .query(
+            scope.kind === 'build'
+              ? 'SELECT * FROM events WHERE build=?1 AND seq>?2 AND seq<=?3 ORDER BY seq'
+              : 'SELECT * FROM repo_events WHERE repo=?1 AND seq>?2 AND seq<=?3 ORDER BY seq',
+          )
+          .all(key, since, through) as {
+          build?: string
+          repo?: string
+          seq: number
+          ts: string
+          actor: string
+          type: string
+          payload: string
+        }[]
+        return rows.map((row) => ({
+          ...row,
+          actor: JSON.parse(row.actor),
+          payload: JSON.parse(row.payload),
+        })) as (AbEvent | RepositoryEvent)[]
+      },
+      put: (key, snapshot) => this.putSnapshot(scope, key, snapshot),
+      read: async (key) => {
+        const row = this.sqlite
+          .query(
+            'SELECT version, cursor, state FROM reducer_snapshots WHERE scope_kind=?1 AND scope_key=?2 AND reducer=?3',
+          )
+          .get(scope.kind, scope.kind === 'build' ? scope.slug : scope.repo, key) as {
+          version: number
+          cursor: number
+          state: string
+        } | null
+        if (!row) return null
+        let state: unknown = null
+        try {
+          state = JSON.parse(row.state)
+        } catch {
+          /* malformed cache */
+        }
+        return { snapshot: { version: row.version, cursor: row.cursor, state }, token: row.state }
+      },
+      repair: async (key, observed, snapshot) => {
+        return this.sqlite.transaction(() => {
+          const tail = this.snapshotTail(scope)
+          if (tail === undefined || snapshot.cursor > tail) return false
+          return (
+            this.sqlite
+              .query(
+                `UPDATE reducer_snapshots SET version=?1, cursor=?2, state=?3, updated_at=?4 WHERE scope_kind=?5 AND scope_key=?6 AND reducer=?7 AND version=?8 AND cursor=?9 AND state=?10`,
+              )
+              .run(
+                snapshot.version,
+                snapshot.cursor,
+                JSON.stringify(snapshot.state),
+                this.clock().toISOString(),
+                scope.kind,
+                scope.kind === 'build' ? scope.slug : scope.repo,
+                key,
+                observed.snapshot.version,
+                observed.snapshot.cursor,
+                observed.token,
+              ).changes > 0
+          )
+        })()
+      },
+    })
+  }
+
   async getReducerSnapshot(
     scope: SnapshotScope,
     reducer: string,
     version: number,
   ): Promise<ReducerSnapshot | null> {
+    assertPublicSnapshotReducer(reducer)
     const tail = this.snapshotTail(scope)
     if (tail === undefined) return null
     const row = this.sqlite
@@ -1120,6 +1179,15 @@ export class SqliteBuildStore implements BuildStore {
     scope: SnapshotScope,
     reducer: string,
     snapshot: ReducerSnapshot,
+  ): Promise<boolean> {
+    assertPublicSnapshotReducer(reducer)
+    return this.putSnapshot(scope, reducer, snapshot)
+  }
+
+  private async putSnapshot(
+    scope: SnapshotScope,
+    reducer: string,
+    snapshot: ReducerSnapshot,
   ): Promise<boolean> {
     const tail = this.snapshotTail(scope)
     if (tail === undefined || snapshot.cursor > tail) return false
@@ -1420,6 +1488,63 @@ export class SqliteBuildStore implements BuildStore {
     })
   }
 
+  async beginRepoTick(repo: string, holder: string): Promise<string | null> {
+    return this.writeTx(() => {
+      const row = this.requireRepo(repo)
+      if (
+        row.leaseHolder !== holder ||
+        !row.leaseExpiresAt ||
+        Date.parse(row.leaseExpiresAt) <= this.clock().getTime()
+      )
+        return null
+      const startedAt = this.now()
+      const tick: RepoTickObservation = {
+        run: holder,
+        open: { startedAt },
+        ...(row.tick?.finished ? { finished: row.tick.finished } : {}),
+      }
+      this.db
+        .update(repoStreams)
+        .set({ tick, updatedAt: startedAt })
+        .where(eq(repoStreams.repo, repo))
+        .run()
+      return startedAt
+    })
+  }
+
+  async finishRepoTick(
+    repo: string,
+    holder: string,
+    completion: RepoTickCompletion,
+    events: RepositoryEventWrite[],
+  ): Promise<RepoTickFinish | null> {
+    const validated = validateTickFinish(holder, completion, events)
+    return this.writeTx(() => {
+      const row = this.requireRepo(repo)
+      if (
+        row.leaseHolder !== holder ||
+        !row.leaseExpiresAt ||
+        Date.parse(row.leaseExpiresAt) <= this.clock().getTime()
+      )
+        return null
+      if (row.tick?.run !== holder || !row.tick.open) throw new Error('no open repository tick')
+      const completedAt = this.now()
+      const envelopes = validated.map((event) =>
+        this.appendRepoInTx(repo, event, completedAt),
+      ) as RepositoryEvent[]
+      const observation: RepoTickObservation = {
+        run: holder,
+        finished: { ...completion, run: holder, startedAt: row.tick.open.startedAt, completedAt },
+      }
+      this.db
+        .update(repoStreams)
+        .set({ tick: observation, updatedAt: completedAt })
+        .where(eq(repoStreams.repo, repo))
+        .run()
+      return { observation, events: envelopes }
+    })
+  }
+
   async claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean> {
     return this.writeTx(() => {
       const row = this.requireRepo(repo)

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

@@ -1,3 +1,13 @@
+import { readPersistedBuildDigests } from './reduced-reads'
+import { assertPublicSnapshotReducer } from './snapshots'
+import {
+  readReducerValue,
+  resolveReducerValue,
+  type ReducerValueRequest,
+  type ReducerValue,
+} from './reducer-values'
+import { validateTickFinish } from './repo-tick'
+import type { RepoTickCompletion, RepoTickFinish, RepoTickObservation } from './types'
 /**
  * The in-memory BuildStore — the reference adapter. Its behavior *is* the
  * contract: the suite in `store/contract.ts` is written against this and
@@ -34,7 +44,6 @@ import {
 } from './snapshots'
 import { validateCreatedEvent } from './new-build'
 import { createSessionScopedStore } from './session-handle'
-import { reduceBuildDigest } from './digest'
 import { projectRepositoryStateEvents } from './repo-state-events'
 import {
   DEFAULT_ARTIFACT_RETENTION_MAX_REVISIONS,
@@ -121,6 +130,7 @@ interface Lease {
 }
 
 interface RepoState {
+  tick?: RepoTickObservation
   record: {
     repo: string
     createdAt: string
@@ -316,34 +326,7 @@ export class MemoryBuildStore implements BuildStore {
   }
 
   async getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
-    // Insertion order is creation order (the listSessions tiebreak note); the
-    // digest map is returned in slug order so every adapter answers the same
-    // shape for the same store contents.
-    const slugs = [...this.builds.entries()]
-      .filter(([, state]) => state.record.repo === repo)
-      .map(([slug]) => slug)
-      .sort()
-    const digests = new Map<string, BuildDigest>()
-    for (const slug of slugs) {
-      const state = this.builds.get(slug)!
-      digests.set(slug, {
-        slug,
-        ...reduceBuildDigest(
-          state.events.map((event) => ({
-            type: event.type,
-            seq: event.seq,
-            ts: event.ts,
-            ...(event.type === 'pr-attachment.reclaimed'
-              ? { hostedSeq: event.payload.hostedSeq }
-              : {}),
-            ...(event.type === 'execution.started' || event.type === 'execution.ended'
-              ? { instance: event.payload.instance }
-              : {}),
-          })),
-        ),
-      })
-    }
-    return digests
+    return readPersistedBuildDigests(this, repo)
   }
 
   async append<T extends EventType>(slug: string, event: EventWrite<T>): Promise<EventEnvelope<T>> {
@@ -563,6 +546,7 @@ export class MemoryBuildStore implements BuildStore {
 
   private repoSnapshot(state: RepoState): RepositoryRecord {
     return {
+      ...(state.tick ? { tick: structuredClone(state.tick) } : {}),
       repo: state.record.repo,
       createdAt: state.record.createdAt,
       updatedAt: state.record.updatedAt,
@@ -714,11 +698,54 @@ export class MemoryBuildStore implements BuildStore {
     return events === undefined ? undefined : (events.at(-1)?.seq ?? 0)
   }
 
+  async getReducerValue(scope: SnapshotScope, request: ReducerValueRequest): Promise<ReducerValue> {
+    // Reject invalid requests before touching storage.
+    resolveReducerValue(scope, request)
+    return readReducerValue(scope, request, {
+      highWater: async () => {
+        const tail = this.snapshotTail(scope)
+        if (tail === undefined) throw new Error('unknown reducer scope')
+        return tail
+      },
+      events: async (since, through) =>
+        structuredClone(
+          (scope.kind === 'build'
+            ? this.state(scope.slug).events
+            : this.repoState(scope.repo).events
+          ).slice(since, through),
+        ) as (AbEvent | RepositoryEvent)[],
+      put: (key, snapshot) => this.putSnapshot(scope, key, snapshot),
+      read: async (key) => {
+        const snapshot = this.snapshots.get(`${snapshotScopeKey(scope)}\u0000${key}`)
+        return snapshot === undefined
+          ? null
+          : { snapshot: structuredClone(snapshot), token: JSON.stringify(snapshot) }
+      },
+      repair: async (key, observed, snapshot) => {
+        const cacheKey = `${snapshotScopeKey(scope)}\u0000${key}`
+        const current = this.snapshots.get(cacheKey)
+        const tail = this.snapshotTail(scope)
+        if (
+          !current ||
+          JSON.stringify(current) !== observed.token ||
+          tail === undefined ||
+          snapshot.cursor > tail
+        )
+          return false
+        if (observed.snapshot.cursor > snapshot.cursor && tail >= observed.snapshot.cursor)
+          return false
+        this.snapshots.set(cacheKey, JSON.parse(JSON.stringify(snapshot)))
+        return true
+      },
+    })
+  }
+
   async getReducerSnapshot(
     scope: SnapshotScope,
     reducer: string,
     version: number,
   ): Promise<ReducerSnapshot | null> {
+    assertPublicSnapshotReducer(reducer)
     const tail = this.snapshotTail(scope)
     if (tail === undefined) return null
     const stored = this.snapshots.get(`${snapshotScopeKey(scope)}\u0000${reducer}`)
@@ -730,6 +757,15 @@ export class MemoryBuildStore implements BuildStore {
     scope: SnapshotScope,
     reducer: string,
     snapshot: ReducerSnapshot,
+  ): Promise<boolean> {
+    assertPublicSnapshotReducer(reducer)
+    return this.putSnapshot(scope, reducer, snapshot)
+  }
+
+  private async putSnapshot(
+    scope: SnapshotScope,
+    reducer: string,
+    snapshot: ReducerSnapshot,
   ): Promise<boolean> {
     const tail = this.snapshotTail(scope)
     if (tail === undefined || snapshot.cursor > tail) return false
@@ -896,6 +932,60 @@ export class MemoryBuildStore implements BuildStore {
     return structuredClone(latest.meta)
   }
 
+  async beginRepoTick(repo: string, holder: string): Promise<string | null> {
+    const state = this.repoState(repo)
+    if (
+      !state.lease ||
+      state.lease.holder !== holder ||
+      state.lease.expiresAt <= this.clock().getTime()
+    )
+      return null
+    const startedAt = this.now()
+    state.tick = {
+      run: holder,
+      open: { startedAt },
+      ...(state.tick?.finished ? { finished: state.tick.finished } : {}),
+    }
+    state.record.updatedAt = startedAt
+    return startedAt
+  }
+
+  async finishRepoTick(
+    repo: string,
+    holder: string,
+    completion: RepoTickCompletion,
+    events: RepositoryEventWrite[],
+  ): Promise<RepoTickFinish | null> {
+    const validated = validateTickFinish(holder, completion, events)
+    const state = this.repoState(repo)
+    if (
+      !state.lease ||
+      state.lease.holder !== holder ||
+      state.lease.expiresAt <= this.clock().getTime()
+    )
+      return null
+    if (state.tick?.run !== holder || !state.tick.open) throw new Error('no open repository tick')
+    const completedAt = this.now()
+    const envelopes = validated.map((event, index) => ({
+      ...event,
+      repo,
+      seq: state.events.length + index + 1,
+      ts: completedAt,
+    })) as RepositoryEvent[]
+    state.tick = {
+      run: holder,
+      finished: {
+        ...structuredClone(completion),
+        run: holder,
+        startedAt: state.tick.open.startedAt,
+        completedAt,
+      },
+    }
+    state.events.push(...structuredClone(envelopes))
+    state.record.updatedAt = completedAt
+    return structuredClone({ observation: state.tick, events: envelopes })
+  }
+
   async claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean> {
     const state = this.repoState(repo)
     const now = this.clock().getTime()

package/packages/core/src/store/phase-session.ts

@@ -1,3 +1,4 @@
+import type { ReducerValueRequest, ReducerValue } from './reducer-values'
 /**
  * Local ambient phase-session wrapper for a BuildStore.
  *
@@ -333,6 +334,14 @@ export function scopeLocalStoreToPhaseSession(
       own('getRepoHighWater', 'repo', repo)
       return store.getRepoHighWater(repo)
     },
+    async getReducerValue(
+      target: SnapshotScope,
+      request: ReducerValueRequest,
+    ): Promise<ReducerValue> {
+      if (target.kind === 'build') own('getReducerValue', 'build', target.slug)
+      else own('getReducerValue', 'repo', target.repo)
+      return store.getReducerValue(target, request)
+    },
     async getReducerSnapshot(
       target: SnapshotScope,
       reducer: string,
@@ -423,6 +432,14 @@ export function scopeLocalStoreToPhaseSession(
       own('claimRepoLease', 'repo', repo)
       return store.claimRepoLease(repo, holder, ttlMs)
     },
+    async beginRepoTick(repo: string) {
+      own('beginRepoTick', 'repo', repo)
+      throw new Error('phase sessions cannot begin repository ticks')
+    },
+    async finishRepoTick(repo: string) {
+      own('finishRepoTick', 'repo', repo)
+      throw new Error('phase sessions cannot finish repository ticks')
+    },
     async heartbeatRepo(repo: string, holder: string): Promise<boolean> {
       own('heartbeatRepo', 'repo', repo)
       return store.heartbeatRepo(repo, holder)