@boxxy/model 0.1.2 → 0.1.4

package/src/build-item-views.ts

@@ -1,128 +0,0 @@
-import { deriveItemState } from './derive-item-state.ts';
-import { liveLevers } from './live-levers.ts';
-import type {
-  AttemptId,
-  AttemptRow,
-  Instant,
-  ItemId,
-  ItemKindName,
-  ItemRow,
-  ItemRows,
-  ItemSetRows,
-  ItemState,
-  ItemWithLevers,
-  LeaseRow,
-  LeverRow,
-  LinkRow,
-  MaxAttemptsByKind,
-  PullRequestRow,
-} from './types/core.ts';
-
-export function buildItemViews(
-  rows: ItemSetRows,
-  now: Instant,
-  maxAttemptsByKind: MaxAttemptsByKind,
-): ItemWithLevers[] {
-  const groups = collectItemGroups(rows, now);
-
-  // A blocking source counts only when it is done or archived, and no link makes an item either,
-  // so each source's state derived without its links settles its targets.
-  const ownStates = new Map<ItemId, ItemState>(
-    rows.items.map((item) => [
-      item.id,
-      deriveItemState(
-        item,
-        buildItemRows(item, groups.get(item.id), maxAttemptsByKind, {
-          links: [],
-          blockerStates: new Map(),
-        }),
-      ).state,
-    ]),
-  );
-
-  return rows.items.map((item) => {
-    const group = groups.get(item.id);
-
-    const itemRows = buildItemRows(item, group, maxAttemptsByKind, {
-      links: group?.links ?? [],
-      blockerStates: ownStates,
-    });
-
-    return { ...item, derived: deriveItemState(item, itemRows), levers: group?.levers ?? [] };
-  });
-}
-
-interface ItemGroup {
-  readonly links: LinkRow[];
-  readonly attempts: AttemptRow[];
-  readonly pullRequests: PullRequestRow[];
-  levers: LeverRow[];
-  liveLease: LeaseRow | null;
-}
-
-function collectItemGroups(rows: ItemSetRows, now: Instant): Map<ItemId, ItemGroup> {
-  const groups = new Map<ItemId, ItemGroup>(
-    rows.items.map((item) => [
-      item.id,
-      { links: [], attempts: [], pullRequests: [], levers: [], liveLease: null },
-    ]),
-  );
-
-  const attemptItems = new Map<AttemptId, ItemId>();
-
-  for (const link of rows.links) {
-    groups.get(link.target)?.links.push(link);
-  }
-
-  for (const attempt of rows.attempts) {
-    attemptItems.set(attempt.id, attempt.item);
-    groups.get(attempt.item)?.attempts.push(attempt);
-  }
-
-  for (const pullRequest of rows.pullRequests) {
-    const item = attemptItems.get(pullRequest.attempt);
-
-    if (item !== undefined) {
-      groups.get(item)?.pullRequests.push(pullRequest);
-    }
-  }
-
-  for (const lease of rows.liveLeases) {
-    const group = groups.get(lease.item);
-
-    if (group !== undefined) {
-      group.liveLease = lease;
-    }
-  }
-
-  for (const [item, group] of groups) {
-    group.levers = liveLevers(
-      rows.levers.filter((lever) => lever.item === item),
-      now,
-    );
-  }
-
-  return groups;
-}
-
-function buildItemRows(
-  item: ItemRow,
-  group: ItemGroup | undefined,
-  maxAttemptsByKind: MaxAttemptsByKind,
-  blocking: Pick<ItemRows, 'links' | 'blockerStates'>,
-): ItemRows {
-  return {
-    ...blocking,
-    levers: group?.levers ?? [],
-    attempts: group?.attempts ?? [],
-    liveLease: group?.liveLease ?? null,
-    pullRequests: group?.pullRequests ?? [],
-    maxAttempts: pickMaxAttempts(item.kind, maxAttemptsByKind),
-  };
-}
-
-function pickMaxAttempts(kind: ItemKindName, maxAttemptsByKind: MaxAttemptsByKind): number {
-  const [first] = maxAttemptsByKind.get(kind)?.values() ?? [];
-
-  return first ?? Number.POSITIVE_INFINITY;
-}

package/src/derive-item-state.ts

@@ -1,76 +0,0 @@
-import type { AttemptRow, DerivedState, ItemRow, ItemRows } from './types/core.ts';
-
-interface StateInput {
-  readonly item: ItemRow;
-  readonly rows: ItemRows;
-
-  // the succeeded and failed attempts that ended after the item's latest `item.retry` lever
-  readonly counted: readonly AttemptRow[];
-}
-
-interface StateRule {
-  readonly derived: DerivedState;
-  readonly holds: (input: StateInput) => boolean;
-}
-
-const stateRules: readonly StateRule[] = [
-  { derived: { state: 'archived' }, holds: (input) => input.item.closedAt !== null },
-  { derived: { state: 'done' }, holds: (input) => hasMergedPullRequest(input.rows) },
-  { derived: { state: 'running' }, holds: (input) => input.rows.liveLease !== null },
-  { derived: { state: 'waiting', reason: 'PR open' }, holds: hasOpenPullRequest },
-  { derived: { state: 'waiting', reason: 'no PR linked' }, holds: hasSucceededWithoutPullRequest },
-  { derived: { state: 'waiting', reason: 'attempts used up' }, holds: hasUsedUpAttempts },
-  { derived: { state: 'idea' }, holds: (input) => input.item.acceptance.length === 0 },
-  { derived: { state: 'blocked' }, holds: (input) => hasOpenBlocker(input.rows) },
-];
-
-export function deriveItemState(item: ItemRow, rows: ItemRows): DerivedState {
-  const input = { item, rows, counted: collectCountedAttempts(rows) };
-
-  return stateRules.find((rule) => rule.holds(input))?.derived ?? { state: 'ready' };
-}
-
-function collectCountedAttempts(rows: ItemRows): AttemptRow[] {
-  const retryAt = Math.max(
-    Number.NEGATIVE_INFINITY,
-    ...rows.levers.filter((lever) => lever.kind === 'item.retry').map((lever) => lever.at),
-  );
-
-  return rows.attempts.filter((attempt) => attempt.endedAt !== null && attempt.endedAt > retryAt);
-}
-
-function hasMergedPullRequest(rows: ItemRows): boolean {
-  const succeeded = new Set(collectSucceeded(rows.attempts).map((attempt) => attempt.id));
-
-  return rows.pullRequests.some((pr) => pr.state === 'merged' && succeeded.has(pr.attempt));
-}
-
-function collectSucceeded(attempts: readonly AttemptRow[]): AttemptRow[] {
-  return attempts.filter((attempt) => attempt.state === 'succeeded');
-}
-
-function hasOpenPullRequest(input: StateInput): boolean {
-  const succeeded = new Set(collectSucceeded(input.counted).map((attempt) => attempt.id));
-
-  return input.rows.pullRequests.some((pr) => pr.state === 'open' && succeeded.has(pr.attempt));
-}
-
-function hasSucceededWithoutPullRequest(input: StateInput): boolean {
-  const linked = new Set(input.rows.pullRequests.map((pr) => pr.attempt));
-
-  return collectSucceeded(input.counted).some((attempt) => !linked.has(attempt.id));
-}
-
-function hasUsedUpAttempts(input: StateInput): boolean {
-  const failed = input.counted.filter((attempt) => attempt.state === 'failed');
-
-  return failed.length >= input.rows.maxAttempts;
-}
-
-function hasOpenBlocker(rows: ItemRows): boolean {
-  return rows.links.some((link) => {
-    const blockerState = rows.blockerStates.get(link.source);
-
-    return link.type === 'blocks' && blockerState !== 'done' && blockerState !== 'archived';
-  });
-}

package/src/fact-schemas.ts

@@ -1,132 +0,0 @@
-import { z } from 'zod';
-import { actorRefSchema } from './actor-ref-schema.ts';
-import { brandSchemas } from './brand-schemas.ts';
-import { buildCloseOutSchema } from './build-close-out-schema.ts';
-import { frictionSchema } from './friction-schema.ts';
-import type { FactType, SliceOneFacts } from './types/facts.ts';
-
-const criterionSchema = z.object({
-  id: brandSchemas.criterionId,
-  text: z.string().min(1),
-  evidence: z.array(brandSchemas.factId),
-});
-
-const linkPayloadSchema = z.object({
-  source: brandSchemas.itemId,
-  target: brandSchemas.itemId,
-  type: brandSchemas.linkTypeName,
-});
-
-const faultSchema = z.object({
-  plugin: z.string().min(1),
-  kind: z.enum(['signal', 'gate', 'waiver', 'admission', 'propagation', 'filter-field']),
-  item: brandSchemas.itemId.nullable(),
-  error: z.string(),
-});
-
-const copiedEvidenceSchema = z.object({
-  criterion: brandSchemas.criterionId,
-  evidence: z.array(brandSchemas.factId),
-});
-
-const pullRequestNumberSchema = z.number().int().positive();
-
-export const factSchemas: { readonly [T in FactType]: z.ZodType<SliceOneFacts[T]> } = {
-  'boxxy.item.filed': z.object({
-    id: brandSchemas.itemId,
-    kind: brandSchemas.itemKindName,
-    repo: brandSchemas.repoName,
-    title: z.string().min(1),
-    outcome: z.string().min(1),
-    acceptance: z.array(criterionSchema),
-    foundInAttempt: brandSchemas.attemptId.nullable(),
-    filedBy: actorRefSchema,
-    filedAt: brandSchemas.instant,
-    closedAt: brandSchemas.instant.nullable(),
-    closeReason: z.string().nullable(),
-  }),
-  'boxxy.item.edited': z
-    .object({
-      title: z.string().min(1).exactOptional(),
-      outcome: z.string().min(1).exactOptional(),
-      acceptance: z.array(criterionSchema).exactOptional(),
-    })
-    .refine((fields) => Object.keys(fields).length > 0, 'an edit changes at least one field'),
-  'boxxy.item.closed': z.object({ reason: z.string().min(1) }),
-  'boxxy.link.added': linkPayloadSchema,
-  'boxxy.link.removed': linkPayloadSchema,
-  'boxxy.lever.recorded': z.object({
-    seq: z.number().int().nonnegative(),
-    kind: z.templateLiteral([z.string().min(1), '.', z.string().min(1)]),
-    item: brandSchemas.itemId,
-    until: brandSchemas.instant.nullable(),
-    expiresAt: brandSchemas.instant.nullable(),
-    reason: z.string().nullable(),
-    actor: actorRefSchema,
-    at: brandSchemas.instant,
-  }),
-  'boxxy.attempt.claimed': z.object({
-    item: brandSchemas.itemId,
-    phase: brandSchemas.phaseName,
-    number: z.number().int().positive(),
-    pool: brandSchemas.poolName,
-    slot: z.number().int().nonnegative(),
-    gen: z.number().int().nonnegative(),
-    recipeHash: brandSchemas.recipeHash,
-    rulesVersion: brandSchemas.rulesVersion,
-  }),
-  'boxxy.decision.recorded': z.object({
-    id: brandSchemas.decisionId,
-    attempt: brandSchemas.attemptId,
-    item: brandSchemas.itemId,
-    pool: brandSchemas.poolName,
-    rulesVersion: brandSchemas.rulesVersion,
-    snapshotHash: brandSchemas.snapshotHash,
-    storeVersion: z.number().int().nonnegative(),
-    pepysOffsets: z.record(brandSchemas.streamName, z.number().int().nonnegative()),
-    faults: z.array(faultSchema),
-    at: brandSchemas.instant,
-  }),
-  'boxxy.attempt.started': z.object({ atcSession: brandSchemas.atcSessionId }),
-  'boxxy.attempt.reconciling': z.object({ reason: z.string().min(1) }),
-  'boxxy.attempt.reconciled': z.object({ atcSession: brandSchemas.atcSessionId }),
-  'boxxy.attempt.session_bound': z.object({
-    atcSession: brandSchemas.atcSessionId,
-    agentSession: brandSchemas.agentSessionId,
-    seenAt: brandSchemas.instant,
-  }),
-  'boxxy.attempt.closed_out': z.object({ closeOut: buildCloseOutSchema }),
-  'boxxy.attempt.settled': z.object({
-    state: z.enum(['succeeded', 'failed']),
-    failure: z.string().min(1).nullable(),
-    endedAt: brandSchemas.instant,
-    criteria: z.array(copiedEvidenceSchema),
-    matched: z.array(brandSchemas.itemId),
-    frictionDropped: z.number().int().nonnegative(),
-  }),
-  'boxxy.evidence.recorded': z.object({
-    kind: z.enum(['pr', 'commit', 'test', 'ci-run', 'live-check']),
-    ref: z.string().min(1),
-    observed: z.string().nullable(),
-  }),
-  'boxxy.evidence.pr_linked': z.object({
-    repo: brandSchemas.repoName,
-    number: pullRequestNumberSchema,
-    url: z.url(),
-  }),
-  'boxxy.evidence.commit_linked': z.object({
-    repo: brandSchemas.repoName,
-    sha: brandSchemas.commitSha,
-    pr: pullRequestNumberSchema,
-  }),
-  'boxxy.pr.merged': z.object({
-    repo: brandSchemas.repoName,
-    number: pullRequestNumberSchema,
-    mergedAt: brandSchemas.instant,
-    mergeCommit: brandSchemas.commitSha,
-  }),
-  'boxxy.pr.closed': z.object({ repo: brandSchemas.repoName, number: pullRequestNumberSchema }),
-  'boxxy.proposal.recorded': frictionSchema,
-  'boxxy.runner.paused': z.object({ runner: brandSchemas.runnerId }),
-  'boxxy.runner.resumed': z.object({ runner: brandSchemas.runnerId }),
-};

package/src/find-slot-take.ts

@@ -1,12 +0,0 @@
-import invariant from 'tiny-invariant';
-import type { RowWrite } from './types/ports.ts';
-
-export type SlotTake = Extract<RowWrite, { op: 'take-slot' }>;
-
-export function findSlotTake(writes: readonly RowWrite[]): SlotTake | null {
-  const takes = writes.filter((write): write is SlotTake => write.op === 'take-slot');
-
-  invariant(takes.length <= 1, 'a change takes one slot at most');
-
-  return takes.at(0) ?? null;
-}

package/src/friction-schema.ts

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-import type { Friction } from './types/facts.ts';
-
-export const frictionSchema: z.ZodType<Friction> = z.object({
-  target: z.object({
-    kind: z.enum(['skill', 'rule', 'lint', 'agents-md', 'tool']),
-    name: z.string().min(1),
-  }),
-  change: z.string().min(1),
-});

package/src/outbox-fact-schema.ts

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-import { actorRefSchema } from './actor-ref-schema.ts';
-import { brandSchemas } from './brand-schemas.ts';
-import type { OutboxFact } from './types/facts.ts';
-
-const idSchema = z.string();
-
-const entityRefSchema = z.union([
-  z.templateLiteral(['boxxy:item:', idSchema]),
-  z.templateLiteral(['boxxy:link:', idSchema, ':', idSchema, ':', idSchema]),
-  z.templateLiteral(['boxxy:attempt:', idSchema]),
-  z.templateLiteral(['boxxy:decision:', idSchema]),
-  z.templateLiteral(['boxxy:runner:', idSchema]),
-]);
-
-export const outboxFactSchema: z.ZodType<OutboxFact> = z.object({
-  seq: z.number().int().positive(),
-  factId: brandSchemas.factId,
-  type: z.string().min(1),
-  entity: entityRefSchema,
-  actor: actorRefSchema,
-  at: brandSchemas.instant,
-  payload: z.json(),
-  sentAt: brandSchemas.instant.nullable(),
-});

package/src/row-schemas.ts

@@ -1,89 +0,0 @@
-import { contentHashSchema } from '@boxxy/content-hash';
-import { z } from 'zod';
-import { actorRefSchema } from './actor-ref-schema.ts';
-import { brandSchemas } from './brand-schemas.ts';
-import { buildCloseOutSchema } from './build-close-out-schema.ts';
-import { factSchemas } from './fact-schemas.ts';
-import type { TableName, Tables } from './types/ports.ts';
-
-const countSchema = z.number().int().nonnegative();
-
-export const rowSchemas: { readonly [T in TableName]: z.ZodType<Tables[T]> } = {
-  items: factSchemas['boxxy.item.filed'],
-  links: z.object({
-    source: brandSchemas.itemId,
-    target: brandSchemas.itemId,
-    type: brandSchemas.linkTypeName,
-    addedBy: actorRefSchema,
-    addedAt: brandSchemas.instant,
-    removedAt: brandSchemas.instant.nullable(),
-  }),
-  levers: factSchemas['boxxy.lever.recorded'],
-  attempts: z.object({
-    id: brandSchemas.attemptId,
-    item: brandSchemas.itemId,
-    phase: brandSchemas.phaseName,
-    number: z.number().int().positive(),
-    runner: brandSchemas.runnerId,
-    recipeHash: brandSchemas.recipeHash,
-    rulesVersion: brandSchemas.rulesVersion,
-    pool: brandSchemas.poolName,
-    slot: countSchema,
-    slotGen: countSchema,
-    leaseGen: countSchema,
-    spawnRequest: z.json(),
-    spawnRequestHash: contentHashSchema,
-    state: z.enum(['starting', 'running', 'reconciling', 'succeeded', 'failed']),
-    failure: z.string().nullable(),
-    atcSession: brandSchemas.atcSessionId.nullable(),
-    closeOut: buildCloseOutSchema.nullable(),
-    claimedAt: brandSchemas.instant,
-    startedAt: brandSchemas.instant.nullable(),
-    endedAt: brandSchemas.instant.nullable(),
-  }),
-  attempt_sessions: z.object({
-    attempt: brandSchemas.attemptId,
-    agentSession: brandSchemas.agentSessionId,
-    atcSession: brandSchemas.atcSessionId,
-    seenAt: brandSchemas.instant,
-  }),
-  leases: z.object({
-    item: brandSchemas.itemId,
-    phase: brandSchemas.phaseName,
-    attempt: brandSchemas.attemptId,
-    gen: countSchema,
-    takenAt: brandSchemas.instant,
-    releasedAt: brandSchemas.instant.nullable(),
-  }),
-  pool_slots: z.object({
-    pool: brandSchemas.poolName,
-    slot: countSchema,
-    holder: brandSchemas.attemptId.nullable(),
-    gen: countSchema,
-    retired: z.boolean(),
-  }),
-  decisions: factSchemas['boxxy.decision.recorded'],
-  evidence: z.object({
-    factId: brandSchemas.factId,
-    attempt: brandSchemas.attemptId,
-    kind: z.enum(['pr', 'commit', 'test', 'ci-run', 'live-check']),
-    ref: z.string().min(1),
-    observed: z.string().nullable(),
-    source: z.enum(['hook', 'trailer', 'agent', 'watch']),
-    at: brandSchemas.instant,
-  }),
-  pull_requests: z.object({
-    repo: brandSchemas.repoName,
-    number: z.number().int().positive(),
-    attempt: brandSchemas.attemptId,
-    state: z.enum(['open', 'closed', 'merged']),
-    mergedAt: brandSchemas.instant.nullable(),
-    mergeCommit: brandSchemas.commitSha.nullable(),
-    checkedAt: brandSchemas.instant,
-  }),
-  runners: z.object({
-    id: brandSchemas.runnerId,
-    heartbeatAt: brandSchemas.instant,
-    paused: z.boolean(),
-  }),
-};

package/src/test-utils/build-mock-item-rows.ts

@@ -1,14 +0,0 @@
-import type { ItemRows } from '../types/core.ts';
-
-export function buildMockItemRows(overrides: Partial<ItemRows> = {}): ItemRows {
-  return {
-    links: [],
-    blockerStates: new Map(),
-    levers: [],
-    attempts: [],
-    liveLease: null,
-    pullRequests: [],
-    maxAttempts: 2,
-    ...overrides,
-  };
-}

package/src/test-utils/build-mock-item-view.ts

@@ -1,8 +0,0 @@
-import type { ItemView } from '../types/core.ts';
-import { buildMockItemRow } from './build-mock-item-row.ts';
-
-export function buildMockItemView(overrides: Partial<ItemView> = {}): ItemView {
-  const { derived, ...row } = overrides;
-
-  return { ...buildMockItemRow(row), derived: derived ?? { state: 'ready' } };
-}

package/src/test-utils/build-mock-pull-request-row.ts

@@ -1,16 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { brandSchemas } from '../brand-schemas.ts';
-import type { PullRequestRow } from '../types/core.ts';
-
-export function buildMockPullRequestRow(overrides: Partial<PullRequestRow> = {}): PullRequestRow {
-  return {
-    repo: brandSchemas.repoName.parse(`${faker.string.alpha(8)}/${faker.string.alpha(8)}`),
-    number: faker.number.int({ min: 1, max: 10_000 }),
-    attempt: brandSchemas.attemptId.parse(faker.string.uuid({ version: 7 })),
-    state: 'open',
-    mergedAt: null,
-    mergeCommit: null,
-    checkedAt: brandSchemas.instant.parse(faker.number.int({ max: 1_800_000_000_000 })),
-    ...overrides,
-  };
-}

package/src/types/dispatch.ts

@@ -1,95 +0,0 @@
-import type { ContentHash } from '@boxxy/content-hash';
-import type {
-  AttemptId,
-  AttemptRow,
-  CriterionId,
-  EvidenceRow,
-  FactId,
-  ForcedFailure,
-  Instant,
-  ItemView,
-  KnownFailure,
-  LiveAttemptState,
-  Minutes,
-  RecipeName,
-  RepoName,
-} from './core.ts';
-import type { Friction, OpenItem } from './facts.ts';
-import type { SessionReading, SpawnRequest } from './ports.ts';
-
-export interface SpawnContext {
-  readonly repoPaths: ReadonlyMap<RepoName, string>;
-  readonly pluginFolder: { readonly path: string; readonly hash: ContentHash };
-  readonly promptTemplates: ReadonlyMap<RecipeName, string>;
-}
-
-export interface Claim {
-  readonly attempt: AttemptRow;
-  readonly spawn: SpawnRequest;
-}
-
-export type ReconcileAction =
-  | {
-      readonly kind: 'move-to-running';
-      readonly fact: 'boxxy.attempt.started' | 'boxxy.attempt.reconciled';
-    }
-  | { readonly kind: 'bind-session' }
-  | { readonly kind: 'settle' }
-  | { readonly kind: 'fail'; readonly failure: Extract<KnownFailure, 'session-lost'> }
-  | {
-      readonly kind: 'respawn';
-      readonly giveUpAfter: Minutes;
-      readonly then: Extract<KnownFailure, 'spawn-lost'>;
-    };
-
-export type ReconcileTable = Readonly<
-  Record<SessionReading['kind'], Readonly<Record<LiveAttemptState, ReconcileAction>>>
->;
-
-export interface Settlement {
-  readonly state: 'succeeded' | 'failed';
-  readonly failure: string | null;
-  readonly openItems: readonly OpenItem[];
-  readonly criteria: readonly {
-    readonly criterion: CriterionId;
-    readonly evidence: readonly FactId[];
-  }[];
-  readonly friction: readonly Friction[];
-  readonly frictionDropped: number;
-}
-
-export interface SettleRule<Out = unknown> {
-  settle: (input: SettleInput<Out>) => Settlement;
-}
-
-export interface SettleInput<Out> {
-  readonly attempt: AttemptRow;
-  readonly item: ItemView;
-  readonly closeOut: CloseOutParse<Out> | null;
-
-  // a `forced` reason wins over the close-out's state
-  readonly forced: ForcedFailure | null;
-  readonly now: Instant;
-}
-
-export interface CloseOutContext {
-  readonly item: ItemView;
-  readonly attempt: AttemptId;
-
-  // the attempt's own evidence rows
-  readonly evidence: readonly EvidenceRow[];
-}
-
-export type CloseOutProblem =
-  | { readonly kind: 'schema'; readonly path: string; readonly message: string }
-  | { readonly kind: 'unknown-criterion'; readonly criterion: CriterionId }
-  | { readonly kind: 'foreign-evidence'; readonly evidence: FactId }
-  | { readonly kind: 'built-without-evidence'; readonly criteria: readonly CriterionId[] };
-
-export type CloseOutParse<Out> =
-  | { readonly kind: 'valid'; readonly closeOut: Out }
-  | { readonly kind: 'invalid'; readonly problems: readonly CloseOutProblem[] };
-
-export interface CloseOutParser<Out> {
-  parse: (raw: unknown, ctx: CloseOutContext) => CloseOutParse<Out>;
-}