@boxxy/model 0.1.2 → 0.1.3

package/src/types/facts.ts

@@ -1,166 +0,0 @@
-import type { JsonValue } from '@boxxy/content-hash';
-import type {
-  ActorRef,
-  AgentSessionId,
-  AtcSessionId,
-  CommitSha,
-  Criterion,
-  CriterionId,
-  DecisionRow,
-  EvidenceKind,
-  FactId,
-  Instant,
-  ItemId,
-  ItemRow,
-  LeverRow,
-  LinkTypeName,
-  PhaseName,
-  PoolName,
-  RecipeHash,
-  RepoName,
-  RulesVersion,
-  RunnerId,
-} from './core.ts';
-
-export interface BuildCloseOut {
-  readonly result:
-    | { readonly kind: 'built' }
-    | { readonly kind: 'blocked'; readonly reason: string }
-    | { readonly kind: 'abandoned'; readonly reason: string };
-  readonly criteria: readonly { readonly criterion: CriterionId; readonly evidence: FactId }[];
-  readonly openItems: readonly OpenItem[];
-  readonly friction: readonly Friction[];
-  readonly frictionDropped: number;
-}
-
-export interface OpenItem {
-  readonly kind: 'core.issue';
-  readonly title: string;
-  readonly body: string;
-}
-
-export type FrictionTargetKind = 'skill' | 'rule' | 'lint' | 'agents-md' | 'tool';
-
-export interface Friction {
-  readonly target: { readonly kind: FrictionTargetKind; readonly name: string };
-  readonly change: string;
-}
-
-export type EntityRef =
-  | `boxxy:item:${string}`
-  | `boxxy:link:${string}:${string}:${string}`
-  | `boxxy:attempt:${string}`
-  | `boxxy:decision:${string}`
-  | `boxxy:runner:${string}`;
-
-export interface FactEnvelope<
-  M extends object = SliceOneFacts,
-  T extends keyof M & string = keyof M & string,
-> {
-  readonly id: FactId;
-  readonly type: T;
-
-  // oxlint-disable-next-line id-length -- pepys's fact envelope names this field
-  readonly v: 1;
-  readonly api: 'boxxy/1';
-  readonly entity: EntityRef;
-  readonly actor: ActorRef;
-  readonly at: Instant;
-  readonly payload: M[T] & { readonly storeVersion: number };
-}
-
-export interface NewFact<T extends keyof M & string, M extends object = SliceOneFacts> {
-  readonly id: FactId;
-  readonly type: T;
-  readonly entity: EntityRef;
-  readonly actor: ActorRef;
-  readonly payload: M[T];
-}
-
-export interface OutboxFact {
-  readonly seq: number;
-  readonly factId: FactId;
-  readonly type: string;
-  readonly entity: EntityRef;
-  readonly actor: ActorRef;
-  readonly at: Instant;
-  readonly payload: JsonValue;
-  readonly sentAt: Instant | null;
-}
-
-export type FactType = keyof SliceOneFacts;
-
-export interface LinkPayload {
-  readonly source: ItemId;
-  readonly target: ItemId;
-  readonly type: LinkTypeName;
-}
-
-export interface SliceOneFacts {
-  'boxxy.item.filed': ItemRow;
-  'boxxy.item.edited': {
-    readonly title?: string;
-    readonly outcome?: string;
-    readonly acceptance?: readonly Criterion[];
-  };
-  'boxxy.item.closed': { readonly reason: string };
-  'boxxy.link.added': LinkPayload;
-  'boxxy.link.removed': LinkPayload;
-  'boxxy.lever.recorded': LeverRow;
-  'boxxy.attempt.claimed': {
-    readonly item: ItemId;
-    readonly phase: PhaseName;
-    readonly number: number;
-    readonly pool: PoolName;
-    readonly slot: number;
-    readonly gen: number;
-    readonly recipeHash: RecipeHash;
-    readonly rulesVersion: RulesVersion;
-  };
-  'boxxy.decision.recorded': DecisionRow;
-  'boxxy.attempt.started': { readonly atcSession: AtcSessionId };
-  'boxxy.attempt.reconciling': { readonly reason: string };
-  'boxxy.attempt.reconciled': { readonly atcSession: AtcSessionId };
-  'boxxy.attempt.session_bound': {
-    readonly atcSession: AtcSessionId;
-    readonly agentSession: AgentSessionId;
-    readonly seenAt: Instant;
-  };
-  'boxxy.attempt.closed_out': { readonly closeOut: BuildCloseOut };
-  'boxxy.attempt.settled': {
-    readonly state: 'succeeded' | 'failed';
-    readonly failure: string | null;
-    readonly endedAt: Instant;
-    readonly criteria: readonly {
-      readonly criterion: CriterionId;
-      readonly evidence: readonly FactId[];
-    }[];
-    readonly matched: readonly ItemId[];
-    readonly frictionDropped: number;
-  };
-  'boxxy.evidence.recorded': {
-    readonly kind: EvidenceKind;
-    readonly ref: string;
-    readonly observed: string | null;
-  };
-  'boxxy.evidence.pr_linked': {
-    readonly repo: RepoName;
-    readonly number: number;
-    readonly url: string;
-  };
-  'boxxy.evidence.commit_linked': {
-    readonly repo: RepoName;
-    readonly sha: CommitSha;
-    readonly pr: number;
-  };
-  'boxxy.pr.merged': {
-    readonly repo: RepoName;
-    readonly number: number;
-    readonly mergedAt: Instant;
-    readonly mergeCommit: CommitSha;
-  };
-  'boxxy.pr.closed': { readonly repo: RepoName; readonly number: number };
-  'boxxy.proposal.recorded': Friction;
-  'boxxy.runner.paused': { readonly runner: RunnerId };
-  'boxxy.runner.resumed': { readonly runner: RunnerId };
-}

package/src/types/planning.ts

@@ -1,136 +0,0 @@
-import type {
-  FaultRecord,
-  Instant,
-  ItemId,
-  ItemView,
-  LeverRow,
-  LinkRow,
-  LinkTypeName,
-  PhaseName,
-  PoolName,
-} from './core.ts';
-import type { Schema } from './registries.ts';
-
-export type SignalName = string;
-
-export type GateName = string;
-
-export type WaiverName = string;
-
-export type AdmissionName = string;
-
-export type ViewName = string;
-
-export type SignalKey = `${SignalName}#${string}`;
-
-export interface Snapshot {
-  storeVersion: number;
-
-  // every item not yet done and not archived, with its state derived at the read's `now`
-  items: ItemView[];
-  links: LinkRow[];
-  levers: LeverRow[];
-  freeSlots: Record<PoolName, number>;
-}
-
-export interface FrameItem extends ItemView {
-  readonly phase: PhaseName;
-}
-
-export interface Frame {
-  // the open items in state `ready`, the only items decide picks
-  candidates: FrameItem[];
-  fields: Map<ItemId, Readonly<Record<string, readonly string[]>>>;
-  values: Map<SignalKey, Map<ItemId, number>>;
-  holds: Map<ItemId, Hold[]>;
-  lifted: Map<ItemId, Lift[]>;
-  faults: Fault[];
-}
-
-export type FrameValues = ReadonlyMap<SignalKey, ReadonlyMap<ItemId, number>>;
-
-export interface Hold {
-  readonly gate: GateName;
-  readonly reason: string;
-  readonly until?: Instant;
-}
-
-export interface Lift {
-  readonly waiver: WaiverName;
-  readonly gate: GateName;
-  readonly reason: string;
-}
-
-export type Fault = FaultRecord;
-
-export interface Decision {
-  // in pool order, then by each pool's `order`
-  picks: Pick[];
-}
-
-export interface Pick {
-  item: ItemId;
-  phase: PhaseName;
-  pool: PoolName;
-}
-
-export interface Pool {
-  readonly name: PoolName;
-  readonly slots: number;
-  readonly takes: Readonly<Record<string, readonly string[]>>;
-
-  // `lead`, then the pool's own `order`: lower first, no value last, then item id
-  readonly order: readonly SignalKey[];
-}
-
-export interface PlanContext {
-  now: Instant;
-  levers: LeverRow[];
-  links: LinkRow[];
-  values: FrameValues;
-}
-
-export interface Signal<P> {
-  name: SignalName;
-  params: Schema<P>;
-
-  // null is no opinion
-  value: (item: FrameItem, ctx: PlanContext, params: P) => number | null;
-  combine?: (left: number, right: number) => number;
-}
-
-export interface Gate<P> {
-  name: GateName;
-  liftable: boolean;
-  params: Schema<P>;
-  hold: (item: FrameItem, ctx: PlanContext, params: P) => Hold | null;
-}
-
-export interface Waiver {
-  name: WaiverName;
-  lifts: GateName;
-  lift: (item: FrameItem, hold: Hold, ctx: PlanContext) => Lift | null;
-}
-
-export interface Admission<P> {
-  name: AdmissionName;
-  params: Schema<P>;
-  admit: (item: FrameItem, ctx: PlanContext, params: P) => AdmissionGrant | null;
-}
-
-export interface AdmissionGrant {
-  readonly admission: AdmissionName;
-  readonly pools: readonly PoolName[] | 'any';
-  readonly reason: string;
-}
-
-export interface View<I = unknown, O = unknown> {
-  name: ViewName;
-  render: (frame: Frame, input: I) => O;
-}
-
-export interface PropagationLine {
-  readonly value: SignalName;
-  readonly over: LinkTypeName;
-  readonly toward: 'source' | 'target';
-}

package/src/types/ports.ts

@@ -1,262 +0,0 @@
-import type { JsonValue } from '@boxxy/content-hash';
-import type {
-  AgentSessionId,
-  AtcSessionId,
-  AttemptId,
-  AttemptRow,
-  AttemptSessionRow,
-  CommitSha,
-  DecisionRow,
-  Effort,
-  EvidenceRow,
-  FactId,
-  Instant,
-  ItemId,
-  ItemRow,
-  ItemState,
-  ItemView,
-  ItemWithLevers,
-  LeaseRow,
-  LeverRow,
-  LinkRow,
-  MaxAttemptsByKind,
-  PhaseName,
-  PoolName,
-  PoolSlotRow,
-  PullRequestRef,
-  PullRequestRow,
-  RepoName,
-  RunnerId,
-  RunnerRow,
-} from './core.ts';
-import type { FactType, NewFact, OutboxFact } from './facts.ts';
-import type { Snapshot } from './planning.ts';
-
-export interface ClaimStore {
-  exclusive: <T>(work: (tx: StoreTx) => Promise<T>) => Promise<T>;
-  read: <T>(work: (tx: StoreReader) => Promise<T>) => Promise<T>;
-}
-
-export interface StoreReader {
-  readSnapshot: (now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<Snapshot>;
-  readItem: (
-    id: ItemId,
-    now: Instant,
-    maxAttemptsByKind: MaxAttemptsByKind,
-  ) => Promise<ItemView | null>;
-  readItemDetail: (
-    id: ItemId,
-    now: Instant,
-    maxAttemptsByKind: MaxAttemptsByKind,
-  ) => Promise<ItemDetailRows | null>;
-  listItems: (
-    filter: ItemFilter,
-    now: Instant,
-    maxAttemptsByKind: MaxAttemptsByKind,
-  ) => Promise<ItemWithLevers[]>;
-  listOpenIssues: (
-    repo: RepoName,
-    now: Instant,
-    maxAttemptsByKind: MaxAttemptsByKind,
-  ) => Promise<ItemView[]>;
-
-  // 0 when the item phase has no lease
-  readLastLeaseGen: (item: ItemId, phase: PhaseName) => Promise<number>;
-  readAttempt: (id: AttemptId) => Promise<AttemptRow | null>;
-  listEvidence: (attempt: AttemptId) => Promise<EvidenceRow[]>;
-  listLiveAttempts: () => Promise<AttemptRow[]>;
-  listSucceededAttemptsWithoutPr: () => Promise<AttemptRow[]>;
-  findAttemptBySession: (session: AtcSessionId) => Promise<AttemptRow | null>;
-  findAttemptByAgentSession: (session: AgentSessionId) => Promise<AttemptId | null>;
-
-  // the rows in state `open`
-  listWatchedPullRequests: () => Promise<PullRequestRow[]>;
-
-  // retired rows included
-  listPoolSlots: () => Promise<PoolSlotRow[]>;
-
-  // oldest first
-  readUnsentFacts: (limit: number) => Promise<OutboxFact[]>;
-  readOutboxLag: () => Promise<{
-    readonly unsent: number;
-    readonly oldestUnsentAt: Instant | null;
-  }>;
-
-  // null before the runner's first heartbeat, which reads as not paused
-  readRunner: (id: RunnerId) => Promise<RunnerRow | null>;
-}
-
-export interface ItemDetailRows {
-  readonly item: ItemWithLevers;
-  readonly attempts: readonly AttemptRow[];
-  readonly links: readonly LinkRow[];
-  readonly evidence: readonly EvidenceRow[];
-  readonly pullRequests: readonly PullRequestRow[];
-}
-
-export interface StoreTx extends StoreReader {
-  applyChange: (change: StoreChange) => Promise<ApplyResult>;
-  markFactsSent: (ids: FactId[], at: Instant) => Promise<void>;
-  writeHeartbeat: (runner: RunnerId, at: Instant) => Promise<void>;
-  syncPoolSlots: (
-    pools: readonly { readonly name: PoolName; readonly slots: number }[],
-  ) => Promise<void>;
-  markPullRequestChecked: (ref: PullRequestRef, at: Instant) => Promise<void>;
-}
-
-export interface StoreChange {
-  at: Instant;
-  under?: {
-    item: ItemId;
-    phase: PhaseName;
-    gen: number;
-    slot?: { pool: PoolName; slot: number; gen: number };
-  };
-  writes: RowWrite[];
-  facts: AnyNewFact[];
-}
-
-export type ApplyResult =
-  | { kind: 'applied'; slot: { pool: PoolName; slot: number; gen: number } | null }
-  | { kind: 'stale-generation' }
-  | { kind: 'lease-held' }
-  | { kind: 'no-free-slot' }
-  | { kind: 'guard-mismatch'; table: TableName; key: JsonValue };
-
-export interface ItemFilter {
-  readonly state?: ItemState;
-  readonly repo?: RepoName;
-}
-
-export interface Tables {
-  items: ItemRow;
-  links: LinkRow;
-  levers: LeverRow;
-  attempts: AttemptRow;
-  attempt_sessions: AttemptSessionRow;
-  leases: LeaseRow;
-  pool_slots: PoolSlotRow;
-  decisions: DecisionRow;
-  evidence: EvidenceRow;
-  pull_requests: PullRequestRow;
-  runners: RunnerRow;
-}
-
-export type TableName = keyof Tables;
-
-export type RowWrite =
-  | {
-      [T in TableName]: { readonly op: 'insert'; readonly table: T; readonly row: Tables[T] };
-    }[TableName]
-  | {
-      [T in TableName]: {
-        readonly op: 'update';
-        readonly table: T;
-        readonly key: Partial<Tables[T]>;
-        readonly expect: Partial<Tables[T]>;
-        readonly set: Partial<Tables[T]>;
-      };
-    }[TableName]
-  | { readonly op: 'take-slot'; readonly pool: PoolName; readonly holder: AttemptId }
-  | {
-      readonly op: 'release-slot';
-      readonly pool: PoolName;
-      readonly slot: number;
-      readonly holder: AttemptId;
-    };
-
-export type AnyNewFact = { [T in FactType]: NewFact<T> }[FactType];
-
-export interface WorkerKind {
-  start: (request: SpawnRequest) => Promise<StartOutcome>;
-  reconcile: (attempt: AttemptRow) => Promise<SessionReading>;
-}
-
-export type StartOutcome =
-  | { kind: 'started'; atcSession: AtcSessionId; agentSession: AgentSessionId | null }
-  | { kind: 'refused'; reason: string }
-  | { kind: 'unknown'; reason: string };
-
-export type SessionReading =
-  | { kind: 'running'; atcSession: AtcSessionId; agentSession: AgentSessionId | null }
-  | { kind: 'ended'; atcSession: AtcSessionId; agentSession: AgentSessionId | null }
-  | { kind: 'absent' };
-
-export interface SpawnRequest {
-  // the repo's configured local path
-  readonly cwd: string;
-  readonly prompt: string;
-  readonly agent: string;
-  readonly model: string;
-  readonly effort: Effort;
-  readonly pluginDirs: readonly string[];
-  readonly name: `boxxy/${string}`;
-  readonly idempotencyKey: AttemptId;
-}
-
-export interface SessionFault {
-  readonly kind: 'fault';
-  readonly fault: 'agent-session-owned';
-  readonly agentSession: AgentSessionId;
-  readonly attempt: AttemptId;
-  readonly holder: AttemptId;
-}
-
-export interface FactSink {
-  append: (
-    facts: OutboxFact[],
-  ) => Promise<
-    'accepted' | { kind: 'unknown'; reason: string } | { kind: 'rejected'; error: string }
-  >;
-}
-
-export interface CostToLandRow {
-  readonly item: ItemId;
-  readonly title: string;
-  readonly repo: RepoName;
-  readonly landedAt: Instant;
-  readonly model: string;
-  readonly attempts: number;
-  readonly requests: number;
-  readonly inputTokens: number;
-  readonly outputTokens: number;
-  readonly cacheReadTokens: number;
-  readonly cacheCreationTokens: number;
-
-  // input, cache read and cache creation tokens together
-  readonly totalInputTokens: number;
-
-  // modelled at list price, not billed
-  readonly costUsd: number;
-}
-
-export interface CostToLandInput {
-  readonly repo?: string;
-
-  // ISO 8601, as the pepys query takes it
-  readonly landedFrom?: string;
-  readonly landedTo?: string;
-}
-
-export interface CostReader {
-  costToLand: (input: CostToLandInput) => Promise<CostToLandRow[]>;
-}
-
-export interface Forge {
-  readPullRequest: (ref: PullRequestRef) => Promise<PullRequestReading | 'not-found'>;
-  listOpenPullRequests: (repo: RepoName) => Promise<PullRequestRef[]>;
-}
-
-export interface PullRequestReading {
-  url: string;
-  state: 'open' | 'closed' | 'merged';
-  mergedAt: Instant | null;
-  mergeCommit: CommitSha | null;
-  commits: { sha: CommitSha; message: string }[];
-}
-
-export interface Clock {
-  now: () => Instant;
-}
-
-export type NewId = () => string;