@re-cinq/floor-pipeline 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 re:cinq B.V.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,110 @@
+# @re-cinq/floor-pipeline
+
+A pipeline as one file: an assembly line with its stations, its agent definitions and their prompts, its files and its schedules. One file is one pipeline, and holds everything the pipeline needs that a file can hold.
+
+The tool speaks the HTTP API of a [floor](https://github.com/re-cinq/floor) and nothing else. It is a client like any other, with the service token.
+
+```
+npm install @re-cinq/floor-pipeline      # the command is floor-pipeline
+
+export FLOOR_SERVICE_TOKEN=...
+
+floor-pipeline export code-review --floor http://localhost:8180 > code-review.yaml
+floor-pipeline export --all --dir backup/ --floor http://localhost:8180
+floor-pipeline import code-review.yaml --floor http://localhost:8180
+floor-pipeline migrate pipelines/ --floor http://localhost:8180
+floor-pipeline migrate pipelines/ --floor http://floor-api:8080 --wait-ready 180
+```
+
+| command | what it does |
+|---|---|
+| `export <line>` | writes the line's latest version, and what it names, as one file |
+| `export --all --dir <dir>` | one file a line, named after it: a backup |
+| `import <file>...` | puts each file to the floor. The same file twice changes nothing: a version is its content |
+| `migrate <dir>` | the folder's files in the order of their names, each once |
+| `--wait-ready <seconds>` | first polls the floor's `/readyz` until it answers 200, and fails, naming the floor and the seconds, if it does not in time. For a job that starts with the floor, such as the chart's seed Job |
+
+## Where this fits
+
+A client and nothing more: it speaks the floor's HTTP API with a service token, exactly as lore or
+a worker does, and links none of floor's own packages. Where
+[`@floor/lore-converter`](https://github.com/re-cinq/floor/blob/main/packages/lore-converter/README.md) brings an assembly line *in* from lore, this
+moves a whole pipeline between a file and a floor — to review it, to keep it in git, or to put the
+same one into another floor. It moves definitions only; assembly runs stay where they happened.
+
+See [the map](https://github.com/re-cinq/floor/blob/main/README.md).
+
+## The file
+
+YAML, in `snake_case`, as the docs write definitions. Every prompt is in it, as the block it is.
+
+```yaml
+line:
+  id: code-review
+  entry: review
+  exit: done
+  args:
+    pr_url: { kind: value, subject: true }
+  files:
+    checklist: |
+      - read the spec
+      - read the diff
+  nodes:
+    - { id: review, station: code-review }
+    - { id: done }
+  edges:
+    - { from: review, to: done, on: success }
+    - { from: review, to: review, on: failed, iteration_max: 1 }
+stations:
+  code-review:
+    kind: agent
+    agent_definition: reviewer
+    outcomes: [success, failed]
+    needs: [{ name: pr_url, kind: value }]
+    produces: []
+agent_definitions:
+  reviewer:
+    settings:
+      model: gemini-3.1-pro-preview
+      image: node:22-bookworm
+      timeout_minutes: 25
+      prices:
+        gemini-3.1-pro-preview: { input_per_million: 2, output_per_million: 12 }
+      prompt: |
+        Review {pr_url}.
+schedules:
+  nightly: { cron: "0 3 * * *", payload: { pr_url: https://pr/1 } }
+```
+
+- **The floor's own fields change spelling**, `timeout_minutes` to `timeoutMinutes`. Names a person chose do not: a model's name, a repository's, a key of `config` or of `env`.
+- **A file a line ships is in the file by its content.** Text as it is; anything else as `{ base64: ... }`. The floor keeps it by its hash, and a hash is no backup.
+- **A station two lines use is in both files.** Put twice with the same content, it is one version.
+- **What is exported is what runs now**: each definition's latest version. Older versions stay on the floor and are not in the file.
+
+## What a file cannot hold
+
+| | where it is |
+|---|---|
+| Secrets: a model's key, an MCP server's token | in the cluster's `agent-secrets`. A definition names the key, and never the value |
+| The program behind a service station | wherever it runs. The file declares the station; the program that posts a review is lore's |
+| Runs, visits, their records and costs | in the floor's database. This is a backup of what a floor is told to do, and not of what it did |
+
+## Migrations
+
+`migrate` is for seeding a floor at deploy, and for changing it after. It runs a folder's files in the order of their names, each once.
+
+```
+pipelines/
+  0001-code-review.yaml
+  0002-code-review-reply.yaml
+  0003-code-review.yaml          a changed prompt
+  0004-remove-gap-fill.yaml      archive: { lines: [gap-fill] }
+```
+
+- **The floor remembers which files ran**, by name and by the sha256 of what they held: `GET /migrations`.
+- **A file that ran is not run again.** So what a person changes over HTTP stays, until a later file changes that pipeline.
+- **A file that ran and was changed since is refused.** What it did is done. A change is a new file.
+- **A file the floor refused is not remembered**, and runs when it is mended.
+- **A pipeline leaves as it came, by a file**: `archive` names the lines, stations, agent definitions and schedules to archive. The floor refuses to archive a line with open runs.
+
+A file is several requests, and not one: a file the floor refuses half way has put what came before. Putting is safe to repeat, so the mended file puts the rest.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// floor-pipeline: a pipeline as one file, out of a floor and into one.
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { exportPipeline, lineIds } from "./export.js";
+import { readPipelineFile, writePipelineFile } from "./file.js";
+import { importPipeline } from "./import.js";
+import { migrate } from "./migrate.js";
+import { waitUntilReady } from "./ready.js";
+import { fileOf, pipelineOf } from "./shape.js";
+const USAGE = `floor-pipeline <what to do> --floor <url>      with FLOOR_SERVICE_TOKEN
+
+  export <line>              one pipeline, written to standard output, or to --out <file>
+  export --all --dir <dir>   every pipeline, one file each, named after its line: a backup
+  import <file>...           puts each file to the floor. The same file twice changes nothing
+  migrate <dir>              the folder's files in the order of their names, each once.
+                             The floor remembers which ran
+
+  --wait-ready <seconds>     first waits up to that long for the floor's /readyz to answer 200,
+                             for a job that starts with the floor`;
+const OPTIONS = { floor: { type: "string" }, out: { type: "string" }, dir: { type: "string" }, all: { type: "boolean" }, "wait-ready": { type: "string" } };
+function given() {
+    return parseArgs({ options: OPTIONS, allowPositionals: true });
+}
+async function main() {
+    const told = given();
+    const [command = ""] = told.positionals;
+    const commands = { export: exported, import: imported, migrate: migrated };
+    const run = commands[command];
+    if (!run)
+        throw new Error(USAGE);
+    const floor = floorOf(told);
+    await waitedFor(floor, told.values["wait-ready"]);
+    await run(floor, told);
+}
+async function waitedFor(floor, waitReady) {
+    if (waitReady === undefined)
+        return;
+    const seconds = Number(waitReady);
+    if (!(seconds > 0))
+        throw new Error(`--wait-ready is a number of seconds above 0, and not "${waitReady}"`);
+    await waitUntilReady({ floorUrl: floor.url, seconds });
+}
+function floorOf(told) {
+    const token = process.env.FLOOR_SERVICE_TOKEN;
+    const url = told.values.floor;
+    if (!url || !token)
+        throw new Error(`a floor is named with --floor, and reached with FLOOR_SERVICE_TOKEN\n\n${USAGE}`);
+    return { url: url.replace(/\/$/, ""), token };
+}
+async function exported(floor, told) {
+    const [, line] = told.positionals;
+    if (told.values.all)
+        return backedUp(floor, told.values.dir);
+    if (!line)
+        throw new Error(USAGE);
+    const written = writePipelineFile(fileOf(await exportPipeline(floor, line)));
+    if (!told.values.out)
+        return void process.stdout.write(written);
+    await writeFile(told.values.out, written);
+}
+async function backedUp(floor, dir) {
+    if (!dir)
+        throw new Error("export --all writes a file a pipeline, into --dir <dir>");
+    await mkdir(dir, { recursive: true });
+    const lines = await lineIds(floor);
+    await Promise.all(lines.map(async (line) => writeFile(join(dir, `${line}.yaml`), writePipelineFile(fileOf(await exportPipeline(floor, line))))));
+    console.error(`${lines.length} pipeline(s) written to ${dir}`);
+}
+async function imported(floor, told) {
+    const [, ...files] = told.positionals;
+    if (files.length === 0)
+        throw new Error(USAGE);
+    for (const file of files)
+        said(file, await importPipeline(floor, pipelineOf(readPipelineFile(await readFile(file, "utf8")))));
+}
+async function migrated(floor, told) {
+    const [, dir] = told.positionals;
+    if (!dir)
+        throw new Error(USAGE);
+    const names = (await readdir(dir)).filter((name) => /\.ya?ml$/.test(name));
+    const files = await Promise.all(names.map(async (name) => ({ name, text: await readFile(join(dir, name), "utf8") })));
+    const all = await migrate(floor, files);
+    all.forEach((each) => (each.ran ? said(each.name, each.put) : console.log(`${each.name}: ran before`)));
+}
+function said(file, put) {
+    console.log(`${file}:`);
+    put.forEach((each) => console.log(`  ${each.kind}/${each.id}: ${each.changed ? "changed" : "as it was"}`));
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map

package/dist/export.d.ts

@@ -0,0 +1,4 @@
+import { type Floor } from "./floor.js";
+import type { Pipeline } from "./shape.js";
+export declare function lineIds(floor: Floor): Promise<string[]>;
+export declare function exportPipeline(floor: Floor, lineId: string): Promise<Pipeline>;

package/dist/export.js

@@ -0,0 +1,51 @@
+// A pipeline, read from a floor: a line's latest version with everything it needs to run on another floor, or on this one after it is lost. A file is read whole, its content and not its hash: a hash is no backup.
+import { asked, blobRead } from "./floor.js";
+const SCHEDULE_TICK = /^schedule\.(.+)\.tick$/;
+export async function lineIds(floor) {
+    const listed = await asked(floor, { method: "GET", path: "/assembly-lines" });
+    return (listed?.items ?? []).map((row) => row.id);
+}
+export async function exportPipeline(floor, lineId) {
+    const line = await named(floor, "assembly-lines", lineId);
+    const { files = {}, ...body } = line.body;
+    const stations = await allNamed(floor, "stations", stationsOf(body));
+    const agentDefinitions = await allNamed(floor, "agent-definitions", namesIn(stations.map((station) => station.body.agentDefinition)));
+    return {
+        line: { id: line.id, body },
+        files: await filesRead(floor, files),
+        stations,
+        agentDefinitions,
+        schedules: await allNamed(floor, "schedules", schedulesOf(body)),
+        archive: { lines: [], stations: [], agentDefinitions: [], schedules: [] },
+    };
+}
+// A node may pin a station's version, `name@hash`; the file carries the station by its name.
+function stationsOf(line) {
+    const nodes = (line.nodes ?? []);
+    const named = nodes.map((node) => node.station ?? "");
+    return namesIn(named.map((station) => station.split("@")[0]));
+}
+// A line a schedule starts names the schedule's tick as what starts it.
+function schedulesOf(line) {
+    const start = (line.start ?? {});
+    const ticks = (start.on ?? []).map((event) => SCHEDULE_TICK.exec(event)?.[1]);
+    return namesIn(ticks);
+}
+function namesIn(held) {
+    const names = held.filter((name) => typeof name === "string" && name.length > 0);
+    return [...new Set(names)];
+}
+function allNamed(floor, kind, ids) {
+    return Promise.all(ids.map((id) => named(floor, kind, id)));
+}
+async function named(floor, kind, id) {
+    const row = await asked(floor, { method: "GET", path: `/${kind}/${id}` });
+    if (!row)
+        throw new Error(`the floor has no ${kind} "${id}"`);
+    return { id: row.id, body: row.body };
+}
+async function filesRead(floor, files) {
+    const read = await Promise.all(Object.entries(files).map(async ([name, hash]) => [name, await blobRead(floor, hash)]));
+    return Object.fromEntries(read);
+}
+//# sourceMappingURL=export.js.map

package/dist/file.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+/** Text as it is; anything else as base64. */
+declare const content: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    base64: z.ZodString;
+}, z.core.$strict>]>;
+declare const pipelineFile: z.ZodObject<{
+    line: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            base64: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$loose>>;
+    stations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    agent_definitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    schedules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    archive: z.ZodOptional<z.ZodObject<{
+        lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        stations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        agent_definitions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        schedules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PipelineFile = z.infer<typeof pipelineFile>;
+export type FileContent = z.infer<typeof content>;
+export declare function readPipelineFile(text: string): PipelineFile;
+/** A prompt is written as the block it is, and no line is folded: a prompt's line breaks are the prompt's. */
+export declare function writePipelineFile(file: PipelineFile): string;
+export {};

package/dist/file.js

@@ -0,0 +1,29 @@
+// A pipeline as one file, as a person writes it: YAML, in snake_case, with every prompt and every file's content in it. Only the file's own outline is checked here; what a line, a station or an agent definition may hold is the floor's to say, and it says so when the file is imported.
+import { parse, stringify } from "yaml";
+import { z } from "zod";
+const fields = z.record(z.string(), z.unknown());
+const named = z.record(z.string(), fields);
+const names = z.array(z.string());
+/** Text as it is; anything else as base64. */
+const content = z.union([z.string(), z.strictObject({ base64: z.string() })]);
+const pipelineFile = z.strictObject({
+    line: z.looseObject({ id: z.string().min(1), files: z.record(z.string(), content).optional() }).optional(),
+    stations: named.optional(),
+    agent_definitions: named.optional(),
+    schedules: named.optional(),
+    /** What this file takes away: a pipeline that is no longer wanted leaves by a file, as it came. */
+    archive: z.strictObject({ lines: names.optional(), stations: names.optional(), agent_definitions: names.optional(), schedules: names.optional() }).optional(),
+});
+export function readPipelineFile(text) {
+    const read = pipelineFile.safeParse(parse(text));
+    if (read.success)
+        return read.data;
+    const { issues } = read.error;
+    const problems = issues.map((issue) => `${issue.path.join(".") || "the file"}: ${issue.message}`);
+    throw new Error(`not a pipeline file: ${problems.join("; ")}`);
+}
+/** A prompt is written as the block it is, and no line is folded: a prompt's line breaks are the prompt's. */
+export function writePipelineFile(file) {
+    return stringify(file, { lineWidth: 0, blockQuote: "literal" });
+}
+//# sourceMappingURL=file.js.map

package/dist/floor.d.ts

@@ -0,0 +1,13 @@
+export interface Floor {
+    url: string;
+    token: string;
+}
+export interface Asking {
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    path: string;
+    body?: unknown;
+}
+/** Null for what the floor does not have. Anything else it refuses is thrown, in the floor's own words. */
+export declare function asked<Answer>(floor: Floor, asking: Asking): Promise<Answer | null>;
+export declare function blobStored(floor: Floor, bytes: Buffer): Promise<string>;
+export declare function blobRead(floor: Floor, hash: string): Promise<Buffer>;

package/dist/floor.js

@@ -0,0 +1,34 @@
+// The floor, as this tool reaches it: over HTTP, as a service, through the routes anything else would use.
+const REQUEST_TIMEOUT_MS = 30_000;
+const HTTP_NOT_FOUND = 404;
+/** Null for what the floor does not have. Anything else it refuses is thrown, in the floor's own words. */
+export async function asked(floor, asking) {
+    const response = await sent(floor, asking, asking.body === undefined ? undefined : { type: "application/json", bytes: JSON.stringify(asking.body) });
+    if (response.status === HTTP_NOT_FOUND)
+        return null;
+    const answer = await response.text();
+    return answer ? JSON.parse(answer) : null;
+}
+export async function blobStored(floor, bytes) {
+    const response = await sent(floor, { method: "POST", path: "/blobs" }, { type: "application/octet-stream", bytes: new Uint8Array(bytes) });
+    const stored = (await response.json());
+    return stored.hash;
+}
+export async function blobRead(floor, hash) {
+    const response = await sent(floor, { method: "GET", path: `/blobs/${hash}` });
+    if (response.status === HTTP_NOT_FOUND)
+        throw new Error(`the floor has no blob "${hash}", which a line names as its file`);
+    return Buffer.from(await response.arrayBuffer());
+}
+async function sent(floor, asking, body) {
+    const response = await fetch(`${floor.url}${asking.path}`, {
+        method: asking.method,
+        headers: { authorization: `Bearer ${floor.token}`, ...(body && { "content-type": body.type }) },
+        body: body?.bytes,
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+    if (response.ok || response.status === HTTP_NOT_FOUND)
+        return response;
+    throw new Error(`the floor refused ${asking.method} ${asking.path} with ${response.status}: ${await response.text()}`);
+}
+//# sourceMappingURL=floor.js.map

package/dist/import.d.ts

@@ -0,0 +1,10 @@
+import { type Floor } from "./floor.js";
+import type { Pipeline } from "./shape.js";
+export interface Put {
+    /** The floor's route: `stations`, say. */
+    kind: string;
+    id: string;
+    /** False for a version the floor already had. */
+    changed: boolean;
+}
+export declare function importPipeline(floor: Floor, pipeline: Pipeline): Promise<Put[]>;

package/dist/import.js

@@ -0,0 +1,40 @@
+// A pipeline, put to a floor: what a line names first, then the line, since the floor refuses a line naming a station it does not have. Putting the same thing twice changes nothing; a version is its content.
+import { asked, blobStored } from "./floor.js";
+export async function importPipeline(floor, pipeline) {
+    const files = await filesStored(floor, pipeline.files);
+    const agentDefinitions = await allPut(floor, "agent-definitions", pipeline.agentDefinitions);
+    const stations = await allPut(floor, "stations", pipeline.stations);
+    const lines = await allPut(floor, "assembly-lines", linesOf(pipeline, files));
+    const schedules = await allPut(floor, "schedules", pipeline.schedules);
+    return [...agentDefinitions, ...stations, ...lines, ...schedules, ...(await archived(floor, pipeline))];
+}
+function linesOf(pipeline, files) {
+    const line = pipeline.line;
+    if (!line)
+        return [];
+    const named = Object.keys(files).length > 0 ? { files } : {};
+    return [{ id: line.id, body: { ...line.body, ...named } }];
+}
+async function filesStored(floor, files) {
+    const stored = await Promise.all(Object.entries(files).map(async ([name, bytes]) => [name, await blobStored(floor, bytes)]));
+    return Object.fromEntries(stored);
+}
+function allPut(floor, kind, named) {
+    return Promise.all(named.map((each) => put(floor, kind, each)));
+}
+async function put(floor, kind, named) {
+    const answer = await asked(floor, { method: "POST", path: `/${kind}`, body: { id: named.id, ...named.body } });
+    return { kind, id: named.id, changed: answer?.created ?? true };
+}
+// A line goes before what it named: the floor keeps a station a line still names.
+async function archived(floor, pipeline) {
+    const { lines, stations, agentDefinitions, schedules } = pipeline.archive;
+    const gone = [...kindOf("assembly-lines", lines), ...kindOf("schedules", schedules), ...kindOf("stations", stations), ...kindOf("agent-definitions", agentDefinitions)];
+    for (const each of gone)
+        await asked(floor, { method: "DELETE", path: `/${each.kind}/${each.id}` });
+    return gone;
+}
+function kindOf(kind, ids) {
+    return ids.map((id) => ({ kind, id, changed: true }));
+}
+//# sourceMappingURL=import.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { readPipelineFile, writePipelineFile, type PipelineFile } from "./file.js";
+export { fileOf, pipelineOf, type Pipeline } from "./shape.js";
+export { exportPipeline, lineIds } from "./export.js";
+export { importPipeline, type Put } from "./import.js";
+export { migrate, type Migrated, type MigrationFile } from "./migrate.js";
+export type { Floor } from "./floor.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { readPipelineFile, writePipelineFile } from "./file.js";
+export { fileOf, pipelineOf } from "./shape.js";
+export { exportPipeline, lineIds } from "./export.js";
+export { importPipeline } from "./import.js";
+export { migrate } from "./migrate.js";
+//# sourceMappingURL=index.js.map

package/dist/migrate.d.ts

@@ -0,0 +1,13 @@
+import { type Floor } from "./floor.js";
+import { type Put } from "./import.js";
+export interface MigrationFile {
+    name: string;
+    text: string;
+}
+export interface Migrated {
+    name: string;
+    /** Empty for a file that had run before. */
+    put: Put[];
+    ran: boolean;
+}
+export declare function migrate(floor: Floor, files: MigrationFile[]): Promise<Migrated[]>;

package/dist/migrate.js

@@ -0,0 +1,28 @@
+// A folder of pipeline files, applied in the order of their names, each once. The floor remembers which ran, and by what content: a file that ran is never run again, and one that ran and was since changed is refused, since what it did is done. A change is a new file.
+import { createHash } from "node:crypto";
+import { readPipelineFile } from "./file.js";
+import { asked } from "./floor.js";
+import { importPipeline } from "./import.js";
+import { pipelineOf } from "./shape.js";
+export async function migrate(floor, files) {
+    const ordered = files.toSorted((one, other) => one.name.localeCompare(other.name));
+    const migrated = [];
+    for (const file of ordered)
+        migrated.push(await applied(floor, file));
+    return migrated;
+}
+async function applied(floor, file) {
+    const sha256 = createHash("sha256").update(file.text).digest("hex");
+    const remembered = await asked(floor, { method: "GET", path: `/migrations/${encodeURIComponent(file.name)}` });
+    if (remembered)
+        return alreadyRan(file, { sha256, ranAs: remembered.body.sha256 });
+    const put = await importPipeline(floor, pipelineOf(readPipelineFile(file.text)));
+    await asked(floor, { method: "PUT", path: `/migrations/${encodeURIComponent(file.name)}`, body: { sha256 } });
+    return { name: file.name, put, ran: true };
+}
+function alreadyRan(file, content) {
+    if (content.sha256 !== content.ranAs)
+        throw new Error(`"${file.name}" has run, and has been changed since: what it did is done. Put the change in a new file`);
+    return { name: file.name, put: [], ran: false };
+}
+//# sourceMappingURL=migrate.js.map

package/dist/ready.d.ts

@@ -0,0 +1,6 @@
+export interface Waiting {
+    floorUrl: string;
+    seconds: number;
+    pollMs?: number;
+}
+export declare function waitUntilReady(waiting: Waiting): Promise<void>;

package/dist/ready.js

@@ -0,0 +1,24 @@
+// The floor answers /readyz once it can serve. A deploy hook runs when the floor's pods are created, not when they are ready.
+import { setTimeout as sleep } from "node:timers/promises";
+const MS_PER_SECOND = 1000;
+const DEFAULT_POLL_MS = 2000;
+const PROBE_TIMEOUT_MS = 5000;
+export async function waitUntilReady(waiting) {
+    const { floorUrl, seconds, pollMs = DEFAULT_POLL_MS } = waiting;
+    const deadline = performance.now() + seconds * MS_PER_SECOND;
+    while (!(await answersReady(floorUrl))) {
+        if (performance.now() + pollMs > deadline)
+            throw new Error(`the floor at ${floorUrl} did not answer ready in ${seconds} seconds`);
+        await sleep(pollMs);
+    }
+}
+async function answersReady(floorUrl) {
+    try {
+        const response = await fetch(`${floorUrl}/readyz`, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=ready.js.map

package/dist/shape.d.ts

@@ -0,0 +1,24 @@
+import type { PipelineFile } from "./file.js";
+export type Fields = Record<string, unknown>;
+export interface Named {
+    id: string;
+    body: Fields;
+}
+export interface Archive {
+    lines: string[];
+    stations: string[];
+    agentDefinitions: string[];
+    schedules: string[];
+}
+export interface Pipeline {
+    /** Without its files, which the floor keeps by their hash and the file by their content. */
+    line?: Named;
+    files: Record<string, Buffer>;
+    stations: Named[];
+    agentDefinitions: Named[];
+    schedules: Named[];
+    archive: Archive;
+}
+export declare function pipelineOf(file: PipelineFile): Pipeline;
+/** What is empty is left out: a file says what a pipeline has. */
+export declare function fileOf(pipeline: Pipeline): PipelineFile;

package/dist/shape.js

@@ -0,0 +1,104 @@
+const AS_THE_FLOOR_SPELLS = {
+    edge: { iteration_max: "iterationMax" },
+    station: { agent_definition: "agentDefinition", conversation_key: "conversationKey", must_change: "mustChange" },
+    settings: { timeout_minutes: "timeoutMinutes" },
+    price: { input_per_million: "inputPerMillion", output_per_million: "outputPerMillion", cache_read_per_million: "cacheReadPerMillion", cache_write_per_million: "cacheWritePerMillion" },
+};
+const AS_THE_FILE_SPELLS = {
+    edge: turned(AS_THE_FLOOR_SPELLS.edge),
+    station: turned(AS_THE_FLOOR_SPELLS.station),
+    settings: turned(AS_THE_FLOOR_SPELLS.settings),
+    price: turned(AS_THE_FLOOR_SPELLS.price),
+};
+export function pipelineOf(file) {
+    return {
+        ...lineOf(file.line),
+        stations: namedIn(file.stations, (body) => respelled(body, AS_THE_FLOOR_SPELLS.station)),
+        agentDefinitions: namedIn(file.agent_definitions, (body) => agentDefinitionBody(body, AS_THE_FLOOR_SPELLS)),
+        schedules: namedIn(file.schedules, (body) => body),
+        archive: archiveOf(file.archive),
+    };
+}
+function lineOf(written) {
+    if (!written)
+        return { files: {} };
+    const { id, files = {}, ...line } = written;
+    return { line: { id, body: lineBody(line, AS_THE_FLOOR_SPELLS) }, files: valuesOf(files, bytesOf) };
+}
+function archiveOf(written) {
+    const { agent_definitions: agentDefinitions, ...taken } = { lines: [], stations: [], schedules: [], agent_definitions: [], ...written };
+    return { ...taken, agentDefinitions };
+}
+/** The order a person reads in: where a line begins before what it is given, a prompt after the model it is for. A floor hands its fields back in the alphabet's. */
+const READ_IN_ORDER = {
+    line: ["id", "entry", "exit", "start", "args", "files", "nodes", "edges"],
+    station: ["kind", "agent_definition", "conversation", "conversation_key", "url", "route", "outcomes", "must_change", "needs", "produces"],
+    settings: ["model", "image", "timeout_minutes", "tags", "prices", "config", "prompt"],
+    schedule: ["cron", "timezone", "payload"],
+};
+/** What is empty is left out: a file says what a pipeline has. */
+export function fileOf(pipeline) {
+    const line = pipeline.line;
+    const written = {
+        line: line && inOrder({ id: line.id, ...lineBody(line.body, AS_THE_FILE_SPELLS), ...filled("files", valuesOf(pipeline.files, contentOf)) }, READ_IN_ORDER.line),
+        stations: byId(pipeline.stations, (body) => inOrder(respelled(body, AS_THE_FILE_SPELLS.station), READ_IN_ORDER.station)),
+        agent_definitions: byId(pipeline.agentDefinitions, (body) => agentDefinitionBody(body, AS_THE_FILE_SPELLS)),
+        schedules: byId(pipeline.schedules, (body) => inOrder(body, READ_IN_ORDER.schedule)),
+    };
+    return Object.fromEntries(Object.entries(written).filter(([, held]) => isFilled(held)));
+}
+// The fields named, in the order named, then any other as it came.
+function inOrder(given, order) {
+    const named = order.filter((name) => name in given);
+    const others = Object.keys(given).filter((name) => !order.includes(name));
+    return Object.fromEntries([...named, ...others].map((name) => [name, given[name]]));
+}
+function lineBody(line, spellings) {
+    return { ...line, ...filled("edges", listOf(line.edges).map((edge) => respelled(edge, spellings.edge))) };
+}
+function agentDefinitionBody(body, spellings) {
+    const variants = valuesOf(fieldsOf(body.variants), (variant) => settingsOf(fieldsOf(variant), spellings));
+    return { ...body, settings: settingsOf(fieldsOf(body.settings), spellings), ...filled("variants", variants) };
+}
+function settingsOf(settings, spellings) {
+    const prices = valuesOf(fieldsOf(settings.prices), (price) => respelled(fieldsOf(price), spellings.price));
+    return inOrder({ ...respelled(settings, spellings.settings), ...filled("prices", prices) }, READ_IN_ORDER.settings);
+}
+function respelled(given, spelling) {
+    return Object.fromEntries(Object.entries(given).map(([name, held]) => [spelling[name] ?? name, held]));
+}
+function turned(spelling) {
+    return Object.fromEntries(Object.entries(spelling).map(([file, floor]) => [floor, file]));
+}
+function namedIn(byName, bodyOf) {
+    return Object.entries(byName ?? {}).map(([id, body]) => ({ id, body: bodyOf(body) }));
+}
+function byId(named, bodyOf) {
+    return Object.fromEntries(named.map((each) => [each.id, bodyOf(each.body)]));
+}
+function bytesOf(written) {
+    return typeof written === "string" ? Buffer.from(written) : Buffer.from(written.base64, "base64");
+}
+// Text only when it comes back the same: bytes that are no text would be written as something else.
+function contentOf(bytes) {
+    const text = bytes.toString("utf8");
+    return Buffer.from(text).equals(bytes) ? text : { base64: bytes.toString("base64") };
+}
+function valuesOf(byName, made) {
+    return Object.fromEntries(Object.entries(byName).map(([name, held]) => [name, made(held)]));
+}
+function filled(name, held) {
+    return isFilled(held) ? { [name]: held } : {};
+}
+function isFilled(held) {
+    if (held === undefined)
+        return false;
+    return typeof held === "object" && held !== null ? Object.keys(held).length > 0 : true;
+}
+function fieldsOf(held) {
+    return typeof held === "object" && held !== null && !Array.isArray(held) ? held : {};
+}
+function listOf(held) {
+    return Array.isArray(held) ? held.map(fieldsOf) : [];
+}
+//# sourceMappingURL=shape.js.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@re-cinq/floor-pipeline",
+  "version": "0.1.1",
+  "description": "A floor's pipeline as one YAML file: an assembly line with its stations, its agent definitions and their prompts, its files and its schedules. Exports one from a floor, imports one into a floor, and applies a folder of them in order, each once. It speaks the floor's HTTP API and nothing else.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/re-cinq/floor.git",
+    "directory": "packages/pipeline"
+  },
+  "homepage": "https://github.com/re-cinq/floor/tree/main/packages/pipeline#readme",
+  "bugs": {
+    "url": "https://github.com/re-cinq/floor/issues"
+  },
+  "keywords": [
+    "floor",
+    "pipeline",
+    "assembly-line",
+    "yaml",
+    "cli"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "floor-pipeline": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc --watch -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "yaml": "^2.7.0",
+    "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "@vitest/coverage-v8": "^5.0.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
+  }
+}