@boxxy/model 0.1.1 → 0.1.3

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;

package/src/types/registries.ts

@@ -1,185 +0,0 @@
-import type { JsonValue } from '@boxxy/content-hash';
-import type { z } from 'zod';
-import type {
-  ConceptPin,
-  ItemKindName,
-  LeverKind,
-  LoadedRecipe,
-  MaxAttemptsByKind,
-  PhaseName,
-  PipelineName,
-  RecipeName,
-  RulesVersion,
-} from './core.ts';
-import type {
-  Admission,
-  FrameItem,
-  Gate,
-  Pool,
-  PropagationLine,
-  Signal,
-  SignalKey,
-  SignalName,
-  View,
-  Waiver,
-} from './planning.ts';
-
-export type Schema<T> = z.ZodType<T>;
-
-export interface ParamKinds<P> {
-  signal: Signal<P>;
-  gate: Gate<P>;
-  admission: Admission<P>;
-}
-
-export type ParamKindName = keyof ParamKinds<unknown>;
-
-export interface Registered<K extends ParamKindName> {
-  readonly kind: K;
-  readonly name: string;
-  open: <R>(use: <P>(plugin: ParamKinds<P>[K]) => R) => R;
-}
-
-export interface Resolved<K extends ParamKindName> {
-  readonly kind: K;
-  readonly name: string;
-
-  // `signalKey(name, params)` for a signal, and the name for a gate
-  readonly key: string;
-  open: <R>(use: <P>(plugin: ParamKinds<P>[K], params: P) => R) => R;
-}
-
-export type ConceptName = string;
-
-export interface Concept {
-  name: ConceptName;
-  version: number;
-  signals?: Registered<'signal'>[];
-  gates?: Registered<'gate'>[];
-  waivers?: Waiver[];
-  levers?: LeverKind[];
-  filterFields?: FilterField[];
-}
-
-export interface FilterField {
-  name: string;
-
-  // null never matches a filter on this field
-  value: (item: FrameItem) => string | readonly string[] | null;
-}
-
-export interface PlainKinds {
-  waiver: Waiver;
-  'filter-field': FilterField;
-  lever: { readonly kind: LeverKind };
-  view: View;
-}
-
-export type PluginKindName = ParamKindName | keyof PlainKinds;
-
-export type Registry = { readonly [K in ParamKindName]: ReadonlyMap<string, Registered<K>> } & {
-  readonly [K in keyof PlainKinds]: ReadonlyMap<string, PlainKinds[K]>;
-} & { readonly pins: readonly ConceptPin[] };
-
-export interface KindRules {
-  readonly pipeline: Pipeline;
-  readonly recipes: Readonly<Record<PhaseName, RecipeName>>;
-}
-
-export interface Pipeline {
-  readonly name: PipelineName;
-  readonly steps: readonly PipelineStep[];
-}
-
-export interface PipelineStep {
-  readonly phase: PhaseName;
-
-  // failed attempts before the item waits on "attempts used up"
-  readonly maxAttempts: number;
-}
-
-export type ConceptEntry = `${string}@${number}`;
-
-export type PluginRef = string | Readonly<Record<string, JsonValue>>;
-
-export type SignalRef = SignalName | Readonly<Record<string, JsonValue>>;
-
-export interface RulesFile {
-  readonly version: 1;
-  readonly concepts: readonly ConceptEntry[];
-  readonly kinds: Readonly<
-    Record<
-      string,
-      {
-        readonly pipeline: readonly string[] | PipelineName;
-        readonly maxAttempts: Readonly<Record<string, number>>;
-        readonly recipes: Readonly<Record<string, string>>;
-      }
-    >
-  >;
-  readonly pools: readonly {
-    readonly name: string;
-    readonly slots: number;
-    readonly takes: Readonly<Record<string, JsonValue>>;
-    readonly order: readonly SignalRef[];
-  }[];
-  readonly lead: readonly SignalRef[];
-  readonly propagation: readonly {
-    readonly value: string;
-    readonly over: string;
-    readonly toward: 'source' | 'target';
-  }[];
-  readonly recipes: Readonly<
-    Record<
-      string,
-      {
-        readonly agent: string;
-        readonly model: string;
-        readonly effort: string;
-        readonly prompt: string;
-        readonly source: string;
-      }
-    >
-  >;
-}
-
-export interface LoadedRules {
-  readonly version: RulesVersion;
-  readonly commit: string;
-  readonly registry: Registry;
-  readonly signals: ReadonlyMap<SignalKey, Resolved<'signal'>>;
-  readonly gates: readonly Resolved<'gate'>[];
-  readonly kinds: ReadonlyMap<ItemKindName, KindRules>;
-  readonly maxAttemptsByKind: MaxAttemptsByKind;
-
-  // in declared order, each pool's `order` starting with `lead`
-  readonly pools: readonly Pool[];
-  readonly propagation: readonly PropagationLine[];
-  readonly recipes: ReadonlyMap<RecipeName, LoadedRecipe>;
-}
-
-export interface LoadRejection {
-  readonly file: string;
-  readonly path: string;
-  readonly reason: LoadRejectionReason;
-}
-
-export type LoadRejectionReason =
-  | { readonly kind: 'invalid'; readonly message: string }
-  | { readonly kind: 'unknown-concept'; readonly ref: string }
-  | { readonly kind: 'unknown-signal'; readonly signal: string }
-  | {
-      readonly kind: 'bad-plugin-params';
-      readonly pluginKind: ParamKindName;
-      readonly name: string;
-      readonly message: string;
-    }
-  | { readonly kind: 'unknown-link-type'; readonly link: string }
-  | { readonly kind: 'signal-without-combine'; readonly signal: string }
-  | { readonly kind: 'missing-recipe'; readonly itemKind: string; readonly phase: string }
-  | { readonly kind: 'missing-prompt'; readonly path: string }
-  | { readonly kind: 'uncommitted-changes' };
-
-export type LoadResult =
-  | { readonly kind: 'loaded'; readonly rules: LoadedRules; readonly warnings: readonly string[] }
-  | { readonly kind: 'rejected'; readonly rejections: readonly LoadRejection[] };