@sanurb/ringi 0.2.1 → 0.3.0

package/server/server/_ssr/runtime-D9IbnMlF.mjs

@@ -0,0 +1,1401 @@
+import { $ as acquireRelease, A as offer, Bt as isSome, D as fromQueue, Dt as try_, E as withDefault, Et as tryPromise, Ft as isSuccess, M as sliding, Nt as mergeAll, Pt as provide, R as NullOr, Rt as Service, S as make, St as sync, T as string, U as TaggedErrorClass, V as String$1, _t as orElseSucceed, at as catchTag, dt as gen, et as acquireUseRelease, ht as mapError, j as shutdown, jt as effect, kt as withSpan, lt as flatMap, mt as map, nt as as, rt as asVoid, tt as andThen, ut as fn, vt as promise, xt as succeed, yt as runFork, z as Number$1, zt as getOrNull } from "../_libs/effect+[...].mjs";
+import { p as TodoNotFound, r as CommentNotFound, u as ReviewNotFound } from "./todo-m_uUvxca.mjs";
+import { t as chokidar_default } from "../_libs/chokidar+readdirp.mjs";
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { execFile, spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { DatabaseSync } from "node:sqlite";
+import { platform } from "node:os";
+//#region node_modules/.nitro/vite/services/ssr/assets/runtime-D9IbnMlF.js
+var HUNK_HEADER = /@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var splitIntoFiles = (diffText) => {
+	const files = [];
+	const lines = diffText.split("\n");
+	let current = [];
+	for (const line of lines) if (line.startsWith("diff --git")) {
+		if (current.length > 0) files.push(current.join("\n"));
+		current = [line];
+	} else current.push(line);
+	if (current.length > 0) files.push(current.join("\n"));
+	return files;
+};
+var parseHunks$1 = (lines) => {
+	const hunks = [];
+	let currentHunk = null;
+	let oldLineNum = 0;
+	let newLineNum = 0;
+	for (const line of lines) {
+		const match = line.match(HUNK_HEADER);
+		if (match) {
+			if (currentHunk) hunks.push(currentHunk);
+			const oldStart = Number.parseInt(match[1], 10);
+			const oldLines = Number.parseInt(match[2] ?? "1", 10);
+			const newStart = Number.parseInt(match[3], 10);
+			currentHunk = {
+				lines: [],
+				newLines: Number.parseInt(match[4] ?? "1", 10),
+				newStart,
+				oldLines,
+				oldStart
+			};
+			oldLineNum = oldStart;
+			newLineNum = newStart;
+			continue;
+		}
+		if (!currentHunk) continue;
+		if (line.startsWith("+") && !line.startsWith("+++")) currentHunk.lines.push({
+			content: line.slice(1),
+			newLineNumber: newLineNum++,
+			oldLineNumber: null,
+			type: "added"
+		});
+		else if (line.startsWith("-") && !line.startsWith("---")) currentHunk.lines.push({
+			content: line.slice(1),
+			newLineNumber: null,
+			oldLineNumber: oldLineNum++,
+			type: "removed"
+		});
+		else if (line.startsWith(" ")) currentHunk.lines.push({
+			content: line.slice(1),
+			newLineNumber: newLineNum++,
+			oldLineNumber: oldLineNum++,
+			type: "context"
+		});
+	}
+	if (currentHunk) hunks.push(currentHunk);
+	return hunks;
+};
+var parseFileDiff = (fileDiff) => {
+	const lines = fileDiff.split("\n");
+	const diffLine = lines.find((l) => l.startsWith("diff --git"));
+	if (!diffLine) return null;
+	const pathMatch = diffLine.match(/diff --git a\/(.+) b\/(.+)/);
+	if (!pathMatch) return null;
+	const oldPath = pathMatch[1];
+	const newPath = pathMatch[2];
+	let status = "modified";
+	if (lines.some((l) => l.startsWith("deleted file mode"))) status = "deleted";
+	else if (lines.some((l) => l.startsWith("new file mode"))) status = "added";
+	else if (lines.some((l) => l.startsWith("rename from")) || oldPath !== newPath) status = "renamed";
+	const hunks = parseHunks$1(lines);
+	let additions = 0;
+	let deletions = 0;
+	for (const hunk of hunks) for (const line of hunk.lines) if (line.type === "added") additions++;
+	else if (line.type === "removed") deletions++;
+	return {
+		additions,
+		deletions,
+		hunks,
+		newPath,
+		oldPath,
+		status
+	};
+};
+/** Parse a full multi-file unified diff into structured DiffFile objects. */
+var parseDiff = (diffText) => {
+	if (!diffText.trim()) return [];
+	const blocks = splitIntoFiles(diffText);
+	const files = [];
+	for (const block of blocks) {
+		const parsed = parseFileDiff(block);
+		if (parsed) files.push(parsed);
+	}
+	return files;
+};
+/** Aggregate stats from already-parsed files. */
+var getDiffSummary = (files) => {
+	let totalAdditions = 0;
+	let totalDeletions = 0;
+	for (const file of files) {
+		totalAdditions += file.additions;
+		totalDeletions += file.deletions;
+	}
+	return {
+		filesAdded: files.filter((f) => f.status === "added").length,
+		filesDeleted: files.filter((f) => f.status === "deleted").length,
+		filesModified: files.filter((f) => f.status === "modified").length,
+		filesRenamed: files.filter((f) => f.status === "renamed").length,
+		totalAdditions,
+		totalDeletions,
+		totalFiles: files.length
+	};
+};
+var GitError = class extends TaggedErrorClass()("GitError", { message: String$1 }) {};
+/** Max bytes to collect from a git command before truncating (200 MB). */
+var MAX_STDOUT_BYTES$1 = 200 * 1024 * 1024;
+var execGit = (args, repoPath) => tryPromise({
+	catch: (error) => new GitError({ message: String(error) }),
+	try: () => new Promise((resolve, reject) => {
+		const child = spawn("git", [...args], { cwd: repoPath });
+		const chunks = [];
+		let bytes = 0;
+		let truncated = false;
+		child.stdout.on("data", (chunk) => {
+			if (truncated) return;
+			bytes += chunk.length;
+			if (bytes > MAX_STDOUT_BYTES$1) {
+				truncated = true;
+				child.kill();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		let stderr = "";
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", reject);
+		child.on("close", (code) => {
+			if (truncated) {
+				resolve(Buffer.concat(chunks).toString("utf8"));
+				return;
+			}
+			if (code !== 0) reject(/* @__PURE__ */ new Error(`git ${args[0]} exited with code ${code}: ${stderr}`));
+			else resolve(Buffer.concat(chunks).toString("utf8"));
+		});
+	})
+});
+/** Split git output into non-empty lines. */
+var lines = (output) => output.trim().split("\n").filter(Boolean);
+/** Parse name-status output (e.g. `M\tfile.ts`). */
+var parseNameStatus = (output) => lines(output).map((line) => {
+	const [status, ...rest] = line.split("	");
+	return {
+		path: rest.join("	"),
+		status
+	};
+});
+var GitService = class GitService extends Service()("@ringi/GitService") {
+	static Default = effect(GitService, gen(function* () {
+		const repoPath = yield* string("REPOSITORY_PATH").pipe(withDefault(process.cwd()));
+		const hasCommits = execGit(["rev-parse", "HEAD"], repoPath).pipe(as(true), catchTag("GitError", () => succeed(false)), withSpan("GitService.hasCommits"));
+		const getRepositoryInfo = gen(function* () {
+			const name = yield* execGit(["rev-parse", "--show-toplevel"], repoPath).pipe(map((s) => s.trim().split("/").pop() ?? "unknown"));
+			return {
+				branch: yield* execGit([
+					"rev-parse",
+					"--abbrev-ref",
+					"HEAD"
+				], repoPath).pipe(map((s) => s.trim())),
+				name,
+				path: repoPath,
+				remote: yield* execGit([
+					"config",
+					"--get",
+					"remote.origin.url"
+				], repoPath).pipe(map((s) => s.trim() || null), catchTag("GitError", () => succeed(null)))
+			};
+		}).pipe(withSpan("GitService.getRepositoryInfo"));
+		const getStagedDiff = execGit([
+			"diff",
+			"--cached",
+			"--no-color",
+			"--unified=3"
+		], repoPath).pipe(withSpan("GitService.getStagedDiff"));
+		const getUncommittedDiff = hasCommits.pipe(flatMap((has) => has ? execGit([
+			"diff",
+			"HEAD",
+			"--no-color",
+			"--unified=3"
+		], repoPath) : succeed("")), withSpan("GitService.getUncommittedDiff"));
+		const getUnstagedDiff = execGit([
+			"diff",
+			"--no-color",
+			"--unified=3"
+		], repoPath).pipe(withSpan("GitService.getUnstagedDiff"));
+		const getLastCommitDiff = hasCommits.pipe(flatMap((has) => has ? execGit([
+			"show",
+			"HEAD",
+			"--format=",
+			"--no-color",
+			"--unified=3"
+		], repoPath) : succeed("")), withSpan("GitService.getLastCommitDiff"));
+		const getBranchDiff = fn("GitService.getBranchDiff")(function* (branch) {
+			return yield* execGit([
+				"diff",
+				`${branch}...HEAD`,
+				"--no-color",
+				"--unified=3"
+			], repoPath);
+		});
+		const getCommitDiff = fn("GitService.getCommitDiff")(function* (shas) {
+			if (shas.length === 1) return yield* execGit([
+				"show",
+				shas[0],
+				"--format=",
+				"--no-color",
+				"--unified=3"
+			], repoPath);
+			const first = shas.at(-1);
+			const last = shas[0];
+			return yield* execGit([
+				"diff",
+				`${first}~1..${last}`,
+				"--no-color",
+				"--unified=3"
+			], repoPath);
+		});
+		const getStagedFiles = execGit([
+			"diff",
+			"--cached",
+			"--name-status"
+		], repoPath).pipe(map(parseNameStatus), withSpan("GitService.getStagedFiles"));
+		const getUncommittedFiles = hasCommits.pipe(flatMap((has) => has ? execGit([
+			"diff",
+			"HEAD",
+			"--name-status"
+		], repoPath).pipe(map(parseNameStatus)) : succeed([])), withSpan("GitService.getUncommittedFiles"));
+		const getUnstagedFiles = execGit(["diff", "--name-status"], repoPath).pipe(map(parseNameStatus), withSpan("GitService.getUnstagedFiles"));
+		const getLastCommitFiles = hasCommits.pipe(flatMap((has) => has ? execGit([
+			"show",
+			"HEAD",
+			"--format=",
+			"--name-status"
+		], repoPath).pipe(map(parseNameStatus)) : succeed([])), withSpan("GitService.getLastCommitFiles"));
+		const getFileContent = fn("GitService.getFileContent")(function* (filePath, version) {
+			switch (version) {
+				case "staged": return yield* execGit(["show", `:${filePath}`], repoPath);
+				case "head": return yield* execGit(["show", `HEAD:${filePath}`], repoPath);
+				default: return yield* tryPromise({
+					catch: (error) => new GitError({ message: `Failed to read ${filePath}: ${String(error)}` }),
+					try: () => readFile(join(repoPath, filePath), "utf8")
+				});
+			}
+		});
+		const getFileTree = fn("GitService.getFileTree")(function* (ref) {
+			return yield* execGit([
+				"ls-tree",
+				"-r",
+				"--name-only",
+				ref
+			], repoPath).pipe(map(lines));
+		});
+		const getBranches = execGit(["branch", "--format=%(refname:short)	%(HEAD)"], repoPath).pipe(map((output) => lines(output).map((line) => {
+			const [name, head] = line.split("	");
+			return {
+				current: head === "*",
+				name
+			};
+		})), withSpan("GitService.getBranches"));
+		const getCommits = fn("GitService.getCommits")(function* (opts) {
+			const limit = (opts.limit ?? 20) + 1;
+			const args = [
+				"log",
+				`--max-count=${limit}`,
+				`--skip=${opts.offset ?? 0}`,
+				"--format=%H	%s	%an	%aI"
+			];
+			if (opts.search) args.push(`--grep=${opts.search}`, "-i");
+			const rows = lines(yield* execGit(args, repoPath));
+			const hasMore = rows.length === limit;
+			return {
+				commits: (hasMore ? rows.slice(0, -1) : rows).map((line) => {
+					const [hash, message, author, date] = line.split("	");
+					return {
+						author,
+						date,
+						hash,
+						message
+					};
+				}),
+				hasMore
+			};
+		});
+		const stageFiles = fn("GitService.stageFiles")(function* (files) {
+			return yield* execGit([
+				"add",
+				"--",
+				...files
+			], repoPath).pipe(as(files));
+		});
+		const stageAll = execGit(["add", "-A"], repoPath).pipe(flatMap(() => getStagedFiles), map((files) => files.map((f) => f.path)), withSpan("GitService.stageAll"));
+		const unstageFiles = fn("GitService.unstageFiles")(function* (files) {
+			return yield* execGit([
+				"reset",
+				"HEAD",
+				"--",
+				...files
+			], repoPath).pipe(as(files));
+		});
+		const getRepositoryPath = execGit(["rev-parse", "--show-toplevel"], repoPath).pipe(map((s) => s.trim()), withSpan("GitService.getRepositoryPath"));
+		return GitService.of({
+			getBranchDiff,
+			getBranches,
+			getCommitDiff,
+			getCommits,
+			getFileContent,
+			getFileTree,
+			getLastCommitDiff,
+			getLastCommitFiles,
+			getRepositoryInfo,
+			getRepositoryPath,
+			getStagedDiff,
+			getStagedFiles,
+			getUncommittedDiff,
+			getUncommittedFiles,
+			getUnstagedDiff,
+			getUnstagedFiles,
+			hasCommits,
+			stageAll,
+			stageFiles,
+			unstageFiles
+		});
+	}));
+};
+var migrations = [
+	`CREATE TABLE IF NOT EXISTS reviews (
+    id TEXT PRIMARY KEY,
+    repository_path TEXT NOT NULL,
+    base_ref TEXT,
+    snapshot_data TEXT NOT NULL,
+    status TEXT DEFAULT 'in_progress',
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`,
+	`CREATE TABLE IF NOT EXISTS comments (
+    id TEXT PRIMARY KEY,
+    review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+    file_path TEXT NOT NULL,
+    line_number INTEGER,
+    line_type TEXT,
+    content TEXT NOT NULL,
+    suggestion TEXT,
+    resolved INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`,
+	`ALTER TABLE reviews ADD COLUMN source_type TEXT DEFAULT 'staged';
+   ALTER TABLE reviews ADD COLUMN source_ref TEXT`,
+	`CREATE TABLE IF NOT EXISTS todos (
+    id TEXT PRIMARY KEY,
+    content TEXT NOT NULL,
+    completed INTEGER DEFAULT 0,
+    review_id TEXT REFERENCES reviews(id) ON DELETE CASCADE,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`,
+	`ALTER TABLE todos ADD COLUMN position INTEGER DEFAULT 0`,
+	`CREATE TABLE IF NOT EXISTS review_files (
+    id TEXT PRIMARY KEY,
+    review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+    file_path TEXT NOT NULL,
+    old_path TEXT,
+    status TEXT NOT NULL,
+    additions INTEGER NOT NULL DEFAULT 0,
+    deletions INTEGER NOT NULL DEFAULT 0,
+    hunks_data TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`
+];
+/** Apply pending migrations using PRAGMA user_version as the version tracker. */
+var runMigrations = (db) => {
+	const currentVersion = db.prepare("PRAGMA user_version").get().user_version;
+	for (let i = currentVersion; i < migrations.length; i++) {
+		const statements = migrations[i].split(";").map((s) => s.trim()).filter(Boolean);
+		for (const sql of statements) db.exec(sql);
+		db.exec(`PRAGMA user_version = ${i + 1}`);
+	}
+};
+/**
+* Wraps `body` in a SQLite transaction: BEGIN before, COMMIT on success,
+* ROLLBACK on any failure or interruption.
+*/
+var withTransaction = (db, body) => acquireUseRelease(sync(() => db.exec("BEGIN")), () => body, (_, exit) => sync(() => {
+	if (isSuccess(exit)) db.exec("COMMIT");
+	else db.exec("ROLLBACK");
+}));
+var SqliteService = class SqliteService extends Service()("@ringi/SqliteService") {
+	static Default = effect(SqliteService, gen(function* () {
+		const dbPath = yield* string("DB_PATH").pipe(withDefault(".ringi/reviews.db"));
+		mkdirSync(dirname(dbPath), { recursive: true });
+		const db = new DatabaseSync(dbPath);
+		db.exec("PRAGMA journal_mode=WAL");
+		db.exec("PRAGMA foreign_keys=ON");
+		runMigrations(db);
+		return SqliteService.of({ db });
+	}));
+};
+var rowToComment = (row) => ({
+	content: row.content,
+	createdAt: row.created_at,
+	filePath: row.file_path,
+	id: row.id,
+	lineNumber: row.line_number,
+	lineType: row.line_type,
+	resolved: row.resolved === 1,
+	reviewId: row.review_id,
+	suggestion: row.suggestion,
+	updatedAt: row.updated_at
+});
+var CommentRepo = class CommentRepo extends Service()("@ringi/CommentRepo") {
+	static Default = effect(CommentRepo, gen(function* () {
+		const { db } = yield* SqliteService;
+		const stmtFindById = db.prepare("SELECT * FROM comments WHERE id = ?");
+		const stmtFindByReview = db.prepare("SELECT * FROM comments WHERE review_id = ? ORDER BY created_at ASC");
+		const stmtFindByFile = db.prepare("SELECT * FROM comments WHERE review_id = ? AND file_path = ? ORDER BY line_number ASC, created_at ASC");
+		const stmtInsert = db.prepare(`INSERT INTO comments (id, review_id, file_path, line_number, line_type, content, suggestion, resolved, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 0, datetime('now'), datetime('now'))`);
+		const stmtDelete = db.prepare("DELETE FROM comments WHERE id = ?");
+		const stmtDeleteByReview = db.prepare("DELETE FROM comments WHERE review_id = ?");
+		const stmtSetResolved = db.prepare("UPDATE comments SET resolved = ?, updated_at = datetime('now') WHERE id = ?");
+		const stmtCountByReview = db.prepare(`SELECT
+         COUNT(*) as total,
+         SUM(CASE WHEN resolved = 1 THEN 1 ELSE 0 END) as resolved,
+         SUM(CASE WHEN resolved = 0 THEN 1 ELSE 0 END) as unresolved,
+         SUM(CASE WHEN suggestion IS NOT NULL THEN 1 ELSE 0 END) as with_suggestions
+       FROM comments WHERE review_id = ?`);
+		const findById = (id) => sync(() => {
+			const row = stmtFindById.get(id);
+			return row ? rowToComment(row) : null;
+		});
+		const findByReview = (reviewId) => sync(() => {
+			return stmtFindByReview.all(reviewId).map(rowToComment);
+		});
+		const findByFile = (reviewId, filePath) => sync(() => {
+			return stmtFindByFile.all(reviewId, filePath).map(rowToComment);
+		});
+		const create = (input) => sync(() => {
+			stmtInsert.run(input.id, input.reviewId, input.filePath, input.lineNumber, input.lineType, input.content, input.suggestion);
+			return rowToComment(stmtFindById.get(input.id));
+		});
+		const update = (id, updates) => sync(() => {
+			const setClauses = [];
+			const params = [];
+			if (updates.content !== void 0) {
+				setClauses.push("content = ?");
+				params.push(updates.content);
+			}
+			if (updates.suggestion !== void 0) {
+				setClauses.push("suggestion = ?");
+				params.push(updates.suggestion);
+			}
+			if (setClauses.length === 0) {
+				const row = stmtFindById.get(id);
+				return row ? rowToComment(row) : null;
+			}
+			setClauses.push("updated_at = datetime('now')");
+			params.push(id);
+			db.prepare(`UPDATE comments SET ${setClauses.join(", ")} WHERE id = ?`).run(...params);
+			const row = stmtFindById.get(id);
+			return row ? rowToComment(row) : null;
+		});
+		const setResolved = (id, resolved) => sync(() => {
+			stmtSetResolved.run(resolved ? 1 : 0, id);
+			const row = stmtFindById.get(id);
+			return row ? rowToComment(row) : null;
+		});
+		const remove = (id) => sync(() => {
+			const result = stmtDelete.run(id);
+			return Number(result.changes) > 0;
+		});
+		const removeByReview = (reviewId) => sync(() => {
+			const result = stmtDeleteByReview.run(reviewId);
+			return Number(result.changes);
+		});
+		const countByReview = (reviewId) => sync(() => {
+			const row = stmtCountByReview.get(reviewId);
+			return {
+				resolved: row.resolved,
+				total: row.total,
+				unresolved: row.unresolved,
+				withSuggestions: row.with_suggestions
+			};
+		});
+		return CommentRepo.of({
+			countByReview,
+			create,
+			findByFile,
+			findById,
+			findByReview,
+			remove,
+			removeByReview,
+			setResolved,
+			update
+		});
+	}));
+};
+var parseHunks = (hunksData) => hunksData == null ? succeed([]) : try_({
+	try: () => JSON.parse(hunksData),
+	catch: () => []
+}).pipe(orElseSucceed(() => []));
+var serializeHunks = (hunks) => JSON.stringify(hunks);
+var ReviewFileRepo = class ReviewFileRepo extends Service()("@ringi/ReviewFileRepo") {
+	static Default = effect(ReviewFileRepo, gen(function* () {
+		const { db } = yield* SqliteService;
+		const stmtFindByReview = db.prepare(`SELECT id, review_id, file_path, old_path, status, additions, deletions, created_at
+         FROM review_files WHERE review_id = ? ORDER BY file_path`);
+		const stmtFindByReviewAndPath = db.prepare("SELECT * FROM review_files WHERE review_id = ? AND file_path = ?");
+		const stmtInsert = db.prepare(`INSERT INTO review_files (id, review_id, file_path, old_path, status, additions, deletions, hunks_data, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`);
+		const stmtDeleteByReview = db.prepare("DELETE FROM review_files WHERE review_id = ?");
+		const stmtCountByReview = db.prepare("SELECT COUNT(*) as count FROM review_files WHERE review_id = ?");
+		const findByReview = (reviewId) => sync(() => stmtFindByReview.all(reviewId));
+		const findByReviewAndPath = (reviewId, filePath) => sync(() => {
+			return stmtFindByReviewAndPath.get(reviewId, filePath) ?? null;
+		});
+		const createBulk = (files) => withTransaction(db, sync(() => {
+			for (const f of files) stmtInsert.run(randomUUID(), f.reviewId, f.filePath, f.oldPath, f.status, f.additions, f.deletions, f.hunksData);
+		}));
+		const deleteByReview = (reviewId) => sync(() => {
+			const result = stmtDeleteByReview.run(reviewId);
+			return Number(result.changes);
+		});
+		const countByReview = (reviewId) => sync(() => {
+			return stmtCountByReview.get(reviewId).count;
+		});
+		return ReviewFileRepo.of({
+			countByReview,
+			createBulk,
+			deleteByReview,
+			findByReview,
+			findByReviewAndPath
+		});
+	}));
+};
+var rowToReview = (row) => ({
+	baseRef: row.base_ref,
+	createdAt: row.created_at,
+	id: row.id,
+	repositoryPath: row.repository_path,
+	snapshotData: row.snapshot_data,
+	sourceRef: row.source_ref,
+	sourceType: row.source_type,
+	status: row.status,
+	updatedAt: row.updated_at
+});
+var ReviewRepo = class ReviewRepo extends Service()("@ringi/ReviewRepo") {
+	static Default = effect(ReviewRepo, gen(function* () {
+		const { db } = yield* SqliteService;
+		const stmtFindById = db.prepare("SELECT * FROM reviews WHERE id = ?");
+		const stmtInsert = db.prepare(`INSERT INTO reviews (id, repository_path, base_ref, source_type, source_ref, snapshot_data, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))`);
+		const stmtUpdate = db.prepare(`UPDATE reviews SET status = COALESCE(?, status), updated_at = datetime('now') WHERE id = ?`);
+		const stmtUpdateSnapshot = db.prepare(`UPDATE reviews SET snapshot_data = ?, updated_at = datetime('now') WHERE id = ?`);
+		const stmtDelete = db.prepare("DELETE FROM reviews WHERE id = ?");
+		const stmtCountAll = db.prepare("SELECT COUNT(*) as count FROM reviews");
+		const stmtCountByStatus = db.prepare("SELECT COUNT(*) as count FROM reviews WHERE status = ?");
+		const findById = (id) => sync(() => {
+			const row = stmtFindById.get(id);
+			return row ? rowToReview(row) : null;
+		});
+		const findAll = (opts = {}) => sync(() => {
+			const conditions = [];
+			const params = [];
+			if (opts.status != null) {
+				conditions.push("status = ?");
+				params.push(opts.status);
+			}
+			if (opts.repositoryPath != null) {
+				conditions.push("repository_path = ?");
+				params.push(opts.repositoryPath);
+			}
+			if (opts.sourceType != null) {
+				conditions.push("source_type = ?");
+				params.push(opts.sourceType);
+			}
+			const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+			const page = opts.page ?? 1;
+			const pageSize = opts.pageSize ?? 20;
+			const offset = (page - 1) * pageSize;
+			const totalRow = db.prepare(`SELECT COUNT(*) as count FROM reviews${where}`).get(...params);
+			return {
+				data: db.prepare(`SELECT * FROM reviews${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, pageSize, offset).map(rowToReview),
+				total: totalRow.count
+			};
+		});
+		const create = (input) => sync(() => {
+			stmtInsert.run(input.id, input.repositoryPath, input.baseRef, input.sourceType, input.sourceRef, input.snapshotData, input.status);
+			return rowToReview(stmtFindById.get(input.id));
+		});
+		const update = (id, status) => sync(() => {
+			stmtUpdate.run(status, id);
+			const row = stmtFindById.get(id);
+			return row ? rowToReview(row) : null;
+		});
+		const updateSnapshotData = (id, snapshotData) => sync(() => {
+			stmtUpdateSnapshot.run(snapshotData, id);
+			const row = stmtFindById.get(id);
+			return row ? rowToReview(row) : null;
+		});
+		const remove = (id) => sync(() => {
+			const result = stmtDelete.run(id);
+			return Number(result.changes) > 0;
+		});
+		const countAll = () => sync(() => {
+			return stmtCountAll.get().count;
+		});
+		const countByStatus = (status) => sync(() => {
+			return stmtCountByStatus.get(status).count;
+		});
+		return ReviewRepo.of({
+			countAll,
+			countByStatus,
+			create,
+			findAll,
+			findById,
+			remove,
+			update,
+			updateSnapshotData
+		});
+	}));
+};
+var rowToTodo = (row) => ({
+	completed: row.completed === 1,
+	content: row.content,
+	createdAt: row.created_at,
+	id: row.id,
+	position: row.position,
+	reviewId: row.review_id,
+	updatedAt: row.updated_at
+});
+var TodoRepo = class TodoRepo extends Service()("@ringi/TodoRepo") {
+	static Default = effect(TodoRepo, gen(function* () {
+		const { db } = yield* SqliteService;
+		const stmtFindById = db.prepare("SELECT * FROM todos WHERE id = ?");
+		const stmtInsert = db.prepare(`INSERT INTO todos (id, content, completed, review_id, position, created_at, updated_at)
+       VALUES (?, ?, 0, ?, ?, datetime('now'), datetime('now'))`);
+		const stmtDelete = db.prepare("DELETE FROM todos WHERE id = ?");
+		const stmtDeleteCompleted = db.prepare("DELETE FROM todos WHERE completed = 1");
+		const stmtNextPosition = db.prepare("SELECT COALESCE(MAX(position), -1) + 1 AS next_pos FROM todos");
+		const stmtCountAll = db.prepare("SELECT COUNT(*) as count FROM todos");
+		const stmtCountCompleted = db.prepare("SELECT COUNT(*) as count FROM todos WHERE completed = 1");
+		const stmtCountPending = db.prepare("SELECT COUNT(*) as count FROM todos WHERE completed = 0");
+		const findById = (id) => sync(() => {
+			const row = stmtFindById.get(id);
+			return row ? rowToTodo(row) : null;
+		});
+		const findAll = (opts = {}) => sync(() => {
+			const conditions = [];
+			const params = [];
+			if (opts.reviewId != null) {
+				conditions.push("review_id = ?");
+				params.push(opts.reviewId);
+			}
+			if (opts.completed != null) {
+				conditions.push("completed = ?");
+				params.push(opts.completed ? 1 : 0);
+			}
+			const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+			const totalRow = db.prepare(`SELECT COUNT(*) as count FROM todos${where}`).get(...params);
+			const limitClause = opts.limit != null ? ` LIMIT ? OFFSET ?` : "";
+			const queryParams = opts.limit != null ? [
+				...params,
+				opts.limit,
+				opts.offset ?? 0
+			] : params;
+			return {
+				data: db.prepare(`SELECT * FROM todos${where} ORDER BY position ASC${limitClause}`).all(...queryParams).map(rowToTodo),
+				total: totalRow.count
+			};
+		});
+		const create = (input) => sync(() => {
+			const { next_pos } = stmtNextPosition.get();
+			stmtInsert.run(input.id, input.content, input.reviewId, next_pos);
+			return rowToTodo(stmtFindById.get(input.id));
+		});
+		const update = (id, updates) => sync(() => {
+			const sets = [];
+			const params = [];
+			if (updates.content != null) {
+				sets.push("content = ?");
+				params.push(updates.content);
+			}
+			if (updates.completed != null) {
+				sets.push("completed = ?");
+				params.push(updates.completed ? 1 : 0);
+			}
+			if (sets.length === 0) {
+				const row = stmtFindById.get(id);
+				return row ? rowToTodo(row) : null;
+			}
+			sets.push("updated_at = datetime('now')");
+			params.push(id);
+			db.prepare(`UPDATE todos SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+			const row = stmtFindById.get(id);
+			return row ? rowToTodo(row) : null;
+		});
+		const toggle = (id) => sync(() => {
+			const row = stmtFindById.get(id);
+			if (!row) return null;
+			const newCompleted = row.completed === 1 ? 0 : 1;
+			db.prepare("UPDATE todos SET completed = ?, updated_at = datetime('now') WHERE id = ?").run(newCompleted, id);
+			return rowToTodo(stmtFindById.get(id));
+		});
+		const remove = (id) => sync(() => {
+			const result = stmtDelete.run(id);
+			return Number(result.changes) > 0;
+		});
+		const removeCompleted = () => sync(() => {
+			const result = stmtDeleteCompleted.run();
+			return Number(result.changes);
+		});
+		const reorder = (orderedIds) => withTransaction(db, sync(() => {
+			const stmt = db.prepare("UPDATE todos SET position = ?, updated_at = datetime('now') WHERE id = ?");
+			let updated = 0;
+			for (let i = 0; i < orderedIds.length; i++) {
+				const result = stmt.run(i, orderedIds[i]);
+				updated += Number(result.changes);
+			}
+			return updated;
+		}));
+		const move = (id, newPosition) => gen(function* () {
+			const row = stmtFindById.get(id);
+			if (!row) return null;
+			const oldPosition = row.position;
+			yield* withTransaction(db, sync(() => {
+				if (newPosition < oldPosition) db.prepare("UPDATE todos SET position = position + 1, updated_at = datetime('now') WHERE position >= ? AND position < ? AND id != ?").run(newPosition, oldPosition, id);
+				else if (newPosition > oldPosition) db.prepare("UPDATE todos SET position = position - 1, updated_at = datetime('now') WHERE position > ? AND position <= ? AND id != ?").run(oldPosition, newPosition, id);
+				db.prepare("UPDATE todos SET position = ?, updated_at = datetime('now') WHERE id = ?").run(newPosition, id);
+			}));
+			return rowToTodo(stmtFindById.get(id));
+		});
+		const countAll = () => sync(() => {
+			return stmtCountAll.get().count;
+		});
+		const countCompleted = () => sync(() => {
+			return stmtCountCompleted.get().count;
+		});
+		const countPending = () => sync(() => {
+			return stmtCountPending.get().count;
+		});
+		return TodoRepo.of({
+			countAll,
+			countCompleted,
+			countPending,
+			create,
+			findAll,
+			findById,
+			move,
+			remove,
+			removeCompleted,
+			reorder,
+			toggle,
+			update
+		});
+	}));
+};
+var CommentService = class CommentService extends Service()("@ringi/CommentService") {
+	static Default = effect(CommentService, gen(function* () {
+		const repo = yield* CommentRepo;
+		const create = (reviewId, input) => {
+			const id = randomUUID();
+			return repo.create({
+				content: input.content,
+				filePath: input.filePath,
+				id,
+				lineNumber: input.lineNumber ?? null,
+				lineType: input.lineType ?? null,
+				reviewId,
+				suggestion: input.suggestion ?? null
+			});
+		};
+		const getById = (id) => gen(function* () {
+			const comment = yield* repo.findById(id);
+			if (!comment) return yield* new CommentNotFound({ id });
+			return comment;
+		});
+		const getByReview = (reviewId) => repo.findByReview(reviewId);
+		const getByFile = (reviewId, filePath) => repo.findByFile(reviewId, filePath);
+		const update = (id, input) => gen(function* () {
+			const updates = {};
+			if (input.content && isSome(input.content)) updates.content = input.content.value;
+			if (input.suggestion && isSome(input.suggestion)) updates.suggestion = input.suggestion.value;
+			const comment = yield* repo.update(id, updates);
+			if (!comment) return yield* new CommentNotFound({ id });
+			return comment;
+		});
+		const resolve = (id) => gen(function* () {
+			const comment = yield* repo.setResolved(id, true);
+			if (!comment) return yield* new CommentNotFound({ id });
+			return comment;
+		});
+		const unresolve = (id) => gen(function* () {
+			const comment = yield* repo.setResolved(id, false);
+			if (!comment) return yield* new CommentNotFound({ id });
+			return comment;
+		});
+		const remove = (id) => gen(function* () {
+			if (!(yield* repo.remove(id))) return yield* new CommentNotFound({ id });
+			return { success: true };
+		});
+		const getStats = (reviewId) => repo.countByReview(reviewId);
+		return CommentService.of({
+			create,
+			getByFile,
+			getById,
+			getByReview,
+			getStats,
+			remove,
+			resolve,
+			unresolve,
+			update
+		});
+	}));
+};
+var EventService = class EventService extends Service()("@ringi/EventService") {
+	static Default = effect(EventService, sync(() => {
+		const subscribers = /* @__PURE__ */ new Set();
+		const broadcast = (type, data) => gen(function* () {
+			const event = {
+				data,
+				timestamp: Date.now(),
+				type
+			};
+			for (const queue of subscribers) yield* offer(queue, event);
+		});
+		const subscribe = () => gen(function* () {
+			const queue = yield* sliding(100);
+			subscribers.add(queue);
+			return {
+				stream: fromQueue(queue),
+				unsubscribe: sync(() => {
+					subscribers.delete(queue);
+				}).pipe(andThen(shutdown(queue)))
+			};
+		});
+		const startFileWatcher = (repoPath) => acquireRelease(sync(() => {
+			let debounceTimer = null;
+			const watcher = chokidar_default.watch(repoPath, {
+				ignoreInitial: true,
+				ignored: [
+					"**/node_modules/**",
+					"**/.git/**",
+					"**/.ringi/**",
+					"**/dist/**"
+				],
+				persistent: true,
+				...platform() === "darwin" ? {
+					interval: 1e3,
+					usePolling: true
+				} : {}
+			});
+			const debouncedBroadcast = (filePath) => {
+				if (debounceTimer) clearTimeout(debounceTimer);
+				debounceTimer = setTimeout(() => {
+					runFork(broadcast("files", { path: relative(repoPath, filePath) }));
+				}, 300);
+			};
+			watcher.on("add", debouncedBroadcast);
+			watcher.on("change", debouncedBroadcast);
+			watcher.on("unlink", debouncedBroadcast);
+			return watcher;
+		}), (watcher) => promise(() => watcher.close()));
+		const getClientCount = () => sync(() => subscribers.size);
+		return EventService.of({
+			broadcast,
+			getClientCount,
+			startFileWatcher,
+			subscribe
+		});
+	}));
+};
+var ReviewError = class extends TaggedErrorClass()("ReviewError", {
+	code: String$1,
+	message: String$1
+}) {};
+var getHeadSha = (repoPath) => tryPromise({
+	catch: () => new ReviewError({
+		code: "GIT_ERROR",
+		message: "Failed to get HEAD"
+	}),
+	try: () => new Promise((resolve, reject) => {
+		execFile("git", ["rev-parse", "HEAD"], { cwd: repoPath }, (err, stdout) => {
+			if (err) reject(err);
+			else resolve(stdout.trim());
+		});
+	})
+});
+var parseSnapshotData = (s) => try_({
+	try: () => JSON.parse(s),
+	catch: () => ({})
+}).pipe(orElseSucceed(() => ({})));
+var ReviewService = class ReviewService extends Service()("@ringi/ReviewService") {
+	static Default = effect(ReviewService, gen(function* () {
+		const git = yield* GitService;
+		const repo = yield* ReviewRepo;
+		const fileRepo = yield* ReviewFileRepo;
+		const create = (input) => gen(function* () {
+			const repoPath = yield* git.getRepositoryPath;
+			if (!(yield* git.hasCommits)) return yield* new ReviewError({
+				code: "NO_COMMITS",
+				message: "Repository has no commits"
+			});
+			let diffText;
+			let baseRef = null;
+			const { sourceType, sourceRef } = input;
+			switch (sourceType) {
+				case "staged":
+					diffText = yield* git.getStagedDiff;
+					if (!diffText.trim()) return yield* new ReviewError({
+						code: "NO_STAGED_CHANGES",
+						message: "No staged changes"
+					});
+					baseRef = yield* getHeadSha(repoPath);
+					break;
+				case "branch":
+					if (!sourceRef) return yield* new ReviewError({
+						code: "INVALID_SOURCE",
+						message: "Branch name required"
+					});
+					diffText = yield* git.getBranchDiff(sourceRef);
+					baseRef = sourceRef;
+					break;
+				case "commits": {
+					if (!sourceRef) return yield* new ReviewError({
+						code: "INVALID_SOURCE",
+						message: "Commit SHAs required"
+					});
+					const shas = sourceRef.split(",").map((s) => s.trim()).filter(Boolean);
+					if (shas.length === 0) return yield* new ReviewError({
+						code: "INVALID_SOURCE",
+						message: "No valid commit SHAs"
+					});
+					diffText = yield* git.getCommitDiff(shas);
+					baseRef = shas.at(-1) ?? null;
+					break;
+				}
+				default: return yield* new ReviewError({
+					code: "INVALID_SOURCE",
+					message: "Unsupported review source"
+				});
+			}
+			const files = parseDiff(diffText);
+			if (files.length === 0) return yield* new ReviewError({
+				code: "NO_CHANGES",
+				message: "No changes found"
+			});
+			const repoInfo = yield* git.getRepositoryInfo;
+			const reviewId = crypto.randomUUID();
+			const storeHunks = sourceType === "staged";
+			const fileInputs = files.map((f) => ({
+				additions: f.additions,
+				deletions: f.deletions,
+				filePath: f.newPath,
+				hunksData: storeHunks ? serializeHunks(f.hunks) : null,
+				oldPath: f.oldPath !== f.newPath ? f.oldPath : null,
+				reviewId,
+				status: f.status
+			}));
+			const snapshotData = JSON.stringify({
+				repository: repoInfo,
+				version: 2
+			});
+			const review = yield* repo.create({
+				baseRef,
+				id: reviewId,
+				repositoryPath: repoPath,
+				snapshotData,
+				sourceRef: sourceRef ?? null,
+				sourceType,
+				status: "in_progress"
+			});
+			yield* fileRepo.createBulk(fileInputs);
+			return review;
+		});
+		const list = (opts) => gen(function* () {
+			const page = opts.page ?? 1;
+			const pageSize = opts.pageSize ?? 20;
+			const result = yield* repo.findAll({
+				page,
+				pageSize,
+				repositoryPath: opts.repositoryPath,
+				sourceType: opts.sourceType,
+				status: opts.status
+			});
+			const reviews = [];
+			for (const review of result.data) {
+				const fileCount = yield* fileRepo.countByReview(review.id);
+				const snapshot = yield* parseSnapshotData(review.snapshotData);
+				reviews.push({
+					...review,
+					fileCount,
+					repository: snapshot.repository ?? null
+				});
+			}
+			return {
+				hasMore: page * pageSize < result.total,
+				page,
+				pageSize,
+				reviews,
+				total: result.total
+			};
+		});
+		const getById = (id) => gen(function* () {
+			const review = yield* repo.findById(id);
+			if (!review) return yield* new ReviewNotFound({ id });
+			const files = (yield* fileRepo.findByReview(id)).map((r) => ({
+				additions: r.additions,
+				deletions: r.deletions,
+				filePath: r.file_path,
+				id: r.id,
+				oldPath: r.old_path,
+				status: r.status
+			}));
+			const snapshot = yield* parseSnapshotData(review.snapshotData);
+			const summary = getDiffSummary(files.map((f) => ({
+				additions: f.additions,
+				deletions: f.deletions,
+				hunks: [],
+				newPath: f.filePath,
+				oldPath: f.oldPath ?? f.filePath,
+				status: f.status
+			})));
+			return {
+				...review,
+				files,
+				repository: snapshot.repository ?? null,
+				summary
+			};
+		});
+		const getFileHunks = (reviewId, filePath) => gen(function* () {
+			const review = yield* repo.findById(reviewId);
+			if (!review) return yield* new ReviewNotFound({ id: reviewId });
+			const fileRecord = yield* fileRepo.findByReviewAndPath(reviewId, filePath);
+			if (fileRecord?.hunks_data) return yield* parseHunks(fileRecord.hunks_data);
+			if (review.sourceType === "branch" && review.sourceRef) return parseDiff(yield* git.getBranchDiff(review.sourceRef)).find((f) => f.newPath === filePath)?.hunks ?? [];
+			if (review.sourceType === "commits" && review.sourceRef) {
+				const shas = review.sourceRef.split(",").map((s) => s.trim());
+				return parseDiff(yield* git.getCommitDiff(shas)).find((f) => f.newPath === filePath)?.hunks ?? [];
+			}
+			const snapshot = yield* parseSnapshotData(review.snapshotData);
+			if (snapshot.files) return snapshot.files.find((f) => f.newPath === filePath)?.hunks ?? [];
+			return [];
+		});
+		const update = (id, input) => gen(function* () {
+			if (!(yield* repo.findById(id))) return yield* new ReviewNotFound({ id });
+			const status = input.status ? getOrNull(input.status) : null;
+			const review = yield* repo.update(id, status);
+			if (!review) return yield* new ReviewNotFound({ id });
+			return review;
+		});
+		const remove = (id) => gen(function* () {
+			if (!(yield* repo.findById(id))) return yield* new ReviewNotFound({ id });
+			yield* fileRepo.deleteByReview(id);
+			yield* repo.remove(id);
+			return { success: true };
+		});
+		const getStats = () => gen(function* () {
+			const total = yield* repo.countAll();
+			const inProgress = yield* repo.countByStatus("in_progress");
+			return {
+				approved: yield* repo.countByStatus("approved"),
+				changesRequested: yield* repo.countByStatus("changes_requested"),
+				inProgress,
+				total
+			};
+		});
+		return ReviewService.of({
+			create,
+			getById,
+			getFileHunks,
+			getStats,
+			list,
+			remove,
+			update
+		});
+	}));
+};
+var TodoService = class TodoService extends Service()("@ringi/TodoService") {
+	static Default = effect(TodoService, gen(function* () {
+		const repo = yield* TodoRepo;
+		const create = (input) => {
+			const id = randomUUID();
+			return repo.create({
+				content: input.content,
+				id,
+				reviewId: input.reviewId ?? null
+			});
+		};
+		const getById = (id) => gen(function* () {
+			const todo = yield* repo.findById(id);
+			if (!todo) return yield* new TodoNotFound({ id });
+			return todo;
+		});
+		const list = (opts = {}) => gen(function* () {
+			const result = yield* repo.findAll(opts);
+			return {
+				data: result.data,
+				limit: opts.limit ?? null,
+				offset: opts.offset ?? 0,
+				total: result.total
+			};
+		});
+		const update = (id, input) => gen(function* () {
+			if (!(yield* repo.findById(id))) return yield* new TodoNotFound({ id });
+			const updates = {};
+			if (input.content && isSome(input.content)) updates.content = input.content.value;
+			if (input.completed && isSome(input.completed)) updates.completed = input.completed.value;
+			const todo = yield* repo.update(id, updates);
+			if (!todo) return yield* new TodoNotFound({ id });
+			return todo;
+		});
+		const toggle = (id) => gen(function* () {
+			const todo = yield* repo.toggle(id);
+			if (!todo) return yield* new TodoNotFound({ id });
+			return todo;
+		});
+		const remove = (id) => gen(function* () {
+			if (!(yield* repo.findById(id))) return yield* new TodoNotFound({ id });
+			yield* repo.remove(id);
+			return { success: true };
+		});
+		const removeCompleted = () => gen(function* () {
+			return { deleted: yield* repo.removeCompleted() };
+		});
+		const reorder = (orderedIds) => gen(function* () {
+			return { updated: yield* repo.reorder(orderedIds) };
+		});
+		const move = (id, position) => gen(function* () {
+			const todo = yield* repo.move(id, position);
+			if (!todo) return yield* new TodoNotFound({ id });
+			return todo;
+		});
+		const getStats = () => gen(function* () {
+			const total = yield* repo.countAll();
+			return {
+				completed: yield* repo.countCompleted(),
+				pending: yield* repo.countPending(),
+				total
+			};
+		});
+		return TodoService.of({
+			create,
+			getById,
+			getStats,
+			list,
+			move,
+			remove,
+			removeCompleted,
+			reorder,
+			toggle,
+			update
+		});
+	}));
+};
+var ExportService = class ExportService extends Service()("@ringi/ExportService") {
+	static Default = effect(ExportService, gen(function* () {
+		const reviewSvc = yield* ReviewService;
+		const commentSvc = yield* CommentService;
+		const todoSvc = yield* TodoService;
+		const exportReview = (reviewId) => gen(function* () {
+			const review = yield* reviewSvc.getById(reviewId);
+			const repo = review.repository;
+			const repoName = repo?.name ?? "Unknown";
+			const branch = repo?.branch ?? "unknown";
+			const comments = yield* commentSvc.getByReview(reviewId);
+			const commentStats = yield* commentSvc.getStats(reviewId);
+			const todos = yield* todoSvc.list({ reviewId });
+			const lines = [];
+			lines.push(`# Code Review: ${repoName}`);
+			lines.push("");
+			lines.push(`**Status:** ${review.status}`);
+			lines.push(`**Branch:** ${branch}`);
+			lines.push(`**Created:** ${review.createdAt}`);
+			if (review.files && review.files.length > 0) {
+				lines.push("");
+				lines.push("## Files Changed");
+				lines.push("");
+				lines.push("| File | Status | Additions | Deletions |");
+				lines.push("|------|--------|-----------|-----------|");
+				for (const f of review.files) {
+					const statusLabel = f.status === "modified" ? "M" : f.status === "added" ? "A" : f.status === "deleted" ? "D" : f.status;
+					lines.push(`| ${f.filePath} | ${statusLabel} | +${f.additions} | -${f.deletions} |`);
+				}
+			}
+			if (comments.length > 0) {
+				lines.push("");
+				lines.push(`## Comments (${commentStats.total} total, ${commentStats.resolved} resolved)`);
+				const byFile = /* @__PURE__ */ new Map();
+				for (const c of comments) {
+					const key = c.filePath ?? "(general)";
+					const arr = byFile.get(key) ?? [];
+					arr.push(c);
+					byFile.set(key, arr);
+				}
+				for (const [filePath, fileComments] of byFile) {
+					lines.push("");
+					lines.push(`### ${filePath}`);
+					for (const c of fileComments) {
+						lines.push("");
+						lines.push(`**Line ${c.lineNumber ?? "–"}** (${c.lineType ?? "context"})`);
+						lines.push(`> ${c.content}`);
+						if (c.suggestion) {
+							lines.push("");
+							lines.push("```suggestion");
+							lines.push(c.suggestion);
+							lines.push("```");
+						}
+					}
+				}
+			}
+			if (todos.data.length > 0) {
+				const completed = todos.data.filter((t) => t.completed).length;
+				lines.push("");
+				lines.push("---");
+				lines.push("");
+				lines.push(`## Todos (${todos.total} total, ${completed} completed)`);
+				lines.push("");
+				for (const t of todos.data) {
+					const check = t.completed ? "x" : " ";
+					lines.push(`- [${check}] ${t.content}`);
+				}
+			}
+			lines.push("");
+			return lines.join("\n");
+		});
+		return ExportService.of({ exportReview });
+	}));
+};
+var GhNotInstalled = class extends TaggedErrorClass()("GhNotInstalled", { message: String$1 }) {};
+var GhAuthError = class extends TaggedErrorClass()("GhAuthError", {
+	host: String$1,
+	message: String$1
+}) {};
+var GhApiError = class extends TaggedErrorClass()("GhApiError", {
+	message: String$1,
+	statusCode: NullOr(Number$1)
+}) {};
+/** Max bytes to collect from gh output (50 MB — PR diffs can be large). */
+var MAX_STDOUT_BYTES = 50 * 1024 * 1024;
+var execGh = (args) => tryPromise({
+	catch: (error) => new GhApiError({
+		message: String(error),
+		statusCode: null
+	}),
+	try: () => new Promise((resolve, reject) => {
+		const child = spawn("gh", [...args], { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		const chunks = [];
+		let bytes = 0;
+		let truncated = false;
+		child.stdout.on("data", (chunk) => {
+			if (truncated) return;
+			bytes += chunk.length;
+			if (bytes > MAX_STDOUT_BYTES) {
+				truncated = true;
+				child.kill();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		let stderr = "";
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", (err) => {
+			reject(/* @__PURE__ */ new Error(`Failed to spawn gh: ${err.message}`));
+		});
+		child.on("close", (code) => {
+			if (truncated) {
+				resolve(Buffer.concat(chunks).toString("utf8"));
+				return;
+			}
+			if (code !== 0) reject(/* @__PURE__ */ new Error(`gh ${args[0]} exited with code ${code}: ${stderr}`));
+			else resolve(Buffer.concat(chunks).toString("utf8"));
+		});
+	})
+});
+/** PR metadata fields requested from gh in a single JSON call. */
+var PR_JSON_FIELDS = [
+	"additions",
+	"author",
+	"baseRefName",
+	"baseRefOid",
+	"body",
+	"changedFiles",
+	"createdAt",
+	"deletions",
+	"headRefName",
+	"headRefOid",
+	"headRepository",
+	"isDraft",
+	"mergeable",
+	"number",
+	"reviewDecision",
+	"state",
+	"title",
+	"updatedAt",
+	"url"
+].join(",");
+var GhService = class GhService extends Service()("@ringi/GhService") {
+	static Default = effect(GhService, gen(function* () {
+		const ensureInstalled = execGh(["version"]).pipe(asVoid, mapError(() => new GhNotInstalled({ message: "GitHub CLI (gh) not found. Install: https://cli.github.com" })), withSpan("GhService.ensureInstalled"));
+		const ensureAuthenticated = fn("GhService.ensureAuthenticated")(function* (host) {
+			yield* execGh([
+				"auth",
+				"status",
+				"--hostname",
+				host
+			]).pipe(asVoid, mapError(() => new GhAuthError({
+				host,
+				message: `Not authenticated to ${host}. Run: gh auth login --hostname ${host}`
+			})));
+		});
+		const fetchPrMetadata = fn("GhService.fetchPrMetadata")(function* (target) {
+			const json = yield* execGh([
+				"pr",
+				"view",
+				String(target.prNumber),
+				"--repo",
+				target.nwoRef,
+				"--json",
+				PR_JSON_FIELDS
+			]);
+			return yield* try_({
+				catch: () => new GhApiError({
+					message: "Failed to parse PR metadata JSON from gh output",
+					statusCode: null
+				}),
+				try: () => JSON.parse(json)
+			});
+		});
+		const fetchPrDiff = fn("GhService.fetchPrDiff")(function* (target) {
+			return yield* execGh([
+				"pr",
+				"diff",
+				String(target.prNumber),
+				"--repo",
+				target.nwoRef
+			]);
+		});
+		const fetchPrHeadOid = fn("GhService.fetchPrHeadOid")(function* (target) {
+			const json = yield* execGh([
+				"pr",
+				"view",
+				String(target.prNumber),
+				"--repo",
+				target.nwoRef,
+				"--json",
+				"headRefOid"
+			]);
+			return yield* try_({
+				catch: () => new GhApiError({
+					message: "Failed to parse head OID from gh output",
+					statusCode: null
+				}),
+				try: () => JSON.parse(json).headRefOid
+			});
+		});
+		return GhService.of({
+			ensureAuthenticated,
+			ensureInstalled,
+			fetchPrDiff,
+			fetchPrHeadOid,
+			fetchPrMetadata
+		});
+	}));
+};
+var RepoLive = mergeAll(ReviewRepo.Default, ReviewFileRepo.Default, CommentRepo.Default, TodoRepo.Default).pipe(provide(SqliteService.Default));
+var CommentServiceLive = CommentService.Default.pipe(provide(CommentRepo.Default), provide(SqliteService.Default));
+var TodoServiceLive = TodoService.Default.pipe(provide(TodoRepo.Default), provide(SqliteService.Default));
+var ReviewServiceLive = ReviewService.Default.pipe(provide(ReviewRepo.Default), provide(ReviewFileRepo.Default), provide(GitService.Default), provide(SqliteService.Default));
+var ExportServiceLive = ExportService.Default.pipe(provide(ReviewServiceLive), provide(CommentServiceLive), provide(TodoServiceLive));
+var CoreLive = mergeAll(ReviewServiceLive, CommentServiceLive, TodoServiceLive, GitService.Default, GhService.Default, EventService.Default, ExportServiceLive, RepoLive, SqliteService.Default);
+var createCoreRuntime = () => make(CoreLive);
+//#endregion
+export { GitService as a, createCoreRuntime as c, ExportService as i, getDiffSummary as l, CoreLive as n, ReviewService as o, EventService as r, TodoService as s, CommentService as t, parseDiff as u };