@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/comma-list.d.ts

@@ -0,0 +1,2 @@
+/** A comma-separated list, with empty values removed. */
+export declare function commaList(raw: string): string[];

package/vendor/@stringsync/splates-server/comma-list.js

@@ -0,0 +1,6 @@
+import {
+  commaList2
+} from "./index-01z7ycdk.js";
+export {
+  commaList2 as commaList
+};

package/vendor/@stringsync/splates-server/config/browser.d.ts

@@ -0,0 +1 @@
+export { LEGACY_PLAN_FILE } from "./legacy-names";

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

@@ -0,0 +1,210 @@
+import type { TaskEventName } from "../hooks";
+import type { ReplicaPlace } from "../replica";
+import type { TunnelProvider } from "../tunnel";
+export interface Config {
+    /**
+     * The integration branch name. `merge` rebases a task onto this branch and
+     * then fast-forwards it to the result; new worktrees start from it.
+     */
+    trunk: string;
+    /**
+     * The git remote each task's branch is pushed to as `splates/<task>`,
+     * after every commit and at every checkpoint, so a task outlives the
+     * machine it runs on: the project's GitHub origin, as `"origin"`. With
+     * one, trunk is the remote's: a merge rebases onto it and the
+     * server alone pushes it. Unset, it is `"origin"` where the
+     * server is deployed or being and `origin` is an SSH URL, and null
+     * elsewhere, which pushes nothing, so tasks live on this machine alone;
+     * `null` set here keeps it so everywhere.
+     */
+    remote: string | null;
+    /** Directory holding one worktree per task, a sibling of the repo. */
+    worktreeRoot: string;
+    /** Command run by `add` in the new worktree, via `sh -c`. */
+    postCheckout: string | null;
+    /**
+     * Command run by `merge` after the rebase, before `preMerge`, via `sh -c`.
+     * A rebase can bring in a dependency the worktree has never installed, and
+     * whatever `preMerge` runs needs it.
+     */
+    postRewrite: string | null;
+    /**
+     * Command run by `merge` after the rebase, via `sh -c`. The last gate before
+     * the branch lands: a nonzero exit rolls the branch back and leaves the base
+     * untouched. Tests are the obvious thing to put here, but splates has no
+     * opinion; a repo with nothing to run leaves it null and merges on a green
+     * rebase alone.
+     *
+     * To have `merge` queue a task for each test slower than 5 seconds, write a
+     * JUnit XML report to the path in `$SPLATES_TEST_REPORT`, as `bun test
+     * --reporter=junit --reporter-outfile="$SPLATES_TEST_REPORT"` does.
+     * A Bun report also enables selective failure attribution: only failures
+     * reproduced with the task after passing on its base spend an attempt.
+     * Missing reports and inconclusive retests hold the merge without charging.
+     */
+    preMerge: string | null;
+    /**
+     * Command run by `merge` after the first rebase, via `sh -c`, before the
+     * merge waits for the premerge lock, so a check that needs neither the lock
+     * nor the cores fails without the wait. A nonzero exit refuses the merge as
+     * a failed gate. `preMerge` then runs with `$SPLATES_CHECKED` set to the
+     * commit this passed on, so it can skip what that run covered.
+     */
+    preLock: string | null;
+    /**
+     * Command `splates ship` runs from the root, via `sh -c`, to release the
+     * project: publish its public packages at their next version and leave the
+     * release committed and tagged on the trunk, as `"wiz dev ship"`. Null
+     * means the project is never shipped from splates, though it still takes
+     * the bumps of those it depends on.
+     */
+    ship: string | null;
+    /**
+     * Command that reads live release versions, via `sh -c` in the main tree.
+     * Prints JSON `{version, artifacts: [{name, deployed}]}`; `deployed` is a
+     * version string or null before anything is live. Null reads npm's latest
+     * dist-tag for each public package instead. Failures stop the read.
+     */
+    shipStatus: string | null;
+    /**
+     * Command a project that pins this one's packages runs once a ship's
+     * cascade has moved its pins to the versions this one shipped, after `bun
+     * install`: its bump task lists it as a step for the agent to run in the
+     * task's worktree and commit what it changed, as `"bunx
+     * @stringsync/splates refresh"`. Null asks nothing past the install.
+     */
+    afterBump: string | null;
+    /**
+     * Commands run on task events, via `sh -c` in the main tree, with the
+     * event in `$SPLATES_EVENT`, its tasks' numbers in `$SPLATES_TASKS`, comma
+     * separated, and the started task's name, if any, in `$SPLATES_TASK`:
+     * `{ "task.done": "./notify-team" }`. Checked in, so shell commands only;
+     * an agent hook spends its person's tokens, so each person sets their own
+     * from the Setup page or `splates hook add`.
+     */
+    on: Partial<Record<TaskEventName, string>>;
+    /** How long since its last heartbeat before a task's lease is up for grabs. */
+    leaseStalenessMs: number;
+    /** Failed `merge` attempts a task gets before only a person's `splates retry` lets it try again. */
+    mergeRetryCount: number;
+    /**
+     * Maximum conflicted rebases before you must allow more with `splates retry`.
+     * Conflicts count separately from failed merge gates (`mergeRetryCount`).
+     */
+    mergeConflictCount: number;
+    /**
+     * How many removed task names to remember. Increase this to keep `remove`
+     * reporting "already removed" for older tasks.
+     */
+    removedCapacity: number;
+    /**
+     * How many finished tasks to keep, each with the `SPLATES.md` it ended on,
+     * for the Tasks page's Finished list, which shows every one kept. The
+     * oldest to finish goes first.
+     */
+    finishedCapacity: number;
+    /**
+     * Maximum events per log file. Increase this to keep more events together
+     * before the log rotates.
+     */
+    logCapacity: number;
+    /**
+     * How long a queued task can wait before `merge` stops recommending it and offers
+     * it for removal instead: work deferred that long has usually been done
+     * some other way, or stopped mattering.
+     */
+    taskStalenessMs: number;
+    /**
+     * How many bytes of files `splates attach` lets one task hold, all of them
+     * together: a screen recording is the one thing here that grows fast.
+     */
+    attachmentCapacity: number;
+    /** How many bytes one artifact a conversation keeps may be (`artifacts.ts`). */
+    artifactFileCapacity: number;
+    /**
+     * How many bytes of artifacts one conversation may keep, every version
+     * whose bytes have not been deleted.
+     */
+    artifactConversationCapacity: number;
+    /** How many bytes of artifacts every conversation in the project may keep together. */
+    artifactProjectCapacity: number;
+    /**
+     * The command the `splates server` Budget page runs `budgets` with, from
+     * the repo's root: vet, whose `budgets` command keeps them.
+     */
+    vet: string;
+    /**
+     * What carries `splates server --tunnel` to its public host, a TunnelProvider
+     * of your own for any tunnel; null runs `cloudflared`.
+     */
+    tunnel: TunnelProvider | null;
+    /**
+     * The platform the project's agents must run on, for a project that
+     * builds only there: its tasks wait for a worker on it rather than run
+     * elsewhere. Null runs them on any.
+     */
+    platform: "linux" | "macos" | "windows" | null;
+    /**
+     * Where `splates server` keeps a copy of the project's records, a few
+     * seconds behind every change: a bucket of any S3-compatible store, as
+     * `{ provider: "s3", endpoint: "https://<store's endpoint>", bucket: "my-splates" }`,
+     * whose key and secret the Creds page asks for as `REPLICA_ACCESS_KEY` and
+     * `REPLICA_SECRET_KEY`, or a folder, as `{ provider: "dir", path: "/Volumes/Backup/splates" }`.
+     * The copy is where the records move from when the server moves to
+     * another machine. Null keeps none.
+     */
+    replica: ReplicaPlace | null;
+    /**
+     * Words the composer's mic should spell as written, for everyone who
+     * dictates in the project: its tools, modules and names, as
+     * `["webappwiz", "scry"]`. Splates and the project's name are always
+     * told; each person adds their own on the Setup page.
+     */
+    dictationWords: string[];
+    /**
+     * Where the project's evals, run by any framework, leave their results for
+     * the Evals page, as `{ results: ".evals" }`: relative to the project's
+     * root, absolute, or under `~`. Each batch is a directory of it holding a
+     * `batch.json` and a `results.jsonl` in the `splates-evals/1` format
+     * (`designs/evals-contract.md`). Null shows no Evals page.
+     */
+    evals: EvalsConfig | null;
+}
+/**
+ * Where a project's evals report to splates, and the commands that start
+ * them from the page's run card (`docs/evals.md`).
+ */
+export interface EvalsConfig {
+    /** The directory holding one directory per batch. */
+    results: string;
+    /**
+     * Prints the cases a run card can pick, one JSON object a line, as
+     * `{"case": "refunds/partial", "group": "refunds", "about": "..."}`.
+     */
+    list?: string;
+    /**
+     * Runs the cases in `SPLATES_EVALS_CASES` on the targets in
+     * `SPLATES_EVALS_TARGETS` into a new batch directory under
+     * `SPLATES_EVALS_RESULTS`. Without it the page only shows results.
+     */
+    run?: string;
+    /**
+     * Told what `run` is, prints what the run comes to as
+     * `{"cells": 12, "usd": 3.6}`, so the card shows a ceiling; exits non-zero
+     * to refuse the run. Without it the card shows no cost.
+     */
+    plan?: string;
+}
+/**
+ * What `splates.config.ts` exports as its default, as
+ * `{ preMerge: "bun test" } satisfies ConfigFile`, with `ConfigFile` imported
+ * type-only from `@stringsync/splates/config` so a reader can import the file
+ * without splates installed.
+ */
+export type ConfigFile = Partial<Config>;
+/**
+ * Return your project settings with their types checked.
+ *
+ * @deprecated Use `satisfies ConfigFile` on your default export instead.
+ */
+export declare function defineConfig(config: Partial<Config>): Partial<Config>;

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

@@ -0,0 +1,6 @@
+export type { Config, ConfigFile, EvalsConfig } from "./config";
+export { defineConfig } from "./config";
+export { LEGACY, LEGACY_DIR, LEGACY_PLAN_FILE, legacyWarnings, movedPath, moveLegacyDir, movePlan, removeLegacySkill, renamed, renameLegacyFiles, unmigrated, } from "./legacy-names";
+export { systemPs } from "./legacy-ps";
+export { ARTIFACT_LIMITS, CONFIG_FILE, ConfigFiles, loadConfig, } from "./load";
+export { typedConfig } from "./source";

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

@@ -0,0 +1,42 @@
+import {
+  defineConfig2,
+  systemPs2,
+  ARTIFACT_LIMITS2,
+  CONFIG_FILE2,
+  loadConfig2,
+  ConfigFiles2,
+  typedConfig2
+} from "../index-e9z7s5hh.js";
+import {
+  LEGACY2,
+  renamed2,
+  LEGACY_PLAN_FILE2,
+  LEGACY_DIR2,
+  legacyWarnings2,
+  unmigrated2,
+  moveLegacyDir2,
+  movePlan2,
+  movedPath2,
+  renameLegacyFiles2,
+  removeLegacySkill2
+} from "../index-g18nxyn7.js";
+export {
+  ARTIFACT_LIMITS2 as ARTIFACT_LIMITS,
+  CONFIG_FILE2 as CONFIG_FILE,
+  ConfigFiles2 as ConfigFiles,
+  LEGACY2 as LEGACY,
+  LEGACY_DIR2 as LEGACY_DIR,
+  LEGACY_PLAN_FILE2 as LEGACY_PLAN_FILE,
+  defineConfig2 as defineConfig,
+  legacyWarnings2 as legacyWarnings,
+  loadConfig2 as loadConfig,
+  moveLegacyDir2 as moveLegacyDir,
+  movePlan2 as movePlan,
+  movedPath2 as movedPath,
+  removeLegacySkill2 as removeLegacySkill,
+  renameLegacyFiles2 as renameLegacyFiles,
+  renamed2 as renamed,
+  systemPs2 as systemPs,
+  typedConfig2 as typedConfig,
+  unmigrated2 as unmigrated
+};

package/vendor/@stringsync/splates-server/config/legacy-names.d.ts

@@ -0,0 +1,70 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+/** splates's old name, as its command, its skill and its directories went by. */
+export declare const LEGACY = "arbor";
+/** The old name of a `SPLATES_*` variable or cred, or null for any other. */
+export declare function legacyName(name: string): string | null;
+/** The `SPLATES_*` name of an `ARBOR_*` variable or cred, or null for any other. */
+export declare function renamed(old: string): string | null;
+/** A task's notes file in a worktree made before the rename. */
+export declare const LEGACY_PLAN_FILE = "ARBOR.md";
+/** The state directory under `.git`, and the home directory's, before the rename. */
+export declare const LEGACY_DIR = "arbor";
+/** Says once per process, on stderr, that an old name was used. */
+declare class Warnings {
+    #private;
+    once(name: string, instead: string): void;
+}
+export declare const legacyWarnings: Warnings;
+/**
+ * `next`, or `old` while only the old directory is there: until `splates server`
+ * has moved it, every command reads records where arbor left them.
+ */
+export declare function unmigrated(next: string, old: string): string;
+/** What `moveLegacyDir` works with. */
+export interface MoveOptions {
+    fs: Fs;
+    log: Logger;
+    /** Makes `path` a symbolic link to `target`; the real one by default. */
+    link?: (target: string, path: string) => Promise<void>;
+}
+/**
+ * Moves arbor's directory `old` to `next` and leaves a link at `old`, so the
+ * absolute paths records hold, attachments named in plans, tasks and
+ * conversations above all, still resolve. Does nothing once moved, or when
+ * `next` is already there. Answers whether it moved.
+ */
+export declare function moveLegacyDir(old: string, next: string, { fs, log, link }: MoveOptions): Promise<boolean>;
+/** Renames a worktree's `ARBOR.md` to `planFile`, unless it has one already. */
+export declare function movePlan(tree: string, planFile: string, fs: Fs): Promise<void>;
+/**
+ * `path` under `.git/splates` when it names a file under `.git/arbor`, as
+ * plans, tasks and conversations written before the move do.
+ */
+export declare function movedPath(path: string): string;
+/** The old name of the file a repo keeps `file`'s settings in, or null. */
+export declare function legacyFile(file: string): string | null;
+/** What `renameLegacyFiles` and `removeLegacySkill` work with. */
+export interface LegacyRepoOptions {
+    /** The repository's main tree. */
+    root: string;
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+}
+/**
+ * Renames `arbor.config.ts` to splates's names, through
+ * git when it tracks them so the rename is staged as one, and points their
+ * imports of `@webappwiz/arbor` at `@stringsync/splates`. Leaves a file
+ * alone when one under the new name is already there.
+ */
+export declare function renameLegacyFiles({ root, fs, ps, log, }: LegacyRepoOptions): Promise<void>;
+/**
+ * Takes arbor's skill at `path` out of its project, which splates's replaces.
+ * Leaves one that links to a copy kept by hand.
+ */
+export declare function removeLegacySkill(path: string, { fs, log }: {
+    fs: Fs;
+    log: Logger;
+}): Promise<void>;
+export {};

package/vendor/@stringsync/splates-server/config/legacy-ps.d.ts

@@ -0,0 +1,32 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import { type Child, type Ps, type SpawnCaptureResult, type SpawnOptions, type SpawnResult, type StartOptions, type TerminalChild, type TerminalOptions } from "../../../core/system/index.js";
+/**
+ * A `Ps` that reads each `SPLATES_*` variable under its `ARBOR_*` name too,
+ * warning once, and sets both names on every child, so a `wiz` or skill still
+ * reading the old ones sees what splates means.
+ */
+export declare class LegacyNamesPs implements Ps {
+    private readonly inner;
+    constructor(inner: Ps);
+    get platform(): NodeJS.Platform;
+    get pid(): number;
+    get hostname(): string;
+    get args(): string[];
+    get self(): string[];
+    env(name: string): string | undefined;
+    columns(): number | undefined;
+    alive(pid: number): boolean;
+    spawn(argv: string[], opts?: SpawnOptions): Promise<SpawnResult>;
+    spawnCapture(argv: string[], opts?: SpawnOptions): Promise<SpawnCaptureResult>;
+    start(argv: string[], opts?: StartOptions): Child;
+    startOnTerminal(argv: string[], opts: TerminalOptions): TerminalChild;
+    processes(): ReturnType<Ps["processes"]>;
+    listening(): ReturnType<Ps["listening"]>;
+    cwd(): string;
+    cd(path: string): void;
+    exit(code: number): void;
+    on(signal: string, handler: (...args: unknown[]) => void): Resource;
+    once(event: "exit", handler: () => void): Resource;
+}
+/** The machine's processes, under both names. */
+export declare function systemPs(): Ps;

package/vendor/@stringsync/splates-server/config/load.d.ts

@@ -0,0 +1,46 @@
+import { type Fs } from "../../../core/system/index.js";
+import type { ArtifactLimits } from "../artifacts";
+import { Git } from "../git";
+import type { Config } from "./config";
+/** What `splates.config.ts` leaves the artifact limits at unless it says otherwise. */
+export declare const ARTIFACT_LIMITS: ArtifactLimits;
+/** The file a repo's settings are in, at its root. */
+export declare const CONFIG_FILE = "splates.config.ts";
+export interface LoadConfigOptions {
+    /** What `splates.config.ts` is looked for through; the real one by default. */
+    fs?: Fs;
+    /** What the trunk is detected through; the repo's own git by default. */
+    git?: Git;
+}
+/**
+ * The settings splates runs a repo with: what `splates.config.ts` names, then the
+ * branch `origin/HEAD` points at for the trunk, then splates's own defaults.
+ * Throws when the config file is there but cannot be imported.
+ */
+export declare function loadConfig(root: string, opts?: LoadConfigOptions): Promise<Config>;
+/** Reads the TypeScript files a repo keeps its settings in, through `fs`. */
+export declare class ConfigFiles {
+    private readonly fs;
+    constructor(fs?: Fs);
+    /**
+     * What `root`'s `splates.config.ts` names, or nothing when there is no such
+     * file.
+     */
+    read(root: string): Promise<Partial<Config>>;
+    /**
+     * Everything `root`'s `splates.config.ts` exports as its default, unchecked, or
+     * nothing when there is no such file.
+     */
+    importConfig(root: string): Promise<Record<string, unknown>>;
+    /**
+     * Where `file` is at `root`, under arbor's old name for it until `splates
+     * update` renames it, or null when it is under neither.
+     */
+    private found;
+    /**
+     * Read `file` relative to the repository's `root`, returning its default
+     * export or an empty record when absent. Throws if the file cannot load;
+     * call again after an edit to read the updated settings.
+     */
+    importDefault(root: string, file: string): Promise<Record<string, unknown>>;
+}

package/vendor/@stringsync/splates-server/config/source.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `source` typed by a type-only import of `ConfigFile` and `satisfies` rather
+ * than by calling `defineConfig`, so a reader can import it without splates
+ * installed; or null unless it imports `defineConfig` alone and calls it
+ * once.
+ */
+export declare function typedConfig(source: string): string | null;

package/vendor/@stringsync/splates-server/config/type-config.d.ts

@@ -0,0 +1,14 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs } from "../../../core/system/index.js";
+/**
+ * Types an older `splates.config.ts` by a type-only import and `satisfies`
+ * rather than `defineConfig`, so a reader can import it without splates
+ * installed. Leaves a config it cannot safely rewrite unchanged and logs
+ * instructions for typing it by hand.
+ */
+export declare function typeConfig({ root, fs, log, }: {
+    /** The repository's main tree. */
+    root: string;
+    fs: Fs;
+    log: Logger;
+}): Promise<void>;

package/vendor/@stringsync/splates-server/conversations/answered.d.ts

@@ -0,0 +1,7 @@
+import type { Answer, Ask } from "./state";
+/**
+ * What the person said to `ask`, in words a new session can read, as for an
+ * agent whose place a drain freed while it asked: that session never asked,
+ * so it hears the question with the answer. Null for one dismissed.
+ */
+export declare function answerWords(ask: Ask, answer: Answer): string | null;

package/vendor/@stringsync/splates-server/conversations/archive.d.ts

@@ -0,0 +1,16 @@
+import type { Conversation } from "./conversation";
+import type { ConversationHost } from "./host";
+/**
+ * Records archive membership and its timestamp together; `rest`, archived
+ * resting, as a persistent agent's run that ended with its role still on.
+ */
+export declare function put(host: ConversationHost, { archived, with: withConversation, rest, }: {
+    archived: boolean;
+    with?: string | undefined;
+    rest?: boolean;
+}): Promise<void>;
+/**
+ * The archived of `conversations`, the latest archived first, but for the
+ * newest of each persistent agent's role, which holds its row, so is kept.
+ */
+export declare function archivedNewestFirst(conversations: readonly Conversation[]): Conversation[];

package/vendor/@stringsync/splates-server/conversations/background.d.ts

@@ -0,0 +1,21 @@
+import type { AgentConnection } from "../agents";
+import type { ConversationDeps, ConversationHost } from "./host";
+/**
+ * The commands the agent left running in the background, as the
+ * conversation's state lists them: what each has printed, and stopping one.
+ */
+export declare class ConversationBackground {
+    private readonly host;
+    private readonly deps;
+    private readonly connection;
+    constructor(host: ConversationHost, deps: ConversationDeps, connection: AgentConnection);
+    /** Stops background command `id`, leaving the agent's turn as it is. */
+    stop(id: string): Promise<void>;
+    /**
+     * What background command `id` has printed, then more as it prints it,
+     * ending once the command has and all of it is read.
+     */
+    output(id: string): ReadableStream<Uint8Array>;
+    /** Background command `id`, refusing one the agent never left. */
+    private command;
+}

package/vendor/@stringsync/splates-server/conversations/browser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The conversation values a browser bundle can take: import them from
+ * `@stringsync/splates/conversations/browser` in the page, and types from
+ * `@stringsync/splates/conversations`.
+ */
+export { paused, textOf } from "./messages";
+export { grooms, lanesOf, namedForTask, nameOf, openingOf, realName, } from "./name";
+export { conversationReference } from "./reference";
+export { saidIn, snippetOf, wordsOf } from "./search";
+export { blank, DEVICES, FROM_HEADER, IDLE_STOP, listed, SERVER_TOLD, switched, unused, } from "./state";
+export type { ConversationDelta } from "./updates";
+export { ConversationUpdates } from "./updates";

package/vendor/@stringsync/splates-server/conversations/choice.d.ts

@@ -0,0 +1,8 @@
+import type { AgentConnection } from "../agents";
+import type { ConversationHost } from "./host";
+/**
+ * Applies a validated choice to the session and its log: the person's, or,
+ * `byAutoPick`, Auto pick's own. Neither switches Auto pick off: that is
+ * the person's own switch; a pick of theirs is only recorded as an override.
+ */
+export declare function choose(host: ConversationHost, connection: AgentConnection, id: string, value: string, byAutoPick?: boolean): Promise<void>;

package/vendor/@stringsync/splates-server/conversations/compact.d.ts

@@ -0,0 +1,6 @@
+import type { Entry } from "./entry";
+/**
+ * `entries` saved short: replayed, the result leaves the conversation as
+ * `entries` do, in a fraction of the lines.
+ */
+export declare function compacted(entries: Entry[]): Entry[];