@defrex/autobuild 0.8.0 → 0.10.0

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

@@ -26,12 +26,34 @@ import {
 } from '../events/sessions'
 import { humanActor } from '../events/envelope'
 import { createBuildScopedStore } from './build-scope'
+import {
+  type ReducerSnapshot,
+  type SnapshotScope,
+  snapshotScopeKey,
+  snapshotSupersedes,
+} 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,
   isRetentionManagedKind,
   revisionsToPrune,
 } from './retention'
+import {
+  DEFAULT_TICKET_ASSET_LIMITS,
+  loadTicketAsset,
+  resolvePinnedAsset,
+  storeTicketAssetBlobs,
+  summarizeTicketAsset,
+  validateTicketAssetInput,
+  type TicketAsset,
+  type TicketAssetInput,
+  type TicketAssetLimits,
+  type TicketAssetMeta,
+  type TicketAssetSummary,
+} from './ticket-assets'
 import { pollingSubscribe } from './subscribe'
 import { StreamLocks } from './streams/lock'
 import { assembleUIMessageDocument } from './streams/assemble'
@@ -62,6 +84,7 @@ import {
   type ArtifactMeta,
   type BlobStore,
   type BuildRecord,
+  type BuildDigest,
   type BuildScopedStore,
   type BuildStore,
   type Clock,
@@ -146,6 +169,11 @@ export class MemoryBuildStore implements BuildStore {
    * stream's close against its appends inside this process (AUT-348). */
   private readonly streamLocks = new StreamLocks()
   private readonly sessions = new Map<string, SessionState>()
+  /** Reducer snapshots (store/snapshots.ts), keyed by scope and reducer name. */
+  private readonly snapshots = new Map<string, ReducerSnapshot>()
+  /** `[repo, ticketId, kind, name]` → rows in revision order. A removal is a
+   * tombstone row (`removed`, empty manifest) taking the next revision. */
+  private readonly ticketAssets = new Map<string, { meta: TicketAssetMeta; removed: boolean }[]>()
   private readonly clock: Clock
   private readonly maxRevisions: number
   readonly blobs: BlobStore
@@ -244,6 +272,7 @@ export class MemoryBuildStore implements BuildStore {
   }
 
   async createBuild(input: NewBuildInput): Promise<BuildRecord> {
+    const created = validateCreatedEvent(input)
     if (this.builds.has(input.slug)) {
       throw new Error(`build "${input.slug}" already exists`)
     }
@@ -261,6 +290,18 @@ export class MemoryBuildStore implements BuildStore {
       events: [],
       artifacts: new Map(),
     }
+    if (created !== undefined) {
+      state.events.push(
+        structuredClone({
+          build: input.slug,
+          seq: 1,
+          ts,
+          actor: created.actor,
+          type: created.type,
+          payload: created.payload,
+        }) as AbEvent,
+      )
+    }
     this.builds.set(input.slug, state)
     return this.snapshot(state)
   }
@@ -274,6 +315,37 @@ export class MemoryBuildStore implements BuildStore {
     return [...this.builds.values()].map((state) => this.snapshot(state))
   }
 
+  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
+  }
+
   async append<T extends EventType>(slug: string, event: EventWrite<T>): Promise<EventEnvelope<T>> {
     const state = this.state(slug)
     const validated = validateEventWrite(event)
@@ -629,6 +701,58 @@ export class MemoryBuildStore implements BuildStore {
     })
   }
 
+  async getRepoHighWater(repo: string): Promise<number> {
+    return this.repoState(repo).events.at(-1)?.seq ?? 0
+  }
+
+  /** The scope's log tail, or `undefined` for a scope that does not exist. */
+  private snapshotTail(scope: SnapshotScope): number | undefined {
+    const events =
+      scope.kind === 'build'
+        ? this.builds.get(scope.slug)?.events
+        : this.repos.get(scope.repo)?.events
+    return events === undefined ? undefined : (events.at(-1)?.seq ?? 0)
+  }
+
+  async getReducerSnapshot(
+    scope: SnapshotScope,
+    reducer: string,
+    version: number,
+  ): Promise<ReducerSnapshot | null> {
+    const tail = this.snapshotTail(scope)
+    if (tail === undefined) return null
+    const stored = this.snapshots.get(`${snapshotScopeKey(scope)}\u0000${reducer}`)
+    if (stored === undefined || stored.version !== version || stored.cursor > tail) return null
+    return { version: stored.version, cursor: stored.cursor, state: structuredClone(stored.state) }
+  }
+
+  async putReducerSnapshot(
+    scope: SnapshotScope,
+    reducer: string,
+    snapshot: ReducerSnapshot,
+  ): Promise<boolean> {
+    const tail = this.snapshotTail(scope)
+    if (tail === undefined || snapshot.cursor > tail) return false
+    const key = `${snapshotScopeKey(scope)}\u0000${reducer}`
+    if (!snapshotSupersedes(snapshot, this.snapshots.get(key))) return false
+    // The JSON round trip is the stored form every adapter shares, so callers
+    // cannot alias what the store holds.
+    this.snapshots.set(key, {
+      version: snapshot.version,
+      cursor: snapshot.cursor,
+      state: JSON.parse(JSON.stringify(snapshot.state ?? null)),
+    })
+    return true
+  }
+
+  async getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
+    // The oracle runs on the in-memory journal itself, which keeps the pure
+    // derivation honest against real adapter data.
+    return structuredClone(
+      projectRepositoryStateEvents(this.repoState(repo).events as RepositoryEvent[]),
+    )
+  }
+
   async putRepoArtifact(repo: string, artifact: ArtifactInput): Promise<RepositoryArtifactMeta> {
     const state = this.repoState(repo)
     if (!artifact.kind) throw new Error('artifact kind is required')
@@ -676,6 +800,102 @@ export class MemoryBuildStore implements BuildStore {
     )
   }
 
+  async ticketAssetLimits(_repo: string): Promise<TicketAssetLimits> {
+    return { ...DEFAULT_TICKET_ASSET_LIMITS }
+  }
+
+  async putTicketAsset(
+    repo: string,
+    ticketId: string,
+    asset: TicketAssetInput,
+  ): Promise<TicketAssetMeta> {
+    const size = validateTicketAssetInput(asset)
+    const entries = await storeTicketAssetBlobs(this.blobs, asset.entries)
+    const key = JSON.stringify([repo, ticketId, asset.kind, asset.name])
+    const rows = this.ticketAssets.get(key) ?? []
+    const meta: TicketAssetMeta = {
+      repo,
+      ticketId,
+      kind: asset.kind,
+      name: asset.name,
+      revision: MemoryBuildStore.nextRevision(rows.map((row) => row.meta)),
+      layout: asset.layout,
+      size,
+      entries,
+      createdAt: this.now(),
+    }
+    rows.push({ meta, removed: false })
+    this.ticketAssets.set(key, rows)
+    return structuredClone(meta)
+  }
+
+  async getTicketAsset(
+    repo: string,
+    ticketId: string,
+    kind: string,
+    name: string,
+    rev?: number,
+  ): Promise<TicketAsset | null> {
+    const rows = this.ticketAssets.get(JSON.stringify([repo, ticketId, kind, name]))
+    const row =
+      rev === undefined ? rows?.at(-1) : rows?.find((candidate) => candidate.meta.revision === rev)
+    if (!row || row.removed) return null
+    return loadTicketAsset(this.blobs, row.meta)
+  }
+
+  async getPinnedTicketAsset(
+    slug: string,
+    kind: string,
+    name: string,
+    rev?: number,
+  ): Promise<TicketAsset | null> {
+    return resolvePinnedAsset(this, slug, kind, name, rev)
+  }
+
+  async listTicketAssets(
+    repo: string,
+    ticketId: string,
+    opts?: { revisions?: boolean },
+  ): Promise<TicketAssetSummary[]> {
+    const out: TicketAssetSummary[] = []
+    for (const rows of this.ticketAssets.values()) {
+      const first = rows[0]
+      if (!first || first.meta.repo !== repo || first.meta.ticketId !== ticketId) continue
+      if (opts?.revisions) {
+        for (const row of rows) if (!row.removed) out.push(summarizeTicketAsset(row.meta))
+      } else {
+        const latest = rows.at(-1)
+        if (latest && !latest.removed) out.push(summarizeTicketAsset(latest.meta))
+      }
+    }
+    return out.sort(
+      (a, b) =>
+        a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name) || a.revision - b.revision,
+    )
+  }
+
+  async removeTicketAsset(
+    repo: string,
+    ticketId: string,
+    kind: string,
+    name: string,
+  ): Promise<TicketAssetMeta | null> {
+    const rows = this.ticketAssets.get(JSON.stringify([repo, ticketId, kind, name]))
+    const latest = rows?.at(-1)
+    if (!rows || !latest || latest.removed) return null
+    rows.push({
+      meta: {
+        ...latest.meta,
+        revision: latest.meta.revision + 1,
+        size: 0,
+        entries: [],
+        createdAt: this.now(),
+      },
+      removed: true,
+    })
+    return structuredClone(latest.meta)
+  }
+
   async claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean> {
     const state = this.repoState(repo)
     const now = this.clock().getTime()
@@ -791,6 +1011,32 @@ export class MemoryBuildStore implements BuildStore {
     return envelope
   }
 
+  async appendSessionEventIfCurrent<T extends SessionEventType>(
+    id: string,
+    expectedSeq: number,
+    event: SessionEventWrite<T>,
+  ): Promise<SessionEventEnvelope<T> | null> {
+    const state = this.sessionState(id)
+    validateExpectedSeq(expectedSeq)
+    const validated = validateSessionEventWrite(event)
+
+    // No await occurs between comparison and mutation. JavaScript's run-to-
+    // completion semantics make this one atomic critical section even when
+    // concurrent remote requests interleave elsewhere in the adapter.
+    if (state.events.length !== expectedSeq) return null
+    const envelope = {
+      session: id,
+      seq: expectedSeq + 1,
+      ts: this.now(),
+      actor: validated.actor,
+      type: validated.type,
+      payload: validated.payload,
+    } as SessionEventEnvelope<T>
+    state.events.push(structuredClone(envelope) as SessionEvent)
+    state.record.updatedAt = envelope.ts
+    return envelope
+  }
+
   async getSessionEvents(
     id: string,
     sinceSeq = 0,

package/packages/core/src/store/new-build.ts

@@ -0,0 +1,17 @@
+import { EventValidationError, validateEventWrite, type EventWrite } from '../events/catalog'
+import type { NewBuildInput } from './types'
+
+/** Validate `input.created` before an adapter opens its create transaction, so
+ * an invalid initial event creates nothing. Returns the validated write. */
+export function validateCreatedEvent(
+  input: NewBuildInput,
+): EventWrite<'build.created'> | undefined {
+  if (input.created === undefined) return undefined
+  const validated = validateEventWrite(input.created)
+  if (validated.type !== 'build.created') {
+    throw new EventValidationError(
+      `createBuild's initial event must be "build.created", got "${validated.type}"`,
+    )
+  }
+  return validated as EventWrite<'build.created'>
+}

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

@@ -8,6 +8,7 @@
  * scope handles in `session-handle.ts` (hosted-only, AUT-339), which scope a
  * store to a single operator session's record.
  */
+import type { ReducerSnapshot, SnapshotScope } from './snapshots'
 import type { EventType } from '../events/payloads'
 import type { EventWrite } from '../events/catalog'
 import type { RepositoryEventType, RepositoryEventWrite } from '../events/repository'
@@ -23,6 +24,7 @@ import type {
   Artifact,
   ArtifactInput,
   ArtifactMeta,
+  BuildDigest,
   BuildRecord,
   BuildStore,
   NewBuildInput,
@@ -35,6 +37,13 @@ import type {
   SubscribeOptions,
   Unsubscribe,
 } from './types'
+import type {
+  TicketAsset,
+  TicketAssetInput,
+  TicketAssetLimits,
+  TicketAssetMeta,
+  TicketAssetSummary,
+} from './ticket-assets'
 import type {
   StreamChunk,
   StreamOutcome,
@@ -316,6 +325,36 @@ export function scopeLocalStoreToPhaseSession(
       own('getRepoEvents', 'repo', repo)
       return store.getRepoEvents(repo, sinceSeq, opts)
     },
+    async getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
+      own('getRepoStateEvents', 'repo', repo)
+      return store.getRepoStateEvents(repo)
+    },
+    async getRepoHighWater(repo: string): Promise<number> {
+      own('getRepoHighWater', 'repo', repo)
+      return store.getRepoHighWater(repo)
+    },
+    async getReducerSnapshot(
+      target: SnapshotScope,
+      reducer: string,
+      version: number,
+    ): Promise<ReducerSnapshot | null> {
+      if (target.kind === 'build') own('getReducerSnapshot', 'build', target.slug)
+      else own('getReducerSnapshot', 'repo', target.repo)
+      return store.getReducerSnapshot(target, reducer, version)
+    },
+    async putReducerSnapshot(
+      target: SnapshotScope,
+      reducer: string,
+      snapshot: ReducerSnapshot,
+    ): Promise<boolean> {
+      if (target.kind === 'build') own('putReducerSnapshot', 'build', target.slug)
+      else own('putReducerSnapshot', 'repo', target.repo)
+      return store.putReducerSnapshot(target, reducer, snapshot)
+    },
+    async getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
+      own('getRepoBuildDigests', 'repo', repo)
+      return store.getRepoBuildDigests(repo)
+    },
     async putRepoArtifact(repo: string, artifact: ArtifactInput): Promise<RepositoryArtifactMeta> {
       own('putRepoArtifact', 'repo', repo)
       return store.putRepoArtifact(repo, artifact)
@@ -332,6 +371,54 @@ export function scopeLocalStoreToPhaseSession(
       own('listRepoArtifacts', 'repo', repo)
       return store.listRepoArtifacts(repo, kind)
     },
+    async ticketAssetLimits(repo: string): Promise<TicketAssetLimits> {
+      own('ticketAssetLimits', 'repo', repo)
+      return store.ticketAssetLimits(repo)
+    },
+    async putTicketAsset(
+      repo: string,
+      ticketId: string,
+      asset: TicketAssetInput,
+    ): Promise<TicketAssetMeta> {
+      own('putTicketAsset', 'repo', repo)
+      return store.putTicketAsset(repo, ticketId, asset)
+    },
+    async getTicketAsset(
+      repo: string,
+      ticketId: string,
+      kind: string,
+      name: string,
+      rev?: number,
+    ): Promise<TicketAsset | null> {
+      own('getTicketAsset', 'repo', repo)
+      return store.getTicketAsset(repo, ticketId, kind, name, rev)
+    },
+    async getPinnedTicketAsset(
+      slug: string,
+      kind: string,
+      name: string,
+      rev?: number,
+    ): Promise<TicketAsset | null> {
+      own('getPinnedTicketAsset', 'build', slug)
+      return store.getPinnedTicketAsset(slug, kind, name, rev)
+    },
+    async listTicketAssets(
+      repo: string,
+      ticketId: string,
+      opts?: { revisions?: boolean },
+    ): Promise<TicketAssetSummary[]> {
+      own('listTicketAssets', 'repo', repo)
+      return store.listTicketAssets(repo, ticketId, opts)
+    },
+    async removeTicketAsset(
+      repo: string,
+      ticketId: string,
+      kind: string,
+      name: string,
+    ): Promise<TicketAssetMeta | null> {
+      own('removeTicketAsset', 'repo', repo)
+      return store.removeTicketAsset(repo, ticketId, kind, name)
+    },
     async claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean> {
       own('claimRepoLease', 'repo', repo)
       return store.claimRepoLease(repo, holder, ttlMs)
@@ -390,6 +477,13 @@ export function scopeLocalStoreToPhaseSession(
     ): Promise<SessionEventEnvelope<T>> {
       return admin('appendSessionEvent')
     },
+    appendSessionEventIfCurrent<T extends SessionEventType>(
+      _id: string,
+      _expectedSeq: number,
+      _event: SessionEventWrite<T>,
+    ): Promise<SessionEventEnvelope<T> | null> {
+      return admin('appendSessionEventIfCurrent')
+    },
     getSessionEvents(_id: string, _sinceSeq?: number): Promise<SessionEvent[]> {
       return admin('getSessionEvents')
     },