@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/ports/slots.d.ts

@@ -0,0 +1,150 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Lock, Ps } from "../../../core/system/index.js";
+import { z } from "zod";
+import { type Document, type Storage } from "../storage";
+/** 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";
+/** What `Slots` works with besides its claims. */
+export interface SlotsDeps {
+    /** The machine's home, where each slot's home sits beside the claims. */
+    home: string;
+    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;
+    }[];
+}
+/**
+ * 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 {
+    /** `slots.json` of the machine's storage, or a test's own. */
+    private readonly document;
+    private readonly deps;
+    constructor(
+    /** `slots.json` of the machine's storage, or a test's own. */
+    document: Document<SlotsFile>, deps: SlotsDeps);
+    /** The machine's slots, read from inside a slot's server too. */
+    static ofMachine({ fs, ps, log }: {
+        fs: Fs;
+        ps: Ps;
+        log: Logger;
+    }): Slots;
+    /** The claims kept in `storage`, whose root is `home`. */
+    static in(storage: Storage, deps: Omit<SlotsDeps, "lock">): 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;
+declare const Claims: z.ZodObject<{
+    format: z.ZodNumber;
+    claims: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+/** The claims' file as stored. */
+export type SlotsFile = z.infer<typeof Claims>;
+/** 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;
+}
+export {};

package/vendor/@stringsync/splates-server/ports/socket.d.ts

@@ -0,0 +1,26 @@
+import type { Connection } from "../server/shared";
+/**
+ * A page's WebSocket to a task's server, such as a dev server's hot reload,
+ * carried on to that server: each message as it came, both ways, and a
+ * close at either end closes the other. The server's end opens first, so the
+ * page's upgrade can answer with the subprotocol the server chose.
+ */
+export declare class PortSocket implements Connection {
+    private readonly upstream;
+    private socket;
+    /** What the task's server said before the page's end opened. */
+    private early;
+    private constructor();
+    /**
+     * Opens a WebSocket to `url` with the page's `headers` and subprotocols,
+     * or says why it could not.
+     */
+    static open(url: string, headers: Headers, protocols: string[]): Promise<PortSocket | {
+        refused: string;
+    }>;
+    /** The subprotocol the task's server chose, for the page's upgrade to answer with. */
+    get protocol(): string;
+    open(socket: Bun.ServerWebSocket<Connection>): void;
+    message(_socket: Bun.ServerWebSocket<Connection>, message: string | Buffer<ArrayBuffer>): void;
+    closed(): void;
+}

package/vendor/@stringsync/splates-server/ports/task-ports.d.ts

@@ -0,0 +1,39 @@
+import type { ListeningEntry, ProcessEntry } from "../../../core/system/index.js";
+/**
+ * What ties a process to a task: its worktree, and the agents at work in
+ * it, each on the worker, by id, that holds it.
+ */
+export interface PortOwners {
+    worktrees: {
+        task: string;
+        path: string;
+        worker: string;
+    }[];
+    /** The pid of each agent `splates server` runs in a task, on its worker. */
+    agents: {
+        task: string;
+        pid: number;
+        worker: string;
+    }[];
+}
+/** One port a task's processes listen on, on the worker that runs them. */
+export interface TaskPort {
+    task: string;
+    port: number;
+}
+/**
+ * The ports each task serves, as an editor finds the ports to forward: each
+ * one a process listens on that runs in the task's worktree, or under one of
+ * its agents, whatever directory it moved to. Each port once, in the order
+ * of its task, then its number.
+ */
+export declare function taskPorts(table: ProcessEntry[], listening: ListeningEntry[], owners: {
+    worktrees: {
+        task: string;
+        path: string;
+    }[];
+    agents: {
+        task: string;
+        pid: number;
+    }[];
+}): TaskPort[];

package/vendor/@stringsync/splates-server/prices/index.d.ts

@@ -0,0 +1,2 @@
+export type { Catalog, Price, PricesOptions, Rate, TurnTokens, } from "./prices";
+export { CATALOG, catalogKey, catalogOf, inputKey, Prices, priced, } from "./prices";

package/vendor/@stringsync/splates-server/prices/prices.d.ts

@@ -0,0 +1,65 @@
+import { type WallClock } from "../../../core/time/index.js";
+import type { Storage } from "../storage";
+/** Where the public API list prices come from: OpenCode prices models by it too. */
+export declare const CATALOG = "https://models.dev/api.json";
+/** Dollars per million tokens of each kind, at one context size and above. */
+export interface Rate {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+/** A model's API list price, and the dearer tiers past a context size some models have. */
+export interface Price extends Rate {
+    /** The kinds of input the model takes, such as `text` or `image`; absent when unknown. */
+    inputs?: string[];
+    tiers: (Rate & {
+        context: number;
+    })[];
+}
+/** Each model's API list price, by `<provider>/<model>`. */
+export type Catalog = Record<string, Price>;
+/** What one turn of an agent used, as it said at the turn's end. */
+export interface TurnTokens {
+    /** Tokens read fresh, those from cache apart. */
+    input: number;
+    cachedRead: number;
+    cachedWrite: number;
+    output: number;
+    /** Tokens in the context window as the turn ended; null when unsaid. */
+    context: number | null;
+}
+export interface PricesOptions {
+    /** How the catalog is fetched; a test's stands in for the network. */
+    fetcher?: typeof fetch;
+    clock?: WallClock;
+}
+/**
+ * The API list price of every model, for pricing a turn's tokens; still
+ * answers offline with the prices it last fetched.
+ */
+export declare class Prices {
+    private readonly saved;
+    private readonly fetcher;
+    private readonly clock;
+    constructor(storage: Storage, opts?: PricesOptions);
+    /** The catalog, fetched again when stale; null when never heard and unreachable. */
+    catalog(): Promise<Catalog | null>;
+    private fetchCatalog;
+}
+/** The prices models.dev's `api.json` gives, each model's that says one. */
+export declare function catalogOf(raw: unknown): Catalog;
+/**
+ * Where `agent` running `model` is in the catalog: Codex runs OpenAI's
+ * models, Kimi Code runs Moonshot's, and OpenCode names each by its provider
+ * already. Null for an agent that says its own API cost, as Claude does.
+ */
+export declare function catalogKey(agent: string, model: string | null): string | null;
+/**
+ * Where `agent` running `model` is in the catalog for what it takes in:
+ * as {@link catalogKey}, and Claude's too, by the roster `name` its short
+ * model id has (`Opus 5.5` is `anthropic/claude-opus-5-5`).
+ */
+export declare function inputKey(agent: string, model: string | null, name: string | null): string | null;
+/** What `tokens` cost at `price`, in dollars, at the dearest tier the turn's context reached. */
+export declare function priced(price: Price, tokens: TurnTokens): number;

package/vendor/@stringsync/splates-server/projects/everywhere-routes.d.ts

@@ -0,0 +1,110 @@
+import type { AsyncResource, Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import { type LaneRecord } from "../board";
+import { type ConversationState, type Conversations } from "../conversations";
+import type { Served } from "../server/shared";
+import { type StreamWatcher } from "../server/shared";
+import type { Details, Snapshot } from "../tasks";
+import type { Projects } from "./projects";
+/**
+ * What `GET /api/everywhere` answers: every project served so far, its
+ * slug first among what it holds, so a page shows all of them at once.
+ */
+export interface EverywhereListing {
+    /** By slug, alphabetically. */
+    projects: EverywhereProject[];
+}
+/** One project as the every-project feed carries it. */
+export interface EverywhereProject extends EverywhereBoard {
+    /**
+     * Newest first, as its own page lists them, all as
+     * summaries; none while they are off.
+     */
+    conversations: ConversationState[];
+}
+/**
+ * What of one project's snapshot the every-project feed carries, sent whole
+ * as `event: board` whenever any of it moves.
+ */
+export interface EverywhereBoard {
+    /** What `?project=` names it by. */
+    project: string;
+    /** Its repository's directory name. */
+    repo: string;
+    /** Its main tree. */
+    root: string;
+    /** The directory that holds each of its tasks' worktrees. */
+    worktreeRoot: string;
+    trunk: string;
+    tasks: Details[];
+    /** Every lane there has been, to name an orchestrator after. */
+    laneNames: LaneRecord[];
+    /** The lane each of its tasks at work on a lane is on, by task name, as `lanesTaken` reads it. */
+    lanesTaken: Record<string, number>;
+}
+/** What the global General destination contributes to the same feed. */
+export interface GeneralFeed {
+    root: string;
+    conversations: Conversations;
+    current(): Promise<Snapshot>;
+    listen(heard: Parameters<Served["listen"]>[0]): Resource;
+}
+/**
+ * Every registered project's tasks and conversations, on one stream: what
+ * a page listing them across projects reads. The first ask opens each
+ * project not yet served, one at a time behind the focused one, so `owned`
+ * finds any conversation and the focused page never waits on the rest.
+ *
+ * The stream says:
+ * - a full conversation on connection, as `data: {project, conversation}`;
+ * - `event: delta` with `{project, delta}` for its later changes;
+ * - `event: removed` with `{project, id}`, for one deleted;
+ * - `event: board` with an `EverywhereBoard`, when a project's tasks moved;
+ * - `event: projects`, when one was served since, to list again.
+ */
+export declare class EverywhereRoutes implements StreamWatcher, AsyncResource {
+    private readonly home;
+    private readonly listeners;
+    private readonly copies;
+    /** Each served project heard, by root, while a stream is open. */
+    private readonly heard;
+    private opening;
+    constructor(home: {
+        projects: Projects;
+        /** By root, as `dev` keeps them. */
+        served: Map<string, Promise<Served>>;
+        servedAt: (root: string) => Promise<Served>;
+        general?: GeneralFeed;
+        log: Logger;
+    });
+    /** `GET /api/everywhere`. */
+    readonly list: () => Promise<Response>;
+    /** `GET /api/everywhere/events`. */
+    readonly events: () => Promise<Response>;
+    /**
+     * Serves every registered project not yet served, one at a time; again
+     * on a later call, for any registered since. One that fails to open is
+     * logged and left.
+     */
+    openAll(): Promise<void>;
+    /** The project at `root` is served now: the streams list again. */
+    added(root: string, project: Served): void;
+    opened(): void;
+    closed(): void;
+    disposeAsync(): Promise<void>;
+    /** Listens to the project at `root` while a stream is open, once. */
+    private hear;
+    /** Listens to General while a stream is open, once. */
+    private hearGeneral;
+    /** Every project served so far, those that failed to open left out. */
+    private servedNow;
+    /**
+     * What the feed carries of the project at `root`'s snapshot, kept as its
+     * pages read it; null when its records are past what this splates reads.
+     */
+    private board;
+    private slugOf;
+    private changed;
+    private write;
+    private say;
+}

package/vendor/@stringsync/splates-server/projects/everywhere.d.ts

@@ -0,0 +1,43 @@
+import type { Conversation, Conversations } from "../conversations";
+import type { Served } from "../server/shared";
+import type { Projects } from "./projects";
+/**
+ * The conversations of every project `splates server` serves, so a conversation
+ * that handed out a task in another project than its own hears of, and
+ * answers for, the agent it handed it to, as it would one in its own.
+ */
+export declare class Everywhere {
+    private readonly placing;
+    /** Only the conversations of the project at `root`, as a server of one has them. */
+    static onlyHere(root: string, conversations: Conversations): Everywhere;
+    /**
+     * The conversations of each project in `served`, by its root, those that
+     * failed to open left out, each named as `projects` names it.
+     */
+    static served(served: Map<string, Promise<Served>>, projects: Projects): Everywhere;
+    constructor(placing: Placing);
+    /** Every conversation of every project served so far, with its project's main tree. */
+    list(): Promise<Placed[]>;
+    /** The conversation `id`, of whichever project holds it, or undefined for none. */
+    find(id: string): Promise<Placed | undefined>;
+    /** What the registry names the project at `root` by, which `?project=` takes. */
+    slug(root: string): Promise<string>;
+    /**
+     * How a directive names `task`, of the project at `root`, to a
+     * conversation of the project at `to`: bare in its own, else
+     * `<slug>/<task>`, which `splates --project <slug>` reaches.
+     */
+    taskNamed(task: string, root: string, to: string): Promise<string>;
+}
+/** A conversation, and the main tree of the project it is in. */
+export interface Placed {
+    conversation: Conversation;
+    root: string;
+}
+/** Where `Everywhere` finds the conversations, and the projects' names. */
+export interface Placing {
+    /** Every conversation of every project served so far. */
+    list(): Promise<Placed[]>;
+    /** What the registry names the project at `root` by. */
+    slug(root: string): Promise<string>;
+}

package/vendor/@stringsync/splates-server/projects/general.d.ts

@@ -0,0 +1,4 @@
+/** The reserved destination for conversations that belong to no project. */
+export declare const GENERAL = "~general";
+/** How the every-project feed names that destination. */
+export declare const GENERAL_NAME = "General";

package/vendor/@stringsync/splates-server/projects/index.d.ts

@@ -0,0 +1,10 @@
+export { Everywhere } from "./everywhere";
+export type { EverywhereBoard, EverywhereListing, EverywhereProject, } from "./everywhere-routes";
+export { EverywhereRoutes } from "./everywhere-routes";
+export { GENERAL, GENERAL_NAME } from "./general";
+export { forget, init } from "./init";
+export type { Added } from "./picker";
+export { Picker } from "./picker";
+export type { Project, Reach } from "./projects";
+export { Projects, projectLine, REACHES, reaches } from "./projects";
+export { grantReach, listReaches } from "./reaches";

package/vendor/@stringsync/splates-server/projects/index.js

@@ -0,0 +1,36 @@
+import {
+  Everywhere2,
+  EverywhereRoutes2,
+  GENERAL2,
+  GENERAL_NAME2,
+  init2,
+  forget2,
+  Projects2,
+  REACHES2,
+  reaches2,
+  projectLine2,
+  Picker2,
+  listReaches2,
+  grantReach2
+} from "../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  Everywhere2 as Everywhere,
+  EverywhereRoutes2 as EverywhereRoutes,
+  GENERAL2 as GENERAL,
+  GENERAL_NAME2 as GENERAL_NAME,
+  Picker2 as Picker,
+  Projects2 as Projects,
+  REACHES2 as REACHES,
+  forget2 as forget,
+  grantReach2 as grantReach,
+  init2 as init,
+  listReaches2 as listReaches,
+  projectLine2 as projectLine,
+  reaches2 as reaches
+};

package/vendor/@stringsync/splates-server/projects/init.d.ts

@@ -0,0 +1,28 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Git } from "../git";
+import type { Projects } from "./projects";
+/**
+ * Makes this repository a splates project: `repository` has set up its records
+ * by now, when it had none, so what is left is installing the skill that
+ * teaches its agents to work through splates, through `bunx skills add` from
+ * this release's tag, and joining the registry, which
+ * lets one `splates server` serve it beside every other. Run again, or in a
+ * project already under way, it changes nothing that is already so.
+ */
+export declare function init({ git, projects, fs, ps, log, }: {
+    git: Git;
+    projects: Projects;
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+}): Promise<void>;
+/**
+ * Takes this repository off the registry, so `splates server` no longer offers it:
+ * its records stay, and `splates init` brings it back.
+ */
+export declare function forget({ git, projects, log, }: {
+    git: Git;
+    projects: Projects;
+    log: Logger;
+}): Promise<void>;

package/vendor/@stringsync/splates-server/projects/picker.d.ts

@@ -0,0 +1,64 @@
+import type { Deps } from "../../../core/cmd/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import type { SecretStores } from "../creds";
+import type { DevMachine } from "../server/shared";
+import { type Project } from "./projects";
+/**
+ * What the page's project picker asks of `splates server` beyond listing: adding
+ * a project, committing what `splates init` wrote there, focusing one, and a
+ * grant card's grant from one to another. Its
+ * handlers are properties, so `dev` hands them to its routes as they are.
+ */
+export declare class Picker {
+    private readonly deps;
+    constructor(deps: DevMachine);
+    /**
+     * Adds the repository the body's `path` names, as `splates init` there
+     * would, and focuses it.
+     */
+    readonly add: (request: Request) => Promise<Response>;
+    /** Commits the body's `paths`, which `splates init` wrote, once the person said to. */
+    readonly commit: (request: Request) => Promise<Response>;
+    /** Makes the body's `project` what an address naming none shows, on any device. */
+    readonly focus: (request: Request) => Promise<Response>;
+    /**
+     * Lets the project the body's `from` names do as much as its `reach` in
+     * the one the path names, as a grant card's Allow asks: the person's
+     * call, which `splates projects grant` refuses an agent.
+     */
+    readonly grant: (request: Request) => Promise<Response>;
+}
+/**
+ * What `splates init` writes in a project: the skill, its link for Claude
+ * Code, and the lock `skills` keeps. Uncommitted, each is offered again,
+ * even when an earlier init left it so.
+ */
+export declare const INIT_WRITES: string[];
+/** A project the page added, and what `splates init` left in it to commit. */
+export interface Added {
+    project: Project;
+    /**
+     * Each file init wrote that is not committed, as `git status` names it:
+     * what the page asks to commit, and all it commits.
+     */
+    uncommitted: string[];
+    /** The same, each under one of `INIT_WRITES` named by that, for the page to say. */
+    shown: string[];
+    /** The branch a commit of them lands on; null on a detached HEAD. */
+    branch: string | null;
+}
+/**
+ * Makes the repository `path` sits in a splates project, as `splates init` run
+ * there would, `~` meaning the home directory: its records, made or brought
+ * forward, the skill, and its place in the registry, focused. Commits
+ * nothing, but says what init wrote, for the page to ask before it commits.
+ */
+export declare function initProject(machine: Deps & {
+    fs: Fs;
+    secrets?: SecretStores;
+}, path: string): Promise<Added>;
+/**
+ * Commits `paths` in the main tree at `root` as setting up splates, on
+ * whatever it has checked out, leaving every other change as it was.
+ */
+export declare function commitInit({ ps }: Deps, root: string, paths: string[]): Promise<void>;