@stringsync/splates 0.0.60 → 1.13.3

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

@@ -0,0 +1,56 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+/**
+ * Set in the environment of the splates `update` hands itself to, so that one
+ * refreshes rather than looking for a newer one again: npm can name a version
+ * a moment before `bunx` can fetch it.
+ */
+export declare const UPDATING = "SPLATES_UPDATING";
+/**
+ * Brings this repository up to the newest splates: when npm has a newer release
+ * than the one running, runs `update` again on that one, which does the rest
+ * itself; otherwise moves tasks saved with tags into lanes, installs this
+ * one's skill over whatever copy is there, through `bunx skills add` from
+ * this release's tag, and moves what an older config holds to where this
+ * one reads it. Offline, the running release is the newest there is to
+ * have. `wiz update` names the release instead, as it pins every webappwiz
+ * package to one. Answers with the exit code to end on.
+ */
+export declare function update({ root, fs, ps, log, newest, release, records, }: {
+    /** The repository's main tree. */
+    root: string;
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    /** The latest splates on npm, or null when it cannot say; unasked given `release`. */
+    newest?: () => Promise<string | null>;
+    /** The release whose skill to install, rather than the newest. */
+    release?: string;
+    /**
+     * Whether the records are in this splates's format, or wait on the server
+     * restarting onto it, which moves them: tasks move from tags into lanes
+     * only once they are.
+     */
+    records?: "current" | "restarting";
+}): Promise<number>;
+/**
+ * Brings what the tree at `root` holds of splates up to `release`, this one
+ * by default: its splates skill, through `bunx skills add` from the
+ * release's tag, and an older config moved to where this one reads it. The
+ * records and any server serving them are left alone, so it suits a task's
+ * worktree, where a ship's bump runs it once the new splates is installed.
+ */
+export declare function refresh({ root, fs, ps, log, release, }: {
+    /** The tree to bring up: the main tree, or a task's worktree. */
+    root: string;
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    release?: string;
+}): Promise<void>;
+/** {@link refresh}es the tree the process stands in, a task's worktree included. */
+export declare function refreshHere(deps: {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+}): Promise<void>;

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

@@ -0,0 +1,53 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import type { Duration } from "../../../core/time/index.js";
+import type { Served } from "./project";
+import { type Behind, type Release } from "./release";
+/** What `Versions` takes from `dev`'s options. */
+export interface VersionsOptions {
+    /** The version serving. */
+    running: string;
+    /** The latest splates on npm, or null when it cannot say. */
+    newest: () => Promise<string | null>;
+    checkEvery: Duration;
+    /** The last commit to splates's own source, or null outside a checkout. */
+    source: () => Promise<string | null>;
+    sourceEvery: Duration;
+}
+/**
+ * Whether this run of `splates server` is stale: a newer splates on npm, or, run
+ * from a checkout, commits to splates's own source since it started. Each
+ * project's pages are told as a check finds one.
+ */
+export declare class Versions {
+    private readonly served;
+    private readonly log;
+    /**
+     * The last commit to splates's own source as this run started, or null
+     * when it does not run from a checkout of it.
+     */
+    private readonly started;
+    private readonly opts;
+    /** A newer splates on npm, once a check has found one; every page says so. */
+    private newer;
+    /** Commits to that source since, once a check has seen one. */
+    private ahead;
+    /**
+     * Versions for this run, reading splates's source now, so a later commit
+     * to it is what makes this run stale.
+     */
+    static start(served: Map<string, Promise<Served>>, log: Logger, opts: VersionsOptions): Promise<Versions>;
+    private constructor();
+    get running(): string;
+    get release(): Release | null;
+    get behind(): Behind | null;
+    /**
+     * Checks for a newer splates, or, run from a checkout, for commits to its
+     * source, until disposed.
+     */
+    check(): Resource;
+    private checkNpm;
+    private checkSource;
+    /** Tells each project's pages to read it again. */
+    private refresh;
+}

package/vendor/@stringsync/splates-server/setup/area-auto-pick.d.ts

@@ -0,0 +1,7 @@
+import type { SetupArea } from "./setup";
+/**
+ * Auto pick on this machine: a decision model to classify tasks, and the
+ * person's rules from a task's kind and depth to an agent, model and
+ * thinking level, with a dry run on a task to see them work.
+ */
+export declare const AUTO_PICK_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/area-dictation.d.ts

@@ -0,0 +1,3 @@
+import type { SetupArea } from "./setup";
+/** Speaking a prompt instead of typing it, on an OpenAI key of the user's. */
+export declare const DICTATION_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/area-droplet.d.ts

@@ -0,0 +1,3 @@
+import type { SetupArea } from "./setup";
+/** Sets up a server on a Droplet: the box you make once by hand and the bucket beside it that its records are copied into. */
+export declare const DROPLET_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/area-evals.d.ts

@@ -0,0 +1,3 @@
+import type { SetupArea } from "./setup";
+/** Showing a project's evals, from any framework, on the Evals page. */
+export declare const EVALS_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/area-github.d.ts

@@ -0,0 +1,8 @@
+import type { SetupArea } from "./setup";
+/**
+ * Pushing each task's branch to the project's GitHub repository, with a
+ * GitHub App's token that reaches `splates/*` alone, so a task outlives
+ * the machine it runs on. The project's, not the machine's: its steps after
+ * the App read the repository setup is opened from.
+ */
+export declare const GITHUB_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/area-native.d.ts

@@ -0,0 +1,7 @@
+import type { SetupArea } from "./setup";
+/** Claude Code, installed, signed in and on the roster. */
+export declare const CLAUDE_AREA: SetupArea;
+/** Codex, installed, signed in and on the roster. */
+export declare const CODEX_AREA: SetupArea;
+/** Kimi Code, installed, signed in and on the roster. */
+export declare const KIMI_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/area-opencode.d.ts

@@ -0,0 +1,5 @@
+import type { SetupArea } from "./setup";
+/** The name to keep an OpenCode Go key under on this device, beside OpenCode's own copy. */
+export declare const OPENCODE_GO_KEY = "OPENCODE_GO_API_KEY";
+/** OpenCode on an OpenCode Go account, beside the other agents. */
+export declare const OPENCODE_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/area-remote.d.ts

@@ -0,0 +1,3 @@
+import type { SetupArea } from "./setup";
+/** Reaching `splates server` from a phone or another computer, behind Access. */
+export declare const REMOTE_ACCESS_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/area-replica.d.ts

@@ -0,0 +1,3 @@
+import type { SetupArea } from "./setup";
+/** The copy of a project's records `splates server` keeps in a bucket or a folder. */
+export declare const REPLICA_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/area-workers.d.ts

@@ -0,0 +1,5 @@
+import type { SetupArea } from "./setup";
+/**
+ * This machine's worker, which runs every agent.
+ */
+export declare const WORKERS_AREA: SetupArea;

package/vendor/@stringsync/splates-server/setup/areas.d.ts

@@ -0,0 +1,7 @@
+import type { SetupArea } from "./setup";
+/**
+ * Everything that makes up setting splates up on a machine, in the order it
+ * is best done. The page and an agent walk the user through each area one
+ * step at a time.
+ */
+export declare const SETUP_AREAS: readonly SetupArea[];

package/vendor/@stringsync/splates-server/setup/checks.d.ts

@@ -0,0 +1,8 @@
+import type { SetupMachine, SetupStep } from "./setup";
+/** Whether `step` is on the roster for this machine; a throw reading that hides it. */
+export declare function listed(step: SetupStep, machine: SetupMachine): Promise<boolean>;
+/** A step's check, a throw turned into the problem it reports. */
+export declare function checked(step: SetupStep, machine: SetupMachine): Promise<{
+    done: boolean;
+    problem: string | null;
+}>;

package/vendor/@stringsync/splates-server/setup/fields.d.ts

@@ -0,0 +1,69 @@
+import type { SetupMachine, SetupStep } from "./setup";
+/** `step`'s fields as the page draws them. */
+export declare function fieldsOf(step: SetupStep, machine: SetupMachine): Promise<FieldProgress[]>;
+/** What `step`'s page asks on this machine. */
+export declare function fieldsIn(step: SetupStep, machine: SetupMachine): Promise<readonly StepField[]>;
+/**
+ * One thing a step's page asks. `name` keys its answer, and for a cred is
+ * the cred's own name, as `OPENAI_API_KEY`, which Next saves for the device
+ * before it submits, so a step's `submit` reads it from `machine.device`.
+ */
+export type StepField = {
+    kind: "cred";
+    name: string;
+    label: string;
+    help?: string;
+    /**
+     * May be left unpasted, as a key with another way to the same end;
+     * the step's check then says whether it is done.
+     */
+    optional?: boolean;
+} | {
+    kind: "text";
+    name: string;
+    label: string;
+    placeholder?: string;
+    /** What the box holds to start with, as a list saved before, to edit. */
+    value?: string;
+    /** May be left empty, as a team name only some accounts need. */
+    optional?: boolean;
+} | {
+    kind: "yes-no";
+    name: string;
+    label: string;
+} | {
+    kind: "choice";
+    name: string;
+    label: string;
+    /** What may be picked, read each time the page reads setup. */
+    options(machine: SetupMachine): Promise<readonly StepOption[]>;
+};
+/** One choice a `choice` field lists. */
+export interface StepOption {
+    value: string;
+    label: string;
+}
+/** A field as the page draws it: a choice's options listed, a cred saved or not. */
+export type FieldProgress = {
+    kind: "cred";
+    name: string;
+    label: string;
+    help: string | null;
+    saved: boolean;
+} | {
+    kind: "text";
+    name: string;
+    label: string;
+    placeholder: string | null;
+    value: string | null;
+    optional: boolean;
+} | {
+    kind: "yes-no";
+    name: string;
+    label: string;
+} | {
+    kind: "choice";
+    name: string;
+    label: string;
+    options: StepOption[];
+};

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

@@ -0,0 +1,8 @@
+export { SETUP_AREAS } from "./areas";
+export type { FieldProgress } from "./fields";
+export { OpenCodeSetup } from "./opencode";
+export { OpenCodeSetupRoutes } from "./opencode-routes";
+export { setupProjectAt } from "./project";
+export { SetupRoutes } from "./routes";
+export { type AreaProgress, Setup, type SetupProgress, type StepAnswers, type StepData, type StepProgress, type StepStatus, } from "./setup";
+export type { StepUndoPlan, UndoCred, UndoPlan, } from "./undo";

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

@@ -0,0 +1,25 @@
+import {
+  SETUP_AREAS2,
+  OpenCodeSetup2,
+  OpenCodeSetupRoutes2,
+  setupProjectAt2,
+  SetupRoutes2,
+  Setup2
+} from "../index-7s01973c.js";
+import"../index-5axhdy8c.js";
+import"../index-acbcm66f.js";
+import"../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 {
+  OpenCodeSetup2 as OpenCodeSetup,
+  OpenCodeSetupRoutes2 as OpenCodeSetupRoutes,
+  SETUP_AREAS2 as SETUP_AREAS,
+  Setup2 as Setup,
+  SetupRoutes2 as SetupRoutes,
+  setupProjectAt2 as setupProjectAt
+};

package/vendor/@stringsync/splates-server/setup/opencode-model-error.d.ts

@@ -0,0 +1,3 @@
+/** A safe setup diagnostic; native output must never become one. */
+export declare class OpenCodeModelError extends Error {
+}

package/vendor/@stringsync/splates-server/setup/opencode-models.d.ts

@@ -0,0 +1,44 @@
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { z } from "zod";
+import { type Roster } from "../models";
+import { type OpenCodeRecipe, OpenCodeRecipes } from "./opencode-recipe";
+/** Only metadata commands. The configuration is embedded in the roster argv so
+ * a single document update activates both the models and their experiment policy. */
+export declare class OpenCodeModels {
+    #private;
+    private readonly deps;
+    private readonly metadata;
+    readonly recipes: OpenCodeRecipes;
+    constructor(deps: {
+        fs: Fs;
+        ps: Ps;
+        home: string;
+        roster?: Roster;
+    }, metadata: OpenCodeMetadata);
+    /** The Go models OpenCode lists, by exact id. */
+    catalog(): Promise<string[]>;
+    /** Lists the catalog afresh next time, as after a new login. */
+    invalidate(): void;
+    /**
+     * Writes `selection` as the roster's OpenCode recipe, once OpenCode
+     * confirms the configuration it makes is the one in effect.
+     */
+    save(selection: OpenCodeSelection, signal: AbortSignal): Promise<void>;
+    verifyStored(recipe: OpenCodeRecipe, cwd: string, signal: AbortSignal): Promise<void>;
+    private discover;
+    /**
+     * Confirms through OpenCode's configuration API that `config` is the
+     * configuration in effect, its agents' models included. OpenCode 2's
+     * agent listing is empty, so the configuration is the only witness.
+     */
+    private verify;
+    private roster;
+}
+export declare const openCodeSelection: z.ZodObject<{
+    model: z.ZodString;
+    auxiliary: z.ZodString;
+}, z.core.$strip>;
+export type OpenCodeSelection = z.infer<typeof openCodeSelection>;
+export interface OpenCodeMetadata {
+    run(args: string[], signal: AbortSignal, env?: Record<string, string>, cwd?: string): Promise<string>;
+}

package/vendor/@stringsync/splates-server/setup/opencode-recipe.d.ts

@@ -0,0 +1,33 @@
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { z } from "zod";
+import { Roster } from "../models";
+import type { OpenCodeSelection } from "./opencode-models";
+export interface OpenCodeRecipe extends OpenCodeSelection {
+    config: Record<string, unknown>;
+    env: Record<string, string>;
+    /** The serialized document checked for changes during verification. */
+    raw: string;
+}
+export declare class OpenCodeRecipes {
+    private readonly deps;
+    readonly roster: Roster;
+    constructor(deps: {
+        fs: Fs;
+        ps: Ps;
+        home: string;
+        roster?: Roster;
+    });
+    /** Read storage on every revisit; this never asserts readiness or runs a process. */
+    stored(): Promise<OpenCodeRecipe | null>;
+    private from;
+    unchanged(recipe: OpenCodeRecipe, signal: AbortSignal): Promise<void>;
+    /** Only removes the wizard-owned entry; native authentication is untouched. */
+    disable(signal: AbortSignal): Promise<void>;
+    rawRoster(): Promise<string | null>;
+    /** Filesystem setup refuses to replace a user's explicitly linked roster. */
+    private checkLink;
+}
+export declare function managedArgv(value: unknown): boolean;
+export declare const projectOff = "OPENCODE_CONFIG_PROJECT_DISABLE=1";
+export declare const contentPrefix = "OPENCODE_CONFIG_CONTENT=";
+export declare const id: z.ZodString;

package/vendor/@stringsync/splates-server/setup/opencode-routes.d.ts

@@ -0,0 +1,17 @@
+import type { OpenCodeSetup } from "./opencode";
+import type { OpenCodeSelection } from "./opencode-models";
+/**
+ * What the OpenCode journey's done page does beyond the Setup steps:
+ * start a conversation on the saved models, or take the recipe off the
+ * roster.
+ */
+export declare class OpenCodeSetupRoutes {
+    readonly setup: OpenCodeSetup;
+    constructor(setup: OpenCodeSetup);
+    /**
+     * Checks the saved recipe again in the project's `cwd`, then hands its
+     * main model to `start`, which opens the conversation.
+     */
+    conversation(cwd: string, start: (selection: OpenCodeSelection) => Promise<Response>): Promise<Response>;
+    readonly disable: () => Promise<Response>;
+}

package/vendor/@stringsync/splates-server/setup/opencode.d.ts

@@ -0,0 +1,61 @@
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Roster } from "../models";
+import { OpenCodeModels, type OpenCodeSelection } from "./opencode-models";
+/** How Setup installs OpenCode; nothing from the page reaches the command. */
+export declare const OPENCODE_INSTALL: string[];
+/**
+ * How Setup logs OpenCode in to Go; `OpenCodeSetup.login` types the key at
+ * its prompt, on a terminal of its own.
+ */
+export declare const OPENCODE_LOGIN: string[];
+/**
+ * OpenCode on this machine as Setup reads and changes it: each check runs
+ * OpenCode afresh, so a page loaded after a restart reads what is there.
+ * None sends a prompt; native output never reaches the page, which gets
+ * fixed lines instead.
+ */
+export declare class OpenCodeSetup {
+    #private;
+    private readonly deps;
+    readonly models: OpenCodeModels;
+    constructor(deps: {
+        fs: Fs;
+        ps: Ps;
+        home: string;
+        /** Has open projects read the roster again once it changes. */
+        roster?: () => Promise<void>;
+        /** The machine roster; file storage by default. */
+        agents?: Roster;
+    });
+    /** Where Setup runs OpenCode, away from any project's configuration. */
+    get cwd(): string;
+    /** The installed OpenCode's version, or null when none answers. */
+    version(): Promise<string | null>;
+    /** Installs OpenCode with npm, throwing a line for the page on failure. */
+    install(): Promise<void>;
+    /**
+     * Whether OpenCode keeps a Go credential, from its public auth listing;
+     * false when OpenCode does not answer.
+     */
+    connected(): Promise<boolean>;
+    /**
+     * Hands OpenCode the Go `key` at its own login prompt, on a terminal of
+     * its own, so OpenCode keeps a copy and works outside splates too.
+     */
+    login(key: string): Promise<void>;
+    /** Checks that OpenCode speaks ACP as splates does; sends no prompt. */
+    handshake(cwd?: string, env?: Record<string, string>): Promise<void>;
+    /** Saves `selection` as the roster's OpenCode recipe. */
+    choose(selection: OpenCodeSelection): Promise<void>;
+    /**
+     * Checks the saved recipe with OpenCode in `cwd`: its models still
+     * listed, its configuration in effect, ACP answering. Sends no prompt.
+     */
+    verify(cwd?: string): Promise<OpenCodeSelection>;
+    /** Whether the recipe on the roster is the one `verify` last passed. */
+    ready(): Promise<boolean>;
+    /** Takes the recipe off the roster; OpenCode's own login stays. */
+    disable(): Promise<void>;
+    prepare(): Promise<string>;
+    private command;
+}

package/vendor/@stringsync/splates-server/setup/project.d.ts

@@ -0,0 +1,10 @@
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { SetupProject } from "./setup";
+/**
+ * The project at `root` as setup reads it: its config and remotes, afresh,
+ * and, from `records`, its replica and creds.
+ */
+export declare function setupProjectAt(root: string, { fs, ps }: {
+    fs: Fs;
+    ps: Ps;
+}, records?: Pick<SetupProject, "replica" | "kept">): SetupProject;

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

@@ -0,0 +1,31 @@
+import type { Setup } from "./setup";
+/**
+ * How the page reads this machine's setup and does its steps. The machine's,
+ * shared by every page on the server, but for the steps that set up the
+ * repository of the project a request names. Each handler is a property, so
+ * `dev` hands them straight to its routes.
+ */
+export declare class SetupRoutes {
+    #private;
+    constructor(setupFor: (request: Request) => Promise<Setup>);
+    /** Every step checked, by area, and the one to do next. */
+    readonly read: (request: Request) => Promise<Response>;
+    /** Marks setup seen, so the page stops nudging towards it. */
+    readonly see: (request: Request) => Promise<Response>;
+    /**
+     * Does what the step `/api/setup/:step/next` names needs with the
+     * answers its page sends, answering the fresh progress, or a 422 whose
+     * message is the one line the page shows under its fields.
+     */
+    readonly next: (request: Request) => Promise<Response>;
+    /**
+     * What undoing the area `/api/setup/:area/undo` names would do, for its
+     * page to ask before it goes.
+     */
+    readonly undoPlan: (request: Request) => Promise<Response>;
+    /**
+     * Undoes that area, `{ confirm }` the name its plan asks to be typed,
+     * answering the fresh progress, or a 422 whose message the page shows.
+     */
+    readonly undo: (request: Request) => Promise<Response>;
+}