@stringsync/splates 0.0.61 → 1.13.3

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

@@ -0,0 +1,21 @@
+import type { Project } from "../server/shared";
+/**
+ * The API a project's Budget page reads and changes its vet budgets with.
+ * Spread one into the project's routes.
+ */
+export declare class BudgetRoutes {
+    #private;
+    constructor(project: Project);
+    readonly listBudgets: () => Promise<Response>;
+    /** Sets a role's spend, or with none, gives it back to the configs. */
+    readonly setBudget: (request: Request) => Promise<Response>;
+    /**
+     * Raises a role's limits by `tokens` `for` a while. Send `project: true`
+     * to raise a budget every project shares for this project alone.
+     */
+    readonly raiseBudget: (request: Request) => Promise<Response>;
+    /** Stops a role asking anything for a while, like `1d`. */
+    readonly pauseBudget: (request: Request) => Promise<Response>;
+    readonly resumeBudget: (request: Request) => Promise<Response>;
+    readonly endRaise: (request: Request) => Promise<Response>;
+}

package/vendor/@stringsync/splates-server/stats/fact-tasks.d.ts

@@ -0,0 +1,19 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Tasks } from "../board";
+import type { Git } from "../git";
+import type { Journal } from "../records";
+import type { Outcomes } from "./outcomes";
+/**
+ * Queues a task, untriaged, for each of `task`'s gate runs that named failing
+ * tests and each test its passing run timed as slow (see `factTasks`),
+ * journaled so the conversation that merged it shows each as an "Added" line
+ * the person can remove it from. One whose line is queued already is not added
+ * again.
+ */
+export declare function addFactTasks({ git, outcomes, tasks, journal, log, }: {
+    git: Git;
+    outcomes: Outcomes;
+    tasks: Tasks;
+    journal: Journal;
+    log: Logger;
+}, task: string): Promise<void>;

package/vendor/@stringsync/splates-server/stats/finding-facts.d.ts

@@ -0,0 +1,37 @@
+import { type Finding } from "./findings";
+import type { Landed } from "./landed";
+/** One thing that went worse than it could have, as the merged card says it. */
+export interface Fact {
+    text: string;
+    /** "3rd time this week" when it came up before in its project; null otherwise. */
+    again: string | null;
+    /** What it was found from; null for an older outcome's count of failed merges. */
+    finding: Finding | null;
+}
+/** What went worse in a merged task: the gate's turn-aways, and the rest. */
+export interface FoundFacts {
+    /** Null when the gate passed it the first time. */
+    gate: Fact[] | null;
+    /** Most severe first. */
+    findings: Fact[];
+}
+/** A task made of a fact: its line, and what more there is to say. */
+export interface FactTask {
+    subject: string;
+    text: string;
+}
+/** The findings that are not the gate's, the most worth acting on first. */
+export declare const SEVERITY: Finding["kind"][];
+/** What went worse in `landed`, from what its outcome kept. */
+export declare function foundFacts({ outcome, baseline }: Landed): FoundFacts;
+/**
+ * The tasks `splates merge` queues for what went worse in `landed`: one for each
+ * gate run that named the tests it failed on, which a later run passed, so
+ * the test is flaky or was fixed on the way, and one for each test the
+ * passing run timed as slow. The rest the merged card lists (conflicts,
+ * retries, lost connections, the person's own calls) are what a merge goes
+ * through, with nothing in the code to act on.
+ */
+export declare function factTasks(landed: Landed): FactTask[];
+/** The task made of `fact`, found in `task` as it merged. */
+export declare function deferred(task: string, fact: Fact): FactTask;

package/vendor/@stringsync/splates-server/stats/findings.d.ts

@@ -0,0 +1,89 @@
+import type { TimedTest } from "../merge";
+import type { GateFailure } from "../tasks";
+import type { Judged } from "./adherence";
+import type { TaskLog } from "./task-log";
+/** What went worse than it could have, in the order `Finding` lists the kinds. */
+export declare function findings(evidence: Evidence): Finding[];
+/** How often each finding fires: tune a threshold to make its finding fire less or more. */
+export declare const FINDING_THRESHOLDS: {
+    /** A command failing this many times in one task. */
+    readonly repeatedFailures: 3;
+    /** Lines edited this many times over the lines that landed. */
+    readonly churnRatio: 4;
+    /** And at least this many lines edited, so a small task's retouching is not churn. */
+    readonly churnLines: 300;
+    /** A skill check passed less than this share of the times it applied. */
+    readonly adherenceBelow: 0.5;
+    /**
+     * A test in the passing gate run taking longer than this: other agents
+     * load the machine while the gate runs, so a lower
+     * bar would name tests that are slow only while contended.
+     */
+    readonly slowTestSeconds: 20;
+};
+/**
+ * Something that went worse than it could have in one task, kept with what it
+ * names, so a later count can tell how often each kind recurs.
+ */
+export type Finding = 
+/** The gate turned it away, even once. */
+({
+    kind: "gate";
+} & GateFailure)
+/** `splates retry` granted it more merge attempts. */
+ | {
+    kind: "retried";
+    times: number;
+}
+/** The person stopped the agent's turn. */
+ | {
+    kind: "stopped";
+    at: string;
+}
+/** A lost connection cut the agent's turn short. */
+ | {
+    kind: "interrupted";
+    at: string;
+}
+/** The person answered picks with another choice than the agent's. */
+ | {
+    kind: "overturned";
+    picks: number;
+}
+/** One command failed again and again. */
+ | {
+    kind: "repeated_failure";
+    command: string;
+    times: number;
+}
+/** Far more lines edited than landed. */
+ | {
+    kind: "churn";
+    edited: number;
+    landed: number;
+}
+/** A skill check its conversation mostly failed. */
+ | {
+    kind: "adherence";
+    check: string;
+    passed: number;
+    failed: number;
+}
+/** Tests the passing gate run timed over the bar, slowest first. */
+ | {
+    kind: "slow_tests";
+    tests: TimedTest[];
+};
+/** What a task leaves to find in, each part absent when it was not kept. */
+export interface Evidence {
+    gateFailures: GateFailure[];
+    retries: number;
+    picksOverturned: number;
+    log: TaskLog | null;
+    /** Lines the landed diff added and removed; null when unknown. */
+    landedLines: number | null;
+    /** Its conversation's skill checks as last judged; null when unjudged. */
+    adherence: Judged | null;
+    /** Each test the passing gate run timed; empty when its hook wrote no report. */
+    testTimes: TimedTest[];
+}

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

@@ -0,0 +1,12 @@
+export { Adherence } from "./adherence";
+export { BudgetRoutes } from "./budget-routes";
+export { addFactTasks } from "./fact-tasks";
+export { findings } from "./findings";
+export type { Outcome } from "./outcomes";
+export { Outcomes, promptsFrom } from "./outcomes";
+export type { RuleOverrides } from "./overrides";
+export { DevOutcomes } from "./routes";
+export type { Beat, Transcript, Verdict } from "./skill-checks";
+export { CHECKS, splatesCalls } from "./skill-checks";
+export type { Stats } from "./stats";
+export { taskLog } from "./task-log";

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

@@ -0,0 +1,30 @@
+import {
+  CHECKS2,
+  splatesCalls2,
+  Adherence2,
+  BudgetRoutes2,
+  findings2,
+  addFactTasks2,
+  taskLog2,
+  Outcomes2,
+  promptsFrom2,
+  DevOutcomes2
+} from "../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  Adherence2 as Adherence,
+  BudgetRoutes2 as BudgetRoutes,
+  CHECKS2 as CHECKS,
+  DevOutcomes2 as DevOutcomes,
+  Outcomes2 as Outcomes,
+  addFactTasks2 as addFactTasks,
+  findings2 as findings,
+  promptsFrom2 as promptsFrom,
+  splatesCalls2 as splatesCalls,
+  taskLog2 as taskLog
+};

package/vendor/@stringsync/splates-server/stats/landed.d.ts

@@ -0,0 +1,14 @@
+import { type Baseline } from "./baselines";
+import type { Outcome } from "./outcomes";
+/** How a merged task went, beside how its project's tasks went the week before. */
+export interface Landed {
+    outcome: Outcome;
+    /** Its project's tasks over the week to its merge, itself among them; null for none. */
+    baseline: Baseline | null;
+}
+/**
+ * The last merge of `task` in `project`, held against the week up to it, so
+ * the comparison reads the same however long after it is asked. Null when it
+ * never merged there.
+ */
+export declare function landed(outcomes: Outcome[], project: string, task: string): Landed | null;

package/vendor/@stringsync/splates-server/stats/outcomes.d.ts

@@ -0,0 +1,207 @@
+import type { Device, Entry } from "../conversations";
+import type { Decision } from "../plans";
+import { Prices } from "../prices";
+import type { Event } from "../records";
+import type { Log, Storage } from "../storage";
+import type { DiffSize, MergeFailure, MergeTimes, RemoveReason } from "../tasks";
+import type { Finding } from "./findings";
+import { type TaskUsage } from "./task-log";
+/**
+ * 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 {
+    readonly log: Log<Outcome>;
+    /**
+     * The usage of the turns tasks ended in, which `splates merge` writes its
+     * line too early to see; `list` adds each to its task.
+     */
+    readonly turns: Log<TurnUsage>;
+    /**
+     * The merge times and batch membership recovered from the journal; `list` adds each to its task.
+     */
+    readonly merges: Log<MergeTimed>;
+    /** The API list prices that agents saying no cost of their own are priced at. */
+    readonly prices: Prices;
+    constructor(
+    /** The machine's storage, or a test's own. */
+    storage: Storage, prices?: Prices);
+    record(outcome: Outcome): Promise<void>;
+    list(): Promise<Outcome[]>;
+    /**
+     * Gives merged tasks missing merge times or batch membership the
+     * times of the `merge` event `eventsOf(project)` logged as each landed,
+     * written beside the outcomes, as `backfill` writes costs. The event comes
+     * just after the outcome, once the worktree is gone, so its run time takes
+     * in that cleanup too. A task with no such event, or one from before
+     * events kept times, stays untimed; a batch already recovered is skipped on a second run.
+     */
+    backfillMerges(eventsOf: (project: string) => Promise<Event[]>): Promise<void>;
+    /**
+     * Prices at the API list price the tasks that ended before splates did, whose
+     * tokens say no cost: writes each its cost as a turn beside the outcomes,
+     * as `creditTurn` does, leaving alone any whose conversation log
+     * `logOf(project, conversation)` no longer finds or whose model has no
+     * price. A task priced has a cost, so a second run skips it. Only what the
+     * task used by its end is priced, not the turns credited to it after.
+     */
+    backfill(logOf: (project: string, conversation: string) => Promise<Log<Entry>>): Promise<void>;
+    /** `creditTurn` once `conversation`'s log has taken the whole turn. */
+    creditSaved(conversation: {
+        id: string;
+        saved(): Promise<unknown>;
+    }, log: Log<Entry>, since: string, until: string): Promise<void>;
+    /**
+     * Credits the task that `conversation`, logged in `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: Log<Entry>, since: string, until: string): Promise<void>;
+}
+/**
+ * What the rest of the turn a task ended in used, a line of
+ * `~/.splates/outcome-usage.jsonl`, naming its outcome by when it ended.
+ */
+export interface TurnUsage {
+    project: string;
+    task: string;
+    endedAt: string;
+    usage: TaskUsage;
+}
+/**
+ * The merge times of an outcome that landed before outcomes kept them, a
+ * line of `~/.splates/outcome-merges.jsonl`, naming its outcome by when it
+ * ended.
+ */
+export interface MergeTimed {
+    /** Batch membership recovered from the successful merge event. */
+    batch?: string[];
+    project: string;
+    task: string;
+    endedAt: string;
+    merge: MergeTimes;
+}
+/**
+ * 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 tasks sharing its successful landing gate, leader first; absent on solo and older merges. */
+    batch?: string[];
+    /** 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>>;
+    /**
+     * How many of its conflicts each file was in, as far as its record kept
+     * them. Absent from lines written before it was kept, and when none.
+     */
+    conflictedFiles?: Record<string, 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;
+    /**
+     * Each time the person set the model or effort of a conversation Auto pick
+     * started, with the pick it overrode. Absent from older lines, and for a
+     * task Auto pick did not start.
+     */
+    overrides?: PickOverride[];
+    /**
+     * Each question its plan asked, with its size and what became of it. Absent from older lines, whose calls the counts above alone keep.
+     */
+    decisions?: Decision[];
+    /**
+     * The `## Outcome` its plan ended on, as markdown: a summary of what
+     * changed and any pivot from the goal, a demo to trigger and its
+     * verification. Absent from older lines and for a plan with none.
+     */
+    outcome?: string;
+    /** How long it waited on a person to answer, 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 `turns` 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;
+    /** How many agent turns it took, the one it ended in among them. Absent as `usage` is, and from older lines. */
+    turns?: number;
+    /**
+     * What made workers cost it until it ended, its slots' share of each
+     * worker's hours. Absent when it held no slot on one, and from older lines.
+     */
+    workerSpend?: WorkerSpend;
+    /** What it landed, or for a removed task, what its branch held. Absent from older lines. */
+    size?: DiffSize;
+    /** For a merge, how long the merge that landed it queued and ran. Absent from older lines. */
+    merge?: MergeTimes;
+    /** 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;
+}
+/** One time the person moved a conversation off what Auto pick set. */
+export interface PickOverride {
+    /** What they changed. */
+    aspect: "model" | "effort";
+    /** What they set it to. */
+    to: string;
+    /** When, as an ISO timestamp. */
+    at: string;
+    /** The index in the rules of the rule whose pick it overrode. */
+    rule: number;
+    /** The kind and depth the task was taken for; null when unsure. */
+    kind: string | null;
+    depth: string | null;
+}
+/** What made workers cost one task. */
+export interface WorkerSpend {
+    dollars: number;
+    /** Slot-hours its agents held on made workers. */
+    slotHours: number;
+    /** True when counted at the provider's list price, false when from its bill. */
+    estimate: boolean;
+}
+/**
+ * How many prompts the person said from each layout in the conversation
+ * logged in `log`, from `since` to `until`: a conversation can outlive the
+ * task, or come to it already under way.
+ */
+export declare function promptsFrom(log: Log<Entry>, since: string, until: string): Promise<Partial<Record<Device, number>>>;

package/vendor/@stringsync/splates-server/stats/overrides.d.ts

@@ -0,0 +1,19 @@
+import type { Outcome } from "./outcomes";
+/** How often the person moved a conversation off what one Auto pick rule set. */
+export interface RuleOverrides {
+    /** The index in the rules of the rule whose pick was overridden. */
+    rule: number;
+    /** Times overridden, a model and an effort change each counting. */
+    count: number;
+    /** What it was moved to, most often first. */
+    moves: {
+        aspect: "model" | "effort";
+        to: string;
+        count: number;
+    }[];
+}
+/**
+ * The overrides in `outcomes` by the rule they overrode, the most overridden
+ * first, so a rule the person keeps correcting is easy to find.
+ */
+export declare function overridesByRule(outcomes: readonly Outcome[]): RuleOverrides[];

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

@@ -0,0 +1,23 @@
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Handler } from "../server/shared";
+import { Adherence } from "./adherence";
+/**
+ * What the page reads of how tasks ended, from the records every project on
+ * this machine shares, so one not open here still counts: the Stats page's
+ * sums, and how one merged task went.
+ */
+export declare class DevOutcomes {
+    private readonly outcomes;
+    /** What `splates server` judged of each conversation as its turns ended. */
+    readonly adherence: Adherence;
+    constructor({ fs, ps }: {
+        fs: Fs;
+        ps: Ps;
+    });
+    /** `?period=` names the period, as `PERIODS` does, or `all` for all time; 7 days for none. `?project=` narrows it to that main tree. */
+    readonly stats: Handler;
+    /** `?project=` narrows it to that main tree. */
+    readonly overrides: Handler;
+    /** How `/api/tasks/:task/outcome`'s task went once it merged in `project`; null when it never did. */
+    landed(project: string): Handler;
+}

package/vendor/@stringsync/splates-server/stats/scry-models.d.ts

@@ -0,0 +1,22 @@
+/** One model scry asks at an effort, and the config naming it. */
+export interface ModelChoice {
+    effort: string;
+    /** The model, or none when no config names one and scry has no default. */
+    model: string | null;
+    /** The config that names it; none when it is scry's own default. */
+    from: string | null;
+}
+/** The models a project's checks ask, per role. */
+export type ScryModels = Record<"som" | "llm", ModelChoice[]>;
+/**
+ * Reads which models scry will ask, from the project's `vet.config.ts` and
+ * then the user's, which lays its own over the project's, over scry's
+ * defaults. A config that cannot load names nothing.
+ */
+export declare class ScryModelsReader {
+    #private;
+    private readonly root;
+    private readonly home;
+    constructor(root: string, home?: string);
+    read(): Promise<ScryModels>;
+}

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

@@ -0,0 +1,59 @@
+/**
+ * The rules of the splates skill a program can decide, checked over one
+ * conversation: what it said and ran, condensed, and what it left behind.
+ * `splates server` runs them on its conversations, for the Stats page's pass rate
+ * per skill version; the hand-run evals run them on theirs. Rules that take
+ * judgment, such as whether a call should have been a question, are left to
+ * a model grading the evals.
+ */
+/** Each check's verdicts on one conversation, by its id. */
+export declare function judge(transcript: Transcript): Record<string, Verdict[]>;
+/** A conversation as the checks read it: its own words and acts, in order. */
+export interface Transcript {
+    beats: Beat[];
+}
+/**
+ * One thing said or done. A `user` beat starts a turn. What the agent's
+ * subagents did is left out: the rules are the agent's own.
+ */
+export type Beat = {
+    kind: "user";
+    text: string;
+}
+/** Words the agent said, one stretch of text between its tool calls. */
+ | {
+    kind: "say";
+    text: string;
+}
+/** A shell command, with the end of what it printed and whether it succeeded. */
+ | {
+    kind: "run";
+    command: string;
+    output: string;
+    ok: boolean;
+}
+/** Files a tool call wrote or edited. */
+ | {
+    kind: "edit";
+    paths: string[];
+};
+/** How one place a rule applied went. */
+export interface Verdict {
+    ok: boolean;
+    /** What was checked, and what was found when it failed. */
+    why: string;
+}
+/** A rule a program can decide; `judge` returns no verdicts where it does not apply. */
+export interface Check {
+    id: string;
+    /** The rule, as the Stats page names it. */
+    rule: string;
+    judge(transcript: Transcript): Verdict[];
+}
+/** Every check, in the order the Stats page lists them. */
+export declare const CHECKS: readonly Check[];
+/** Each `splates` command `command` runs, by its verb and its words after. */
+export declare function splatesCalls(command: string): {
+    verb: string;
+    args: string[];
+}[];