@thinair/factory 0.0.0-stage → 0.1.124

package/domain/system-elements/rule.ts

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+import type { RuleOut, RuleSeen } from "./compose";
+import { AUTHORED, authoredHead, FactKindName, head, Ref, type Authored, type Encoder, type FactKind, type LiveRows, type Slot } from "./node";
+import type { AnyStage } from "./stage";
+
+/*
+ * A rule routes one kind of fact. Each fact of that kind that the factory
+ * has not routed yet goes through its route, which returns tickets to file
+ * or update (by key, in the stages it lists) and acts. A rule never sees a
+ * fact the factory wrote itself.
+ */
+
+export const Node = Schema.TaggedStruct("Rule", {
+  ...head,
+  on: Schema.Struct({ from: Schema.Union([Ref("Repository"), Ref("Source")]), kind: FactKindName }),
+  /** The only stages it may file tickets in. */
+  files: Schema.Array(Ref("Stage")),
+});
+export type Node = typeof Node.Type;
+
+export interface AuthoredRule<N extends string = string, A = any, S extends AnyStage = AnyStage> extends Authored<"Rule", N> {
+  readonly on: FactKind<A>;
+  readonly files: ReadonlyArray<S>;
+  readonly route: (fact: A, seen: RuleSeen) => ReadonlyArray<RuleOut<S>>;
+}
+
+/** `rule("pull-request", { on: web.facts.pullRequest, files: [change], route: (pr, seen) => [...] })`. */
+export const rule = <const N extends string, A, const S extends ReadonlyArray<AnyStage>>(name: N, settings: Readonly<{
+  on: FactKind<A>;
+  files: S;
+  route: (fact: A, seen: RuleSeen) => ReadonlyArray<RuleOut<S[number]>>;
+}>): AuthoredRule<N, A, S[number]> => ({
+  [AUTHORED]: authoredHead("Rule", name, true),
+  on: settings.on,
+  files: settings.files,
+  route: settings.route,
+});
+
+export const make = (authored: AuthoredRule, encoder: Encoder) => ({
+  on: {
+    from: authored.on.from[AUTHORED].tag === "Repository"
+      ? encoder.ref("Repository", authored.on.from as Slot<"Repository">)
+      : encoder.ref("Source", authored.on.from as Slot<"Source">),
+    kind: authored.on.kind,
+  },
+  files: authored.files.map((stage: AnyStage) => encoder.ref("Stage", stage)),
+});
+
+/** How many facts of its kind arrived. */
+export const live = (node: Node, rows: LiveRows) => ({
+  facts: rows.facts.filter((fact) => fact.from === node.on.from.id && fact.kind === node.on.kind).length,
+});
+
+export const owner = "vm" as const;
+

package/domain/system-elements/service.ts

@@ -0,0 +1,82 @@
+import { Schema } from "effect";
+import type { AuthoredAgent } from "./agent";
+import type { Carries, Question } from "./compose";
+import { Needs } from "./job";
+import { AUTHORED, authoredHead, head, Ref, type Authored, type Encoder, type LiveRows } from "./node";
+import type { AuthoredRepository } from "./repository";
+
+/*
+ * A service: something that stays up while a stage wants it, rather than
+ * running once. A repository copy is the ticket's own `.repository` process
+ * of a repository; an agent session is one of these agents working the
+ * ticket, on the harness's own path. A Run is one `together` group of them.
+ */
+
+export const Service = Schema.Union([
+  Schema.TaggedStruct("RepositoryCopy", { repository: Ref("Repository") }),
+  Schema.TaggedStruct("AgentSession", { agents: Schema.Array(Ref("Agent")) }),
+]);
+
+/** How a Disarm stops it: a copy rests (its disk is kept); a session cancels its turn, then rests. */
+export const ServiceStop = Schema.Literals(["rest", "cancel-turn"]);
+
+export const Node = Schema.TaggedStruct("Service", { ...head, service: Service, needs: Needs, stop: ServiceStop });
+export type Node = typeof Node.Type;
+
+/** A repository copy, as the next member of its Run receives it. */
+export type RepositoryCopy = Readonly<{ process: string; path: string }>;
+
+export interface RepositoryService<N extends string = string> extends Authored<"Service", N>, Carries<Readonly<{ base: string }>, RepositoryCopy> {
+  readonly service: "repository";
+  readonly repository: AuthoredRepository;
+  readonly needs: typeof Needs.Type;
+}
+
+export type AgentSessionInput = Readonly<{ agent: AuthoredAgent; brief: string; repository: RepositoryCopy }>;
+export type AgentSession = Readonly<{ session: string }>;
+
+export interface AgentService<N extends string = string> extends Authored<"Service", N>, Carries<AgentSessionInput, AgentSession> {
+  readonly service: "agent";
+  readonly agents: ReadonlyArray<AuthoredAgent>;
+  readonly needs: typeof Needs.Type;
+  /** Which of its agents works a ticket: the judge picks from them; the safe default is the first listed. */
+  readonly choose: Question<AuthoredAgent>;
+}
+
+export type AnyService = RepositoryService | AgentService;
+
+type Options<N extends string> = Readonly<{ name?: N; needs?: typeof Needs.Type }>;
+
+export const service = {
+  /** The ticket's own copy of a repository. Named `repository-<repository>` unless named. */
+  repository: <const N extends string = string>(repository: AuthoredRepository, options?: Options<N>): RepositoryService<N> => ({
+    [AUTHORED]: authoredHead("Service", (options?.name ?? `repository-${repository[AUTHORED].name}`) as N, false),
+    service: "repository",
+    repository,
+    needs: options?.needs ?? {},
+  }),
+  /** One of these agents working the ticket. Named `agent-<agents>` unless named. */
+  agent: <const N extends string = string>(agents: ReadonlyArray<AuthoredAgent>, options?: Options<N>): AgentService<N> => {
+    const made: Omit<AgentService<N>, "choose"> = {
+      [AUTHORED]: authoredHead("Service", (options?.name ?? `agent-${agents.map((agent) => agent[AUTHORED].name).join("-")}`) as N, false),
+      service: "agent",
+      agents,
+      needs: options?.needs ?? {},
+    };
+    const session = made as AgentService<N>;
+    return Object.assign(session, { choose: { _tag: "Question", name: "choose", service: session, legal: agents } as const });
+  },
+};
+
+export const make = (authored: AnyService, encoder: Encoder) =>
+  authored.service === "repository"
+    ? { service: { _tag: "RepositoryCopy" as const, repository: encoder.ref("Repository", authored.repository) }, needs: authored.needs, stop: "rest" as const }
+    : { service: { _tag: "AgentSession" as const, agents: authored.agents.map((agent) => encoder.ref("Agent", agent)) }, needs: authored.needs, stop: "cancel-turn" as const };
+
+/** Its sessions or copies by state. */
+export const live = (node: Node, rows: LiveRows) => {
+  const jobs = rows.jobs.filter((row) => row.node === node.id);
+  return { up: jobs.filter((row) => row.state === "running").length, starting: jobs.filter((row) => row.state === "waiting" || row.state === "bound").length };
+};
+
+export const owner = "vm" as const;

package/domain/system-elements/source.ts

@@ -0,0 +1,40 @@
+import { Schema } from "effect";
+import { AUTHORED, authoredHead, FactKindName, head, type Authored, type Encoder, type FactKind, type LiveRows } from "./node";
+
+/*
+ * A source of facts that are not about a repository: anything a person, an
+ * agent or another program posts to the factory with `factory.fact.post`.
+ * `source("linear", { issue: Schema.Struct({ ... }) })` declares its kinds;
+ * `linear.facts.issue` is typed, and rules listen on it.
+ */
+
+export const Node = Schema.TaggedStruct("Source", { ...head, kinds: Schema.Array(FactKindName) });
+export type Node = typeof Node.Type;
+
+type Facts = Readonly<Record<string, Schema.Codec<any, any, never, never>>>;
+
+export interface AuthoredSource<N extends string = string, F extends Facts = Facts> extends Authored<"Source", N> {
+  readonly facts: { readonly [K in keyof F & string]: FactKind<F[K]["Type"]> };
+}
+
+export const source = <const N extends string, const F extends Facts>(name: N, facts: F): AuthoredSource<N, F> => {
+  const made = { [AUTHORED]: authoredHead("Source", name, false) };
+  const from: Authored<"Source"> = made;
+  return Object.assign(made, {
+    facts: Object.fromEntries(Object.entries(facts).map(([kind, schema]) => [kind, { from, kind, schema }])) as AuthoredSource<N, F>["facts"],
+  });
+};
+
+export const make = (authored: AuthoredSource, encoder: Encoder) => {
+  const kinds = Object.keys(authored.facts).sort();
+  if (kinds.length === 0) encoder.problem("A source posts at least one kind of fact.");
+  return { kinds };
+};
+
+/** Its newest fact, and how many it has posted. */
+export const live = (node: Node, rows: LiveRows) => {
+  const facts = rows.facts.filter((fact) => fact.from === node.id);
+  return { last: facts.at(-1)?.at ?? null, facts: facts.length };
+};
+
+export const owner = "vm" as const;

package/domain/system-elements/stage.ts

@@ -0,0 +1,70 @@
+import { Schema } from "effect";
+import type { Out, Question, Seen, TicketView, Work } from "./compose";
+import { AUTHORED, authoredHead, head, Name, Ref, type Authored, type Encoder, type LiveRows, type Slot } from "./node";
+
+/*
+ * A stage: a kind of ticket and how it is worked. Its spec is the ticket's
+ * desired state. Its compose reads the ticket and what the factory has seen,
+ * and returns what should exist now: wanted jobs and services, child
+ * tickets, pins, judgments and acts. Compose may want only the jobs the
+ * stage lists, and types enforce it. A stage's ticket state comes from its
+ * verdict, or from its lifecycle when it has one.
+ */
+
+export const Node = Schema.TaggedStruct("Stage", {
+  ...head,
+  /** The only jobs and services compose may want. */
+  jobs: Schema.Array(Schema.Union([Ref("Job"), Ref("Service")])),
+  /** The stages whose tickets compose may file as its children. */
+  children: Schema.Array(Ref("Stage")),
+  /** Questions compose may ask the judge, each a choice one of its services offers. */
+  questions: Schema.Record(Name, Ref("Service")),
+});
+export type Node = typeof Node.Type;
+
+export interface AuthoredStage<N extends string = string, Spec = any, W extends Work = Work, C extends AnyStage = any> extends Authored<"Stage", N> {
+  readonly spec: Schema.Codec<Spec, any, never, never>;
+  readonly jobs: ReadonlyArray<W>;
+  readonly children: ReadonlyArray<C>;
+  readonly questions: Readonly<Record<string, Question<unknown>>>;
+  readonly compose: (ticket: TicketView<Spec>, seen: Seen<W>) => ReadonlyArray<Out<W, C>>;
+}
+export type AnyStage = AuthoredStage<string, any, any, any>;
+export type StageSpec<S> = S extends AuthoredStage<string, infer Spec, any, any> ? Spec : never;
+
+/** `stage("change", { spec, jobs, compose })`. */
+export const stage = <const N extends string, Spec, const W extends ReadonlyArray<Work> = readonly [], const C extends ReadonlyArray<AnyStage> = readonly []>(name: N, settings: Readonly<{
+  spec: Schema.Codec<Spec, any, never, never>;
+  jobs?: W;
+  children?: C;
+  questions?: Readonly<Record<string, Question<any>>>;
+  compose: (ticket: TicketView<Spec>, seen: Seen<W[number]>) => ReadonlyArray<Out<W[number], C[number]>>;
+}>): AuthoredStage<N, Spec, W[number], C[number]> => ({
+  [AUTHORED]: authoredHead("Stage", name, true),
+  spec: settings.spec,
+  jobs: settings.jobs ?? [],
+  children: settings.children ?? [],
+  questions: settings.questions ?? {},
+  compose: settings.compose,
+});
+
+export const make = (authored: AnyStage, encoder: Encoder) => ({
+  jobs: authored.jobs.map((work: Work) => work[AUTHORED].tag === "Job"
+    ? encoder.ref("Job", work as Slot<"Job">)
+    : encoder.ref("Service", work as Slot<"Service">)),
+  children: authored.children.map((child: AnyStage) => encoder.ref("Stage", child)),
+  questions: Object.fromEntries(Object.entries(authored.questions).map(([name, question]) => {
+    if (!authored.jobs.includes(question.service)) encoder.problem(`Question ${name} asks ${question.service[AUTHORED].name}, which this stage does not list in its jobs.`);
+    return [name, encoder.ref("Service", question.service)];
+  })),
+});
+
+/** Its tickets by state. */
+export const live = (node: Node, rows: LiveRows) => {
+  const byState: Record<string, number> = {};
+  for (const ticket of rows.tickets) if (ticket.stage === node.id) byState[ticket.state] = (byState[ticket.state] ?? 0) + 1;
+  return { tickets: byState };
+};
+
+export const owner = "vm" as const;
+

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@thinair/factory",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.124",
+  "description": "The Thinair factory SDK: the language a factory's code is written in, and the loader that checks it.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "thinair-factory": "cli/load.ts"
+  },
+  "exports": {
+    "./domain/system-elements/factory": "./domain/system-elements/factory.ts",
+    "./domain/system-elements/repository": "./domain/system-elements/repository.ts",
+    "./domain/system-elements/source": "./domain/system-elements/source.ts",
+    "./domain/system-elements/rule": "./domain/system-elements/rule.ts",
+    "./domain/system-elements/stage": "./domain/system-elements/stage.ts",
+    "./domain/system-elements/job": "./domain/system-elements/job.ts",
+    "./domain/system-elements/service": "./domain/system-elements/service.ts",
+    "./domain/system-elements/pool": "./domain/system-elements/pool.ts",
+    "./domain/system-elements/agent": "./domain/system-elements/agent.ts",
+    "./domain/system-elements/goal": "./domain/system-elements/goal.ts",
+    "./domain/system-elements/hole": "./domain/system-elements/hole.ts",
+    "./domain/system-elements/compose": "./domain/system-elements/compose.ts",
+    "./domain/step": "./domain/step.ts",
+    "./domain/system-elements/program": "./domain/system-elements/program.ts",
+    "./domain/load": "./domain/load.ts",
+    "./cli/load": "./cli/load.ts"
+  },
+  "dependencies": {
+    "effect": "4.0.0-rc.117",
+    "oxlint": "1.88.0"
+  },
+  "engines": {
+    "bun": ">=1.4.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ThinAirThings/thinair.monorepo.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}