@stringsync/splates 0.0.53 → 0.0.54

package/lane.ts

@@ -1,172 +0,0 @@
-import {
-	APPROVAL,
-	BACKLOG_LANE,
-	laneAdd,
-	laneList,
-	laneRemove,
-	laneShow,
-	laneUpdate,
-	laneUpdated,
-	recordLaneRemove,
-} from "@stringsync/splates-server/board";
-import { refuseGroomer } from "@stringsync/splates-server/conversations";
-import { UNTRIAGED } from "@stringsync/splates-server/plans";
-import { refuseAgentQueue } from "@stringsync/splates-server/queue";
-import { repository } from "@stringsync/splates-server/records";
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import { cli } from "webappwiz/cmd";
-import { z } from "zod";
-import { position } from "./flags";
-
-/** Backlog is lane zero, also addressable by its permanent name. */
-const laneNumber = z.union([
-	z.literal("backlog").transform(() => BACKLOG_LANE),
-	z.coerce.number().int().nonnegative(),
-]);
-
-/** `splates lane`, which the root cli mounts after `splates task`. */
-export const splatesLane = cli<SplatesDeps>("lane").description(
-	"lanes: named groups of tasks, for you to see related work together on the board; queue one whole with `splates lane queue`. Backlog (lane 0) is permanent and holds unmatched deferred work. Untriaged is groomed into lanes and cannot be queued whole",
-);
-
-splatesLane
-	.command("list")
-	.use(repository({ needs: "read" }))
-	.description(
-		"every lane: its name, its queued tasks in order, the started tasks on it, its next task, and what blocks that in other lanes",
-	)
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.action((opts, ctx) => laneList(ctx, { json: opts.json }));
-
-splatesLane
-	.command("show")
-	.use(repository({ needs: "read" }))
-	.description(
-		"one lane step by step, and what its agent does next: start the next task, or wait for the one blocking it in another lane to land first; `untriaged` lists the tasks in no lane, to place in lanes",
-	)
-	.arg(
-		"lane",
-		z.union([z.literal(UNTRIAGED).transform(() => null), laneNumber], {
-			error: "pass a lane's number, backlog, or untriaged",
-		}),
-		{ description: "lane number, `backlog`, or `untriaged`" },
-	)
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.action((opts, ctx) => laneShow(ctx, opts.lane, { json: opts.json }));
-
-splatesLane
-	.command("add")
-	.use(repository({ needs: "tasks" }))
-	.description("start an empty lane, after the others")
-	.arg("name", z.string(), {
-		description: "what its tasks are for, like `Licensing`",
-	})
-	.action(async (opts, ctx) => {
-		await ctx.journal.record(
-			"lane add",
-			null,
-			() => laneAdd(ctx, opts.name),
-			(lane) => ({ lane: lane.id, name: lane.name }),
-		);
-	});
-
-splatesLane
-	.command("update")
-	.use(repository({ needs: "tasks" }))
-	.description("rename a lane, or move it among the others")
-	.arg("lane", laneNumber, {
-		description: "lane number",
-	})
-	.option("name", z.string().optional(), {
-		description: "what it is called from now on",
-	})
-	.option("position", position, {
-		description:
-			"where to move it among the lanes, 1 the first column on the board; the others close up around it",
-	})
-	.action(async (opts, ctx) => {
-		const change = { name: opts.name, position: opts.position };
-		await ctx.journal.record(
-			"lane update",
-			null,
-			() => laneUpdate(ctx, opts.lane, change),
-			(record) => laneUpdated(opts.lane, record, change),
-		);
-	});
-
-splatesLane
-	.command("queue")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"queue a lane whole: each of its tasks is queued as soon as nothing blocks it, now and as tasks land, until the lane is empty; a task you take out with `splates queue remove` stays out until you queue it again. Untriaged cannot be queued whole",
-	)
-	.arg("lane", laneNumber, {
-		description: "lane number",
-	})
-	.action(async (opts, ctx) => {
-		refuseAgentQueue(ctx.service, "lane queue");
-		await refuseGroomer(ctx.service, "lane queue");
-		const change = { queued: true };
-		await ctx.journal.record(
-			"lane update",
-			null,
-			() => laneUpdate(ctx, opts.lane, change),
-			(record) => laneUpdated(opts.lane, record, change),
-		);
-	});
-
-splatesLane
-	.command("approve")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"let a queued lane queue more tasks on its own: it stops when its budget is spent, which starts at its tasks then plus 5, and this adds 10 to what is left; refused from an agent",
-	)
-	.arg("lane", laneNumber, {
-		description: "lane number",
-	})
-	.action(async (opts, ctx) => {
-		refuseAgentQueue(ctx.service, "lane approve");
-		const change = { approve: APPROVAL };
-		await ctx.journal.record(
-			"lane update",
-			null,
-			() => laneUpdate(ctx, opts.lane, change),
-			(record) => laneUpdated(opts.lane, record, change),
-		);
-	});
-
-splatesLane
-	.command("unqueue")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"stop queueing a lane whole, taking out of the queue each of its tasks that has yet to start; those under way go on",
-	)
-	.arg("lane", laneNumber, {
-		description: "lane number",
-	})
-	.action(async (opts, ctx) => {
-		refuseAgentQueue(ctx.service, "lane unqueue");
-		const change = { queued: false };
-		await ctx.journal.record(
-			"lane update",
-			null,
-			() => laneUpdate(ctx, opts.lane, change),
-			(record) => laneUpdated(opts.lane, record, change),
-		);
-	});
-
-splatesLane
-	.command("remove")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"remove a lane and its tasks, kept to restore; a lane whose last task merges goes on its own; refused from an agent, which asks with a permission card",
-	)
-	.arg("lane", laneNumber, {
-		description: "lane number",
-	})
-	.action((opts, ctx) => {
-		refuseAgentQueue(ctx.service, "lane remove");
-		return recordLaneRemove(ctx.journal, ctx.tasks, opts.lane, () =>
-			laneRemove(ctx, opts.lane),
-		);
-	});

package/notes.ts

@@ -1,19 +0,0 @@
-import { loadConfig } from "@stringsync/splates-server/config";
-import { Notes } from "@stringsync/splates-server/notes";
-import type { Repository } from "@stringsync/splates-server/records";
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-
-/** Prints the descriptions in this checkout, or the project explicitly named. */
-export async function notes(ctx: SplatesDeps & Repository): Promise<void> {
-	const root =
-		ctx.project === undefined
-			? (
-					await ctx.git.run(ctx.ps.cwd(), "rev-parse", "--show-toplevel")
-				).stdout.trim()
-			: ctx.git.root;
-	const config = await loadConfig(root, { fs: ctx.fs, git: ctx.git });
-	const found = await new Notes(ctx.fs).list(root, config);
-	for (const note of found) {
-		ctx.log.info(note.description);
-	}
-}

package/projects.test.ts

@@ -1,191 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { basename, join } from "node:path";
-import { Testing } from "@stringsync/splates-server/testing";
-import { projectArgs, splates } from "./splates";
-
-/**
- * Two projects on one machine, the first's registry naming both, its agent
- * running `splates` on the second with `--project`.
- */
-describe("splates across projects", () => {
-	let here: Testing;
-	let there: Testing;
-	let deps: Parameters<typeof splates.run>[0];
-	let hereSlug: string;
-	let thereSlug: string;
-
-	beforeEach(async () => {
-		here = await Testing.open();
-		there = await Testing.open();
-		await here.projects.register(there.root);
-		const listed = await here.projects.list();
-		const slug = (root: string) =>
-			listed.find((each) => each.root === root)?.slug ?? "";
-		hereSlug = slug(here.root);
-		thereSlug = slug(there.root);
-		here.ps.cd(here.root);
-		deps = {
-			log: here.log,
-			fs: here.fs,
-			ps: here.ps,
-			assets: here.assets,
-			secrets: here.secrets,
-		};
-	});
-
-	afterEach(async () => {
-		await here.disposeAsync();
-		await there.disposeAsync();
-	});
-
-	/** Runs `splates --project <there> ...args` from here. */
-	const onThere = (...args: string[]) =>
-		splates.run({ ...deps, project: thereSlug }, args);
-
-	it("splits a leading --project off the arguments", () => {
-		expect(projectArgs(["--project", "shop", "list"])).toEqual({
-			project: "shop",
-			argv: ["list"],
-		});
-		expect(projectArgs(["--project=shop", "list"])).toEqual({
-			project: "shop",
-			argv: ["list"],
-		});
-		expect(projectArgs(["list", "--project", "shop"])).toEqual({
-			argv: ["list", "--project", "shop"],
-		});
-	});
-
-	it("queues a task in its untriaged lane, saying where it came from", async () => {
-		await splates.run(deps, ["add", "alpha", "--goal", "Land it."]);
-		here.ps.cd((await here.service.find("alpha")).path);
-
-		await onThere(
-			"task",
-			"add",
-			"Export the parser",
-			"--slug",
-			"parser-export",
-		);
-
-		const thereSlug = (await here.projects.list()).find(
-			(each) => each.root === there.root,
-		)?.slug;
-		expect(String(here.log.entries.at(-1)?.message)).toContain(
-			`${thereSlug} #1 at`,
-		);
-
-		const [queued] = await there.tasks.all();
-		expect(queued?.state).toMatchObject({
-			subject: "Export the parser",
-			from: null,
-			lane: null,
-			origin: { project: here.root, task: "alpha" },
-		});
-		expect(await here.tasks.all()).toEqual([]);
-
-		await onThere("task", "show", String(queued?.id));
-		expect(String(here.log.entries.at(-1)?.message)).toContain(
-			`${thereSlug} #${queued?.id}`,
-		);
-		expect(String(here.log.entries.at(-1)?.message)).toContain(
-			`from:      ${basename(here.root)}/alpha`,
-		);
-	});
-
-	it("refuses a lane for a queued task from another project", async () => {
-		await onThere(
-			"task",
-			"add",
-			"Export the parser",
-			"--slug",
-			"parser-export",
-			"--lane",
-			"new",
-		);
-
-		expect(here.out()).toContain('"reason":"not_granted"');
-		expect(await there.tasks.all()).toEqual([]);
-	});
-
-	it("refuses what the other project has not granted, until it does", async () => {
-		await onThere(
-			"task",
-			"add",
-			"Export the parser",
-			"--slug",
-			"parser-export",
-		);
-		await onThere("task", "remove", "1");
-		expect(here.out()).toContain('"reason":"not_granted"');
-		expect(here.out()).toContain(`splates projects grant ${hereSlug} tasks`);
-		expect(await there.tasks.all()).toHaveLength(1);
-
-		// The person, in the other project's main tree.
-		here.ps.cd(there.root);
-		await splates.run(deps, ["projects", "grant", hereSlug, "tasks"]);
-		expect(await here.projects.reach(here.root, there.root)).toBe("tasks");
-
-		here.ps.cd(here.root);
-		await onThere("task", "remove", "1");
-		expect(await there.tasks.all()).toEqual([]);
-	});
-
-	it("starts no task in another project, granted or not, so it is queued there", async () => {
-		await here.projects.grant(there.root, here.root, "tasks");
-
-		await onThere("add", "beta", "--goal", "Do it.", "--agent", "claude");
-
-		expect(here.out()).toContain('"reason":"not_granted"');
-		expect(here.out()).toContain("task add");
-		expect((await there.service.find("beta")).gone).toBe(true);
-	});
-
-	it("refuses a command only a project runs on itself", async () => {
-		await here.projects.grant(there.root, here.root, "tasks");
-
-		await onThere("projects", "grant", hereSlug, "tasks");
-
-		expect(here.out()).toContain('"reason":"not_granted"');
-	});
-
-	it("checks an agent of this project's page that changes into the other", async () => {
-		await here.projects.grant(there.root, here.root, "read");
-		await here.fs.mkdir(join(here.root, ".git/splates/conversations"));
-		await here.fs.write(
-			join(here.root, ".git/splates/conversations/c1.jsonl"),
-			"",
-		);
-		here.proc.env.SPLATES_CONVERSATION = "c1";
-		here.ps.cd(there.root);
-
-		await splates.run(deps, [
-			"task",
-			"add",
-			"Export the parser",
-			"--slug",
-			"parser-export",
-		]);
-		expect(here.out()).toContain('"reason":"not_granted"');
-		expect(await there.tasks.all()).toEqual([]);
-
-		await splates.run(deps, ["task", "list", "--json"]);
-		expect(JSON.parse(String(here.log.entries.at(-1)?.message))).toEqual([]);
-	});
-
-	it("lists what each project may do in the other", async () => {
-		await here.projects.grant(there.root, here.root, "tasks");
-
-		await splates.run(deps, ["projects", "list", "--json"]);
-
-		expect(JSON.parse(String(here.log.entries.at(-1)?.message))).toEqual([
-			{
-				slug: thereSlug,
-				root: there.root,
-				gone: false,
-				here: "queue",
-				there: "tasks",
-			},
-		]);
-	});
-});

package/projects.ts

@@ -1,37 +0,0 @@
-import {
-	grantReach,
-	listReaches,
-	REACHES,
-} from "@stringsync/splates-server/projects";
-import { repository } from "@stringsync/splates-server/records";
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import { cli } from "webappwiz/cmd";
-import { z } from "zod";
-
-/** `splates projects`, which the root cli mounts after `splates lane`. */
-export const splatesProjects = cli<SplatesDeps>("projects")
-	.description(
-		"the other splates projects on this machine, and what agents of each may do in the others through splates: `read` their tasks and lanes; add tasks to their untriaged lane with `queue`, as every project may until granted otherwise; or run their queue, lanes and hooks with `tasks`. Any repo command runs on another project as `splates --project <slug> <command>`, refused where it needs more than that project granted",
-	)
-	.fallback("list");
-
-splatesProjects
-	.command("list")
-	.use(repository({ needs: "read" }))
-	.description(
-		"print each other project: its slug, its root, what it may do here, and what this one may do there",
-	)
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.action((opts, ctx) => listReaches(ctx, { json: opts.json }));
-
-splatesProjects
-	.command("grant")
-	.use(repository({ needs: "own" }))
-	.description(
-		"let agents of another project do as much as `read`, `queue` or `tasks` here, each including those before it; the user's call, so an agent runs it only when the user asks it to",
-	)
-	.arg("project", z.string(), { description: "the other project's slug" })
-	.arg("reach", z.enum(REACHES), {
-		description: "read, queue or tasks",
-	})
-	.action((opts, ctx) => grantReach(ctx, opts.project, opts.reach));

package/queue.ts

@@ -1,82 +0,0 @@
-import { tasksNamed } from "@stringsync/splates-server/board";
-import { refuseGroomer } from "@stringsync/splates-server/conversations";
-import {
-	queueAdd,
-	queueList,
-	queueMove,
-	queueRemove,
-	refuseAgentQueue,
-} from "@stringsync/splates-server/queue";
-import { repository } from "@stringsync/splates-server/records";
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import { cli } from "webappwiz/cmd";
-import { z } from "zod";
-import { here } from "./flags";
-
-/** `splates queue`, which the root cli mounts beside `splates task`. */
-export const splatesQueue = cli<SplatesDeps>("queue").description(
-	"the queue: the tasks a worker of `splates server` starts as soon as it has a slot free, each after every task it is blocked by, otherwise in the order you set. Only you queue a task, from the backlog or groomed, and an agent asks you to with a queue card; one that names no model runs on the roster's first agent",
-);
-
-splatesQueue
-	.command("list")
-	.use(repository({ needs: "read" }))
-	.description(
-		"the queue in the order workers start it, with each task's model and what it waits on: the open tasks it is blocked by, or those removed without merging",
-	)
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.action((opts, ctx) => queueList(ctx, { json: opts.json }));
-
-splatesQueue
-	.command("add")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"queue tasks for a worker to start once nothing they are blocked by is open; refused for one already under way",
-	)
-	.rest("ids", z.coerce.number().int().positive(), {
-		description: "task numbers",
-	})
-	.action(async (opts, ctx) => {
-		refuseAgentQueue(ctx.service, "queue add");
-		await refuseGroomer(ctx.service, "queue add");
-		await ctx.journal.record(
-			"queue add",
-			await here(ctx),
-			() => queueAdd(ctx, opts.ids),
-			(queued) => ({ tasks: tasksNamed(queued) }),
-		);
-	});
-
-splatesQueue
-	.command("remove")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"take tasks out of the queue, back to ready when they name a model, else the backlog; the tasks stay",
-	)
-	.rest("ids", z.coerce.number().int().positive(), {
-		description: "task numbers",
-	})
-	.action(async (opts, ctx) => {
-		refuseAgentQueue(ctx.service, "queue remove");
-		await ctx.journal.record(
-			"queue remove",
-			await here(ctx),
-			() => queueRemove(ctx, opts.ids),
-			(removed) => ({ tasks: tasksNamed(removed) }),
-		);
-	});
-
-splatesQueue
-	.command("move")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"move a queued task to another place in the queue, from 1 for the next to start; what it is blocked by still goes first. Then lists the queue",
-	)
-	.arg("id", z.coerce.number().int().positive(), { description: "task number" })
-	.arg("position", z.coerce.number().int().positive(), {
-		description: "where in the queue to put it, from 1",
-	})
-	.action(async (opts, ctx) => {
-		refuseAgentQueue(ctx.service, "queue move");
-		return queueMove(ctx, opts.id, opts.position);
-	});