@ghfs/cli 0.0.3 → 0.1.0

package/dist/cli.mjs

@@ -1,20 +1,15 @@
 #!/usr/bin/env node
-import { a as formatIssueNumber, i as formatDuration, n as normalizeReactions, o as formatTerminalLink$1, r as countNoun, s as formatValue, t as createRepositoryProvider } from "./factory-COZFMWsb.mjs";
+import { i as formatDuration, o as formatTerminalLink$1, r as countNoun, s as formatValue } from "./factory-DypZ8oi9.mjs";
+import { a as isExecuteCancelledError, c as GHFS_VERSION, d as pathExists, f as getExecuteFile, i as executePendingChanges, l as ensureExecuteArtifacts, m as resolveConfig, n as syncRepository, o as loadSyncState, p as getStorageDirAbsolute, r as appendExecutionResult, s as GHFS_NAME, t as createUiServer, u as ACTIONS_COLOR_HEX } from "./server-n1FLF8Xo.mjs";
 import process from "node:process";
 import { cac } from "cac";
-import { basename, dirname, isAbsolute, join, resolve } from "pathe";
+import { resolve } from "pathe";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { existsSync } from "node:fs";
-import { createJiti } from "jiti";
-import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import * as v from "valibot";
-import { parse, stringify } from "yaml";
-import { randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
 import c from "ansis";
 import * as p from "@clack/prompts";
 import { cancel, confirm, isCancel, multiselect, password, select } from "@clack/prompts";
-
 //#region src/config/auth.ts
 const execFileAsync$1 = promisify(execFile);
 async function resolveAuthToken(options) {
@@ -44,142 +39,6 @@ async function readTokenFromEnv() {
 		if (value) return value;
 	}
 }
-
-//#endregion
-//#region src/constants.ts
-const CONFIG_FILE_CANDIDATES = [
-	"ghfs.config.ts",
-	"ghfs.config.mts",
-	"ghfs.config.mjs",
-	"ghfs.config.js",
-	"ghfs.config.cjs"
-];
-const DEFAULT_STORAGE_DIR = ".ghfs";
-const ISSUE_DIR_NAME = "issues";
-const PULL_DIR_NAME = "pulls";
-const CLOSED_DIR_NAME = "closed";
-const SYNC_STATE_FILE_NAME = ".sync.json";
-const ISSUES_INDEX_FILE_NAME = "issues.md";
-const PULLS_INDEX_FILE_NAME = "pulls.md";
-const REPO_SNAPSHOT_FILE_NAME = "repo.json";
-const EXECUTE_FILE_NAME = "execute.yml";
-const EXECUTE_MD_FILE_NAME = "execute.md";
-const EXECUTE_SCHEMA_RELATIVE_PATH = "schema/execute.schema.json";
-
-//#endregion
-//#region src/config/load.ts
-async function loadUserConfig(cwd) {
-	const configPath = findConfigFile(cwd);
-	if (!configPath) return { config: {} };
-	return {
-		path: configPath,
-		config: extractUserConfig(await createJiti(resolve(cwd, "ghfs.config.ts"), { interopDefault: true }).import(configPath))
-	};
-}
-function extractUserConfig(loaded) {
-	if (!loaded || typeof loaded !== "object") return {};
-	if ("default" in loaded) {
-		const config = loaded.default;
-		if (config && typeof config === "object") return config;
-		return {};
-	}
-	return loaded;
-}
-async function resolveConfig(options = {}) {
-	const cwd = options.cwd ?? process.cwd();
-	const overrides = options.overrides ?? {};
-	const { config: userConfig } = await loadUserConfig(cwd);
-	const merged = mergeUserConfig(userConfig, overrides);
-	const directory = merged.directory ?? DEFAULT_STORAGE_DIR;
-	const configuredToken = merged.auth?.token?.trim() || "";
-	const repo = merged.repo?.trim() || "";
-	const issuesEnabled = merged.sync?.issues ?? true;
-	const pullsEnabled = merged.sync?.pulls ?? true;
-	const closedMode = merged.sync?.closed ?? false;
-	const patchesMode = merged.sync?.patches ?? "open";
-	return {
-		cwd,
-		repo,
-		directory,
-		auth: { token: configuredToken },
-		sync: {
-			issues: issuesEnabled,
-			pulls: pullsEnabled,
-			closed: closedMode,
-			patches: patchesMode
-		}
-	};
-}
-function getStorageDirAbsolute(config) {
-	return resolve(config.cwd, config.directory);
-}
-function getExecuteFile(config) {
-	return join(config.directory, EXECUTE_FILE_NAME);
-}
-function findConfigFile(cwd) {
-	for (const candidate of CONFIG_FILE_CANDIDATES) {
-		const fullPath = resolve(cwd, candidate);
-		if (existsSync(fullPath)) return fullPath;
-	}
-}
-function mergeUserConfig(base, overrides) {
-	return {
-		...base,
-		...overrides,
-		auth: {
-			...base.auth,
-			...overrides.auth
-		},
-		sync: {
-			...base.sync,
-			...overrides.sync
-		}
-	};
-}
-
-//#endregion
-//#region src/utils/fs.ts
-async function pathExists(path) {
-	try {
-		await access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function writeFileEnsured(path, content) {
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, content, "utf8");
-}
-async function removePath(path) {
-	await rm(path, { force: true });
-}
-async function movePath(from, to) {
-	await mkdir(dirname(to), { recursive: true });
-	await rename(from, to);
-}
-async function removePatchIfExists(storageDirAbsolute, number) {
-	const pullsDir = join(storageDirAbsolute, PULL_DIR_NAME);
-	let entries;
-	try {
-		entries = await readdir(pullsDir, { withFileTypes: true });
-	} catch {
-		return 0;
-	}
-	const padded = String(number).padStart(5, "0");
-	let removed = 0;
-	for (const entry of entries) {
-		if (!entry.isFile()) continue;
-		const fileName = entry.name;
-		const isLegacyPatch = fileName === `${number}.patch`;
-		const isCurrentPatch = fileName.startsWith(`${padded}-`) && fileName.endsWith(".patch");
-		if (!isLegacyPatch && !isCurrentPatch) continue;
-		await removePath(join(pullsDir, fileName));
-		removed += 1;
-	}
-	return removed;
-}
-
 //#endregion
 //#region src/config/repo.ts
 const execFileAsync = promisify(execFile);
@@ -318,2171 +177,6 @@ function prioritizeRemotes(remotes) {
 function stripGitSuffix(name) {
 	return name.replace(/\.git$/, "");
 }
-
-//#endregion
-//#region src/execute/actions.ts
-const ACTIONS_SUPPORTED = [
-	"close",
-	"close-with-comment",
-	"reopen",
-	"set-title",
-	"set-body",
-	"add-comment",
-	"add-labels",
-	"remove-labels",
-	"set-labels",
-	"add-assignees",
-	"remove-assignees",
-	"set-assignees",
-	"set-milestone",
-	"clear-milestone",
-	"lock",
-	"unlock",
-	"request-reviewers",
-	"remove-reviewers",
-	"mark-ready-for-review",
-	"convert-to-draft"
-];
-const ACTIONS_ALIAS_MAP = {
-	"open": "reopen",
-	"closes": "close",
-	"close-comment": "close-with-comment",
-	"comment-close": "close-with-comment",
-	"close-and-comment": "close-with-comment",
-	"comment-and-close": "close-with-comment",
-	"label": "add-labels",
-	"labels": "add-labels",
-	"tag": "add-labels",
-	"tags": "add-labels",
-	"add-tag": "add-labels",
-	"assign": "add-assignees",
-	"assignee": "add-assignees",
-	"assignees": "add-assignees",
-	"body": "set-body",
-	"title": "set-title",
-	"retitle": "set-title",
-	"ready": "mark-ready-for-review",
-	"undraft": "mark-ready-for-review",
-	"draft": "convert-to-draft",
-	"comment": "add-comment"
-};
-const ACTIONS_COLOR_HEX = {
-	"close": "#ef4444",
-	"close-with-comment": "#fb7185",
-	"reopen": "#22c55e",
-	"set-title": "#3b82f6",
-	"set-body": "#06b6d4",
-	"add-comment": "#f97316",
-	"add-labels": "#84cc16",
-	"remove-labels": "#f43f5e",
-	"set-labels": "#eab308",
-	"add-assignees": "#10b981",
-	"remove-assignees": "#fb7185",
-	"set-assignees": "#0ea5e9",
-	"set-milestone": "#6366f1",
-	"clear-milestone": "#f59e0b",
-	"lock": "#a855f7",
-	"unlock": "#14b8a6",
-	"request-reviewers": "#38bdf8",
-	"remove-reviewers": "#e879f9",
-	"mark-ready-for-review": "#34d399",
-	"convert-to-draft": "#f472b6"
-};
-const ACTION_NAMES_SET = new Set(ACTIONS_SUPPORTED);
-const ACTION_ALIASES = Object.keys(ACTIONS_ALIAS_MAP);
-const ACTION_INPUTS = [...ACTIONS_SUPPORTED, ...ACTION_ALIASES];
-function resolveActionName(action) {
-	const normalized = normalizeActionInput(action);
-	if (!normalized) return void 0;
-	if (ACTION_NAMES_SET.has(normalized)) return normalized;
-	return ACTIONS_ALIAS_MAP[normalized];
-}
-function normalizeActionInput(action) {
-	return action.trim().toLowerCase();
-}
-
-//#endregion
-//#region src/execute/schema.ts
-const executeSchema = {
-	$id: "https://ghfs.dev/schema/execute.json",
-	type: "array",
-	items: {
-		type: "object",
-		additionalProperties: true,
-		required: ["number", "action"],
-		properties: {
-			number: { type: "number" },
-			action: {
-				type: "string",
-				enum: [...ACTION_INPUTS]
-			},
-			ifUnchangedSince: {
-				type: "string",
-				format: "date-time"
-			},
-			title: { type: "string" },
-			body: { type: "string" },
-			labels: {
-				type: "array",
-				items: { type: "string" }
-			},
-			assignees: {
-				type: "array",
-				items: { type: "string" }
-			},
-			milestone: { anyOf: [{ type: "string" }, { type: "number" }] },
-			reviewers: {
-				type: "array",
-				items: { type: "string" }
-			},
-			reason: {
-				type: "string",
-				enum: [
-					"resolved",
-					"off-topic",
-					"too heated",
-					"too-heated",
-					"spam"
-				]
-			}
-		}
-	}
-};
-const EXECUTE_FILE_PLACEHOLDER = [
-	`# yaml-language-server: $schema=./${EXECUTE_SCHEMA_RELATIVE_PATH}`,
-	"# Add operations as YAML list items, then run: ghfs execute --run",
-	"# Action names are case-insensitive and support aliases (for example: label, assign, comment, close-comment).",
-	"# - action: close",
-	"#   number: 123",
-	"[]",
-	""
-].join("\n");
-const EXECUTE_MD_FILE_PLACEHOLDER = [
-	"# Add one action per line, then run: ghfs execute --run",
-	"# Command names are case-insensitive and support aliases.",
-	"# close #123 #124",
-	"# label #123 bug, triage",
-	"# assign #123 antfu",
-	"# comment #123 \"Need more context\"",
-	"# close-comment #123 \"Closing as completed\"",
-	"# set-title #123 \"new title\"",
-	"# add-tag #123 foo, bar",
-	""
-].join("\n");
-async function writeExecuteSchema(storageDirAbsolute) {
-	const schemaPath = getExecuteSchemaPath(storageDirAbsolute);
-	await mkdir(dirname(schemaPath), { recursive: true });
-	await writeFile(schemaPath, `${JSON.stringify(executeSchema, null, 2)}\n`, "utf8");
-	return schemaPath;
-}
-async function ensureExecuteArtifacts(executeFilePath) {
-	const storageDirAbsolute = dirname(executeFilePath);
-	const [schemaPath] = await Promise.all([
-		ensureExecuteSchema(storageDirAbsolute),
-		ensureExecuteFile(executeFilePath),
-		ensureExecuteMdFile(storageDirAbsolute)
-	]);
-	return {
-		executeFilePath,
-		schemaPath
-	};
-}
-async function ensureExecuteSchema(storageDirAbsolute) {
-	const schemaPath = getExecuteSchemaPath(storageDirAbsolute);
-	if (await pathExists(schemaPath)) return schemaPath;
-	return writeExecuteSchema(storageDirAbsolute);
-}
-async function ensureExecuteFile(executeFilePath) {
-	if (await pathExists(executeFilePath)) return;
-	await mkdir(dirname(executeFilePath), { recursive: true });
-	await writeFile(executeFilePath, EXECUTE_FILE_PLACEHOLDER, "utf8");
-}
-async function ensureExecuteMdFile(storageDirAbsolute) {
-	const executeMdPath = join(storageDirAbsolute, EXECUTE_MD_FILE_NAME);
-	if (await pathExists(executeMdPath)) return;
-	await mkdir(dirname(executeMdPath), { recursive: true });
-	await writeFile(executeMdPath, EXECUTE_MD_FILE_PLACEHOLDER, "utf8");
-}
-function getExecuteSchemaPath(storageDirAbsolute) {
-	return join(storageDirAbsolute, EXECUTE_SCHEMA_RELATIVE_PATH);
-}
-
-//#endregion
-//#region src/execute/validate.ts
-const executeOpSchema = v.looseObject({
-	number: v.number(),
-	action: v.string(),
-	ifUnchangedSince: v.optional(v.string()),
-	title: v.optional(v.string()),
-	body: v.optional(v.string()),
-	labels: v.optional(v.array(v.string())),
-	assignees: v.optional(v.array(v.string())),
-	milestone: v.optional(v.union([v.string(), v.number()])),
-	reviewers: v.optional(v.array(v.string())),
-	reason: v.optional(v.picklist([
-		"resolved",
-		"off-topic",
-		"too heated",
-		"too-heated",
-		"spam"
-	]))
-});
-const executeFileSchema = v.array(executeOpSchema);
-async function readAndValidateExecuteFileWithSource(path) {
-	const raw = await readFile(path, "utf8");
-	let parsed;
-	try {
-		parsed = parse(raw);
-	} catch (error) {
-		throw new Error(`Failed to parse execute YAML: ${error.message}`);
-	}
-	const parsedResult = v.safeParse(executeFileSchema, parsed);
-	if (!parsedResult.success) {
-		const message = parsedResult.issues.map((issue) => {
-			const path = issue.path?.map((segment) => String(segment.key)).join(".");
-			return `${path ? `${path}: ` : ""}${issue.message}`;
-		}).join("; ");
-		throw new Error(`Invalid execute file: ${message}`);
-	}
-	const { pending, sourceActions, actionErrors } = normalizeActionInputs(parsedResult.output);
-	if (actionErrors.length) throw new Error(`Invalid execute file: ${actionErrors.join("; ")}`);
-	const customErrors = validateExecuteRules(pending);
-	if (customErrors.length) throw new Error(`Invalid execute file: ${customErrors.join("; ")}`);
-	return {
-		ops: pending,
-		sourceActions
-	};
-}
-async function writeExecuteFile(path, pending) {
-	const content = stringify(pending);
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, content.endsWith("\n") ? content : `${content}\n`, "utf8");
-}
-function validateExecuteRules(pending) {
-	const errors = [];
-	for (const [index, op] of pending.entries()) {
-		const key = `[${index}]`;
-		errors.push(...validateOperationRules(key, op));
-	}
-	return errors;
-}
-function validateOperationRules(key, op) {
-	const errors = [];
-	if (!Number.isInteger(op.number) || op.number <= 0) errors.push(`${key}: number must be a positive integer`);
-	switch (op.action) {
-		case "set-title":
-			if (!isNonEmptyString(op.title)) errors.push(`${key}: set-title requires title`);
-			break;
-		case "set-body":
-		case "add-comment":
-		case "close-with-comment":
-			if (!isNonEmptyString(op.body)) errors.push(`${key}: ${op.action} requires body`);
-			break;
-		case "add-labels":
-		case "remove-labels":
-		case "set-labels":
-			if (!isStringArray(op.labels)) errors.push(`${key}: ${op.action} requires labels[]`);
-			break;
-		case "add-assignees":
-		case "remove-assignees":
-		case "set-assignees":
-			if (!isStringArray(op.assignees)) errors.push(`${key}: ${op.action} requires assignees[]`);
-			break;
-		case "set-milestone":
-			if (!(typeof op.milestone === "string" || typeof op.milestone === "number")) errors.push(`${key}: set-milestone requires milestone`);
-			break;
-		case "request-reviewers":
-		case "remove-reviewers":
-			if (!isStringArray(op.reviewers)) errors.push(`${key}: ${op.action} requires reviewers[]`);
-			break;
-		default: break;
-	}
-	if (op.ifUnchangedSince && Number.isNaN(Date.parse(op.ifUnchangedSince))) errors.push(`${key}: ifUnchangedSince must be a valid datetime`);
-	return errors;
-}
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.trim().length > 0;
-}
-function isStringArray(value) {
-	return Array.isArray(value) && value.every((entry) => typeof entry === "string") && value.length > 0;
-}
-function normalizeActionInputs(pending) {
-	const normalized = [];
-	const sourceActions = [];
-	const actionErrors = [];
-	for (const [index, op] of pending.entries()) {
-		const sourceAction = op.action;
-		sourceActions.push(sourceAction);
-		const action = resolveActionName(sourceAction);
-		if (!action) {
-			actionErrors.push(`[${index}]: unknown action: ${sourceAction}`);
-			continue;
-		}
-		normalized.push({
-			...op,
-			action
-		});
-	}
-	return {
-		pending: normalized,
-		sourceActions,
-		actionErrors
-	};
-}
-
-//#endregion
-//#region src/execute/sources/execute-md.ts
-const MULTI_SIMPLE_ACTIONS = new Set([
-	"close",
-	"reopen",
-	"clear-milestone",
-	"unlock",
-	"mark-ready-for-review",
-	"convert-to-draft"
-]);
-function parseExecuteMdLine(line) {
-	const trimmed = line.trim();
-	if (!trimmed || isCommentLine(trimmed)) return void 0;
-	const tokens = tokenizeCommand(trimmed);
-	if (!tokens) return {
-		kind: "warning",
-		message: "invalid quoted string syntax"
-	};
-	if (tokens.length === 0) return void 0;
-	const [commandInput, ...args] = tokens;
-	const command = resolveActionName(commandInput);
-	if (!command) return {
-		kind: "warning",
-		message: `unrecognized action pattern: ${commandInput}`
-	};
-	if (command === "set-title") return parseSetTitle(args);
-	if (command === "add-labels") return parseAddLabels(args, commandInput);
-	if (command === "add-assignees") return parseAddAssignees(args, commandInput);
-	if (command === "add-comment") return parseAddComment(args, commandInput);
-	if (command === "close-with-comment") return parseCloseWithComment(args, commandInput);
-	if (MULTI_SIMPLE_ACTIONS.has(command)) return parseMultiSimpleAction(command, args, commandInput);
-	return {
-		kind: "warning",
-		message: `unrecognized action pattern: ${commandInput}`
-	};
-}
-async function readExecuteMdFile(path) {
-	if (!await pathExists(path)) return parseExecuteMd("");
-	return parseExecuteMd(await readFile(path, "utf8"));
-}
-function parseExecuteMd(raw) {
-	const lines = raw.split(/\r?\n/);
-	const ops = [];
-	const parsedLines = [];
-	const warnings = [];
-	let inHtmlCommentBlock = false;
-	for (const [lineIndex, rawLine] of lines.entries()) {
-		const trimmed = rawLine.trim();
-		if (inHtmlCommentBlock) {
-			parsedLines.push({
-				kind: "raw",
-				raw: rawLine
-			});
-			if (trimmed.includes("-->")) inHtmlCommentBlock = false;
-			continue;
-		}
-		if (trimmed.startsWith("<!--")) {
-			parsedLines.push({
-				kind: "raw",
-				raw: rawLine
-			});
-			if (!trimmed.includes("-->")) inHtmlCommentBlock = true;
-			continue;
-		}
-		const parsed = parseExecuteMdLine(rawLine);
-		if (!parsed) {
-			parsedLines.push({
-				kind: "raw",
-				raw: rawLine
-			});
-			continue;
-		}
-		if (parsed.kind === "warning") {
-			warnings.push(`execute-md line ${lineIndex + 1}: ${parsed.message}`);
-			parsedLines.push({
-				kind: "raw",
-				raw: rawLine
-			});
-			continue;
-		}
-		if (parsed.kind === "single") {
-			const opIndex = ops.length;
-			ops.push(parsed.op);
-			parsedLines.push({
-				kind: "single",
-				raw: rawLine,
-				opIndex
-			});
-			continue;
-		}
-		const opIndexes = [];
-		for (const number of parsed.numbers) {
-			opIndexes.push(ops.length);
-			ops.push({
-				action: parsed.action,
-				number
-			});
-		}
-		parsedLines.push({
-			kind: "multi",
-			action: parsed.action,
-			command: parsed.command,
-			opIndexes
-		});
-	}
-	return {
-		ops,
-		warnings,
-		lines: parsedLines
-	};
-}
-function stringifyExecuteMd(parsed, remainingOpIndexes) {
-	const lines = [];
-	for (const line of parsed.lines) {
-		if (line.kind === "raw") {
-			lines.push(line.raw);
-			continue;
-		}
-		if (line.kind === "single") {
-			if (remainingOpIndexes.has(line.opIndex)) lines.push(line.raw);
-			continue;
-		}
-		const numbers = line.opIndexes.filter((index) => remainingOpIndexes.has(index)).map((index) => parsed.ops[index]?.number).filter((value) => typeof value === "number");
-		if (numbers.length > 0) lines.push(`${line.command} ${numbers.map((number) => `#${number}`).join(" ")}`);
-	}
-	return `${lines.join("\n")}\n`;
-}
-function parseSetTitle(args) {
-	if (args.length !== 2) return {
-		kind: "warning",
-		message: "set-title expects: set-title #<number> \"<title>\""
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: "set-title expects a single issue reference (#123)"
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "set-title",
-			number,
-			title: args[1]
-		}
-	};
-}
-function parseAddLabels(args, command) {
-	if (args.length < 2) return {
-		kind: "warning",
-		message: `${command} expects: ${command} #<number> <label1, label2>`
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: `${command} expects a single issue reference (#123)`
-	};
-	const labels = args.slice(1).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
-	if (labels.length === 0) return {
-		kind: "warning",
-		message: `${command} requires at least one label`
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "add-labels",
-			number,
-			labels
-		}
-	};
-}
-function parseAddAssignees(args, command) {
-	if (args.length < 2) return {
-		kind: "warning",
-		message: `${command} expects: ${command} #<number> <assignee1, assignee2>`
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: `${command} expects a single issue reference (#123)`
-	};
-	const assignees = args.slice(1).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
-	if (assignees.length === 0) return {
-		kind: "warning",
-		message: `${command} requires at least one assignee`
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "add-assignees",
-			number,
-			assignees
-		}
-	};
-}
-function parseAddComment(args, command) {
-	if (args.length < 2) return {
-		kind: "warning",
-		message: `${command} expects: ${command} #<number> "<comment>"`
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: `${command} expects a single issue reference (#123)`
-	};
-	const body = args.slice(1).join(" ").trim();
-	if (!body) return {
-		kind: "warning",
-		message: `${command} requires a non-empty comment`
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "add-comment",
-			number,
-			body
-		}
-	};
-}
-function parseCloseWithComment(args, command) {
-	if (args.length < 2) return {
-		kind: "warning",
-		message: `${command} expects: ${command} #<number> "<comment>"`
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: `${command} expects a single issue reference (#123)`
-	};
-	const body = args.slice(1).join(" ").trim();
-	if (!body) return {
-		kind: "warning",
-		message: `${command} requires a non-empty comment`
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "close-with-comment",
-			number,
-			body
-		}
-	};
-}
-function parseMultiSimpleAction(action, args, command) {
-	const numbers = args.map(parseIssueRef);
-	if (numbers.length === 0 || numbers.some((number) => !number)) return {
-		kind: "warning",
-		message: `${command} expects one or more issue references (#123 #456)`
-	};
-	return {
-		kind: "multi",
-		action,
-		command,
-		numbers
-	};
-}
-function parseIssueRef(value) {
-	const match = value.match(/^#(\d+)$/);
-	if (!match) return void 0;
-	const number = Number.parseInt(match[1], 10);
-	if (!Number.isInteger(number) || number <= 0) return void 0;
-	return number;
-}
-function tokenizeCommand(value) {
-	const tokens = [];
-	let index = 0;
-	while (index < value.length) {
-		while (index < value.length && /\s/.test(value[index])) index += 1;
-		if (index >= value.length) break;
-		if (value[index] === "\"") {
-			index += 1;
-			let token = "";
-			let closed = false;
-			while (index < value.length) {
-				const char = value[index];
-				if (char === "\\") {
-					const next = value[index + 1];
-					if (next === "\"" || next === "\\") {
-						token += next;
-						index += 2;
-						continue;
-					}
-				}
-				if (char === "\"") {
-					closed = true;
-					index += 1;
-					break;
-				}
-				token += char;
-				index += 1;
-			}
-			if (!closed) return void 0;
-			tokens.push(token);
-			continue;
-		}
-		const start = index;
-		while (index < value.length && !/\s/.test(value[index])) index += 1;
-		tokens.push(value.slice(start, index));
-	}
-	return tokens;
-}
-function isCommentLine(trimmed) {
-	return trimmed.startsWith("#") || trimmed.startsWith("//") || trimmed.startsWith("<!--");
-}
-
-//#endregion
-//#region package.json
-var version = "0.0.3";
-
-//#endregion
-//#region src/meta.ts
-const GHFS_NAME = "ghfs";
-const GHFS_VERSION = version;
-
-//#endregion
-//#region src/sync/state.ts
-function getSyncStatePath(storageDirAbsolute) {
-	return join(storageDirAbsolute, SYNC_STATE_FILE_NAME);
-}
-async function loadSyncState(storageDirAbsolute) {
-	const path = getSyncStatePath(storageDirAbsolute);
-	try {
-		const raw = await readFile(path, "utf8");
-		const parsed = JSON.parse(raw);
-		if (parsed.version !== 2) return createEmptySyncState();
-		return {
-			version: 2,
-			items: normalizeItems(parsed.items),
-			executions: normalizeExecutions(parsed.executions),
-			ghfsVersion: typeof parsed.ghfsVersion === "string" ? parsed.ghfsVersion : void 0,
-			repo: parsed.repo,
-			lastSyncedAt: parsed.lastSyncedAt,
-			lastSince: parsed.lastSince,
-			lastRepoUpdatedAt: parsed.lastRepoUpdatedAt,
-			lastSyncRun: parsed.lastSyncRun
-		};
-	} catch {
-		return createEmptySyncState();
-	}
-}
-function normalizeItems(items) {
-	if (!items) return {};
-	if (typeof items !== "object" || Array.isArray(items)) return {};
-	const normalizedItems = {};
-	for (const [key, item] of Object.entries(items)) {
-		const normalizedItem = normalizeItem(item);
-		if (!normalizedItem) continue;
-		normalizedItems[key] = normalizedItem;
-	}
-	return normalizedItems;
-}
-function normalizeExecutions(executions) {
-	if (!Array.isArray(executions)) return [];
-	return executions.map((execution) => {
-		if (!execution || typeof execution !== "object") return execution;
-		const typedExecution = execution;
-		if (typedExecution.mode === "dry-run") return {
-			...typedExecution,
-			mode: "report"
-		};
-		return typedExecution;
-	});
-}
-async function saveSyncState(storageDirAbsolute, state) {
-	await mkdir(storageDirAbsolute, { recursive: true });
-	const normalizedState = {
-		...state,
-		ghfsVersion: state.ghfsVersion ?? GHFS_VERSION
-	};
-	await writeFile(getSyncStatePath(storageDirAbsolute), `${JSON.stringify(normalizedState, null, 2)}\n`, "utf8");
-}
-function createEmptySyncState() {
-	return {
-		version: 2,
-		items: {},
-		executions: []
-	};
-}
-function appendExecution(state, result, limit = 20) {
-	const nextExecutions = [result, ...state.executions].slice(0, limit);
-	return {
-		...state,
-		executions: nextExecutions
-	};
-}
-function normalizeItem(item) {
-	if (!item || typeof item !== "object") return void 0;
-	if (!item.lastUpdatedAt || !item.lastSyncedAt || !item.filePath) return void 0;
-	if (!item.data || !item.data.item) return void 0;
-	const comments = Array.isArray(item.data.comments) ? item.data.comments : [];
-	return {
-		...item,
-		data: {
-			...item.data,
-			item: {
-				...item.data.item,
-				reactions: normalizeReactions(item.data.item.reactions)
-			},
-			comments: comments.filter((comment) => comment && typeof comment === "object").map((comment) => ({
-				...comment,
-				reactions: normalizeReactions(comment.reactions)
-			}))
-		}
-	};
-}
-
-//#endregion
-//#region src/execute/sources/per-item.ts
-async function loadPerItemSource(storageDir) {
-	const syncState = await loadSyncState(storageDir);
-	const ops = [];
-	const warnings = [];
-	const repo = syncState.repo;
-	for (const tracked of Object.values(syncState.items)) {
-		const markdownPath = join(storageDir, tracked.filePath);
-		if (!await pathExists(markdownPath)) {
-			warnings.push(`per-item: missing markdown for ${formatIssueNumber(tracked.number, { repo })} (${tracked.filePath})`);
-			continue;
-		}
-		const frontmatter = parseFrontmatter(await readFile(markdownPath, "utf8"));
-		if (!frontmatter) {
-			warnings.push(`per-item: invalid or missing frontmatter for ${formatIssueNumber(tracked.number, { repo })}`);
-			continue;
-		}
-		const trackedItem = tracked.data.item;
-		const itemOps = computePerItemOps({
-			number: tracked.number,
-			current: {
-				title: trackedItem.title,
-				state: trackedItem.state,
-				labels: trackedItem.labels,
-				assignees: trackedItem.assignees,
-				milestone: trackedItem.milestone
-			},
-			desired: frontmatter,
-			updatedAt: trackedItem.updatedAt
-		});
-		ops.push(...itemOps);
-	}
-	return {
-		ops,
-		warnings
-	};
-}
-function computePerItemOps(input) {
-	const ops = [];
-	const ifUnchangedSince = input.updatedAt;
-	if (input.current.title !== input.desired.title) ops.push({
-		action: "set-title",
-		number: input.number,
-		title: input.desired.title,
-		ifUnchangedSince
-	});
-	if (input.current.state !== input.desired.state) ops.push({
-		action: input.desired.state === "closed" ? "close" : "reopen",
-		number: input.number,
-		ifUnchangedSince
-	});
-	if (!sameStringSet(input.current.labels, input.desired.labels)) {
-		const additions = diffStrings(input.desired.labels, input.current.labels);
-		const deletions = diffStrings(input.current.labels, input.desired.labels);
-		if (additions.length > 0 && deletions.length > 0) ops.push({
-			action: "set-labels",
-			number: input.number,
-			labels: input.desired.labels,
-			ifUnchangedSince
-		});
-		else if (additions.length > 0) ops.push({
-			action: "add-labels",
-			number: input.number,
-			labels: additions,
-			ifUnchangedSince
-		});
-		else if (deletions.length > 0) ops.push({
-			action: "remove-labels",
-			number: input.number,
-			labels: deletions,
-			ifUnchangedSince
-		});
-	}
-	if (!sameStringSet(input.current.assignees, input.desired.assignees)) {
-		if (input.desired.assignees.length > 0) ops.push({
-			action: "set-assignees",
-			number: input.number,
-			assignees: input.desired.assignees,
-			ifUnchangedSince
-		});
-		else if (input.current.assignees.length > 0) ops.push({
-			action: "remove-assignees",
-			number: input.number,
-			assignees: input.current.assignees,
-			ifUnchangedSince
-		});
-	}
-	if (normalizeMilestone(input.current.milestone) !== normalizeMilestone(input.desired.milestone)) if (input.desired.milestone) ops.push({
-		action: "set-milestone",
-		number: input.number,
-		milestone: input.desired.milestone,
-		ifUnchangedSince
-	});
-	else ops.push({
-		action: "clear-milestone",
-		number: input.number,
-		ifUnchangedSince
-	});
-	return ops;
-}
-function parseFrontmatter(raw) {
-	const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
-	if (!match) return void 0;
-	let parsed;
-	try {
-		parsed = parse(match[1]);
-	} catch {
-		return;
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
-	const data = parsed;
-	const title = typeof data.title === "string" && data.title.trim().length > 0 ? data.title.trim() : void 0;
-	const state = data.state === "open" || data.state === "closed" ? data.state : void 0;
-	if (!title || !state) return void 0;
-	return {
-		title,
-		state,
-		labels: normalizeStringArray(data.labels ?? data.tags),
-		assignees: normalizeStringArray(data.assignees),
-		milestone: normalizeMilestone(data.milestone)
-	};
-}
-function normalizeStringArray(value) {
-	if (!Array.isArray(value)) return [];
-	const unique = /* @__PURE__ */ new Set();
-	for (const entry of value) {
-		if (typeof entry !== "string") continue;
-		const normalized = entry.trim();
-		if (!normalized) continue;
-		unique.add(normalized);
-	}
-	return [...unique];
-}
-function sameStringSet(left, right) {
-	if (left.length !== right.length) return false;
-	const sortedLeft = [...left].sort();
-	const sortedRight = [...right].sort();
-	return sortedLeft.every((value, index) => value === sortedRight[index]);
-}
-function normalizeMilestone(value) {
-	if (typeof value !== "string") return null;
-	const normalized = value.trim();
-	return normalized.length > 0 ? normalized : null;
-}
-function diffStrings(source, target) {
-	const targetSet = new Set(target);
-	return source.filter((value) => !targetSet.has(value));
-}
-
-//#endregion
-//#region src/execute/sources/index.ts
-async function loadExecuteSources(executeFilePath) {
-	const storageDir = dirname(executeFilePath);
-	const executeMdPath = join(storageDir, EXECUTE_MD_FILE_NAME);
-	const yml = await readAndValidateExecuteFileWithSource(executeFilePath);
-	const ymlOps = yml.ops;
-	const executeMd = await readExecuteMdFile(executeMdPath);
-	const perItem = await loadPerItemSource(storageDir);
-	const mergedOps = [
-		...ymlOps,
-		...executeMd.ops,
-		...perItem.ops
-	];
-	const customErrors = validateExecuteRules(mergedOps);
-	if (customErrors.length) throw new Error(`Invalid execute file: ${customErrors.join("; ")}`);
-	return {
-		ops: mergedOps,
-		warnings: [...executeMd.warnings, ...perItem.warnings],
-		async writeRemaining(remainingIndexes) {
-			await writeExecuteFile(executeFilePath, ymlOps.map((op, index) => ({
-				op,
-				index
-			})).filter((item) => remainingIndexes.has(item.index)).map(({ op, index }) => ({
-				...op,
-				action: yml.sourceActions[index] ?? op.action
-			})));
-			if (!await pathExists(executeMdPath)) return;
-			const mdOffset = ymlOps.length;
-			const mdRemaining = /* @__PURE__ */ new Set();
-			for (const index of remainingIndexes) if (index >= mdOffset) mdRemaining.add(index - mdOffset);
-			await writeFile(executeMdPath, stringifyExecuteMd(executeMd, mdRemaining), "utf-8");
-		}
-	};
-}
-
-//#endregion
-//#region src/execute/index.ts
-var ExecuteCancelledError = class extends Error {
-	constructor() {
-		super("Execution cancelled");
-		this.name = "ExecuteCancelledError";
-	}
-};
-function isExecuteCancelledError(error) {
-	return error instanceof ExecuteCancelledError;
-}
-async function executePendingChanges(options) {
-	try {
-		await ensureExecuteArtifacts(options.executeFilePath);
-		const sources = await loadExecuteSources(options.executeFilePath);
-		const allOps = sources.ops;
-		for (const warning of sources.warnings) options.onWarning?.(warning);
-		if (allOps.length === 0) return {
-			runId: createRunId(),
-			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-			mode: "report",
-			repo: options.repo,
-			planned: 0,
-			applied: 0,
-			failed: 0,
-			details: []
-		};
-		const interactive = process.stdin.isTTY && !options.nonInteractive;
-		if (interactive && !options.prompts) throw new Error("Interactive execute prompts are unavailable. Use --non-interactive or provide prompts.");
-		const selected = Array.isArray(options.selectedIndexes) ? selectOperationsByIndexes(allOps, options.selectedIndexes) : interactive ? await selectOperations(allOps, options.prompts) : allOps.map((op, index) => ({
-			op,
-			index
-		}));
-		const runId = createRunId();
-		const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-		const mode = options.apply ? "apply" : "report";
-		options.reporter?.onStart?.({
-			repo: options.repo,
-			mode,
-			planned: selected.length
-		});
-		if (selected.length === 0) {
-			const result = {
-				runId,
-				createdAt,
-				mode,
-				repo: options.repo,
-				planned: 0,
-				applied: 0,
-				failed: 0,
-				details: []
-			};
-			options.reporter?.onComplete?.({ result });
-			return result;
-		}
-		options.onPlan?.(selected.map((item) => item.op));
-		if (!options.apply) {
-			const result = {
-				runId,
-				createdAt,
-				mode: "report",
-				repo: options.repo,
-				planned: selected.length,
-				applied: 0,
-				failed: 0,
-				details: selected.map(({ op, index }) => ({
-					op: index + 1,
-					action: op.action,
-					number: op.number,
-					status: "planned",
-					message: describeExecutionAction(op.action, op.number)
-				}))
-			};
-			options.reporter?.onComplete?.({ result });
-			return result;
-		}
-		if (interactive) {
-			if (!await confirmApply(selected.length, options.prompts)) throw new ExecuteCancelledError();
-		}
-		const provider = options.provider ?? createRepositoryProvider({
-			token: options.token,
-			repo: options.repo
-		});
-		const details = [];
-		const appliedIndexes = /* @__PURE__ */ new Set();
-		let applied = 0;
-		let failed = 0;
-		for (const { op, index } of selected) try {
-			const target = await applyOperation(provider, op);
-			appliedIndexes.add(index);
-			await persistRemainingOps(sources.writeRemaining, allOps, appliedIndexes);
-			const detail = {
-				op: index + 1,
-				action: op.action,
-				number: op.number,
-				target,
-				status: "applied",
-				message: describeExecutionAction(op.action, op.number)
-			};
-			details.push(detail);
-			applied += 1;
-			options.reporter?.onProgress?.({
-				repo: options.repo,
-				mode: "apply",
-				planned: selected.length,
-				completed: details.length,
-				applied,
-				failed,
-				detail
-			});
-		} catch (error) {
-			failed += 1;
-			const detail = {
-				op: index + 1,
-				action: op.action,
-				number: op.number,
-				status: "failed",
-				message: error.message
-			};
-			details.push(detail);
-			options.reporter?.onProgress?.({
-				repo: options.repo,
-				mode: "apply",
-				planned: selected.length,
-				completed: details.length,
-				applied,
-				failed,
-				detail
-			});
-			if (!options.continueOnError) break;
-		}
-		const result = {
-			runId,
-			createdAt,
-			mode: "apply",
-			repo: options.repo,
-			planned: selected.length,
-			applied,
-			failed,
-			details
-		};
-		options.reporter?.onComplete?.({ result });
-		return result;
-	} catch (error) {
-		options.reporter?.onError?.({ error });
-		throw error;
-	}
-}
-async function persistRemainingOps(writeRemaining, allOps, appliedIndexes) {
-	const remainingIndexes = /* @__PURE__ */ new Set();
-	for (const [index] of allOps.entries()) if (!appliedIndexes.has(index)) remainingIndexes.add(index);
-	await writeRemaining(remainingIndexes);
-}
-async function applyOperation(provider, op) {
-	const item = await provider.fetchItemSnapshot(op.number);
-	const isPull = item.kind === "pull";
-	if (op.ifUnchangedSince) {
-		const remoteUpdatedAt = item.updatedAt;
-		if (remoteUpdatedAt && new Date(remoteUpdatedAt).getTime() > new Date(op.ifUnchangedSince).getTime()) throw new Error(`Operation conflict: remote updated_at=${remoteUpdatedAt}`);
-	}
-	switch (op.action) {
-		case "close":
-			await provider.actionClose(op.number);
-			break;
-		case "reopen":
-			await provider.actionReopen(op.number);
-			break;
-		case "set-title":
-			await provider.actionSetTitle(op.number, op.title);
-			break;
-		case "set-body":
-			await provider.actionSetBody(op.number, op.body);
-			break;
-		case "add-comment":
-			await provider.actionAddComment(op.number, op.body);
-			break;
-		case "close-with-comment":
-			await provider.actionAddComment(op.number, op.body);
-			await provider.actionClose(op.number);
-			break;
-		case "add-labels":
-			await provider.actionAddLabels(op.number, op.labels);
-			break;
-		case "remove-labels":
-			await provider.actionRemoveLabels(op.number, op.labels);
-			break;
-		case "set-labels":
-			await provider.actionSetLabels(op.number, op.labels);
-			break;
-		case "add-assignees":
-			await provider.actionAddAssignees(op.number, op.assignees);
-			break;
-		case "remove-assignees":
-			await provider.actionRemoveAssignees(op.number, op.assignees);
-			break;
-		case "set-assignees":
-			await provider.actionSetAssignees(op.number, op.assignees);
-			break;
-		case "set-milestone":
-			await provider.actionSetMilestone(op.number, op.milestone);
-			break;
-		case "clear-milestone":
-			await provider.actionClearMilestone(op.number);
-			break;
-		case "lock":
-			await provider.actionLock(op.number, op.reason);
-			break;
-		case "unlock":
-			await provider.actionUnlock(op.number);
-			break;
-		case "request-reviewers":
-			ensurePullAction(op.action, op.number, isPull);
-			await provider.actionRequestReviewers(op.number, op.reviewers);
-			break;
-		case "remove-reviewers":
-			ensurePullAction(op.action, op.number, isPull);
-			await provider.actionRemoveReviewers(op.number, op.reviewers);
-			break;
-		case "mark-ready-for-review":
-			ensurePullAction(op.action, op.number, isPull);
-			await provider.actionMarkReadyForReview(op.number);
-			break;
-		case "convert-to-draft":
-			ensurePullAction(op.action, op.number, isPull);
-			await provider.actionConvertToDraft(op.number);
-			break;
-		default: throw new Error(`Unsupported action: ${String(op.action)}`);
-	}
-	return item.kind;
-}
-function createRunId() {
-	return `run_${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "")}_${Math.random().toString(36).slice(2, 7)}`;
-}
-async function selectOperations(ops, prompts) {
-	const selectedIndexes = await prompts.selectOperations(ops);
-	if (!selectedIndexes) throw new ExecuteCancelledError();
-	const selectedIndexesSet = new Set(selectedIndexes);
-	return ops.map((op, index) => ({
-		op,
-		index
-	})).filter((item) => selectedIndexesSet.has(item.index));
-}
-async function confirmApply(count, prompts) {
-	const result = await prompts.confirmApply(count);
-	if (result == null) return false;
-	return result;
-}
-function selectOperationsByIndexes(ops, selectedIndexes) {
-	const selectedSet = /* @__PURE__ */ new Set();
-	for (const index of selectedIndexes) if (Number.isInteger(index) && index >= 0 && index < ops.length) selectedSet.add(index);
-	return ops.map((op, index) => ({
-		op,
-		index
-	})).filter((item) => selectedSet.has(item.index));
-}
-function ensurePullAction(action, number, isPull) {
-	if (!isPull) throw new Error(`Action ${action} requires #${number} to be a pull request`);
-}
-function describeExecutionAction(action, number) {
-	return `${action} #${number}`;
-}
-
-//#endregion
-//#region src/sync/execution-log.ts
-async function appendExecutionResult(storageDirAbsolute, result) {
-	await saveSyncState(storageDirAbsolute, appendExecution(await loadSyncState(storageDirAbsolute), result));
-}
-
-//#endregion
-//#region src/utils/sync.ts
-function resolveSince(options, syncState) {
-	if (options.full) return void 0;
-	if (options.since) return options.since;
-	return syncState.lastSyncedAt;
-}
-function normalizeIssueNumbers(numbers) {
-	if (!numbers) return void 0;
-	return [...new Set(numbers.filter((number) => Number.isInteger(number) && number > 0))];
-}
-
-//#endregion
-//#region src/sync/markdown.ts
-const FIELDS_ALWAYS_KEEP = new Set(["labels", "assignees"]);
-const FIELDS_ALWAYS_EXCLUDE = new Set(["repo", "kind"]);
-const REACTION_FIELDS = [
-	{
-		key: "plusOne",
-		emoji: "👍"
-	},
-	{
-		key: "minusOne",
-		emoji: "👎"
-	},
-	{
-		key: "laugh",
-		emoji: "😄"
-	},
-	{
-		key: "hooray",
-		emoji: "🎉"
-	},
-	{
-		key: "confused",
-		emoji: "😕"
-	},
-	{
-		key: "heart",
-		emoji: "❤️"
-	},
-	{
-		key: "rocket",
-		emoji: "🚀"
-	},
-	{
-		key: "eyes",
-		emoji: "👀"
-	}
-];
-function renderIssueMarkdown(input) {
-	const url = input.url || `https://github.com/${input.repo}/${input.kind === "pull" ? "pull" : "issues"}/${input.number}`;
-	const frontmatter = {
-		repo: input.repo,
-		number: input.number,
-		kind: input.kind,
-		url,
-		state: input.state,
-		title: input.title,
-		author: input.author,
-		labels: input.labels,
-		assignees: input.assignees,
-		milestone: input.milestone,
-		created_at: input.createdAt,
-		updated_at: input.updatedAt,
-		closed_at: input.closedAt,
-		last_synced_at: input.lastSyncedAt,
-		reactions: formatReactionsFrontmatter(input.reactions),
-		is_draft: input.pr?.isDraft,
-		merged: input.pr?.merged,
-		merged_at: input.pr?.mergedAt,
-		base_ref: input.pr?.baseRef,
-		head_ref: input.pr?.headRef,
-		reviewers_requested: input.pr?.requestedReviewers
-	};
-	const compactFrontmatter = Object.fromEntries(Object.entries(frontmatter).filter(([key, value]) => {
-		if (FIELDS_ALWAYS_EXCLUDE.has(key)) return false;
-		if (FIELDS_ALWAYS_KEEP.has(key)) return true;
-		if (value === void 0 || value === null || value === false) return false;
-		if (Array.isArray(value)) return value.length > 0;
-		return true;
-	}));
-	const sections = [
-		`# ${input.title}`,
-		"",
-		"## Description",
-		"",
-		input.body?.trim() || "_No description._"
-	];
-	const bodyReactionsLine = formatReactionsLine(input.reactions);
-	if (bodyReactionsLine) {
-		sections.push("");
-		sections.push(bodyReactionsLine);
-	}
-	sections.push("");
-	sections.push("---");
-	sections.push("");
-	sections.push("## Comments");
-	sections.push("");
-	if (input.comments.length === 0) sections.push("_No comments._");
-	else for (const [index, comment] of input.comments.entries()) {
-		if (index > 0) {
-			sections.push("---");
-			sections.push("");
-		}
-		sections.push(`### @${comment.author} on ${comment.createdAt}`);
-		sections.push(`<!-- comment-id:${comment.id} updated:${comment.updatedAt} -->`);
-		sections.push("");
-		sections.push(comment.body?.trim() || "_No content._");
-		const reactionsLine = formatReactionsLine(comment.reactions);
-		if (reactionsLine) {
-			sections.push("");
-			sections.push(reactionsLine);
-		}
-		sections.push("");
-	}
-	return [
-		"---",
-		stringify(compactFrontmatter).trimEnd(),
-		"---",
-		"",
-		...sections,
-		""
-	].join("\n");
-}
-function formatReactionsLine(reactions) {
-	const entries = getReactionEntries(reactions);
-	if (entries.length === 0) return void 0;
-	return `> ${entries.map((entry) => `\`${entry.emoji} ${entry.count}\``).join(" | ")}`;
-}
-function formatReactionsFrontmatter(reactions) {
-	const entries = getReactionEntries(reactions);
-	if (entries.length === 0) return void 0;
-	return Object.fromEntries(entries.map((entry) => [entry.emoji, entry.count]));
-}
-function getReactionEntries(reactions) {
-	const normalized = normalizeReactions(reactions);
-	return REACTION_FIELDS.map(({ key, emoji }) => {
-		const count = normalized[key];
-		if (!count) return void 0;
-		return {
-			emoji,
-			count
-		};
-	}).filter((entry) => Boolean(entry));
-}
-
-//#endregion
-//#region src/utils/string.ts
-function slugifyTitle(title, maxLength = 48) {
-	const normalized = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-	if (!normalized) return "item";
-	return normalized.slice(0, maxLength).replace(/-+$/g, "") || "item";
-}
-
-//#endregion
-//#region src/sync/paths.ts
-const FILE_NUMBER_PAD_LENGTH = 5;
-const MAX_SLUG_LENGTH = 48;
-function getIssueMarkdownPath(storageDirAbsolute, number, state, title) {
-	const fileName = getItemFileName(number, title);
-	if (state === "closed") return join(storageDirAbsolute, ISSUE_DIR_NAME, CLOSED_DIR_NAME, fileName);
-	return join(storageDirAbsolute, ISSUE_DIR_NAME, fileName);
-}
-function getPullMarkdownPath(storageDirAbsolute, number, state, title) {
-	const fileName = getItemFileName(number, title);
-	if (state === "closed") return join(storageDirAbsolute, PULL_DIR_NAME, CLOSED_DIR_NAME, fileName);
-	return join(storageDirAbsolute, PULL_DIR_NAME, fileName);
-}
-function getItemMarkdownPath(storageDirAbsolute, kind, number, state, title) {
-	if (kind === "pull") return getPullMarkdownPath(storageDirAbsolute, number, state, title);
-	return getIssueMarkdownPath(storageDirAbsolute, number, state, title);
-}
-function getItemFileName(number, title) {
-	return `${String(number).padStart(FILE_NUMBER_PAD_LENGTH, "0")}-${slugifyTitle(title, MAX_SLUG_LENGTH)}.md`;
-}
-function getPrPatchPath(storageDirAbsolute, number, title) {
-	return join(storageDirAbsolute, PULL_DIR_NAME, getItemFileName(number, title).replace(/\.md$/, ".patch"));
-}
-
-//#endregion
-//#region src/sync/sync-repository-utils.ts
-function createCounters(scanned = 0, selected = 0) {
-	return {
-		scanned,
-		selected,
-		processed: 0,
-		skipped: 0,
-		written: 0,
-		moved: 0,
-		patchesWritten: 0,
-		patchesDeleted: 0
-	};
-}
-function addItemStats(counters, stats) {
-	counters.skipped += stats.skipped;
-	counters.written += stats.written;
-	counters.moved += stats.moved;
-	counters.patchesWritten += stats.patchesWritten;
-	counters.patchesDeleted += stats.patchesDeleted;
-}
-function shouldSyncKind(sync, kind) {
-	return kind === "issue" ? sync.issues : sync.pulls;
-}
-function shouldSyncIssue(sync, issue) {
-	return shouldSyncKind(sync, issue.kind);
-}
-function resolvePatchPlan(patchesMode, kind, state) {
-	if (kind !== "pull") return {
-		shouldWritePatch: false,
-		shouldDeletePatch: false
-	};
-	const shouldWritePatch = patchesMode === "all" || patchesMode === "open" && state === "open";
-	return {
-		shouldWritePatch,
-		shouldDeletePatch: !shouldWritePatch
-	};
-}
-function relativeToStorage(storageDirAbsolute, absolutePath) {
-	if (absolutePath.startsWith(storageDirAbsolute)) return absolutePath.slice(storageDirAbsolute.length + 1);
-	return basename(absolutePath);
-}
-
-//#endregion
-//#region src/sync/sync-repository-storage.ts
-async function resolveIssuePaths(storageDirAbsolute, kind, number, title, state, trackedFilePath) {
-	const closedPath = getItemMarkdownPath(storageDirAbsolute, kind, number, "closed", title);
-	const openPath = getItemMarkdownPath(storageDirAbsolute, kind, number, "open", title);
-	const hasClosedFile = await pathExists(closedPath);
-	const hasOpenFile = await pathExists(openPath);
-	const trackedPath = resolveTrackedPath(storageDirAbsolute, trackedFilePath);
-	const hasTrackedFile = trackedPath ? await pathExists(trackedPath) : false;
-	const targetPath = getItemMarkdownPath(storageDirAbsolute, kind, number, state, title);
-	const hasTargetFile = state === "open" ? hasOpenFile : hasClosedFile;
-	const matchedPaths = await findMatchedMarkdownPaths(storageDirAbsolute, kind, number, [
-		openPath,
-		closedPath,
-		trackedPath
-	]);
-	return {
-		openPath,
-		closedPath,
-		targetPath,
-		patchPath: getPrPatchPath(storageDirAbsolute, number, title),
-		trackedPath,
-		hasOpenFile,
-		hasClosedFile,
-		hasTrackedFile,
-		matchedPaths,
-		hasLocalFile: hasOpenFile || hasClosedFile || hasTrackedFile || matchedPaths.length > 0,
-		hasTargetFile
-	};
-}
-async function moveMarkdownByState(paths, state) {
-	const sourcePath = resolveMoveSourcePath(paths, state);
-	if (!sourcePath) return 0;
-	if (sourcePath === paths.targetPath) return 0;
-	if (await pathExists(paths.targetPath)) return 0;
-	await movePath(sourcePath, paths.targetPath);
-	return 1;
-}
-function resolveMoveSourcePath(paths, state) {
-	if (paths.hasTrackedFile && paths.trackedPath && paths.trackedPath !== paths.targetPath) return paths.trackedPath;
-	if (state === "open" && paths.hasClosedFile && paths.closedPath !== paths.targetPath) return paths.closedPath;
-	if (state === "closed" && paths.hasOpenFile && paths.openPath !== paths.targetPath) return paths.openPath;
-	if (paths.hasOpenFile && paths.openPath !== paths.targetPath) return paths.openPath;
-	if (paths.hasClosedFile && paths.closedPath !== paths.targetPath) return paths.closedPath;
-	return paths.matchedPaths.find((path) => path !== paths.targetPath);
-}
-function getExistingMarkdownPaths(paths) {
-	const markdownPaths = /* @__PURE__ */ new Set();
-	if (paths.hasOpenFile) markdownPaths.add(paths.openPath);
-	if (paths.hasClosedFile) markdownPaths.add(paths.closedPath);
-	if (paths.hasTrackedFile && paths.trackedPath) markdownPaths.add(paths.trackedPath);
-	for (const matchedPath of paths.matchedPaths) markdownPaths.add(matchedPath);
-	return [...markdownPaths];
-}
-function resolveTrackedPath(storageDirAbsolute, trackedFilePath) {
-	if (!trackedFilePath) return void 0;
-	if (isAbsolute(trackedFilePath)) return trackedFilePath;
-	return join(storageDirAbsolute, trackedFilePath);
-}
-function resolveTrackedPathOrJoin(storageDirAbsolute, trackedFilePath) {
-	return resolveTrackedPath(storageDirAbsolute, trackedFilePath) ?? join(storageDirAbsolute, trackedFilePath);
-}
-async function findMatchedMarkdownPaths(storageDirAbsolute, kind, number, knownPaths) {
-	const matchedPaths = /* @__PURE__ */ new Set();
-	const knownPathSet = new Set(knownPaths.filter(Boolean));
-	const padded = String(number).padStart(5, "0");
-	const kindDir = kind === "issue" ? ISSUE_DIR_NAME : PULL_DIR_NAME;
-	for (const stateDir of ["", CLOSED_DIR_NAME]) {
-		const dir = stateDir ? join(storageDirAbsolute, kindDir, stateDir) : join(storageDirAbsolute, kindDir);
-		let files;
-		try {
-			files = await readdir(dir);
-		} catch {
-			continue;
-		}
-		for (const fileName of files) {
-			if (!fileName.startsWith(`${padded}-`) || !fileName.endsWith(".md")) continue;
-			const fullPath = join(dir, fileName);
-			if (!knownPathSet.has(fullPath)) matchedPaths.add(fullPath);
-		}
-	}
-	return [...matchedPaths];
-}
-function updateTrackedItem(context, number, kind, state, issueUpdatedAt, markdownPath, patchPath, data) {
-	context.syncState.items[String(number)] = {
-		number,
-		kind,
-		state,
-		lastUpdatedAt: issueUpdatedAt,
-		lastSyncedAt: context.syncedAt,
-		filePath: relativeToStorage(context.storageDirAbsolute, markdownPath),
-		patchPath: patchPath ? relativeToStorage(context.storageDirAbsolute, patchPath) : void 0,
-		data
-	};
-}
-async function pruneTrackedClosedItems(storageDirAbsolute, syncState, sync) {
-	if (sync.issues) await rm(join(storageDirAbsolute, ISSUE_DIR_NAME, CLOSED_DIR_NAME), {
-		recursive: true,
-		force: true
-	});
-	if (sync.pulls) await rm(join(storageDirAbsolute, PULL_DIR_NAME, CLOSED_DIR_NAME), {
-		recursive: true,
-		force: true
-	});
-	let patchesDeleted = 0;
-	for (const item of Object.values(syncState.items)) {
-		if (item.state !== "closed") continue;
-		if (!shouldSyncKind(sync, item.kind)) continue;
-		await removePath(resolveTrackedPathOrJoin(storageDirAbsolute, item.filePath));
-		if (item.kind === "pull") patchesDeleted += await removePatchIfExists(storageDirAbsolute, item.number);
-		delete syncState.items[String(item.number)];
-	}
-	return patchesDeleted;
-}
-async function pruneMissingOpenTrackedItems(storageDirAbsolute, syncState, openNumbers, sync) {
-	let patchesDeleted = 0;
-	for (const item of Object.values(syncState.items)) {
-		if (item.state !== "open") continue;
-		if (!shouldSyncKind(sync, item.kind)) continue;
-		if (openNumbers.has(item.number)) continue;
-		await removePath(resolveTrackedPathOrJoin(storageDirAbsolute, item.filePath));
-		if (item.kind === "pull") patchesDeleted += await removePatchIfExists(storageDirAbsolute, item.number);
-		delete syncState.items[String(item.number)];
-	}
-	return patchesDeleted;
-}
-
-//#endregion
-//#region src/sync/sync-repository-item.ts
-async function prepareIssueCandidateSync(context, issue) {
-	const number = issue.number;
-	const kind = issue.kind;
-	const state = issue.state;
-	const tracked = context.syncState.items[String(number)];
-	const paths = await resolveIssuePaths(context.storageDirAbsolute, kind, number, issue.title, state, tracked?.filePath);
-	const patchPlan = resolvePatchPlan(context.config.sync.patches, kind, state);
-	if (state === "closed" && context.config.sync.closed === false) {
-		delete context.syncState.items[String(number)];
-		return {
-			number,
-			kind,
-			state,
-			action: "remove",
-			paths,
-			patchPlan
-		};
-	}
-	if (state === "closed" && context.config.sync.closed === true && !paths.hasLocalFile) {
-		delete context.syncState.items[String(number)];
-		return {
-			number,
-			kind,
-			state,
-			action: "remove",
-			paths,
-			patchPlan
-		};
-	}
-	const hasCanonicalData = Boolean(tracked?.data && (kind !== "pull" || tracked.data.pull));
-	const shouldRefetch = !tracked || tracked.lastUpdatedAt !== issue.updatedAt || !hasCanonicalData;
-	const data = shouldRefetch ? await fetchCanonicalData(context, issue) : tracked.data;
-	updateTrackedItem(context, number, kind, state, issue.updatedAt, paths.targetPath, patchPlan.shouldWritePatch ? paths.patchPath : void 0, data);
-	return {
-		number,
-		kind,
-		state,
-		action: resolveSyncAction(shouldRefetch, paths, state),
-		paths,
-		patchPlan
-	};
-}
-async function materializePreparedIssue(context, candidate) {
-	const { number, kind, state, action, patchPlan, paths } = candidate;
-	if (action === "remove") {
-		for (const markdownPath of getExistingMarkdownPaths(paths)) await removePath(markdownPath);
-		let patchesDeleted = 0;
-		if (kind === "pull") patchesDeleted += await removePatchIfExists(context.storageDirAbsolute, number);
-		return {
-			kind,
-			action,
-			skipped: 0,
-			written: 0,
-			moved: 0,
-			patchesWritten: 0,
-			patchesDeleted
-		};
-	}
-	if (action === "skip") {
-		let patchesDeleted = 0;
-		if (patchPlan.shouldDeletePatch) patchesDeleted += await removePatchIfExists(context.storageDirAbsolute, number);
-		return {
-			kind,
-			action,
-			skipped: 1,
-			written: 0,
-			moved: 0,
-			patchesWritten: 0,
-			patchesDeleted
-		};
-	}
-	const tracked = context.syncState.items[String(number)];
-	if (!tracked) throw new Error(`Missing tracked canonical data for ${formatIssueNumber(number, {
-		repo: context.repoSlug,
-		kind
-	})}`);
-	const markdown = buildTrackedMarkdown(context, tracked);
-	const moved = await moveMarkdownByState(paths, state);
-	await writeFileEnsured(paths.targetPath, markdown);
-	const patchStats = await syncPatchByPlan(context, number, paths.patchPath, patchPlan);
-	return {
-		kind,
-		action,
-		skipped: 0,
-		written: 1,
-		moved,
-		patchesWritten: patchStats.patchesWritten,
-		patchesDeleted: patchStats.patchesDeleted
-	};
-}
-async function rematerializeTrackedMarkdown(context) {
-	let processed = 0;
-	let written = 0;
-	let moved = 0;
-	for (const tracked of Object.values(context.syncState.items)) {
-		const paths = await resolveIssuePaths(context.storageDirAbsolute, tracked.kind, tracked.number, tracked.data.item.title, tracked.state, tracked.filePath);
-		moved += await moveMarkdownByState(paths, tracked.state);
-		await writeFileEnsured(paths.targetPath, buildTrackedMarkdown(context, tracked));
-		tracked.filePath = relativeToStorage(context.storageDirAbsolute, paths.targetPath);
-		tracked.lastSyncedAt = context.syncedAt;
-		processed += 1;
-		written += 1;
-	}
-	return {
-		processed,
-		written,
-		moved
-	};
-}
-async function reconcileMarkdownFilesByScan(context) {
-	let written = 0;
-	let moved = 0;
-	const expectedPaths = /* @__PURE__ */ new Set();
-	for (const tracked of Object.values(context.syncState.items)) {
-		const paths = await resolveIssuePaths(context.storageDirAbsolute, tracked.kind, tracked.number, tracked.data.item.title, tracked.state, tracked.filePath);
-		expectedPaths.add(paths.targetPath);
-		const movedByState = !paths.hasTargetFile ? await moveMarkdownByState(paths, tracked.state) : 0;
-		let changed = movedByState > 0;
-		if (!await pathExists(paths.targetPath)) {
-			await writeFileEnsured(paths.targetPath, buildTrackedMarkdown(context, tracked));
-			written += 1;
-			changed = true;
-		}
-		tracked.filePath = relativeToStorage(context.storageDirAbsolute, paths.targetPath);
-		if (changed) tracked.lastSyncedAt = context.syncedAt;
-		moved += movedByState;
-	}
-	moved += await moveExtraMarkdownFilesToClosed(context.storageDirAbsolute, expectedPaths);
-	return {
-		written,
-		moved
-	};
-}
-function resolveSyncAction(shouldRefetch, paths, state) {
-	if (shouldRefetch) return "refetch";
-	if (paths.hasTargetFile) return "skip";
-	if (resolveMoveSourcePath(paths, state)) return "move";
-	return "create";
-}
-async function fetchCanonicalData(context, issue) {
-	return {
-		item: issue,
-		comments: await context.provider.fetchComments(issue.number),
-		pull: issue.kind === "pull" ? await context.provider.fetchPullMetadata(issue.number) : void 0
-	};
-}
-async function syncPatchByPlan(context, number, patchPath, patchPlan) {
-	let patchesWritten = 0;
-	let patchesDeleted = 0;
-	if (patchPlan.shouldWritePatch) {
-		const patch = await context.provider.fetchPullPatch(number);
-		await removePatchIfExists(context.storageDirAbsolute, number);
-		await writeFileEnsured(patchPath, patch);
-		patchesWritten += 1;
-	}
-	if (patchPlan.shouldDeletePatch) patchesDeleted += await removePatchIfExists(context.storageDirAbsolute, number);
-	return {
-		patchesWritten,
-		patchesDeleted
-	};
-}
-function buildTrackedMarkdown(context, tracked) {
-	return renderIssueMarkdown({
-		repo: context.repoSlug,
-		number: tracked.data.item.number,
-		kind: tracked.data.item.kind,
-		url: tracked.data.item.url,
-		state: tracked.data.item.state,
-		title: tracked.data.item.title,
-		body: tracked.data.item.body ?? "",
-		author: tracked.data.item.author ?? "unknown",
-		labels: tracked.data.item.labels,
-		assignees: tracked.data.item.assignees,
-		milestone: tracked.data.item.milestone,
-		createdAt: tracked.data.item.createdAt,
-		updatedAt: tracked.data.item.updatedAt,
-		closedAt: tracked.data.item.closedAt,
-		lastSyncedAt: context.syncedAt,
-		reactions: normalizeReactions(tracked.data.item.reactions),
-		comments: tracked.data.comments.map((comment) => ({
-			id: comment.id,
-			author: comment.author ?? "unknown",
-			body: comment.body ?? "",
-			createdAt: comment.createdAt,
-			updatedAt: comment.updatedAt,
-			reactions: normalizeReactions(comment.reactions)
-		})),
-		pr: tracked.data.pull
-	});
-}
-async function moveExtraMarkdownFilesToClosed(storageDirAbsolute, expectedPaths) {
-	let moved = 0;
-	moved += await moveOpenMarkdownFilesToClosed(join(storageDirAbsolute, ISSUE_DIR_NAME), expectedPaths);
-	moved += await moveOpenMarkdownFilesToClosed(join(storageDirAbsolute, PULL_DIR_NAME), expectedPaths);
-	return moved;
-}
-async function moveOpenMarkdownFilesToClosed(kindDirAbsolute, expectedPaths) {
-	let moved = 0;
-	const openFiles = await listOpenMarkdownFiles(kindDirAbsolute);
-	const closedDirAbsolute = join(kindDirAbsolute, CLOSED_DIR_NAME);
-	for (const markdownPath of openFiles) {
-		if (expectedPaths.has(markdownPath)) continue;
-		await movePath(markdownPath, await resolveUniqueClosedTarget(closedDirAbsolute, basename(markdownPath)));
-		moved += 1;
-	}
-	return moved;
-}
-async function listOpenMarkdownFiles(kindDirAbsolute) {
-	try {
-		return (await readdir(kindDirAbsolute, {
-			withFileTypes: true,
-			encoding: "utf8"
-		})).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => join(kindDirAbsolute, entry.name));
-	} catch {
-		return [];
-	}
-}
-async function resolveUniqueClosedTarget(closedDirAbsolute, fileName) {
-	const baseName = fileName.replace(/\.md$/i, "");
-	let candidate = join(closedDirAbsolute, fileName);
-	let index = 1;
-	while (await pathExists(candidate)) {
-		candidate = join(closedDirAbsolute, `${baseName}-extra-${index}.md`);
-		index += 1;
-	}
-	return candidate;
-}
-
-//#endregion
-//#region src/sync/sync-repository-provider.ts
-async function fetchIssueCandidatesByPagination(context, since) {
-	const issues = [];
-	let scanned = 0;
-	const allOpenNumbers = context.config.sync.closed === false && !since ? /* @__PURE__ */ new Set() : void 0;
-	const state = context.config.sync.closed === false ? "open" : "all";
-	for await (const page of context.provider.paginateItems({
-		state,
-		since
-	})) for (const issue of page) {
-		if (!shouldSyncIssue(context.config.sync, issue)) continue;
-		scanned += 1;
-		issues.push(issue);
-		if (state === "open" && allOpenNumbers) allOpenNumbers.add(issue.number);
-	}
-	return {
-		issues,
-		scanned,
-		allOpenNumbers
-	};
-}
-async function fetchIssueCandidatesByNumbers(context, numbers) {
-	const issues = (await context.provider.fetchItemsByNumbers(numbers)).filter((issue) => shouldSyncIssue(context.config.sync, issue));
-	return {
-		issues,
-		scanned: issues.length
-	};
-}
-
-//#endregion
-//#region src/utils/markdown.ts
-function getTimestamp(value) {
-	const timestamp = Date.parse(value);
-	if (Number.isFinite(timestamp)) return timestamp;
-	return Number.NEGATIVE_INFINITY;
-}
-function renderRowsTable(rows) {
-	const lines = ["| Number | Title | Labels | Updated | File |", "| --- | --- | --- | --- | --- |"];
-	if (rows.length === 0) {
-		lines.push("| - | - | - | - | - |");
-		return lines;
-	}
-	for (const row of rows) {
-		const labels = row.labels.length ? row.labels.map((label) => `\`${escapeInlineCode(label)}\``).join(", ") : "-";
-		lines.push(`| #${row.number} | ${escapeTableCell(row.title)} | ${labels} | ${escapeTableCell(row.updatedAt)} | [${row.filePath}](${row.filePath}) |`);
-	}
-	return lines;
-}
-function escapeTableCell(value) {
-	return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").trim() || "-";
-}
-function escapeInlineCode(value) {
-	return value.replace(/`/g, "\\`");
-}
-
-//#endregion
-//#region src/sync/sync-repository-snapshot.ts
-async function writeRepoSnapshot(context) {
-	const repoSnapshot = await buildRepoSnapshot(context);
-	await mkdir(context.storageDirAbsolute, { recursive: true });
-	await writeFile(join(context.storageDirAbsolute, REPO_SNAPSHOT_FILE_NAME), `${JSON.stringify(repoSnapshot, null, 2)}\n`, "utf8");
-}
-async function writeRepositoryIndexes(context) {
-	const [issuesMarkdown, pullsMarkdown] = await Promise.all([renderIndexMarkdown(context, "issue"), renderIndexMarkdown(context, "pull")]);
-	await mkdir(context.storageDirAbsolute, { recursive: true });
-	await Promise.all([writeFile(join(context.storageDirAbsolute, ISSUES_INDEX_FILE_NAME), issuesMarkdown, "utf8"), writeFile(join(context.storageDirAbsolute, PULLS_INDEX_FILE_NAME), pullsMarkdown, "utf8")]);
-}
-async function renderIndexMarkdown(context, kind) {
-	const rows = Object.values(context.syncState.items).filter((item) => item.kind === kind).map((item) => readIndexRow(item));
-	const openRows = sortRows(rows.filter((row) => row.state === "open"));
-	const closedRows = sortRows(rows.filter((row) => row.state === "closed"));
-	return [
-		`# ${kind === "issue" ? "Issues" : "Pull Requests"}`,
-		"",
-		`- repo: ${context.repoSlug}`,
-		`- synced_at: ${context.syncedAt}`,
-		`- total: ${rows.length}`,
-		`- open: ${openRows.length}`,
-		`- closed: ${closedRows.length}`,
-		"",
-		`## Open (${openRows.length})`,
-		"",
-		...renderRowsTable(openRows),
-		"",
-		`## Closed (${closedRows.length})`,
-		"",
-		...renderRowsTable(closedRows),
-		""
-	].join("\n");
-}
-function readIndexRow(item) {
-	return {
-		number: item.number,
-		state: item.state,
-		title: item.data.item.title,
-		labels: item.data.item.labels,
-		updatedAt: item.data.item.updatedAt,
-		filePath: item.filePath
-	};
-}
-function sortRows(rows) {
-	return [...rows].sort((left, right) => {
-		const updatedDiff = getTimestamp(right.updatedAt) - getTimestamp(left.updatedAt);
-		if (updatedDiff !== 0) return updatedDiff;
-		return right.number - left.number;
-	});
-}
-async function buildRepoSnapshot(context) {
-	const [repoResult, labelsResult, milestonesResult] = await Promise.all([
-		context.provider.fetchRepository(),
-		context.provider.fetchRepositoryLabels(),
-		context.provider.fetchRepositoryMilestones()
-	]);
-	const repository = repoResult;
-	const labels = labelsResult.map((label) => ({
-		name: label.name,
-		color: label.color,
-		description: label.description ?? null,
-		default: Boolean(label.default)
-	})).sort((left, right) => left.name.localeCompare(right.name));
-	const milestones = milestonesResult.map((milestone) => ({
-		number: milestone.number,
-		title: milestone.title,
-		state: milestone.state,
-		description: milestone.description ?? null,
-		due_on: milestone.due_on,
-		open_issues: milestone.open_issues,
-		closed_issues: milestone.closed_issues,
-		created_at: milestone.created_at,
-		updated_at: milestone.updated_at,
-		closed_at: milestone.closed_at
-	})).sort((left, right) => left.number - right.number);
-	return {
-		repo: context.repoSlug,
-		synced_at: context.syncedAt,
-		repository: {
-			owner: repository.owner.login,
-			name: repository.name,
-			full_name: repository.full_name,
-			description: repository.description ?? null,
-			private: repository.private,
-			archived: repository.archived,
-			default_branch: repository.default_branch,
-			html_url: repository.html_url,
-			fork: repository.fork,
-			open_issues_count: repository.open_issues_count,
-			has_issues: repository.has_issues,
-			has_projects: repository.has_projects,
-			has_wiki: repository.has_wiki,
-			created_at: repository.created_at,
-			updated_at: repository.updated_at,
-			pushed_at: repository.pushed_at
-		},
-		labels,
-		milestones
-	};
-}
-
-//#endregion
-//#region src/sync/sync-repository.ts
-async function syncRepository(options) {
-	const reporter = options.reporter;
-	const startedAt = /* @__PURE__ */ new Date();
-	const startedAtIso = startedAt.toISOString();
-	const runId = createSyncRunId();
-	const provider = options.provider ?? createRepositoryProvider({
-		token: options.token,
-		repo: options.repo
-	});
-	const storageDirAbsolute = resolve(options.config.cwd, options.config.directory);
-	const targetNumbers = normalizeIssueNumbers(options.numbers);
-	const counters = createCounters();
-	const stageDurations = createStageDurations();
-	let errorReported = false;
-	reporter?.onStart?.({
-		repo: options.repo,
-		startedAt: startedAtIso,
-		numbersCount: targetNumbers?.length,
-		snapshot: cloneSnapshot(counters)
-	});
-	let context;
-	let since;
-	let repoUpdatedAt;
-	let candidates = {
-		issues: [],
-		scanned: 0
-	};
-	const preparedCandidates = [];
-	let updatedIssues = 0;
-	let updatedPulls = 0;
-	let ghfsVersionMismatch = false;
-	let previousGhfsVersion;
-	const runStage = async (stage, message, fn) => {
-		reporter?.onStageStart?.({
-			stage,
-			message,
-			snapshot: cloneSnapshot(counters)
-		});
-		const stageStartedAt = Date.now();
-		try {
-			const result = await fn();
-			const durationMs = Date.now() - stageStartedAt;
-			stageDurations[stage] = durationMs;
-			reporter?.onStageEnd?.({
-				stage,
-				message,
-				durationMs,
-				snapshot: cloneSnapshot(counters)
-			});
-			return result;
-		} catch (error) {
-			errorReported = true;
-			stageDurations[stage] = Date.now() - stageStartedAt;
-			reporter?.onError?.({
-				stage,
-				error,
-				snapshot: cloneSnapshot(counters)
-			});
-			throw error;
-		}
-	};
-	try {
-		let shouldEarlyReturn = false;
-		await runStage("metadata", "Fetch repository metadata", async () => {
-			const syncState = await loadSyncState(storageDirAbsolute);
-			since = targetNumbers ? void 0 : resolveSince(options, syncState);
-			const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
-			context = {
-				provider,
-				repoSlug: options.repo,
-				storageDirAbsolute,
-				config: options.config,
-				syncState,
-				syncedAt,
-				totalIssues: 0,
-				totalPulls: 0
-			};
-			previousGhfsVersion = syncState.ghfsVersion;
-			ghfsVersionMismatch = syncState.ghfsVersion !== GHFS_VERSION;
-			if (targetNumbers) return;
-			repoUpdatedAt = (await provider.fetchRepository()).updated_at;
-			if (!options.full && syncState.lastRepoUpdatedAt && syncState.lastRepoUpdatedAt === repoUpdatedAt) shouldEarlyReturn = true;
-			reporter?.onStageUpdate?.({
-				stage: "metadata",
-				snapshot: cloneSnapshot(counters),
-				message: `since=${since ?? "(full)"} repoUpdatedAt=${repoUpdatedAt}`
-			});
-		});
-		assertContext(context);
-		const syncContext = context;
-		if (!shouldEarlyReturn) {
-			await runStage("pagination", "Pagination", async () => {
-				const paginatedSince = options.full ? void 0 : since;
-				candidates = targetNumbers ? await fetchIssueCandidatesByNumbers(syncContext, targetNumbers) : await fetchIssueCandidatesByPagination(syncContext, paginatedSince);
-				counters.scanned = candidates.scanned;
-				counters.selected = candidates.issues.length;
-				reporter?.onStageUpdate?.({
-					stage: "pagination",
-					snapshot: cloneSnapshot(counters),
-					message: `scanned=${counters.scanned} selected=${counters.selected}`
-				});
-			});
-			await runStage("fetch", "Fetch updated issues/PRs", async () => {
-				for (const issue of candidates.issues) {
-					const prepared = await prepareIssueCandidateSync(syncContext, issue);
-					preparedCandidates.push(prepared);
-					counters.processed += 1;
-					if (prepared.action === "refetch" || prepared.action === "create") if (prepared.kind === "issue") updatedIssues += 1;
-					else updatedPulls += 1;
-					reporter?.onStageUpdate?.({
-						stage: "fetch",
-						snapshot: cloneSnapshot(counters),
-						message: `${formatIssueNumber(issue.number, {
-							repo: options.repo,
-							kind: issue.kind
-						})} ${prepared.kind} ${prepared.action}`
-					});
-				}
-			});
-			syncContext.syncState.repo = options.repo;
-			if (!targetNumbers) {
-				syncContext.syncState.lastSyncedAt = syncContext.syncedAt;
-				syncContext.syncState.lastSince = since;
-				syncContext.syncState.lastRepoUpdatedAt = repoUpdatedAt;
-			}
-			await saveSyncState(syncContext.storageDirAbsolute, syncContext.syncState);
-			await runStage("materialize", "Materialize local files", async () => {
-				for (const prepared of preparedCandidates) addItemStats(counters, await materializePreparedIssue(syncContext, prepared));
-			});
-			await runStage("prune", "Prune stale local artifacts", async () => {
-				if (options.config.sync.closed === false) counters.patchesDeleted += await pruneTrackedClosedItems(syncContext.storageDirAbsolute, syncContext.syncState, options.config.sync);
-				if (!targetNumbers && options.config.sync.closed === false && candidates.allOpenNumbers) counters.patchesDeleted += await pruneMissingOpenTrackedItems(syncContext.storageDirAbsolute, syncContext.syncState, candidates.allOpenNumbers, options.config.sync);
-				reporter?.onStageUpdate?.({
-					stage: "prune",
-					snapshot: cloneSnapshot(counters),
-					message: `patchesDeleted=${counters.patchesDeleted}`
-				});
-			});
-		}
-		await runStage("save", "Save sync state", async () => {
-			if (ghfsVersionMismatch) {
-				const rematerialized = await rematerializeTrackedMarkdown(syncContext);
-				reporter?.onStageUpdate?.({
-					stage: "save",
-					snapshot: cloneSnapshot(counters),
-					message: `regenerated=${rematerialized.written} version=${previousGhfsVersion ?? "(none)"}->${GHFS_VERSION}`
-				});
-			}
-			const scanStats = await reconcileMarkdownFilesByScan(syncContext);
-			counters.written += scanStats.written;
-			counters.moved += scanStats.moved;
-			reporter?.onStageUpdate?.({
-				stage: "save",
-				snapshot: cloneSnapshot(counters),
-				message: `scan-fixed written=${scanStats.written} moved=${scanStats.moved}`
-			});
-			if (!shouldEarlyReturn) await writeRepoSnapshot(syncContext);
-			if (!shouldEarlyReturn || ghfsVersionMismatch) await writeRepositoryIndexes(syncContext);
-			syncContext.syncState.ghfsVersion = GHFS_VERSION;
-			await saveSyncState(syncContext.storageDirAbsolute, syncContext.syncState);
-		});
-		const totals = computeTotals(syncContext.syncState.items);
-		syncContext.totalIssues = totals.totalIssues;
-		syncContext.totalPulls = totals.totalPulls;
-		const finishedAt = /* @__PURE__ */ new Date();
-		const durationMs = Math.max(0, finishedAt.getTime() - startedAt.getTime());
-		const requestCount = provider.getRequestCount();
-		const summary = {
-			repo: options.repo,
-			since,
-			syncedAt: syncContext.syncedAt,
-			totalIssues: totals.totalIssues,
-			totalPulls: totals.totalPulls,
-			updatedIssues,
-			updatedPulls,
-			trackedItems: totals.trackedItems,
-			requestCount,
-			scanned: counters.scanned,
-			selected: counters.selected,
-			processed: counters.processed,
-			skipped: counters.skipped,
-			written: counters.written,
-			moved: counters.moved,
-			patchesWritten: counters.patchesWritten,
-			patchesDeleted: counters.patchesDeleted,
-			durationMs
-		};
-		syncContext.syncState.lastSyncRun = {
-			runId,
-			repo: options.repo,
-			startedAt: startedAtIso,
-			finishedAt: finishedAt.toISOString(),
-			durationMs,
-			requestCount,
-			since,
-			numbersCount: targetNumbers?.length,
-			counters: cloneSnapshot(counters),
-			stages: { ...stageDurations }
-		};
-		await saveSyncState(syncContext.storageDirAbsolute, syncContext.syncState);
-		reporter?.onComplete?.({
-			summary,
-			stages: { ...stageDurations }
-		});
-		return summary;
-	} catch (error) {
-		if (!errorReported) reporter?.onError?.({
-			error,
-			snapshot: cloneSnapshot(counters)
-		});
-		throw error;
-	}
-}
-function assertContext(context) {
-	if (!context) throw new Error("Sync context was not initialized");
-}
-function createSyncRunId() {
-	return `sync_${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "")}_${randomBytes(3).toString("hex")}`;
-}
-function createStageDurations() {
-	return {
-		metadata: 0,
-		pagination: 0,
-		fetch: 0,
-		materialize: 0,
-		prune: 0,
-		save: 0
-	};
-}
-function cloneSnapshot(counters) {
-	return {
-		scanned: counters.scanned,
-		selected: counters.selected,
-		processed: counters.processed,
-		skipped: counters.skipped,
-		written: counters.written,
-		moved: counters.moved,
-		patchesWritten: counters.patchesWritten,
-		patchesDeleted: counters.patchesDeleted
-	};
-}
-function computeTotals(items) {
-	let totalIssues = 0;
-	let totalPulls = 0;
-	for (const item of Object.values(items)) if (item.kind === "issue") totalIssues += 1;
-	else totalPulls += 1;
-	return {
-		totalIssues,
-		totalPulls,
-		trackedItems: totalIssues + totalPulls
-	};
-}
-
 //#endregion
 //#region src/cli/action-color.ts
 function colorizeAction(action, enabled = true) {
@@ -2536,7 +230,6 @@ function wrapTextValue(value) {
 	if (normalized.length <= 48) return normalized;
 	return `${normalized.slice(0, 45)}...`;
 }
-
 //#endregion
 //#region src/cli/errors.ts
 function withErrorHandling(fn) {
@@ -2547,7 +240,6 @@ function withErrorHandling(fn) {
 		});
 	};
 }
-
 //#endregion
 //#region src/cli/meta.ts
 const CLI_NAME = GHFS_NAME;
@@ -2565,7 +257,6 @@ function ASCII_HEADER(repo) {
 function toGitHubRepoUrl(repo) {
 	return `https://github.com/${repo}`;
 }
-
 //#endregion
 //#region src/cli/printer.ts
 function createCliPrinter(command, options = {}) {
@@ -2844,7 +535,6 @@ function describeStage(stage) {
 	if (stage === "prune") return "pruning local artifacts";
 	return "saving sync state";
 }
-
 //#endregion
 //#region src/cli/prompts.ts
 async function promptForToken() {
@@ -2913,7 +603,6 @@ async function confirmExecuteApply(count) {
 	}
 	return result;
 }
-
 //#endregion
 //#region src/cli/commands/execute.ts
 const PLAN_PREVIEW_LIMIT = 20;
@@ -3090,7 +779,6 @@ function printExecutionSummary(printer, result) {
 	}
 	printer.success(summary);
 }
-
 //#endregion
 //#region src/sync/status.ts
 async function getStatusSummary(config) {
@@ -3144,7 +832,6 @@ async function getStatusSummary(config) {
 		} : void 0
 	};
 }
-
 //#endregion
 //#region src/cli/commands/status.ts
 function registerStatusCommand(cli) {
@@ -3163,7 +850,6 @@ function registerStatusCommand(cli) {
 		printer.done("");
 	}));
 }
-
 //#endregion
 //#region src/cli/summary.ts
 function printSyncSummaryTable(printer, summary, title) {
@@ -3177,7 +863,6 @@ function printSyncSummaryTable(printer, summary, title) {
 		["duration", formatDuration(summary.durationMs)]
 	]);
 }
-
 //#endregion
 //#region src/cli/commands/sync.ts
 function registerSyncCommand(cli) {
@@ -3213,7 +898,56 @@ function setupSyncCommand(command) {
 		printer.done("Sync finished");
 	}));
 }
-
+//#endregion
+//#region src/cli/commands/ui.ts
+function registerUiCommand(cli) {
+	cli.command("ui", "Launch a local web UI for the mirror").option("--repo <repo>", "GitHub repository in owner/name format").option("--port <port>", "Port to listen on", { default: 7710 }).option("--host <host>", "Host to bind", { default: "127.0.0.1" }).option("--no-open", "Do not open the browser automatically").action(withErrorHandling(async (options) => {
+		const printer = createCliPrinter("ui");
+		const config = await resolveConfig();
+		await ensureExecuteArtifacts(resolve(config.cwd, getExecuteFile(config)));
+		const repo = await resolveRepo({
+			cwd: config.cwd,
+			cliRepo: options.repo,
+			configRepo: config.repo,
+			interactive: Boolean(process.stdin.isTTY),
+			selectRepoChoice: promptRepoChoice
+		});
+		printer.header(repo.repo);
+		const initialToken = await resolveAuthToken({
+			token: config.auth.token,
+			interactive: false,
+			promptForToken
+		}).catch(() => "");
+		const port = typeof options.port === "number" ? options.port : Number(options.port ?? 7710);
+		const host = options.host ?? "127.0.0.1";
+		const server = await createUiServer({
+			config,
+			repo: repo.repo,
+			initialToken,
+			port,
+			host,
+			devMode: process.env.GHFS_UI_DEV === "1",
+			onRequestToken: async () => resolveAuthToken({
+				token: config.auth.token,
+				interactive: Boolean(process.stdin.isTTY),
+				promptForToken
+			})
+		});
+		printer.info(`ghfs UI running at ${server.url}`);
+		if (!initialToken) printer.info("No GitHub token yet; sync/execute will prompt or fail until one is available.");
+		if (options.open !== false) {
+			const { default: open } = await import("open");
+			await open(server.url);
+		}
+		const shutdown = async () => {
+			await server.close().catch(() => {});
+			process.exit(0);
+		};
+		process.once("SIGINT", shutdown);
+		process.once("SIGTERM", shutdown);
+		await new Promise(() => {});
+	}));
+}
 //#endregion
 //#region src/cli/index.ts
 function createCli() {
@@ -3221,6 +955,7 @@ function createCli() {
 	registerSyncCommand(cli);
 	registerExecuteCommand(cli);
 	registerStatusCommand(cli);
+	registerUiCommand(cli);
 	cli.help();
 	cli.version(CLI_VERSION);
 	return cli;
@@ -3228,10 +963,8 @@ function createCli() {
 function runCli(argv = process.argv) {
 	createCli().parse(argv);
 }
-
 //#endregion
 //#region src/cli.ts
 runCli();
-
 //#endregion
-export {  };
+export {};