@stringsync/splates 0.0.61 → 1.13.3

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

@@ -0,0 +1,15 @@
+import type { Conversations } from "./conversations";
+/** The conversations and saved agent defaults offered to the page. */
+export declare function listing(all: Conversations): Promise<{
+    agents: {
+        id: string;
+        name: string;
+        models: {
+            id: string;
+            name: string;
+        }[];
+        settings: import("./state").Setting[];
+        limits: import("./state").Limit[];
+    }[];
+    conversations: import("./state").ConversationState[];
+}>;

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

@@ -0,0 +1,117 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import { type Eventful } from "../../../core/events/index.js";
+import { type Timer } from "../../../core/time/index.js";
+import type { ProcessHandle } from "../agents";
+import type { Log } from "../storage";
+import type { Entry } from "./entry";
+import { type Ask, type ConversationState } from "./state";
+/** The log format this version reads and writes. */
+export declare const LOG_FORMAT = 1;
+/** What a `ConversationLog` says of its saves. */
+export interface ConversationLogEvents extends Record<string, unknown> {
+    /** A save reached the log: `savedThrough` may have moved. */
+    saved: undefined;
+}
+/**
+ * A conversation's log, an entry each: `write` each entry as it happens,
+ * and `replay` the log to read the conversation back.
+ */
+export declare class ConversationLog implements Eventful<ConversationLogEvents> {
+    readonly log: Log<Entry>;
+    private readonly dispatcher;
+    readonly events: import("../../../core/events/index.js").Events<ConversationLogEvents>;
+    /** The entries not yet appended to the log, each with its seq. */
+    private readonly unsaved;
+    private saving;
+    private readonly saves;
+    /** The seq of the agent's frame being handled; 0 before the first. */
+    private seq;
+    /** The seq of the last entry the log holds. */
+    private lastSaved;
+    /** Raised at each new process, so a save of the last one's entries moves no seq of this one's. */
+    private process;
+    constructor(log: Log<Entry>, timer: Timer);
+    /**
+     * The highest seq every entry at or under which the log holds: the seq
+     * before the first unsaved entry, or the last saved one with none unsaved.
+     */
+    get savedThrough(): number;
+    /** Stamps what is written from now on with frame `seq`. */
+    heard(seq: number): void;
+    /**
+     * Call as a new process starts in the conversation, before its first
+     * frame: `savedThrough` then counts only that process's frames.
+     */
+    relaunched(): void;
+    /**
+     * What the log adds up to, read back: the conversation as its entries
+     * left it, stopped, whatever it was doing, unless its process is still
+     * out there (`live`), in which case it is left as it stands for whoever
+     * takes the process back, or `stopped` once nobody can. Null for a log
+     * that does not start one.
+     */
+    replay(): Promise<Replayed | null>;
+    /**
+     * Leaves `replayed` as a conversation whose process is gone: its turn cut
+     * short, its commands ended, its question unanswered, and, for one read
+     * back live, an `end` so the next read finds it stopped too.
+     */
+    stopped(replayed: Replayed, error?: string | null): Promise<void>;
+    /** Appends `entry`, with whatever else is written before the next save. */
+    write(entry: Entry): void;
+    /** Settles once everything written so far is in the log. */
+    flush(): Promise<void>;
+    /** Deletes the log, once the last save has reached it. */
+    remove(): Promise<void>;
+}
+/** What a log read back says of its conversation, beyond its state. */
+export interface Replayed {
+    state: ConversationState;
+    /** The agent's session, once it opened one. */
+    session: string | null;
+    /** Explicit requested model, including failed selections. */
+    model: string | null;
+    /** Original session directory, independent of task moves. */
+    sessionCwd: string | null;
+    /** Where it runs; null for a log too old to say. */
+    cwd: string | null;
+    /** Its settings as last set, by id, for the resumed session to match. */
+    picks: Record<string, string>;
+    /** Its process, still running on a worker; null once it is gone. */
+    live: Live | null;
+    /** Whether the log says a turn is running. */
+    running: boolean;
+    /** Whether reading it back cut that turn short, its process being gone. */
+    cut?: boolean;
+    /**
+     * Whether what was said while it started waits unheard, the server
+     * having gone down before its session opened, for the next run to say.
+     */
+    unsaid?: boolean;
+    /** When the log last said anything happened; null for one that never did. */
+    last: string | null;
+}
+/** What a log read back live says of the process to take back. */
+export interface Live {
+    handle: ProcessHandle;
+    /** The last frame the log holds, for the worker to replay on from. */
+    held: number;
+    /** The highest request id this side sent, past which the next stream numbers its own. */
+    lastId: number;
+    /** The prompt request still open, by its id; null when no turn waits on one. */
+    prompt: number | null;
+    /** What the agent is asking, and the request id to answer it on, when known; null for nothing. */
+    ask: {
+        rpc: acp.JsonRpcId | null;
+        ask: Ask;
+    } | null;
+    /** Whether the agent takes a prompt into its running turn. */
+    steers: boolean;
+    /** Whether the agent takes images in a prompt. */
+    sees: boolean;
+    /** Whether the agent has said a turn ended, so one it starts can end. */
+    tells: boolean;
+    /** Whether the agent says on its session list when a turn ends. */
+    follows: boolean;
+}
+export type { Entry } from "./entry";

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

@@ -0,0 +1,23 @@
+import type { Attached, ConversationState, Image, Message, Sent } from "./state";
+/** What the person said, `at`: what they sent with it, then their words. */
+export declare function said(text: string, at: string | null, sent?: Sent[]): Message;
+/** How many of `messages` went out, as the thread shows them. */
+export declare function sent(messages: Message[]): number;
+/** A prompt entry's images and files, each left out of the log when there are none. */
+export declare function shown(sent: Sent[]): {
+    images?: Image[];
+    files?: Attached[];
+};
+/** The words of `message`, without what was sent with them. */
+export declare function textOf(message: Message): string;
+/**
+ * Whether the person's last word to the conversation was its checkpoint, so
+ * `[SPLATES RESUME]` carries it on.
+ */
+export declare function paused({ messages }: ConversationState): boolean;
+/** Marks up to `count` queued messages as gone out, all by default. */
+export declare function delivered(messages: Message[], count?: number, at?: string): void;
+/** Removes the `index`th queued message, returning it if there was one. */
+export declare function takeBack(messages: Message[], index: number): Message | null;
+/** What an error says, whether it is an `Error` or only shaped like one. */
+export declare function messageOf(error: unknown): string;

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

@@ -0,0 +1,38 @@
+import type { LaneRecord } from "../board";
+import type { ConversationState } from "./state";
+/**
+ * What a conversation goes by: its real name (see `realName`), else a
+ * stand-in until it has one: the first line of what the person first said,
+ * else "Not started".
+ */
+export declare function nameOf(conversation: ConversationState, lanes: readonly LaneRecord[]): string;
+/**
+ * The name a conversation has earned, or null: the name the person gave it,
+ * else the lanes it was started on, so an orchestrator's follows a lane's
+ * renames and keeps them through a task it does itself, else "Groomer" for
+ * the project's groomer (see `grooms`), else the task its
+ * agent holds, so it follows the agent from task to task, or held last, so a
+ * finished task keeps its name until the agent takes another, else the
+ * agent's title.
+ */
+export declare function realName(conversation: ConversationState, lanes: readonly LaneRecord[]): string | null;
+/**
+ * Whether a conversation goes by the task its agent holds or held last, as
+ * `nameOf` names it.
+ */
+export declare function namedForTask(conversation: ConversationState): boolean;
+/** The persistent agent's role the project's groomer is kept for. */
+export declare const GROOMER_ROLE = "groomer";
+/**
+ * Whether a conversation is the project's groomer: kept for its role, or,
+ * from before persistent agents, opened on `[SPLATES GROOM #N]`.
+ */
+export declare function grooms(conversation: ConversationState): boolean;
+/** What each `[SPLATES LANE ...]` the person's first words start with names. */
+export declare function lanesOf(conversation: ConversationState): string[];
+/**
+ * The first line the person said in a conversation, or null before they say
+ * any, past the `[SPLATES AUTO]` an Auto start led its first prompt with
+ * before Auto went.
+ */
+export declare function openingOf(conversation: ConversationState): string | null;

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

@@ -0,0 +1,87 @@
+import type { IdProvider } from "../../../core/id/index.js";
+import type { Fs, Lock } from "../../../core/system/index.js";
+import type { Timer, WallClock } from "../../../core/time/index.js";
+import type { Agent, Launch, Launcher, SessionServers, Watch } from "../agents";
+import type { ArtifactLimits } from "../artifacts";
+import type { Limits, Offered } from "../models";
+import type { Prices } from "../prices";
+import type { Spend } from "../spend";
+import type { Adherence, Outcomes } from "../stats";
+import type { Storage } from "../storage";
+import type { WorkerMachine } from "../workers";
+import type { ConversationPlacer, ProjectRoster } from "./host";
+import type { Limit } from "./state";
+export interface ConversationsOptions {
+    /** The ledger each finished turn's dollars are added to, priced at `prices`; none keeps no ledger. */
+    spend?: {
+        ledger: Spend;
+        prices: Prices;
+    };
+    fs?: Fs;
+    /** Kimi Code's home (`~/.kimi-code`), whose session logs supply its tokens. */
+    kimiHome?: string;
+    /** Where the conversations are kept; the files in `dir`, on `fs`, by default. */
+    storage?: Storage;
+    /** How many bytes of artifacts each may keep; `ARTIFACT_LIMITS` by default. */
+    artifacts?: ArtifactLimits;
+    ids?: IdProvider;
+    /** What starts agents, when nothing takes one back after a restart; this process by default. */
+    launch?: Launch;
+    /** What starts agents and takes them back after a restart, over `launch`: a worker. */
+    launcher?: Launcher;
+    /**
+     * Where each agent waits for a place on a worker, which it then starts
+     * on: one another agent started for a free one, one the person started
+     * for any worker up. With none, every one starts at once on `launcher`.
+     */
+    placer?: ConversationPlacer;
+    /**
+     * Where agents run, which their background output is read from; this
+     * machine by default.
+     */
+    machine?: WorkerMachine;
+    /**
+     * Held while each agent starts, shared by every project's conversations
+     * so no two start at once; one of their own by default.
+     */
+    starting?: Lock;
+    timer?: Timer;
+    clock?: WallClock;
+    /** What watches the agents' commands for what they do to git; none by default. */
+    watch?: Watch | null;
+    /** Where what each agent's sessions offer is kept across projects; nowhere by default. */
+    offered?: Offered | null;
+    /** Where each agent's plan limits are kept across projects; nowhere by default. */
+    limits?: Limits | null;
+    /**
+     * Where how each conversation followed the splates skill is kept across
+     * projects, judged as each turn ends; nowhere by default.
+     */
+    adherence?: Adherence | null;
+    /**
+     * Where how each task ended is kept across projects, credited with the
+     * turn it ended in once that turn ends; nowhere by default.
+     */
+    outcomes?: Outcomes | null;
+    /**
+     * Asks an agent that does not send its plan's windows for them, after
+     * each of its turns; none by default.
+     */
+    readLimits?: ((agent: Agent) => Promise<Limit[]>) | null;
+    /**
+     * The main tree, where a conversation carries on once its task's worktree
+     * is gone, as when the task landed while `splates server` was not there to hear
+     * of it; without it, such a conversation cannot resume.
+     */
+    root?: string | null;
+    /**
+     * The splates projects on this machine, for a prompt's `#slug` to name one
+     * by; none by default.
+     */
+    projects?: ProjectRoster | null;
+    /**
+     * The MCP servers each session is offered, beyond the agent's own, shared
+     * across projects like the browser they serve; none by default.
+     */
+    servers?: SessionServers | null;
+}

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

@@ -0,0 +1,14 @@
+import type { Lock } from "../../../core/system/index.js";
+import type { Timer } from "../../../core/time/index.js";
+import { type Agent, type Launcher, type Session } from "../agents";
+import type { Conversation } from "./conversation";
+/**
+ * The sessions `agents` hold in `cwd` outside splates, the latest first:
+ * those none of `known` has brought in. An agent that cannot list its
+ * sessions lists none.
+ */
+export declare function outside(known: readonly Conversation[], agents: readonly Agent[], cwd: string, { launch, timer, starting, }: {
+    launch: Launcher["launch"];
+    timer: Timer;
+    starting: Lock;
+}): Promise<Session[]>;

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

@@ -0,0 +1,2 @@
+/** Whether a # reference names a conversation by its stable UUID. */
+export declare function conversationReference(called: string): boolean;

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

@@ -0,0 +1,109 @@
+import { Everywhere } from "../projects";
+import type { Project } from "../server/shared";
+import type { Conversations } from "./conversations";
+import { type ConversationsHeard } from "./stream";
+/**
+ * How a project's page talks to agents: starting, prompting and steering its
+ * conversations, and hearing each change to them as it streams. Spread its
+ * handlers into the project's routes, as `serveProject` does.
+ */
+export declare class ConversationRoutes {
+    #private;
+    constructor(project: Project | null, conversations: Conversations | null, everywhere?: Everywhere | null, scratchRoot?: string | null);
+    /**
+     * Tells `heard` of each change a page's stream hears, at the same beat,
+     * until the returned function is called.
+     */
+    listen(heard: ConversationsHeard): () => void;
+    held(): Conversations;
+    /**
+     * Asks every conversation at work for a checkpoint, or only those `only`
+     * names by id, without waiting on the agents, passing over the idle ones,
+     * whose turn has ended already: one whose task is merging
+     * gets to finish the merge first. While one is still asked, the
+     * checkpoint under way stands, and nothing is asked again. Answers with
+     * what settles as each asked answers. With `budget`, a worker budget
+     * hard stop's reason, it asks those `only` names for the budget, beside
+     * any checkpoint under way.
+     */
+    readonly checkpoint: (only?: string[], budget?: string | null) => Promise<Promise<void>[]>;
+    /** Asks the agents that do not send their limits for them, now and then. */
+    readonly refreshLimits: () => Promise<Response>;
+    /** Saves a setting a new conversation's agent starts with, before one starts. */
+    readonly chooseDefault: (request: Request) => Promise<Response>;
+    readonly listConversations: () => Promise<Response>;
+    /**
+     * What every conversation says of `?q=`'s words, by its id, for ⌘K: a
+     * listing's summaries leave most of the words out.
+     */
+    readonly searchConversations: (request: Request) => Promise<Response>;
+    /** One conversation whole, as a listing sends only summaries. */
+    readonly showConversation: (request: Request) => Promise<Response>;
+    /** The tree a terminal opens in: `?task=`'s worktree, or the main tree. */
+    readonly terminalTree: (request: Request) => Promise<string>;
+    readonly startConversation: (request: Request) => Promise<Response>;
+    /**
+     * The sessions the agents hold in `?task=`'s tree that no conversation
+     * does, such as ones started in their CLI, to bring in.
+     */
+    readonly listSessions: (request: Request) => Promise<Response>;
+    /** Brings in a session an agent holds, as a conversation in `task`'s tree. */
+    readonly bringSession: (request: Request) => Promise<Response>;
+    readonly moveConversation: (request: Request) => Promise<Response>;
+    readonly promptConversation: (request: Request) => Promise<Response>;
+    /**
+     * The person allows the agent's run-command card that runs the whole test
+     * suite: one run of it, outside a merge's gate. The card's Allow then
+     * tells the agent, as for any command.
+     */
+    readonly approveSuite: (request: Request) => Promise<Response>;
+    readonly conversationAttachment: (request: Request) => Promise<Response>;
+    readonly conversationArtifact: (request: Request) => Promise<Response>;
+    readonly answerConversation: (request: Request) => Promise<Response>;
+    readonly cancelConversation: (request: Request) => Promise<Response>;
+    /**
+     * Checkpoints a running agent for the person and leaves it stopped,
+     * answering without waiting on the agent; one whose task is merging gets
+     * to finish the merge first.
+     */
+    readonly pauseConversation: (request: Request) => Promise<Response>;
+    /**
+     * Starts a conversation's agent again in a new session on its task,
+     * answering once it is told to claim the task.
+     */
+    readonly restartConversation: (request: Request) => Promise<Response>;
+    /**
+     * Takes a conversation off its task, its agent stopped, for another to
+     * take on, answering with the prompt that has the next one claim it.
+     */
+    readonly handOffConversation: (request: Request) => Promise<Response>;
+    /** What a background command prints, as it prints it, until it ends. */
+    readonly backgroundOutput: (request: Request) => Promise<Response>;
+    readonly stopBackground: (request: Request) => Promise<Response>;
+    readonly unqueueConversation: (request: Request) => Promise<Response>;
+    readonly sendQueuedNow: (request: Request) => Promise<Response>;
+    readonly chooseSetting: (request: Request) => Promise<Response>;
+    readonly switchAutoPick: (request: Request) => Promise<Response>;
+    readonly renameConversation: (request: Request) => Promise<Response>;
+    readonly markUnread: (request: Request) => Promise<Response>;
+    readonly markRead: (request: Request) => Promise<Response>;
+    readonly pinConversation: (request: Request) => Promise<Response>;
+    readonly reparentConversation: (request: Request) => Promise<Response>;
+    readonly archiveConversation: (request: Request) => Promise<Response>;
+    readonly addArtifact: (request: Request) => Promise<Response>;
+    readonly removeArtifact: (request: Request) => Promise<Response>;
+    readonly deleteArtifactVersion: (request: Request) => Promise<Response>;
+    readonly conversationEvents: () => Promise<Response>;
+    disposeAsync(): Promise<void>;
+    /** Where a conversation for `task` runs, as `treeOf` says. */
+    private treeFor;
+    /** The project task-only routes work on, never General's null one. */
+    private projectService;
+    /**
+     * Whether a task landing on `base` is a part of `task`, or a part of one
+     * of its parts, following each base back while it is a task's branch.
+     */
+    private isPartOf;
+    /** The conversation a `/api/conversations/<id>` path names. */
+    private conversationAt;
+}

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

@@ -0,0 +1,15 @@
+import type { ConversationState } from "./state";
+/**
+ * What a conversation's words hold of a search: a line around the first
+ * place each word is found in them, by the word. Words it lacks are left out.
+ */
+export type Said = Record<string, string>;
+/** The words a search of `query` matches, each lowercase, every one needed. */
+export declare function wordsOf(query: string): string[];
+/**
+ * What `state`'s messages say of `words`, for ⌘K to match where a listing's
+ * summary has left the words out; null when they say none of them.
+ */
+export declare function saidIn(state: ConversationState, words: string[]): Said | null;
+/** One line of `body` around `length` characters at `at`. */
+export declare function snippetOf(body: string, at: number, length: number): string;

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

@@ -0,0 +1,19 @@
+import { type Used } from "../spend";
+import type { Conversation } from "./conversation";
+import type { ProjectRoster } from "./host";
+import type { ConversationsOptions } from "./options";
+import type { ConversationState } from "./state";
+/**
+ * Adds the dollars the turn that took `conversation` from `before` cost to
+ * `spend`'s ledger, under the project whose main tree is `root`, or the
+ * conversation's own tree.
+ */
+export declare function spent(spend: NonNullable<ConversationsOptions["spend"]>, conversation: Conversation, { before, turnsBefore, root, projects, }: {
+    before: Used;
+    /** How many turns OpenCode had said it ran before it. */
+    turnsBefore: number;
+    root: string | null;
+    projects: ProjectRoster | null;
+}): Promise<void>;
+/** What `state` has used so far, for pricing the turn between two such readings. */
+export declare function usedOf(state: ConversationState): Used;