@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/git.d.ts

@@ -0,0 +1,168 @@
+import { type Fs, type Ps } from "../../core/system/index.js";
+import { type Author, type GitIdentity } from "./git-identity";
+export interface GitResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+/** Run Git in a checkout on this machine or a worker, preserving untrimmed output. */
+export interface GitRunner {
+    git(cwd: string, args: string[], env?: Record<string, string>): Promise<GitResult>;
+}
+/** The files a `Git` reads itself rather than asking git. */
+export type GitFiles = Pick<Fs, "exists" | "read">;
+/** What a `Git` works through; the real ones by default. */
+export interface GitOptions {
+    ps?: Ps;
+    /** Where a worktree's git directory is read, on the machine git runs on. */
+    fs?: GitFiles;
+    /** Where git runs; a process through `ps` by default. */
+    run?: GitRunner;
+    /** Whose author commits are signed as where the machine git runs on has none of its own; `splates` without. */
+    identity?: Author;
+}
+export declare class Git {
+    /** The main worktree, where trunk lives. */
+    readonly root: string;
+    private readonly fs;
+    private readonly runner;
+    private readonly identity;
+    constructor(
+    /** The main worktree, where trunk lives. */
+    root: string, opts?: GitOptions);
+    /** Who this machine's git commits as, from its config; null unless both name and email are set. */
+    author(): Promise<GitIdentity | null>;
+    /**
+     * The same repository's git, run the same way, as rooted at `root`: a
+     * clone's own, whose branches its main tree does not have.
+     */
+    at(root: string): Git;
+    run(cwd: string, ...args: string[]): Promise<GitResult>;
+    /** Run Git with additional environment variables. Pass credentials in `env`, never in arguments. */
+    runWith(cwd: string, args: string[], env: Record<string, string>): Promise<GitResult>;
+    out(cwd: string, ...args: string[]): Promise<string>;
+    branchExists(branch: string): Promise<boolean>;
+    /**
+     * The branch `origin/HEAD` points at, or null when the repo has no such ref:
+     * no remote, or a clone that never fetched it.
+     */
+    defaultBranch(): Promise<string | null>;
+    /**
+     * The branch checked out at `cwd`, or null where there is none: a detached
+     * HEAD, or a directory outside any repository. Any other failure throws, so
+     * it is not mistaken for being off a task's branch.
+     */
+    currentBranch(cwd: string): Promise<string | null>;
+    head(cwd: string): Promise<string>;
+    shortHead(cwd: string): Promise<string>;
+    porcelain(cwd: string): Promise<string[]>;
+    conflictedPaths(cwd: string): Promise<string[]>;
+    commitsAhead(trunk: string, branch: string): Promise<number | null>;
+    /** When `ref`'s latest commit was committed, as ISO 8601; null when git cannot say. */
+    committedAt(ref: string): Promise<string | null>;
+    /**
+     * The message of each commit on `branch` since it left `trunk`, oldest
+     * first; null when git cannot say.
+     */
+    commitMessages(trunk: string, branch: string): Promise<string[] | null>;
+    /**
+     * What `branch` changed since it left `trunk`, as a unified diff, along
+     * with all the work still uncommitted in `worktree` when there is one, new
+     * files git does not track yet among it; `uncommitted` names the paths
+     * that have some. Untrimmed, since a diff's lines keep their leading spaces.
+     */
+    diff(trunk: string, branch: string, worktree: string | null): Promise<{
+        text: string;
+        uncommitted: string[];
+    } | null>;
+    /**
+     * Every path `branch` touches since it left `trunk`, plus what is still
+     * uncommitted in `worktree` when there is one: an agent mid-task has usually
+     * committed nothing yet, and its edits are the overlap that matters most.
+     */
+    changedFiles(trunk: string, branch: string, worktree: string | null): Promise<string[] | null>;
+    /**
+     * Every path a person might point an agent at in the tree at `cwd`: the
+     * files git tracks, the new ones it does not ignore, and each directory
+     * above them, which ends in `/`. Sorted, relative to the tree's root.
+     */
+    paths(cwd: string): Promise<string[]>;
+    /**
+     * The latest `count` commits on `ref`, newest first, each with the paths
+     * it changed. Empty when `ref` names nothing, as in a repo with no commit.
+     */
+    log(ref: string, count: number): Promise<Commit[]>;
+    /** Every path git tracks at `ref`, or none when `ref` names nothing. */
+    files(ref: string): Promise<string[]>;
+    rebase(cwd: string, onto: string): Promise<GitResult>;
+    resetHard(cwd: string, commit: string): Promise<GitResult>;
+    checkout(branch: string): Promise<GitResult>;
+    mergeFfOnly(cwd: string, branch: string): Promise<GitResult>;
+    /**
+     * The worktree with `branch` checked out, or null when no worktree has it.
+     * Git allows one worktree per branch and that is the only place the branch
+     * can be advanced, so this is where a fast-forward has to happen.
+     */
+    worktreeFor(branch: string): Promise<string | null>;
+    addWorktree(branch: string, path: string, from: string): Promise<GitResult>;
+    removeWorktree(path: string): Promise<GitResult>;
+    /** Drops metadata for worktrees whose directories are gone. */
+    pruneWorktrees(): Promise<GitResult>;
+    deleteBranch(branch: string): Promise<GitResult>;
+    /**
+     * Commits everything in the tree at `cwd`, new files git does not ignore
+     * among it, as `message`, skipping the repo's commit hooks: a checkpoint
+     * saves work as it stands, finished or not.
+     */
+    commitAll(cwd: string, message: string): Promise<GitResult>;
+    /**
+     * `git commit` with `args`, signed as `splates` when the machine has no
+     * identity of its own, as a worker made fresh has none: a configured one
+     * is never overridden.
+     */
+    private commit;
+    /**
+     * Folds every commit the branch at `cwd` has that `base` lacks into one,
+     * `message`, running the repo's commit hooks as any commit does. Null when
+     * it has none to fold; on a failed commit, the branch is put back as it was.
+     */
+    squash(cwd: string, base: string, message: string): Promise<GitResult | null>;
+    /** The URL `remote` fetches from, or null when there is no such remote. */
+    remoteUrl(remote: string): Promise<string | null>;
+    /** Which of `paths` git tracks at `ref`. */
+    tracked(ref: string, paths: string[]): Promise<string[]>;
+    /** Push refs with additional arguments and environment variables; fails if credentials are missing. */
+    push(cwd: string, args: string[], env?: Record<string, string>): Promise<GitResult>;
+    /** `git fetch` with `args`, signing in as `push` does. */
+    fetch(cwd: string, args: string[], env?: Record<string, string>): Promise<GitResult>;
+    /**
+     * The commit each of `refs` is at on `remote`, by ref, leaving out those
+     * it lacks; null when the remote cannot be read.
+     */
+    remoteHeads(remote: string, refs: string[]): Promise<Map<string, string> | null>;
+    /** Whether `ancestor` is `commit` or reached from it. */
+    isAncestor(ancestor: string, commit: string): Promise<boolean>;
+    /** Whether this repository has `commit`'s object. */
+    hasCommit(commit: string): Promise<boolean>;
+    /** The one `.git` every worktree of this repo shares. */
+    commonDir(): Promise<string>;
+    /**
+     * The git directory belonging to a worktree, or null if it has none: the
+     * one a linked worktree's `.git` file points at, or a clone's own `.git`.
+     */
+    worktreeGitDir(worktree: string): Promise<string | null>;
+    /** Half-finished merges and rebases a resuming agent is standing in. */
+    interruptedOps(worktree: string): Promise<string[]>;
+}
+/** One commit as `Git.log` reads it. */
+export interface Commit {
+    hash: string;
+    /** When it was written, as ISO 8601. */
+    at: string;
+    author: string;
+    /** Its message's first line. */
+    subject: string;
+    /** The paths it changed, repo-relative. */
+    files: string[];
+}
+export { processGit, sshUrl } from "./git-process";

package/vendor/@stringsync/splates-server/hooks/commands.d.ts

@@ -0,0 +1,31 @@
+import { type Logger } from "../../../core/log/index.js";
+import { type AgentPick } from "../models";
+import { type HookChange } from "./edit";
+import type { Automation, Hook, HookStore, Trigger } from "./store";
+/** What the hook commands work with. */
+export interface HookDeps {
+    hooks: HookStore;
+    log: Logger;
+}
+/** Every automation set for this project, by number. */
+export declare function hookList({ hooks, log }: HookDeps, { json }?: {
+    json?: boolean;
+}): Promise<void>;
+/** Adds `hook` on `trigger`, then says what it set. */
+export declare function hookAdd({ hooks, log }: HookDeps, trigger: Trigger, hook: Hook): Promise<void>;
+/** Makes `change` to the person's automation numbered `id`, then says what it set. */
+export declare function hookEdit({ hooks, log }: HookDeps, id: string, change: HookChange): Promise<void>;
+/** Takes away the automation numbered `id`, or every one on the event `id` names. */
+export declare function hookRemove({ hooks, log }: HookDeps, id: string): Promise<void>;
+/** Turns the groomer on as `pick`, or off for null, then says so. */
+export declare function hookGroomer({ hooks, log }: HookDeps, pick: AgentPick | null): Promise<void>;
+/** Pauses the automation numbered `id`, or lets it run again. */
+export declare function hookPause({ hooks, log }: HookDeps, id: string, paused: boolean): Promise<void>;
+/** Asks for the automation numbered `id` to run now, which `splates server` does at once. */
+export declare function hookRun({ hooks, log }: HookDeps, id: string): Promise<void>;
+/** `automation` in a line: its number, trigger and what it runs. */
+export declare function described(automation: Automation): string;
+/** `trigger` in a few words, as `task.created in backlog, lane 3` or `every 1h`. */
+export declare function triggerLabel(trigger: Trigger): string;
+/** `hook` in a few words. */
+export declare function hookLabel(hook: Hook): string;

package/vendor/@stringsync/splates-server/hooks/edit.d.ts

@@ -0,0 +1,24 @@
+import type { AgentPick } from "../models";
+import { type Automation, type Hook, type Trigger } from "./store";
+/**
+ * What `splates hook edit` changes of an automation, each "" to leave it as
+ * it is: a new trigger from `event`, `every` or `cron`; its event narrowed
+ * anew by `stage` or `lane`, `any` for no narrowing; what an agent is told;
+ * or a shell command in place of what runs.
+ */
+export interface HookChange {
+    event: string;
+    every: string;
+    cron: string;
+    stage: string;
+    lane: string;
+    prompt: string;
+    run: string;
+    /** The agent to run in place of the one it runs, when given. */
+    pick?: AgentPick;
+}
+/** `automation`'s trigger and hook with `change` made, refusing one that will not fit. */
+export declare function changed(automation: Automation, change: HookChange): {
+    trigger: Trigger;
+    hook: Hook;
+};

package/vendor/@stringsync/splates-server/hooks/events.d.ts

@@ -0,0 +1,20 @@
+import type { Event } from "../records";
+/** Each event a task's life gives, in the order a task usually gives them. */
+export declare const TASK_EVENTS: readonly ["task.created", "task.updated", "task.ready", "task.queued", "task.started", "task.done", "task.dropped"];
+export type TaskEventName = (typeof TASK_EVENTS)[number];
+/** One change in a task's life, as hooks hear of it. */
+export interface TaskEvent {
+    name: TaskEventName;
+    /** The journal event it came from, so a follower takes each once. */
+    from: string;
+    at: string;
+    /** The tasks it is about, by number; none for a started one numbered off the list. */
+    numbers: number[];
+    /** The started task it is about, by name; null for one not started. */
+    task: string | null;
+}
+/**
+ * The task events journal event `event` gives: none for a refused command,
+ * or one that is no change in a task's life.
+ */
+export declare function taskEventsOf(event: Event): TaskEvent[];

package/vendor/@stringsync/splates-server/hooks/groomer.d.ts

@@ -0,0 +1,8 @@
+import type { Trigger } from "./store";
+/** The built-in automation the groomer runs as, once turned on from the Automations page. */
+export declare const GROOMER_AUTOMATION = "groomer";
+/**
+ * What wakes the groomer: a task added, to the backlog for grooming, or
+ * ready and Untriaged for a lane.
+ */
+export declare const GROOMER_TRIGGER: Trigger;

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

@@ -0,0 +1,17 @@
+export type { HookDeps } from "./commands";
+export { described, hookAdd, hookEdit, hookGroomer, hookLabel, hookList, hookPause, hookRemove, hookRun, triggerLabel, } from "./commands";
+export type { HookChange } from "./edit";
+export type { TaskEvent, TaskEventName } from "./events";
+export { TASK_EVENTS, taskEventsOf } from "./events";
+export { GROOMER_AUTOMATION, GROOMER_TRIGGER } from "./groomer";
+export { BY_HAND, runsNow } from "./now";
+export type { AutomationRow } from "./routes";
+export { AutomationRoutes } from "./routes";
+export type { FireDeps, Fired, HookActions, HookRunnerDeps } from "./runner";
+export { HookRunner } from "./runner";
+export type { AutomationRun, AutomationRuns } from "./runs";
+export { RunStore } from "./runs";
+export type { SchedulerDeps } from "./scheduler";
+export { Scheduler } from "./scheduler";
+export type { Automation, Hook, Hooks, TaskFilter, Trigger } from "./store";
+export { eventNamed, fromHooks, HookStore, lanesNamed, stagesNamed, } from "./store";

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

@@ -0,0 +1,61 @@
+import {
+  TASK_EVENTS2,
+  taskEventsOf2,
+  GROOMER_AUTOMATION2,
+  GROOMER_TRIGGER2,
+  BY_HAND2,
+  runsNow2,
+  HookStore2,
+  fromHooks2,
+  eventNamed2,
+  stagesNamed2,
+  lanesNamed2,
+  hookList2,
+  hookAdd2,
+  hookEdit2,
+  hookRemove2,
+  hookGroomer2,
+  hookPause2,
+  hookRun2,
+  described2,
+  triggerLabel2,
+  hookLabel2,
+  AutomationRoutes2,
+  HookRunner2,
+  RunStore2,
+  Scheduler2
+} from "../index-76t8y8h5.js";
+import"../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 {
+  AutomationRoutes2 as AutomationRoutes,
+  BY_HAND2 as BY_HAND,
+  GROOMER_AUTOMATION2 as GROOMER_AUTOMATION,
+  GROOMER_TRIGGER2 as GROOMER_TRIGGER,
+  HookRunner2 as HookRunner,
+  HookStore2 as HookStore,
+  RunStore2 as RunStore,
+  Scheduler2 as Scheduler,
+  TASK_EVENTS2 as TASK_EVENTS,
+  described2 as described,
+  eventNamed2 as eventNamed,
+  fromHooks2 as fromHooks,
+  hookAdd2 as hookAdd,
+  hookEdit2 as hookEdit,
+  hookGroomer2 as hookGroomer,
+  hookLabel2 as hookLabel,
+  hookList2 as hookList,
+  hookPause2 as hookPause,
+  hookRemove2 as hookRemove,
+  hookRun2 as hookRun,
+  lanesNamed2 as lanesNamed,
+  runsNow2 as runsNow,
+  stagesNamed2 as stagesNamed,
+  taskEventsOf2 as taskEventsOf,
+  triggerLabel2 as triggerLabel
+};

package/vendor/@stringsync/splates-server/hooks/now.d.ts

@@ -0,0 +1,9 @@
+import type { Automation } from "./store";
+/** What a run the person asked for was set off by, as its run lists it. */
+export declare const BY_HAND = "by hand";
+/**
+ * Whether `automation` can be run at once by hand: one on a schedule, or the
+ * groomer, which grooms the backlog as it stands. One on any other task
+ * event needs the event's tasks, so it runs only on that event.
+ */
+export declare function runsNow({ trigger, hook, }: Pick<Automation, "trigger" | "hook">): boolean;

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

@@ -0,0 +1,39 @@
+import type { AutomationRun, RunStore } from "./runs";
+import { type Automation, type HookStore } from "./store";
+/** One automation as the Automations page lists it. */
+export interface AutomationRow extends Automation {
+    /** Its trigger in a few words, as `task.created in backlog`. */
+    when: string;
+    /** What it runs in a few words. */
+    does: string;
+    /** Its latest runs, the latest last. */
+    runs: AutomationRun[];
+}
+/**
+ * The routes the Automations page reads and changes the person's
+ * automations through, each answering with every automation as it now
+ * stands. Spread one into a project's routes.
+ */
+export declare class AutomationRoutes {
+    #private;
+    constructor(store: HookStore, runs: RunStore, 
+    /** Every automation, the project's checked-in ones too. */
+    all: () => Promise<Automation[]>, 
+    /** Told once one is added, edited, removed, paused or resumed here. */
+    changed?: () => void, 
+    /** Runs each automation asked to run now; settles once they started. */
+    run?: () => Promise<void>);
+    readonly listAutomations: () => Promise<Response>;
+    readonly addAutomation: (request: Request) => Promise<Response>;
+    /**
+     * Edits one of the person's automations or, named `groomer`, sets the
+     * agent the groomer runs as, turning it on when it is off: its trigger
+     * and its prompt are splates's own.
+     */
+    readonly editAutomation: (request: Request) => Promise<Response>;
+    readonly removeAutomation: (request: Request) => Promise<Response>;
+    readonly pauseAutomation: (request: Request) => Promise<Response>;
+    readonly resumeAutomation: (request: Request) => Promise<Response>;
+    /** Runs one at once, answering once it started, its run listed. */
+    readonly runAutomation: (request: Request) => Promise<Response>;
+}

package/vendor/@stringsync/splates-server/hooks/runner.d.ts

@@ -0,0 +1,75 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import { type Timer } from "../../../core/time/index.js";
+import type { TaskStage } from "../board";
+import type { Journal } from "../records";
+import type { Storage } from "../storage";
+import { type TaskEvent } from "./events";
+import type { RunStore } from "./runs";
+import type { Automation, Hook } from "./store";
+/**
+ * What set an automation off: a task event, or its schedule coming due, or
+ * the person asking it to run now, which runs as its schedule would.
+ */
+export type Fired = {
+    event: TaskEvent;
+} | {
+    schedule: string;
+    byHand?: true;
+};
+/** What a hook does, by kind. */
+export interface HookActions {
+    run(command: string, fired: Fired): Promise<void>;
+    /** Starts an agent for automation `id` as `hook` says. */
+    agent(hook: Extract<Hook, {
+        kind: "agent";
+    }>, fired: Fired, id: string): Promise<void>;
+    /** Wakes the project's groomer, which the state, not `fired`, tells what to groom. */
+    groom(hook: Extract<Hook, {
+        kind: "groom";
+    }>): Promise<void>;
+}
+/** Runs `automation`'s hook for `fired`, keeping the run, and logging a failure rather than throwing it. */
+export declare function fire(automation: Automation, fired: Fired, { actions, runs, log, now }: FireDeps): Promise<void>;
+/** What `fire` works with. */
+export interface FireDeps {
+    actions: HookActions;
+    runs: RunStore;
+    log: Logger;
+    /** The time now, as an ISO string. */
+    now: () => string;
+}
+/**
+ * Runs the hooks set for each task event as the journal takes it, in the
+ * order it took them. Where it got to is kept in `seen`, so after a restart
+ * it catches up on what it missed; the first time, it starts from now
+ * rather than run hooks for the whole past.
+ */
+export declare class HookRunner implements Resource {
+    #private;
+    private readonly deps;
+    private constructor();
+    /** Runs hooks for each task event from where it got to, then follows the journal for more. */
+    static follow({ timer, ...deps }: HookRunnerDeps & {
+        timer?: Timer;
+    }): Promise<HookRunner>;
+    /** Runs hooks for what the journal took since the last look; settles once they ran. */
+    changed(): Promise<void>;
+    dispose(): void;
+}
+/** What a `HookRunner` works with. */
+export interface HookRunnerDeps extends FireDeps {
+    journal: Journal;
+    /**
+     * The project's, where the journal writes, watched for more, and where
+     * `hooks-seen.json` keeps how far it got, past a restart.
+     */
+    storage: Storage;
+    /** Every automation set now: the person's, and the shell hooks the project checks in. */
+    automations: () => Promise<Automation[]>;
+    /** Queued task `id`'s stage and lane now, or null for one off the list, for filters. */
+    task: (id: number) => Promise<{
+        stage: TaskStage;
+        lane: number | null;
+    } | null>;
+}

package/vendor/@stringsync/splates-server/hooks/runs.d.ts

@@ -0,0 +1,38 @@
+import type { Storage } from "../storage";
+/** One time an automation ran, as its page lists it. */
+export interface AutomationRun {
+    at: string;
+    /** What set it off: an event and its tasks, as `task.created #3`, `schedule`, or `by hand` when the person asked it to run now. */
+    on: string;
+    /** Why it failed, or null when it ran. */
+    error: string | null;
+}
+/** What is kept of each automation's runs, by its id. */
+export type AutomationRuns = Record<string, {
+    /** The latest last, at most `KEPT`. */
+    runs: AutomationRun[];
+    /** When its schedule last came due, so a restart runs a missed one once. */
+    scheduledAt?: string;
+    /** The automation's latest `requestedAt` it ran for, so each request runs once. */
+    requestedAt?: string;
+}>;
+/** How many runs each automation keeps. */
+export declare const KEPT = 5;
+/**
+ * The last runs of each automation, in `.git/splates/hooks-runs.json`. Only
+ * `splates server` writes it, one run at a time, so it takes no lock.
+ */
+export declare class RunStore {
+    #private;
+    constructor(
+    /** The project's, holding `hooks-runs.json`. */
+    storage: Storage);
+    /** Every automation's runs; none when the file is missing or will not parse. */
+    read(): Promise<AutomationRuns>;
+    /** Keeps that automation `id` ran, dropping its oldest past `KEPT`. */
+    ran(id: string, run: AutomationRun): Promise<void>;
+    /** Keeps that automation `id`'s schedule came due at `at`. */
+    scheduled(id: string, at: string): Promise<void>;
+    /** Keeps that automation `id` ran for the request made at `at`. */
+    requested(id: string, at: string): Promise<void>;
+}

package/vendor/@stringsync/splates-server/hooks/schedule.d.ts

@@ -0,0 +1,10 @@
+/** When a schedule runs next after a time, in epoch milliseconds. */
+export interface Schedule {
+    nextAfter(at: number): number;
+}
+/** A trigger's schedule, refusing one that will not read. */
+export declare function scheduleOf(trigger: {
+    every: string;
+} | {
+    cron: string;
+}): Schedule;

package/vendor/@stringsync/splates-server/hooks/scheduler.d.ts

@@ -0,0 +1,28 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import { type Timer, type WallClock } from "../../../core/time/index.js";
+import { type FireDeps } from "./runner";
+import type { Automation } from "./store";
+/**
+ * Runs each scheduled automation as it comes due, looking once a minute.
+ * When it came due more than once since its last run, as while
+ * `splates server` was down, it runs once, not once per miss. One the
+ * person asked to run now runs once for each request, its schedule left be.
+ */
+export declare class Scheduler implements Resource {
+    #private;
+    private readonly deps;
+    private constructor();
+    /** Runs what came due while it was down, then looks again each minute. */
+    static start({ timer, ...deps }: SchedulerDeps & {
+        timer?: Timer;
+    }): Promise<Scheduler>;
+    /** Runs each automation due now; settles once they ran. */
+    look(): Promise<void>;
+    dispose(): void;
+}
+/** What a `Scheduler` works with. */
+export interface SchedulerDeps extends FireDeps {
+    /** Every automation set now. */
+    automations: () => Promise<Automation[]>;
+    clock: WallClock;
+}

package/vendor/@stringsync/splates-server/hooks/store.d.ts

@@ -0,0 +1,110 @@
+import type { TaskStage } from "../board";
+import type { AgentPick } from "../models";
+import type { Storage } from "../storage";
+import { type TaskEventName } from "./events";
+/**
+ * What runs on a trigger: an agent told of it with a prompt, or a shell
+ * command.
+ */
+export type Hook = ({
+    kind: "agent";
+    prompt: string;
+} & AgentPick) | {
+    kind: "run";
+    command: string;
+}
+/** The project's groomer, told to groom the backlog, as built-in automation `groomer` runs. */
+ | ({
+    kind: "groom";
+} & AgentPick);
+/** Which tasks an event hook fires for; a field left out matches any. */
+export interface TaskFilter {
+    /** The stages the task stands in. */
+    stages?: TaskStage[];
+    /** The lanes it is in, by number. */
+    lanes?: number[];
+}
+/**
+ * What sets an automation off: a task event, narrowed by a filter; or a
+ * time, every so often (`30m`, `2h`, `1d`) or on a five-field cron.
+ */
+export type Trigger = {
+    event: TaskEventName;
+    filter?: TaskFilter;
+} | {
+    every: string;
+} | {
+    cron: string;
+};
+/** One thing that runs on a trigger, as the Automations page lists it. */
+export interface Automation {
+    /** Its number among the person's, or a name for one splates or the project sets. */
+    id: string;
+    trigger: Trigger;
+    hook: Hook;
+    /** Set while the person has it paused: it keeps its place and runs nothing. */
+    paused?: boolean;
+    /** When it was set, which a schedule counts its first run from. */
+    createdAt: string;
+    /** When its trigger last changed: its schedule counts from then, not from a run before. */
+    editedAt?: string;
+    /** When the person last asked it to run at once, which `splates server` runs it for once. */
+    requestedAt?: string;
+    /** Where it comes from: the person, by default; the project's config, or splates itself. */
+    source?: "config" | "builtin";
+}
+/**
+ * The automations one person set for one project, in
+ * `.git/splates/hooks.json`: never checked in, since an agent hook spends
+ * its person's tokens. None set, nothing runs.
+ */
+export declare class HookStore {
+    #private;
+    constructor(
+    /** The project's, holding `hooks.json`. */
+    storage: Storage);
+    /**
+     * Every automation set; none when the file is missing or will not parse.
+     * A file of the old form, each event's hooks, reads as one automation per
+     * hook, numbered in event order.
+     */
+    read(): Promise<Automation[]>;
+    /** Adds an automation of `hook` on `trigger`, numbered after the others. */
+    add(trigger: Trigger, hook: Hook): Promise<Automation>;
+    /**
+     * Takes away the automation numbered `id`, or, given an event's name,
+     * every one on that event; refuses one there is none of.
+     */
+    remove(id: string): Promise<Automation[]>;
+    /**
+     * Turns the groomer on, running as `pick`, or off for null: built-in
+     * automation `groomer`, which keeps its pause through a change of pick.
+     * Its trigger and what it is told are splates's own.
+     */
+    groomer(pick: AgentPick | null): Promise<Automation | null>;
+    /**
+     * Sets what sets the person's automation `id` off and what it runs, keeping
+     * its number, its pause and its runs; refuses one there is none of. A
+     * changed trigger is stamped, so its schedule counts from now.
+     */
+    edit(id: string, trigger: Trigger, hook: Hook): Promise<Automation>;
+    /** Pauses the automation numbered `id`, or lets it run again. */
+    pause(id: string, paused: boolean): Promise<Automation>;
+    /**
+     * Asks for the automation `id` to run at once, as `splates server` runs it
+     * for the request, its schedule left as it was; refuses one there is none
+     * of, or one that runs only on a task event.
+     */
+    request(id: string): Promise<Automation>;
+    private change;
+}
+/** Each event's hooks, in the order they run: the store's form before automations. */
+export type Hooks = Partial<Record<TaskEventName, Hook[]>>;
+/** The old form's hooks as automations, numbered in event order. */
+export declare function fromHooks(hooks: Hooks, source?: Automation["source"]): Automation[];
+/** `name` as a task event, refusing one that is none. */
+export declare function eventNamed(name: string): TaskEventName;
+/** `names` as task stages, refusing one that is none. */
+export declare function stagesNamed(names: readonly string[]): TaskStage[];
+/** `text` as lane numbers, comma separated, refusing what is none. */
+export declare function lanesNamed(text: string): number[];

package/vendor/@stringsync/splates-server/index-01z7ycdk.js

@@ -0,0 +1,6 @@
+// comma-list.ts
+function commaList2(raw) {
+  return raw.split(",").map((value) => value.trim()).filter(Boolean);
+}
+
+export { commaList2 };