@stringsync/splates 0.0.53 → 0.0.54

package/flags.ts

@@ -1,157 +0,0 @@
-import { BACKLOG_LANE } from "@stringsync/splates-server/board";
-import { commaList } from "@stringsync/splates-server/comma-list";
-import { SYSTEM_STORES } from "@stringsync/splates-server/creds";
-import { fail } from "@stringsync/splates-server/exit";
-import {
-	type AgentPick,
-	Offered,
-	pickAgent,
-	pickEffort,
-	type RosterAgent,
-	splatesHome,
-} from "@stringsync/splates-server/models";
-import { SLOT_POOL } from "@stringsync/splates-server/ports";
-import type { Repository } from "@stringsync/splates-server/records";
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import { rosterOf, seeded } from "@stringsync/splates-server/server";
-import { FsStorage } from "@stringsync/splates-server/storage";
-import { SavedTunnel } from "@stringsync/splates-server/tunnel";
-import { z } from "zod";
-
-/** A place in the queue, 1 at the top; absent leaves it to the command. */
-export const position = z.coerce.number().int().positive().optional();
-
-/**
- * The agent `--agent`, `--model` and `--effort` name off the roster:
- * undefined when none is given, null for `--agent none`.
- */
-export async function assigneeIn(
-	deps: SplatesDeps,
-	agent: string,
-	model: string,
-	effort: string,
-): Promise<AgentPick | null | undefined> {
-	if (agent === "") {
-		if (model !== "" || effort !== "") {
-			fail("usage", "--model and --effort go with --agent", {
-				model,
-				effort,
-			});
-		}
-		return undefined;
-	}
-	if (agent === "none") {
-		return null;
-	}
-	return pickIn(deps, await seeded(rosterOf(deps)), agent, model, effort);
-}
-
-/**
- * `agent` on `model` off `agents`, at the thinking level `effort` names
- * among those it offers, each left out when empty.
- */
-export async function pickIn(
-	deps: SplatesDeps,
-	agents: RosterAgent[],
-	agent: string,
-	model: string,
-	effort: string,
-	data: Record<string, unknown> = {},
-): Promise<AgentPick> {
-	const picked = pickAgent(
-		agents,
-		agent,
-		model === "" ? undefined : model,
-		data,
-	);
-	return { ...picked, ...(await effortIn(deps, picked.agent, effort, data)) };
-}
-
-/**
- * `{ effort }` for the thinking level `effort` names among those `agent`
- * offered when last started, or nothing when it is empty.
- */
-export async function effortIn(
-	deps: SplatesDeps,
-	agent: string,
-	effort: string,
-	data: Record<string, unknown> = {},
-): Promise<{ effort?: string }> {
-	if (effort === "") {
-		return {};
-	}
-	const offered = (await offeredOf(deps).all())[agent];
-	return { effort: pickEffort(offered, agent, effort, data) };
-}
-
-/** The settings each agent offered when last started, from any project. */
-export function offeredOf({ ps, fs }: SplatesDeps): Offered {
-	return new Offered(
-		new FsStorage(splatesHome(ps), fs).document("offered.json"),
-	);
-}
-
-/** The tunnel each slot's home may have saved, for every word of the pool. */
-export function slotTunnelsOf({
-	ps,
-	fs,
-	secrets = SYSTEM_STORES,
-}: SplatesDeps): SavedTunnel[] {
-	return SLOT_POOL.map(({ word }) =>
-		SavedTunnel.in(
-			new FsStorage(`${splatesHome(ps)}/slots/${word}`, fs),
-			secrets.device,
-		),
-	);
-}
-
-/** `--lane 3`, `new` or `none` as a lane; absent leaves it to the command. */
-export function laneIn(raw: string): number | "new" | null | undefined {
-	const value = raw.trim();
-	if (value === "") {
-		return undefined;
-	}
-	if (value === "new") {
-		return "new";
-	}
-	if (value === "none") {
-		return null;
-	}
-	if (value === "backlog") {
-		return BACKLOG_LANE;
-	}
-	const id = Number(value);
-	if (!Number.isInteger(id) || id < 0) {
-		fail("usage", `'${value}' is not a lane: pass its number, new or none`, {
-			lane: value,
-		});
-	}
-	return id;
-}
-
-/** `--task 3,5` as task numbers, refusing anything that is not one. */
-export function taskIds(raw: string): number[] {
-	return commaList(raw).map((value) => {
-		const id = Number(value);
-		if (!Number.isInteger(id) || id <= 0) {
-			fail("usage", `'${value}' is not a task number`, { number: value });
-		}
-		return id;
-	});
-}
-
-/**
- * Which task a command that takes no task name is about, so the journal can
- * name it. `merge` reads it off the current branch.
- */
-export async function here({
-	service,
-	git,
-	ps,
-	project,
-}: SplatesDeps & Repository): Promise<string | null> {
-	// Run with `--project`, the working directory is another repository's.
-	return project === undefined
-		? service.taskFor(await git.currentBranch(ps.cwd()))
-		: null;
-}

package/hook.ts

@@ -1,328 +0,0 @@
-import { commaList } from "@stringsync/splates-server/comma-list";
-import { fail } from "@stringsync/splates-server/exit";
-import {
-	type Hook,
-	HookStore,
-	hookAdd,
-	hookEdit,
-	hookGardener,
-	hookGroomer,
-	hookList,
-	hookPause,
-	hookRemove,
-	lanesNamed,
-	stagesNamed,
-	TASK_EVENTS,
-	type TaskEventName,
-	type TaskFilter,
-	type Trigger,
-} from "@stringsync/splates-server/hooks";
-import { repository } from "@stringsync/splates-server/records";
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import type { Storage } from "@stringsync/splates-server/storage";
-import { cli } from "webappwiz/cmd";
-import { z } from "zod";
-import { assigneeIn } from "./flags";
-
-/** `splates hook`, which the root cli mounts beside `splates queue`. */
-export const splatesHook = cli<SplatesDeps>("hook").description(
-	`automations: what runs on a task event (${TASK_EVENTS.join(", ")}), as \`splates server\` sees the journal take it, or on a schedule it keeps: an agent told of it; or a shell command. Kept for you in this project's .git/splates, never checked in, since an agent hook spends your tokens; splates.config.ts's \`on\` holds the shell commands a project checks in. None set, nothing runs. The page's Automations tab lists them with when each last ran and for what task`,
-);
-
-splatesHook
-	.command("list")
-	.use(repository({ needs: "read" }))
-	.description("every automation set here, by number, with its trigger")
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.action((opts, ctx) =>
-		hookList({ hooks: storeOf(ctx), log: ctx.log }, { json: opts.json }),
-	);
-
-splatesHook
-	.command("add")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"run something on a task event, or on a schedule with `--every` or `--cron` in place of the event: `--agent <a> --prompt <words>` starts that agent in the main tree, told the event as `[SPLATES EVENT <event> #N]`, or a schedule as `[SPLATES SCHEDULE <number>]`, then your words; `--run <command>` runs it via `sh -c` in the main tree, with $SPLATES_EVENT (`schedule` for one), $SPLATES_TASKS and $SPLATES_TASK set. A schedule that came due while `splates server` was down runs once as it starts",
-	)
-	.arg("event", z.string().optional(), {
-		description: "the task event, as task.created; none for a schedule",
-	})
-	.option("stage", z.string(), {
-		default: "",
-		description:
-			"only for tasks in these stages, comma separated: backlog, ready, queued, running",
-	})
-	.option("lane", z.string(), {
-		default: "",
-		description: "only for tasks in these lanes, by number, comma separated",
-	})
-	.option("every", z.string(), {
-		default: "",
-		description: "run every so often, as 30m, 2h or 1d",
-	})
-	.option("cron", z.string(), {
-		default: "",
-		description:
-			'run on a five-field cron line, in this machine\'s time, as "0 9 * * 1-5"',
-	})
-	.option("agent", z.string(), {
-		default: "",
-		description: "the agent to run, as `splates agents` names it",
-	})
-	.option("model", z.string(), {
-		default: "",
-		description: "its model (default: the agent's own)",
-	})
-	.option("effort", z.string(), {
-		default: "",
-		description: "its thinking level (default: the agent's own)",
-	})
-	.option("prompt", z.string(), {
-		default: "",
-		description: "what the agent is told after the event",
-	})
-	.option("run", z.string(), {
-		default: "",
-		description: "a shell command to run",
-	})
-	.action(async (opts, ctx) => {
-		const pick = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
-		let hook: Hook;
-		if (opts.run !== "") {
-			if (pick != null || opts.prompt !== "") {
-				fail("usage", "--run goes alone: a shell command runs no agent", {});
-			}
-			hook = { kind: "run", command: opts.run };
-		} else if (pick == null) {
-			fail("usage", "say what runs: --agent with --prompt, or --run", {});
-		} else if (opts.prompt === "") {
-			fail("usage", "an agent hook needs --prompt: what to tell it", {});
-		} else {
-			hook = { kind: "agent", prompt: opts.prompt, ...pick };
-		}
-		await hookAdd({ hooks: storeOf(ctx), log: ctx.log }, triggerOf(opts), hook);
-	});
-
-splatesHook
-	.command("edit")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"change one of your automations, by its number in `splates hook list`, keeping its number, its pause and its last runs. Each flag changes only what it names, as `splates hook add` takes it: `--event`, `--every` or `--cron` sets what sets it off anew, `--stage` or `--lane` alone narrows its event again (`any` for no narrowing), `--prompt` or `--agent` changes what an agent is told or which agent, and `--run` makes it a shell command. The groomer changes through `splates hook groomer`",
-	)
-	.arg("id", z.string(), { description: "its number in `splates hook list`" })
-	.option("event", z.string(), {
-		default: "",
-		description:
-			"a task event to run on, as task.created, in place of what sets it off now",
-	})
-	.option("stage", z.string(), {
-		default: "",
-		description:
-			"only for tasks in these stages, comma separated, or `any`: backlog, ready, queued, running",
-	})
-	.option("lane", z.string(), {
-		default: "",
-		description:
-			"only for tasks in these lanes, by number, comma separated, or `any`",
-	})
-	.option("every", z.string(), {
-		default: "",
-		description: "run every so often, as 30m, 2h or 1d",
-	})
-	.option("cron", z.string(), {
-		default: "",
-		description:
-			'run on a five-field cron line, in this machine\'s time, as "0 9 * * 1-5"',
-	})
-	.option("agent", z.string(), {
-		default: "",
-		description: "the agent to run, as `splates agents` names it",
-	})
-	.option("model", z.string(), {
-		default: "",
-		description: "its model, with --agent (default: the agent's own)",
-	})
-	.option("effort", z.string(), {
-		default: "",
-		description: "its thinking level, with --agent (default: the agent's own)",
-	})
-	.option("prompt", z.string(), {
-		default: "",
-		description: "what the agent is told after the event",
-	})
-	.option("run", z.string(), {
-		default: "",
-		description: "a shell command to run in place of an agent",
-	})
-	.action(async (opts, ctx) => {
-		const { id, agent, model, effort, ...change } = opts;
-		const pick = await assigneeIn(ctx, agent, model, effort);
-		if (pick === null) {
-			fail(
-				"usage",
-				"an agent automation needs an agent: name one, or --run",
-				{},
-			);
-		}
-		await hookEdit({ hooks: storeOf(ctx), log: ctx.log }, id, {
-			...change,
-			...(pick === undefined ? {} : { pick }),
-		});
-	});
-
-splatesHook
-	.command("remove")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"take away an automation, by its number in `splates hook list`, or every one on an event",
-	)
-	.arg("id", z.string(), {
-		description: "its number, or a task event, as task.created",
-	})
-	.action((opts, ctx) =>
-		hookRemove({ hooks: storeOf(ctx), log: ctx.log }, opts.id),
-	);
-
-splatesHook
-	.command("pause")
-	.use(repository({ needs: "tasks" }))
-	.description("stop an automation running, keeping it to resume")
-	.arg("id", z.string(), { description: "its number in `splates hook list`" })
-	.action((opts, ctx) =>
-		hookPause({ hooks: storeOf(ctx), log: ctx.log }, opts.id, true),
-	);
-
-splatesHook
-	.command("resume")
-	.use(repository({ needs: "tasks" }))
-	.description("let a paused automation run again")
-	.arg("id", z.string(), { description: "its number in `splates hook list`" })
-	.action((opts, ctx) =>
-		hookPause({ hooks: storeOf(ctx), log: ctx.log }, opts.id, false),
-	);
-
-splatesHook
-	.command("groomer")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"turn on the project's groomer, built-in automation `groomer`, or set the agent it runs as, as the Automations page does: on each task deferred to the backlog, and the backlog as `splates server` starts, a conversation of its own per run, archived as the run ends, organizes each task in order and marks it ready, never doing it. `--off` turns it off, retiring its conversations",
-	)
-	.option("agent", z.string(), {
-		default: "",
-		description: "the agent it runs as, as `splates agents` names it",
-	})
-	.option("model", z.string(), {
-		default: "",
-		description: "its model (default: the agent's own)",
-	})
-	.option("effort", z.string(), {
-		default: "",
-		description: "its thinking level (default: the agent's own)",
-	})
-	.option("off", z.boolean(), {
-		default: false,
-		description: "turn it off",
-	})
-	.action(async (opts, ctx) => {
-		const pick = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
-		if (opts.off === (pick != null)) {
-			fail(
-				"usage",
-				"say how it runs with --agent, or turn it off with --off",
-				{},
-			);
-		}
-		await hookGroomer({ hooks: storeOf(ctx), log: ctx.log }, pick ?? null);
-	});
-
-splatesHook
-	.command("gardener")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"turn on the notes gardener, built-in automation `notes-gardener`, or set the agent it runs as and its schedule, as the Automations page does: on each run, an agent reads each project note no open task names by its path, checks it against the code and the other notes, and drafts the fixes in one task, `notes-garden`: rewriting what went stale, merging notes that say one thing, splitting one that says several, settling a contradiction the code settles and sharpening descriptions, then asks you to review the change rather than merge it, asking about any contradiction the code does not settle. No run starts while `notes-garden` is open. Off by default, since each run reads code for every note on your tokens; it runs every 7d until you set `--every` or `--cron`. `--off` turns it off",
-	)
-	.option("agent", z.string(), {
-		default: "",
-		description: "the agent it runs as, as `splates agents` names it",
-	})
-	.option("model", z.string(), {
-		default: "",
-		description: "its model (default: the agent's own)",
-	})
-	.option("effort", z.string(), {
-		default: "",
-		description: "its thinking level (default: the agent's own)",
-	})
-	.option("every", z.string(), {
-		default: "",
-		description: "run every so often, as 1d (default: as it was, or 7d)",
-	})
-	.option("cron", z.string(), {
-		default: "",
-		description:
-			'run on a five-field cron line, in this machine\'s time, as "0 9 * * 1"',
-	})
-	.option("off", z.boolean(), {
-		default: false,
-		description: "turn it off",
-	})
-	.action(async (opts, ctx) => {
-		const pick = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
-		if (opts.off === (pick != null)) {
-			fail(
-				"usage",
-				"say how it runs with --agent, or turn it off with --off",
-				{},
-			);
-		}
-		await hookGardener({ hooks: storeOf(ctx), log: ctx.log }, pick ?? null, {
-			every: opts.every,
-			cron: opts.cron,
-		});
-	});
-
-/** What sets the automation `splates hook add` adds off, refusing two triggers or none. */
-function triggerOf(opts: TriggerOptions): Trigger {
-	const given = [opts.event, opts.every, opts.cron].filter(
-		(each) => each !== undefined && each !== "",
-	);
-	if (given.length !== 1) {
-		fail(
-			"usage",
-			"say what sets it off: a task event, --every or --cron, one of them",
-			{},
-		);
-	}
-	if (opts.event === undefined || opts.event === "") {
-		if (opts.stage !== "" || opts.lane !== "") {
-			fail(
-				"usage",
-				"--stage and --lane narrow a task event, not a schedule",
-				{},
-			);
-		}
-		return opts.every !== "" ? { every: opts.every } : { cron: opts.cron };
-	}
-	const filter: TaskFilter = {};
-	if (opts.stage !== "") {
-		filter.stages = stagesNamed(commaList(opts.stage));
-	}
-	if (opts.lane !== "") {
-		filter.lanes = lanesNamed(opts.lane);
-	}
-	const event = opts.event as TaskEventName;
-	return Object.keys(filter).length === 0 ? { event } : { event, filter };
-}
-
-/** The options of `splates hook add` that say what sets it off. */
-interface TriggerOptions {
-	event?: string;
-	every: string;
-	cron: string;
-	stage: string;
-	lane: string;
-}
-
-function storeOf(ctx: { storage: Storage }) {
-	return new HookStore(ctx.storage);
-}

package/index.ts

@@ -1,18 +0,0 @@
-#!/usr/bin/env bun
-import { basename } from "node:path";
-import {
-	LEGACY,
-	legacyWarnings,
-	systemPs,
-} from "@stringsync/splates-server/config";
-import { assets } from "@stringsync/splates-server/server";
-import { NodeFs } from "webappwiz/system";
-import { projectArgs, splates } from "./splates";
-
-// The bin's old name, kept for one release.
-if (basename(process.argv[1] ?? "") === LEGACY) {
-	legacyWarnings.once(LEGACY, "splates");
-}
-const ps = systemPs();
-const { project, argv } = projectArgs(ps.args);
-await splates.run({ fs: new NodeFs(), ps, assets, project }, argv);

package/infra.ts

@@ -1,107 +0,0 @@
-import { resolve } from "node:path";
-import { commaList } from "@stringsync/splates-server/comma-list";
-import {
-	ACCESS_ENVIRONMENT,
-	accessEnvironmentExists,
-	CoordinatorBox,
-	pulumiOrg,
-	writeInfraConfig,
-} from "@stringsync/splates-server/coordinator";
-import { fail } from "@stringsync/splates-server/exit";
-import { infraConfigure } from "@stringsync/splates-server/infra/configure";
-import { secretsEnvironmentUrl } from "@stringsync/splates-server/infra/secrets";
-import { Projects } from "@stringsync/splates-server/projects";
-import { repository } from "@stringsync/splates-server/records";
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import { savedTunnelOf } from "@stringsync/splates-server/server";
-import { FsStorage } from "@stringsync/splates-server/storage";
-import { cli } from "webappwiz/cmd";
-import { z } from "zod";
-
-/** `splates server infra`, which `splates server` mounts. */
-export const splatesInfra = cli<SplatesDeps>("infra").description(
-	"the Pulumi project that makes everything the server's box needs in AWS, Cloudflare and GitHub, which `splates server deploy` then installs splates on",
-);
-
-splatesInfra
-	.command("init")
-	.use(repository({ needs: "own" }))
-	.description(
-		"write a Pulumi project in <dir>, its program a dozen lines using the components of @stringsync/splates-server/infra, and the stack's config from the flags; run again, it writes only what is not so already and keeps values you changed. It fills the stack's config from what splates keeps (the projects, the saved tunnel, the Cloudflare ids). The secrets never pass through splates: it makes the Pulumi ESC environment splates/secrets with a placeholder for each (the Cloudflare token, a GitHub token per owner, the Anthropic key), which the stack imports and the user replaces on the Pulumi site; `splates setup` has a step for each saying how to get it. When the Pulumi ESC environment `coordinator-access` makes (splates/aws) is there, the stack imports it. It records the directory in ~/.splates/coordinator/infra.json, where `splates server deploy` finds the stack. Its runtime is bun, which runs the program's TypeScript itself. Commit the project but not Pulumi.<stack>.yaml, which holds your own accounts and ids and which the .gitignore it writes keeps out of git; init writes it again from what splates keeps. Then `bun add @stringsync/splates-server @pulumi/pulumi @pulumi/aws @pulumi/awsx @pulumi/cloudflare @pulumi/github @pulumi/tls @pulumi/random` there and `pulumi up`",
-	)
-	.arg("dir", z.string(), { description: "where the Pulumi project goes" })
-	.option("stack", z.string(), { default: "prod", description: "the stack" })
-	.option("host", z.string(), {
-		default: "",
-		description:
-			"the public host name, as in splates.example.com; the saved tunnel's by default",
-	})
-	.option("email", z.string(), {
-		default: "",
-		description:
-			"the email address Access lets in; the tunnel's Access application's by default",
-	})
-	.option("region", z.string(), {
-		default: "us-east-1",
-		description: "the AWS region",
-	})
-	.option("projects", z.string(), {
-		default: "",
-		description:
-			"comma-separated slug=owner/repo, each a project the box pushes trunk of; every project registered here with a GitHub origin by default",
-	})
-	.action(async (opts, ctx) => {
-		const listed = commaList(opts.projects).map((entry) => {
-			const [slug, repository] = entry.split("=");
-			if (!slug || !repository?.includes("/")) {
-				fail("usage", `--projects wants slug=owner/repo, not ${entry}`, {
-					entry,
-				});
-			}
-			return { slug, repository };
-		});
-		const org = await pulumiOrg(ctx.ps);
-		const home = new CoordinatorBox({ ps: ctx.ps, fs: ctx.fs }).home;
-		const { written, todo } = await infraConfigure({
-			dir: opts.dir,
-			stack: opts.stack,
-			host: opts.host,
-			email: opts.email,
-			region: opts.region,
-			projects: listed.length === 0 ? null : listed,
-			registered: async () =>
-				(await Projects.in(new FsStorage(home, ctx.fs), ctx.fs).list()).filter(
-					(project) => !project.gone,
-				),
-			creds: ctx.creds,
-			saved: savedTunnelOf(ctx),
-			// The sign-in `coordinator-access` made, once it is there.
-			...(org !== null && (await accessEnvironmentExists(ctx.ps, org))
-				? { environment: ACCESS_ENVIRONMENT }
-				: {}),
-			fs: ctx.fs,
-			ps: ctx.ps,
-			log: ctx.log,
-			fetch: ctx.fetch,
-		});
-		await writeInfraConfig(ctx.fs, home, {
-			dir: resolve(opts.dir),
-			stack: opts.stack,
-		});
-		ctx.log.info(
-			written.length === 0
-				? "already so: nothing written"
-				: `wrote ${written.join(", ")}`,
-		);
-		ctx.log.info(
-			`Pulumi.${opts.stack}.yaml stays out of git: it holds your own accounts and ids, and init writes it again from what splates keeps`,
-		);
-		for (const command of todo) {
-			ctx.log.info(`still to run in ${opts.dir}: ${command}`);
-		}
-		if (org !== null) {
-			ctx.log.info(
-				`paste each secret over its placeholder at ${secretsEnvironmentUrl(org)}: \`splates setup\` has a step for each saying how to get it`,
-			);
-		}
-	});

package/lane.test.ts

@@ -1,29 +0,0 @@
-import { expect, it } from "bun:test";
-import { Testing } from "@stringsync/splates-server/testing";
-import { splates } from "./splates";
-
-it("addresses permanent Backlog by name in both task and lane commands", async () => {
-	await using testing = await Testing.open();
-	testing.ps.cd(testing.root);
-	const deps = {
-		log: testing.log,
-		fs: testing.fs,
-		ps: testing.ps,
-		assets: testing.assets,
-		secrets: testing.secrets,
-	};
-	await splates.run(deps, [
-		"task",
-		"defer",
-		"later",
-		"--slug",
-		"later",
-		"--lane",
-		"backlog",
-	]);
-	const [task] = await testing.tasks.all();
-	expect(task?.lane, testing.out()).toBe(0);
-	testing.log.clear();
-	await splates.run(deps, ["lane", "show", "backlog", "--json"]);
-	expect(JSON.parse(testing.out())).toMatchObject({ lane: 0, name: "Backlog" });
-});