@stringsync/splates 0.0.45 → 0.0.47

package/lane.d.ts

@@ -1,55 +1,3 @@
-import { type Logger } from "webappwiz/log";
-import type { Facts } from "./events.js";
-import type { Journal } from "./journal.js";
-import { type LaneRecord } from "./lanes.js";
-import type { Todos } from "./todos.js";
-export interface LaneListOptions {
-    /** Print the lanes as JSON instead of a table. */
-    json?: boolean;
-}
-/** Every lane, with its todos in order, who is on it, and what blocks it. */
-export declare function laneList({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, { json }?: LaneListOptions): Promise<void>;
-export interface LaneShowOptions {
-    /** Print the lane as JSON instead of prose. */
-    json?: boolean;
-}
-/**
- * One lane in full, step by step: what an agent handed `[SPLATES LANE N]`
- * reads to know which todo is next, and whether it is blocked first. For
- * null, the untriaged todos, and how to place them in lanes.
- */
-export declare function laneShow({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, id: number | null, { json }?: LaneShowOptions): Promise<void>;
-/** Starts an empty lane called `name`, after the others. */
-export declare function laneAdd({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, name: string): Promise<LaneRecord>;
-export interface LaneUpdateOptions {
-    /** What it is called from now on. */
-    name?: string;
-    /** Where it goes among the lanes, 1 the first; the others close up around it. */
-    position?: number;
-}
-/** Calls a lane by another name, or moves it among the others. */
-export declare function laneUpdate({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, id: number, { name, position }?: LaneUpdateOptions): Promise<LaneRecord>;
-/** What a lane update changed, for the event: only the parts it was asked to. */
-export declare function laneUpdated(id: number, record: LaneRecord, { name, position }: LaneUpdateOptions): Facts["lane update"];
-/**
- * Runs `drop`, which removes lane `id`, and journals it with the lane's name
- * and the todos it sent back to none, read before it went.
- */
-export declare function recordLaneRemove(journal: Journal, todos: Todos, id: number, drop: () => Promise<void>): Promise<void>;
-/** Removes a lane, putting its todos back with the untriaged ones. */
-export declare function laneRemove({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, id: number): Promise<void>;
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+/** `splates lane`, which the root cli mounts after `splates todo`. */
+export declare const splatesLane: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;

package/main.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runs the splates program on the process's own arguments. Both entries end
+ * here: `index.ts`, the published bin, and `checkout.ts`, which mounts `dev`
+ * first.
+ */
+export declare function main(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@stringsync/splates",
-	"version": "0.0.45",
+	"version": "0.0.47",
 	"description": "Runs several AI coding agents on one repository at once, each in its own git worktree",
 	"license": "MIT",
 	"author": "stringsync LLC",
@@ -10,9 +10,6 @@
 		"directory": "packages/splates"
 	},
 	"type": "module",
-	"imports": {
-		"#dev/*": "./dev/*"
-	},
 	"engines": {
 		"bun": ">=1.3"
 	},
@@ -20,8 +17,8 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@agentclientprotocol/sdk": "^1.7.0",
-		"webappwiz": "^0.0.45",
+		"@stringsync/splates-server": "^0.0.47",
+		"webappwiz": "0.0.46",
 		"zod": "^4.4.3"
 	},
 	"main": "./index.js",
@@ -30,42 +27,6 @@
 		".": {
 			"types": "./index.d.ts",
 			"default": "./index.js"
-		},
-		"./asked": {
-			"types": "./asked.d.ts",
-			"default": "./asked.js"
-		},
-		"./probe-runtime": {
-			"types": "./probe-runtime.d.ts",
-			"default": "./probe-runtime.js"
-		},
-		"./testing/agent": {
-			"types": "./fake-agent.d.ts",
-			"default": "./fake-agent.js"
-		},
-		"./config": {
-			"types": "./config.d.ts",
-			"default": "./config.js"
-		},
-		"./heavy": {
-			"types": "./heavy.d.ts",
-			"default": "./heavy.js"
-		},
-		"./skill-checks": {
-			"types": "./skill-checks.d.ts",
-			"default": "./skill-checks.js"
-		},
-		"./systems": {
-			"types": "./systems.d.ts",
-			"default": "./systems.js"
-		},
-		"./tunnel-provider": {
-			"types": "./tunnel-provider.d.ts",
-			"default": "./tunnel-provider.js"
-		},
-		"./update": {
-			"types": "./update.d.ts",
-			"default": "./update.js"
 		}
 	},
 	"bin": {

package/projects.d.ts

@@ -1,136 +1,3 @@
-import type { Logger } from "webappwiz/log";
-import { type Fs, type Lock, type Ps } from "webappwiz/system";
-/** A repository splates has run in, as the registry keeps it. */
-export interface ProjectRecord {
-    /** The main tree's root, never a task's worktree. */
-    root: string;
-    /** When splates first ran there, as an ISO timestamp. */
-    added: string;
-    /**
-     * What each other project may do here, by its root, those left out
-     * `DEFAULT_REACH`.
-     */
-    grants?: Record<string, Reach>;
-}
-/** A registered repository, as the registry reads it back. */
-export interface Project extends ProjectRecord {
-    /**
-     * What a URL names it by: the root's last part, `webappwiz`, with `-2`
-     * and on for a second of the same name, in the order they joined.
-     */
-    slug: string;
-    /** The repository is no longer there: moved or deleted since. */
-    gone: boolean;
-}
-/** What `Projects` works with. */
-export interface ProjectsOptions {
-    fs: Fs;
-    /** Held while the file is rewritten, so two commands never drop each other's. */
-    lock: Lock;
-    /** The current time; a test passes its own. */
-    now?: () => Date;
-}
-/**
- * Every splates project on this machine, kept in one file under the user's
- * home: an explicit roster that `splates init` writes each into, so one
- * `splates server` can find them all without scanning the disk.
- */
-export declare class Projects {
-    /** `~/.splates/projects.json`, or a test's own. */
-    readonly path: string;
-    private readonly fs;
-    private readonly lock;
-    private readonly now;
-    /**
-     * This machine's registry, in `SPLATES_HOME`, `~/.splates` for none, with a
-     * lock that counts as stale after `stalenessMs`.
-     */
-    static ofMachine({ fs, ps, log }: {
-        fs: Fs;
-        ps: Ps;
-        log: Logger;
-    }, stalenessMs?: number): Projects;
-    constructor(
-    /** `~/.splates/projects.json`, or a test's own. */
-    path: string, { fs, lock, now }: ProjectsOptions);
-    /**
-     * Adds the repository at `root`, once, saying whether it did: registering
-     * it again changes nothing.
-     */
-    register(root: string): Promise<boolean>;
-    /**
-     * Makes the registered repository at `root` the one an address naming
-     * none shows, as picking it on the page does, saying whether it is
-     * registered.
-     */
-    focus(root: string): Promise<boolean>;
-    /**
-     * The project an address naming none shows: the one focused last, else
-     * the one focused before it, and so on, else the first registered,
-     * skipping those gone; null while there is none.
-     */
-    focused(): Promise<Project | null>;
-    /**
-     * Every registered project, in the order splates first ran in each, those
-     * whose repository is gone flagged rather than dropped: one on a drive
-     * that is not mounted comes back.
-     */
-    list(): Promise<Project[]>;
-    /**
-     * What the project at `from` may do in the one at `to`: what `to` granted
-     * it, else `DEFAULT_REACH`.
-     */
-    reach(from: string, to: string): Promise<Reach>;
-    /**
-     * Lets the project at `from` do as much as `reach` in the registered one
-     * at `to`, saying whether `to` is registered.
-     */
-    grant(to: string, from: string, reach: Reach): Promise<boolean>;
-    /**
-     * The registered project a command names as `slug`, refusing one that is
-     * not there.
-     */
-    named(slug: string): Promise<Project>;
-    /**
-     * Drops the repository at `root`, saying whether it was there: one gone
-     * for good, or one `splates server` should no longer offer.
-     */
-    forget(root: string): Promise<boolean>;
-    /**
-     * Rewrites the file as `edit` says, under the lock, saying whether it
-     * did: `edit` returns null to leave it as it is.
-     */
-    private change;
-    private get dir();
-    private read;
-    private write;
-}
-/**
- * What an agent working in one project may do in another through splates,
- * each including those before it: read its tasks, todos, lanes and systems;
- * add todos to its untriaged lane; or hand its tasks to agents and
- * orchestrate them. Grants stop splates commands, not file edits.
- */
-export declare const REACHES: readonly ["read", "todos", "tasks"];
-export type Reach = (typeof REACHES)[number];
-/** What a project lets another do that it has granted nothing. */
-export declare const DEFAULT_REACH: Reach;
-/** Whether `granted` covers what `needed` asks for. */
-export declare function reaches(granted: Reach, needed: Reach): boolean;
-/**
- * One line telling an agent where a project a prompt names as `#slug` sits,
- * and how to change it:
- *
- * ```
- * #shop is the splates project at /Users/me/shop: read its code there, and land any change to it from a task added there.
- * ```
- */
-export declare function projectLine({ slug, root, reach, }: {
-    slug: string;
-    root: string;
-    /**
-     * What the project the prompt is in may do there; null when it is that
-     * project, or in none.
-     */
-    reach: Reach | null;
-}): string;
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+/** `splates projects`, which the root cli mounts after `splates lane`. */
+export declare const splatesProjects: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;

package/queue.d.ts

@@ -0,0 +1,3 @@
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+/** `splates queue`, which the root cli mounts beside `splates worker`. */
+export declare const splatesQueue: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;

package/setup.d.ts

@@ -1,102 +1,20 @@
-import type { SecretStore } from "webappwiz/creds";
-import type { Fs } from "webappwiz/system";
-import type { OpenCodeSetup } from "./setup-opencode.js";
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+import { Setup } from "@stringsync/splates-server/setup";
+/** What `splates setup` was asked for. */
+export interface SetupOptions {
+    /** A step's id, or empty for every area's progress. */
+    step: string;
+    json: boolean;
+    skip: boolean;
+    unskip: boolean;
+}
 /**
- * Setting splates up on this machine: the roster's steps, which the user has
- * skipped, kept in `~/.splates/setup.json` so a skipped step stops asking, and
- * where each stands.
+ * `splates setup [step]`: progress by area and the one next step, or one step's
+ * why and instructions, after skipping or unskipping it when asked.
  */
-export declare class Setup {
-    #private;
-    constructor(machine: SetupMachine, areas: readonly SetupArea[]);
-    /** The step `id` names, refusing one not on the roster. */
-    step(id: string): SetupStep;
-    /** Every step checked, by area, and the one to do next. */
-    read(): Promise<SetupProgress>;
-    /** Stops `id` asking, until `unskip`. */
-    skip(id: string): Promise<void>;
-    /** Asks for `id` again. */
-    unskip(id: string): Promise<void>;
-    /**
-     * Marks setup as seen on this machine, so the page stops nudging a fresh
-     * one towards it.
-     */
-    see(): Promise<void>;
-}
-/** What a step's check reads: this machine's splates home and its device store. */
-export interface SetupMachine {
-    /** Explicit checks from the optional native setup panel; never launch on page load. */
-    opencode?: OpenCodeSetup;
-    fs: Fs;
-    /** `~/.splates`, or a test's own. */
-    home: string;
-    /** The device's secret store, where creds kept for every project live. */
-    device: SecretStore;
-    /** How a check reaches the network, as for Access; the global one by default. */
-    fetch?: typeof globalThis.fetch;
-}
+export declare function setup(deps: SplatesDeps, opts: SetupOptions): Promise<void>;
 /**
- * One thing to set up, small enough that the user does at most one thing for
- * it. Whether it is done comes from its check against real state, never a
- * stored flag, so a step undone by hand shows as left again.
+ * This machine's setup, read through `deps`, for the project `--project`
+ * names or the repository the working directory is in, if either.
  */
-export interface SetupStep {
-    /** How `splates setup <step>` and the page name it, lowercase-with-dashes. */
-    readonly id: string;
-    readonly title: string;
-    /** Why it matters, in a sentence. */
-    readonly why: string;
-    /** The one thing the user does, in markdown. */
-    readonly user: string;
-    /** What the agent walking the user through it does, in markdown. */
-    readonly agent: string;
-    /** An optional step can be left undone for good; a required one cannot. */
-    readonly optional: boolean;
-    /** The steps that must be done first, on the roster before this one. */
-    readonly after: readonly SetupStep[];
-    /** The cred the user pastes for it, when that is the one thing they do. */
-    readonly cred?: string;
-    /** Whether it is done, from real state. */
-    check(machine: SetupMachine): Promise<boolean>;
-}
-/** A part of setup, such as remote access, and its steps in order. */
-export interface SetupArea {
-    readonly id: string;
-    readonly title: string;
-    readonly steps: readonly SetupStep[];
-}
-/** A step's state: done and skipped are settled, ready can go now, waiting cannot yet. */
-export type StepStatus = "done" | "skipped" | "ready" | "waiting";
-/** A step as `splates setup --json` and `GET /api/setup` give it. */
-export interface StepProgress {
-    id: string;
-    title: string;
-    why: string;
-    user: string;
-    agent: string;
-    optional: boolean;
-    after: string[];
-    status: StepStatus;
-    /** What went wrong checking it, or null when the check ran. */
-    problem: string | null;
-    /** The cred the user pastes for it, or null. */
-    cred: string | null;
-}
-export interface AreaProgress {
-    id: string;
-    title: string;
-    done: number;
-    skipped: number;
-    /** Steps neither done nor skipped. */
-    left: number;
-    steps: StepProgress[];
-}
-export interface SetupProgress {
-    areas: AreaProgress[];
-    /** The one step to do next, or null when nothing is ready. */
-    next: string | null;
-    /** Whether no one has opened setup on this machine yet. */
-    fresh: boolean;
-    /** Whether any required step is neither done nor skipped. */
-    required: boolean;
-}
+export declare function setupOf(deps: SplatesDeps): Promise<Setup>;

package/slots.d.ts

@@ -1,135 +1,3 @@
-import type { Logger } from "webappwiz/log";
-import { type Fs, type Lock, type Ps } from "webappwiz/system";
-/** The file in a slot's home that its server writes its pid to. */
-export declare const SERVER_PID = "server.pid";
-/** Set in a slot's server's environment to the word it serves under. */
-export declare const SLOT = "SPLATES_SLOT";
-/**
- * Set in a slot's server's environment to the machine's `SPLATES_HOME`, whose
- * tunnel and slots the page lists to switch between.
- */
-export declare const MACHINE_HOME = "SPLATES_MACHINE_HOME";
-/**
- * Which tree holds which slot, kept in `~/.splates/slots.json` for every
- * checkout on this machine. A tree holds the same word every time, so its host
- * name is worth writing down, for as long as it owns it: a task's worktree
- * owns its word until the task merges or is removed, which stops its server
- * and gives the word back. The main tree of a splates repository owns none,
- * since every agent of it stands there, so one agent's slot would be every
- * other's to stop. A server left running from a tree that owns its word no
- * more still holds its port and its host, so its word goes to no other tree
- * until `prune` stops it.
- */
-export declare class Slots {
-    /** `~/.splates/slots.json`, or a test's own. */
-    readonly path: string;
-    private readonly deps;
-    constructor(
-    /** `~/.splates/slots.json`, or a test's own. */
-    path: string, deps: {
-        fs: Fs;
-        /** Tells whether a slot's last server still runs. */
-        ps: Pick<Ps, "pid" | "alive" | "processes" | "spawnCapture">;
-        /** Held while claiming, so two trees starting together get a word each. */
-        lock: Lock;
-        pool?: readonly {
-            word: string;
-            emoji: string;
-        }[];
-    });
-    /** The machine's slots, read from inside a slot's server too. */
-    static ofMachine({ fs, ps, log }: {
-        fs: Fs;
-        ps: Ps;
-        log: Logger;
-    }): Slots;
-    /**
-     * Whether `tree` can own a word: it exists, and is no splates repository's
-     * main tree, whose `.git` is a directory holding splates's records rather
-     * than a linked worktree's file.
-     */
-    owns(tree: string): Promise<boolean>;
-    /**
-     * The slot `tree` holds, claimed now when it holds none: the first word no
-     * tree that owns it holds, and no server still runs on. Throws, naming each
-     * holder, when every word is held.
-     */
-    claim(tree: string): Promise<Slot>;
-    /** The slot's home, its `SPLATES_HOME`: `~/.splates/slots/<word>`. */
-    home(slot: Slot): string;
-    /**
-     * The pid of the slot's last server while it still runs, as one does when
-     * its wrapper was killed or its worktree merged; null once it has stopped,
-     * or for this process itself.
-     */
-    server(slot: Slot): Promise<number | null>;
-    /** Each slot a tree that owns it holds, in the pool's order. */
-    list(): Promise<{
-        slot: Slot;
-        tree: string;
-    }[]>;
-    /** Every claimed word, owned or orphaned, with its server, in the pool's order. */
-    status(): Promise<Held[]>;
-    /**
-     * Stops the slot's server, if one runs, which ends its cloudflared too:
-     * a SIGTERM, then a SIGKILL if it outlives `STOP_WAIT`. Answers with the
-     * pid it stopped, or null when none ran.
-     */
-    stop(slot: Slot): Promise<number | null>;
-    /**
-     * Gives back the word `tree` holds, stopping its server, as a task's
-     * worktree does when it merges or is removed. Answers with what it gave
-     * back, or null when the tree held none.
-     */
-    release(tree: string): Promise<{
-        slot: Slot;
-        stopped: number | null;
-    } | null>;
-    /**
-     * Frees every orphaned word, as `status` tells them, stopping its server:
-     * the only slots any agent may stop, since each of the rest is a task's.
-     * Answers with what it freed.
-     */
-    prune(): Promise<Held[]>;
-    private read;
-    private write;
-}
-/**
- * The words `splates server --slot` hands out, tried in this order, as
- * sound2score's dev slots are: short animals, spellable into a phone, each
- * with an emoji that is that animal and nothing else.
- * Each one's tunnel is made on its first ever claim and kept, so this is also
- * every host name a slot will ever answer on. When every one is held, add the
- * next: goat 🐐, seal 🦭.
- */
-export declare const SLOT_POOL: readonly {
-    word: string;
-    emoji: string;
-}[];
-/** A word of the pool, which names a slot's tunnel, host and home. */
-export interface Slot {
-    /** Like "fox". */
-    word: string;
-    /** Like "🦊": shown beside the project's name while this slot serves it. */
-    emoji: string;
-}
-/** What `release` gave back, as `merge` and `remove` report it. */
-export declare function freedLine({ slot, stopped, }: {
-    slot: Slot;
-    stopped: number | null;
-}): string;
-/** The emoji of `word`, or null for a word not in the pool. */
-export declare function slotOf(word: string): Slot | null;
-/** A claimed word, the tree that holds it, and its server while one runs. */
-export interface Held {
-    slot: Slot;
-    tree: string;
-    /** The pid of its server while one runs, as `server` tells. */
-    pid: number | null;
-    /**
-     * Whether no tree can be said to own it any more: its tree is gone, or is
-     * the main tree of a splates repository, which every agent of it shares.
-     * Only an orphan's server is any agent's to stop, by `prune`.
-     */
-    orphaned: boolean;
-}
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+/** `splates slots`, which the root cli mounts after `splates tunnel`. */
+export declare const splatesSlots: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;

package/splates.d.ts

@@ -1,22 +1,4 @@
-import { type Deps } from "webappwiz/cmd";
-import type { Fs } from "webappwiz/system";
-import type { SecretStores } from "./creds.js";
-import type { Assets } from "./dev/assets.js";
-/** Everything `splates` is run with, before the repository middleware adds to it. */
-export interface SplatesDeps extends Deps {
-    fs: Fs;
-    /**
-     * The registered project a leading `--project <slug>` names, which repo
-     * commands run on instead of the one the working directory is in.
-     */
-    project?: string;
-    /** The built page `dev` serves as its preview. */
-    assets: Assets;
-    /** Where creds are kept; the system's stores by default. */
-    secrets?: SecretStores;
-    /** How `splates tunnel setup` reaches Cloudflare's API; the global one by default. */
-    fetch?: typeof fetch;
-}
+import type { SplatesDeps } from "@stringsync/splates-server/server";
 /**
  * Splits a leading `--project <slug>`, or `--project=<slug>`, off the
  * arguments, for `run` to be handed as `project`.