@webappwiz/arbor 0.0.30 → 0.0.31

package/add.ts

@@ -1,192 +0,0 @@
-import { color, type Logger } from "webappwiz/log";
-import { MarkdownWriter } from "webappwiz/md";
-import type { Fs } from "webappwiz/system";
-import type { Config } from "./config";
-import { fail } from "./exit";
-import { PLAN_FILE } from "./plan";
-import type { Shell } from "./shell";
-import type { Todo, Todos } from "./todo";
-import type { WorktreeService } from "./worktree-service";
-
-const NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-
-export interface AddOptions {
-	/** Branch the task starts from and merges onto. Defaults to the trunk. */
-	base?: string;
-	/**
-	 * The todos this task takes up: their words seed the plan's Goal, and
-	 * nobody else can take them while the task lives.
-	 */
-	todos?: number[];
-}
-
-export async function add(
-	{
-		service,
-		shell,
-		config,
-		log,
-		fs,
-		todos,
-	}: {
-		service: WorktreeService;
-		shell: Shell;
-		config: Config;
-		log: Logger;
-		fs: Fs;
-		todos: Todos;
-	},
-	task: string,
-	{ base = config.trunk, todos: ids = [] }: AddOptions = {},
-): Promise<void> {
-	if (!NAME.test(task)) {
-		fail(
-			"usage",
-			`invalid task name '${task}': use lowercase letters, digits and dashes`,
-			{ task },
-		);
-	}
-
-	// A worktree gets its own empty submodule directories, so every task would
-	// have to bootstrap them before anything builds. Refuse the repo instead.
-	// Git only reads the superproject's top-level file, so there is nowhere else
-	// to look; a stale one with no live gitlink refuses too, which is the safe
-	// direction to be wrong in.
-	if (await fs.exists(`${service.git.root}/.gitmodules`)) {
-		fail(
-			"usage",
-			"this repo has git submodules (.gitmodules), which arbor does not support: worktrees do not share them",
-			{ task },
-		);
-	}
-
-	const found = await service.find(task);
-	if (found.status === "stray") {
-		fail(
-			"exists",
-			`branch ${found.branch} exists without a worktree: run \`arbor remove ${task}\` first`,
-			{ task, branch: found.branch },
-		);
-	}
-	if (!found.gone) {
-		fail(
-			"exists",
-			`task '${task}' already exists: run \`arbor claim ${task}\``,
-			{ task, worktree: found.path },
-		);
-	}
-
-	// Looked up before anything is created, so a todo that is gone or taken
-	// refuses the whole add instead of leaving a tree behind.
-	const taken: Todo[] = [];
-	for (const id of new Set(ids)) {
-		const todo = await todos.find(id);
-		if (todo.takenBy) {
-			await todo.take(task); // refuses, naming the task that has it
-		}
-		taken.push(todo);
-	}
-
-	const added = await service.add(task, { base });
-	if (added.code !== 0) {
-		// git's own "invalid reference" sends people to the branch, when what is
-		// wrong is which branch arbor thinks the trunk is.
-		const missingTrunk =
-			base === config.trunk && !(await service.git.branchExists(base));
-		fail(
-			"usage",
-			missingTrunk
-				? `trunk '${base}' is not a branch in this repo: set \`trunk\` in arbor.config.ts`
-				: `git worktree add failed: ${added.stderr}`,
-			{ task },
-		);
-	}
-
-	const worktree = await (await service.find(task)).take({ base });
-
-	// The plan is scratch for one task and must never land on trunk. Excluding
-	// it through the shared `.git` covers every worktree at once and leaves the
-	// repo's own .gitignore, which arbor would have to commit to, alone.
-	const info = `${await service.git.commonDir()}/info`;
-	const excluded = await fs.read(`${info}/exclude`).catch(() => "");
-	if (!excluded.split("\n").includes(PLAN_FILE)) {
-		await fs.mkdir(info);
-		await fs.write(
-			`${info}/exclude`,
-			`${excluded.trimEnd()}\n${PLAN_FILE}\n`.trimStart(),
-		);
-	}
-
-	await fs.write(
-		`${worktree.path}/${PLAN_FILE}`,
-		PLAN(task, taken.length === 0 ? null : goal(taken)),
-	);
-	for (const todo of taken) {
-		await todo.take(task);
-	}
-
-	// A fresh worktree shares no untracked files with the repo: no node_modules,
-	// no .env. That is what the hook is for.
-	if (config.postCheckout) {
-		const { exitCode } = await shell.stream(
-			config.postCheckout,
-			worktree.path,
-			{
-				env: {
-					ARBOR_TASK: task,
-					ARBOR_WORKTREE: worktree.path,
-					ARBOR_TRUNK: config.trunk,
-				},
-			},
-		);
-		if (exitCode !== 0) {
-			// The worktree stays. Rolling back would throw away a tree the agent
-			// can fix by hand and re-run the hook in.
-			fail(
-				"hook_failed",
-				`postCheckout hook failed (exit ${exitCode}); worktree left in place at ${worktree.path}`,
-				{ task, worktree: worktree.path },
-			);
-		}
-	}
-
-	log.info(
-		`${color.green("added")} ${task}\n  worktree: ${worktree.path}\n  branch:   ${worktree.branch}\n  base:     ${base}`,
-	);
-}
-
-/**
- * Todos as a Goal: each one's subject and detail, and each file attached to it
- * by path, which stay readable until the task lands and takes the todo with
- * it. One todo is the Goal as it stands; several are each named by id.
- */
-function goal(todos: Todo[]): string {
-	return todos
-		.map((todo) => {
-			const subject =
-				todos.length === 1 ? todo.subject : `Todo ${todo.id}: ${todo.subject}`;
-			return [
-				subject,
-				todo.text,
-				todo.files.map((path) => `Attached: \`${path}\``).join("\n"),
-			]
-				.filter(Boolean)
-				.join("\n\n");
-		})
-		.join("\n\n");
-}
-
-/** The plan a fresh task starts with. `## Goal` is the todos it takes up, if
- * any; it and `## Files` are otherwise left empty on purpose: `arbor show` nags
- * until the agent fills them in. */
-function PLAN(task: string, goal: string | null): string {
-	const writer = new MarkdownWriter().heading(1, task).heading(2, "Goal");
-	if (goal !== null) {
-		writer.text(goal);
-	}
-	return writer
-		.heading(2, "Files")
-		.heading(2, "Next")
-		.checklist("fill in Goal and list the steps here as `- [ ]` items")
-		.toString();
-}

package/age.ts

@@ -1,11 +0,0 @@
-/** How long ago an ISO timestamp was, at the coarsest unit that still reads. */
-export function age(since: string): string {
-	const minutes = Math.floor((Date.now() - Date.parse(since)) / 60_000);
-	if (minutes < 60) {
-		return `${minutes}m`;
-	}
-	if (minutes < 60 * 24) {
-		return `${Math.floor(minutes / 60)}h`;
-	}
-	return `${Math.floor(minutes / (60 * 24))}d`;
-}

package/arbor.test.ts

@@ -1,145 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { basename, join } from "node:path";
-import { arbor } from "./arbor";
-import { Testing } from "./testing";
-
-/**
- * The cli in this process, run with fakes: the same commands `e2e.test.ts`
- * spawns, minus the subprocess. What it proves is the wiring, that every
- * dependency an action uses arrives through `run`.
- */
-describe("arbor cli", () => {
-	it("runs its commands against the dependencies it is given", async () => {
-		await using env = await Testing.open();
-		env.ps.cd(env.root);
-		const deps = {
-			log: env.log,
-			fs: env.fs,
-			ps: env.ps,
-			assets: env.assets,
-		};
-
-		await arbor.run(deps, ["add", "alpha"]);
-		await arbor.run(deps, ["list", "--json"]);
-
-		const rows = JSON.parse(String(env.log.entries.at(-1)?.message));
-		expect(rows).toMatchObject([{ task: "alpha", status: "working" }]);
-		expect(await env.fs.exists(join(`${env.root}-arbor`, "alpha"))).toBe(true);
-	});
-
-	it("escalates a task and edits its todos", async () => {
-		await using env = await Testing.open();
-		env.ps.cd(env.root);
-		const deps = {
-			log: env.log,
-			fs: env.fs,
-			ps: env.ps,
-			assets: env.assets,
-		};
-		await arbor.run(deps, ["add", "alpha"]);
-		const worktree = await env.service.find("alpha");
-		await env.fs.write(
-			join(worktree.path, "ARBOR.md"),
-			"# alpha\n\n## Blocked\n\n- [ ] 1. Open it.\n",
-		);
-		await env.fs.write(join(env.root, "a.png"), "a");
-		env.ps.cd(worktree.path);
-		await arbor.run(deps, ["escalate", "needs a person"]);
-
-		env.ps.cd(env.root);
-		await arbor.run(deps, [
-			"todo",
-			"add",
-			"write docs",
-			"the CLI first",
-			"--file",
-			"a.png",
-		]);
-		const [attached = ""] = (await env.todos.find(1)).files;
-		await arbor.run(deps, [
-			"todo",
-			"update",
-			"1",
-			"--subject",
-			"write the docs",
-			"--position",
-			"1",
-			"--remove-file",
-			basename(attached),
-		]);
-		expect((await env.todos.find(1)).state).toMatchObject({
-			subject: "write the docs",
-			text: "the CLI first",
-			position: 1,
-			files: [],
-		});
-
-		await arbor.run(deps, ["log", "--json"]);
-		const entries = JSON.parse(String(env.log.entries.at(-1)?.message));
-		expect(entries.map((entry: { action: string }) => entry.action)).toContain(
-			"escalate",
-		);
-	});
-
-	it("asks for a review from the command line", async () => {
-		await using env = await Testing.open();
-		env.ps.cd(env.root);
-		const deps = {
-			log: env.log,
-			fs: env.fs,
-			ps: env.ps,
-			assets: env.assets,
-		};
-		await arbor.run(deps, ["add", "alpha"]);
-
-		await arbor.run(deps, [
-			"escalate",
-			"check the header",
-			"--task",
-			"alpha",
-			"--review",
-		]);
-
-		const worktree = await env.service.find("alpha");
-		expect(worktree.state?.escalations?.at(-1)?.review).toBe("1");
-		expect(await env.fs.read(join(worktree.path, "ARBOR.md"))).toContain(
-			"- [ ] 1. Ready to merge?\n  check the header\n",
-		);
-	});
-
-	it("reports a refusal as a reason, a message and an exit code", async () => {
-		await using env = await Testing.open();
-		env.ps.cd(env.root);
-
-		await arbor.run(
-			{
-				log: env.log,
-				fs: env.fs,
-				ps: env.ps,
-				assets: env.assets,
-			},
-			["claim", "nope"],
-		);
-
-		expect(env.out()).toContain('"reason":"not_found"');
-		expect(env.proc.lastExit()).toBe(8);
-	});
-
-	it("refuses a port that cannot exist rather than trying to listen", async () => {
-		await using env = await Testing.open();
-		env.ps.cd(env.root);
-
-		await arbor.run(
-			{
-				log: env.log,
-				fs: env.fs,
-				ps: env.ps,
-				assets: env.assets,
-			},
-			["dev", "--port", "99999"],
-		);
-
-		expect(env.out()).not.toContain("  reply ");
-		expect(env.proc.lastExit()).toBe(1);
-	});
-});