@stringsync/splates 0.0.45 → 0.0.46

package/system-changes.d.ts

@@ -1,67 +0,0 @@
-import type { Commit } from "./git.js";
-import type { Systems } from "./systems.js";
-/** How many of trunk's latest commits the Systems page looks through. */
-export declare const RECENT_COMMITS = 500;
-/** How many of those commits each system lists, newest first. */
-export declare const CHANGES_SHOWN = 10;
-/**
- * How many uncovered files a directory holds before they are split into
- * groups by the first word of their names.
- */
-export declare const SPLIT = 30;
-/** One commit that changed a system. */
-export type Change = Omit<Commit, "files">;
-/** What one system is made of on trunk, and how it moved lately. */
-export interface SystemChanges {
-    /** The system's name. */
-    name: string;
-    /** How many files trunk tracks in it. */
-    files: number;
-    /** Its globs that take in no file trunk tracks. */
-    unmatched: string[];
-    /** How many of the commits looked through changed it. */
-    changed: number;
-    /** The latest of them, up to `CHANGES_SHOWN`, newest first. */
-    changes: Change[];
-    /**
-     * Each other system some of those commits changed too, the most first.
-     * A task lands as one commit, so this is how often its tasks reach there.
-     */
-    overlaps: Overlap[];
-}
-/** Another system that commits changing one system changed too. */
-export interface Overlap {
-    /** The other system's name. */
-    name: string;
-    /** How many of the commits changing both. */
-    changed: number;
-}
-/** What the Systems page reads: every system, and how far back it looked. */
-export interface SystemsReport {
-    systems: SystemChanges[];
-    /** When the oldest commit looked through was written, or null for none. */
-    since: string | null;
-    /** How many commits were looked through. */
-    scanned: number;
-    /** How many files trunk tracks that no system covers. */
-    uncovered: number;
-    /**
-     * Those files as globs: those of several files first, then each lot
-     * changed most lately first.
-     */
-    groups: Uncovered[];
-}
-/** Files no system covers, as one glob a system could be named for. */
-export interface Uncovered {
-    /** A glob taking in the files, such as `src/upload/*` or `src/upload*`. */
-    glob: string;
-    /** How many uncovered files it takes in. */
-    files: number;
-    /** How many of the commits looked through changed one of them. */
-    changed: number;
-}
-/**
- * How each of `systems` stands in a tree whose tracked files are `files`,
- * and which of `commits`, newest first, changed it.
- */
-export declare function systemsReport(systems: Systems, files: string[], commits: Commit[]): SystemsReport;

package/system.d.ts

@@ -1,28 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs } from "webappwiz/system";
-import type { Git } from "./git.js";
-import type { WorktreeService } from "./worktree-service.js";
-export interface ShowSystemsOptions {
-    /** A system to print alone, by its name or an alias. */
-    name?: string;
-    /** Print only the systems this task's changed files fall in. */
-    task?: string;
-    /**
-     * The task the command runs in, read off the current branch: with no
-     * `task`, its worktree's systems are the ones read.
-     */
-    here?: string | null;
-    /** Print the systems as JSON instead of prose. */
-    json?: boolean;
-}
-/**
- * The systems `splates.systems.ts` names: every one, one by name, or those a
- * task touches. Read from the task's own worktree, so one it names counts
- * before it lands.
- */
-export declare function systems({ service, git, fs, log, }: {
-    service: WorktreeService;
-    git: Git;
-    fs: Fs;
-    log: Logger;
-}, { name, task, here, json }?: ShowSystemsOptions): Promise<void>;

package/systems.d.ts

@@ -1,119 +0,0 @@
-import { type Fs, type Glob } from "webappwiz/system";
-/** The file a repo names its systems in, at its root. */
-export declare const SYSTEMS_FILE = "splates.systems.ts";
-/** One named part of the code: the files it is made of. */
-export interface System {
-    /** What it is for in one short line, never how it works, which goes stale. */
-    description?: string;
-    /**
-     * Other names people call it by, at most two, so one part of the code
-     * keeps one word for it.
-     */
-    aliases?: string[];
-    /** Repo-relative globs of the files it is made of. */
-    globs: string[];
-    /** Globs of files the `globs` take in that are not part of it. */
-    ignore?: string[];
-}
-/** A system with the name `splates.systems.ts` keys it by. */
-export interface NamedSystem extends System {
-    name: string;
-}
-/** Configures where {@link Systems.at} reads and how it matches. */
-export interface SystemsOptions {
-    /** What `splates.systems.ts` is read through; the real one by default. */
-    fs?: Fs;
-    /** What paths are matched against globs with; `node:path`'s by default. */
-    glob?: Glob;
-}
-/**
- * What `splates.systems.ts` exports as its default, keyed by name:
- *
- * ```ts
- * import type { SystemsFile } from "@stringsync/splates/systems";
- *
- * export default {
- * 	playback: { description: "Playing a song", globs: ["src/audio/**"] },
- * } satisfies SystemsFile;
- * ```
- *
- * The import is only a type, so a reader can import the file without splates
- * installed.
- */
-export type SystemsFile = Record<string, System>;
-/**
- * The systems one tree's `splates.systems.ts` names, and which of them a set of
- * paths falls in.
- */
-export declare class Systems {
-    private readonly named;
-    private readonly glob;
-    private constructor();
-    /**
-     * The systems the tree at `root` names as it stands now: read afresh, so
-     * one named in a task's worktree counts there at once.
-     */
-    static at(root: string, opts?: SystemsOptions): Promise<Systems>;
-    static of(systems: Record<string, System>, glob?: Glob): Systems;
-    /** Every system, in the order `splates.systems.ts` names them. */
-    all(): NamedSystem[];
-    /** The system called `name`, by its name or one of its aliases. */
-    find(name: string): NamedSystem | null;
-    /** The systems any of `paths`, repo-relative, falls in. */
-    touchedBy(paths: string[]): NamedSystem[];
-    /** Those of `paths`, repo-relative, that fall in `system`. */
-    within(system: System, paths: string[]): string[];
-    /**
-     * The globs of `system` that take in none of `paths`: as a rule, ones
-     * left behind when the files they named moved.
-     */
-    unmatched(system: System, paths: string[]): string[];
-    /**
-     * The systems `text` mentions as `#name` or `#alias`, each once, in the
-     * order first mentioned. A `#` that names no system, such as `#12`, is
-     * left alone.
-     */
-    mentioned(text: string): NamedSystem[];
-    /**
-     * The words `text` mentions as `#word` that no system answers to, each
-     * once, in the order first mentioned. A number, such as `#12`, is a todo
-     * rather than a system, and one in code means something else.
-     */
-    unknown(text: string): string[];
-    private contains;
-}
-/**
- * Each word `text` mentions as `#word` outside code, once, in the order first
- * mentioned: in code, a `#` means something else.
- */
-export declare function hashed(text: string): string[];
-/**
- * One line telling an agent what a mentioned system is made of:
- *
- * ```
- * #playback (player, audio engine): Playing a song. Made of src/player/**, src/audio/**; not src/player/*.test.ts
- * ```
- */
-export declare function mentionLine(system: NamedSystem): string;
-/**
- * One line asking an agent to find the code an unknown `#name` means, so the
- * user can name it as a system, or give one that covers it the alias.
- */
-export declare function unknownLine(name: string): string;
-/** The longest {@link System.description} splates takes. */
-export declare const DESCRIPTION_MAX = 80;
-/**
- * The systems `root`'s `splates.systems.ts` names, checked, or none when there
- * is no such file. Read afresh each time, so a long-running `splates server` sees a
- * system named mid-task without a restart. Throws while `splates.config.ts`
- * still names systems, which `splates update` moves.
- */
-export declare function readSystems(root: string, fs?: Fs): Promise<Record<string, System>>;
-/**
- * `systems` in the shape {@link System} names, or throws
- * naming `path` for one that is not, one with more than two aliases or a
- * description longer than one short line, or two
- * that answer to the same name, which would leave `splates systems <name>`
- * guessing.
- */
-export declare function checkSystems(path: string, systems: unknown): Record<string, System>;

package/systems.js

@@ -1,21 +0,0 @@
-import {
-  SYSTEMS_FILE2,
-  Systems2,
-  hashed2,
-  mentionLine2,
-  unknownLine2,
-  DESCRIPTION_MAX2,
-  readSystems2,
-  checkSystems2
-} from "./index-4776671w.js";
-import"./index-k73tsw5g.js";
-export {
-  DESCRIPTION_MAX2 as DESCRIPTION_MAX,
-  SYSTEMS_FILE2 as SYSTEMS_FILE,
-  Systems2 as Systems,
-  checkSystems2 as checkSystems,
-  hashed2 as hashed,
-  mentionLine2 as mentionLine,
-  readSystems2 as readSystems,
-  unknownLine2 as unknownLine
-};

package/table.d.ts

@@ -1,5 +0,0 @@
-/**
- * Columns padded to their widest cell. Padding goes by visible width, not
- * string length: cells carry color codes.
- */
-export declare function table(header: string[], rows: string[][]): string;

package/task-log.d.ts

@@ -1,35 +0,0 @@
-import type { Fs } from "webappwiz/system";
-/** What a task's turns used, apart from the rest of its conversation's. */
-export interface TaskUsage {
-    /** Tokens read, those from cache among them. */
-    input: number;
-    cached: number;
-    output: number;
-    /** What it cost; null for an agent that never says, as Codex does not. */
-    cost: {
-        amount: number;
-        currency: string;
-    } | null;
-}
-/** What a task's stretch of its conversation shows of how the work went. */
-export interface TaskLog {
-    /** OpenCode observations have different scope; kept in the conversation, not legacy task totals. */
-    usage: TaskUsage | undefined;
-    /** Each agent turn's span, start to last move, summed. */
-    workedMs: number;
-    /** When the person stopped the agent's turn, each time. */
-    stopped: string[];
-    /** When a lost connection cut the agent's turn short, each time. */
-    interrupted: string[];
-    /** How many times each command failed. */
-    failedCommands: Record<string, number>;
-    /** Lines the agent's edits took out and put in, its plan's aside. */
-    editedLines: number;
-}
-/**
- * Reads the conversation logged at `log` from `since` to `until`: a
- * conversation can outlive the task, or come to it already under way. Null
- * when there is no such log. Read raw rather than replayed, since the agent
- * merging is still writing it.
- */
-export declare function taskLog(log: string, fs: Fs, since: string, until: string): Promise<TaskLog | null>;

package/task-ports.d.ts

@@ -1,25 +0,0 @@
-import type { ListeningEntry, ProcessEntry } from "webappwiz/system";
-/** What ties a process to a task: its worktree, and the agents at work in it. */
-export interface PortOwners {
-    worktrees: {
-        task: string;
-        path: string;
-    }[];
-    /** The pid of each agent `splates server` runs in a task. */
-    agents: {
-        task: string;
-        pid: number;
-    }[];
-}
-/** One port a task's processes listen on, on the worker that runs them. */
-export interface TaskPort {
-    task: string;
-    port: number;
-}
-/**
- * The ports each task serves, as an editor finds the ports to forward: each
- * one a process listens on that runs in the task's worktree, or under one of
- * its agents, whatever directory it moved to. Each port once, in the order
- * of its task, then its number.
- */
-export declare function taskPorts(table: ProcessEntry[], listening: ListeningEntry[], owners: PortOwners): TaskPort[];

package/tell.d.ts

@@ -1,47 +0,0 @@
-import type { Logger } from "webappwiz/log";
-import type { Ps } from "webappwiz/system";
-import type { Projects } from "./projects.js";
-import type { Worktree } from "./worktree.js";
-import type { WorktreeService } from "./worktree-service.js";
-/** What `fetch` is used for here, so a test can stand in for it. */
-type Send = (url: string, init: RequestInit) => Promise<Response>;
-/**
- * The two ends of a task one conversation handed to an agent with `splates add
- * --agent`: the caller that handed it out, and the conversation `splates server`
- * started for the agent. Null for any other task, which answers to the user
- * alone.
- */
-export declare function handOff(worktree: Worktree): {
-    caller: string;
-    conversation: string;
-} | null;
-/**
- * Says `text` in the conversation of the agent a task was handed to, as the
- * user would, for the conversation that handed it out to wake it, pass on
- * answers, or what the earlier steps of its lane taught it; with `stop`, its
- * running turn stopped first, for a change of plans. Only that conversation
- * may, not whoever else asks. Answers with that agent's conversation.
- */
-export declare function tell({ ps, service, send, }: {
-    ps: Ps;
-    service: WorktreeService;
-    send?: Send;
-}, task: string, text: string, { stop }?: {
-    stop?: boolean;
-}): Promise<string>;
-/**
- * Tells the conversation that handed `worktree` out that the task stopped,
- * escalated, merged or removed, with `[SPLATES REPORT <task>]`, when its agent
- * answers to that conversation, or that conversation is another project's. Run before the record
- * goes, by the command that stops it. Outside `splates server`, or for a task
- * nobody handed out, it says nothing; a server that cannot be reached is
- * worth a line, never a failure, since the command has done its work.
- */
-export declare function reportToCaller({ ps, log, service, projects, send, }: {
-    ps: Ps;
-    log: Logger;
-    service: WorktreeService;
-    projects: Projects;
-    send?: Send;
-}, worktree: Worktree): Promise<void>;
-export {};

package/todo-edit.d.ts

@@ -1,60 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs, Ps } from "webappwiz/system";
-import type { Facts } from "./events.js";
-import type { AgentPick } from "./roster.js";
-import type { Todo, TodoOrigin } from "./todo.js";
-import type { Todos } from "./todos.js";
-export interface TodoFileOptions {
-    /** Files to attach, relative to the current directory or absolute. */
-    files?: string[];
-}
-export interface TodoAddOptions extends TodoFileOptions {
-    /** Whatever more there is to say than the subject. */
-    text?: string;
-    /** Where it goes in the list, 1 at the top; the bottom by default. */
-    position?: number;
-    /** The todos blocking it: each has to merge before it starts. */
-    blockedBy?: number[];
-    /** The lane it goes in, `"new"` for one of its own; none by default. */
-    lane?: number | "new" | null;
-    /** The agent that should work it; none by default. */
-    assignee?: AgentPick | null;
-    /** The other project it is added from; none by default. */
-    origin?: TodoOrigin;
-}
-export declare function todoAdd(deps: {
-    todos: Todos;
-    log: Logger;
-    fs: Fs;
-    ps: Ps;
-}, subject: string, from: string | null, { text, files, position, blockedBy, lane, assignee, origin, }?: TodoAddOptions): Promise<Todo>;
-/** What a `todo add` event says of the todo it added. */
-export declare function addedFacts(todo: Todo): Facts["todo add"];
-export interface TodoUpdateOptions extends TodoFileOptions {
-    /** A new line; the old one stays when this is absent or empty. */
-    subject?: string;
-    /** New detail; the old stays when this is absent or empty. */
-    text?: string;
-    /** Where to move it in the list, 1 at the top; it stays put when absent. */
-    position?: number;
-    /** Attached files to drop, by path or by the name they were stored under. */
-    removeFiles?: string[];
-    /** Todos blocking it from now on, besides those that already do. */
-    blockedBy?: number[];
-    /** Todos no longer blocking it. */
-    removeBlockedBy?: number[];
-    /** The lane it moves to, `"new"` for one of its own, null for none; it stays when absent. */
-    lane?: number | "new" | null;
-    /** The agent that should work it, null for none; it stays when absent. */
-    assignee?: AgentPick | null;
-}
-export declare function todoUpdate(deps: {
-    todos: Todos;
-    log: Logger;
-    fs: Fs;
-    ps: Ps;
-}, id: number, { subject, text, position, files, removeFiles, blockedBy, removeBlockedBy, lane, assignee, }?: TodoUpdateOptions): Promise<Todo>;
-export declare function todoRemove({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, id: number): Promise<Todo>;

package/todo-file.d.ts

@@ -1,6 +0,0 @@
-import { type TodoState } from "./todo.js";
-/** A todo as stored, with any tags it was saved with; null when it will not parse. */
-export declare function parseTodoFile(raw: string): {
-    state: TodoState;
-    tags: string[];
-} | null;

package/todo-lanes.d.ts

@@ -1,82 +0,0 @@
-import type { Fs } from "webappwiz/system";
-import { type LaneRecord } from "./lanes.js";
-import type { TodoState } from "./todo.js";
-import type { Todos } from "./todos.js";
-/**
- * The lanes of a `Todos`: their records in `lanes` beside the todos, and every
- * change that moves todos between them, each made under the todos' lock.
- */
-export declare class TodoLanes {
-    private readonly todos;
-    private readonly fs;
-    constructor(todos: Todos, fs: Fs);
-    /**
-     * Moves every todo in lane `from` to the bottom of lane `into`, in the
-     * order they had, and the lane `from` is gone.
-     */
-    joinLanes(from: number, into: number): Promise<void>;
-    /** Starts an empty lane called `name`, after the others. */
-    addLane(name: string): Promise<LaneRecord>;
-    /** Calls lane `id` by another name. */
-    renameLane(id: number, name: string): Promise<LaneRecord>;
-    /**
-     * Puts lane `id` at `position` among the lanes, 1 the first column, past
-     * the last meaning the last; the others close up around it.
-     */
-    moveLane(id: number, position: number): Promise<LaneRecord[]>;
-    /** Removes lane `id`, putting its todos back in none, untriaged. */
-    dropLane(id: number): Promise<void>;
-    /**
-     * @internal Removes each lane in `ids` that no todo is in any more: a lane
-     * whose last todo merged is done. One emptied by hand stays, to be filled.
-     */
-    endLanes(ids: number[]): Promise<void>;
-    /**
-     * Moves todos saved while splates kept tags into lanes, one lane a tag,
-     * and drops their tags, which splates refuses to read until then. A todo
-     * in no lane goes to the lane of its tag the most todos share, at the
-     * bottom, in list order, below anything in that lane blocking it; a lane
-     * already called that takes them. Gives back each lane it filled, with
-     * the todos it put there, in board order; none once no todo has tags.
-     */
-    moveTagsToLanes(): Promise<{
-        lane: LaneRecord;
-        todos: number[];
-    }[]>;
-    /**
-     * @internal The lane `lane` names: null for none, one there is, or for
-     * `"new"` one started for `todos`, called `name` or named after them. Call
-     * it under the lock.
-     */
-    laneId(lane: number | "new" | null, states: TodoState[], todos: TodoState[], name?: string): Promise<number | null>;
-    /**
-     * Starts a lane for `todos` after the others, called `name`, or aptly
-     * named without one. Call it under the lock.
-     */
-    private newLane;
-    /**
-     * A lane id never handed out before, so a lane's number never comes back
-     * meaning another. Call it under the lock.
-     */
-    private nextLaneId;
-    /**
-     * @internal The lanes as stored, and after them any lane a todo is in that
-     * has no record. A file that will not parse reads as none.
-     */
-    records(states: TodoState[]): Promise<LaneRecord[]>;
-    /**
-     * The name of every lane there has been: those on the board, and after
-     * them each that is gone as it was last called, so an orchestrator whose
-     * lanes are done still goes by their names.
-     */
-    names(states: TodoState[]): Promise<LaneRecord[]>;
-    /** The lane records in `file`, none when it is missing or will not parse. */
-    private read;
-    /**
-     * Writes the lanes, in board order, keeping the name of each lane they
-     * drop in `ended-lanes`. Call it under the lock.
-     */
-    private writeLanes;
-    /** Writes `records` to `file` whole, so a reader never sees half of it. */
-    private write;
-}

package/todo-list.d.ts

@@ -1,26 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Todos } from "./todos.js";
-export interface TodoListOptions {
-    /** Print the todos as JSON instead of a table. */
-    json?: boolean;
-    /** Only those no task has taken: the ones free to pick up. */
-    open?: boolean;
-    /**
-     * Only those free to start now: nobody has taken them, and nothing they
-     * is blocked by is still open.
-     */
-    ready?: boolean;
-}
-export declare function todoList({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, { json, open, ready }?: TodoListOptions): Promise<void>;
-export interface TodoShowOptions {
-    /** Print the todo as JSON instead of prose. */
-    json?: boolean;
-}
-/** One todo in full: what `todo list` shows of it, its files, and its detail. */
-export declare function todoShow({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, id: number, { json }?: TodoShowOptions): Promise<void>;

package/todo-take.d.ts

@@ -1,27 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Todo } from "./todo.js";
-import type { Todos } from "./todos.js";
-/**
- * Takes up todos for `task` after it started, as when one turns out to be
- * part of the work. Every id is checked before any is taken, so one that is
- * gone or another task's refuses them all.
- */
-export declare function todoTake({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, ids: number[], task: string | null): Promise<Todo[]>;
-/**
- * Puts todos back on the list, as when a task is landing without finishing
- * them: say what is left with `splates todo update` first. From a worktree it
- * gives back only its own task's todos.
- */
-export declare function todoRelease({ todos, log }: {
-    todos: Todos;
-    log: Logger;
-}, ids: number[], task: string | null): Promise<Todo[]>;
-/**
- * The lines warning that `todo` was taken while `blockers` have yet to merge,
- * or none when nothing blocks it: it may be started, but what it builds on
- * is not there yet.
- */
-export declare function blockedWarning(todo: Todo, blockers: Todo[]): string[];