kanbot 0.0.0-stage → 0.1.0

package/src/daemon/loop.ts

@@ -0,0 +1,207 @@
+import { loadAgents } from "../agents/load.ts";
+import { sync } from "../agents/sync.ts";
+import { type Config, loadConfig } from "../config.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 Error(`Board is missing columns: ${missing.join(", ")}`);
+
+	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();
+	}
+}

package/src/daemon/types.ts

@@ -0,0 +1,73 @@
+import type { ColumnKey } from "../config.ts";
+
+export type Comment = {
+	id: string;
+	databaseId: number;
+	author: string;
+	body: string;
+	createdAt: string;
+};
+
+export type ReviewThread = {
+	id: string;
+	isResolved: boolean;
+	path: string | null;
+	line: number | null;
+	comments: Comment[];
+};
+
+export type Checks =
+	| "SUCCESS"
+	| "FAILURE"
+	| "ERROR"
+	| "PENDING"
+	| "EXPECTED"
+	| null;
+
+export type PR = {
+	id: string;
+	number: number;
+	url: string;
+	title: string;
+	body: string;
+	state: "OPEN" | "CLOSED" | "MERGED";
+	headRefName: string;
+	headSha: string;
+	createdAt: string;
+	labels: string[];
+	comments: Comment[];
+	/** Submitted reviews that have a body. */
+	reviews: Comment[];
+	threads: ReviewThread[];
+	checks: Checks;
+	/** UNKNOWN while GitHub is still computing it. */
+	mergeable: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+};
+
+export type Issue = {
+	id: string;
+	number: number;
+	url: string;
+	title: string;
+	body: string;
+	state: "OPEN" | "CLOSED";
+	labels: string[];
+	comments: Comment[];
+	prs: PR[];
+	/** A PR labeled `kanbot-review`, reviewed without a card. Fields mirror the PR. */
+	prOnly?: boolean;
+};
+
+export type Item = {
+	itemId: string;
+	column: ColumnKey | null;
+	/** Index in board order; lower is higher priority. */
+	position: number;
+	issue: Issue;
+};
+
+export type Snapshot = {
+	items: Item[];
+	/** Logins whose comments agents act on (collaborators with write access). */
+	trusted: ReadonlySet<string>;
+};