@webappwiz/arbor 0.0.28 → 0.0.30

package/merge.test.ts

@@ -0,0 +1,332 @@
+import { describe, expect, it, setDefaultTimeout } from "bun:test";
+import { join } from "node:path";
+import { FakePs } from "webappwiz/system/testing";
+import { add } from "./add";
+import { merge } from "./merge";
+import { PLAN_FILE } from "./plan";
+import { Shell } from "./shell";
+import { LIVE_PID, Testing } from "./testing";
+
+// Every test here drives real git in a repo of its own, dozens of processes
+// each: fast alone, but starved past bun's 5s default when the whole suite
+// runs in parallel on a busy machine.
+setDefaultTimeout(30_000);
+
+describe.concurrent("merge", () => {
+	it("rebases, tests, then fast-forwards trunk", async () => {
+		await using deps = await Testing.open();
+
+		await add(deps, "alpha");
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
+		// Trunk moved on underneath, so the rebase has real work to do.
+		await deps.commit(deps.root, "trunk.txt", "trunk\n", "add trunk");
+
+		await merge(deps, worktree);
+
+		expect(await deps.gitCli(deps.root, "log", "--oneline", "main")).toContain(
+			"add alpha",
+		);
+		expect(
+			await deps.gitCli(deps.root, "rev-list", "--count", "--merges", "main"),
+		).toBe("0");
+		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
+	});
+
+	it("lands on a clean rebase alone when no hook is configured", async () => {
+		await using deps = await Testing.open();
+
+		deps.config.postRewrite = null;
+		deps.config.preMerge = null;
+		await add(deps, "alpha");
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
+
+		await merge(deps, worktree);
+
+		expect(await deps.gitCli(deps.root, "log", "--oneline", "main")).toContain(
+			"add alpha",
+		);
+	});
+
+	it("lands a --base task on its base branch and leaves trunk alone", async () => {
+		await using deps = await Testing.open();
+
+		await deps.gitCli(deps.root, "branch", "feature", "main");
+		const trunkBefore = await deps.gitCli(deps.root, "rev-parse", "main");
+		await add(deps, "alpha", { base: "feature" });
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
+
+		await merge(deps, worktree);
+
+		expect(
+			await deps.gitCli(deps.root, "log", "--oneline", "feature"),
+		).toContain("add alpha");
+		expect(await deps.gitCli(deps.root, "rev-parse", "main")).toBe(trunkBefore);
+	});
+
+	it("lands into the worktree that holds the base, leaving trunk alone", async () => {
+		await using deps = await Testing.open();
+
+		await add(deps, "parent");
+		const parent = (await deps.service.find("parent")).path;
+		await deps.commit(parent, "parent.txt", "parent\n", "add parent");
+		const trunkBefore = await deps.gitCli(deps.root, "rev-parse", "main");
+
+		await add(deps, "child", { base: "task/parent" });
+		const child = (await deps.service.find("child")).path;
+		await deps.commit(child, "child.txt", "child\n", "add child");
+
+		await merge(deps, child);
+
+		// The parent's files move with its branch, not just the ref: a ref moved
+		// behind a worktree's back leaves it reading the landed files as deleted.
+		expect(await deps.fs.exists(join(parent, "child.txt"))).toBe(true);
+		expect(await deps.gitCli(parent, "log", "--oneline", "HEAD")).toContain(
+			"add child",
+		);
+		expect(await deps.gitCli(deps.root, "rev-parse", "main")).toBe(trunkBefore);
+	});
+
+	it("refuses to land into a base worktree whose changes collide", async () => {
+		await using deps = await Testing.open();
+
+		await add(deps, "parent");
+		const parent = (await deps.service.find("parent")).path;
+		await add(deps, "child", { base: "task/parent" });
+		const child = (await deps.service.find("child")).path;
+		await deps.commit(child, "shared.txt", "child\n", "add shared");
+		// The parent is mid-edit on the very file the child is about to land.
+		await deps.fs.write(join(parent, "shared.txt"), "parent still editing\n");
+
+		await expect(merge(deps, child)).toBail("merge_failed", {
+			message: parent,
+		});
+		expect((await deps.service.find("child")).state?.mergeAttempts).toBe(1);
+		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
+	});
+
+	it("discards the landed task, so it drops out of the listing", async () => {
+		await using deps = await Testing.open();
+
+		await add(deps, "alpha");
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
+
+		await merge(deps, worktree);
+
+		expect((await deps.service.find("alpha")).status).toBe("removed");
+		expect(await deps.fs.exists(worktree)).toBe(false);
+		expect(await deps.service.list()).toEqual([]);
+	});
+
+	it("refuses to run with uncommitted changes, before taking the lock", async () => {
+		await using deps = await Testing.open();
+
+		await add(deps, "alpha");
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.fs.write(join(worktree, "alpha.txt"), "not committed\n");
+
+		await expect(merge(deps, worktree)).toBail("dirty");
+		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
+	});
+
+	it("leaves a conflicting rebase in progress for the agent to resolve", async () => {
+		await using deps = await Testing.open();
+
+		await add(deps, "alpha");
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.commit(worktree, "README.md", "task side\n", "task edit");
+		await deps.commit(deps.root, "README.md", "trunk side\n", "trunk edit");
+
+		await expect(merge(deps, worktree)).toBail("conflict", {
+			message: "README.md",
+		});
+		expect(await deps.gitCli(worktree, "status", "--porcelain")).toContain(
+			"UU README.md",
+		);
+		expect((await deps.service.find("alpha")).state?.mergeAttempts).toBe(1);
+		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
+	});
+
+	it("rolls the branch back and leaves trunk alone when the gate fails", async () => {
+		await using deps = await Testing.open();
+
+		deps.config.preMerge = "echo boom-from-tests; exit 1";
+		await add(deps, "alpha");
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
+		await deps.commit(deps.root, "trunk.txt", "trunk\n", "add trunk");
+		const before = await deps.gitCli(worktree, "rev-parse", "HEAD");
+		const trunkBefore = await deps.gitCli(deps.root, "rev-parse", "main");
+
+		await expect(merge(deps, worktree)).toBail("tests_failed", {
+			message: "boom-from-tests",
+		});
+		expect(await deps.gitCli(worktree, "rev-parse", "HEAD")).toBe(before);
+		expect(await deps.gitCli(deps.root, "rev-parse", "main")).toBe(trunkBefore);
+		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
+	});
+
+	it("runs postRewrite before preMerge, and fails the gate when it does", async () => {
+		await using deps = await Testing.open();
+
+		// Only passes if the hook ran first, in the same tree, before preMerge.
+		deps.config.postRewrite = "echo hooked > hook.txt";
+		deps.config.preMerge = "grep -q hooked hook.txt";
+		await add(deps, "alpha");
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
+
+		await merge(deps, worktree);
+		expect(await deps.gitCli(deps.root, "log", "-1", "--format=%s")).toBe(
+			"add alpha",
+		);
+
+		deps.config.postRewrite = "echo boom-from-hook; exit 1";
+		await add(deps, "beta");
+		const beta = (await deps.service.find("beta")).path;
+		await deps.commit(beta, "beta.txt", "beta\n", "add beta");
+
+		await expect(merge(deps, beta)).toBail("tests_failed", {
+			message: "boom-from-hook",
+		});
+		expect((await deps.service.find("beta")).state?.mergeAttempts).toBe(1);
+	});
+
+	it("runs postMerge in the main tree after landing", async () => {
+		await using deps = await Testing.open();
+
+		deps.config.postMerge = 'echo "$ARBOR_TASK" > post-merge.txt';
+		await add(deps, "alpha");
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
+
+		await merge(deps, worktree);
+
+		expect(await deps.fs.read(join(deps.root, "post-merge.txt"))).toBe(
+			"alpha\n",
+		);
+	});
+
+	it("reports a failed postMerge without disturbing the landed branch", async () => {
+		await using deps = await Testing.open();
+
+		deps.config.postMerge = "echo boom-after-land; exit 1";
+		await add(deps, "alpha");
+		const worktree = (await deps.service.find("alpha")).path;
+		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
+
+		await expect(merge(deps, worktree)).toBail("hook_failed", {
+			message: "boom-after-land",
+		});
+		expect(await deps.gitCli(deps.root, "log", "--oneline", "main")).toContain(
+			"add alpha",
+		);
+		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
+	});
+
+	it("refuses to land while a question is open or an answer unchecked", async () => {
+		await using deps = await Testing.open();
+
+		await add(deps, "alpha");
+		const found = await deps.service.find("alpha");
+		const worktree = found.path;
+		await deps.commit(worktree, "alpha.txt", "alpha\n", "add alpha");
+		const plan = `${worktree}/${PLAN_FILE}`;
+		await deps.fs.write(plan, "# alpha\n\n## Blocked\n\n- [ ] 1. Keep it?\n");
+
+		await expect(merge(deps, worktree)).toBail("blocked", {
+			message: "questions 1 unchecked",
+			data: { task: "alpha", blocked: ["1"] },
+		});
+
+		// Answered but not acted on: the agent checks it off once it has.
+		await deps.fs.write(
+			plan,
+			"# alpha\n\n## Blocked\n\n- [ ] 1. Keep it? → rename it first\n",
+		);
+		await expect(merge(deps, worktree)).toBail("blocked");
+		expect(
+			await deps.gitCli(deps.root, "log", "--oneline", "main"),
+		).not.toContain("add alpha");
+
+		const read = await deps.fs.read(plan);
+		await deps.fs.write(plan, read.replace("- [ ]", "- [x]"));
+		await merge(deps, worktree);
+		expect(await deps.gitCli(deps.root, "log", "--oneline", "main")).toContain(
+			"add alpha",
+		);
+	});
+
+	it("stops once the retry budget is spent", async () => {
+		await using deps = await Testing.open();
+
+		deps.config.mergeRetryCount = 2;
+		await add(deps, "alpha");
+		const worktree = await deps.service.find("alpha");
+		await worktree.save({ mergeAttempts: 2 });
+
+		await expect(merge(deps, worktree.path)).toBail("budget_exhausted", {
+			message: "arbor escalate",
+		});
+	});
+
+	it("refuses to land when the lease changed hands during the test run", async () => {
+		await using deps = await Testing.open();
+
+		await add(deps, "alpha");
+		const worktree = await deps.service.find("alpha");
+		await deps.commit(worktree.path, "alpha.txt", "alpha\n", "add alpha");
+		const trunkBefore = await deps.gitCli(deps.root, "rev-parse", "main");
+		// Another agent takes the tree while the tests are running: the one
+		// window merge cannot hold the record across, and the reason it re-reads
+		// it before landing.
+		const ps = new FakePs();
+		ps.simulate(async () => {
+			await worktree.save({
+				lease: {
+					pid: LIVE_PID,
+					hostname: deps.ps.hostname,
+					heartbeatAt: new Date().toISOString(),
+				},
+			});
+			return 0;
+		});
+
+		await expect(
+			merge({ ...deps, shell: new Shell({ ps }) }, worktree.path),
+		).toBail("lease_lost");
+		expect(await deps.gitCli(deps.root, "rev-parse", "main")).toBe(trunkBefore);
+		expect(await deps.fs.exists(deps.lockPath)).toBe(false);
+	});
+
+	it("serializes: one merge runs its tests and lands before the next starts", async () => {
+		await using deps = await Testing.open();
+
+		const trace = join(deps.root, "trace.log");
+		deps.config.preMerge = `printf 'start-%s\\n' "$ARBOR_TASK" >> ${trace}; sleep 0.2; printf 'end-%s\\n' "$ARBOR_TASK" >> ${trace}`;
+
+		await add(deps, "alpha");
+		await add(deps, "beta");
+		const alpha = (await deps.service.find("alpha")).path;
+		const beta = (await deps.service.find("beta")).path;
+		await deps.commit(alpha, "alpha.txt", "alpha\n", "add alpha");
+		await deps.commit(beta, "beta.txt", "beta\n", "add beta");
+
+		await Promise.all([merge(deps, alpha), merge(deps, beta)]);
+
+		const lines = (await deps.fs.read(trace)).trim().split("\n");
+		expect(lines).toHaveLength(4);
+		// Merges hold the lock exclusively, so the second can't start until the first ends.
+		expect(lines[1]).toBe(`end-${lines[0]?.slice("start-".length)}`);
+		expect(lines[3]).toBe(`end-${lines[2]?.slice("start-".length)}`);
+		const log = await deps.gitCli(deps.root, "log", "--oneline", "main");
+		expect(log).toContain("add alpha");
+		expect(log).toContain("add beta");
+		expect(
+			await deps.gitCli(deps.root, "rev-list", "--count", "--merges", "main"),
+		).toBe("0");
+	}, 20_000);
+});

package/merge.ts

@@ -0,0 +1,283 @@
+import { color, type Logger } from "webappwiz/log";
+import type { Fs, Lock } from "webappwiz/system";
+import type { Config } from "./config";
+import { fail } from "./exit";
+import type { Git } from "./git";
+import { PLAN_FILE, questions } from "./plan";
+import type { Shell } from "./shell";
+import { recommend, recommendation, type Todos } from "./todo";
+import type { Worktree } from "./worktree";
+import type { WorktreeService } from "./worktree-service";
+
+const TAIL_LINES = 40;
+
+/**
+ * Lands the current worktree's branch on its base branch, trunk unless the
+ * task was created with `--base`. Never a merge commit: it rebases onto the
+ * base, runs the gate there, and fast-forwards the base with
+ * `git merge --ff-only`, in whichever worktree has the base checked out.
+ * History stays linear.
+ */
+export async function merge(
+	{
+		service,
+		git,
+		lock,
+		shell,
+		config,
+		log,
+		todos,
+		fs,
+	}: {
+		service: WorktreeService;
+		git: Git;
+		lock: Lock;
+		shell: Shell;
+		config: Config;
+		log: Logger;
+		todos: Todos;
+		fs: Fs;
+	},
+	cwd: string,
+): Promise<void> {
+	const branch = await git.currentBranch(cwd).catch(() => "");
+	const task = service.taskFor(branch);
+	if (!task) {
+		fail(
+			"not_found",
+			`not in a task worktree (branch '${branch}'): run merge from a worktree made by \`arbor add\``,
+			{ branch },
+		);
+	}
+	let worktree = await service.find(task);
+	if (!worktree.state) {
+		fail(
+			"not_found",
+			`no state file for '${task}': run \`arbor claim ${task}\` first`,
+			{ task },
+		);
+	}
+
+	const base = worktree.base;
+	const dirty = await worktree.uncommitted();
+	if (dirty.length > 0) {
+		fail(
+			"dirty",
+			`'${task}' has uncommitted changes: commit them before merging`,
+			{ task, paths: dirty },
+		);
+	}
+	if (worktree.mergeAttempts >= config.mergeRetryCount) {
+		fail(
+			"budget_exhausted",
+			`'${task}' has used its ${config.mergeRetryCount} merge attempts: run \`arbor escalate <reason>\`, and a human can grant another ${config.mergeRetryCount} with \`arbor retry ${task}\`; or \`arbor remove ${task}\` and start over against current ${base}`,
+			{ task, mergeAttempts: worktree.mergeAttempts },
+		);
+	}
+	if (worktree.leaseHeldByOther) {
+		fail(
+			"lease_held",
+			`'${task}' is held by pid ${worktree.lease?.pid} on ${worktree.lease?.hostname}: another agent is driving this tree`,
+			{ task, lease: worktree.lease },
+		);
+	}
+	// An unchecked question is one the user has yet to answer, or an answer
+	// the agent has yet to act on.
+	const plan = await fs.read(`${worktree.path}/${PLAN_FILE}`).catch(() => "");
+	const blocked = questions(plan)
+		.filter((asked) => !asked.done)
+		.map((asked) => asked.number);
+	if (blocked.length > 0) {
+		fail(
+			"blocked",
+			`'${task}' has questions ${blocked.join(", ")} unchecked under ## Blocked: act on each answer and check it off, or escalate and ask the user in chat, then merge again`,
+			{ task, blocked },
+		);
+	}
+	worktree = await worktree.take();
+
+	// Blocks until free: an agent told "busy, try later" goes and edits code in
+	// a branch that is supposed to be frozen.
+	await lock.acquire();
+	worktree = await worktree.take({ status: "merging" });
+
+	const before = await git.head(worktree.path);
+	const rebase = await git.rebase(worktree.path, base);
+	if (rebase.code !== 0) {
+		// Left in progress on purpose: the agent needs the conflict markers.
+		const paths = await git.conflictedPaths(worktree.path);
+		await lock.release();
+		await bump(worktree);
+		fail(
+			"conflict",
+			[
+				`rebase onto ${base} conflicted in ${paths.length || "?"} file(s):`,
+				...paths.map((file) => `  ${file}`),
+				"",
+				"The rebase is still in progress. Resolve the conflicts, `git add` them,",
+				"`git rebase --continue`, then run `arbor merge` again.",
+				"If both sides restructured the same logic, prefer `arbor escalate <reason>`",
+				`or \`arbor remove ${task}\` and redo the task against current ${base}.`,
+			].join("\n"),
+			{ task, paths },
+		);
+	}
+
+	// After the rebase, never before: a branch that passed against an older
+	// trunk tells you nothing about the combination. This is the only thing
+	// standing between semantic conflicts and a broken trunk, and a repo that
+	// configures neither hook has chosen to go without it.
+	//
+	// The two hooks share one shell rather than getting a run each: the recovery
+	// is the same either way, and one gate reports one failure however far down
+	// it got.
+	const gate = [config.postRewrite, config.preMerge]
+		.filter(Boolean)
+		.join(" && ");
+	const gated = gate
+		? await shell.run(gate, worktree.path, {
+				env: {
+					ARBOR_TASK: task,
+					ARBOR_WORKTREE: worktree.path,
+				},
+			})
+		: { exitCode: 0, stdout: "", stderr: "" };
+	if (gated.exitCode !== 0) {
+		// The rebase already finished, so there is nothing for `rebase --abort`
+		// to undo: resetting to the pre-rebase commit is what returns the branch
+		// to its previous state.
+		await git.resetHard(worktree.path, before);
+		await lock.release();
+		await bump(worktree);
+		fail(
+			"tests_failed",
+			[
+				`\`${gate}\` failed after rebasing onto ${base} (exit ${gated.exitCode}).`,
+				`${base} is untouched and ${branch} is back at ${before.slice(0, 8)}.`,
+				"",
+				tail(`${gated.stdout}\n${gated.stderr}`),
+			].join("\n"),
+			{ task, exitCode: gated.exitCode },
+		);
+	}
+
+	// Deliberately re-read from disk rather than trusting the copy in hand: a
+	// long test run can outlive the lease, and landing after someone else
+	// claimed the tree would land work that is no longer ours.
+	const current = await worktree.reload();
+	if (!current.leaseOurs) {
+		await lock.release();
+		fail(
+			"lease_lost",
+			`the lease on '${task}' was taken by pid ${current.lease?.pid} during the merge, stopping without landing. Do not retry; another agent owns this tree.`,
+			{ task, lease: current.lease },
+		);
+	}
+
+	// A branch can only be advanced where it is checked out: git allows one
+	// worktree per branch, and moving the ref behind that worktree's back would
+	// leave its index and files on the old commit. For trunk that tree is the
+	// main one; for a task created with `--base task/<other>` it is that task's
+	// worktree, and the work lands there rather than on trunk.
+	const holder = await git.worktreeFor(base);
+	const landing = holder ?? git.root;
+	const checkout = holder ? null : await git.checkout(base);
+	const merged =
+		checkout && checkout.code !== 0
+			? checkout
+			: await git.mergeFfOnly(landing, branch);
+	if (merged.code !== 0) {
+		await lock.release();
+		await bump(worktree);
+		fail(
+			"merge_failed",
+			[
+				`could not fast-forward ${base} in ${landing}: ${merged.stderr || merged.stdout}`,
+				...(landing === git.root
+					? []
+					: [
+							"",
+							`${base} is checked out there, which is the only place it can move.`,
+							"Whoever is working in that tree has to commit or stash what collides,",
+							"then merge again.",
+						]),
+			].join("\n"),
+			{ task, base, landing },
+		);
+	}
+
+	const head = await git.shortHead(landing);
+	// The work is on the base, so the tree has nothing left to hold. Discarding it
+	// here is what keeps `arbor list` a list of live work rather than a graveyard
+	// of landed tasks.
+	//
+	// Step out of it first: merge usually runs from inside the tree it is about
+	// to delete, and spawning git from a directory that no longer exists fails
+	// with ENOENT before git is even reached.
+	service.ps.cd(git.root);
+	const discarded = await current.discard();
+	await lock.release();
+	if (discarded.code !== 0) {
+		fail(
+			"usage",
+			`landed '${task}' on ${base} (${head}) but could not discard its worktree: ${discarded.stderr || discarded.stdout}\nRun \`arbor remove ${task}\` to clean up.`,
+			{ task },
+		);
+	}
+	// After the land, in the main tree: the merge can bring the main tree a
+	// dependency change the way a rebase brings the worktree one. The branch is
+	// already on the base, so a failure here reports and rolls nothing back.
+	if (config.postMerge) {
+		const ran = await shell.run(config.postMerge, landing, {
+			env: { ARBOR_TASK: task },
+		});
+		if (ran.exitCode !== 0) {
+			fail(
+				"hook_failed",
+				[
+					`landed '${task}' on ${base} (${head}) but the postMerge hook failed (exit ${ran.exitCode}).`,
+					"",
+					tail(`${ran.stdout}\n${ran.stderr}`),
+				].join("\n"),
+				{ task, exitCode: ran.exitCode },
+			);
+		}
+	}
+	// Done is done: the todos this task took up leave the list with it.
+	const done = await todos.takenBy(task);
+	for (const todo of done) {
+		await todo.remove();
+	}
+	const lines = [
+		`${color.green("merged")} ${task} onto ${base} (${head})${
+			landing === git.root ? "" : `\n  landed in: ${landing}`
+		}\n  worktree removed, cd ${git.root}`,
+		...done.map((todo) => `  done todo ${todo.id}: ${todo.subject}`),
+	];
+	// Only a landing on trunk ends a piece of work. A part landing on its
+	// parent's branch hands back to that parent, which is not done yet.
+	if (landing === git.root) {
+		lines.push(
+			...recommendation(
+				await recommend(
+					todos,
+					task,
+					config.todoStalenessMs,
+					done.flatMap((todo) => todo.tags),
+				),
+			),
+		);
+	}
+	log.info(lines.join("\n"));
+}
+
+async function bump(worktree: Worktree): Promise<void> {
+	await worktree.take({
+		status: "working",
+		mergeAttempts: worktree.mergeAttempts + 1,
+	});
+}
+
+function tail(output: string): string {
+	return output.trim().split("\n").slice(-TAIL_LINES).join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webappwiz/arbor",
-	"version": "0.0.28",
+	"version": "0.0.30",
 	"description": "Runs several AI coding agents on one repository at once, each in its own git worktree",
 	"license": "MIT",
 	"author": "Jared Johnson",
@@ -10,6 +10,14 @@
 		"directory": "packages/arbor"
 	},
 	"type": "module",
+	"module": "index.ts",
+	"bin": {
+		"arbor": "./index.ts"
+	},
+	"exports": {
+		".": "./index.ts",
+		"./config": "./config.ts"
+	},
 	"imports": {
 		"#dev/*": "./dev/*"
 	},
@@ -20,22 +28,31 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"webappwiz": "^0.0.28",
+		"webappwiz": "0.0.29",
 		"zod": "^4.4.3"
 	},
-	"main": "./index.js",
-	"types": "./index.d.ts",
-	"exports": {
-		".": {
-			"types": "./index.d.ts",
-			"default": "./index.js"
-		},
-		"./config": {
-			"types": "./config.d.ts",
-			"default": "./config.js"
-		}
+	"devDependencies": {
+		"@base-ui/react": "^1.8.0",
+		"@dnd-kit/core": "^6.3.1",
+		"@dnd-kit/modifiers": "^9.0.0",
+		"@dnd-kit/sortable": "^10.0.0",
+		"@dnd-kit/utilities": "^3.2.2",
+		"@tailwindcss/oxide": "^4.3.3",
+		"@testing-library/react": "^16.3.1",
+		"@types/react": "^19.2.18",
+		"@types/react-dom": "^19.2.4",
+		"@webappwiz/react": "0.0.29",
+		"class-variance-authority": "^0.7.1",
+		"clsx": "^2.1.1",
+		"lucide-react": "^1.49.0",
+		"markdown-to-jsx": "^9.10.3",
+		"react": "^19.2.8",
+		"react-dom": "^19.2.8",
+		"tailwind-merge": "^3.7.0",
+		"tailwindcss": "^4.3.3",
+		"tw-animate-css": "^1.4.0"
 	},
-	"bin": {
-		"arbor": "./index.js"
+	"scripts": {
+		"build": "bun run build.ts"
 	}
 }