uigraph 0.0.1 → 1.0.1

package/dist/bin.mjs

@@ -0,0 +1,4583 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command, InvalidArgumentError, Option } from "@commander-js/extra-typings";
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+import { AGENT_LABELS, AGENT_NAMES, AgentError, AgentLimitError, agentTool, analyzeReview, fetchReview, fileIconPath, lensSettingsSchema, listRuns, readLocalReview, readRun, readSettings, runAgent, saveSettings } from "@uigraph/lens/agents";
+import { LogLevels, consola } from "consola";
+import { execFile, spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { inspect, promisify } from "node:util";
+import open from "open";
+import pc from "picocolors";
+import fs$1, { existsSync, readFileSync, readdirSync } from "node:fs";
+import { AstToUiConverter, DynamoEditorSchema, MongoEditorSchema, SqlToAstParser, contextSchema, convertDynamoSchemaToAst, convertMermaidToReactFlow, convertMermaidToReactFlowWithContext, convertMongoSchemaToAst, convertReactFlowToC4UiGraph, convertReactFlowToSequenceUiGraph, convertUiGraphToMermaid, isC4ReactFlowDiagram, isSequenceDiagram } from "@uigraph/sdk";
+import { GraphQLError, Kind, NoSchemaIntrospectionCustomRule, buildSchema, execute, getOperationAST, parse, print, specifiedRules, validate } from "graphql";
+import { createHash, randomUUID } from "node:crypto";
+import { glob } from "tinyglobby";
+import { isMap, isScalar, isSeq, parse as parse$1, parseDocument, stringify, visit } from "yaml";
+import { z } from "zod";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import http from "node:http";
+import { fileURLToPath } from "node:url";
+//#region src/artifacts/yaml-edit.ts
+function applyEdits(source, edits) {
+	return [...edits].sort((a, b) => b.start - a.start).reduce((text, edit) => text.slice(0, edit.start) + edit.text + text.slice(edit.end), source);
+}
+async function readYaml(root, file) {
+	const { realPath } = await resolveRepositoryFile(root, file);
+	const source = await fs.readFile(realPath, "utf8");
+	return {
+		source,
+		document: parseDocument(source)
+	};
+}
+function nodeRange(node, what) {
+	const range = node?.range;
+	if (range === void 0 || range === null) throw new Error(`Cannot locate ${what} in the YAML file`);
+	return range;
+}
+function column(source, position) {
+	return position - (source.lastIndexOf("\n", position - 1) + 1);
+}
+function lineStart(source, position) {
+	return source.lastIndexOf("\n", position - 1) + 1;
+}
+function renderBlock(value, indent) {
+	return stringify(value, { lineWidth: 0 }).trimEnd().split("\n").map((line, index) => index === 0 ? line : " ".repeat(indent) + line).join("\n");
+}
+function replaceScalar(node, value) {
+	if (!isScalar(node)) throw new Error(`Expected a YAML scalar to replace with "${value}"`);
+	const [start, end] = nodeRange(node, "a scalar");
+	return {
+		start,
+		end,
+		text: stringify(value, { lineWidth: 0 }).trimEnd()
+	};
+}
+function replaceItem(source, node, value) {
+	if (!isMap(node) || node.flow === true) throw new Error("Expected a block mapping in the YAML file");
+	const [start, end] = nodeRange(node, "an entry");
+	const trailingNewline = source[end - 1] === "\n" ? "\n" : "";
+	return {
+		start,
+		end,
+		text: renderBlock(value, column(source, start)) + trailingNewline
+	};
+}
+function setField(source, map, key, value) {
+	if (!isMap(map) || map.flow === true) throw new Error(`Expected a block mapping to set "${key}"`);
+	const existing = map.get(key, true);
+	if (isScalar(existing) && (typeof value === "string" || typeof value === "number")) return replaceScalar(existing, value);
+	if (existing !== void 0) throw new Error(`Cannot replace the "${key}" field in place`);
+	const first = map.items[0]?.key;
+	if (first === void 0) throw new Error(`Cannot add "${key}" to an empty mapping`);
+	const indent = column(source, nodeRange(first, "a key")[0]);
+	const end = nodeRange(map, "a mapping")[1];
+	return {
+		start: end,
+		end,
+		text: `${source[end - 1] === "\n" ? "" : "\n"}${" ".repeat(indent)}${renderBlock({ [key]: value }, indent)}\n`
+	};
+}
+function appendItem(source, document, path, value) {
+	const sequence = document.getIn(path, true);
+	if (isSeq(sequence) && sequence.flow !== true) {
+		const range = nodeRange(sequence, path.join("."));
+		const indent = column(source, range[0]);
+		const needsNewline = source[range[1] - 1] === "\n" ? "" : "\n";
+		return {
+			start: range[1],
+			end: range[1],
+			text: `${needsNewline}${" ".repeat(indent)}- ${renderBlock(value, indent + 2)}\n`
+		};
+	}
+	const key = path.at(-1);
+	if (typeof key !== "string") throw new Error(`Cannot add an item to ${path.join(".")}`);
+	const parent = path.length === 1 ? document.contents : document.getIn(path.slice(0, -1), true);
+	if (!isMap(parent) || parent.flow === true) throw new Error(`Cannot add an item to ${path.join(".")}`);
+	const pair = parent.items.find((item) => isScalar(item.key) && item.key.value === key);
+	if (pair !== void 0) {
+		if (!isSeq(pair.value) || pair.value.items.length > 0) throw new Error(`${path.join(".")} must be a list`);
+		const keyColumn = column(source, nodeRange(pair.key, key)[0]);
+		const [valueStart, end] = nodeRange(pair.value, key);
+		return {
+			start: source.lastIndexOf(":", valueStart) + 1,
+			end,
+			text: `\n${" ".repeat(keyColumn + 2)}- ${renderBlock(value, keyColumn + 4)}`
+		};
+	}
+	return setField(source, parent, key, [value]);
+}
+function removeItem(source, document, path, index) {
+	const sequence = document.getIn(path, true);
+	if (!isSeq(sequence) || sequence.flow === true) throw new Error(`${path.join(".")} must be a block list`);
+	const item = sequence.items[index];
+	if (item === void 0) throw new Error(`${path.join(".")} has no item ${index}`);
+	if (sequence.items.length > 1) {
+		const [start, , end] = nodeRange(item, "an item");
+		return {
+			start: lineStart(source, start),
+			end,
+			text: ""
+		};
+	}
+	const [start, , end] = nodeRange(sequence, path.join("."));
+	return {
+		start: source.lastIndexOf(":", start) + 1,
+		end,
+		text: " []\n"
+	};
+}
+function findItemIndex(document, path, name) {
+	const sequence = document.getIn(path, true);
+	if (!isSeq(sequence)) throw new Error(`${path.join(".")} must be a list`);
+	const index = sequence.items.findIndex((item) => isMap(item) && item.get("name") === name);
+	if (index === -1) throw new Error(`${path.join(".")} has no entry named "${name}"`);
+	return index;
+}
+//#endregion
+//#region src/artifacts/docs.ts
+const DOC_EXTENSIONS$1 = {
+	pdf: ".pdf",
+	html: ".html",
+	markdown: ".md",
+	txt: ".txt"
+};
+async function loadValid(root, configFile) {
+	const { db, errors } = await loadArtifacts(root, configFile);
+	if (errors.length > 0) throw new Error(`The .uigraph artifacts are invalid:\n${errors.join("\n")}`);
+	return db;
+}
+async function exists(file) {
+	return fs.lstat(file).then(() => true, (error) => {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	});
+}
+async function createDoc(root, configFile, file, input, data) {
+	const db = await loadValid(root, configFile);
+	if ([...db.docs, ...db.standaloneDocs].some((doc) => doc.file === file && doc.entry.name === input.name)) throw new Error(`Another doc in ${file} is named "${input.name}"`);
+	const extension = DOC_EXTENSIONS$1[input.fileType];
+	if (extension === void 0) throw new Error(`Unsupported doc type "${input.fileType}"`);
+	const base = slugify(input.name);
+	if (base === "") throw new Error("The doc name must contain a letter or digit");
+	let docPath = `.uigraph/docs/${base}${extension}`;
+	for (let suffix = 2; await exists(path.join(root, docPath)); suffix++) docPath = `.uigraph/docs/${base}-${suffix}${extension}`;
+	await writeArtifactFile(root, docPath, data);
+	const { source, document } = await readYaml(root, file);
+	await writeArtifactFile(root, file, applyEdits(source, [appendItem(source, document, ["docs"], {
+		name: input.name,
+		path: docPath,
+		fileType: input.fileType,
+		...input.description === "" ? {} : { description: input.description }
+	})]));
+	return docPath;
+}
+async function deleteDoc(root, configFile, file, name) {
+	const db = await loadValid(root, configFile);
+	const allDocs = [...db.docs, ...db.standaloneDocs];
+	const doc = allDocs.find((d) => d.file === file && d.entry.name === name);
+	if (doc === void 0) throw new Error(`No doc named "${name}" in ${file}`);
+	const { source, document } = await readYaml(root, file);
+	await writeArtifactFile(root, file, applyEdits(source, [removeItem(source, document, ["docs"], findItemIndex(document, ["docs"], name))]));
+	const stillUsed = allDocs.some((d) => d !== doc && d.entry.path === doc.entry.path);
+	if (isArtifactPath(doc.entry.path) && !stillUsed) await deleteArtifactFile(root, doc.entry.path);
+}
+//#endregion
+//#region src/artifacts/maps.ts
+const IMAGE_EXTENSIONS = {
+	"image/png": ".png",
+	"image/jpeg": ".jpg",
+	"image/webp": ".webp",
+	"image/gif": ".gif"
+};
+async function createMap(root, configFile, file, input) {
+	await loadValid(root, configFile);
+	const { source, document } = await readYaml(root, file);
+	await writeArtifactFile(root, file, applyEdits(source, [appendItem(source, document, ["maps"], {
+		name: input.name,
+		...input.description === "" ? {} : { description: input.description }
+	})]));
+}
+async function editMap(root, configFile, file, name, edit) {
+	await loadValid(root, configFile);
+	const { source, document } = await readYaml(root, file);
+	const index = findItemIndex(document, ["maps"], name);
+	const node = document.getIn(["maps", index], true);
+	if (!isMap(node)) throw new Error(`maps[${name}] must be a mapping`);
+	const next = edit(node.toJSON());
+	await writeArtifactFile(root, file, applyEdits(source, [next === null ? removeItem(source, document, ["maps"], index) : replaceItem(source, node, next)]));
+}
+async function editCanvas(root, edit) {
+	const present = await exists(path.join(root, CANVAS_FILE));
+	let canvas = {};
+	if (present) {
+		const { realPath } = await resolveRepositoryFile(root, CANVAS_FILE);
+		canvas = canvasFileSchema.parse(JSON.parse(await fs.readFile(realPath, "utf8")));
+	}
+	const before = JSON.stringify(canvas);
+	edit(canvas);
+	if (JSON.stringify(canvas) === before) return;
+	if (Object.keys(canvas).length === 0) {
+		if (present) await deleteArtifactFile(root, CANVAS_FILE);
+		return;
+	}
+	await writeArtifactFile(root, CANVAS_FILE, `${JSON.stringify(canvas, null, 2)}\n`);
+}
+async function retargetLinks(root, from, to) {
+	await editCanvas(root, (canvas) => {
+		for (const mapCanvas of Object.values(canvas)) for (const frameCanvas of Object.values(mapCanvas.frames ?? {})) {
+			if (frameCanvas.links === void 0) continue;
+			frameCanvas.links = frameCanvas.links.flatMap((link) => {
+				if (!(link.map === from.map && (from.frame === void 0 || link.frame === from.frame))) return [link];
+				if (to === null) return [];
+				return [{
+					...link,
+					map: to.map,
+					...from.frame === void 0 ? {} : { frame: to.frame }
+				}];
+			});
+		}
+	});
+}
+async function writeFrameImage(root, mapName, frameName, upload) {
+	const extension = IMAGE_EXTENSIONS[upload.contentType];
+	if (extension === void 0) throw new Error("Frame images must be PNG, JPEG, WebP or GIF files");
+	const directory = `.uigraph/maps/${slugify(mapName)}`;
+	const base = slugify(frameName);
+	let imagePath = `${directory}/${base}${extension}`;
+	for (let suffix = 2; await exists(path.join(root, imagePath)); suffix++) imagePath = `${directory}/${base}-${suffix}${extension}`;
+	await writeArtifactFile(root, imagePath, upload.data);
+	return imagePath;
+}
+async function deleteUnusedImages(root, configFile, imagePaths) {
+	const db = await loadValid(root, configFile);
+	const used = new Set(db.maps.flatMap((map) => map.frames.flatMap(({ frame }) => frame.screenshotAssetId ?? [])));
+	for (const imagePath of imagePaths) if (isArtifactPath(imagePath) && !used.has(imagePath)) await deleteArtifactFile(root, imagePath);
+}
+//#endregion
+//#region src/artifacts/diagram-images.ts
+const DIAGRAM_IMAGE_EXTENSIONS = {
+	...IMAGE_EXTENSIONS,
+	"image/svg+xml": ".svg"
+};
+function imageDirectory(diagramPath) {
+	return `${path.posix.dirname(diagramPath)}/images`;
+}
+async function listDiagramImages(root, diagramPath) {
+	const directory = imageDirectory(diagramPath);
+	const entries = await fs.readdir(path.join(root, directory), { withFileTypes: true }).catch((error) => {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	});
+	const extensions = new Set(Object.values(DIAGRAM_IMAGE_EXTENSIONS));
+	const images = [];
+	for (const entry of entries) if (entry.isFile() && extensions.has(path.extname(entry.name).toLowerCase())) {
+		const imagePath = `${directory}/${entry.name}`;
+		const stat = await fs.stat(path.join(root, imagePath));
+		images.push({
+			imagePath,
+			createdAt: stat.birthtime.toISOString()
+		});
+	}
+	return images.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+async function writeDiagramImage(root, diagramPath, fileName, upload) {
+	const extension = DIAGRAM_IMAGE_EXTENSIONS[upload.contentType];
+	if (extension === void 0) throw new Error("Diagram images must be PNG, JPEG, WebP, GIF or SVG files");
+	const directory = imageDirectory(diagramPath);
+	const base = slugify(path.parse(fileName).name);
+	if (base === "") throw new Error("The image file name must contain a letter or digit");
+	let imagePath = `${directory}/${base}${extension}`;
+	for (let suffix = 2; await exists(path.join(root, imagePath)); suffix++) imagePath = `${directory}/${base}-${suffix}${extension}`;
+	await writeArtifactFile(root, imagePath, upload.data);
+	return imagePath;
+}
+//#endregion
+//#region src/artifacts/write.ts
+const MAX_WRITE_BYTES = 2e6;
+const MAX_UPLOAD_BYTES = 5e7;
+function isArtifactPath(relativePath) {
+	return relativePath === ".uigraph.yaml" || relativePath.startsWith(".uigraph/");
+}
+function toArtifactPath(requested) {
+	const relativePath = path.posix.normalize(requested.replaceAll("\\", "/")).replace(/^\.\//, "");
+	if (path.posix.isAbsolute(relativePath) || relativePath.split("/").includes("..")) throw new Error(`Path must be relative to the repository: ${requested}`);
+	if (!isArtifactPath(relativePath) || relativePath.endsWith("/")) throw new Error(`Only ${ROOT_CONFIG} and files under .uigraph/ can be written: ${requested}`);
+	return relativePath;
+}
+async function deleteArtifactFile(root, requested) {
+	const relativePath = toArtifactPath(requested);
+	let current = root;
+	for (const segment of relativePath.split("/")) {
+		current = path.join(current, segment);
+		if ((await fs.lstat(current)).isSymbolicLink()) throw new Error(`Refusing to delete through a symbolic link: ${relativePath}`);
+	}
+	await fs.rm(current);
+	const artifactRoot = path.join(root, ".uigraph");
+	for (let directory = path.dirname(current); directory.startsWith(`${artifactRoot}${path.sep}`); directory = path.dirname(directory)) {
+		if ((await fs.readdir(directory)).length > 0) return;
+		await fs.rmdir(directory);
+	}
+}
+async function writeArtifactFile(root, requested, content) {
+	const relativePath = toArtifactPath(requested);
+	const limit = typeof content === "string" ? MAX_WRITE_BYTES : MAX_UPLOAD_BYTES;
+	if (Buffer.byteLength(content) > limit) throw new Error(`Content is larger than ${limit} bytes`);
+	const segments = relativePath.split("/");
+	let current = root;
+	for (const [index, segment] of segments.entries()) {
+		current = path.join(current, segment);
+		const isLast = index === segments.length - 1;
+		const stat = await fs.lstat(current).catch((error) => {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		});
+		if (stat === null) {
+			if (!isLast) await fs.mkdir(current);
+			continue;
+		}
+		if (stat.isSymbolicLink()) throw new Error(`Refusing to write through a symbolic link: ${relativePath}`);
+		if (!isLast && !stat.isDirectory()) throw new Error(`Not a directory: ${segments.slice(0, index + 1).join("/")}`);
+		if (isLast && !stat.isFile()) throw new Error(`Not a file: ${relativePath}`);
+	}
+	const temporary = path.join(path.dirname(current), `.${path.basename(current)}.${randomUUID()}.tmp`);
+	await fs.writeFile(temporary, content, { flag: "wx" });
+	await fs.rename(temporary, current);
+	return relativePath;
+}
+function exportDiagram(nodes, edges) {
+	if (isC4ReactFlowDiagram(nodes)) return convertReactFlowToC4UiGraph(nodes, edges);
+	if (isSequenceDiagram(nodes)) return convertReactFlowToSequenceUiGraph(nodes, edges);
+	return convertUiGraphToMermaid({
+		nodes,
+		edges
+	});
+}
+async function saveDiagram(root, configFile, diagramId, input) {
+	const { db, errors } = await loadArtifacts(root, configFile);
+	if (errors.length > 0) throw new Error(`The .uigraph artifacts are invalid:\n${errors.join("\n")}`);
+	const diagram = db.diagrams.find((d) => d.entity.id === diagramId);
+	if (diagram === void 0) throw new Error(`Diagram ${diagramId} not found`);
+	const name = input.name === void 0 || input.name === null || input.name.trim() === "" ? diagram.entry.name : input.name.trim();
+	if (db.diagrams.some((d) => d.file === diagram.file && d.entity.id !== diagramId && d.entry.name === name)) throw new Error(`Another diagram in ${diagram.file} is named "${name}"`);
+	let contextPath = diagram.entry.contextPath;
+	if (input.content !== void 0 && input.content !== null) {
+		const parsed = JSON.parse(input.content);
+		if (!Array.isArray(parsed.nodes) || !Array.isArray(parsed.edges)) throw new Error("Diagram content must have nodes and edges arrays");
+		const next = exportDiagram(parsed.nodes, parsed.edges);
+		const previous = exportDiagram(diagram.flow.nodes, diagram.flow.edges);
+		if (JSON.stringify(next) !== JSON.stringify(previous)) {
+			contextPath ??= path.posix.join(path.posix.dirname(diagram.entry.path), "context.json");
+			await writeArtifactFile(root, diagram.entry.path, next.mermaid);
+			await writeArtifactFile(root, contextPath, `${JSON.stringify(next.context, null, 2)}\n`);
+		}
+	}
+	if (name !== diagram.entry.name || contextPath !== diagram.entry.contextPath) {
+		const { source, document } = await readYaml(root, diagram.file);
+		const entry = document.getIn(["architectureDiagrams", diagram.index], true);
+		if (!isMap(entry) || entry.flow === true) throw new Error(`${diagram.file}: architectureDiagrams[${diagram.index}] must be a block mapping`);
+		const edits = [];
+		if (name !== diagram.entry.name) edits.push(replaceScalar(entry.get("name", true), name));
+		if (contextPath !== diagram.entry.contextPath) {
+			const pathPair = entry.items.find((pair) => isScalar(pair.key) && pair.key.value === "path");
+			const key = pathPair?.key;
+			const value = pathPair?.value;
+			if (!key?.range || !value?.range) throw new Error(`${diagram.file}: architectureDiagrams[${diagram.index}] has no path`);
+			const indent = key.range[0] - source.lastIndexOf("\n", key.range[0]) - 1;
+			edits.push({
+				start: value.range[1],
+				end: value.range[1],
+				text: `\n${" ".repeat(indent)}contextPath: ${stringify(contextPath, { lineWidth: 0 }).trimEnd()}`
+			});
+		}
+		await writeArtifactFile(root, diagram.file, applyEdits(source, edits));
+	}
+	const mermaid = await fs.readFile(path.join(root, diagram.entry.path), "utf8");
+	const context = contextPath === void 0 ? "" : await fs.readFile(path.join(root, contextPath), "utf8");
+	return {
+		id: diagramId,
+		name,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		contentHash: contentHash(mermaid, context)
+	};
+}
+async function createDiagram(root, configFile, file, name) {
+	const { db, errors } = await loadArtifacts(root, configFile);
+	if (errors.length > 0) throw new Error(`The .uigraph artifacts are invalid:\n${errors.join("\n")}`);
+	if (db.diagrams.some((d) => d.file === file && d.entry.name === name)) throw new Error(`Another diagram in ${file} is named "${name}"`);
+	const base = slugify(name);
+	if (base === "") throw new Error("The diagram name must contain a letter or digit");
+	let folder = base;
+	for (let suffix = 2; db.diagrams.some((d) => d.entity.id === folder) || await fs.lstat(path.join(root, ".uigraph/diagrams", folder)).then(() => true, (error) => {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}); suffix++) folder = `${base}-${suffix}`;
+	const entry = {
+		name,
+		path: `.uigraph/diagrams/${folder}/${folder}.mmd`,
+		contextPath: `.uigraph/diagrams/${folder}/context.json`
+	};
+	const empty = convertUiGraphToMermaid({
+		nodes: [],
+		edges: []
+	});
+	await writeArtifactFile(root, entry.path, empty.mermaid);
+	await writeArtifactFile(root, entry.contextPath, `${JSON.stringify(empty.context, null, 2)}\n`);
+	const { source, document } = await readYaml(root, file);
+	await writeArtifactFile(root, file, applyEdits(source, [appendItem(source, document, ["architectureDiagrams"], entry)]));
+	return folder;
+}
+async function deleteDiagram(root, configFile, diagramId) {
+	const { db, errors } = await loadArtifacts(root, configFile);
+	if (errors.length > 0) throw new Error(`The .uigraph artifacts are invalid:\n${errors.join("\n")}`);
+	const diagram = db.diagrams.find((d) => d.entity.id === diagramId);
+	if (diagram === void 0) throw new Error(`Diagram ${diagramId} not found`);
+	const images = await listDiagramImages(root, diagram.entry.path);
+	const { source, document } = await readYaml(root, diagram.file);
+	await writeArtifactFile(root, diagram.file, applyEdits(source, [removeItem(source, document, ["architectureDiagrams"], diagram.index)]));
+	for (const file of [
+		diagram.entry.path,
+		diagram.entry.contextPath,
+		...images.map((image) => image.imagePath)
+	]) if (file !== void 0 && isArtifactPath(file)) await deleteArtifactFile(root, file);
+}
+async function renameDiagramReferences(root, files, serviceName, oldName, newName) {
+	for (const file of files) {
+		const { source, document } = await readYaml(root, file);
+		const edits = [];
+		visit(document, { Map(_, map) {
+			if (map.get("serviceName") === serviceName && map.get("architectureDiagramName") === oldName) edits.push(replaceScalar(map.get("architectureDiagramName", true), newName));
+		} });
+		if (edits.length > 0) await writeArtifactFile(root, file, applyEdits(source, edits));
+	}
+}
+const diagramCandidateSchema = z.object({
+	id: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use a kebab-case id").max(48).describe("Kebab-case id. It becomes the diagram directory name under .uigraph/diagrams/."),
+	name: z.string().min(1).max(60).describe("Plain display name that says what the diagram shows"),
+	type: z.enum([
+		"flowchart",
+		"sequenceDiagram",
+		"stateDiagram-v2",
+		"C4Container",
+		"C4Component"
+	]).describe("Mermaid diagram type"),
+	summary: z.string().min(1).max(160).describe("One line saying what the diagram shows"),
+	evidence: z.array(z.string().min(1)).min(1).max(4).describe("Repository-relative files that prove this flow or structure exists"),
+	recommended: z.boolean().describe("Pre-selected for the owner")
+});
+const docCandidateSchema = z.object({
+	path: z.string().min(1).describe("Repository-relative path of an existing Markdown or HTML document"),
+	name: z.string().min(1).max(60).describe("Plain display name, such as \"Deployment guide\""),
+	summary: z.string().min(1).max(160).describe("One line saying what the document covers")
+});
+function findPlanProblems(diagrams) {
+	const problems = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const { id } of diagrams) {
+		if (seen.has(id)) problems.push(`Duplicate id: ${id}`);
+		seen.add(id);
+	}
+	const recommended = diagrams.filter((diagram) => diagram.recommended).length;
+	if (recommended < 1 || recommended > 8) problems.push(`Mark between 1 and 8 diagrams as recommended (found ${recommended})`);
+	return problems;
+}
+function formatApprovedDiagrams(selection, existing) {
+	const lines = [];
+	if (selection.diagrams.length === 0) lines.push("The owner approved no new architecture diagrams. Do not generate any new architecture diagram.");
+	else {
+		lines.push("Approved diagrams. Generate exactly these under architectureDiagrams, each at .uigraph/diagrams/<id>/<id>.mmd with a context.json, using the listed Mermaid type. Do not generate any other new diagram:");
+		for (const diagram of selection.diagrams) lines.push(`- ${diagram.id} | ${diagram.name} | ${diagram.type} | ${diagram.summary} | evidence: ${diagram.evidence.join(", ")}`);
+	}
+	if (selection.docs.length > 0) {
+		lines.push("Approved existing documents. Add each one under docs with the listed name and its current path, and set fileType to markdown or html. Do not copy, move, or rewrite these files. This replaces the rule in references/docs.md that existing repository documents are never doc artifacts:");
+		for (const doc of selection.docs) lines.push(`- ${doc.path} | ${doc.name} | ${doc.summary}`);
+	}
+	if (existing.length > 0) lines.push(`Diagrams already in the repository (keep them and update them when the code changed): ${existing.join(", ")}.`);
+	if (selection.focus !== null) lines.push(`The owner asked you to focus on: "${selection.focus}". If this names a flow the code shows, add one diagram for it. If the code does not show it, leave it out and say so in your summary. Never invent a flow.`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/analysis/repo-access.ts
+const EXCLUDED_DIRECTORIES = [
+	".git",
+	"node_modules",
+	"dist",
+	"build",
+	"out",
+	".next",
+	".nuxt",
+	".turbo",
+	".cache",
+	"coverage",
+	"target",
+	"vendor",
+	".venv",
+	"venv",
+	"__pycache__",
+	".terraform",
+	".claude"
+];
+const SECRET_FILE_PATTERNS = [
+	/^\.env(\..+)?$/,
+	/\.(pem|key|p12|pfx|jks|keystore|crt|cer|der)$/,
+	/^id_(rsa|dsa|ecdsa|ed25519)/,
+	/^credentials/,
+	/^secrets?\./,
+	/^\.npmrc$/,
+	/^\.netrc$/,
+	/^\.pypirc$/,
+	/\.tfstate(\.backup)?$/
+];
+const ALLOWED_ENV_FILES = [
+	".env.example",
+	".env.sample",
+	".env.template"
+];
+const IGNORE_GLOBS = EXCLUDED_DIRECTORIES.map((dir) => `**/${dir}/**`);
+const MAX_READ_BYTES = 2e5;
+const MAX_READ_LINES = 2e3;
+const MAX_LIST_RESULTS = 2e3;
+const MAX_SEARCH_MATCHES = 200;
+const MAX_SEARCH_FILE_BYTES = 1e6;
+function isExcludedPath(relativePath) {
+	const segments = relativePath.split("/");
+	if (segments.some((segment) => EXCLUDED_DIRECTORIES.includes(segment))) return true;
+	const fileName = segments[segments.length - 1];
+	if (ALLOWED_ENV_FILES.includes(fileName)) return false;
+	return SECRET_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
+}
+async function resolveRepositoryFile(root, requested) {
+	const normalized = path.posix.normalize(requested.replaceAll("\\", "/"));
+	if (normalized === ".." || normalized.startsWith("../") || path.isAbsolute(normalized)) throw new Error(`Path must be relative to the repository: ${requested}`);
+	const relativePath = normalized.replace(/^\.\//, "");
+	if (isExcludedPath(relativePath)) throw new Error(`Path is excluded from analysis: ${relativePath}`);
+	const absolutePath = path.join(root, relativePath);
+	const realPath = await fs.realpath(absolutePath);
+	if (realPath !== root && !realPath.startsWith(root + path.sep)) throw new Error(`Path resolves outside the repository: ${relativePath}`);
+	return {
+		relativePath,
+		realPath,
+		stat: await fs.stat(realPath)
+	};
+}
+async function listRepositoryFiles(root, pattern) {
+	const files = await glob(pattern, {
+		cwd: root,
+		ignore: IGNORE_GLOBS,
+		dot: true,
+		followSymbolicLinks: false,
+		onlyFiles: true
+	});
+	const allowed = [];
+	for (const file of files.sort()) {
+		if (isExcludedPath(file)) continue;
+		if ((await fs.lstat(path.join(root, file))).isSymbolicLink()) continue;
+		allowed.push(file);
+	}
+	return allowed;
+}
+function isBinary(buffer) {
+	return buffer.subarray(0, 8e3).includes(0);
+}
+function textResult(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function errorResult(error) {
+	return {
+		content: [{
+			type: "text",
+			text: error instanceof Error ? error.message : String(error)
+		}],
+		isError: true
+	};
+}
+function createRepositoryTools(root, skill, onToolUse, plan) {
+	const onSubmit = plan?.onSubmit;
+	const listFiles = agentTool("list_files", "List repository files matching a glob pattern. Generated directories and secret files are never listed.", { pattern: z.string().default("**/*").describe("Glob relative to the repository root, e.g. src/**/*.ts") }, async ({ pattern }) => {
+		onToolUse({
+			tool: "list_files",
+			pattern
+		});
+		try {
+			const files = await listRepositoryFiles(root, pattern);
+			const shown = files.slice(0, MAX_LIST_RESULTS);
+			const more = files.length > shown.length ? `\n… ${files.length - shown.length} more files; narrow the pattern` : "";
+			return textResult(shown.length === 0 ? "No files matched." : shown.join("\n") + more);
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
+	const readFile = agentTool("read_file", "Read a repository text file. Lines are prefixed with their line numbers.", {
+		path: z.string().describe("Repository-relative file path"),
+		offset: z.number().int().min(1).default(1).describe("First line to read, 1-based"),
+		limit: z.number().int().min(1).max(MAX_READ_LINES).default(MAX_READ_LINES).describe("Maximum number of lines to read")
+	}, async ({ path: requested, offset, limit }) => {
+		onToolUse({
+			tool: "read_file",
+			path: requested
+		});
+		try {
+			const { realPath, stat } = await resolveRepositoryFile(root, requested);
+			if (!stat.isFile()) return errorResult(`Not a file: ${requested}`);
+			const handle = await fs.open(realPath, "r");
+			const buffer = Buffer.alloc(Math.min(stat.size, MAX_READ_BYTES));
+			await handle.read(buffer, 0, buffer.length, 0);
+			await handle.close();
+			if (isBinary(buffer)) return errorResult(`Binary file skipped: ${requested}`);
+			return textResult(buffer.toString("utf8").split("\n").slice(offset - 1, offset - 1 + limit).map((line, index) => `${offset + index}\t${line}`).join("\n") + (stat.size > MAX_READ_BYTES ? `\n… file truncated at ${MAX_READ_BYTES} bytes` : ""));
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
+	const search = agentTool("search", "Search repository text files with a JavaScript regular expression. Returns path:line: text matches.", {
+		pattern: z.string().describe("JavaScript regular expression"),
+		glob: z.string().default("**/*").describe("Glob limiting which files are searched"),
+		caseInsensitive: z.boolean().default(false)
+	}, async ({ pattern, glob: fileGlob, caseInsensitive }) => {
+		onToolUse({
+			tool: "search",
+			pattern,
+			glob: fileGlob
+		});
+		try {
+			const regex = new RegExp(pattern, caseInsensitive ? "i" : "");
+			const files = await listRepositoryFiles(root, fileGlob);
+			const matches = [];
+			for (const file of files) {
+				const absolutePath = path.join(root, file);
+				if ((await fs.stat(absolutePath)).size > MAX_SEARCH_FILE_BYTES) continue;
+				const buffer = await fs.readFile(absolutePath);
+				if (isBinary(buffer)) continue;
+				const lines = buffer.toString("utf8").split("\n");
+				for (let index = 0; index < lines.length; index++) {
+					if (regex.test(lines[index])) matches.push(`${file}:${index + 1}: ${lines[index].trim().slice(0, 300)}`);
+					if (matches.length >= MAX_SEARCH_MATCHES) break;
+				}
+				if (matches.length >= MAX_SEARCH_MATCHES) {
+					matches.push(`… stopped at ${MAX_SEARCH_MATCHES} matches`);
+					break;
+				}
+			}
+			return textResult(matches.length === 0 ? "No matches." : matches.join("\n"));
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
+	const writeFile = agentTool("write_file", "Create or replace a UIGraph artifact. Only .uigraph.yaml and files under .uigraph/ can be written.", {
+		path: z.string().describe("Repository-relative path: .uigraph.yaml or .uigraph/..."),
+		content: z.string().describe("Complete file content")
+	}, async ({ path: requested, content }) => {
+		onToolUse({
+			tool: "write_file",
+			path: requested
+		});
+		try {
+			return textResult(`Wrote ${await writeArtifactFile(root, requested, content)}`);
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
+	const validateArtifacts = agentTool("validate_artifacts", "Load .uigraph.yaml and every artifact it references the way the UIGraph viewer does, and list every problem found.", {}, async () => {
+		onToolUse({ tool: "validate_artifacts" });
+		const { errors } = await loadArtifacts(root);
+		return textResult(errors.length === 0 ? "All artifacts are valid." : errors.map((error) => `- ${error}`).join("\n"));
+	});
+	const readSkillFile = agentTool("read_skill_file", "Read a file from the UIGraph skill, e.g. references/uigraph-yaml-schema.md or assets/templates/context-example.json.", { path: z.string().describe("Path relative to the skill directory") }, async ({ path: requested }) => {
+		onToolUse({
+			tool: "read_skill_file",
+			path: requested
+		});
+		const content = skill.get(path.posix.normalize(requested.replaceAll("\\", "/")).replace(/^\.\//, ""));
+		if (content === void 0) return errorResult(`The skill has no file ${requested}`);
+		return textResult(content);
+	});
+	function createSubmitPlanTool(submit) {
+		return agentTool("submit_diagram_plan", "Submit the architecture diagrams worth generating and the existing documents worth adding for this repository. Call it exactly once, when you finish exploring.", {
+			diagrams: z.array(diagramCandidateSchema).min(1).max(15),
+			docs: z.array(docCandidateSchema).max(10)
+		}, async ({ diagrams, docs }) => {
+			onToolUse({
+				tool: "submit_diagram_plan",
+				count: diagrams.length
+			});
+			try {
+				const problems = findPlanProblems(diagrams);
+				for (const diagram of diagrams) for (const file of diagram.evidence) try {
+					const { stat } = await resolveRepositoryFile(root, file);
+					if (!stat.isFile()) problems.push(`${diagram.id}: evidence is not a file: ${file}`);
+				} catch {
+					problems.push(`${diagram.id}: evidence file not found: ${file}`);
+				}
+				for (const doc of docs) {
+					if (!/\.(md|markdown|html?)$/i.test(doc.path)) {
+						problems.push(`${doc.path}: not a Markdown or HTML document`);
+						continue;
+					}
+					try {
+						const { stat } = await resolveRepositoryFile(root, doc.path);
+						if (!stat.isFile()) problems.push(`${doc.path}: document is not a file`);
+					} catch {
+						problems.push(`${doc.path}: document not found`);
+					}
+				}
+				if (problems.length > 0) return errorResult(`The plan was not accepted. Fix these and submit again:\n${problems.map((problem) => `- ${problem}`).join("\n")}`);
+				submit({
+					diagrams,
+					docs
+				});
+				return textResult("Plan received. Stop here.");
+			} catch (error) {
+				return errorResult(error);
+			}
+		});
+	}
+	return onSubmit === void 0 ? [
+		listFiles,
+		readFile,
+		search,
+		writeFile,
+		validateArtifacts,
+		readSkillFile
+	] : [
+		listFiles,
+		readFile,
+		search,
+		readSkillFile,
+		createSubmitPlanTool(onSubmit)
+	];
+}
+//#endregion
+//#region src/artifacts/load.ts
+const ROOT_CONFIG = ".uigraph.yaml";
+const ORG_ID = "local";
+const ACTOR_ID = "uigraph";
+const MAX_FILE_BYTES = 2e6;
+const HTTP_METHODS = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"patch",
+	"options",
+	"head",
+	"trace"
+];
+const DOC_FILE_TYPES = [
+	"pdf",
+	"html",
+	"markdown",
+	"doc",
+	"txt",
+	"image",
+	"video",
+	"audio",
+	"other"
+];
+const DOC_EXTENSIONS = {
+	".pdf": "pdf",
+	".html": "html",
+	".htm": "html",
+	".md": "markdown",
+	".markdown": "markdown",
+	".doc": "doc",
+	".docx": "doc",
+	".txt": "txt",
+	".png": "image",
+	".jpg": "image",
+	".jpeg": "image",
+	".gif": "image",
+	".webp": "image",
+	".svg": "image",
+	".mp4": "video",
+	".mov": "video",
+	".webm": "video",
+	".mp3": "audio",
+	".wav": "audio",
+	".ogg": "audio",
+	".m4a": "audio"
+};
+const DATABASE_DIALECTS = [
+	"postgres",
+	"mysql",
+	"sqlite",
+	"other",
+	"dynamodb",
+	"mongodb"
+];
+const queryEntrySchema = z.looseObject({
+	name: z.string().min(1),
+	database: z.string().min(1),
+	path: z.string().min(1).optional(),
+	queryText: z.string().min(1).optional(),
+	description: z.string().optional(),
+	tags: z.array(z.string()).optional()
+});
+const queryFileSchema = z.looseObject({ queries: z.array(queryEntrySchema).default([]) });
+const componentRefSchema = z.looseObject({
+	componentId: z.string().min(1),
+	componentLinkId: z.string().optional(),
+	serviceName: z.string().optional(),
+	apiGroupName: z.string().optional(),
+	operationId: z.string().optional(),
+	testPackName: z.string().optional(),
+	docName: z.string().optional(),
+	architectureDiagramName: z.string().optional(),
+	modalFields: z.array(z.looseObject({
+		componentFieldId: z.string(),
+		label: z.string().optional(),
+		type: z.string().optional(),
+		data: z.array(z.unknown()).optional()
+	})).optional()
+});
+const mapSchema = z.looseObject({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	frames: z.array(z.looseObject({
+		name: z.string().min(1),
+		description: z.string().optional(),
+		imagePath: z.string().min(1).optional(),
+		focalPoints: z.array(z.looseObject({
+			name: z.string().min(1),
+			x: z.number(),
+			y: z.number(),
+			visibility: z.string().optional(),
+			color: z.string().optional(),
+			components: z.array(componentRefSchema).optional()
+		})).optional()
+	})).optional()
+});
+const CANVAS_FILE = ".uigraph/maps/canvas.json";
+const canvasPointSchema = z.object({
+	x: z.number(),
+	y: z.number()
+});
+const canvasFileSchema = z.record(z.string(), z.object({
+	zoom: z.number().optional(),
+	navigationX: z.number().optional(),
+	navigationY: z.number().optional(),
+	framePositions: z.record(z.string(), canvasPointSchema).optional(),
+	frames: z.record(z.string(), z.object({
+		groups: z.array(canvasPointSchema.extend({
+			name: z.string(),
+			description: z.string(),
+			width: z.number(),
+			height: z.number()
+		})).optional(),
+		links: z.array(canvasPointSchema.extend({
+			kind: z.enum(["frame", "map"]),
+			map: z.string(),
+			frame: z.string().optional(),
+			label: z.string()
+		})).optional()
+	})).optional()
+}));
+const configSchema = z.looseObject({
+	version: z.literal(1),
+	service: z.looseObject({
+		name: z.string().min(1),
+		category: z.string().min(1),
+		description: z.string().min(1),
+		repository: z.looseObject({
+			provider: z.string(),
+			url: z.string()
+		}).optional(),
+		ownership: z.looseObject({ team: z.string().min(1) }).optional(),
+		labels: z.array(z.string()).optional(),
+		integrations: z.looseObject({
+			slack: z.looseObject({ url: z.string() }).optional(),
+			jira: z.looseObject({ url: z.string() }).optional()
+		}).optional()
+	}).optional(),
+	apis: z.array(z.looseObject({
+		name: z.string().min(1),
+		type: z.enum([
+			"openapi",
+			"graphql",
+			"grpc"
+		]),
+		path: z.string().min(1)
+	})).default([]),
+	dependencies: z.array(z.looseObject({
+		name: z.string().min(1),
+		service: z.string().min(1),
+		direction: z.enum(["upstream", "downstream"]),
+		criticality: z.enum(["hard", "soft"]),
+		type: z.enum([
+			"http",
+			"graphql",
+			"grpc",
+			"database"
+		]).optional(),
+		description: z.string().optional(),
+		apiGroupName: z.string().optional(),
+		apiEndpointNames: z.array(z.string().min(1)).optional(),
+		databaseName: z.string().optional()
+	})).default([]),
+	architectureDiagrams: z.array(z.looseObject({
+		name: z.string().min(1),
+		path: z.string().min(1),
+		contextPath: z.string().min(1).optional()
+	})).default([]),
+	docs: z.array(z.looseObject({
+		name: z.string().min(1),
+		path: z.string().min(1),
+		fileType: z.enum(DOC_FILE_TYPES).optional(),
+		description: z.string().optional()
+	})).default([]),
+	databases: z.array(z.looseObject({
+		name: z.string().min(1),
+		dialect: z.enum(DATABASE_DIALECTS),
+		dbType: z.string().optional(),
+		schemaPath: z.string().min(1)
+	})).default([]),
+	queries: z.array(queryEntrySchema).default([]),
+	queryFiles: z.array(z.string().min(1)).default([]),
+	maps: z.array(mapSchema).default([])
+});
+const PROTOCOL_LABELS = {
+	openapi: "REST",
+	graphql: "GraphQL",
+	grpc: "gRPC"
+};
+function slugify(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function contentHash(...parts) {
+	const hash = createHash("sha256");
+	for (const part of parts) hash.update(part);
+	return hash.digest("hex");
+}
+async function readArtifactFile(root, relativePath) {
+	const { realPath, stat } = await resolveRepositoryFile(root, relativePath);
+	if (!stat.isFile()) throw new Error(`Not a file: ${relativePath}`);
+	if (stat.size > MAX_FILE_BYTES) throw new Error(`File is larger than ${MAX_FILE_BYTES} bytes: ${relativePath}`);
+	return {
+		text: await fs.readFile(realPath, "utf8"),
+		updatedAt: stat.mtime.toISOString()
+	};
+}
+function parseOpenApi(text) {
+	const spec = parse$1(text);
+	if (spec === null || typeof spec !== "object") throw new Error("not an OpenAPI document");
+	return Object.entries(spec.paths ?? {}).flatMap(([route, operations]) => HTTP_METHODS.filter((method) => operations[method] !== void 0).map((method) => {
+		const operation = operations[method];
+		return {
+			method: method.toUpperCase(),
+			path: route,
+			operationId: typeof operation.operationId === "string" ? operation.operationId : `${method.toUpperCase()} ${route}`,
+			summary: typeof operation.summary === "string" ? operation.summary : "",
+			description: typeof operation.description === "string" ? operation.description : "",
+			parameters: "[]"
+		};
+	}));
+}
+function parseGraphQLSchema(text) {
+	return parse(text).definitions.flatMap((definition) => {
+		if (definition.kind !== Kind.OBJECT_TYPE_DEFINITION && definition.kind !== Kind.OBJECT_TYPE_EXTENSION || ![
+			"Query",
+			"Mutation",
+			"Subscription"
+		].includes(definition.name.value)) return [];
+		return (definition.fields ?? []).map((field) => {
+			const args = field.arguments === void 0 || field.arguments.length === 0 ? "" : `(${field.arguments.map((arg) => `${arg.name.value}: ${print(arg.type)}`).join(", ")})`;
+			return {
+				method: definition.name.value,
+				path: `${field.name.value}${args}: ${print(field.type)}`,
+				operationId: field.name.value,
+				summary: "",
+				description: field.description?.value ?? "",
+				parameters: "[]"
+			};
+		});
+	});
+}
+function parseProto(text) {
+	const packageName = /^\s*package\s+([\w.]+)\s*;/m.exec(text)?.[1] ?? "";
+	const services = [...text.matchAll(/\bservice\s+(\w+)\s*\{/g)];
+	return [...text.matchAll(/\brpc\s+(\w+)\s*\(\s*(stream\s+)?[\w.]+\s*\)\s*returns\s*\(\s*(stream\s+)?[\w.]+\s*\)/g)].map((rpc) => {
+		const service = services.filter((match) => match.index < rpc.index).pop();
+		if (service === void 0) throw new Error(`rpc ${rpc[1]} is outside a service`);
+		const clientStream = rpc[2] !== void 0;
+		const serverStream = rpc[3] !== void 0;
+		const qualifiedService = packageName === "" ? service[1] : `${packageName}.${service[1]}`;
+		return {
+			method: clientStream && serverStream ? "bidirectional" : clientStream ? "client_streaming" : serverStream ? "server_streaming" : "unary",
+			path: `${qualifiedService}/${rpc[1]}`,
+			operationId: rpc[1],
+			summary: "",
+			description: "",
+			parameters: JSON.stringify({
+				packageName,
+				serviceName: service[1]
+			})
+		};
+	});
+}
+function parseApiSpec(type, text) {
+	if (type === "openapi") return parseOpenApi(text);
+	if (type === "graphql") return parseGraphQLSchema(text);
+	if (type === "grpc") return parseProto(text);
+	throw new Error(`Unknown API type: ${String(type)}`);
+}
+async function convertDiagram(mermaid, context) {
+	if (context === void 0) return convertMermaidToReactFlow(mermaid);
+	return convertMermaidToReactFlowWithContext(mermaid, contextSchema.parse(context), { repositionNodes: true });
+}
+function parseDatabaseSchema(dialect, text) {
+	if (dialect === "dynamodb") {
+		const table = DynamoEditorSchema.parse(JSON.parse(text));
+		return {
+			sdkDialect: dialect,
+			ast: convertDynamoSchemaToAst(table),
+			sourceContent: table,
+			noSQLSchema: { dynamo: { table } }
+		};
+	}
+	if (dialect === "mongodb") {
+		const schema = MongoEditorSchema.parse(JSON.parse(text));
+		return {
+			sdkDialect: dialect,
+			ast: convertMongoSchemaToAst(schema),
+			sourceContent: schema,
+			noSQLSchema: { mongo: { collections: schema.collections } }
+		};
+	}
+	const sdkDialect = dialect === "postgres" ? "postgresql" : dialect === "other" ? SqlToAstParser.detectDialect(text) : dialect;
+	return {
+		sdkDialect,
+		ast: new SqlToAstParser(sdkDialect).parse(text),
+		sourceContent: void 0,
+		noSQLSchema: null
+	};
+}
+function toTables(ast) {
+	return ast.tables.map((table) => ({
+		name: table.name,
+		columns: table.columns.map((column) => ({
+			name: column.name,
+			type: column.dataType.name,
+			nullable: column.nullable,
+			description: column.comment || null,
+			isPrimaryKey: table.constraints.some((c) => c.type === "primary_key" && c.columns.includes(column.name))
+		})),
+		indexes: []
+	}));
+}
+function toServiceEntity(id, service, updatedAt) {
+	return {
+		id,
+		orgId: ORG_ID,
+		folderId: null,
+		teamId: null,
+		name: service.name,
+		description: service.description,
+		status: "active",
+		tier: "tier3",
+		category: service.category,
+		language: "",
+		gitRepoUrl: service.repository?.url ?? null,
+		jiraProjectUrl: service.integrations?.jira?.url ?? null,
+		slackChannelUrl: service.integrations?.slack?.url ?? null,
+		lastCommitSha: null,
+		labels: service.labels ?? [],
+		metadata: "{}",
+		docLinks: null,
+		createdBy: ACTOR_ID,
+		updatedBy: null,
+		stats: {
+			serviceId: id,
+			endpointCount: 0,
+			diagramCount: 0,
+			dbTableCount: 0,
+			docCount: 0,
+			testCaseCount: 0
+		},
+		createdAt: updatedAt,
+		updatedAt
+	};
+}
+async function loadArtifacts(root, configFile = ROOT_CONFIG) {
+	const errors = [];
+	const configFiles = [configFile];
+	if (configFile === ".uigraph.yaml") configFiles.push(...(await glob(".uigraph/services/*.yaml", {
+		cwd: root,
+		dot: true,
+		onlyFiles: true,
+		followSymbolicLinks: false
+	})).sort());
+	const configs = [];
+	for (const file of configFiles) try {
+		const { text, updatedAt } = await readArtifactFile(root, file);
+		const parsed = configSchema.safeParse(parse$1(text));
+		if (!parsed.success) {
+			for (const issue of parsed.error.issues) errors.push(`${file}: ${issue.path.join(".") || "root"}: ${issue.message}`);
+			continue;
+		}
+		configs.push({
+			file,
+			config: parsed.data,
+			updatedAt
+		});
+	} catch (error) {
+		errors.push(`${file}: ${describe(error)}`);
+	}
+	for (const { file, config } of configs) if (config.service === void 0) {
+		if (config.apis.length > 0 || config.dependencies.length > 0 || config.databases.length > 0 || config.queries.length > 0 || config.queryFiles.length > 0) errors.push(`${file}: apis, dependencies, databases and queries require a service block`);
+	}
+	const services = [];
+	const serviceFiles = [];
+	const serviceIdByName = /* @__PURE__ */ new Map();
+	for (const { file, config, updatedAt } of configs) {
+		if (config.service === void 0) continue;
+		const id = slugify(config.service.name);
+		if (serviceIdByName.has(config.service.name) || services.some((s) => s.id === id)) {
+			errors.push(`${file}: duplicate service "${config.service.name}"`);
+			continue;
+		}
+		serviceIdByName.set(config.service.name, id);
+		services.push(toServiceEntity(id, config.service, updatedAt));
+		serviceFiles.push({
+			serviceId: id,
+			file
+		});
+	}
+	const apiGroups = [];
+	for (const { file, config, updatedAt } of configs) {
+		if (config.service === void 0) continue;
+		const serviceId = serviceIdByName.get(config.service.name);
+		if (serviceId === void 0) continue;
+		for (const api of config.apis) {
+			let text;
+			let endpoints;
+			try {
+				text = (await readArtifactFile(root, api.path)).text;
+				endpoints = parseApiSpec(api.type, text);
+			} catch (error) {
+				errors.push(`${file}: apis[${api.name}]: ${describe(error)}`);
+				continue;
+			}
+			const id = slugify(`${serviceId}-${api.name}`);
+			const hash = contentHash(text);
+			const fileName = path.posix.basename(api.path);
+			apiGroups.push({
+				group: {
+					id,
+					serviceId,
+					orgId: ORG_ID,
+					name: api.name,
+					version: "1",
+					label: null,
+					protocol: PROTOCOL_LABELS[api.type],
+					specKey: fileName,
+					specHash: hash,
+					createdBy: ACTOR_ID,
+					updatedBy: null,
+					createdAt: updatedAt,
+					updatedAt
+				},
+				version: {
+					id: `${id}-v1`,
+					orgId: ORG_ID,
+					apiGroupId: id,
+					versionNumber: 1,
+					label: null,
+					specKey: fileName,
+					specHash: hash,
+					isAutoVersion: false,
+					createdBy: ACTOR_ID,
+					createdAt: updatedAt
+				},
+				spec: api.type === "openapi" ? {
+					fileName,
+					content: text
+				} : null,
+				endpoints: endpoints.map((endpoint, index) => ({
+					id: slugify(`${id}-${endpoint.method}-${endpoint.path}`),
+					apiGroupId: id,
+					serviceId,
+					orgId: ORG_ID,
+					operationId: endpoint.operationId,
+					method: endpoint.method,
+					path: endpoint.path,
+					summary: endpoint.summary,
+					description: endpoint.description,
+					tags: [],
+					parameters: endpoint.parameters,
+					requestBody: "{}",
+					responses: "{}",
+					exampleRequests: "[]",
+					exampleResponses: "[]",
+					order: index,
+					sla: null,
+					createdBy: ACTOR_ID,
+					updatedBy: null,
+					createdAt: updatedAt,
+					updatedAt
+				}))
+			});
+		}
+	}
+	const diagrams = [];
+	const diagramIds = /* @__PURE__ */ new Set();
+	const serviceDiagrams = [];
+	for (const { file, config } of configs) {
+		const serviceId = config.service === void 0 ? void 0 : serviceIdByName.get(config.service.name);
+		for (const [index, entry] of config.architectureDiagrams.entries()) {
+			const where = `${file}: architectureDiagrams[${entry.name}]`;
+			const id = slugify(path.posix.basename(path.posix.dirname(entry.path)));
+			if (diagramIds.has(id)) {
+				errors.push(`${where}: another diagram already uses the folder "${id}"`);
+				continue;
+			}
+			let mermaid;
+			let contextText;
+			let updatedAt;
+			let flow;
+			try {
+				const mermaidFile = await readArtifactFile(root, entry.path);
+				mermaid = mermaidFile.text;
+				updatedAt = mermaidFile.updatedAt;
+				contextText = entry.contextPath === void 0 ? void 0 : (await readArtifactFile(root, entry.contextPath)).text;
+				const context = contextText === void 0 ? void 0 : JSON.parse(contextText);
+				flow = await convertDiagram(mermaid, context);
+			} catch (error) {
+				errors.push(`${where}: ${describe(error)}`);
+				continue;
+			}
+			if (flow.nodes.length === 0 && !/^flowchart (TB|TD|BT|RL|LR)$/.test(mermaid.trim())) {
+				errors.push(`${where}: the Mermaid source could not be converted; check its syntax`);
+				continue;
+			}
+			const hash = contentHash(mermaid, contextText ?? "");
+			const entity = {
+				id,
+				orgId: ORG_ID,
+				folderId: null,
+				teamId: null,
+				name: entry.name,
+				description: null,
+				contentKey: entry.path,
+				contentHash: hash,
+				content: JSON.stringify({
+					nodes: flow.nodes,
+					edges: flow.edges,
+					dataSources: [],
+					components: [],
+					viewport: null
+				}),
+				previewAssetId: null,
+				previewImageUrl: null,
+				previewContentHash: null,
+				previewStatus: "none",
+				createdBy: ACTOR_ID,
+				updatedBy: null,
+				createdByCommitHash: null,
+				updatedByCommitHash: null,
+				createdByActor: null,
+				updatedByActor: null,
+				createdAt: updatedAt,
+				updatedAt
+			};
+			diagramIds.add(id);
+			diagrams.push({
+				entity,
+				file,
+				index,
+				entry,
+				flow,
+				mermaid
+			});
+			if (serviceId !== void 0) serviceDiagrams.push({
+				serviceId,
+				diagramId: id,
+				orgId: ORG_ID,
+				createdBy: ACTOR_ID,
+				updatedBy: null,
+				createdAt: updatedAt,
+				updatedAt,
+				diagram: entity
+			});
+		}
+	}
+	const docs = [];
+	const standaloneDocs = [];
+	const docIds = /* @__PURE__ */ new Set();
+	for (const { file, config } of configs) {
+		const serviceId = config.service === void 0 ? null : serviceIdByName.get(config.service.name);
+		if (serviceId === void 0) continue;
+		const names = /* @__PURE__ */ new Set();
+		for (const [index, entry] of config.docs.entries()) {
+			const where = `${file}: docs[${entry.name}]`;
+			if (names.has(entry.name)) {
+				errors.push(`${where}: duplicate doc name`);
+				continue;
+			}
+			names.add(entry.name);
+			let stat;
+			try {
+				stat = (await resolveRepositoryFile(root, entry.path)).stat;
+			} catch (error) {
+				errors.push(`${where}: ${describe(error)}`);
+				continue;
+			}
+			if (!stat.isFile()) {
+				errors.push(`${where}: not a file: ${entry.path}`);
+				continue;
+			}
+			const updatedAt = stat.mtime.toISOString();
+			const base = slugify(`${serviceId ?? "doc"}-${entry.name}`);
+			let id = base;
+			for (let suffix = 2; docIds.has(id); suffix++) id = `${base}-${suffix}`;
+			docIds.add(id);
+			const doc = {
+				id,
+				orgId: ORG_ID,
+				folderId: null,
+				teamId: null,
+				fileAssetId: entry.path,
+				fileUrl: null,
+				fileName: entry.name,
+				serviceName: config.service?.name ?? null,
+				fileType: entry.fileType ?? DOC_EXTENSIONS[path.posix.extname(entry.path).toLowerCase()] ?? "other",
+				description: entry.description ?? "",
+				contentHash: `${stat.size}-${stat.mtimeMs}`,
+				createdBy: ACTOR_ID,
+				updatedBy: null,
+				createdAt: updatedAt,
+				updatedAt
+			};
+			if (serviceId === null) {
+				standaloneDocs.push({
+					file,
+					index,
+					entry,
+					doc
+				});
+				continue;
+			}
+			docs.push({
+				file,
+				index,
+				entry,
+				serviceDoc: {
+					serviceId,
+					docId: doc.id,
+					orgId: ORG_ID,
+					createdBy: ACTOR_ID,
+					updatedBy: null,
+					createdAt: updatedAt,
+					updatedAt,
+					doc
+				}
+			});
+		}
+	}
+	const databases = [];
+	const queries = [];
+	for (const { file, config, updatedAt: configUpdatedAt } of configs) {
+		if (config.service === void 0) continue;
+		const serviceId = serviceIdByName.get(config.service.name);
+		if (serviceId === void 0) continue;
+		const databaseIds = /* @__PURE__ */ new Map();
+		for (const [index, entry] of config.databases.entries()) {
+			const where = `${file}: databases[${entry.name}]`;
+			if (databaseIds.has(entry.name)) {
+				errors.push(`${where}: duplicate database name`);
+				continue;
+			}
+			let text;
+			let updatedAt;
+			let parsed;
+			try {
+				({text, updatedAt} = await readArtifactFile(root, entry.schemaPath));
+				parsed = parseDatabaseSchema(entry.dialect, text);
+			} catch (error) {
+				errors.push(`${where}: ${describe(error)}`);
+				continue;
+			}
+			const id = slugify(`${serviceId}-${entry.name}`);
+			databaseIds.set(entry.name, id);
+			const diagramId = `db-${id}`;
+			const flow = AstToUiConverter.toReactFlow(parsed.ast, entry.name);
+			const hash = contentHash(text);
+			const diagram = {
+				id: diagramId,
+				orgId: ORG_ID,
+				folderId: null,
+				teamId: null,
+				name: `${entry.name} Schema Diagram`,
+				description: null,
+				contentKey: entry.schemaPath,
+				contentHash: hash,
+				content: JSON.stringify({
+					nodes: flow.nodes,
+					edges: flow.edges,
+					dataSources: [{
+						id,
+						name: entry.name,
+						dialect: parsed.sdkDialect,
+						schemaAst: parsed.ast,
+						sourceType: "file",
+						sourceContent: parsed.sourceContent,
+						createdAt: Date.parse(updatedAt),
+						modifiedAt: null
+					}],
+					components: [],
+					viewport: null
+				}),
+				previewAssetId: null,
+				previewImageUrl: null,
+				previewContentHash: null,
+				previewStatus: "none",
+				createdBy: ACTOR_ID,
+				updatedBy: null,
+				createdByCommitHash: null,
+				updatedByCommitHash: null,
+				createdByActor: null,
+				updatedByActor: null,
+				createdAt: updatedAt,
+				updatedAt
+			};
+			databases.push({
+				file,
+				index,
+				entry,
+				diagram,
+				serviceDb: {
+					id,
+					serviceId,
+					orgId: ORG_ID,
+					dbName: entry.name,
+					dbType: entry.dbType ?? entry.dialect,
+					dialect: entry.dialect,
+					schemaJson: "{}",
+					tables: parsed.noSQLSchema === null ? toTables(parsed.ast) : [],
+					noSQLSchema: parsed.noSQLSchema,
+					dbDiagramId: diagramId,
+					pgDumpFileId: null,
+					source: "cli",
+					sourceTs: null,
+					createdBy: ACTOR_ID,
+					updatedBy: null,
+					createdByCommitHash: null,
+					updatedByCommitHash: null,
+					createdByActor: null,
+					updatedByActor: null,
+					createdAt: updatedAt,
+					updatedAt
+				}
+			});
+		}
+		const entries = config.queries.map((entry, index) => ({
+			source: file,
+			index,
+			entry
+		}));
+		for (const queryFile of config.queryFiles) try {
+			const { text } = await readArtifactFile(root, queryFile);
+			const parsed = queryFileSchema.safeParse(parse$1(text));
+			if (!parsed.success) {
+				for (const issue of parsed.error.issues) errors.push(`${queryFile}: ${issue.path.join(".") || "root"}: ${issue.message}`);
+				continue;
+			}
+			entries.push(...parsed.data.queries.map((entry, index) => ({
+				source: queryFile,
+				index,
+				entry
+			})));
+		} catch (error) {
+			errors.push(`${file}: queryFiles[${queryFile}]: ${describe(error)}`);
+		}
+		const queryIds = /* @__PURE__ */ new Set();
+		for (const { source, index, entry } of entries) {
+			const where = `${source}: queries[${entry.name}]`;
+			const serviceDbId = databaseIds.get(entry.database);
+			if (serviceDbId === void 0) {
+				errors.push(`${where}: unknown database "${entry.database}"`);
+				continue;
+			}
+			const id = slugify(`${serviceDbId}-${entry.name}`);
+			if (queryIds.has(id)) {
+				errors.push(`${where}: duplicate query name`);
+				continue;
+			}
+			let queryText;
+			let updatedAt;
+			try {
+				if (entry.path !== void 0 && entry.queryText === void 0) ({text: queryText, updatedAt} = await readArtifactFile(root, entry.path));
+				else if (entry.path === void 0 && entry.queryText !== void 0) {
+					queryText = entry.queryText;
+					updatedAt = configUpdatedAt;
+				} else throw new Error("set exactly one of path or queryText");
+			} catch (error) {
+				errors.push(`${where}: ${describe(error)}`);
+				continue;
+			}
+			queryIds.add(id);
+			queries.push({
+				file: source,
+				index,
+				entry,
+				savedQuery: {
+					id,
+					orgId: ORG_ID,
+					serviceDbId,
+					folderId: null,
+					scope: "TEAM",
+					ownerUserId: null,
+					teamId: null,
+					title: entry.name,
+					description: entry.description ?? "",
+					queryText,
+					tags: entry.tags ?? [],
+					source: "cli",
+					createdBy: ACTOR_ID,
+					updatedBy: null,
+					createdByCommitHash: null,
+					updatedByCommitHash: null,
+					createdByActor: null,
+					updatedByActor: null,
+					createdAt: updatedAt,
+					updatedAt
+				}
+			});
+		}
+	}
+	let canvas = {};
+	try {
+		const parsed = canvasFileSchema.safeParse(JSON.parse((await readArtifactFile(root, CANVAS_FILE)).text));
+		if (parsed.success) canvas = parsed.data;
+		else for (const issue of parsed.error.issues) errors.push(`${CANVAS_FILE}: ${issue.path.join(".") || "root"}: ${issue.message}`);
+	} catch (error) {
+		if (error.code !== "ENOENT") errors.push(`${CANVAS_FILE}: ${describe(error)}`);
+	}
+	const maps = [];
+	const mapIds = /* @__PURE__ */ new Set();
+	for (const { file, config, updatedAt } of configs) for (const [index, entry] of config.maps.entries()) {
+		const where = `${file}: maps[${entry.name}]`;
+		const id = slugify(entry.name);
+		if (mapIds.has(id)) {
+			errors.push(`${where}: another map has the same name`);
+			continue;
+		}
+		mapIds.add(id);
+		const mapCanvas = canvas[entry.name] ?? {};
+		const frames = [];
+		const frameIds = /* @__PURE__ */ new Set();
+		for (const [frameIndex, frameEntry] of (entry.frames ?? []).entries()) {
+			const frameWhere = `${where}: frames[${frameEntry.name}]`;
+			const frameId = `${id}--${slugify(frameEntry.name)}`;
+			if (frameIds.has(frameId)) {
+				errors.push(`${frameWhere}: another frame has the same name`);
+				continue;
+			}
+			frameIds.add(frameId);
+			let imageHash = null;
+			if (frameEntry.imagePath !== void 0) try {
+				const { stat } = await resolveRepositoryFile(root, frameEntry.imagePath);
+				if (!stat.isFile()) throw new Error(`Not a file: ${frameEntry.imagePath}`);
+				imageHash = `${stat.size}-${stat.mtimeMs}`;
+			} catch (error) {
+				errors.push(`${frameWhere}: ${describe(error)}`);
+				continue;
+			}
+			const pointNames = /* @__PURE__ */ new Set();
+			const focalPoints = [];
+			for (const [pointIndex, point] of (frameEntry.focalPoints ?? []).entries()) {
+				if (pointNames.has(point.name)) {
+					errors.push(`${frameWhere}: focalPoints[${point.name}]: another focal point has the same name`);
+					continue;
+				}
+				pointNames.add(point.name);
+				const pointId = `${frameId}--p${pointIndex}`;
+				focalPoints.push({
+					point: {
+						id: pointId,
+						frameId,
+						orgId: ORG_ID,
+						name: point.name,
+						locationX: point.x,
+						locationY: point.y,
+						visibility: point.visibility ?? "public",
+						color: point.color ?? null,
+						isActive: true,
+						createdBy: ACTOR_ID,
+						updatedBy: null,
+						createdByCommitHash: null,
+						updatedByCommitHash: null,
+						createdAt: updatedAt,
+						updatedAt
+					},
+					components: (point.components ?? []).map((ref, refIndex) => ({
+						ref,
+						meta: {
+							id: `${pointId}--c${refIndex}`,
+							focalPointId: pointId,
+							orgId: ORG_ID,
+							frameId,
+							componentId: ref.componentId,
+							componentLinkDiagramId: null,
+							componentLinkApiEndpointId: null,
+							componentLinkTestPackId: null,
+							componentLinkServiceDocId: null,
+							componentModalFields: (ref.modalFields ?? []).map((field, order) => ({
+								componentFieldId: field.componentFieldId,
+								label: field.label ?? null,
+								type: field.type ?? null,
+								required: null,
+								isReadonly: null,
+								data: field.data ?? null,
+								options: null,
+								order
+							})),
+							createdBy: ACTOR_ID,
+							updatedBy: null,
+							createdByCommitHash: null,
+							updatedByCommitHash: null,
+							createdAt: updatedAt,
+							updatedAt
+						}
+					}))
+				});
+			}
+			const frameCanvas = mapCanvas.frames?.[frameEntry.name] ?? {};
+			frames.push({
+				name: frameEntry.name,
+				frame: {
+					id: frameId,
+					mapId: id,
+					orgId: ORG_ID,
+					parentFrameId: null,
+					name: frameEntry.name,
+					description: frameEntry.description ?? "",
+					templateType: "default",
+					screenshotAssetId: frameEntry.imagePath ?? null,
+					screenshotImageUrl: null,
+					screenshotContentHash: imageHash,
+					status: "active",
+					order: frameIndex,
+					source: "cli",
+					focalPointCount: focalPoints.length,
+					createdBy: ACTOR_ID,
+					updatedBy: null,
+					createdByCommitHash: null,
+					updatedByCommitHash: null,
+					createdByActor: null,
+					updatedByActor: null,
+					createdAt: updatedAt,
+					updatedAt
+				},
+				focalPoints,
+				groups: (frameCanvas.groups ?? []).map((group, groupIndex) => ({
+					id: `${frameId}--g${groupIndex}`,
+					frameId,
+					orgId: ORG_ID,
+					name: group.name,
+					description: group.description,
+					locationX: group.x,
+					locationY: group.y,
+					width: group.width,
+					height: group.height,
+					order: groupIndex,
+					isActive: true,
+					createdBy: ACTOR_ID,
+					updatedBy: null,
+					createdAt: updatedAt,
+					updatedAt
+				})),
+				links: (frameCanvas.links ?? []).map((link, linkIndex) => ({
+					target: {
+						map: link.map,
+						frame: link.frame
+					},
+					link: {
+						id: `${frameId}--l${linkIndex}`,
+						frameId,
+						orgId: ORG_ID,
+						kind: link.kind,
+						targetFrameId: null,
+						targetMapId: null,
+						label: link.label,
+						locationX: link.x,
+						locationY: link.y,
+						isActive: true,
+						createdBy: ACTOR_ID,
+						updatedBy: null,
+						createdAt: updatedAt,
+						updatedAt
+					}
+				}))
+			});
+		}
+		maps.push({
+			file,
+			index,
+			entry,
+			canvas: mapCanvas,
+			frames,
+			map: {
+				id,
+				orgId: ORG_ID,
+				folderId: null,
+				teamId: null,
+				name: entry.name,
+				description: entry.description ?? "",
+				status: "active",
+				createdBy: ACTOR_ID,
+				updatedBy: null,
+				createdByCommitHash: null,
+				updatedByCommitHash: null,
+				createdAt: updatedAt,
+				updatedAt,
+				previewImgUrls: []
+			}
+		});
+	}
+	const dependencies = [];
+	for (const { file, config } of configs) {
+		if (config.service === void 0) continue;
+		const service = services.find((s) => s.id === serviceIdByName.get(config.service.name));
+		if (service === void 0) continue;
+		const names = /* @__PURE__ */ new Set();
+		for (const dependency of config.dependencies) {
+			const where = `${file}: dependencies[${dependency.name}]`;
+			if (names.has(dependency.name)) errors.push(`${where}: duplicate dependency name`);
+			names.add(dependency.name);
+			if (dependency.service === config.service.name) errors.push(`${where}: a service cannot depend on itself`);
+			const endpointNames = dependency.apiEndpointNames ?? [];
+			if (new Set(endpointNames).size !== endpointNames.length) errors.push(`${where}: apiEndpointNames must be unique`);
+			const target = services.find((s) => s.id === slugify(dependency.service));
+			dependencies.push({
+				id: slugify(`${service.id}-${dependency.name}`),
+				name: dependency.name,
+				service: toDependencyService(service),
+				dependency: target === void 0 ? null : toDependencyService(target),
+				dependencyName: dependency.service,
+				direction: dependency.direction,
+				type: dependency.type ?? null,
+				criticality: dependency.criticality,
+				description: dependency.description ?? null,
+				apiGroupName: dependency.apiGroupName ?? null,
+				apiEndpointNames: endpointNames,
+				databaseName: dependency.databaseName ?? null
+			});
+		}
+	}
+	for (const service of services) {
+		service.stats.endpointCount = apiGroups.filter(({ group }) => group.serviceId === service.id).reduce((count, { endpoints }) => count + endpoints.length, 0);
+		service.stats.diagramCount = serviceDiagrams.filter((link) => link.serviceId === service.id).length;
+		service.stats.docCount = docs.filter(({ serviceDoc }) => serviceDoc.serviceId === service.id).length;
+		service.stats.dbTableCount = databases.filter(({ serviceDb }) => serviceDb.serviceId === service.id).reduce((count, { serviceDb }) => count + serviceDb.tables.length, 0);
+	}
+	return {
+		errors,
+		db: {
+			configFiles: configs.map(({ file }) => file),
+			services,
+			serviceFiles,
+			apiGroups,
+			diagrams,
+			serviceDiagrams,
+			docs,
+			standaloneDocs,
+			databases,
+			queries,
+			maps,
+			dependencies
+		}
+	};
+}
+function toDependencyService(service) {
+	return {
+		id: service.id,
+		name: service.name,
+		description: service.description,
+		status: service.status,
+		tier: service.tier,
+		category: service.category,
+		language: service.language,
+		gitRepoUrl: service.gitRepoUrl,
+		updatedAt: service.updatedAt,
+		metadata: null
+	};
+}
+//#endregion
+//#region src/version.ts
+const { version } = createRequire(import.meta.url)("../package.json");
+const VERSION = version;
+const BUILD_ID = createHash("sha1").update(readFileSync(new URL(import.meta.url))).digest("hex").slice(0, 8);
+//#endregion
+//#region src/analysis/skill.ts
+const REPOSITORY = "uigraph-oss/skills";
+const SKILL_DIRECTORY = "skills/uigraph/";
+const SKILL_SOURCE = `github.com/${REPOSITORY}`;
+async function fetchOk(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`${url} responded ${response.status}`);
+	return response;
+}
+async function downloadSkill() {
+	const tree = await (await fetchOk(`https://api.github.com/repos/${REPOSITORY}/git/trees/main?recursive=1`)).json();
+	if (tree.truncated) throw new Error(`The file list of ${SKILL_SOURCE} is truncated`);
+	const paths = tree.tree.filter((entry) => entry.type === "blob" && entry.path.startsWith(SKILL_DIRECTORY)).map((entry) => entry.path);
+	const files = /* @__PURE__ */ new Map();
+	await Promise.all(paths.map(async (filePath) => {
+		const response = await fetchOk(`https://raw.githubusercontent.com/${REPOSITORY}/${tree.sha}/${filePath}`);
+		files.set(filePath.slice(15), await response.text());
+	}));
+	const instructions = files.get("SKILL.md");
+	if (instructions === void 0) throw new Error(`${SKILL_SOURCE} has no ${SKILL_DIRECTORY}SKILL.md`);
+	return {
+		instructions: instructions.replace(/^---\n[\s\S]*?\n---\n/, ""),
+		files
+	};
+}
+//#endregion
+//#region src/analysis/analyze.ts
+const PROMPT = fs$1.readFileSync(new URL("./prompt.md", import.meta.url), "utf8");
+const PLAN_PROMPT = fs$1.readFileSync(new URL("./plan-prompt.md", import.meta.url), "utf8");
+const PLAN_MAX_TURNS = 100;
+var AnalysisError = class extends Error {};
+var AnalysisCancelledError = class extends Error {};
+var AnalysisLimitError = class extends AnalysisError {};
+function describeToolEvent(event) {
+	if (event.tool === "list_files") return `list   ${event.pattern}`;
+	if (event.tool === "read_file") return `read   ${event.path}`;
+	if (event.tool === "search") return `search ${event.pattern}  ${pc.dim(`in ${event.glob}`)}`;
+	if (event.tool === "write_file") return pc.green(`write  ${event.path}`);
+	if (event.tool === "validate_artifacts") return "validate";
+	if (event.tool === "read_skill_file") return `skill  ${event.path}`;
+	if (event.tool === "submit_diagram_plan") return pc.green(`plan   ${event.count} diagram candidates`);
+	throw new Error(`Unknown tool event: ${JSON.stringify(event)}`);
+}
+function describeUsage(outcome) {
+	return `${outcome.tokens.toLocaleString()} tokens${outcome.costUsd === null ? "" : ` · ~$${outcome.costUsd.toFixed(2)} estimated`}`;
+}
+async function runSession(root, skill, prompt, abortController, settings, mode = "generate") {
+	let toolCalls = 0;
+	const tools = createRepositoryTools(root, skill.files, (event) => {
+		toolCalls++;
+		console.log(pc.dim(`  ${String(toolCalls).padStart(3)} `) + describeToolEvent(event));
+	}, mode === "generate" ? void 0 : { onSubmit: mode.onPlan });
+	let outcome;
+	try {
+		outcome = await runAgent({
+			agent: settings.agent,
+			cwd: root,
+			systemPrompt: mode === "generate" ? `${PROMPT}\n# UIGraph skill\n\nThe skill below was written for interactive use. The run instructions above override its approval workflow, and its file references resolve through \`read_skill_file\`.\n\n${skill.instructions}` : PLAN_PROMPT,
+			prompt,
+			tools,
+			signal: abortController.signal,
+			model: settings.model,
+			maxBudgetUsd: settings.maxBudgetUsd,
+			maxTurns: mode === "generate" ? void 0 : PLAN_MAX_TURNS,
+			clientApp: `uigraph/${VERSION}`,
+			log: consola.debug
+		});
+	} catch (error) {
+		if (abortController.signal.aborted) throw new AnalysisCancelledError("Analysis cancelled");
+		if (error instanceof AgentLimitError) throw new AnalysisLimitError(error.message, { cause: error });
+		if (error instanceof AgentError) throw new AnalysisError(error.message, { cause: error });
+		throw error;
+	}
+	if (abortController.signal.aborted) throw new AnalysisCancelledError("Analysis cancelled");
+	return outcome;
+}
+function printErrors(errors) {
+	for (const error of errors.slice(0, 30)) console.log(pc.yellow(`  • ${error}`));
+	if (errors.length > 30) console.log(pc.yellow(`  • … ${errors.length - 30} more`));
+}
+async function loadSkill() {
+	console.log(pc.dim(`  Downloading the UIGraph skill from ${SKILL_SOURCE}`));
+	try {
+		return await downloadSkill();
+	} catch (error) {
+		throw new AnalysisError(`Could not download the UIGraph skill from ${SKILL_SOURCE}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+async function listExistingDiagrams(root) {
+	return (await fs$1.promises.readdir(path.join(root, ".uigraph", "diagrams"), { withFileTypes: true }).catch((error) => {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	})).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+async function planDiagrams(root, repositoryName, skill, abortController, settings) {
+	const startedAt = Date.now();
+	const existing = await listExistingDiagrams(root);
+	const captured = { submission: null };
+	let outcome;
+	try {
+		outcome = await runSession(root, skill, [`Propose the architecture diagrams worth generating and the existing documents worth adding for the repository "${repositoryName}" in the working directory.`, existing.length === 0 ? "No diagrams exist yet." : `These diagrams already exist, so do not propose them again: ${existing.join(", ")}.`].join("\n"), abortController, settings, { onPlan: (submission) => {
+			captured.submission = submission;
+		} });
+	} catch (error) {
+		if (error instanceof AnalysisLimitError) {
+			consola.debug(`Planning stopped: ${inspect(error)}`);
+			return null;
+		}
+		throw error;
+	}
+	if (captured.submission === null) return null;
+	return {
+		...captured.submission,
+		seconds: Math.round((Date.now() - startedAt) / 1e3),
+		usage: outcome
+	};
+}
+async function generateArtifacts(root, repositoryName, gitRemote, update, abortController, skill, selection, settings) {
+	const startedAt = Date.now();
+	const existing = await listExistingDiagrams(root);
+	let outcome = await runSession(root, skill, [
+		update ? `Update the existing UIGraph artifacts of the repository "${repositoryName}" in the working directory so they match the current code. Read the existing .uigraph.yaml and .uigraph/ files first and keep what is still correct.` : `Generate UIGraph artifacts for the repository "${repositoryName}" in the working directory.`,
+		gitRemote === null ? "The CLI found no usable git remote." : `The repository's git remote is ${gitRemote}.`,
+		...selection === null ? [] : [formatApprovedDiagrams(selection, existing)]
+	].join("\n"), abortController, settings);
+	let { errors } = await loadArtifacts(root);
+	if (errors.length > 0) {
+		console.log(pc.yellow(`\nThe artifacts have ${errors.length} problem(s). Asking ${AGENT_LABELS[settings.agent]} to repair them once:`));
+		printErrors(errors);
+		console.log();
+		outcome = await runSession(root, skill, [
+			"The UIGraph artifacts failed validation. Fix every problem below, re-reading files where needed, and run validate_artifacts until it passes. Remove findings you cannot support with evidence rather than guessing.",
+			"",
+			...errors.map((error) => `- ${error}`)
+		].join("\n"), abortController, settings);
+		errors = (await loadArtifacts(root)).errors;
+	}
+	if (errors.length > 0) {
+		printErrors(errors);
+		throw new AnalysisError(`The artifacts are still invalid after one repair attempt (${errors.length} problem(s)).`);
+	}
+	const seconds = Math.round((Date.now() - startedAt) / 1e3);
+	console.log(pc.dim(`\n  ${seconds}s · ${describeUsage(outcome)}`));
+}
+//#endregion
+//#region src/banner.ts
+const NAME = "UIGraph";
+const WEBSITE = "https://uigraph.app";
+const TAGLINE = "Map your project into services, APIs and diagrams";
+function blue(text) {
+	return pc.isColorSupported ? `\x1b[38;2;59;107;255m${text}\x1b[39m` : text;
+}
+const MARK = [[
+	0,
+	0,
+	pc.white("⏺")
+]];
+for (let col = 1; col < 5; col++) MARK.push([
+	0,
+	col,
+	blue("━")
+]);
+MARK.push([
+	0,
+	5,
+	blue("⏺")
+]);
+MARK.push([
+	1,
+	5,
+	blue("┃")
+]);
+MARK.push([
+	2,
+	5,
+	blue("⏺")
+]);
+for (let col = 4; col > 0; col--) MARK.push([
+	2,
+	col,
+	blue("━")
+]);
+MARK.push([
+	2,
+	0,
+	blue("⏺")
+]);
+MARK.push([
+	1,
+	0,
+	blue("┃")
+]);
+function imageProtocol() {
+	const program = process.env.TERM_PROGRAM;
+	if (program === "iTerm.app" || program === "WezTerm") return "iterm";
+	if (program === "ghostty" || process.env.TERM === "xterm-kitty" || process.env.KITTY_WINDOW_ID) return "kitty";
+	return null;
+}
+function logoImage(protocol) {
+	const file = fs$1.readFileSync(new URL("./uigraph-mark.png", import.meta.url));
+	const png = file.toString("base64");
+	if (protocol === "iterm") return `\x1b]1337;File=inline=1;size=${file.length};height=3;preserveAspectRatio=1:${png}\x07`;
+	const chunks = png.match(/.{1,4096}/g);
+	return chunks.map((chunk, index) => {
+		const more = index < chunks.length - 1 ? 1 : 0;
+		return `\x1b_G${index === 0 ? `a=T,f=100,r=3,C=1,q=2,m=${more}` : `m=${more}`};${chunk}\x1b\\`;
+	}).join("");
+}
+function render(frame, markFrames) {
+	const grid = Array.from({ length: 3 }, () => Array(6).fill(" "));
+	for (const [row, col, char] of MARK.slice(0, Math.min(frame, markFrames))) grid[row][col] = char;
+	const letters = Math.max(0, frame - markFrames);
+	const done = letters > 7;
+	const text = [
+		pc.bold(NAME.slice(0, letters)) + (done ? pc.dim(` v${VERSION}`) : ""),
+		done ? blue(WEBSITE) : "",
+		done ? pc.dim(TAGLINE) : ""
+	];
+	return grid.map((cells, row) => `  ${cells.join("")}    ${text[row]}\x1b[K`).join("\n");
+}
+async function showBanner() {
+	if (!process.stdout.isTTY) return;
+	const protocol = imageProtocol();
+	const markFrames = protocol ? 0 : MARK.length;
+	const frames = markFrames + 7 + 1;
+	process.stdout.write("\n");
+	for (let frame = 1; frame <= frames; frame++) {
+		process.stdout.write(`${frame === 1 ? "" : "\x1B[2A\r"}${render(frame, markFrames)}`);
+		if (frame === frames && protocol) process.stdout.write(`\x1b7\x1b[2A\r\x1b[2C${logoImage(protocol)}\x1b8`);
+		await setTimeout$1(20);
+	}
+	process.stdout.write("\n");
+}
+//#endregion
+//#region src/guidance/guidance.ts
+const TEMPLATE = readFileSync(new URL("./agents.md", import.meta.url), "utf8");
+const AGENT_FILES = ["CLAUDE.md", "AGENTS.md"];
+const GUIDANCE_FILE = ".uigraph/AGENTS.md";
+const REFERENCE = `## UIGraph
+
+If your change adds or changes API endpoints, database schemas, calls to other services, or a flow shown in a diagram, read \`${GUIDANCE_FILE}\` and follow it.
+`;
+async function writeGuidance(root) {
+	await writeArtifactFile(root, GUIDANCE_FILE, TEMPLATE);
+	const files = [];
+	for (const file of AGENT_FILES) {
+		const target = path.join(root, file);
+		const text = await fs.readFile(target, "utf8").catch((error) => {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		});
+		if (text === null) continue;
+		files.push(file);
+		if (text.includes(".uigraph/AGENTS.md")) continue;
+		if (text === "" || text.endsWith("\n\n")) await fs.appendFile(target, REFERENCE);
+		else if (text.endsWith("\n")) await fs.appendFile(target, `\n${REFERENCE}`);
+		else await fs.appendFile(target, `\n\n${REFERENCE}`);
+	}
+	if (files.length === 0) {
+		await fs.writeFile(path.join(root, "AGENTS.md"), REFERENCE, { flag: "wx" });
+		files.push("AGENTS.md");
+	}
+	return files;
+}
+//#endregion
+//#region src/workspace.ts
+const WORKSPACE_CONFIG = ".uigraph/workspace.yaml";
+const COMPONENT_API_CONTRACT_ID = "component_api-contract";
+const COMPONENT_FLOW_DIAGRAM_ID = "component_backend-flow-diagram";
+const COMPONENT_SUPPORT_KB_ID = "component_support-kb-troubleshooting";
+const REGISTRY = ".uigraph/registry.yaml";
+const PREFERENCES = ".uigraph/preferences.yaml";
+const WORKSPACE_ID = "workspace";
+const registrySchema = z.object({ projects: z.array(z.string().min(1)) });
+const preferencesSchema = z.object({ agentGuidance: z.object({ declined: z.array(z.string().min(1)) }) });
+function homeRoot() {
+	return fs.realpath(os.homedir());
+}
+async function readOptional(file) {
+	return fs.readFile(file, "utf8").catch((error) => {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	});
+}
+async function readRegistry(home) {
+	const text = await readOptional(path.join(home, REGISTRY));
+	if (text === null) return [];
+	return registrySchema.parse(parse$1(text)).projects;
+}
+async function registerProject$1(root) {
+	const home = await homeRoot();
+	const projects = await readRegistry(home);
+	if (projects.includes(root)) return;
+	await writeArtifactFile(home, REGISTRY, stringify({ projects: [...projects, root] }));
+}
+async function unregisterProject(root) {
+	const home = await homeRoot();
+	const projects = await readRegistry(home);
+	if (!projects.includes(root)) throw new Error(`${root} is not registered`);
+	await writeArtifactFile(home, REGISTRY, stringify({ projects: projects.filter((project) => project !== root) }));
+}
+async function readDeclinedGuidance(home) {
+	const text = await readOptional(path.join(home, PREFERENCES));
+	if (text === null) return [];
+	return preferencesSchema.parse(parse$1(text)).agentGuidance.declined;
+}
+async function isGuidanceDeclined(root) {
+	return (await readDeclinedGuidance(await homeRoot())).includes(root);
+}
+async function setGuidanceDeclined(root, declined) {
+	const home = await homeRoot();
+	const others = (await readDeclinedGuidance(home)).filter((project) => project !== root);
+	await writeArtifactFile(home, PREFERENCES, stringify({ agentGuidance: { declined: declined ? [...others, root] : others } }));
+}
+async function syncProject(root) {
+	await registerProject$1(root);
+	const { skipped, workspace } = await loadWorkspace();
+	const problem = skipped.find((entry) => entry.root === root);
+	if (problem !== void 0) return {
+		synced: false,
+		reason: problem.reason
+	};
+	if (workspace.projects.find((entry) => entry.root === root) === void 0) return {
+		synced: false,
+		reason: "is not part of the workspace"
+	};
+	return {
+		synced: true,
+		services: workspace.services.length
+	};
+}
+async function listRegisteredProjects() {
+	const home = await homeRoot();
+	const { skipped, workspace } = await loadWorkspace();
+	return (await readRegistry(home)).map((root) => ({
+		root,
+		problem: skipped.find((entry) => entry.root === root)?.reason ?? null,
+		services: workspace.services.filter((service) => workspace.projects.find((project) => project.root === root)?.serviceIds.includes(service.id)).map((service) => ({
+			id: service.id,
+			name: service.name
+		}))
+	}));
+}
+async function ensureWorkspaceConfig(home) {
+	if (await readOptional(path.join(home, ".uigraph/workspace.yaml")) === null) await writeArtifactFile(home, WORKSPACE_CONFIG, "version: 1\n");
+}
+function dropServices(db, ids) {
+	db.services = db.services.filter((service) => !ids.has(service.id));
+	db.serviceFiles = db.serviceFiles.filter((link) => !ids.has(link.serviceId));
+	db.apiGroups = db.apiGroups.filter(({ group }) => !ids.has(group.serviceId));
+	db.serviceDiagrams = db.serviceDiagrams.filter((link) => !ids.has(link.serviceId));
+	db.docs = db.docs.filter(({ serviceDoc }) => !ids.has(serviceDoc.serviceId));
+	const droppedDatabases = new Set(db.databases.filter(({ serviceDb }) => ids.has(serviceDb.serviceId)).map(({ serviceDb }) => serviceDb.id));
+	db.databases = db.databases.filter(({ serviceDb }) => !droppedDatabases.has(serviceDb.id));
+	db.queries = db.queries.filter(({ savedQuery }) => !droppedDatabases.has(savedQuery.serviceDbId));
+	db.dependencies = db.dependencies.filter((dependency) => !ids.has(dependency.service.id));
+}
+async function loadWorkspace() {
+	const home = await homeRoot();
+	const warnings = [];
+	const skipped = [];
+	function skip(root, reason) {
+		skipped.push({
+			root,
+			reason
+		});
+		warnings.push(`${root} ${reason}`);
+	}
+	const projects = [];
+	if (await readOptional(path.join(home, ".uigraph/workspace.yaml")) !== null) projects.push({
+		id: WORKSPACE_ID,
+		root: home,
+		configFile: WORKSPACE_CONFIG
+	});
+	const ids = new Set(projects.map((p) => p.id));
+	for (const root of await readRegistry(home)) {
+		const base = slugify(path.basename(root));
+		let id = base;
+		for (let suffix = 2; ids.has(id); suffix++) id = `${base}-${suffix}`;
+		ids.add(id);
+		if (await readOptional(path.join(root, ".uigraph.yaml")) === null) {
+			skip(root, `has no ${ROOT_CONFIG} and was skipped`);
+			continue;
+		}
+		projects.push({
+			id,
+			root,
+			configFile: ROOT_CONFIG
+		});
+	}
+	const loaded = [];
+	const services = [];
+	const serviceFiles = [];
+	const apiGroups = [];
+	const diagrams = [];
+	const serviceDiagrams = [];
+	const docs = [];
+	const standaloneDocs = [];
+	const databases = [];
+	const queries = [];
+	const maps = [];
+	const files = /* @__PURE__ */ new Map();
+	const dependencies = [];
+	const candidates = [];
+	for (const project of projects) {
+		const { db, errors } = await loadArtifacts(project.root, project.configFile);
+		if (errors.length > 0) {
+			skip(project.root, `has invalid artifacts and was skipped:\n${errors.map((error) => `  • ${error}`).join("\n")}`);
+			continue;
+		}
+		candidates.push({
+			project,
+			db
+		});
+	}
+	const owners = /* @__PURE__ */ new Map();
+	for (const { project, db } of candidates) for (const service of db.services) {
+		const primary = db.serviceFiles.find((link) => link.serviceId === service.id)?.file === project.configFile;
+		const current = owners.get(service.id);
+		if (current === void 0 || primary && !current.primary) owners.set(service.id, {
+			root: project.root,
+			primary
+		});
+	}
+	for (const { project, db } of candidates) {
+		const conflict = db.services.find((service) => {
+			const owner = owners.get(service.id);
+			return db.serviceFiles.find((link) => link.serviceId === service.id)?.file === project.configFile && owner?.root !== project.root;
+		});
+		if (conflict !== void 0) {
+			skip(project.root, `was skipped because the service "${conflict.name}" is already defined by ${owners.get(conflict.id)?.root ?? "another project"}. A service can only be defined in one repository.`);
+			continue;
+		}
+		const droppedIds = new Set(db.services.filter((service) => owners.get(service.id)?.root !== project.root).map((service) => service.id));
+		if (droppedIds.size > 0) dropServices(db, droppedIds);
+		loaded.push({
+			...project,
+			configFiles: db.configFiles,
+			serviceIds: db.services.map((service) => service.id)
+		});
+		services.push(...db.services);
+		serviceFiles.push(...db.serviceFiles.map((link) => ({
+			...link,
+			project
+		})));
+		apiGroups.push(...db.apiGroups);
+		for (const diagram of db.diagrams) {
+			const localId = diagram.entity.id;
+			diagram.entity.id = `${project.id}--${localId}`;
+			diagrams.push({
+				...diagram,
+				project,
+				localId
+			});
+			for (const { imagePath } of await listDiagramImages(project.root, diagram.entry.path)) files.set(`/files/${project.id}/${imagePath}`, {
+				root: project.root,
+				path: imagePath
+			});
+		}
+		serviceDiagrams.push(...db.serviceDiagrams.map((link) => ({
+			...link,
+			diagramId: link.diagram.id
+		})));
+		for (const doc of db.docs) {
+			const url = `/files/${project.id}/${doc.entry.path}`;
+			doc.serviceDoc.doc.fileUrl = url;
+			files.set(url, {
+				root: project.root,
+				path: doc.entry.path
+			});
+			docs.push({
+				...doc,
+				project
+			});
+		}
+		for (const doc of db.standaloneDocs) {
+			const url = `/files/${project.id}/${doc.entry.path}`;
+			doc.doc.id = `${project.id}--${doc.doc.id}`;
+			doc.doc.fileUrl = url;
+			files.set(url, {
+				root: project.root,
+				path: doc.entry.path
+			});
+			standaloneDocs.push({
+				...doc,
+				project
+			});
+		}
+		for (const database of db.databases) {
+			database.diagram.id = `${project.id}--${database.diagram.id}`;
+			database.serviceDb.dbDiagramId = database.diagram.id;
+			databases.push({
+				...database,
+				project
+			});
+		}
+		queries.push(...db.queries.map((query) => ({
+			...query,
+			project
+		})));
+		for (const map of db.maps) {
+			const prefix = `${project.id}--`;
+			map.map.id = prefix + map.map.id;
+			for (const { frame, focalPoints, groups, links } of map.frames) {
+				frame.id = prefix + frame.id;
+				frame.mapId = map.map.id;
+				if (frame.screenshotAssetId !== null) {
+					const url = `/files/${project.id}/${frame.screenshotAssetId}`;
+					files.set(url, {
+						root: project.root,
+						path: frame.screenshotAssetId
+					});
+					frame.screenshotImageUrl = `${url}?v=${frame.screenshotContentHash}`;
+				}
+				for (const { point, components } of focalPoints) {
+					point.id = prefix + point.id;
+					point.frameId = frame.id;
+					for (const { meta } of components) {
+						meta.id = prefix + meta.id;
+						meta.focalPointId = point.id;
+						meta.frameId = frame.id;
+					}
+				}
+				for (const group of groups) {
+					group.id = prefix + group.id;
+					group.frameId = frame.id;
+				}
+				for (const { link } of links) {
+					link.id = prefix + link.id;
+					link.frameId = frame.id;
+				}
+			}
+			map.map.previewImgUrls = map.frames.flatMap(({ frame }) => frame.screenshotImageUrl ?? []).slice(0, 4);
+			maps.push({
+				...map,
+				project
+			});
+		}
+		dependencies.push(...db.dependencies);
+	}
+	for (const dependency of dependencies) {
+		const target = services.find((s) => s.id === slugify(dependency.dependencyName));
+		dependency.dependency = target === void 0 ? null : toDependencyService(target);
+	}
+	for (const map of maps) for (const { links, focalPoints } of map.frames) {
+		for (const { target, link } of links) {
+			const targetMap = maps.find((m) => m.map.name === target.map);
+			link.targetMapId = targetMap?.map.id ?? null;
+			link.targetFrameId = target.frame === void 0 ? null : targetMap?.frames.find((f) => f.name === target.frame)?.frame.id ?? null;
+		}
+		for (const { components } of focalPoints) for (const { ref, meta } of components) {
+			const service = services.find((s) => s.name === ref.serviceName);
+			if (service === void 0) continue;
+			if (ref.componentId === "component_api-contract") meta.componentLinkApiEndpointId = apiGroups.find(({ group }) => group.serviceId === service.id && group.name === ref.apiGroupName)?.endpoints.find((endpoint) => endpoint.operationId === ref.operationId)?.id ?? null;
+			else if (ref.componentId === "component_backend-flow-diagram") meta.componentLinkDiagramId = serviceDiagrams.find((link) => link.serviceId === service.id && link.diagram.name === ref.architectureDiagramName)?.diagramId ?? null;
+			else if (ref.componentId === "component_support-kb-troubleshooting") meta.componentLinkServiceDocId = docs.find((doc) => doc.serviceDoc.serviceId === service.id && doc.entry.name === ref.docName)?.serviceDoc.docId ?? null;
+		}
+	}
+	const projectCount = loaded.filter((p) => p.id !== WORKSPACE_ID).length;
+	return {
+		warnings,
+		skipped,
+		workspace: {
+			home,
+			projects: loaded,
+			name: `${projectCount} ${projectCount === 1 ? "project" : "projects"}`,
+			services,
+			serviceFiles,
+			apiGroups,
+			diagrams,
+			serviceDiagrams,
+			docs,
+			standaloneDocs,
+			databases,
+			queries,
+			maps,
+			files,
+			dependencies
+		}
+	};
+}
+//#endregion
+//#region src/lock.ts
+const LOCK_FILE = path.join(".uigraph", "viewer.lock.json");
+const lockSchema = z.object({
+	pid: z.number().int().positive(),
+	port: z.number().int().min(1).max(65535)
+});
+async function lockPath() {
+	return path.join(await homeRoot(), LOCK_FILE);
+}
+function isAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+async function readViewerLock() {
+	const file = await lockPath();
+	const text = await fs.readFile(file, "utf8").catch(() => null);
+	if (text === null) return null;
+	let lock;
+	try {
+		lock = lockSchema.parse(JSON.parse(text));
+	} catch {
+		await fs.rm(file, { force: true });
+		return null;
+	}
+	if (!isAlive(lock.pid)) {
+		await fs.rm(file, { force: true });
+		return null;
+	}
+	return lock;
+}
+async function writeViewerLock(lock) {
+	const file = await lockPath();
+	await fs.mkdir(path.dirname(file), { recursive: true });
+	await fs.writeFile(file, JSON.stringify(lock), { mode: 384 });
+}
+async function removeViewerLock(pid) {
+	if ((await readViewerLock())?.pid === pid) await fs.rm(await lockPath(), { force: true });
+}
+//#endregion
+//#region src/artifacts/databases.ts
+const DIALECTS = {
+	postgresql: "postgres",
+	postgres: "postgres",
+	mysql: "mysql",
+	sqlite: "sqlite",
+	dynamodb: "dynamodb",
+	mongodb: "mongodb"
+};
+async function createDatabase(root, configFile, file, input, content) {
+	if ((await loadValid(root, configFile)).databases.some((d) => d.file === file && d.entry.name.toLowerCase() === input.name.toLowerCase())) throw new Error(`Another database in ${file} is named "${input.name}"`);
+	const dialect = DIALECTS[input.dialect];
+	if (dialect === void 0) throw new Error(`Unsupported database type "${input.dialect}"`);
+	parseDatabaseSchema(dialect, content);
+	const base = slugify(input.name);
+	if (base === "") throw new Error("The database name must contain a letter or digit");
+	const extension = dialect === "dynamodb" || dialect === "mongodb" ? ".json" : ".sql";
+	let schemaPath = `.uigraph/db/${base}${extension}`;
+	for (let suffix = 2; await exists(path.join(root, schemaPath)); suffix++) schemaPath = `.uigraph/db/${base}-${suffix}${extension}`;
+	await writeArtifactFile(root, schemaPath, content);
+	const { source, document } = await readYaml(root, file);
+	await writeArtifactFile(root, file, applyEdits(source, [appendItem(source, document, ["databases"], {
+		name: input.name,
+		dialect,
+		schemaPath
+	})]));
+	return schemaPath;
+}
+async function deleteDatabase(root, configFile, file, name) {
+	const db = await loadValid(root, configFile);
+	const database = db.databases.find((d) => d.file === file && d.entry.name === name);
+	if (database === void 0) throw new Error(`No database named "${name}" in ${file}`);
+	const usedBy = db.queries.filter((q) => q.savedQuery.serviceDbId === database.serviceDb.id);
+	if (usedBy.length > 0) throw new Error(`Remove the queries that use "${name}" first: ${usedBy.map((q) => q.entry.name).join(", ")}`);
+	const { source, document } = await readYaml(root, file);
+	await writeArtifactFile(root, file, applyEdits(source, [removeItem(source, document, ["databases"], findItemIndex(document, ["databases"], name))]));
+	const stillUsed = db.databases.some((d) => d !== database && d.entry.schemaPath === database.entry.schemaPath);
+	if (isArtifactPath(database.entry.schemaPath) && !stillUsed) await deleteArtifactFile(root, database.entry.schemaPath);
+}
+//#endregion
+//#region src/artifacts/queries.ts
+async function findDatabase$1(root, configFile, serviceDbId) {
+	const db = await loadValid(root, configFile);
+	const database = db.databases.find((d) => d.serviceDb.id === serviceDbId);
+	if (database === void 0) throw new Error(`Database ${serviceDbId} not found`);
+	return {
+		db,
+		database
+	};
+}
+function assertNameFree(db, serviceDbId, name, exceptId) {
+	const id = slugify(`${serviceDbId}-${name}`);
+	if (db.queries.some((q) => q.savedQuery.id === id && q.savedQuery.id !== exceptId)) throw new Error(`Another query on this database is named "${name}"`);
+	return id;
+}
+function optionalFields(input) {
+	return {
+		...input.description === "" ? {} : { description: input.description },
+		...input.tags.length === 0 ? {} : { tags: input.tags }
+	};
+}
+async function createQuery(root, configFile, serviceDbId, input) {
+	const { db, database } = await findDatabase$1(root, configFile, serviceDbId);
+	const id = assertNameFree(db, serviceDbId, input.name, null);
+	const { source, document } = await readYaml(root, database.file);
+	await writeArtifactFile(root, database.file, applyEdits(source, [appendItem(source, document, ["queries"], {
+		name: input.name,
+		database: database.entry.name,
+		queryText: input.queryText,
+		...optionalFields(input)
+	})]));
+	return id;
+}
+async function updateQuery(root, configFile, queryId, input) {
+	const db = await loadValid(root, configFile);
+	const query = db.queries.find((q) => q.savedQuery.id === queryId);
+	if (query === void 0) throw new Error(`Query ${queryId} not found`);
+	const id = assertNameFree(db, query.savedQuery.serviceDbId, input.name, queryId);
+	const { description, tags, queryText, path, ...rest } = query.entry;
+	if (path !== void 0) {
+		if (!isArtifactPath(path)) throw new Error(`The query file ${path} is outside .uigraph and cannot be edited`);
+		await writeArtifactFile(root, path, input.queryText);
+	}
+	const { source, document } = await readYaml(root, query.file);
+	await writeArtifactFile(root, query.file, applyEdits(source, [replaceItem(source, document.getIn(["queries", query.index], true), {
+		...rest,
+		name: input.name,
+		...path === void 0 ? { queryText: input.queryText } : { path },
+		...optionalFields(input)
+	})]));
+	return id;
+}
+async function deleteQuery(root, configFile, queryId) {
+	const db = await loadValid(root, configFile);
+	const query = db.queries.find((q) => q.savedQuery.id === queryId);
+	if (query === void 0) throw new Error(`Query ${queryId} not found`);
+	const { source, document } = await readYaml(root, query.file);
+	await writeArtifactFile(root, query.file, applyEdits(source, [removeItem(source, document, ["queries"], query.index)]));
+	const path = query.entry.path;
+	const stillUsed = db.queries.some((q) => q !== query && q.entry.path === path);
+	if (path !== void 0 && isArtifactPath(path) && !stillUsed) await deleteArtifactFile(root, path);
+}
+//#endregion
+//#region src/uploads.ts
+const pending = /* @__PURE__ */ new Set();
+const uploads = /* @__PURE__ */ new Map();
+function createUpload() {
+	const assetId = randomUUID();
+	pending.add(assetId);
+	return {
+		assetId,
+		uploadUrl: `/uploads/${assetId}`
+	};
+}
+function isPendingUpload(assetId) {
+	return pending.has(assetId);
+}
+function storeUpload(assetId, data, contentType) {
+	if (!pending.delete(assetId)) throw new Error(`Unknown upload ${assetId}`);
+	uploads.set(assetId, {
+		data,
+		contentType
+	});
+}
+function takeUpload(assetId) {
+	const upload = uploads.get(assetId);
+	if (upload === void 0) throw new Error(`The upload ${assetId} was not found; upload the file again`);
+	uploads.delete(assetId);
+	return upload;
+}
+//#endregion
+//#region src/graphql/resolvers.ts
+const MAX_DEPENDENCY_DEPTH = 10;
+function toDiagramImage(projectId, diagramId, imagePath, createdAt, order) {
+	return {
+		diagramImageId: imagePath,
+		diagramId,
+		orgId: ORG_ID,
+		assetId: imagePath,
+		imageUrl: `/files/${projectId}/${imagePath}`,
+		fileName: imagePath.split("/").at(-1),
+		order,
+		createdBy: ACTOR_ID,
+		createdAt
+	};
+}
+function notFound(kind, id) {
+	throw new GraphQLError(`${kind} ${id} not found`);
+}
+function findApiGroup(db, serviceId, apiGroupId) {
+	return db.apiGroups.find(({ group }) => group.id === apiGroupId && group.serviceId === serviceId) ?? notFound("API group", apiGroupId);
+}
+function sortItems(items, sortBy, sortDir) {
+	if (sortBy === "name") {
+		const sorted = [...items].sort((a, b) => a.name.localeCompare(b.name));
+		if (sortDir === "desc") return sorted.reverse();
+		return sorted;
+	}
+	if (sortBy === null || sortBy === void 0 || sortBy === "created" || sortBy === "updated") return items;
+	throw new GraphQLError(`Unsupported sort: ${sortBy}`);
+}
+function page(items, args) {
+	const search = args.search?.trim().toLowerCase() ?? "";
+	const matching = search === "" ? items : items.filter((item) => item.name.toLowerCase().includes(search));
+	const sorted = sortItems(matching, args.sortBy, args.sortDir);
+	const offset = args.offset ?? 0;
+	return {
+		items: args.limit === null || args.limit === void 0 ? sorted.slice(offset) : sorted.slice(offset, offset + args.limit),
+		totalCount: matching.length
+	};
+}
+function walkDependencies(db, serviceId, direction) {
+	const { dependencies } = db;
+	const ownSide = direction === "upstream" ? "downstream" : "upstream";
+	const otherSide = direction === "upstream" ? "upstream" : "downstream";
+	const visited = /* @__PURE__ */ new Set([serviceId]);
+	let frontier = [serviceId];
+	for (let depth = 0; depth < MAX_DEPENDENCY_DEPTH && frontier.length > 0; depth++) {
+		const next = [];
+		for (const current of frontier) for (const row of dependencies) {
+			if (row.dependency === null) continue;
+			const neighbour = row.service.id === current && row.direction === ownSide ? row.dependency.id : row.dependency.id === current && row.direction === otherSide ? row.service.id : null;
+			if (neighbour !== null && !visited.has(neighbour)) {
+				visited.add(neighbour);
+				next.push(neighbour);
+			}
+		}
+		frontier = next;
+	}
+	return dependencies.filter((row) => visited.has(row.service.id) && (row.dependency === null || visited.has(row.dependency.id)));
+}
+async function findCreatedDiagram(projectRoot, localId) {
+	const { workspace } = await loadWorkspace();
+	const diagram = workspace.diagrams.find((d) => d.project.root === projectRoot && d.localId === localId);
+	if (diagram === void 0) throw new GraphQLError(`The new diagram ${localId} could not be loaded`);
+	return diagram;
+}
+function requireName(name) {
+	if (name === null || name === void 0 || name.trim() === "") throw new GraphQLError("A name is required");
+	return name.trim();
+}
+function findServiceFile(db, serviceId) {
+	return db.serviceFiles.find((s) => s.serviceId === serviceId) ?? notFound("Service", serviceId);
+}
+function findDatabase(db, serviceId, id) {
+	return db.databases.find((d) => d.serviceDb.serviceId === serviceId && d.serviceDb.id === id) ?? notFound("Database", id);
+}
+function toQueryInput(input) {
+	const queryText = input.queryText?.trim() ?? "";
+	if (queryText === "") throw new GraphQLError("The query text is required");
+	return {
+		name: requireName(input.title),
+		description: input.description?.trim() ?? "",
+		queryText,
+		tags: input.tags ?? []
+	};
+}
+async function findSavedQuery(id) {
+	const { workspace } = await loadWorkspace();
+	return workspace.queries.find((q) => q.savedQuery.id === id)?.savedQuery ?? notFound("Query", id);
+}
+const COMPONENTS = [
+	{
+		componentId: COMPONENT_API_CONTRACT_ID,
+		name: "API Contract",
+		description: "Link an API operation of a service"
+	},
+	{
+		componentId: COMPONENT_FLOW_DIAGRAM_ID,
+		name: "Flow Diagram",
+		description: "Link an architecture diagram of a service"
+	},
+	{
+		componentId: COMPONENT_SUPPORT_KB_ID,
+		name: "Documentation",
+		description: "Link a doc of a service"
+	}
+].map((component, order) => ({
+	...component,
+	type: "link",
+	category: "Links",
+	tags: [],
+	slug: component.componentId,
+	previewImageJpg: "",
+	isActive: true,
+	order,
+	componentFields: [],
+	createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+	updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+}));
+function findMap(db, id) {
+	return db.maps.find((m) => m.map.id === id) ?? notFound("Map", id);
+}
+function findFrame(db, mapId, id) {
+	const map = findMap(db, mapId);
+	return {
+		map,
+		frame: map.frames.find((f) => f.frame.id === id) ?? notFound("Frame", id)
+	};
+}
+function findFocalPoint(db, mapId, frameId, id) {
+	const { map, frame } = findFrame(db, mapId, frameId);
+	return {
+		map,
+		frame,
+		focalPoint: frame.focalPoints.find((p) => p.point.id === id) ?? notFound("Focal point", id)
+	};
+}
+function requireSlug(name) {
+	if (slugify(name) === "") throw new GraphQLError("The name must contain a letter or digit");
+	return name;
+}
+function assertMapNameFree(db, name, exceptId) {
+	if (db.maps.some((m) => m.map.id !== exceptId && slugify(m.entry.name) === slugify(name))) throw new GraphQLError(`Another map is named "${name}"`);
+}
+function frameIn(entry, name) {
+	return entry.frames?.find((f) => f.name === name) ?? notFound("Frame", name);
+}
+function pointIn(frame, name) {
+	return frame.focalPoints?.find((p) => p.name === name) ?? notFound("Focal point", name);
+}
+function editMapOf(map, edit) {
+	return editMap(map.project.root, map.project.configFile, map.file, map.entry.name, edit);
+}
+function editFrameCanvas(map, frameName, edit) {
+	return editCanvas(map.project.root, (canvas) => {
+		const mapCanvas = canvas[map.entry.name] ??= {};
+		const frames = mapCanvas.frames ??= {};
+		edit(frames[frameName] ??= {});
+	});
+}
+function itemAt(items, id, kind) {
+	const index = Number(id.slice(id.lastIndexOf("--") + 2).slice(1));
+	if (items?.[index] === void 0) notFound(kind, id);
+	return {
+		items,
+		index
+	};
+}
+function toCanvas(map) {
+	const positions = Object.fromEntries(map.frames.flatMap(({ name, frame }) => {
+		const position = map.canvas.framePositions?.[name];
+		return position === void 0 ? [] : [[frame.id, position]];
+	}));
+	return {
+		mapId: map.map.id,
+		orgId: ORG_ID,
+		zoom: map.canvas.zoom ?? 1,
+		navigationX: map.canvas.navigationX ?? 0,
+		navigationY: map.canvas.navigationY ?? 0,
+		framePositions: JSON.stringify(positions),
+		updatedAt: map.map.updatedAt
+	};
+}
+function serviceName(db, serviceId) {
+	return (db.services.find((s) => s.id === serviceId) ?? notFound("Service", serviceId)).name;
+}
+function toLinkTarget(db, input) {
+	if (input.kind === "frame") {
+		for (const map of db.maps) {
+			const frame = map.frames.find((f) => f.frame.id === input.targetFrameId);
+			if (frame !== void 0) return {
+				map: map.entry.name,
+				frame: frame.name
+			};
+		}
+		return notFound("Frame", String(input.targetFrameId));
+	}
+	if (input.kind === "map") return { map: findMap(db, String(input.targetMapId)).entry.name };
+	throw new GraphQLError(`Unsupported link kind: ${input.kind}`);
+}
+function toModalFields(fields) {
+	return fields.map((field) => {
+		if (!field.componentFieldId) throw new GraphQLError("Every component field needs a componentFieldId");
+		return {
+			componentFieldId: field.componentFieldId,
+			...field.label ? { label: field.label } : {},
+			...field.type ? { type: field.type } : {},
+			...field.data ? { data: field.data } : {}
+		};
+	});
+}
+function toComponentRef(db, componentId, input) {
+	if (input.componentLinkTestPackId) throw new GraphQLError("Test packs are not available in uigraph");
+	const ref = { componentId };
+	if (input.componentLinkApiEndpointId) {
+		const id = input.componentLinkApiEndpointId;
+		const group = db.apiGroups.find(({ endpoints }) => endpoints.some((e) => e.id === id)) ?? notFound("Endpoint", id);
+		const endpoint = group.endpoints.find((e) => e.id === id) ?? notFound("Endpoint", id);
+		if (endpoint.operationId === "") throw new GraphQLError(`${endpoint.method} ${endpoint.path} has no operationId, so it cannot be linked`);
+		ref.serviceName = serviceName(db, group.group.serviceId);
+		ref.apiGroupName = group.group.name;
+		ref.operationId = endpoint.operationId;
+	} else if (input.componentLinkDiagramId) {
+		const link = db.serviceDiagrams.find((l) => l.diagramId === input.componentLinkDiagramId);
+		if (link === void 0) throw new GraphQLError("Only service diagrams can be linked to a focal point");
+		ref.serviceName = serviceName(db, link.serviceId);
+		ref.architectureDiagramName = link.diagram.name;
+	} else if (input.componentLinkServiceDocId) {
+		const doc = db.docs.find((d) => d.serviceDoc.docId === input.componentLinkServiceDocId) ?? notFound("Doc", input.componentLinkServiceDocId);
+		ref.serviceName = serviceName(db, doc.serviceDoc.serviceId);
+		ref.docName = doc.entry.name;
+	} else throw new GraphQLError("Choose the API operation, diagram or doc to link");
+	if (input.componentModalFields && input.componentModalFields.length > 0) ref.modalFields = toModalFields(input.componentModalFields);
+	return ref;
+}
+function createRootValue(db) {
+	const diagrams = db.diagrams.map((d) => d.entity);
+	return {
+		me: () => ({
+			userId: "local-user",
+			orgId: ORG_ID,
+			email: "",
+			name: os.userInfo().username,
+			login: "local",
+			kind: "user",
+			isServerAdmin: false,
+			authProvider: "local",
+			avatarUrl: null
+		}),
+		myOrgs: () => [{
+			id: ORG_ID,
+			name: db.name,
+			logoUrl: null,
+			role: "editor",
+			active: true,
+			onboardingDone: true
+		}],
+		features: () => ({
+			github: false,
+			slack: false,
+			enterprise: false,
+			billingUrl: null
+		}),
+		teams: () => [],
+		members: () => [],
+		comments: () => [],
+		serviceDBs: ({ serviceId }) => db.databases.filter((d) => d.serviceDb.serviceId === serviceId).map((d) => d.serviceDb),
+		serviceDB: ({ serviceId, id }) => findDatabase(db, serviceId, id).serviceDb,
+		savedQueries: ({ serviceDbId, scope }) => scope === "TEAM" ? db.queries.filter((q) => q.savedQuery.serviceDbId === serviceDbId).map((q) => q.savedQuery) : [],
+		createSavedQuery: async ({ serviceId, serviceDbId, input }) => {
+			const database = findDatabase(db, serviceId, serviceDbId);
+			return findSavedQuery(await createQuery(database.project.root, database.project.configFile, serviceDbId, toQueryInput(input)));
+		},
+		updateSavedQuery: async ({ serviceId, serviceDbId, id, input }) => {
+			const database = findDatabase(db, serviceId, serviceDbId);
+			return findSavedQuery(await updateQuery(database.project.root, database.project.configFile, id, toQueryInput(input)));
+		},
+		deleteSavedQuery: async ({ serviceId, serviceDbId, id }) => {
+			const database = findDatabase(db, serviceId, serviceDbId);
+			await deleteQuery(database.project.root, database.project.configFile, id);
+			return true;
+		},
+		createServiceDB: async ({ serviceId, input }) => {
+			const name = requireName(input.dbName);
+			if (!input.schemaContent) throw new GraphQLError("A schema file is required");
+			const link = findServiceFile(db, serviceId);
+			const schemaPath = await createDatabase(link.project.root, link.project.configFile, link.file, {
+				name,
+				dialect: input.dialect ?? ""
+			}, input.schemaContent);
+			const { workspace } = await loadWorkspace();
+			return workspace.databases.find((d) => d.project.root === link.project.root && d.entry.schemaPath === schemaPath)?.serviceDb ?? notFound("Database", schemaPath);
+		},
+		deleteServiceDB: async ({ serviceId, id }) => {
+			const database = findDatabase(db, serviceId, id);
+			await deleteDatabase(database.project.root, database.project.configFile, database.file, database.entry.name);
+			return true;
+		},
+		componentLinkUsages: () => [],
+		maps: (args) => {
+			if (args.folderId || args.teamId) return {
+				items: [],
+				totalCount: 0
+			};
+			return page(db.maps.map((m) => m.map), args);
+		},
+		map: ({ id }) => findMap(db, id).map,
+		frames: (args) => page(findMap(db, args.mapId).frames.map((f) => f.frame), args),
+		frame: ({ mapId, id }) => findFrame(db, mapId, id).frame.frame,
+		frameById: ({ id }) => db.maps.flatMap((m) => m.frames).find((f) => f.frame.id === id)?.frame ?? notFound("Frame", id),
+		focalPoints: ({ mapId, frameId }) => findFrame(db, mapId, frameId).frame.focalPoints.map((p) => p.point),
+		focalPointMeta: (args) => findFocalPoint(db, args.mapId, args.frameId, args.focalPointId).focalPoint.components.map((c) => c.meta),
+		frameGroups: ({ mapId, frameId }) => findFrame(db, mapId, frameId).frame.groups,
+		frameLinks: ({ mapId, frameId }) => findFrame(db, mapId, frameId).frame.links.map((l) => l.link),
+		canvas: ({ mapId }) => toCanvas(findMap(db, mapId)),
+		createMap: async ({ input }) => {
+			const name = requireSlug(requireName(input.name));
+			if (!input.serviceId) throw new GraphQLError("Choose the service whose repository stores this map");
+			assertMapNameFree(db, name);
+			const link = findServiceFile(db, input.serviceId);
+			await createMap(link.project.root, link.project.configFile, link.file, {
+				name,
+				description: input.description?.trim() ?? ""
+			});
+			const { workspace } = await loadWorkspace();
+			return workspace.maps.find((m) => m.project.root === link.project.root && m.entry.name === name)?.map ?? notFound("Map", name);
+		},
+		updateMap: async ({ id, input }) => {
+			const map = findMap(db, id);
+			const oldName = map.entry.name;
+			const name = input.name === null || input.name === void 0 ? oldName : requireSlug(requireName(input.name));
+			assertMapNameFree(db, name, id);
+			await editMapOf(map, (entry) => {
+				entry.name = name;
+				if (input.description !== null && input.description !== void 0) {
+					const description = input.description.trim();
+					if (description === "") delete entry.description;
+					else entry.description = description;
+				}
+				return entry;
+			});
+			if (name !== oldName) {
+				await editCanvas(map.project.root, (canvas) => {
+					if (canvas[oldName] !== void 0) {
+						canvas[name] = canvas[oldName];
+						delete canvas[oldName];
+					}
+				});
+				for (const project of db.projects) await retargetLinks(project.root, { map: oldName }, { map: name });
+			}
+			const { workspace } = await loadWorkspace();
+			return workspace.maps.find((m) => m.project.root === map.project.root && m.entry.name === name)?.map ?? notFound("Map", name);
+		},
+		deleteMap: async ({ id }) => {
+			const map = findMap(db, id);
+			await editMapOf(map, () => null);
+			await deleteUnusedImages(map.project.root, map.project.configFile, map.frames.flatMap((f) => f.frame.screenshotAssetId ?? []));
+			await editCanvas(map.project.root, (canvas) => {
+				delete canvas[map.entry.name];
+			});
+			for (const project of db.projects) await retargetLinks(project.root, { map: map.entry.name }, null);
+			return true;
+		},
+		createFrame: async ({ mapId, input }) => {
+			const map = findMap(db, mapId);
+			const name = requireSlug(requireName(input.name));
+			if (map.frames.some((f) => slugify(f.name) === slugify(name))) throw new GraphQLError(`Another frame in this map is named "${name}"`);
+			const imagePath = input.screenshotAssetId ? await writeFrameImage(map.project.root, map.entry.name, name, takeUpload(input.screenshotAssetId)) : void 0;
+			const description = input.description?.trim() ?? "";
+			await editMapOf(map, (entry) => {
+				entry.frames = [...entry.frames ?? [], {
+					name,
+					...description === "" ? {} : { description },
+					...imagePath === void 0 ? {} : { imagePath }
+				}];
+				return entry;
+			});
+			const { workspace } = await loadWorkspace();
+			return findMap(workspace, mapId).frames.find((f) => f.name === name)?.frame ?? notFound("Frame", name);
+		},
+		updateFrame: async ({ mapId, id, input }) => {
+			if (input.order !== null && input.order !== void 0) throw new GraphQLError("Reordering frames is not supported");
+			const { map, frame } = findFrame(db, mapId, id);
+			const oldName = frame.name;
+			const name = input.name === null || input.name === void 0 ? oldName : requireSlug(requireName(input.name));
+			if (map.frames.some((f) => f !== frame && slugify(f.name) === slugify(name))) throw new GraphQLError(`Another frame in this map is named "${name}"`);
+			const oldImage = frame.frame.screenshotAssetId;
+			const imagePath = input.screenshotAssetId ? await writeFrameImage(map.project.root, map.entry.name, name, takeUpload(input.screenshotAssetId)) : void 0;
+			await editMapOf(map, (entry) => {
+				const target = frameIn(entry, oldName);
+				target.name = name;
+				if (input.description !== null && input.description !== void 0) {
+					const description = input.description.trim();
+					if (description === "") delete target.description;
+					else target.description = description;
+				}
+				if (imagePath !== void 0) target.imagePath = imagePath;
+				return entry;
+			});
+			if (imagePath !== void 0 && oldImage !== null) await deleteUnusedImages(map.project.root, map.project.configFile, [oldImage]);
+			if (name !== oldName) {
+				await editCanvas(map.project.root, (canvas) => {
+					const mapCanvas = canvas[map.entry.name];
+					for (const record of [mapCanvas?.framePositions, mapCanvas?.frames]) if (record?.[oldName] !== void 0) {
+						record[name] = record[oldName];
+						delete record[oldName];
+					}
+				});
+				for (const project of db.projects) await retargetLinks(project.root, {
+					map: map.entry.name,
+					frame: oldName
+				}, {
+					map: map.entry.name,
+					frame: name
+				});
+			}
+			const { workspace } = await loadWorkspace();
+			return findMap(workspace, mapId).frames.find((f) => f.name === name)?.frame ?? notFound("Frame", name);
+		},
+		deleteFrame: async ({ mapId, id }) => {
+			const { map, frame } = findFrame(db, mapId, id);
+			await editMapOf(map, (entry) => {
+				entry.frames = entry.frames?.filter((f) => f.name !== frame.name);
+				return entry;
+			});
+			if (frame.frame.screenshotAssetId !== null) await deleteUnusedImages(map.project.root, map.project.configFile, [frame.frame.screenshotAssetId]);
+			await editCanvas(map.project.root, (canvas) => {
+				delete canvas[map.entry.name]?.framePositions?.[frame.name];
+				delete canvas[map.entry.name]?.frames?.[frame.name];
+			});
+			for (const project of db.projects) await retargetLinks(project.root, {
+				map: map.entry.name,
+				frame: frame.name
+			}, null);
+			return true;
+		},
+		createFocalPoint: async ({ mapId, frameId, input }) => {
+			const { map, frame } = findFrame(db, mapId, frameId);
+			const name = requireName(input.name);
+			if (input.locationX === null || input.locationX === void 0) throw new GraphQLError("A focal point needs a location");
+			if (input.locationY === null || input.locationY === void 0) throw new GraphQLError("A focal point needs a location");
+			const x = input.locationX;
+			const y = input.locationY;
+			await editMapOf(map, (entry) => {
+				const target = frameIn(entry, frame.name);
+				if (target.focalPoints?.some((p) => p.name === name)) throw new GraphQLError(`Another focal point is named "${name}"`);
+				target.focalPoints = [...target.focalPoints ?? [], {
+					name,
+					x,
+					y,
+					visibility: input.visibility ?? "public",
+					...input.color ? { color: input.color } : {}
+				}];
+				return entry;
+			});
+			const { workspace } = await loadWorkspace();
+			return findFrame(workspace, mapId, frameId).frame.focalPoints.find((p) => p.point.name === name)?.point ?? notFound("Focal point", name);
+		},
+		updateFocalPoint: async ({ mapId, frameId, id, input }) => {
+			const { map, frame, focalPoint } = findFocalPoint(db, mapId, frameId, id);
+			const oldName = focalPoint.point.name;
+			const name = input.name === null || input.name === void 0 ? oldName : requireName(input.name);
+			await editMapOf(map, (entry) => {
+				const target = frameIn(entry, frame.name);
+				if (name !== oldName && target.focalPoints?.some((p) => p.name === name)) throw new GraphQLError(`Another focal point is named "${name}"`);
+				const point = pointIn(target, oldName);
+				point.name = name;
+				if (input.locationX !== null && input.locationX !== void 0) point.x = input.locationX;
+				if (input.locationY !== null && input.locationY !== void 0) point.y = input.locationY;
+				if (input.visibility) point.visibility = input.visibility;
+				if (input.color) point.color = input.color;
+				return entry;
+			});
+			const { workspace } = await loadWorkspace();
+			return findFocalPoint(workspace, mapId, frameId, id).focalPoint.point;
+		},
+		deleteFocalPoint: async ({ mapId, frameId, id }) => {
+			const { map, frame, focalPoint } = findFocalPoint(db, mapId, frameId, id);
+			await editMapOf(map, (entry) => {
+				const target = frameIn(entry, frame.name);
+				target.focalPoints = target.focalPoints?.filter((p) => p.name !== focalPoint.point.name);
+				return entry;
+			});
+			return true;
+		},
+		upsertCanvas: async ({ mapId, input }) => {
+			const map = findMap(db, mapId);
+			const positions = input.framePositions === null || input.framePositions === void 0 ? void 0 : Object.fromEntries(Object.entries(JSON.parse(input.framePositions)).map(([frameId, position]) => [(map.frames.find((f) => f.frame.id === frameId) ?? notFound("Frame", frameId)).name, {
+				x: position.x,
+				y: position.y
+			}]));
+			await editCanvas(map.project.root, (canvas) => {
+				const mapCanvas = canvas[map.entry.name] ??= {};
+				if (input.zoom !== null && input.zoom !== void 0) mapCanvas.zoom = input.zoom;
+				if (input.navigationX !== null && input.navigationX !== void 0) mapCanvas.navigationX = input.navigationX;
+				if (input.navigationY !== null && input.navigationY !== void 0) mapCanvas.navigationY = input.navigationY;
+				if (positions !== void 0) mapCanvas.framePositions = positions;
+			});
+			const { workspace } = await loadWorkspace();
+			return toCanvas(findMap(workspace, mapId));
+		},
+		createFrameGroup: async ({ mapId, frameId, input }) => {
+			const { map, frame } = findFrame(db, mapId, frameId);
+			const name = requireName(input.name);
+			await editFrameCanvas(map, frame.name, (frameCanvas) => {
+				frameCanvas.groups = [...frameCanvas.groups ?? [], {
+					name,
+					description: input.description?.trim() ?? "",
+					x: input.locationX ?? 0,
+					y: input.locationY ?? 0,
+					width: input.width ?? 0,
+					height: input.height ?? 0
+				}];
+			});
+			const { workspace } = await loadWorkspace();
+			return findFrame(workspace, mapId, frameId).frame.groups.at(-1);
+		},
+		updateFrameGroup: async ({ mapId, frameId, id, input }) => {
+			const { map, frame } = findFrame(db, mapId, frameId);
+			await editFrameCanvas(map, frame.name, (frameCanvas) => {
+				const { items, index } = itemAt(frameCanvas.groups, id, "Frame group");
+				const group = items[index];
+				items[index] = {
+					name: input.name === null || input.name === void 0 ? group.name : requireName(input.name),
+					description: input.description?.trim() ?? group.description,
+					x: input.locationX ?? group.x,
+					y: input.locationY ?? group.y,
+					width: input.width ?? group.width,
+					height: input.height ?? group.height
+				};
+			});
+			const { workspace } = await loadWorkspace();
+			return findFrame(workspace, mapId, frameId).frame.groups.find((g) => g.id === id) ?? notFound("Frame group", id);
+		},
+		deleteFrameGroup: async ({ mapId, frameId, id }) => {
+			const { map, frame } = findFrame(db, mapId, frameId);
+			await editFrameCanvas(map, frame.name, (frameCanvas) => {
+				const { items, index } = itemAt(frameCanvas.groups, id, "Frame group");
+				items.splice(index, 1);
+			});
+			return true;
+		},
+		createFrameLink: async ({ mapId, frameId, input }) => {
+			const { map, frame } = findFrame(db, mapId, frameId);
+			const target = toLinkTarget(db, input);
+			await editFrameCanvas(map, frame.name, (frameCanvas) => {
+				frameCanvas.links = [...frameCanvas.links ?? [], {
+					kind: input.kind === "frame" ? "frame" : "map",
+					...target,
+					label: input.label ?? "",
+					x: input.locationX ?? 0,
+					y: input.locationY ?? 0
+				}];
+			});
+			const { workspace } = await loadWorkspace();
+			return findFrame(workspace, mapId, frameId).frame.links.at(-1)?.link;
+		},
+		updateFrameLink: async ({ mapId, frameId, id, input }) => {
+			const { map, frame } = findFrame(db, mapId, frameId);
+			const target = input.kind === null || input.kind === void 0 ? void 0 : toLinkTarget(db, input);
+			await editFrameCanvas(map, frame.name, (frameCanvas) => {
+				const { items, index } = itemAt(frameCanvas.links, id, "Frame link");
+				const link = items[index];
+				items[index] = {
+					kind: target === void 0 ? link.kind : input.kind === "frame" ? "frame" : "map",
+					...target === void 0 ? {
+						map: link.map,
+						frame: link.frame
+					} : target,
+					label: input.label ?? link.label,
+					x: input.locationX ?? link.x,
+					y: input.locationY ?? link.y
+				};
+			});
+			const { workspace } = await loadWorkspace();
+			return findFrame(workspace, mapId, frameId).frame.links.find((l) => l.link.id === id)?.link ?? notFound("Frame link", id);
+		},
+		deleteFrameLink: async ({ mapId, frameId, id }) => {
+			const { map, frame } = findFrame(db, mapId, frameId);
+			await editFrameCanvas(map, frame.name, (frameCanvas) => {
+				const { items, index } = itemAt(frameCanvas.links, id, "Frame link");
+				items.splice(index, 1);
+			});
+			return true;
+		},
+		createFocalPointMeta: async ({ mapId, frameId, focalPointId, input }) => {
+			const { map, frame, focalPoint } = findFocalPoint(db, mapId, frameId, focalPointId);
+			const ref = toComponentRef(db, requireName(input.componentId), input);
+			await editMapOf(map, (entry) => {
+				const point = pointIn(frameIn(entry, frame.name), focalPoint.point.name);
+				point.components = [...point.components ?? [], ref];
+				return entry;
+			});
+			const { workspace } = await loadWorkspace();
+			return findFocalPoint(workspace, mapId, frameId, focalPointId).focalPoint.components.at(-1)?.meta;
+		},
+		updateFocalPointMeta: async ({ mapId, frameId, focalPointId, id, input }) => {
+			if (input.componentLinkDiagramId || input.componentLinkApiEndpointId || input.componentLinkTestPackId || input.componentLinkServiceDocId) throw new GraphQLError("Only the fields of a component can be updated");
+			const { map, frame, focalPoint } = findFocalPoint(db, mapId, frameId, focalPointId);
+			await editMapOf(map, (entry) => {
+				const { items, index } = itemAt(pointIn(frameIn(entry, frame.name), focalPoint.point.name).components, id, "Component");
+				const component = items[index];
+				if (input.componentId && input.componentId !== component.componentId) throw new GraphQLError("The component of a link cannot be changed");
+				if (input.componentModalFields === null || input.componentModalFields === void 0 || input.componentModalFields.length === 0) delete component.modalFields;
+				else component.modalFields = toModalFields(input.componentModalFields);
+				return entry;
+			});
+			const { workspace } = await loadWorkspace();
+			return findFocalPoint(workspace, mapId, frameId, focalPointId).focalPoint.components.find((c) => c.meta.id === id)?.meta ?? notFound("Component", id);
+		},
+		deleteFocalPointMeta: async ({ mapId, frameId, focalPointId, id }) => {
+			const { map, frame, focalPoint } = findFocalPoint(db, mapId, frameId, focalPointId);
+			await editMapOf(map, (entry) => {
+				const point = pointIn(frameIn(entry, frame.name), focalPoint.point.name);
+				const { items, index } = itemAt(point.components, id, "Component");
+				items.splice(index, 1);
+				if (items.length === 0) delete point.components;
+				return entry;
+			});
+			return true;
+		},
+		serviceGitHubRepository: () => null,
+		githubApp: () => null,
+		diagramImages: async ({ diagramId }) => {
+			const diagram = db.diagrams.find((d) => d.entity.id === diagramId) ?? notFound("Diagram", diagramId);
+			return (await listDiagramImages(diagram.project.root, diagram.entry.path)).map(({ imagePath, createdAt }, order) => toDiagramImage(diagram.project.id, diagramId, imagePath, createdAt, order));
+		},
+		diagramVersions: () => [],
+		diagramVersionContent: ({ versionId }) => notFound("Diagram version", versionId),
+		components: () => ({
+			components: COMPONENTS,
+			customComponents: []
+		}),
+		services: (args) => {
+			if (args.folderId || args.teamId) return {
+				items: [],
+				totalCount: 0
+			};
+			return page(db.services, args);
+		},
+		service: ({ id }) => db.services.find((s) => s.id === id) ?? notFound("Service", id),
+		apiGroups: ({ serviceId }) => db.apiGroups.filter(({ group }) => group.serviceId === serviceId).map(({ group }) => group),
+		apiGroup: ({ serviceId, id }) => findApiGroup(db, serviceId, id).group,
+		apiGroupVersions: (args) => [findApiGroup(db, args.serviceId, args.apiGroupId).version],
+		apiEndpoints: (args) => findApiGroup(db, args.serviceId, args.apiGroupId).endpoints,
+		apiEndpointById: ({ id }) => db.apiGroups.flatMap(({ endpoints }) => endpoints).find((e) => e.id === id) ?? notFound("Endpoint", id),
+		apiGroupSpec: (args) => {
+			const { group, spec } = findApiGroup(db, args.serviceId, args.apiGroupId);
+			if (spec === null) throw new GraphQLError(`${group.name} has no spec file`);
+			return {
+				apiGroupId: group.id,
+				...spec
+			};
+		},
+		dependencies: (args) => db.dependencies.filter((row) => row.service.id === args.serviceId && (!args.direction || args.direction === "all" || row.direction === args.direction) && (!args.criticality || row.criticality === args.criticality)),
+		dependencyGraph: () => db.dependencies,
+		serviceDependencyGraph: ({ serviceId }) => {
+			const seen = /* @__PURE__ */ new Set();
+			return [...walkDependencies(db, serviceId, "upstream"), ...walkDependencies(db, serviceId, "downstream")].filter((row) => {
+				if (seen.has(row.id)) return false;
+				seen.add(row.id);
+				return true;
+			});
+		},
+		diagrams: (args) => {
+			if (args.folderId || args.teamId) return {
+				items: [],
+				totalCount: 0
+			};
+			const { serviceDiagrams } = db;
+			return page(args.serviceId ? serviceDiagrams.filter((link) => link.serviceId === args.serviceId).map((link) => link.diagram) : diagrams, args);
+		},
+		diagram: ({ id }) => diagrams.find((d) => d.id === id) ?? db.databases.find((d) => d.diagram.id === id)?.diagram ?? notFound("Diagram", id),
+		serviceDocs: ({ serviceId }) => db.docs.filter((d) => d.serviceDoc.serviceId === serviceId).map((d) => d.serviceDoc),
+		serviceDocById: ({ id }) => db.docs.find((d) => d.serviceDoc.docId === id)?.serviceDoc ?? notFound("Doc", id),
+		doc: ({ id }) => db.docs.find((d) => d.serviceDoc.docId === id)?.serviceDoc.doc ?? db.standaloneDocs.find((d) => d.doc.id === id)?.doc ?? notFound("Doc", id),
+		docs: (args) => {
+			if (args.folderId || args.teamId) return {
+				items: [],
+				totalCount: 0
+			};
+			return page([...db.docs.map((d) => d.serviceDoc.doc), ...db.standaloneDocs.map((d) => d.doc)].map((doc) => ({
+				...doc,
+				name: doc.fileName
+			})), args);
+		},
+		createDoc: async ({ input }) => {
+			const name = requireName(input.fileName);
+			if (!input.fileAssetId) throw new GraphQLError("Upload a file first");
+			await ensureWorkspaceConfig(db.home);
+			const docPath = await createDoc(db.home, WORKSPACE_CONFIG, WORKSPACE_CONFIG, {
+				name,
+				fileType: input.fileType ?? "",
+				description: input.description?.trim() ?? ""
+			}, takeUpload(input.fileAssetId).data);
+			const { workspace } = await loadWorkspace();
+			return workspace.standaloneDocs.find((d) => d.project.root === db.home && d.entry.path === docPath)?.doc ?? notFound("Doc", docPath);
+		},
+		deleteDoc: async ({ id }) => {
+			const doc = db.docs.find((d) => d.serviceDoc.docId === id) ?? db.standaloneDocs.find((d) => d.doc.id === id) ?? notFound("Doc", id);
+			await deleteDoc(doc.project.root, doc.project.configFile, doc.file, doc.entry.name);
+			return true;
+		},
+		createAssetUpload: () => createUpload(),
+		createDiagramImage: async ({ diagramId, input }) => {
+			const diagram = db.diagrams.find((d) => d.entity.id === diagramId) ?? notFound("Diagram", diagramId);
+			const imagePath = await writeDiagramImage(diagram.project.root, diagram.entry.path, requireName(input.fileName), takeUpload(input.assetId));
+			const images = await listDiagramImages(diagram.project.root, diagram.entry.path);
+			const order = images.findIndex((image) => image.imagePath === imagePath);
+			return toDiagramImage(diagram.project.id, diagramId, imagePath, images[order].createdAt, order);
+		},
+		createServiceDoc: async ({ serviceId, input }) => {
+			const name = requireName(input.fileName);
+			if (!input.fileAssetId) throw new GraphQLError("Upload a file first");
+			const link = findServiceFile(db, serviceId);
+			const docPath = await createDoc(link.project.root, link.project.configFile, link.file, {
+				name,
+				fileType: input.fileType ?? "",
+				description: input.description?.trim() ?? ""
+			}, takeUpload(input.fileAssetId).data);
+			const { workspace } = await loadWorkspace();
+			return workspace.docs.find((d) => d.project.root === link.project.root && d.entry.path === docPath)?.serviceDoc ?? notFound("Doc", docPath);
+		},
+		deleteServiceDoc: async ({ serviceId, docId }) => {
+			const doc = db.docs.find((d) => d.serviceDoc.serviceId === serviceId && d.serviceDoc.docId === docId) ?? notFound("Doc", docId);
+			await deleteDoc(doc.project.root, doc.project.configFile, doc.file, doc.entry.name);
+			return true;
+		},
+		serviceDiagrams: ({ serviceId }) => db.serviceDiagrams.filter((link) => link.serviceId === serviceId),
+		updateDiagram: async ({ id, input }) => {
+			const diagram = db.diagrams.find((d) => d.entity.id === id) ?? notFound("Diagram", id);
+			const saved = await saveDiagram(diagram.project.root, diagram.project.configFile, diagram.localId, input);
+			const link = db.serviceDiagrams.find((l) => l.diagramId === id);
+			const service = db.services.find((s) => s.id === link?.serviceId);
+			const oldName = diagram.entry.name;
+			const newName = saved.name;
+			if (service !== void 0 && newName !== oldName) for (const project of db.projects) await renameDiagramReferences(project.root, project.configFiles, service.name, oldName, newName);
+			return {
+				...saved,
+				id
+			};
+		},
+		createDiagram: async ({ input }) => {
+			const name = requireName(input.name);
+			await ensureWorkspaceConfig(db.home);
+			const localId = await createDiagram(db.home, WORKSPACE_CONFIG, WORKSPACE_CONFIG, name);
+			return (await findCreatedDiagram(db.home, localId)).entity;
+		},
+		createServiceDiagram: async ({ serviceId, input }) => {
+			const name = requireName(input.name);
+			const link = findServiceFile(db, serviceId);
+			const localId = await createDiagram(link.project.root, link.project.configFile, link.file, name);
+			const diagram = await findCreatedDiagram(link.project.root, localId);
+			return {
+				serviceId,
+				diagramId: diagram.entity.id,
+				orgId: ORG_ID,
+				createdBy: diagram.entity.createdBy,
+				updatedBy: null,
+				createdAt: diagram.entity.createdAt,
+				updatedAt: diagram.entity.updatedAt,
+				diagram: diagram.entity
+			};
+		},
+		deleteDiagram: async ({ id }) => {
+			const diagram = db.diagrams.find((d) => d.entity.id === id) ?? notFound("Diagram", id);
+			await deleteDiagram(diagram.project.root, diagram.project.configFile, diagram.localId);
+			return true;
+		},
+		deleteService: async ({ id }) => {
+			const link = findServiceFile(db, id);
+			if (link.project.configFile === ".uigraph/workspace.yaml") throw new GraphQLError(`Services defined in ${WORKSPACE_CONFIG} cannot be removed`);
+			await unregisterProject(link.project.root);
+			return true;
+		}
+	};
+}
+//#endregion
+//#region src/lens.ts
+var LensRequestError = class extends Error {};
+const activeRuns = /* @__PURE__ */ new Map();
+async function dataDirectory() {
+	return path.join(await homeRoot(), ".uigraph", "lens");
+}
+async function resolveGitHubToken() {
+	const environmentToken = process.env.GITHUB_TOKEN?.trim() || process.env.GH_TOKEN?.trim();
+	if (environmentToken) return environmentToken;
+	const token = await promisify(execFile)("gh", ["auth", "token"], { timeout: 1e4 }).then(({ stdout }) => stdout.trim(), () => "");
+	if (token === "") throw new LensRequestError("GitHub authentication is required. Set GITHUB_TOKEN or GH_TOKEN, or sign in with `gh auth login`, then restart the viewer.");
+	return token;
+}
+async function startLensRun(request, regenerate, agent, model) {
+	if (agent === void 0 && model !== void 0) throw new LensRequestError("A model can only be set together with an agent.");
+	let review;
+	let source;
+	try {
+		if (request.type === "github") {
+			const token = await resolveGitHubToken();
+			review = await fetchReview({
+				pullRequest: request.pullRequest,
+				token
+			});
+			source = {
+				type: "github",
+				token
+			};
+		} else {
+			const local = await readLocalReview(request);
+			review = local.review;
+			source = {
+				type: "local",
+				repositoryPath: local.repositoryPath
+			};
+		}
+	} catch (error) {
+		throw new LensRequestError(error instanceof Error ? error.message : String(error));
+	}
+	const label = review.pullRequest.number === null ? `${review.repository.fullName} ${review.pullRequest.base.branch}..${review.pullRequest.head.branch}` : `${review.repository.fullName}#${review.pullRequest.number}`;
+	const settings = await readSettings(await dataDirectory());
+	const stop = new AbortController();
+	const ticket = { answer: null };
+	const states = analyzeReview({
+		review,
+		source,
+		dataDirectory: await dataDirectory(),
+		services: await readServiceGraph(),
+		settings: agent === void 0 ? settings : {
+			...settings,
+			agent,
+			model: model ?? ""
+		},
+		regenerate,
+		signal: stop.signal,
+		askTicket: () => new Promise((resolve) => {
+			ticket.answer = resolve;
+		}),
+		log: (message) => consola.debug(`Lens ${label} ${message}`)
+	});
+	const first = await states.next();
+	if (first.done) throw new Error("Lens ended without reporting any progress.");
+	const runId = first.value.runId;
+	const run = {
+		review,
+		analysis: first.value,
+		stop,
+		ticket,
+		subscribers: /* @__PURE__ */ new Set(),
+		finished: Promise.resolve()
+	};
+	activeRuns.set(runId, run);
+	console.log(`${pc.cyan("Lens")} ${label} ${pc.dim(runId)}`);
+	run.finished = (async () => {
+		try {
+			for await (const analysis of states) {
+				for (const [id, stage] of Object.entries(analysis.stages)) if (stage.status !== run.analysis.stages[id].status) consola.debug(`Lens ${label} ${id} ${stage.status}`);
+				run.analysis = analysis;
+				for (const subscriber of run.subscribers) subscriber.update(analysis);
+			}
+			console.log(`${pc.cyan("Lens")} ${label} finished ${pc.dim(runId)}`);
+		} catch (error) {
+			console.error(`${pc.red("Lens")} ${label} failed: ${error instanceof Error ? error.message : String(error)}`);
+			consola.debug(inspect(error));
+		} finally {
+			activeRuns.delete(runId);
+			for (const subscriber of run.subscribers) subscriber.end();
+		}
+	})();
+	return runId;
+}
+async function getLensSettings() {
+	return readSettings(await dataDirectory());
+}
+async function saveLensSettings(settings) {
+	await saveSettings(await dataDirectory(), settings);
+}
+function stopLensRun(runId) {
+	const run = activeRuns.get(runId);
+	if (!run) return false;
+	run.stop.abort();
+	return true;
+}
+function answerLensTicket(runId, keys) {
+	const run = activeRuns.get(runId);
+	const candidates = run?.analysis.ticketCandidates ?? null;
+	if (!run || run.ticket.answer === null || candidates === null) return false;
+	if (new Set(keys).size !== keys.length || !keys.every((key) => candidates.some((candidate) => candidate.key === key))) return false;
+	run.ticket.answer(keys);
+	run.ticket.answer = null;
+	return true;
+}
+async function stopAllLensRuns() {
+	const runs = [...activeRuns.values()];
+	for (const run of runs) run.stop.abort();
+	await Promise.all(runs.map((run) => run.finished));
+}
+async function listLensRuns() {
+	const saved = await listRuns(await dataDirectory());
+	return [...[...activeRuns.values()].map((run) => ({
+		...run,
+		running: true
+	})), ...saved.filter((run) => !activeRuns.has(run.analysis.runId)).map((run) => ({
+		...run,
+		running: false
+	}))].map((run) => ({
+		runId: run.analysis.runId,
+		repository: run.review.repository.fullName,
+		number: run.review.pullRequest.number,
+		title: run.review.pullRequest.title,
+		status: readStatus(run.analysis, run.running),
+		updatedAt: Object.values(run.analysis.stages).flatMap((stage) => [stage.startedAt, stage.completedAt]).reduce((latest, time) => time !== null && time > latest ? time : latest, run.review.fetchedAt)
+	})).sort((first, second) => second.updatedAt.localeCompare(first.updatedAt));
+}
+async function getLensRun(runId) {
+	const active = activeRuns.get(runId);
+	if (active) return {
+		review: active.review,
+		analysis: active.analysis,
+		running: true
+	};
+	const saved = await readRun(await dataDirectory(), runId);
+	if (!saved) return null;
+	return {
+		review: saved.review,
+		analysis: saved.analysis,
+		running: false
+	};
+}
+function subscribeToLensRun(runId, subscriber) {
+	const run = activeRuns.get(runId);
+	if (!run) return null;
+	run.subscribers.add(subscriber);
+	return () => {
+		run.subscribers.delete(subscriber);
+	};
+}
+function readStatus(analysis, running) {
+	if (running) return "running";
+	return Object.values(analysis.stages).every((stage) => stage.status === "done" || stage.status === "skipped") ? "done" : "failed";
+}
+async function readServiceGraph() {
+	const { workspace } = await loadWorkspace();
+	return {
+		services: workspace.services.map((service) => ({
+			name: service.name,
+			endpoints: workspace.apiGroups.filter(({ group }) => group.serviceId === service.id).flatMap(({ endpoints }) => endpoints.map((endpoint) => ({
+				method: endpoint.method,
+				path: endpoint.path,
+				operationId: endpoint.operationId
+			}))),
+			databases: workspace.databases.filter(({ serviceDb }) => serviceDb.serviceId === service.id).map(({ serviceDb }) => serviceDb.dbName),
+			diagrams: workspace.diagrams.filter(({ entity }) => workspace.serviceDiagrams.some((link) => link.serviceId === service.id && link.diagramId === entity.id)).map(({ entity, mermaid }) => ({
+				name: entity.name,
+				mermaid
+			})),
+			docs: workspace.docs.filter(({ serviceDoc }) => serviceDoc.serviceId === service.id).map(({ serviceDoc }) => ({
+				name: serviceDoc.doc.fileName,
+				description: serviceDoc.doc.description
+			}))
+		})),
+		links: workspace.dependencies.map((dependency) => {
+			const target = dependency.dependency?.name ?? dependency.dependencyName;
+			const link = {
+				type: dependency.type,
+				criticality: dependency.criticality,
+				endpoints: dependency.apiEndpointNames,
+				database: dependency.databaseName,
+				description: dependency.description
+			};
+			if (dependency.direction === "downstream") return {
+				consumer: dependency.service.name,
+				provider: target,
+				...link
+			};
+			if (dependency.direction === "upstream") return {
+				consumer: target,
+				provider: dependency.service.name,
+				...link
+			};
+			throw new Error(`Unknown dependency direction: ${String(dependency.direction)}`);
+		})
+	};
+}
+//#endregion
+//#region src/server.ts
+function resolveAssetRoot(bundled, source) {
+	const bundledRoot = fileURLToPath(new URL(bundled, import.meta.url));
+	return existsSync(bundledRoot) ? bundledRoot : fileURLToPath(new URL(source, import.meta.url));
+}
+const VIEWER_ROOT = resolveAssetRoot("./viewer/", "../dist/viewer/");
+const SCHEMA_ROOT = resolveAssetRoot("./schema/", "./graphql/schema/");
+const MAX_BODY_BYTES = 1e7;
+const SUPPORTED_MUTATIONS = [
+	"updateDiagram",
+	"createDiagram",
+	"createServiceDiagram",
+	"deleteDiagram",
+	"deleteService",
+	"createAssetUpload",
+	"createDiagramImage",
+	"createDoc",
+	"deleteDoc",
+	"createServiceDoc",
+	"deleteServiceDoc",
+	"createServiceDB",
+	"deleteServiceDB",
+	"createSavedQuery",
+	"updateSavedQuery",
+	"deleteSavedQuery",
+	"createMap",
+	"updateMap",
+	"deleteMap",
+	"createFrame",
+	"updateFrame",
+	"deleteFrame",
+	"createFocalPoint",
+	"updateFocalPoint",
+	"deleteFocalPoint",
+	"upsertCanvas",
+	"createFrameGroup",
+	"updateFrameGroup",
+	"deleteFrameGroup",
+	"createFrameLink",
+	"updateFrameLink",
+	"deleteFrameLink",
+	"createFocalPointMeta",
+	"updateFocalPointMeta",
+	"deleteFocalPointMeta"
+];
+const DEFAULT_PORT = 7357;
+const HEALTH_PATH = "/__uigraph";
+const INFO_PATH = "/__uigraph/info";
+const HEALTH_BODY = "uigraph";
+const HEALTH_TIMEOUT_MS = 1500;
+const LENS_RUN_PATH = /^\/api\/lens\/runs\/([\w-]+)(\/events|\/stop|\/ticket)?$/;
+const lensStartSchema = z.object({
+	request: z.discriminatedUnion("type", [z.object({
+		type: z.literal("github"),
+		pullRequest: z.string().min(1)
+	}), z.object({
+		type: z.literal("local"),
+		directory: z.string().min(1),
+		base: z.string().min(1),
+		target: z.string().min(1)
+	})]),
+	regenerate: z.boolean(),
+	agent: z.enum(AGENT_NAMES).optional(),
+	model: z.string().trim().min(1).max(200).optional()
+});
+const lensTicketSchema = z.object({ keys: z.array(z.string().min(1)) });
+function serverUrl(port) {
+	return `http://127.0.0.1:${port}/`;
+}
+var HttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+const schema = buildSchema(readdirSync(SCHEMA_ROOT).filter((file) => file.endsWith(".graphqls")).map((file) => readFileSync(path.join(SCHEMA_ROOT, file), "utf8")).join("\n"));
+const CONTENT_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".md": "text/markdown; charset=utf-8",
+	".markdown": "text/markdown; charset=utf-8",
+	".txt": "text/plain; charset=utf-8",
+	".pdf": "application/pdf",
+	".htm": "text/html; charset=utf-8",
+	".jpeg": "image/jpeg",
+	".mp4": "video/mp4",
+	".mov": "video/quicktime",
+	".webm": "video/webm",
+	".mp3": "audio/mpeg",
+	".wav": "audio/wav",
+	".ogg": "audio/ogg",
+	".m4a": "audio/mp4",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf"
+};
+async function listViewerAssets() {
+	const entries = await fs.readdir(VIEWER_ROOT, {
+		recursive: true,
+		withFileTypes: true
+	});
+	const assets = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (!entry.isFile()) continue;
+		const absolutePath = path.join(entry.parentPath, entry.name);
+		const urlPath = "/" + path.relative(VIEWER_ROOT, absolutePath).split(path.sep).join("/");
+		assets.set(urlPath, absolutePath);
+	}
+	if (!assets.has("/index.html")) throw new Error(`The prebuilt viewer is missing from ${VIEWER_ROOT}. Reinstall uigraph.`);
+	return assets;
+}
+function contentType(file) {
+	return CONTENT_TYPES[path.extname(file).toLowerCase()] ?? "application/octet-stream";
+}
+async function readBody(request, limit) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of request) {
+		size += chunk.length;
+		if (size > limit) throw new HttpError(413, "Request body is too large");
+		chunks.push(chunk);
+	}
+	return Buffer.concat(chunks);
+}
+const reportedWarnings = /* @__PURE__ */ new Set();
+async function runGraphQL(body) {
+	const request = JSON.parse(body);
+	const document = parse(request.query);
+	const validationErrors = validate(schema, document, [...specifiedRules, NoSchemaIntrospectionCustomRule]);
+	if (validationErrors.length > 0) return { errors: validationErrors };
+	const operation = getOperationAST(document, request.operationName);
+	if (operation === null || operation === void 0) return { errors: [new GraphQLError("No operation to execute")] };
+	if (operation.operation === "subscription") return { errors: [new GraphQLError("Not supported in uigraph")] };
+	if (operation.operation === "mutation" && !operation.selectionSet.selections.every((selection) => selection.kind === Kind.FIELD && SUPPORTED_MUTATIONS.includes(selection.name.value))) return { errors: [new GraphQLError("Not supported in uigraph")] };
+	const { workspace, warnings } = await loadWorkspace();
+	for (const warning of warnings) if (!reportedWarnings.has(warning)) {
+		reportedWarnings.add(warning);
+		console.log(pc.yellow(`⚠ ${warning}`));
+	}
+	return execute({
+		schema,
+		document,
+		rootValue: createRootValue(workspace),
+		variableValues: request.variables,
+		operationName: request.operationName
+	});
+}
+function respondWithError(response, status, message) {
+	if (response.headersSent) {
+		response.destroy();
+		return;
+	}
+	response.writeHead(status, {
+		"X-Content-Type-Options": "nosniff",
+		"Cache-Control": "no-store"
+	}).end(message);
+}
+async function getViewerInfo(port) {
+	if (!await isServerRunning(port)) return null;
+	try {
+		const response = await fetch(new URL(INFO_PATH, serverUrl(port)), { signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS) });
+		if (!response.ok) return "legacy";
+		const body = await response.json();
+		return typeof body.version === "string" && typeof body.build === "string" && typeof body.pid === "number" ? {
+			version: body.version,
+			build: body.build,
+			pid: body.pid
+		} : "legacy";
+	} catch {
+		return "legacy";
+	}
+}
+async function isServerRunning(port) {
+	try {
+		const response = await fetch(new URL(HEALTH_PATH, serverUrl(port)), { signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS) });
+		return response.ok && await response.text() === HEALTH_BODY;
+	} catch {
+		return false;
+	}
+}
+async function startServer(port) {
+	const assets = await listViewerAssets();
+	const allowedHosts = [`127.0.0.1:${port}`, `localhost:${port}`];
+	const server = http.createServer((request, response) => {
+		(async () => {
+			const securityHeaders = {
+				"X-Content-Type-Options": "nosniff",
+				"Referrer-Policy": "no-referrer",
+				"X-Frame-Options": "DENY",
+				"Content-Security-Policy": "frame-ancestors 'none'",
+				"Cache-Control": "no-store"
+			};
+			if (!allowedHosts.includes(request.headers.host ?? "")) {
+				response.writeHead(403, securityHeaders).end("Forbidden");
+				return;
+			}
+			const url = new URL(request.url ?? "/", "http://localhost");
+			const pathname = decodeURIComponent(url.pathname);
+			if (pathname === INFO_PATH) {
+				response.writeHead(200, {
+					...securityHeaders,
+					"Content-Type": "application/json"
+				}).end(JSON.stringify({
+					version: VERSION,
+					build: BUILD_ID,
+					pid: process.pid
+				}));
+				return;
+			}
+			if (pathname === HEALTH_PATH) {
+				response.writeHead(200, securityHeaders).end(HEALTH_BODY);
+				return;
+			}
+			if (pathname === "/graphql") {
+				if (request.method !== "POST") {
+					response.writeHead(405, securityHeaders).end("Method Not Allowed");
+					return;
+				}
+				if (request.headers.origin !== `http://${request.headers.host}`) {
+					response.writeHead(403, securityHeaders).end("Forbidden");
+					return;
+				}
+				if (!(request.headers["content-type"] ?? "").startsWith("application/json")) {
+					response.writeHead(415, securityHeaders).end("Unsupported Media Type");
+					return;
+				}
+				const result = await runGraphQL((await readBody(request, MAX_BODY_BYTES)).toString("utf8"));
+				response.writeHead(200, {
+					...securityHeaders,
+					"Content-Type": CONTENT_TYPES[".json"]
+				}).end(JSON.stringify(result));
+				return;
+			}
+			if (pathname.startsWith("/api/lens/")) {
+				if (request.headers.origin !== void 0 && request.headers.origin !== `http://${request.headers.host}`) {
+					response.writeHead(403, securityHeaders).end("Forbidden");
+					return;
+				}
+				await handleLensRequest(request, response, pathname, securityHeaders);
+				return;
+			}
+			if (pathname === "/api/projects") {
+				if (request.method !== "GET") {
+					response.writeHead(405, securityHeaders).end("Method Not Allowed");
+					return;
+				}
+				if (request.headers.origin !== void 0 && request.headers.origin !== `http://${request.headers.host}`) {
+					response.writeHead(403, securityHeaders).end("Forbidden");
+					return;
+				}
+				response.writeHead(200, {
+					...securityHeaders,
+					"Content-Type": CONTENT_TYPES[".json"]
+				}).end(JSON.stringify(await listRegisteredProjects()));
+				return;
+			}
+			if (pathname.startsWith("/uploads/")) {
+				const assetId = pathname.slice(9);
+				if (request.method !== "PUT") {
+					response.writeHead(405, securityHeaders).end("Method Not Allowed");
+					return;
+				}
+				if (request.headers.origin !== `http://${request.headers.host}`) {
+					response.writeHead(403, securityHeaders).end("Forbidden");
+					return;
+				}
+				if (!isPendingUpload(assetId)) {
+					response.writeHead(404, securityHeaders).end("Not Found");
+					return;
+				}
+				storeUpload(assetId, await readBody(request, MAX_UPLOAD_BYTES), request.headers["content-type"] ?? "");
+				response.writeHead(200, securityHeaders).end();
+				return;
+			}
+			if (request.method !== "GET" && request.method !== "HEAD") {
+				response.writeHead(405, securityHeaders).end("Method Not Allowed");
+				return;
+			}
+			if (pathname.startsWith("/files/")) {
+				const { workspace } = await loadWorkspace();
+				const served = workspace.files.get(pathname);
+				if (served === void 0) {
+					response.writeHead(404, securityHeaders).end("Not Found");
+					return;
+				}
+				const { realPath } = await resolveRepositoryFile(served.root, served.path);
+				const body = await fs.readFile(realPath);
+				const scriptable = [
+					".html",
+					".htm",
+					".svg"
+				].includes(path.extname(realPath).toLowerCase());
+				response.writeHead(200, {
+					...securityHeaders,
+					"Content-Type": contentType(realPath),
+					...scriptable ? { "Content-Security-Policy": "sandbox" } : {}
+				}).end(request.method === "HEAD" ? void 0 : body);
+				return;
+			}
+			const file = assets.get(pathname) ?? assets.get("/index.html");
+			const body = await fs.readFile(file);
+			response.writeHead(200, {
+				...securityHeaders,
+				"Content-Type": contentType(file)
+			}).end(request.method === "HEAD" ? void 0 : body);
+		})().catch((error) => {
+			const status = error instanceof HttpError ? error.status : 500;
+			if (error instanceof SyntaxError) {
+				respondWithError(response, 400, "Bad Request");
+				return;
+			}
+			if (status === 500) console.error(`[uigraph] ${request.method} ${request.url}: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+			respondWithError(response, status, status === 413 ? "Payload Too Large" : "Internal Server Error");
+		});
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", (error) => {
+			if (error.code === "EADDRINUSE") {
+				reject(/* @__PURE__ */ new Error(`Port ${port} is in use by another program. Choose another with --port.`));
+				return;
+			}
+			reject(error);
+		});
+		server.listen(port, "127.0.0.1", () => resolve());
+	});
+	return { async close() {
+		await stopAllLensRuns();
+		await new Promise((resolve) => {
+			server.close(() => resolve());
+			server.closeAllConnections();
+		});
+	} };
+}
+async function handleLensRequest(request, response, pathname, securityHeaders) {
+	function sendJson(status, value) {
+		response.writeHead(status, {
+			...securityHeaders,
+			"Content-Type": CONTENT_TYPES[".json"]
+		}).end(JSON.stringify(value));
+	}
+	if (pathname === "/api/lens/file-icon") {
+		if (request.method !== "GET") {
+			response.writeHead(405, securityHeaders).end("Method Not Allowed");
+			return;
+		}
+		const query = new URL(request.url ?? "/", "http://localhost").searchParams;
+		const name = query.get("name");
+		const kind = query.get("kind");
+		if (name === null || kind !== "file" && kind !== "folder" && kind !== "folder-open") {
+			sendJson(400, { error: "name and kind are required" });
+			return;
+		}
+		response.writeHead(200, {
+			...securityHeaders,
+			"Content-Type": CONTENT_TYPES[".svg"],
+			"Content-Security-Policy": "sandbox",
+			"Cache-Control": "max-age=86400"
+		}).end(await fs.readFile(fileIconPath(name, kind)));
+		return;
+	}
+	if (pathname === "/api/lens/settings") {
+		if (request.method === "GET") {
+			sendJson(200, await getLensSettings());
+			return;
+		}
+		if (request.method !== "PUT") {
+			response.writeHead(405, securityHeaders).end("Method Not Allowed");
+			return;
+		}
+		if (!(request.headers["content-type"] ?? "").startsWith("application/json")) {
+			response.writeHead(415, securityHeaders).end("Unsupported Media Type");
+			return;
+		}
+		const settings = lensSettingsSchema.safeParse(JSON.parse((await readBody(request, MAX_BODY_BYTES)).toString("utf8")));
+		if (!settings.success) {
+			sendJson(400, { error: settings.error.message });
+			return;
+		}
+		await saveLensSettings(settings.data);
+		sendJson(200, settings.data);
+		return;
+	}
+	if (pathname === "/api/lens/runs") {
+		if (request.method === "GET") {
+			sendJson(200, await listLensRuns());
+			return;
+		}
+		if (request.method !== "POST") {
+			response.writeHead(405, securityHeaders).end("Method Not Allowed");
+			return;
+		}
+		if (!(request.headers["content-type"] ?? "").startsWith("application/json")) {
+			response.writeHead(415, securityHeaders).end("Unsupported Media Type");
+			return;
+		}
+		const input = lensStartSchema.safeParse(JSON.parse((await readBody(request, MAX_BODY_BYTES)).toString("utf8")));
+		if (!input.success) {
+			sendJson(400, { error: "Expected { request, regenerate, agent?, model? }." });
+			return;
+		}
+		try {
+			sendJson(200, { runId: await startLensRun(input.data.request, input.data.regenerate, input.data.agent, input.data.model) });
+		} catch (error) {
+			if (error instanceof LensRequestError) {
+				sendJson(400, { error: error.message });
+				return;
+			}
+			throw error;
+		}
+		return;
+	}
+	const match = LENS_RUN_PATH.exec(pathname);
+	if (match === null) {
+		response.writeHead(404, securityHeaders).end("Not Found");
+		return;
+	}
+	const runId = match[1];
+	const action = match[2];
+	if (action === "/stop") {
+		if (request.method !== "POST") {
+			response.writeHead(405, securityHeaders).end("Method Not Allowed");
+			return;
+		}
+		sendJson(stopLensRun(runId) ? 200 : 404, {});
+		return;
+	}
+	if (action === "/ticket") {
+		if (request.method !== "POST") {
+			response.writeHead(405, securityHeaders).end("Method Not Allowed");
+			return;
+		}
+		if (!(request.headers["content-type"] ?? "").startsWith("application/json")) {
+			response.writeHead(415, securityHeaders).end("Unsupported Media Type");
+			return;
+		}
+		const input = lensTicketSchema.safeParse(JSON.parse((await readBody(request, MAX_BODY_BYTES)).toString("utf8")));
+		if (!input.success) {
+			sendJson(400, { error: "Expected { keys }." });
+			return;
+		}
+		sendJson(answerLensTicket(runId, input.data.keys) ? 200 : 409, {});
+		return;
+	}
+	if (request.method !== "GET") {
+		response.writeHead(405, securityHeaders).end("Method Not Allowed");
+		return;
+	}
+	const run = await getLensRun(runId);
+	if (run === null) {
+		response.writeHead(404, securityHeaders).end("Not Found");
+		return;
+	}
+	if (action === void 0) {
+		sendJson(200, run);
+		return;
+	}
+	if (action !== "/events") throw new Error(`Unknown Lens action: ${action}`);
+	response.writeHead(200, {
+		...securityHeaders,
+		"Content-Type": "text/event-stream; charset=utf-8",
+		Connection: "keep-alive"
+	});
+	response.write(`data: ${JSON.stringify(run.analysis)}\n\n`);
+	const unsubscribe = subscribeToLensRun(runId, {
+		update: (analysis) => {
+			response.write(`data: ${JSON.stringify(analysis)}\n\n`);
+		},
+		end: () => response.end("event: end\ndata:\n\n")
+	});
+	if (unsubscribe === null) {
+		response.end("event: end\ndata:\n\n");
+		return;
+	}
+	request.on("close", unsubscribe);
+}
+//#endregion
+//#region src/bin.ts
+const ARTIFACT_ENTRIES = [ROOT_CONFIG, ".uigraph"];
+if (process.env.UIGRAPH_DEBUG === "1") consola.level = LogLevels.debug;
+var UsageError = class extends Error {};
+function fail(message, exitCode = 1) {
+	console.error(pc.red(`✖ ${message}`));
+	process.exit(exitCode);
+}
+async function withCancellation(message, work) {
+	const abortController = new AbortController();
+	let signals = 0;
+	function onSignal() {
+		signals++;
+		if (signals > 1) {
+			console.error(pc.red("\nForced exit."));
+			process.exit(130);
+		}
+		console.log(pc.yellow(`\n${message} (press Ctrl+C again to force quit)`));
+		abortController.abort();
+	}
+	process.on("SIGINT", onSignal);
+	process.on("SIGTERM", onSignal);
+	try {
+		return await work(abortController);
+	} finally {
+		process.off("SIGINT", onSignal);
+		process.off("SIGTERM", onSignal);
+	}
+}
+async function resolveRepository(input) {
+	const requested = path.resolve(input ?? process.cwd());
+	let realPath;
+	try {
+		realPath = await fs.realpath(requested);
+	} catch {
+		throw new UsageError(`Repository not found: ${requested}`);
+	}
+	if (!(await fs.stat(realPath)).isDirectory()) throw new UsageError(`Not a directory: ${realPath}`);
+	return realPath;
+}
+function describeLimits(settings) {
+	if (settings.maxBudgetUsd !== void 0) return `  • Each Claude session is capped at $${settings.maxBudgetUsd.toFixed(2)}.`;
+	if (settings.agent === "claude") return "  • No spending cap is set (see --max-budget); usage counts against your Claude plan or API account.";
+	return `  • Usage counts against your ${AGENT_LABELS[settings.agent]} plan or API account.`;
+}
+async function chooseAgent(agent, question) {
+	if (agent !== void 0) return agent;
+	if (!process.stdin.isTTY) throw new UsageError(`Choose an agent with --agent (${AGENT_NAMES.join(", ")}).`);
+	return select({
+		message: question,
+		choices: AGENT_NAMES.map((name) => ({
+			name: AGENT_LABELS[name],
+			value: name
+		}))
+	});
+}
+async function confirmAnalysis(root, settings) {
+	const agent = AGENT_LABELS[settings.agent];
+	console.log([
+		"",
+		`${pc.bold("uigraph")} will generate UIGraph artifacts for ${pc.cyan(root)} with ${agent}.`,
+		"",
+		`  • ${agent} reads selected repository files (manifests, source, configs) and sends`,
+		settings.agent === "opencode" ? "    their contents to its model provider, using provider API keys from your environment." : `    their contents to its model provider, using your ${agent} login or API key.`,
+		`  • ${agent} first proposes which diagrams to generate and which existing docs to add,`,
+		"    and you choose. Nothing is written until you do.",
+		`  • ${agent} writes ${ROOT_CONFIG} and files under .uigraph/ in the repository. Nothing else`,
+		"    is changed. If generation fails, the previous artifacts are restored.",
+		describeLimits(settings),
+		""
+	].join("\n"));
+	if (await confirm({
+		message: "Continue?",
+		default: false
+	})) return true;
+	console.log(pc.yellow(`Cancelled. Nothing was sent to ${agent}.`));
+	return false;
+}
+async function promptForDiagrams(candidates, preselected, docCandidates, agent) {
+	const diagrams = await checkbox({
+		message: `${AGENT_LABELS[agent]} found ${candidates.length} ${candidates.length === 1 ? "diagram" : "diagrams"} worth generating. Pick the ones to generate.`,
+		choices: candidates.map((diagram) => ({
+			name: `${diagram.name}  ${pc.cyan(diagram.type)}`,
+			value: diagram,
+			checked: preselected.has(diagram.id),
+			description: `${diagram.summary}\nevidence: ${diagram.evidence.join(", ")}`
+		})),
+		pageSize: candidates.length
+	});
+	const docs = docCandidates.length === 0 ? [] : await checkbox({
+		message: `${AGENT_LABELS[agent]} found ${docCandidates.length} existing ${docCandidates.length === 1 ? "document" : "documents"} in the repository. Pick the ones to add to the viewer.`,
+		choices: docCandidates.map((doc) => ({
+			name: `${doc.name}  ${pc.cyan(doc.path)}`,
+			value: doc,
+			checked: true,
+			description: doc.summary
+		})),
+		pageSize: docCandidates.length
+	});
+	const focus = (await input({ message: "Anything in particular to focus on? (optional, press Enter to skip)" })).trim();
+	return {
+		diagrams,
+		docs,
+		focus: focus === "" ? null : focus
+	};
+}
+async function chooseDiagrams(root, skill, settings) {
+	console.log(pc.bold("\nLooking for diagrams worth generating…\n"));
+	let plan;
+	try {
+		plan = await withCancellation("Cancelling…", (abortController) => planDiagrams(root, path.basename(root), skill, abortController, settings));
+	} catch (error) {
+		if (error instanceof AnalysisCancelledError) fail("Cancelled. Nothing was written.", 130);
+		if (error instanceof AnalysisError) fail(`${error.message}\n  Nothing was written.`);
+		throw error;
+	}
+	if (plan === null) {
+		console.log(pc.yellow("\nCould not build a diagram plan. Generating the default set instead."));
+		return null;
+	}
+	console.log(pc.dim(`\n  ${plan.diagrams.length} diagram and ${plan.docs.length} document candidates · ${plan.seconds}s · ${describeUsage(plan.usage)}`));
+	const recommended = new Set(plan.diagrams.filter((diagram) => diagram.recommended).map(({ id }) => id));
+	return promptForDiagrams(plan.diagrams, recommended, plan.docs, settings.agent);
+}
+async function downloadSkillOrFail() {
+	try {
+		return await loadSkill();
+	} catch (error) {
+		if (error instanceof AnalysisError) fail(error.message);
+		throw error;
+	}
+}
+async function countAnalyzableFiles(root) {
+	const files = await listRepositoryFiles(root, "**/*");
+	if (files.length === 0) fail("The repository has no analyzable files (generated directories and secret files are skipped). Nothing was sent to an agent.");
+	return files.length;
+}
+async function findGitRemote(root) {
+	const remote = await promisify(execFile)("git", [
+		"-C",
+		root,
+		"remote",
+		"get-url",
+		"origin"
+	], { timeout: 1e4 }).then(({ stdout }) => stdout.trim(), () => null);
+	if (remote === null) return null;
+	const match = /^(?:https:\/\/|ssh:\/\/git@|git@)(github\.com|gitlab\.com|bitbucket\.org)[:/](.+?)(?:\.git)?\/?$/.exec(remote);
+	if (match === null) return null;
+	return `https://${match[1]}/${match[2]}`;
+}
+async function pathExists(file) {
+	return fs.lstat(file).then(() => true, (error) => {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	});
+}
+async function backupArtifacts(root) {
+	const backup = await fs.mkdtemp(path.join(os.tmpdir(), "uigraph-"));
+	for (const entry of ARTIFACT_ENTRIES) if (await pathExists(path.join(root, entry))) await fs.cp(path.join(root, entry), path.join(backup, entry), {
+		recursive: true,
+		verbatimSymlinks: true
+	});
+	return backup;
+}
+async function restoreArtifacts(root, backup) {
+	for (const entry of ARTIFACT_ENTRIES) {
+		await fs.rm(path.join(root, entry), {
+			recursive: true,
+			force: true
+		});
+		if (await pathExists(path.join(backup, entry))) await fs.cp(path.join(backup, entry), path.join(root, entry), {
+			recursive: true,
+			verbatimSymlinks: true
+		});
+	}
+}
+async function runGeneration(root, fileCount, update, skill, selection, settings) {
+	const gitRemote = await findGitRemote(root);
+	const backup = await backupArtifacts(root);
+	console.log(pc.bold(`\nGenerating artifacts from ${fileCount} ${fileCount === 1 ? "file" : "files"} with ${AGENT_LABELS[settings.agent]}…\n`));
+	try {
+		await withCancellation("Cancelling generation…", (abortController) => generateArtifacts(root, path.basename(root), gitRemote, update, abortController, skill, selection, settings));
+		console.log(pc.green(`\n✔ Artifacts written to ${ROOT_CONFIG} and .uigraph/`));
+	} catch (error) {
+		await restoreArtifacts(root, backup);
+		if (error instanceof AnalysisCancelledError) fail("Generation cancelled. The previous artifacts were restored.", 130);
+		if (error instanceof AnalysisError) fail(`${error.message}\n  The previous artifacts were restored.`);
+		throw error;
+	} finally {
+		await fs.rm(backup, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function printSummary(db) {
+	const endpoints = db.apiGroups.reduce((count, { endpoints }) => count + endpoints.length, 0);
+	console.log(pc.dim(`  ${db.services.length} services · ${endpoints} endpoints · ${db.dependencies.length} dependencies · ${db.diagrams.length} diagrams`));
+}
+async function generate(root, hasArtifacts, options) {
+	const fileCount = await countAnalyzableFiles(root);
+	const settings = {
+		agent: await chooseAgent(options.agent, "Which agent should generate the artifacts?"),
+		model: options.model,
+		maxBudgetUsd: options.maxBudgetUsd
+	};
+	if (settings.agent !== "claude" && settings.maxBudgetUsd !== void 0) throw new UsageError(`--max-budget only works with Claude. ${AGENT_LABELS[settings.agent]} does not support a spending cap.`);
+	if (!await confirmAnalysis(root, settings)) return false;
+	const skill = await downloadSkillOrFail();
+	await runGeneration(root, fileCount, hasArtifacts, skill, await chooseDiagrams(root, skill, settings), settings);
+	return true;
+}
+async function registerProject(root, port) {
+	const { db, errors } = await loadArtifacts(root);
+	if (errors.length > 0) {
+		console.error(pc.red(`✖ The UIGraph artifacts are invalid:\n${errors.map((error) => `  • ${error}`).join("\n")}\n  Fix them or run "uigraph generate --update".`));
+		return false;
+	}
+	printSummary(db);
+	return reportSync(root, await syncProject(root), port);
+}
+async function offerGuidance(root, hasGuidance) {
+	const accepted = await confirm({
+		message: hasGuidance ? "Update the UIGraph instructions for coding agents?" : "Add UIGraph instructions for coding agents?",
+		default: true
+	});
+	await setGuidanceDeclined(root, !accepted);
+	if (!accepted) {
+		console.log(pc.dim("  Run \"uigraph init\" to add them later."));
+		return;
+	}
+	const files = await writeGuidance(root);
+	console.log(pc.green(`✔ Wrote ${GUIDANCE_FILE} and linked it from ${files.join(" and ")}`));
+}
+function reportSync(root, result, port) {
+	if (result.synced) {
+		console.log(pc.green(`✔ Registered with the viewer (${serverUrl(port)})`));
+		return true;
+	}
+	console.error(pc.red(`✖ The viewer will not show this repository. ${root} ${result.reason}`));
+	return false;
+}
+const STALE_HELP = "Run \"uigraph restart\" to replace it.";
+async function findListeningPid(port) {
+	const pid = await promisify(execFile)("lsof", [
+		"-ti",
+		`tcp:${port}`,
+		"-sTCP:LISTEN"
+	], { timeout: 5e3 }).then(({ stdout }) => Number.parseInt(stdout.split("\n")[0] ?? "", 10), () => NaN);
+	return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+async function stopViewerProcess(port) {
+	const lock = await readViewerLock();
+	const pid = lock !== null && lock.port === port ? lock.pid : await findListeningPid(port);
+	if (pid === null || pid === process.pid) return false;
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch {
+		return false;
+	}
+	for (let waited = 0; waited < 5e3; waited += 100) {
+		if (!await isServerRunning(port)) return true;
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	return false;
+}
+async function describeStaleViewer(port) {
+	const info = await getViewerInfo(port);
+	if (info === null) return null;
+	if (info === "legacy") return "An older uigraph viewer is running and may not show your changes.";
+	return info.build === BUILD_ID ? null : `A viewer from a different build (${info.version}, ${info.build}) is running and may not show your changes.`;
+}
+async function viewerLogPath() {
+	return path.join(await homeRoot(), ".uigraph", "viewer.log");
+}
+async function startViewer(port, mode) {
+	await showBanner();
+	const url = serverUrl(port);
+	const stale = await describeStaleViewer(port);
+	if (stale !== null) {
+		console.log(pc.yellow(`${stale} Restarting it.`));
+		if (!await stopViewerProcess(port)) fail(`Could not stop it. Stop whatever listens on port ${port} (lsof -ti :${port} | xargs kill), then run this command again.`);
+	}
+	if (await isServerRunning(port)) {
+		console.log(`\n${pc.bold("UIGraph viewer")} is already running at ${pc.cyan(url)}`);
+		return null;
+	}
+	if (mode === "background") {
+		const logFile = await viewerLogPath();
+		await fs.mkdir(path.dirname(logFile), { recursive: true });
+		const log = await fs.open(logFile, "a");
+		await log.write(`\n--- ${(/* @__PURE__ */ new Date()).toISOString()} uigraph ${VERSION} ---\n`);
+		spawn(process.execPath, [
+			...process.execArgv,
+			process.argv[1],
+			"start",
+			"--port",
+			String(port)
+		], {
+			detached: true,
+			stdio: [
+				"ignore",
+				log.fd,
+				log.fd
+			]
+		}).unref();
+		await log.close();
+		for (let waited = 0; !await isServerRunning(port); waited += 100) {
+			if (waited >= 1e4) fail(`The viewer did not start in the background. See ${logFile}, or run "uigraph start" to see why.`);
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+		console.log(`\n${pc.bold("UIGraph viewer")} running in the background at ${pc.cyan(url)}`);
+		console.log(pc.dim(`  Logs: ${logFile}`));
+		console.log(pc.dim("  Run \"uigraph stop\" to stop it.\n"));
+		return null;
+	}
+	const server = await startServer(port);
+	await writeViewerLock({
+		pid: process.pid,
+		port
+	});
+	console.log(`\n${pc.bold("UIGraph viewer")} running at ${pc.cyan(url)}\n`);
+	return server;
+}
+function holdViewer(server) {
+	console.log(pc.dim("\nPress Ctrl+C to stop.\n"));
+	let stopping = false;
+	async function stop() {
+		if (stopping) process.exit(0);
+		stopping = true;
+		await server.close();
+		await removeViewerLock(process.pid);
+		console.log(pc.dim("\nViewer stopped."));
+		process.exit(0);
+	}
+	process.on("SIGINT", () => void stop());
+	process.on("SIGTERM", () => void stop());
+}
+async function openBrowser(url) {
+	try {
+		await open(url);
+	} catch {
+		console.log(pc.yellow(`Could not open a browser. Open ${url} manually.`));
+	}
+}
+async function resolvePullRequest(input) {
+	if (!/^\d+$/.test(input)) return input;
+	const remote = await findGitRemote(process.cwd());
+	if (remote === null || !remote.startsWith("https://github.com/")) throw new UsageError("A bare pull request number needs a GitHub origin remote in the current directory. Pass a pull request URL or owner/repo#number instead.");
+	return `${remote}/pull/${input}`;
+}
+async function lens(request, regenerate, agent, model, port, noOpen) {
+	const viewer = await startViewer(port, "foreground");
+	const response = await fetch(`${serverUrl(port)}api/lens/runs`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			request,
+			regenerate,
+			agent,
+			model
+		})
+	});
+	const text = await response.text();
+	if (response.ok) {
+		const { runId } = JSON.parse(text);
+		const url = `${serverUrl(port)}lens/${runId}`;
+		console.log(`${pc.bold("Lens")} review at ${pc.cyan(url)}`);
+		if (!noOpen) await openBrowser(url);
+	} else {
+		const isJson = (response.headers.get("content-type") ?? "").startsWith("application/json");
+		console.error(pc.red(`✖ ${isJson ? JSON.parse(text).error : text}`));
+		process.exitCode = 1;
+	}
+	if (viewer !== null) holdViewer(viewer);
+}
+async function status(port) {
+	const lock = await readViewerLock();
+	const effectivePort = lock?.port ?? port;
+	if (await isServerRunning(effectivePort)) {
+		console.log(`UIGraph viewer is running at ${pc.cyan(serverUrl(effectivePort))}${lock === null ? "" : pc.dim(` (pid ${lock.pid})`)}`);
+		console.log(pc.dim(`  Logs: ${await viewerLogPath()}`));
+		const stale = await describeStaleViewer(effectivePort);
+		if (stale !== null) console.log(pc.yellow(`  ${stale}\n  ${STALE_HELP}`));
+	} else {
+		console.log("UIGraph viewer is not running.");
+		process.exitCode = 1;
+	}
+	const projects = await listRegisteredProjects();
+	if (projects.length === 0) {
+		console.log(pc.dim("No repositories are registered."));
+		return;
+	}
+	console.log(pc.bold("\nRegistered repositories"));
+	for (const { root, problem } of projects) console.log(problem === null ? `  ${pc.green("✔")} ${root}` : `  ${pc.red("✖")} ${root}\n      ${problem}`);
+}
+async function stopViewer(port) {
+	const lock = await readViewerLock();
+	if (lock === null) {
+		if (await isServerRunning(port)) {
+			if (await stopViewerProcess(port)) {
+				console.log(`Stopped the UIGraph viewer on port ${port}.`);
+				return;
+			}
+			console.error(pc.red(`✖ A viewer is running on port ${port} but could not be stopped. Try: lsof -ti :${port} | xargs kill`));
+			process.exitCode = 1;
+			return;
+		}
+		console.log("UIGraph viewer is not running.");
+		return;
+	}
+	if (await stopViewerProcess(lock.port)) {
+		console.log(`Stopped the UIGraph viewer (pid ${lock.pid}).`);
+		return;
+	}
+	console.error(pc.red(`✖ The UIGraph viewer (pid ${lock.pid}) could not be stopped. Try: kill ${lock.pid}`));
+	process.exitCode = 1;
+}
+function parseNumber(min, max, integer) {
+	return (raw) => {
+		const value = Number(raw);
+		if (raw.trim() === "" || !Number.isFinite(value) || value < min || value > max || integer && !Number.isInteger(value)) throw new InvalidArgumentError(`Expected ${integer ? "an integer" : "a number"} between ${min} and ${max}.`);
+		return value;
+	};
+}
+const parsePort = parseNumber(1, 65535, true);
+const parseBudget = parseNumber(.01, 1e4, false);
+function agentOption() {
+	return new Option("--agent <name>", "Coding agent to use").choices(AGENT_NAMES);
+}
+function portOption() {
+	return new Option("--port <number>", "Viewer port").env("UIGRAPH_PORT").default(DEFAULT_PORT).argParser(parsePort);
+}
+const program = new Command().name("uigraph").description("Generate UIGraph artifacts for a repository with a coding agent (Claude Code,\nCodex, OpenCode, Pi or Cursor) and browse every registered repository in one\nlocal viewer.").version(VERSION, "-v, --version").option("--debug", "Print stack traces, agent output and Lens progress (also UIGRAPH_DEBUG=1)").showHelpAfterError("(run uigraph --help for usage)").addHelpText("after", "\nA repository literally named \"open\", \"init\", \"generate\", \"sync\", \"start\",\n\"status\", \"stop\", \"restart\" or \"lens\" can be passed as ./start.").hook("preAction", () => {
+	if (program.opts().debug === true) {
+		process.env.UIGRAPH_DEBUG = "1";
+		consola.level = LogLevels.debug;
+	}
+});
+program.command("open", { isDefault: true }).description("Start the viewer, offer to generate artifacts if there are none, and open it (default)").argument("[repository]", "Repository path (default: current directory)").addOption(agentOption()).option("--model <name>", "Model to use for generation, in the agent's own format").option("--max-budget <usd>", "Spending cap per Claude session (planning, generation and repair each get one). Claude only", parseBudget).addOption(portOption()).option("--no-open", "Do not open a browser").action(async (repository, options) => {
+	const root = await resolveRepository(repository);
+	await startViewer(options.port, "background");
+	const hasArtifacts = await pathExists(path.join(root, ROOT_CONFIG));
+	let generated = false;
+	if (hasArtifacts) {
+		console.log(`Opening the UIGraph artifacts in ${pc.cyan(root)}`);
+		console.log(pc.dim("  Run \"uigraph generate --update\" to update them."));
+	} else if (!process.stdin.isTTY) console.log(`${root} has no UIGraph artifacts. Run "uigraph generate" in a terminal to generate them.`);
+	else if (await confirm({
+		message: `${root} has no UIGraph artifacts. Generate them with an agent?`,
+		default: true
+	})) generated = await generate(root, false, {
+		agent: options.agent,
+		model: options.model,
+		maxBudgetUsd: options.maxBudget
+	});
+	const synced = hasArtifacts || generated ? await registerProject(root, options.port) : true;
+	if (process.stdin.isTTY && (hasArtifacts || generated) && !await pathExists(path.join(root, ".uigraph/AGENTS.md")) && !await isGuidanceDeclined(root)) await offerGuidance(root, false);
+	if (options.open) await openBrowser(serverUrl(options.port));
+	if (!synced) process.exitCode = 1;
+});
+program.command("init").description("Generate artifacts if there are none, then add or update the instructions for coding agents").argument("[repository]", "Repository path (default: current directory)").addOption(agentOption()).option("--model <name>", "Model to use for generation, in the agent's own format").option("--max-budget <usd>", "Spending cap per Claude session (planning, generation and repair each get one). Claude only", parseBudget).action(async (repository, options) => {
+	const root = await resolveRepository(repository);
+	if (!process.stdin.isTTY) throw new UsageError("\"uigraph init\" needs a terminal.");
+	if (!await pathExists(path.join(root, ".uigraph.yaml"))) {
+		if (!await generate(root, false, {
+			agent: options.agent,
+			model: options.model,
+			maxBudgetUsd: options.maxBudget
+		})) {
+			process.exitCode = 130;
+			return;
+		}
+	}
+	const synced = await registerProject(root, parsePort(process.env.UIGRAPH_PORT ?? String(7357)));
+	await offerGuidance(root, await pathExists(path.join(root, GUIDANCE_FILE)));
+	if (!synced) process.exitCode = 1;
+});
+program.command("generate").description("Generate artifacts, or update them after asking, then exit").argument("[repository]", "Repository path (default: current directory)").option("--update", "Regenerate existing artifacts without asking").addOption(agentOption()).option("--model <name>", "Model to use for generation, in the agent's own format").option("--max-budget <usd>", "Spending cap per Claude session (planning, generation and repair each get one). Claude only", parseBudget).action(async (repository, options) => {
+	const root = await resolveRepository(repository);
+	if (!process.stdin.isTTY) throw new UsageError("\"uigraph generate\" needs a terminal.");
+	const hasArtifacts = await pathExists(path.join(root, ROOT_CONFIG));
+	if (hasArtifacts && options.update !== true && !await confirm({
+		message: `${root} already has UIGraph artifacts. Update them?`,
+		default: false
+	})) {
+		console.log("Nothing was changed.");
+		return;
+	}
+	if (!await generate(root, hasArtifacts, {
+		agent: options.agent,
+		model: options.model,
+		maxBudgetUsd: options.maxBudget
+	})) {
+		process.exitCode = 130;
+		return;
+	}
+	if (!await registerProject(root, parsePort(process.env.UIGRAPH_PORT ?? String(7357)))) process.exitCode = 1;
+});
+program.command("sync").description("Show the artifacts of a repository in the viewer, then exit").argument("[repository]", "Repository path (default: current directory)").action(async (repository) => {
+	const root = await resolveRepository(repository);
+	if (!await pathExists(path.join(root, ".uigraph.yaml"))) throw new UsageError(`${root} has no UIGraph artifacts. Run "uigraph generate" to generate them.`);
+	if (!await registerProject(root, parsePort(process.env.UIGRAPH_PORT ?? String(7357)))) process.exitCode = 1;
+});
+program.command("start").description("Start the viewer").addOption(portOption()).action(async (options) => {
+	const viewer = await startViewer(options.port, "foreground");
+	if (viewer !== null) holdViewer(viewer);
+});
+program.command("status").description("Show the viewer and every registered repository").addOption(portOption()).action((options) => status(options.port));
+program.command("stop").description("Stop a running viewer").addOption(portOption()).action((options) => stopViewer(options.port));
+program.command("restart").description("Stop a running viewer and start it in this terminal").addOption(portOption()).action(async (options) => {
+	await stopViewer(options.port);
+	if (process.exitCode === 1) return;
+	const viewer = await startViewer(options.port, "foreground");
+	if (viewer !== null) holdViewer(viewer);
+});
+program.command("lens").description("Review a GitHub pull request, or two branches, with Lens").argument("[pull-request]", "Pull request URL, owner/repo#number, or a number in the current repository").option("--base <branch>", "Branch or commit to compare against").option("--target <branch>", "Branch or commit to review").option("--regenerate", "Run a new review instead of reusing a completed one").addOption(agentOption()).option("--model <name>", "Model to use, in the agent's own format (default: the agent's default)").addOption(portOption()).option("--no-open", "Do not open a browser").action(async (pullRequest, options) => {
+	let request;
+	if (pullRequest !== void 0) {
+		if (options.base !== void 0 || options.target !== void 0) throw new UsageError("Pass a pull request, or --base with --target, not both.");
+		request = {
+			type: "github",
+			pullRequest: await resolvePullRequest(pullRequest)
+		};
+	} else if (options.base !== void 0 && options.target !== void 0) request = {
+		type: "local",
+		directory: process.cwd(),
+		base: options.base,
+		target: options.target
+	};
+	else throw new UsageError("Pass a pull request, or both --base and --target.");
+	await lens(request, options.regenerate === true, await chooseAgent(options.agent, "Which agent should run the review?"), options.model, options.port, !options.open);
+});
+program.parseAsync().catch((error) => {
+	if (error instanceof Error && error.name === "ExitPromptError") fail("Cancelled.", 130);
+	if (error instanceof UsageError) fail(`${error.message}\n\nRun uigraph --help for usage.`);
+	if (consola.level >= LogLevels.debug) fail(inspect(error));
+	fail(`${error instanceof Error ? error.message : String(error)}\n  Run with --debug for details.`);
+});
+//#endregion
+export {};