@stringsync/splates 0.0.45 → 0.0.47

package/load-config.d.ts

@@ -1,44 +0,0 @@
-import { type Fs } from "webappwiz/system";
-import type { Config } from "./config.js";
-import { Git } from "./git.js";
-/** 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. Systems live in `splates.systems.ts` now: a config that still names
-     * them is read without them, so `splates update` can run to move them.
-     */
-    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;
-    /**
-     * What the TypeScript file `file` at `root` exports as its default, unchecked,
-     * or nothing when there is no such file. Read afresh whenever the file has
-     * changed, so a long-running `splates server` sees an edit without a restart.
-     */
-    importDefault(root: string, file: string): Promise<Record<string, unknown>>;
-}

package/log.d.ts

@@ -1,14 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Journal } from "./journal.js";
-/** Enough to cover a session's worth of work without scrolling. */
-export declare const DEFAULT_COUNT = 20;
-export interface LogOptions {
-    /** How many of the most recent entries to show. */
-    count?: number;
-    /** Print the entries as JSON instead of a table. */
-    json?: boolean;
-}
-export declare function log({ journal, log }: {
-    journal: Journal;
-    log: Logger;
-}, { count, json }?: LogOptions): Promise<void>;

package/machine.d.ts

@@ -1,42 +0,0 @@
-import type { Fs } from "webappwiz/system";
-/** How hard the machine `splates server` runs on is working right now. */
-export interface MachineReading {
-    /** What the page calls the machine: "Mac" on macOS, else "machine". */
-    kind: "Mac" | "machine";
-    /** The share of CPU time busy since the reading before, 0 to 1. */
-    cpu: number;
-    /** The share of memory in use, 0 to 1. */
-    memory: number;
-    /** The load average over the last minute. */
-    load: number;
-    cores: number;
-    /** The hottest CPU sensor in °C, or null where none can be read. */
-    temperature: number | null;
-}
-/** Where a reading comes from: the OS by default, a fake in tests. */
-export interface MachineSensors {
-    platform: NodeJS.Platform;
-    cpus(): {
-        times: Record<"user" | "nice" | "sys" | "idle" | "irq", number>;
-    }[];
-    loadavg(): number[];
-    freemem(): number;
-    totalmem(): number;
-    temperature(): Promise<number | null>;
-}
-/**
- * Reads the machine on each ask, its CPU share taken over the time since the
- * ask before, or since it was made for the first.
- */
-export declare class Machine {
-    #private;
-    constructor(sensors: MachineSensors);
-    read(): Promise<MachineReading>;
-}
-/**
- * The machine this process runs on. Temperature is read from Linux's thermal
- * zones, and from the CPU die sensors on Apple Silicon; null elsewhere.
- */
-export declare function osSensors(fs: Fs): MachineSensors;
-/** The hottest of Linux's thermal zones under `root`, in °C, or null for none. */
-export declare function thermalZones(fs: Fs, root: string): Promise<number | null>;

package/merge.d.ts

@@ -1,35 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs, HeavyCap, Lock } from "webappwiz/system";
-import type { Config } from "./config.js";
-import type { Facts } from "./events.js";
-import type { Git } from "./git.js";
-import type { Shell } from "./shell.js";
-import { type Slots } from "./slots.js";
-import type { Todos } from "./todos.js";
-import type { FailedTest } from "./worktree.js";
-import type { WorktreeService } from "./worktree-service.js";
-/**
- * Lands the current worktree's branch on its base branch, trunk unless the
- * task was created with `--base`. Never a merge commit: it rebases onto the
- * base, runs the gate there, and fast-forwards the base with
- * `git merge --ff-only`, in whichever worktree has the base checked out.
- * History stays linear.
- */
-export declare function merge({ service, git, lock, shell, config, log, todos, fs, slots, heavy, }: {
-    service: WorktreeService;
-    git: Git;
-    lock: Lock;
-    shell: Shell;
-    config: Config;
-    log: Logger;
-    todos: Todos;
-    fs: Fs;
-    slots: Slots;
-    heavy: HeavyCap;
-}, cwd: string, facts?: Partial<Facts["merge"]>): Promise<void>;
-/**
- * The tests a runner reported as failing, each with what it said, which the
- * tail cuts off. Another runner prints none, so the tail alone is what the
- * agent gets.
- */
-export declare function failedTests(output: string): FailedTest[];

package/migrate-config.d.ts

@@ -1,31 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs } from "webappwiz/system";
-import { type SystemsFile } from "./systems.js";
-/**
- * Moves the systems an older `splates.config.ts` names into `splates.systems.ts`,
- * taking the `systems` key out of the config. Does nothing when the config
- * names none. Rewrites the config only once re-importing it shows the rest of
- * it unchanged, and puts it back otherwise. Answers with the exit code to end
- * on.
- */
-export declare function moveSystems({ root, fs, log, }: {
-    /** The repository's main tree. */
-    root: string;
-    fs: Fs;
-    log: Logger;
-}): Promise<number>;
-/**
- * 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 rewrite as it is, since
- * `defineConfig` still works. Rewrites it only once re-importing it shows it
- * unchanged, and puts it back otherwise.
- */
-export declare function typeConfig({ root, fs, log, }: {
-    /** The repository's main tree. */
-    root: string;
-    fs: Fs;
-    log: Logger;
-}): Promise<void>;
-/** A `splates.systems.ts` that names `systems`, keys unquoted where they can be. */
-export declare function systemsSource(systems: SystemsFile): string;

package/models.d.ts

@@ -1,24 +0,0 @@
-import type { Fs } from "webappwiz/system";
-import type { Setting } from "./conversations.js";
-/**
- * Where `model` is among `settings`: the model setting's id, and the value
- * there whose value or name it is; null when none offers it. Provider-qualified
- * values always require an exact ID; `exact` also disables all display aliases.
- */
-export declare function modelOption(settings: Setting[], model: string, exact?: boolean): {
-    setting: string;
-    value: string;
-} | null;
-/**
- * The model `settings` has picked, by its name, `Opus 5.5`; for a default,
- * the model its description says it stands for. Null when none is offered.
- */
-export declare function pickedModel(settings: Setting[]): string | null;
-/**
- * The agent the conversation logged at `log` runs, and the model it last had
- * picked; null when there is no such log.
- */
-export declare function ranWith(log: string, fs: Fs): Promise<{
-    agent: string;
-    model: string | null;
-} | null>;

package/needs.d.ts

@@ -1,115 +0,0 @@
-import { Duration } from "webappwiz/time";
-import type { ConversationState } from "./conversations.js";
-import { type Question } from "./plan.js";
-import type { Details } from "./show.js";
-/**
- * What an agent needs from the person, by how much it costs to leave it:
- * `waiting` has stopped on them, `assuming` goes ahead on a guess an answer
- * may overturn, `working` needs nothing yet, and `idle` is not doing anything.
- */
-export type Need = {
-    kind: "waiting";
-    why: Why;
-    /**
-     * What to act on: the ask, what a review asks you to look at, the
-     * first open question, or the failure.
-     */
-    subject: string;
-    /** When it stopped, where that is known. */
-    since: string | null;
-    /** The task's open questions, none for a task-less conversation. */
-    questions: Question[];
-    /** The agent handed out by this one it waits for, lifted onto it. */
-    via?: string;
-} | {
-    kind: "assuming";
-    /** The first open question. */
-    subject: string;
-    questions: Question[];
-    /** The agent handed out by this one whose questions it relays. */
-    via?: string;
-} | {
-    kind: "working";
-    /** The next step under `## Next`, else the Goal's first line. */
-    subject: string | null;
-} | {
-    kind: "idle";
-};
-/** One agent the page shows: a conversation, its task, or both. */
-export interface Needing {
-    conversation: ConversationState | null;
-    task: Details | null;
-    need: Need;
-}
-/**
- * Every listed conversation, and every live task no listed conversation runs
- * in (an external agent, run outside the page) and none is about to, with
- * what each needs: those waiting first,
- * oldest stop first, then those assuming, most open questions first, then the
- * rest in the order given.
- */
-export declare function needs({ tasks, conversations, }: {
-    tasks: Details[];
-    conversations: ConversationState[];
-}): Needing[];
-/**
- * Why an agent waits: a live ACP ask (a permission or a form), a review it
- * escalated for, any other escalation, open questions it ended its turn on,
- * a failure, or for a task, no agent left on it (see `abandoned`).
- */
-export type Why = "ask" | "review" | "escalated" | "questions" | "failed" | "abandoned";
-/**
- * Every live task no listed conversation runs in, an external agent's, with
- * what it needs, before `answeredThrough`. One handed to an agent shows once
- * its conversation starts.
- */
-export declare function externals(tasks: Details[], conversations: ConversationState[]): Needing[];
-/** What a task no listed conversation runs in needs: see `externals`. */
-export declare function needOfExternal(task: Details, conversations: ConversationState[]): Need;
-/**
- * Whether no agent is left on an external task, for certain: the page
- * conversation whose agent last took it is archived, or gone with the oldest
- * archived ones, and no agent outside the page has taken it since. What it
- * says of it, and since when; null while an agent may yet be on it. A
- * conversation listed on another task may still have a subagent on this
- * one, so only going quiet tells of it.
- */
-export declare function abandoned(task: Details, conversations: ConversationState[]): {
-    subject: string;
-    since: string | null;
-} | null;
-/**
- * How long an external agent's task goes without a sign of it at work before
- * it shows as quiet: long enough for a test run or a long think.
- */
-export declare const QUIET_AFTER: Duration;
-/**
- * When an external agent's task last showed a sign of its agent at work, once
- * that is `QUIET_AFTER` ago at `now`; null while it has lately, or nothing
- * says. Only an agent taken to be at work goes quiet: one that waits on the
- * person is still for a reason.
- */
-export declare function quietSince({ task, need }: Pick<Needing, "task" | "need">, now: number): string | null;
-/**
- * What one agent needs, from its conversation (null for an agent the page
- * does not run) and the task it is in (null for the main tree).
- */
-export declare function need(task: Details | null, conversation: ConversationState | null): Need;
-/**
- * `found` with each agent that answers to another conversation waiting on
- * that one rather than on the person: only the person answers its asks, so
- * one waits on that one's row, where they show, whatever it is doing; its
- * escalations reach the person through that one's reports, so one waits on
- * that one's row once it is idle, having relayed it, naming the agent, and
- * while it works on regardless, that one goes ahead with them owed, as an
- * assuming agent does. A failure stays the agent's own, since nothing tells
- * that one of it.
- */
-export declare function answeredThrough(found: Needing[], conversations: ConversationState[]): Needing[];
-/**
- * The conversation an agent answers to, rather than to the person, while the
- * page holds it: the one that handed its conversation the task, or for an
- * external agent, such as a subagent its harness started, the listed one
- * whose agent added its task.
- */
-export declare function answersTo({ conversation, task }: Pick<Needing, "conversation" | "task">, conversations: readonly ConversationState[]): ConversationState | null;

package/notices.d.ts

@@ -1,39 +0,0 @@
-import type { Needing } from "./needs.js";
-/** Something a row did worth telling the person about, away from the page. */
-export interface Notice {
-    row: Needing;
-    title: string;
-    body: string;
-}
-/** Which notices the person asked for, as the page's Notifications settings say. */
-export interface Wants {
-    waiting: boolean;
-    finished: boolean;
-    quiet: boolean;
-    /** Minutes a running agent goes without a word before it counts as quiet. */
-    quietAfter: number;
-}
-/**
- * Tells what changed in the rows since the last look worth notifying of,
- * the same on the page and on the server, which pushes it to a phone the
- * page cannot run on once it leaves the front.
- */
-export declare class Notices {
-    /** By row, what the last look saw; null before the first. */
-    private seen;
-    /**
-     * Compares `rows`, named by `name`, with the last look at `now`, and
-     * returns what changed worth telling, of the kinds `wants` asks for: a
-     * row that came to wait, a conversation that finished its turn, and one
-     * running with no word for the quiet time. The first look tells nothing,
-     * since it has nothing to compare.
-     */
-    look(rows: Needing[], name: (row: Needing) => string, now: number, wants: Wants): Notice[];
-}
-/** What tells `row` apart from the others, in a notification and its click. */
-export declare function keyOf(row: Needing): string;
-/**
- * The first line of `markdown` with its marks taken out, cut to `length`:
- * a notification shows plain text, and a phone only a line or so of it.
- */
-export declare function plain(markdown: string, length: number): string;

package/offered.d.ts

@@ -1,39 +0,0 @@
-import type { Fs } from "webappwiz/system";
-import type { Conversation } from "./conversation.js";
-import type { Setting } from "./conversations.js";
-/**
- * The agent settings offered across projects, with defaults changed only by
- * user selections. Session reports can refresh available options without
- * replacing the values the person picked.
- */
-export declare class Offered {
-    /** `~/.splates/offered.json`, or a test's own. */
-    readonly path: string;
-    private readonly deps;
-    /** Read once, then kept: this process is the one writing it. */
-    private known;
-    /** Set when a newer splates wrote the file, which this one leaves alone. */
-    private newer;
-    /** Writes one after another, so none is lost to another. */
-    private writing;
-    constructor(
-    /** `~/.splates/offered.json`, or a test's own. */
-    path: string, deps: {
-        fs: Fs;
-    });
-    /** Every agent's settings, by its id; none for one never started. */
-    all(): Promise<Record<string, Setting[]>>;
-    /**
-     * Keeps `settings` as what `agent`'s sessions offer from now on, or, with
-     * `preserveChoices`, refreshes options while keeping existing default values.
-     */
-    remember(agent: string, settings: Setting[], { preserveChoices }?: {
-        preserveChoices?: boolean;
-    }): Promise<void>;
-    /** Saves only settings the person selected, leaving other defaults alone. */
-    choose(agent: string, settings: Setting[], ids: string[]): Promise<void>;
-    /** Tracks capabilities separately from explicit choices, including the opening form. */
-    track(conversation: Conversation, changed: () => void, picks?: Record<string, string>): void;
-    private read;
-    private write;
-}

package/opencode-usage.d.ts

@@ -1,37 +0,0 @@
-import type * as acp from "@agentclientprotocol/sdk";
-import type { ConversationState } from "./conversation-state.js";
-/** Observations, never a quota estimate or evidence of an invoice. */
-export interface OpenCodeUsage {
-    turns: ObservedTurn[];
-    costAt: string | null;
-    retry: {
-        attempt: number | null;
-        nextRetryAt: string | null;
-        message: string;
-        type: string | null;
-        status: number | null;
-    } | null;
-}
-/** Null means absent or invalid, including in logs predating instrumentation. */
-export interface ObservedTurn {
-    at: string;
-    until: string | null;
-    firstText: string | null;
-    requested: string | null;
-    confirmed: string | null;
-    cwd: string | null;
-    /** ACP prompt response; per turn, parent session only. */
-    tokens: {
-        input: number | null;
-        output: number | null;
-        cachedRead: number | null;
-        cachedWrite: number | null;
-    } | null;
-}
-export declare function metric(value: unknown): number | null;
-/** End exactly once, including cancellation, failure and worker reattachment. */
-export declare function finishObservation(state: ConversationState, at: string | null): void;
-/** Keep only documented retry fields; provider response bodies are not diagnostics. */
-export declare function safeOpenCodeUpdate(update: acp.SessionUpdate): acp.SessionUpdate;
-/** Snapshot fields independently; optional cache data is not evidence of zero. */
-export declare function observeTokens(state: ConversationState, usage: acp.Usage): void;

package/outcomes.d.ts

@@ -1,114 +0,0 @@
-import type { Fs } from "webappwiz/system";
-import type { Device } from "./conversation-state.js";
-import type { Finding } from "./findings.js";
-import type { Decision } from "./plan.js";
-import { type TaskUsage } from "./task-log.js";
-import type { DiffSize, MergeFailure, RemoveReason } from "./worktree.js";
-/**
- * Every task that has ended on this machine, across projects, in
- * `~/.splates/outcomes.jsonl`, oldest first. Unlike the journal it is never
- * trimmed: a trend needs months of it, and a line per task stays small.
- */
-export declare class Outcomes {
-    /** `~/.splates/outcomes.jsonl`, or a test's own. */
-    readonly path: string;
-    private readonly fs;
-    constructor(
-    /** `~/.splates/outcomes.jsonl`, or a test's own. */
-    path: string, fs: Fs);
-    /**
-     * Beside `path`, the usage of the turns tasks ended in, which `splates
-     * merge` writes its line too early to see. Apart from `path`, so splates
-     * versions that read only that never mistake one for a task.
-     */
-    get turnsPath(): string;
-    record(outcome: Outcome): Promise<void>;
-    list(): Promise<Outcome[]>;
-    /**
-     * Credits the task that `conversation`, logged at `log`, ended last in
-     * its turn from `since` to `until` with what the rest of that turn used,
-     * once the turn has ended and said it. Several ended in one turn: the
-     * last one's is what the turn finished on.
-     */
-    creditTurn(conversation: string, log: string, since: string, until: string): Promise<void>;
-    private get dir();
-}
-/**
- * How one task ended, written as it goes. Its record goes with it, so this is
- * what is left to tell whether tasks are getting easier to land over time.
- */
-export interface Outcome {
-    /** The main tree of the repository the task was in. */
-    project: string;
-    task: string;
-    /** Where it landed or would have: trunk, or `task/<parent>` for a part. */
-    base: string;
-    ended: "merged" | "removed";
-    /** When it was added, as an ISO timestamp. */
-    startedAt: string;
-    /** When it was merged or removed, as an ISO timestamp. */
-    endedAt: string;
-    /** How many times it was handed to a person with questions. */
-    questionRounds: number;
-    /** How many times it was handed to a person to approve. */
-    reviewRounds: number;
-    /** Merges that failed on a conflict, the gate, or a base that would not move. */
-    failedMerges: number;
-    /** `failedMerges` by why each failed. Absent from lines written before it was kept. */
-    failedMergesBy?: Partial<Record<MergeFailure, number>>;
-    /** The questions its plan asked under `## Blocked`. Absent from older lines. */
-    questionsAsked?: number;
-    /** Of those, the ones that offered a `(chosen)` pick and were answered with a choice. */
-    picksAsked?: number;
-    /** Of `picksAsked`, those answered with another choice than the agent's. */
-    picksOverturned?: number;
-    /** Of `picksAsked`, those answered with the agent's choice but with words added. */
-    picksAmended?: number;
-    /** The calls its plan made without asking, under `## Assumptions` or challenged out of it. Absent from older lines. */
-    assumptionsMade?: number;
-    /** Of `assumptionsMade`, those the person challenged. */
-    assumptionsChallenged?: number;
-    /**
-     * Each call its plan made, asked or assumed, with its size and what became
-     * of it. Absent from older lines, whose calls the counts above alone keep.
-     */
-    decisions?: Decision[];
-    /** The systems its changed files fall in, by name. Absent from older lines. */
-    systems?: string[];
-    /** How long it waited on a person, escalated, in milliseconds. Absent from older lines. */
-    waitedMs?: number;
-    /** Why it was removed, when `splates remove --reason` said; null when merged or unsaid. */
-    removedFor?: RemoveReason | null;
-    /** For a merge, each commit's message it landed, oldest first. Absent from older lines. */
-    commits?: string[];
-    /**
-     * How many times the person spoke to its conversation from each layout of
-     * the page while it ran. Absent from older lines.
-     */
-    promptsFrom?: Partial<Record<Device, number>>;
-    /**
-     * What its own turns used, not the rest of its conversation's, the turn it
-     * ended in added from `turnsPath` once `splates server` saw it end. Absent from
-     * older lines, for a task with no conversation log to read, and, as read,
-     * for one with no tokens out, which never kept the turns that did its work.
-     */
-    usage?: TaskUsage;
-    /** How long its agent worked, its turns summed, in milliseconds. Absent as `usage` is. */
-    workedMs?: number;
-    /** What it landed, or for a removed task, what its branch held. Absent from older lines. */
-    size?: DiffSize;
-    /** What went worse than it could have. Absent from older lines, never read as none. */
-    findings?: Finding[];
-    /** The `splates server` conversation that ended it; null for an external agent. */
-    conversation: string | null;
-    /** The agent `splates add --agent` handed it to, if any. */
-    agent: string | null;
-    /** The model it was handed over with, if any. */
-    model: string | null;
-}
-/**
- * How many prompts the person said from each layout in the conversation
- * logged at `log`, from `since` to `until`: a conversation can outlive the
- * task, or come to it already under way.
- */
-export declare function promptsFrom(log: string, fs: Fs, since: string, until: string): Promise<Partial<Record<Device, number>>>;

package/path.d.ts

@@ -1,13 +0,0 @@
-import type { Logger } from "webappwiz/log";
-import type { WorktreeService } from "./worktree-service.js";
-/**
- * Where a task lives, or (with no task) the main tree. Nothing but the path
- * on stdout, so it composes: `cd "$(splates path)"`, `zed -a "$(splates path x)"`.
- * Moving between trees is `cd` and nothing else, and the main tree is the one
- * path a process standing in a worktree cannot otherwise name: git's
- * `--show-toplevel` hands back the worktree it is already in.
- */
-export declare function path({ service, log }: {
-    service: WorktreeService;
-    log: Logger;
-}, task?: string): Promise<void>;