@stringsync/splates 0.0.0-stage → 0.0.45

package/stats.d.ts

@@ -0,0 +1,186 @@
+import type { Judged } from "./adherence.js";
+import { type Baseline } from "./baselines.js";
+import type { Outcome } from "./outcomes.js";
+import { type MergeFailure, type RemoveReason } from "./worktree.js";
+/** What the Stats page shows: how tasks ended, bar by bar and by who did them. */
+export interface Stats {
+    /**
+     * Each bar of the period, oldest first, those with nothing ended among
+     * them: `start` is when it starts, as an ISO time.
+     */
+    buckets: ({
+        start: string;
+    } & Tally)[];
+    /**
+     * The as long a span before the period, summed, to compare it with; null
+     * for all time, which has nothing before it.
+     */
+    previous: Tally | null;
+    /** By the model that ended each task in the period, the most first; null for unknown. */
+    models: ({
+        model: string | null;
+    } & Tally)[];
+    /**
+     * By where the person worked each task in the period from, the most
+     * first: null for none, as for an external agent, or one that ended
+     * before it was kept.
+     */
+    devices: ({
+        device: WorkedFrom | null;
+    } & Tally)[];
+    /** By the main tree each task in the period was in, the most first. */
+    projects: ({
+        project: string;
+    } & Tally)[];
+    /**
+     * By each system a task in the period touched, the most first: a task
+     * counts in each of its systems, and in `null` when it touched none or
+     * ended before systems were kept.
+     */
+    systems: ({
+        system: string | null;
+    } & Tally)[];
+    /**
+     * Who made the calls tasks in the period made, by size: `SIZES` in order, then any
+     * other word an older scheme used, then null for those with none, which
+     * holds every call from before sizes were kept.
+     */
+    sizes: SizeTally[];
+    /** When the first outcome was written, the start of what there is to show. */
+    since: string | null;
+    /**
+     * How conversations followed the splates skill, by the version each started
+     * on, newest first: over all time, since a version is its own span.
+     */
+    skill: SkillVersion[];
+    /** Each project's recent merged tasks, to hold one against: over the week before now, whatever the period. */
+    baselines: Baseline[];
+}
+/** How a group of ended tasks went, summed. */
+export interface Tally {
+    merged: number;
+    removed: number;
+    /** Of `merged`, those that landed without a person answering a question. */
+    clean: number;
+    /** Over every task in the group, merged and removed alike. */
+    questionRounds: number;
+    reviewRounds: number;
+    failedMerges: number;
+    /** Questions that offered the agent's pick and were answered with a choice. */
+    picksAsked: number;
+    /** Of `picksAsked`, those answered with another choice. */
+    picksOverturned: number;
+    /** Of `picksAsked`, those answered with the agent's choice and words added. */
+    picksAmended: number;
+    /** Calls made without asking. */
+    assumptionsMade: number;
+    /** Of `assumptionsMade`, those challenged. */
+    assumptionsChallenged: number;
+    /** Calls the person made: questions put to them, assumptions challenged. */
+    decidedByYou: number;
+    /** Calls agents made that stood without the person: assumptions left alone. */
+    decidedByAgents: number;
+    /** Tasks whose time waiting on a person was kept; older ones were not. */
+    timed: number;
+    /** Of the `timed` tasks, how long they waited on a person, in milliseconds. */
+    waitedMs: number;
+    /** Of the `timed` tasks, how long they took from add to end, in milliseconds. */
+    spentMs: number;
+    /** Tasks whose own usage was kept; older ones and external agents' were not. */
+    used: number;
+    /** Of the `used` tasks, tokens read, those from cache among them, and written. */
+    inputTokens: number;
+    outputTokens: number;
+    /** Of the `used` tasks, those whose agent said what they cost; Codex does not. */
+    costed: number;
+    /** Of the `costed` tasks, what they cost, summed. */
+    cost: number;
+    /** Of the `used` tasks, how long their agents worked, in milliseconds. */
+    workedMs: number;
+    /** Tasks whose diff size was kept. */
+    sized: number;
+    /** Of the `sized` tasks, the files and lines they changed. */
+    filesChanged: number;
+    linesAdded: number;
+    linesRemoved: number;
+    /** Failed merges by why, where it was kept. */
+    failedBy: Record<MergeFailure, number>;
+    /** Removed tasks by why; `unsaid` for one removed without `--reason`, or before it was kept. */
+    removedFor: Record<RemoveReason | "unsaid", number>;
+}
+/** Who made the calls of one size: the person, or agents without asking. */
+export interface SizeTally extends Decided {
+    size: string | null;
+    /** The same, bar by bar, in the order of `Stats.buckets`. */
+    buckets: Decided[];
+    /** The same over the as long a span before, as `Stats.previous`; null for all time. */
+    previous: Decided | null;
+}
+/** How many calls the person made, and how many agents made without them. */
+export interface Decided {
+    decidedByYou: number;
+    decidedByAgents: number;
+}
+/** Where the person spoke to a task's conversation from: a phone, a desktop, or both. */
+export type WorkedFrom = "phone" | "desktop" | "both";
+/** Where `outcome`'s prompts came from, or null when none was said from the page. */
+export declare function workedFrom(outcome: Outcome): WorkedFrom | null;
+/**
+ * The spans the page can look at, as `?period=` names them: how long each
+ * runs back from now, and how long each of its bars is.
+ */
+export declare const PERIODS: {
+    readonly "6h": {
+        readonly span: number;
+        readonly bucket: number;
+    };
+    readonly "1d": {
+        readonly span: number;
+        readonly bucket: number;
+    };
+    readonly "3d": {
+        readonly span: number;
+        readonly bucket: number;
+    };
+    readonly "7d": {
+        readonly span: number;
+        readonly bucket: number;
+    };
+};
+/** A span in `PERIODS`, or `all` for all time, a bar a week. */
+export type PeriodId = keyof typeof PERIODS | "all";
+export declare function isPeriodId(value: string): value is PeriodId;
+/** How long each bar of `period` is, in milliseconds: a week for all time. */
+export declare function bucketOf(period: PeriodId): number;
+export interface SummarizeOptions {
+    period?: PeriodId;
+    now?: Date;
+    /** Each conversation's skill checks as last judged. */
+    judged?: Judged[];
+}
+/**
+ * Sums the outcomes written so far for the page, over `period`. A part,
+ * which lands on its caller's branch rather than trunk, is left out: it is a
+ * piece of a task that is counted when its caller ends.
+ */
+export declare function summarize(outcomes: Outcome[], { period, now, judged }?: SummarizeOptions): Stats;
+/** Tallies added up, as for the bars of a period. */
+export declare function combine(tallies: Tally[]): Tally;
+/** How one check went over the conversations on one skill version. */
+export interface CheckRate {
+    id: string;
+    rule: string;
+    /** The conversations it applied in. */
+    applied: number;
+    /** Of `applied`, those where it passed every time. */
+    passed: number;
+}
+/** How the conversations on one splates skill version followed it. */
+export interface SkillVersion {
+    /** Null for conversations whose version is unknown. */
+    skill: string | null;
+    conversations: number;
+    checks: CheckRate[];
+}
+/** Each skill version's pass rates, the newest version first and unknown last. */
+export declare function rates(judged: Judged[]): SkillVersion[];

package/supervise.d.ts

@@ -0,0 +1,50 @@
+import type { Ps } from "webappwiz/system";
+import { type Timer } from "webappwiz/time";
+/** What a server exits with to be started again as it was. */
+export declare const RESTART = 75;
+/** What a server exits with to be started again on the newest splates. */
+export declare const UPDATE = 76;
+/**
+ * Set in the server's environment, so the `splates server` it runs serves rather
+ * than supervising another.
+ */
+export declare const SERVING = "SPLATES_DEV_SERVING";
+/**
+ * Set in the server's environment to tell it its page failed to build, so
+ * the page says it may be out of date.
+ */
+export declare const UNBUILT = "SPLATES_DEV_UNBUILT";
+/** What `supervise` starts the server with, beyond the process it runs in. */
+export interface SuperviseOptions {
+    /**
+     * Builds the page, run before each start of the same splates, as from a
+     * checkout, whose page `bun install` built last and the commits since may
+     * have changed, packages they added included; null for one installed from
+     * npm, whose page shipped built.
+     */
+    build?: {
+        argv: string[];
+        cwd: string;
+    } | null;
+    /** Added to the server's environment, as a slot's home is. */
+    env?: Record<string, string>;
+    /** Where the server runs, the working directory by default. */
+    cwd?: string;
+    /**
+     * The arguments of a worker to run beside the server, as `["worker",
+     * "run"]`: started again whenever it ends, on the newest splates once the
+     * server updates, and stopped with this. Null for none.
+     */
+    worker?: string[] | null;
+    timer?: Timer;
+}
+/**
+ * Runs `splates server` as a child of this process, sharing its terminal, and
+ * starts another each time the child exits to restart: as this one was
+ * started, or on the newest splates when it asks to update. Ctrl-C reaches the
+ * child too, and its exit ends this. A SIGTERM or SIGHUP to this one stops the
+ * child with a SIGTERM and ends this, since the child would otherwise outlive
+ * it, listening on its port. A `worker` runs beside it as a second child.
+ * Answers with the exit code to end on.
+ */
+export declare function supervise(ps: Ps, { build, env, cwd, worker, timer, }?: SuperviseOptions): Promise<number>;

package/system-changes.d.ts

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,5 @@
+/**
+ * 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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,6 @@
+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;