kanbot 0.0.0-stage → 0.2.0

package/src/daemon/git.ts

@@ -0,0 +1,187 @@
+import { existsSync } from "node:fs";
+import { mkdir, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { log } from "../log.ts";
+
+export async function git(cwd: string, ...args: string[]): Promise<string> {
+	const proc = Bun.spawn(["git", ...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [out, err, code] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	if (code !== 0)
+		throw new Error(
+			`git ${args.join(" ")} failed: ${err.trim() || out.trim()}`,
+		);
+	return out.trim();
+}
+
+/**
+ * One git worktree per job, outside the repo so the human's checkout and
+ * tooling never see agent work in progress. Worktrees are reused per key.
+ */
+export class Worktrees {
+	readonly dir: string;
+	private queue: Promise<unknown> = Promise.resolve();
+
+	constructor(
+		readonly root: string,
+		repo: string,
+		readonly base: string,
+		readonly dryRun = false,
+	) {
+		this.dir = join(homedir(), ".kanbot", "worktrees", repo.replace("/", "__"));
+	}
+
+	/**
+	 * Run git operations that touch the shared repo (.git/config, refs, the
+	 * worktree list) one at a time; parallel jobs otherwise race on its locks.
+	 */
+	private serial<T>(fn: () => Promise<T>): Promise<T> {
+		const run = this.queue.then(fn, fn);
+		this.queue = run.catch(() => {});
+		return run;
+	}
+
+	private path(name: string) {
+		return join(this.dir, name.replace(/[^a-zA-Z0-9._-]/g, "_"));
+	}
+
+	fetch() {
+		return this.serial(() => git(this.root, "fetch", "--prune", "origin"));
+	}
+
+	async remoteHas(branch: string) {
+		return (
+			(await git(this.root, "ls-remote", "--heads", "origin", branch)).length >
+			0
+		);
+	}
+
+	/**
+	 * Check out `branch` in its own worktree. Starts from origin/<branch> when it
+	 * exists remotely (resuming), otherwise from origin/<base>.
+	 */
+	checkout(name: string, branch: string): Promise<string> {
+		return this.serial(() => this.checkoutNow(name, branch));
+	}
+
+	private async checkoutNow(name: string, branch: string) {
+		const path = this.path(name);
+		const from = (await this.remoteHas(branch))
+			? `origin/${branch}`
+			: `origin/${this.base}`;
+		await mkdir(this.dir, { recursive: true });
+		if (!existsSync(path)) {
+			await git(
+				this.root,
+				"worktree",
+				"add",
+				"--force",
+				"--no-track",
+				"-B",
+				branch,
+				path,
+				from,
+			);
+		} else {
+			await git(path, "checkout", "--force", "--no-track", "-B", branch, from);
+			await git(path, "reset", "--hard", from);
+			// Keep ignored files (node_modules) so installs stay warm.
+			await git(path, "clean", "-fd");
+		}
+		return path;
+	}
+
+	/** Read-only snapshot of the base branch for planning. */
+	detached(name: string): Promise<string> {
+		return this.serial(() => this.detachedNow(name));
+	}
+
+	private async detachedNow(name: string) {
+		const path = this.path(name);
+		await mkdir(this.dir, { recursive: true });
+		const ref = `origin/${this.base}`;
+		if (!existsSync(path)) {
+			await git(this.root, "worktree", "add", "--force", "--detach", path, ref);
+		} else {
+			await git(path, "checkout", "--force", "--detach", ref);
+			await git(path, "clean", "-fd");
+		}
+		return path;
+	}
+
+	/** Commit anything the agent left uncommitted. */
+	async commitAll(path: string, message: string) {
+		if (!(await git(path, "status", "--porcelain"))) return;
+		await git(path, "add", "-A");
+		await git(path, "commit", "-m", message, "--no-verify");
+	}
+
+	/**
+	 * Merge `ref` into HEAD. Returns the conflicted files, leaving the merge in
+	 * progress for an agent to resolve; empty when it merged cleanly.
+	 */
+	async merge(path: string, ref: string): Promise<string[]> {
+		try {
+			await git(path, "merge", "--no-edit", "--no-verify", ref);
+			return [];
+		} catch (e) {
+			const files = await git(path, "diff", "--name-only", "--diff-filter=U");
+			if (!files) throw e;
+			return files.split("\n");
+		}
+	}
+
+	/** Stage everything and commit the merge in progress, if any. */
+	async concludeMerge(path: string) {
+		await git(path, "add", "-A");
+		const merging = await git(path, "rev-parse", "-q", "--verify", "MERGE_HEAD")
+			.then(() => true)
+			.catch(() => false);
+		if (merging) await git(path, "commit", "--no-edit", "--no-verify");
+	}
+
+	async isAncestor(path: string, ref: string) {
+		return git(path, "merge-base", "--is-ancestor", ref, "HEAD")
+			.then(() => true)
+			.catch(() => false);
+	}
+
+	async commitsAhead(path: string, of: string) {
+		return Number(await git(path, "rev-list", "--count", `${of}..HEAD`));
+	}
+
+	async head(path: string) {
+		return git(path, "rev-parse", "HEAD");
+	}
+
+	async push(path: string, branch: string) {
+		if (this.dryRun) return log.info(`[dry-run] push ${branch}`);
+		await this.serial(() =>
+			git(
+				path,
+				"push",
+				"--force-with-lease",
+				"origin",
+				`HEAD:refs/heads/${branch}`,
+			),
+		);
+	}
+
+	async remove(prefix: string) {
+		if (!existsSync(this.dir)) return;
+		for (const name of await readdir(this.dir)) {
+			if (!name.startsWith(prefix)) continue;
+			await this.serial(() =>
+				git(this.root, "worktree", "remove", "--force", join(this.dir, name)),
+			).catch((e) => log.warn(String(e)));
+		}
+	}
+}

package/src/daemon/lock.ts

@@ -0,0 +1,29 @@
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { UserError } from "../errors.ts";
+
+/** One daemon per repo. Stale locks (dead pid) are taken over. */
+export async function acquireLock(root: string): Promise<() => void> {
+	const file = join(root, ".kanbot", "daemon.pid");
+	if (existsSync(file)) {
+		const pid = Number(await Bun.file(file).text());
+		if (pid && isAlive(pid)) {
+			throw new UserError("kanbot is already running for this repo.", {
+				why: `Process ${pid} holds .kanbot/daemon.pid. Only one daemon runs per repo.`,
+				fix: `Stop it with \`kill ${pid}\`, or check it with \`kanbot status\`.`,
+				docs: "usage#kanbot-run",
+			});
+		}
+	}
+	await Bun.write(file, String(process.pid));
+	return () => rmSync(file, { force: true });
+}
+
+function isAlive(pid: number) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/daemon/loop.ts

@@ -0,0 +1,212 @@
+import { loadAgents } from "../agents/load.ts";
+import { sync } from "../agents/sync.ts";
+import { type Config, loadConfig } from "../config.ts";
+import { UserError } from "../errors.ts";
+import { Gh } from "../github/gh.ts";
+import { loadBoard, missingColumns } from "../github/project.ts";
+import { Trust } from "../github/trust.ts";
+import {
+	applyAction,
+	type JobDeps,
+	NeedsHuman,
+	RateLimited,
+	runJob,
+} from "../jobs/run.ts";
+import { log } from "../log.ts";
+import { claude } from "../providers/claude.ts";
+import { codex } from "../providers/codex.ts";
+import type { Provider } from "../providers/types.ts";
+import { type Action, derive, type Job, schedule } from "./derive.ts";
+import { Worktrees } from "./git.ts";
+import { acquireLock } from "./lock.ts";
+import { Notifier } from "./notify.ts";
+import { takeSnapshot } from "./snapshot.ts";
+import { State } from "./state.ts";
+
+export type RunOptions = { once: boolean; dryRun: boolean };
+
+const RATE_LIMIT_PAUSE_MS = 30 * 60_000;
+
+export function providerFor(config: Config): Provider {
+	return config.provider === "codex"
+		? codex({ networkAccess: config.codex.networkAccess })
+		: claude;
+}
+
+export async function runDaemon(root: string, opts: RunOptions) {
+	const config = await loadConfig(root);
+	const agents = await loadAgents(root);
+	const changed = await sync(root, agents, { check: true });
+	if (changed.length) {
+		log.warn(
+			`Generated agent files are stale (${changed.join(", ")}). Run \`kanbot sync\` and commit.`,
+		);
+	}
+	const gh = new Gh(config.repo, opts.dryRun);
+	const board = await loadBoard(gh, config);
+	const missing = missingColumns(board);
+	if (missing.length)
+		throw new UserError("The project board is missing columns.", {
+			why: `No Status option for: ${missing.map((k) => config.columns[k]).join(", ")}.`,
+			fix: "kanbot board create adds them. Or match `columns` in .kanbot/config.yml to your board.",
+			docs: "configuration#columns",
+		});
+
+	const release = opts.dryRun ? () => {} : await acquireLock(root);
+	const state = await new State(root).load();
+	const deps: JobDeps = {
+		root,
+		config,
+		gh,
+		board,
+		agents,
+		provider: providerFor(config),
+		worktrees: new Worktrees(root, config.repo, config.baseBranch, opts.dryRun),
+		notify: new Notifier(config.notify),
+		state,
+	};
+	const trust = new Trust(gh);
+	const running = new Map<string, Promise<void>>();
+	let wake: () => void = () => {};
+	// kanbot-review PRs vanish from the snapshot when closed; clean up after them.
+	let prOnly = new Set<number>();
+	let stopping = false;
+
+	const stop = () => {
+		if (stopping) process.exit(1);
+		stopping = true;
+		log.info("Stopping after running jobs finish (Ctrl-C again to force)…");
+		wake();
+	};
+	process.on("SIGINT", stop);
+	process.on("SIGTERM", stop);
+
+	log.info(
+		`kanbot: ${config.repo} · ${board.url} · provider ${config.provider} · ${config.concurrency} workers${opts.dryRun ? " · DRY RUN" : ""}`,
+	);
+
+	try {
+		while (!stopping) {
+			if (Date.now() < state.pausedUntil) {
+				log.info(
+					`Paused for rate limits until ${new Date(state.pausedUntil).toLocaleTimeString()}`,
+				);
+			} else {
+				await tick().catch((e) =>
+					log.error(`tick failed: ${e instanceof Error ? e.message : e}`),
+				);
+			}
+			if (opts.once) break;
+			await new Promise<void>((resolve) => {
+				// Clear the timer on wake so Ctrl-C doesn't wait out the poll interval.
+				const timer = setTimeout(resolve, config.pollSeconds * 1000);
+				wake = () => {
+					clearTimeout(timer);
+					resolve();
+				};
+			});
+		}
+		await Promise.allSettled(running.values());
+	} finally {
+		release();
+	}
+
+	async function tick() {
+		if (!opts.dryRun) await deps.worktrees.fetch();
+		const snapshot = await takeSnapshot(gh, board, trust);
+		const { jobs, actions } = derive(snapshot, {
+			config,
+			running: new Set(running.keys()),
+			failures: state.failures,
+			now: Date.now(),
+		});
+		const nowPrOnly = new Set(
+			snapshot.items.filter((i) => i.issue.prOnly).map((i) => i.issue.number),
+		);
+		for (const n of prOnly) {
+			if (nowPrOnly.has(n)) continue;
+			// Retry next tick while a job still uses the worktree.
+			if ([...running.keys()].some((k) => k.includes(`#${n}:`)))
+				nowPrOnly.add(n);
+			else actions.push({ kind: "cleanup", number: n });
+		}
+		prOnly = nowPrOnly;
+		for (const a of actions) {
+			if (a.kind === "cleanup" && opts.dryRun) continue;
+			if (opts.dryRun) log.info(`[dry-run] action ${describeAction(a)}`);
+			await applyAction(a, deps).catch((e) =>
+				log.error(`action ${a.kind} failed: ${e}`),
+			);
+		}
+		const picked = schedule(
+			jobs,
+			config.concurrency - running.size,
+			config.priority,
+		);
+		log.debug(
+			`${jobs.length} job(s) waiting, ${running.size} running, starting ${picked.length}`,
+		);
+		for (const job of picked) {
+			if (opts.dryRun) {
+				log.info(`[dry-run] would start ${job.key}`);
+				continue;
+			}
+			running.set(job.key, start(job));
+		}
+	}
+
+	async function start(job: Job) {
+		try {
+			await runJob(job, deps);
+			await state.succeed(job.key);
+			log.info(`✔ ${job.key}`);
+		} catch (e) {
+			const msg = e instanceof Error ? e.message : String(e);
+			if (e instanceof RateLimited) {
+				log.warn(
+					`${job.key}: rate limited; pausing all work for ${RATE_LIMIT_PAUSE_MS / 60_000} min`,
+				);
+				await state.pause(RATE_LIMIT_PAUSE_MS);
+			} else if (e instanceof NeedsHuman) {
+				log.warn(`${job.key}: needs human (${msg})`);
+			} else {
+				const n = await state.fail(job.key);
+				log.error(
+					`${job.key} failed (attempt ${n}/${config.maxAttempts}): ${msg}`,
+				);
+				if (n >= config.maxAttempts) {
+					await applyAction(
+						{
+							kind: "needsHuman",
+							number: job.item.issue.number,
+							why: `\`${job.key}\` failed ${n} times. Last error:\n\n\`\`\`\n${msg.slice(0, 1500)}\n\`\`\``,
+						},
+						deps,
+					).catch(() => {});
+				}
+			}
+		} finally {
+			running.delete(job.key);
+			wake();
+		}
+	}
+}
+
+function describeAction(a: Action) {
+	switch (a.kind) {
+		case "move":
+			return `move #${a.item.issue.number} → ${a.to}`;
+		case "label":
+			return `label #${a.number} +[${a.add}] -[${a.remove}]`;
+		case "agentReviewed":
+			return `mark PR #${a.pr.number} agent-reviewed`;
+		case "compare":
+			return `post comparison on #${a.item.issue.number}`;
+		case "needsHuman":
+			return `needs-human #${a.number}`;
+		case "resetFailures":
+			return `reset failures ${a.prefix}`;
+		case "cleanup":
+			return `cleanup worktrees of #${a.number}`;
+	}
+}

package/src/daemon/notify.ts

@@ -0,0 +1,44 @@
+import notifier from "node-notifier";
+import type { Config } from "../config.ts";
+import { log } from "../log.ts";
+
+/**
+ * Agents act as your own account, so GitHub never notifies you about their
+ * work. This is the replacement: desktop notifications and/or a webhook.
+ */
+export class Notifier {
+	constructor(private config: Config["notify"]) {}
+
+	send(title: string, message: string, url?: string) {
+		log.info(`🔔 ${title} — ${message}${url ? ` ${url}` : ""}`);
+		if (this.config.desktop)
+			desktop(title, message, url).catch((e) =>
+				log.warn(`desktop notification failed: ${e}`),
+			);
+		if (this.config.webhook) {
+			fetch(this.config.webhook, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					Title: title,
+					...(url ? { Click: url } : {}),
+				},
+				body: JSON.stringify({ title, message, url }),
+			}).catch((e) => log.warn(`webhook failed: ${e}`));
+		}
+	}
+}
+
+function desktop(title: string, message: string, url?: string) {
+	return new Promise<void>((resolve, reject) =>
+		notifier.notify(
+			{
+				title: "kanbot",
+				subtitle: title,
+				message,
+				...(url ? { open: url } : {}),
+			},
+			(err) => (err ? reject(err) : resolve()),
+		),
+	);
+}

package/src/daemon/snapshot.ts

@@ -0,0 +1,109 @@
+import type { ColumnKey } from "../config.ts";
+import { LABELS } from "../config.ts";
+import { fetchIssue, fetchLabeledPRs } from "../github/api.ts";
+import type { Gh } from "../github/gh.ts";
+import { type Board, listItems } from "../github/project.ts";
+import type { Trust } from "../github/trust.ts";
+import type { Item, PR, Snapshot } from "./types.ts";
+
+const ACTIVE: ReadonlySet<ColumnKey> = new Set([
+	"planning",
+	"ready",
+	"inProgress",
+	"review",
+]);
+
+/** Board items plus full detail for issues in columns agents work on. */
+export async function takeSnapshot(
+	gh: Gh,
+	board: Board,
+	trust: Trust,
+): Promise<Snapshot> {
+	const raw = await listItems(gh, board);
+	const items = await mapLimit(
+		raw,
+		4,
+		async (r, position): Promise<Item | null> => {
+			const active =
+				r.state === "OPEN" && r.column !== null && ACTIVE.has(r.column);
+			if (active) {
+				return {
+					itemId: r.itemId,
+					column: r.column,
+					position,
+					issue: await fetchIssue(gh, r.number),
+				};
+			}
+			if (r.state !== "CLOSED") return null;
+			// Closed issues only need enough shape for cleanup.
+			return {
+				itemId: r.itemId,
+				column: r.column,
+				position,
+				issue: {
+					id: "",
+					number: r.number,
+					url: "",
+					title: "",
+					body: "",
+					state: "CLOSED",
+					labels: [],
+					comments: [],
+					prs: [],
+				},
+			};
+		},
+	);
+	const labeled = (await fetchLabeledPRs(gh, LABELS.review))
+		.filter((p) => !p.headRefName.startsWith("kanbot/"))
+		.map((p, i) => prItem(p, raw.length + i));
+	const present = [...items.filter((i): i is Item => i !== null), ...labeled];
+	const authors = present.flatMap(({ issue }) => [
+		...issue.comments.map((c) => c.author),
+		...issue.prs.flatMap((p) => [
+			...p.comments.map((c) => c.author),
+			...p.reviews.map((c) => c.author),
+			...p.threads.flatMap((t) => t.comments.map((c) => c.author)),
+		]),
+	]);
+	return { items: present, trusted: await trust.resolve(authors) };
+}
+
+/** A `kanbot-review` PR as a Review item, so it gets the same review jobs. */
+export function prItem(pr: PR, position: number): Item {
+	return {
+		itemId: "",
+		column: "review",
+		position,
+		issue: {
+			id: pr.id,
+			number: pr.number,
+			url: pr.url,
+			title: pr.title,
+			body: pr.body,
+			state: "OPEN",
+			labels: pr.labels,
+			comments: [],
+			prs: [pr],
+			prOnly: true,
+		},
+	};
+}
+
+async function mapLimit<T, R>(
+	xs: T[],
+	limit: number,
+	fn: (x: T, i: number) => Promise<R>,
+): Promise<R[]> {
+	const out: R[] = new Array(xs.length);
+	let next = 0;
+	await Promise.all(
+		Array.from({ length: Math.min(limit, xs.length) }, async () => {
+			while (next < xs.length) {
+				const i = next++;
+				out[i] = await fn(xs[i] as T, i);
+			}
+		}),
+	);
+	return out;
+}

package/src/daemon/state.ts

@@ -0,0 +1,60 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+type Data = { failures: Record<string, number>; pausedUntil: number };
+
+/**
+ * The only local state: failure counts and a rate-limit pause. Everything else
+ * is derived from GitHub on each tick, so deleting this file is always safe.
+ */
+export class State {
+	private data: Data = { failures: {}, pausedUntil: 0 };
+	private readonly file: string;
+
+	constructor(root: string) {
+		this.file = join(root, ".kanbot", "state.json");
+	}
+
+	async load() {
+		if (existsSync(this.file)) {
+			this.data = { ...this.data, ...(await Bun.file(this.file).json()) };
+		}
+		return this;
+	}
+
+	private save() {
+		return Bun.write(this.file, JSON.stringify(this.data, null, 2));
+	}
+
+	get failures(): ReadonlyMap<string, number> {
+		return new Map(Object.entries(this.data.failures));
+	}
+
+	async fail(key: string) {
+		this.data.failures[key] = (this.data.failures[key] ?? 0) + 1;
+		await this.save();
+		return this.data.failures[key];
+	}
+
+	async succeed(key: string) {
+		if (!(key in this.data.failures)) return;
+		delete this.data.failures[key];
+		await this.save();
+	}
+
+	async resetFailures(prefix: string) {
+		for (const k of Object.keys(this.data.failures)) {
+			if (k.includes(prefix)) delete this.data.failures[k];
+		}
+		await this.save();
+	}
+
+	get pausedUntil() {
+		return this.data.pausedUntil;
+	}
+
+	async pause(ms: number) {
+		this.data.pausedUntil = Date.now() + ms;
+		await this.save();
+	}
+}