@clemrig/factory 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Clément CHESNEAU
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,188 @@
-# Temporary Holding Version
+# @clemrig/factory
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Write agent workflows in TypeScript inside any repository, run them in the terminal and watch them in a local dashboard.
+
+A workflow is an explicit graph of **CODE** stages (your code), **AGENT** stages (an agent run by [Claude Code](https://code.claude.com) or [Pi](https://www.npmjs.com/package/@earendil-works/pi-coding-agent)) and **GATE** stages that accept a result or send it back for correction, a bounded number of times. Workflows live in the repository's `.factory/` folder, are committed with it and run without a build step.
+
+## Requirements
+
+- macOS or Linux, Node.js 24 or later, npm.
+- For agents run by Claude Code: the `claude` CLI 2.1.296 or later in the `PATH`, logged in with a claude.ai subscription (`claude`, then `/login`) or given an API key (`ANTHROPIC_API_KEY`).
+- For agents run by Pi: the `pi` CLI (`@earendil-works/pi-coding-agent` 1.1.0 or later) in the `PATH`, connected to the provider each Pi profile names (`pi`, then `/login`, or the provider's API key).
+
+The factory never reads or stores credentials: each runtime uses its own connection, from its login or from an API key in the environment or `.factory/.env`. Claude Code prefers an API key to its login; Pi prefers a login stored for the provider to an API key. `factory doctor` and `factory run` show which connection each runtime uses.
+
+## Get started
+
+```sh
+npm install -g @clemrig/factory
+cd my-repository
+factory init
+factory doctor
+factory run ask --question "What changed recently?"
+```
+
+`factory init` creates `.factory/` in the current directory and installs it; it refuses to overwrite an existing `.factory/`. Commit `.factory/`: another machine only needs `npm ci --prefix .factory`.
+
+```
+.factory/
+  package.json             pins the exact factory version
+  factory.ts               the repository's workflows
+  workflows/ask/
+    index.ts               the example workflow
+    prompts/answer.md      the prompt of its answer stage
+  tsconfig.json            editor settings only
+  .gitignore               node_modules/, runs/, .env
+  runs/                    one folder per run (ignored)
+  .env                     optional secrets (ignored)
+```
+
+The global `factory` command uses the nearest `.factory/` holding a `package.json`, in the current directory or a parent, and runs the factory version installed there: every machine runs the version pinned in the repository. Only `factory init` and `factory help` run with the global version. Without `.factory/` the command asks for `factory init`; without installed dependencies it gives the `npm ci --prefix .factory` command to run.
+
+The example workflow `ask` reads the last 10 commits with `git log` (a CODE stage), asks a read-only Claude Code agent (`claude-sonnet-5-5`, effort `low`, tools `Read`, `Grep`, `Glob`) to answer the question, and checks the answer with a gate that sends it back at most 3 times. Copy its folder to start a new workflow.
+
+## Write a workflow
+
+```ts
+// .factory/workflows/changelog/index.ts
+import {
+  agent,
+  defineWorkflow,
+  END,
+  node,
+  pick,
+  retry,
+  runProcess,
+  schemaGate,
+  step,
+  z,
+} from "@clemrig/factory";
+
+const notes = z.strictObject({ entries: z.array(z.string().min(1)).min(1) });
+
+export default defineWorkflow({
+  name: "changelog", // also the folder name: .factory/workflows/changelog/
+  input: z.object({
+    since: z.string().min(1),
+    limit: z.coerce.number().int().positive().optional(), // options are strings: coerce numbers
+  }),
+  initial: "log",
+  nodes: {
+    log: node(
+      step(async ({ dir, state }) => {
+        const log = await runProcess(
+          ["git", "log", "--oneline", `--since=${String(state.input.since)}`],
+          dir,
+          30_000,
+        );
+        if (log.exitCode !== 0) throw new Error(log.stderr);
+        return { commits: log.stdout.trim().split("\n") };
+      }),
+      { ok: "write" },
+    ),
+    // AGENT: prompt in prompts/write.md, after the stage.
+    write: node(
+      agent({
+        profile: {
+          runtime: "claude-code",
+          model: "claude-sonnet-5-5",
+          thinking: "low",
+          tools: ["Read", "Grep", "Glob"],
+          // access: "read" by default; "write" allows tools that change the repository
+        },
+        schema: notes,
+        context: pick("input", "commits"),
+      }),
+      { ok: "check" },
+    ),
+    check: node(
+      schemaGate({
+        schema: notes,
+        into: "notes",
+        check: ({ entries }) =>
+          entries.length > 20 ? "Keep at most 20 entries" : undefined,
+      }),
+      { ok: END, invalid: retry("write", 3) },
+    ),
+  },
+  // Optional: without it, the result shows the run's validated data as JSON.
+  presentResult: (state) =>
+    (state.data.notes as { entries: string[] }).entries.map((entry) => `- ${entry}`),
+});
+```
+
+```ts
+// .factory/factory.ts
+import ask from "./workflows/ask/index.ts";
+import changelog from "./workflows/changelog/index.ts";
+
+export default [ask, changelog];
+```
+
+Workflows are TypeScript run directly by Node: use erasable syntax only (no `enum`, no parameter properties) and relative imports with their `.ts` extension. Import only from `@clemrig/factory`, which also exports `z` (Zod), so that workflows, the factory and its engine share one Zod instance.
+
+**Graph.** Each stage declares its outcomes and the node routes every outcome to a stage, to `END` or to `retry(stage, max)`. A stage receives `{ state, agent, log, dir }`: the run (read-only), the agent runtime, the run journal and the repository directory. Stages and agents work in the repository (the folder that contains `.factory/`), which is also the process's working directory during a run, wherever the command was started.
+
+| Primitive | Use |
+|---|---|
+| `step(run)`, `code(outcomes, run)` | CODE stage: returns data (merged into `state.data`) or a named outcome |
+| `agent({ profile, schema, context, prompt?, session? })` | AGENT stage: one structured request run with its profile; its output waits in `state.output` for a gate |
+| `gate(outcomes, run)`, `schemaGate({ schema, into, check? })` | GATE stage: `schemaGate` validates the agent output, runs `check`, then writes it into `state.data[into]` or sends a correction |
+| `retry(stage, max)` | correction route, taken at most `max` times (1–100) per run, with the gate's reason as `feedback` for the next agent |
+| `pick(...keys)` | agent context from `input` and data keys |
+| `runProcess(argv, cwd, timeoutMs)` | runs a command without a shell; Ctrl-C stops it |
+
+`defineWorkflow` refuses, when the workflow is loaded: a `.` in a stage or outcome name (a correction counter is named `<stage>.<outcome>`), an unrouted outcome, an unknown target, a retry maximum outside 1–100, a loop whose edges include no `retry` (with the loop's path), an invalid profile, a write tool in a read-only profile, a prompt or session name that cannot name a file, a `maxCostUsd` that is not a positive number, and an input that is not a `z.object`. Loading `factory.ts` also refuses an input whose name cannot be an option (`json`, `help`, `max-cost-usd`, or other than letters, digits, `-` and `_` after a letter). Every run is therefore bounded.
+
+**Inputs.** Each field of `input` becomes a `--<name>` option of `factory run`; an option given without a value is `true` and only a boolean field accepts it: `z.boolean()`, possibly with `.optional()`, `.nullable()` or `.default(…)` (a transformed boolean or one with `.catch` takes no option alone). A missing, invalid or unknown option is refused with the list of problems, before any run is created. A workflow without `input` accepts no input option.
+
+**Budget.** `maxCostUsd` (optional) fails a run once the cost its agents' runtimes announced exceeds it; `factory run … --max-cost-usd 2` sets it for one run, instead of the workflow's. It is checked before and after each agent call, failed or not, on the runtime's figures: a running call is not stopped and can go past it; once it is exceeded, no further call starts and the run fails at its next stage boundary, even if workflow code catches the error. A call that announced no cost fails a run that has a budget, since the budget can no longer be checked. With a subscription, the cost is an estimate.
+
+**Profiles.** Each agent stage declares its complete profile; no machine setting changes it. A profile is a plain object: share one between stages with a constant, typed with `satisfies AgentProfile` (`AgentProfile` is exported by `@clemrig/factory`).
+
+| Field | Claude Code (`runtime: "claude-code"`) | Pi (`runtime: "pi"`) |
+|---|---|---|
+| `access` | `"read"` (default) or `"write"` | `"read"` (default) or `"write"` |
+| `provider` | — | the Pi provider, required (`openai`, `openai-codex`…) |
+| `model` | model name or alias | model name |
+| `thinking` | effort: `low` … `max` | `off` … `max` |
+| `tools` | exact names (`Read`, `Grep`, `Bash`…) and `mcp__<server>__<tool>` | exact names (`read`, `bash`…); other names need an extension |
+| other | `mcpServers: { name: { command, args? } }` | `skills`, `extensions` (paths) |
+| `timeoutMs` | default 15 minutes | default 15 minutes |
+
+A read-only profile may use only `Read`, `Grep`, `Glob`, `WebFetch`, `WebSearch` and declared MCP tools on Claude Code, and no `bash`, `powershell`, `edit` or `write` on Pi. Relative skill, extension and MCP command paths are relative to `.factory/`; a bare command is looked up in the `PATH`. Each Claude Code session holds only the profile's tools and MCP servers, without the operator's settings, plugins, skills or memory: a session with another tool, MCP server or plugin is refused, and another customization (skills, commands, output style, memory) is journaled as a warning. Pi runs without the machine's extensions, skills, context files and MCP servers. Runtimes are not sandboxes: listed tools act with your rights.
+
+**Prompts.** An agent's prompt is `.factory/workflows/<workflow>/prompts/<name>.md`, where the name is the stage's unless `agent({ prompt })` names another. It is appended to the runtime's system prompt; the request (context and output JSON Schema) follows on standard input. Prompts are read when a run starts: an edit applies to the next run, without building anything.
+
+**Sessions.** An agent stage keeps one conversation per run: a correction sent back to it resumes the conversation, with the gate's feedback. `session: "name"` shares a conversation between stages of the same runtime (sharing one across runtimes is refused); `session: (state) => name` opens one per value. A run's stage and session names form one namespace per runtime: a name returned by a function joins the conversation of that name on the same runtime. Session names start and end with a letter or digit.
+
+## Run and observe
+
+```sh
+factory run changelog --since 2026-10-01 [--json]
+factory status [RUN_ID] [--json]
+factory ui [--port 4321]
+factory doctor [--json]
+```
+
+Before creating a run, `factory run` validates the input, reads the prompts and checks from the repository, where the agents will work, for each runtime the workflow uses, that its executable is in the `PATH`, at least the supported version, and connected; a missing piece fails the command with the stage, runtime and reason. The terminal then shows each runtime's version and connection. A model the account cannot use fails the run at its first call, with the runtime's message.
+
+The run executes in the foreground. The terminal shows each stage's start and end, decisions and corrections with their counter (`[check.invalid 1/3]`), journal messages and, for an agent, the start and end of its call, each finished tool with its duration and isolation warnings; then the result, the duration, the agents' tokens and estimated cost, and the runtimes used. `--json` writes every event, then the result, as JSON lines on standard output. Exit codes: 0 completed, 1 error or failed run.
+
+**Ctrl-C** stops the run's child processes and ends the run as `failed` with its cause before its next stage, or instead of completing; a second Ctrl-C kills the remaining child processes and quits at once (exit code 130, the run may then stay `running`). A failed or interrupted run is not resumed: start a new one.
+
+`factory status` lists the repository's runs or shows one; while `factory.ts` cannot load, `status` and `ui` say so and still show the runs with the default rendering. `factory ui` serves a read-only dashboard of the repository's runs on `127.0.0.1` (port chosen by the system unless `--port` sets it, URL printed; Ctrl-C stops it): the runs with workflow, status, current stage, duration, estimated cost and last update, and for a run its runtimes, a timeline with one block per stage (status, duration, the agent's tools and tokens as they come, journal, decision), the correction counters and the result. It follows a running run as it goes. To watch a run on another machine, forward the same port through SSH: `ssh -L 4321:127.0.0.1:4321 machine`, run `factory ui --port 4321` there, and open `http://localhost:4321/`. `factory doctor` checks Node, loads the workflows, reads their prompts, lists each workflow's options and checks each runtime's executable, version and connection, without any provider request.
+
+## Data
+
+Each run keeps `state.json` and `events.jsonl` in `.factory/runs/<RUN_ID>/`, plus its Pi sessions and Claude Code session markers; Claude Code keeps its transcripts in its own storage (`~/.claude/projects/…`). Runs hold inputs, agent outputs and the journal: they stay private and are ignored by Git. `.factory/.env` is loaded automatically, without overriding variables already set in the shell; runtimes, MCP servers and commands inherit the environment. `factory run` executes the code of `.factory/`: trust it as you trust `npm run`. The dashboard shows the same data to any local process that can reach `127.0.0.1`.
+
+Tokens and costs are the figures each runtime announces, never recomputed: Claude Code announces at the end of a call its session's total, earlier calls included, and its tokens during a call are provisional; Pi announces each response with its cost. A run's total is the sum of its sessions; a call without figures makes it partial. The estimated cost is the runtime's public-price estimate, not a bill.
+
+## Limits
+
+Not in this version: resuming a run, detached runs, logs `--follow` and stop, local settings or profile overrides, actions or graph drawing in the dashboard, runs of several repositories, `factory new`, a shared stage library, a test harness for workflows, CI, cron or Git hook triggers, notifications, Windows.
+
+## License
+
+MIT

package/dist/app/doctor.d.ts

@@ -0,0 +1,18 @@
+import { type AgentProblem, type Runtime, type RuntimeStatus, type Workflow } from "@clemrig/flow";
+export type { RuntimeStatus } from "@clemrig/flow";
+/** What `factory doctor` found, without any provider request. */
+export interface Diagnosis {
+    ok: boolean;
+    node: RuntimeStatus;
+    factory: RuntimeStatus;
+    /** Each loaded workflow, with the reason its prompts cannot be read. */
+    workflows: {
+        workflow: Workflow;
+        error?: string;
+    }[];
+    runtimes: Partial<Record<Runtime, RuntimeStatus>>;
+    /** Missing runtimes, by `<workflow>.<stage>`. */
+    problems: AgentProblem[];
+}
+/** Node, the factory and its workflows' prompts, then each runtime in use. */
+export declare function diagnose(factoryDir: string): Promise<Diagnosis>;

package/dist/app/doctor.js

@@ -0,0 +1,40 @@
+import { inspectNode, inspectRuntimes, } from "@clemrig/flow";
+import { loadLocalEnvironment } from "../system/environment.js";
+import { emptyFactory, loadPrompts } from "../system/factory.js";
+import { loadWorkflows } from "./factory.js";
+const message = (error) => error instanceof Error ? error.message : String(error);
+/** Node, the factory and its workflows' prompts, then each runtime in use. */
+export async function diagnose(factoryDir) {
+    loadLocalEnvironment(factoryDir);
+    const node = inspectNode();
+    let factory;
+    let loaded;
+    try {
+        factory = await loadWorkflows(factoryDir);
+        loaded = { ok: true, detail: `Factory ${factoryDir}` };
+    }
+    catch (error) {
+        loaded = { ok: false, detail: `Factory: ${message(error)}` };
+    }
+    const workflows = [];
+    const agents = {};
+    for (const workflow of factory?.workflows.values() ?? []) {
+        try {
+            await loadPrompts(factoryDir, workflow);
+            workflows.push({ workflow });
+        }
+        catch (error) {
+            workflows.push({ workflow, error: message(error) });
+        }
+        for (const [stage, declared] of Object.entries(workflow.agents))
+            agents[`${workflow.name}.${stage}`] = declared;
+    }
+    // Where the agents will work: the repository.
+    const { runtimes, problems } = await inspectRuntimes(agents, factory?.dir ?? emptyFactory(factoryDir).dir);
+    const ok = node.ok &&
+        loaded.ok &&
+        workflows.every(({ error }) => error === undefined) &&
+        problems.length === 0;
+    return { ok, node, factory: loaded, workflows, runtimes, problems };
+}
+//# sourceMappingURL=doctor.js.map

package/dist/app/doctor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.js","sourceRoot":"","sources":["../../src/app/doctor.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,WAAW,EACX,eAAe,GAIhB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAgB,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAgB7C,MAAM,OAAO,GAAG,CAAC,KAAc,EAAE,EAAE,CACjC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAEzD,8EAA8E;AAC9E,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,UAAkB;IAC/C,oBAAoB,CAAC,UAAU,CAAC,CAAC;IACjC,MAAM,IAAI,GAAG,WAAW,EAAE,CAAC;IAC3B,IAAI,OAA4B,CAAC;IACjC,IAAI,MAAqB,CAAC;IAC1B,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,aAAa,CAAC,UAAU,CAAC,CAAC;QAC1C,MAAM,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,UAAU,EAAE,EAAE,CAAC;IACzD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;IAC/D,CAAC;IACD,MAAM,SAAS,GAA2B,EAAE,CAAC;IAC7C,MAAM,MAAM,GAA+B,EAAE,CAAC;IAC9C,KAAK,MAAM,QAAQ,IAAI,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC;QACzD,IAAI,CAAC;YACH,MAAM,WAAW,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YACxC,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC/B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACtD,CAAC;QACD,KAAK,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;YAC7D,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC;IACnD,CAAC;IACD,8CAA8C;IAC9C,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,MAAM,eAAe,CAClD,MAAM,EACN,OAAO,EAAE,GAAG,IAAI,YAAY,CAAC,UAAU,CAAC,CAAC,GAAG,CAC7C,CAAC;IACF,MAAM,EAAE,GACN,IAAI,CAAC,EAAE;QACP,MAAM,CAAC,EAAE;QACT,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC;QACnD,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC;IACxB,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AACtE,CAAC"}

package/dist/app/factory.d.ts

@@ -0,0 +1,14 @@
+import { type Factory } from "../system/factory.js";
+export type { Factory } from "../system/factory.js";
+/** The repository's workflows, each of whose inputs can be given as options of `factory run`. */
+export declare function loadWorkflows(factoryDir: string): Promise<Factory>;
+/** Loads `.factory/.env` without overriding the shell, then the repository's workflows. */
+export declare function openFactory(factoryDir: string): Promise<Factory>;
+/**
+ * The factory to read runs with: while `factory.ts` cannot load, its runs stay
+ * readable with the default rendering, and `error` says why.
+ */
+export declare function openFactoryForReading(factoryDir: string): Promise<{
+    factory: Factory;
+    error?: string;
+}>;

package/dist/app/factory.js

@@ -0,0 +1,33 @@
+import { loadLocalEnvironment } from "../system/environment.js";
+import { emptyFactory, loadFactory } from "../system/factory.js";
+import { optionProblems } from "./options.js";
+const message = (error) => error instanceof Error ? error.message : String(error);
+/** The repository's workflows, each of whose inputs can be given as options of `factory run`. */
+export async function loadWorkflows(factoryDir) {
+    const factory = await loadFactory(factoryDir);
+    for (const workflow of factory.workflows.values()) {
+        const problems = optionProblems(workflow);
+        if (problems.length)
+            throw new Error(`Invalid workflow ${workflow.name}: ${problems.join("; ")}`);
+    }
+    return factory;
+}
+/** Loads `.factory/.env` without overriding the shell, then the repository's workflows. */
+export async function openFactory(factoryDir) {
+    loadLocalEnvironment(factoryDir);
+    return loadWorkflows(factoryDir);
+}
+/**
+ * The factory to read runs with: while `factory.ts` cannot load, its runs stay
+ * readable with the default rendering, and `error` says why.
+ */
+export async function openFactoryForReading(factoryDir) {
+    loadLocalEnvironment(factoryDir);
+    try {
+        return { factory: await loadWorkflows(factoryDir) };
+    }
+    catch (error) {
+        return { factory: emptyFactory(factoryDir), error: message(error) };
+    }
+}
+//# sourceMappingURL=factory.js.map

package/dist/app/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../src/app/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAgB,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAI9C,MAAM,OAAO,GAAG,CAAC,KAAc,EAAE,EAAE,CACjC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAEzD,iGAAiG;AACjG,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,UAAkB;IACpD,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,UAAU,CAAC,CAAC;IAC9C,KAAK,MAAM,QAAQ,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC;QAClD,MAAM,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;QAC1C,IAAI,QAAQ,CAAC,MAAM;YACjB,MAAM,IAAI,KAAK,CACb,oBAAoB,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC5D,CAAC;IACN,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,2FAA2F;AAC3F,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,UAAkB;IAClD,oBAAoB,CAAC,UAAU,CAAC,CAAC;IACjC,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC;AACnC,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,UAAkB;IAElB,oBAAoB,CAAC,UAAU,CAAC,CAAC;IACjC,IAAI,CAAC;QACH,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC,UAAU,CAAC,EAAE,CAAC;IACtD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;IACtE,CAAC;AACH,CAAC"}

package/dist/app/init.d.ts

@@ -0,0 +1,6 @@
+export { createFromTemplates as createFactory } from "../system/templates.js";
+/** Installs `.factory/`'s dependencies; `output` explains a failure. */
+export declare function installFactory(factoryDir: string): Promise<{
+    ok: boolean;
+    output: string;
+}>;

package/dist/app/init.js

@@ -0,0 +1,15 @@
+import { runProcess } from "@clemrig/flow";
+export { createFromTemplates as createFactory } from "../system/templates.js";
+/** Installs `.factory/`'s dependencies; `output` explains a failure. */
+export async function installFactory(factoryDir) {
+    const install = await runProcess(["npm", "install", "--no-audit", "--no-fund"], factoryDir, 600_000).catch((error) => ({
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+    }));
+    return {
+        ok: install.exitCode === 0,
+        output: install.stderr || install.stdout,
+    };
+}
+//# sourceMappingURL=init.js.map

package/dist/app/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../src/app/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,mBAAmB,IAAI,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE9E,wEAAwE;AACxE,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,UAAkB;IAElB,MAAM,OAAO,GAAG,MAAM,UAAU,CAC9B,CAAC,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,CAAC,EAC7C,UAAU,EACV,OAAO,CACR,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE,CAAC,CAAC;QAC3B,QAAQ,EAAE,CAAC;QACX,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;KAC/D,CAAC,CAAC,CAAC;IACJ,OAAO;QACL,EAAE,EAAE,OAAO,CAAC,QAAQ,KAAK,CAAC;QAC1B,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM;KACzC,CAAC;AACJ,CAAC"}

package/dist/app/options.d.ts

@@ -0,0 +1,17 @@
+import { type Workflow, type z } from "@clemrig/flow";
+/** What an option may be called, after its `--`. */
+export declare const OPTION_NAME: RegExp;
+/** Why some inputs of the workflow cannot be given as `--<name>` options of `factory run`. */
+export declare function optionProblems(workflow: Pick<Workflow, "input">): string[];
+/** Whether a field takes an option given alone: a boolean, possibly optional or defaulted. */
+export declare function isFlag(schema: z.ZodType): boolean;
+/**
+ * The input that `factory run` options give the workflow. An option given
+ * without a value is `true`, accepted only by a boolean field: otherwise it is
+ * refused with every other problem, found by validating the input once.
+ */
+export declare function inputFromOptions(workflow: Pick<Workflow, "name" | "input">, options: Record<string, string | boolean>): Record<string, string | boolean>;
+/** A refused input of `factory run`, worded as options; any other error as it is. */
+export declare function asOptionsError(workflow: Pick<Workflow, "name">, options: Record<string, string | boolean>, error: unknown): unknown;
+/** `--max-cost-usd`: the run's budget instead of the workflow's. */
+export declare function parseBudget(value: string | boolean): number;

package/dist/app/options.js

@@ -0,0 +1,78 @@
+import { InvalidInputError, parseInput, } from "@clemrig/flow";
+/** Options of every `factory run`: no input may take their names. */
+const GLOBAL_OPTIONS = ["json", "help", "max-cost-usd"];
+/** What an option may be called, after its `--`. */
+export const OPTION_NAME = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+/** Why some inputs of the workflow cannot be given as `--<name>` options of `factory run`. */
+export function optionProblems(workflow) {
+    return Object.keys(workflow.input?.shape ?? {}).flatMap((name) => GLOBAL_OPTIONS.includes(name)
+        ? [`input ${name} conflicts with the global --${name} option`]
+        : OPTION_NAME.test(name)
+            ? []
+            : [`input ${name} is not a valid option name`]);
+}
+/** Whether a field takes an option given alone: a boolean, possibly optional or defaulted. */
+export function isFlag(schema) {
+    let def = schema.def;
+    while (def.innerType &&
+        ["optional", "nullable", "default"].includes(def.type))
+        def = def.innerType.def;
+    return def.type === "boolean";
+}
+/** Options given without a value to a field that is not a boolean: they have no value to give. */
+function valueless(workflow, options) {
+    const shape = workflow.input?.shape ?? {};
+    return Object.keys(options).filter((name) => {
+        const field = Object.hasOwn(shape, name) ? shape[name] : undefined;
+        return options[name] === true && field !== undefined && !isFlag(field);
+    });
+}
+/** Every problem of `factory run` options, worded as options. */
+function optionsError(workflow, options, missingValues, problems) {
+    const found = missingValues.map((name) => `--${name}: missing value`);
+    for (const { kind, field, message } of problems) {
+        const name = field.split(".")[0] ?? "";
+        if (kind === "unknown")
+            found.push(`unknown option --${field}`);
+        else if (!missingValues.includes(name))
+            found.push(Object.hasOwn(options, name)
+                ? `--${name}: ${message}`
+                : `missing option --${name}`);
+    }
+    return new Error(`Invalid input for ${workflow.name}: ${found.join("; ")}`);
+}
+/**
+ * The input that `factory run` options give the workflow. An option given
+ * without a value is `true`, accepted only by a boolean field: otherwise it is
+ * refused with every other problem, found by validating the input once.
+ */
+export function inputFromOptions(workflow, options) {
+    const missingValues = valueless(workflow, options);
+    const input = Object.fromEntries(Object.entries(options).filter(([name]) => !missingValues.includes(name)));
+    if (!missingValues.length)
+        return input;
+    let problems = [];
+    try {
+        parseInput(workflow, input);
+    }
+    catch (error) {
+        if (!(error instanceof InvalidInputError))
+            throw error;
+        problems = error.problems;
+    }
+    throw optionsError(workflow, options, missingValues, problems);
+}
+/** A refused input of `factory run`, worded as options; any other error as it is. */
+export function asOptionsError(workflow, options, error) {
+    return error instanceof InvalidInputError
+        ? optionsError(workflow, options, [], error.problems)
+        : error;
+}
+/** `--max-cost-usd`: the run's budget instead of the workflow's. */
+export function parseBudget(value) {
+    const budget = Number(value);
+    if (typeof value !== "string" || !Number.isFinite(budget) || budget <= 0)
+        throw new Error(`Invalid --max-cost-usd ${String(value)}: expected a positive number of USD`);
+    return budget;
+}
+//# sourceMappingURL=options.js.map

package/dist/app/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/app/options.ts"],"names":[],"mappings":"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"}

package/dist/app/run.d.ts

@@ -0,0 +1,8 @@
+import { type RunHooks, type StartedRun } from "@clemrig/flow";
+import { type Factory } from "../system/factory.js";
+/**
+ * Starts a workflow of the factory from `factory run` options, with its prompts
+ * from `.factory/`; the run works in the repository that contains `.factory/`
+ * and is kept in its `runs/`.
+ */
+export declare function startRun(factory: Factory, name: string, options: Record<string, string | boolean>, hooks: RunHooks): Promise<StartedRun>;

package/dist/app/run.js

@@ -0,0 +1,29 @@
+import { startRun as start, } from "@clemrig/flow";
+import { loadPrompts, workflowOf } from "../system/factory.js";
+import { asOptionsError, inputFromOptions, parseBudget } from "./options.js";
+/**
+ * Starts a workflow of the factory from `factory run` options, with its prompts
+ * from `.factory/`; the run works in the repository that contains `.factory/`
+ * and is kept in its `runs/`.
+ */
+export async function startRun(factory, name, options, hooks) {
+    const workflow = workflowOf(factory, name);
+    const { "max-cost-usd": budget, ...given } = options;
+    const maxCostUsd = budget === undefined ? undefined : parseBudget(budget);
+    const input = inputFromOptions(workflow, given);
+    try {
+        return await start({
+            workflow,
+            input,
+            maxCostUsd,
+            prompts: () => loadPrompts(factory.factoryDir, workflow),
+            dir: factory.dir,
+            configDir: factory.factoryDir,
+            runsDir: factory.runsDir,
+        }, hooks);
+    }
+    catch (error) {
+        throw asOptionsError(workflow, given, error);
+    }
+}
+//# sourceMappingURL=run.js.map

package/dist/app/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../../src/app/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,QAAQ,IAAI,KAAK,GAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAgB,WAAW,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE7E;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,OAAgB,EAChB,IAAY,EACZ,OAAyC,EACzC,KAAe;IAEf,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC3C,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;IACrD,MAAM,UAAU,GAAG,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1E,MAAM,KAAK,GAAG,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAChD,IAAI,CAAC;QACH,OAAO,MAAM,KAAK,CAChB;YACE,QAAQ;YACR,KAAK;YACL,UAAU;YACV,OAAO,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,EAAE,QAAQ,CAAC;YACxD,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,SAAS,EAAE,OAAO,CAAC,UAAU;YAC7B,OAAO,EAAE,OAAO,CAAC,OAAO;SACzB,EACD,KAAK,CACN,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,cAAc,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC"}

package/dist/app/runs.d.ts

@@ -0,0 +1,4 @@
+import type { RunState } from "@clemrig/flow";
+import type { Factory } from "../system/factory.js";
+/** A run's result lines: its workflow's rendering, or its validated data when the workflow left `factory.ts`. */
+export declare function presentResult(factory: Factory, state: Readonly<RunState>): string[];

package/dist/app/runs.js

@@ -0,0 +1,6 @@
+import * as flow from "@clemrig/flow";
+/** A run's result lines: its workflow's rendering, or its validated data when the workflow left `factory.ts`. */
+export function presentResult(factory, state) {
+    return flow.presentResult(factory.workflows.get(state.workflow), state);
+}
+//# sourceMappingURL=runs.js.map

package/dist/app/runs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runs.js","sourceRoot":"","sources":["../../src/app/runs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,eAAe,CAAC;AAItC,iHAAiH;AACjH,MAAM,UAAU,aAAa,CAC3B,OAAgB,EAChB,KAAyB;IAEzB,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC;AAC1E,CAAC"}

package/dist/cli/application.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The command run by the factory installed in `.factory/`: the global `factory`
+ * calls it with the arguments it received and the `.factory/` it found. This
+ * contract only changes with a major version.
+ */
+export declare function main(argv: string[], directory: string): Promise<number>;

package/dist/cli/application.js

@@ -0,0 +1,63 @@
+import { resolve } from "node:path";
+import { openFactory, openFactoryForReading } from "../app/factory.js";
+import { presentResult } from "../app/runs.js";
+import { noOptions, parseArgs } from "./args.js";
+import { doctor } from "./doctor.js";
+import { help } from "./help.js";
+import { TerminalReporter } from "./reporter.js";
+import { run } from "./run.js";
+import { status } from "./status.js";
+import { ui } from "./ui.js";
+/** `--port`: a fixed port, so that an SSH tunnel can forward the same one. */
+function parsePort(value) {
+    const port = Number(value);
+    if (value === true || !/^\d+$/.test(value) || port < 1 || port > 65535)
+        throw new Error(`Invalid --port ${value === true ? "" : value}: expected a port from 1 to 65535`);
+    return port;
+}
+/**
+ * The command run by the factory installed in `.factory/`: the global `factory`
+ * calls it with the arguments it received and the `.factory/` it found. This
+ * contract only changes with a major version.
+ */
+export async function main(argv, directory) {
+    // A run changes the working directory: every path must already be absolute.
+    const factoryDir = resolve(directory);
+    try {
+        const args = parseArgs(argv);
+        if (args.help || args.command === "help") {
+            process.stdout.write(help);
+            return 0;
+        }
+        if (args.command === "doctor") {
+            noOptions(args);
+            return await doctor(factoryDir, args.json);
+        }
+        if (args.command === "run") {
+            const factory = await openFactory(factoryDir);
+            const reporter = new TerminalReporter((state) => presentResult(factory, state), args.json);
+            return await run(factory, args, reporter);
+        }
+        if (!["status", "ui"].includes(args.command))
+            throw new Error(`Unknown command ${args.command}; see factory help`);
+        const { port, ...others } = args.options;
+        const dashboardPort = args.command === "ui" && port !== undefined ? parsePort(port) : undefined;
+        noOptions({
+            ...args,
+            options: args.command === "ui" ? others : args.options,
+        });
+        // Runs stay readable while factory.ts is being fixed.
+        const { factory, error } = await openFactoryForReading(factoryDir);
+        if (error)
+            process.stderr.write(`factory: factory.ts cannot be loaded, results use the default rendering: ${error}\n`);
+        if (args.command === "ui")
+            return await ui(factory, dashboardPort);
+        const reporter = new TerminalReporter((state) => presentResult(factory, state), args.json);
+        return await status(factory, reporter, args.positional[0]);
+    }
+    catch (error) {
+        process.stderr.write(`factory: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}
+//# sourceMappingURL=application.js.map

package/dist/cli/application.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.js","sourceRoot":"","sources":["../../src/cli/application.ts"],"names":[],"mappings":"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"}

package/dist/cli/args.d.ts

@@ -0,0 +1,12 @@
+export interface Arguments {
+    command: string;
+    positional: string[];
+    /** Command options; for `run`, the workflow's input. */
+    options: Record<string, string | true>;
+    json: boolean;
+    help: boolean;
+}
+/** `--name value`, or `--name` alone for true; --json and --help never take a value. */
+export declare function parseArgs(argv: string[]): Arguments;
+/** Commands other than `run` take no option of their own. */
+export declare function noOptions(args: Arguments): void;