@ghfs/cli 0.0.0 → 0.0.1

package/dist/cli.mjs

@@ -1,1276 +0,0 @@
-#!/usr/bin/env node
-import { basename, dirname, join, resolve } from "node:path";
-import { cac } from "cac";
-import { existsSync } from "node:fs";
-import { createJiti } from "jiti";
-import { cancel, confirm, isCancel, multiselect, password, select } from "@clack/prompts";
-import { retry } from "@octokit/plugin-retry";
-import { throttling } from "@octokit/plugin-throttling";
-import { Octokit } from "octokit";
-import * as v from "valibot";
-import { parse, stringify } from "yaml";
-import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-//#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 DEFAULT_EXECUTE_FILE = ".ghfs/execute.yml";
-const DEFAULT_TOKEN_ENV = ["GH_TOKEN", "GITHUB_TOKEN"];
-const ISSUE_DIR_NAME = "issues";
-const CLOSED_DIR_NAME = "closed";
-const SYNC_STATE_FILE_NAME = ".sync.json";
-const EXECUTE_SCHEMA_RELATIVE_PATH = "schema/execute.schema.json";
-
-//#endregion
-//#region src/config.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 storageDir = merged.storageDir ?? DEFAULT_STORAGE_DIR;
-	const executeFile = merged.executeFile ?? (storageDir === DEFAULT_STORAGE_DIR ? DEFAULT_EXECUTE_FILE : join(storageDir, "execute.yml"));
-	return {
-		cwd,
-		repo: merged.repo,
-		storageDir,
-		storageDirAbsolute: resolve(cwd, storageDir),
-		executeFile,
-		executeFileAbsolute: resolve(cwd, executeFile),
-		auth: {
-			preferGhCli: merged.auth?.preferGhCli ?? true,
-			tokenEnv: merged.auth?.tokenEnv ?? [...DEFAULT_TOKEN_ENV]
-		},
-		detectRepo: {
-			fromGit: merged.detectRepo?.fromGit ?? true,
-			fromPackageJson: merged.detectRepo?.fromPackageJson ?? true
-		},
-		sync: {
-			includeClosed: merged.sync?.includeClosed ?? true,
-			writePrPatch: merged.sync?.writePrPatch ?? true,
-			deleteClosedPrPatch: merged.sync?.deleteClosedPrPatch ?? true
-		},
-		cli: { interactiveExecuteInTTY: merged.cli?.interactiveExecuteInTTY ?? true }
-	};
-}
-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
-		},
-		detectRepo: {
-			...base.detectRepo,
-			...overrides.detectRepo
-		},
-		sync: {
-			...base.sync,
-			...overrides.sync
-		},
-		cli: {
-			...base.cli,
-			...overrides.cli
-		}
-	};
-}
-
-//#endregion
-//#region src/github/client.ts
-const BaseOctokit = Octokit.plugin(retry, throttling);
-function createGitHubClient(token) {
-	return new BaseOctokit({
-		auth: token,
-		throttle: {
-			onRateLimit: (retryAfter, options) => {
-				if ((options.request.retryCount ?? 0) < 2) return true;
-				return false;
-			},
-			onSecondaryRateLimit: () => {
-				return false;
-			}
-		},
-		retry: {
-			doNotRetry: [401, 403],
-			retries: 2
-		}
-	});
-}
-
-//#endregion
-//#region src/utils/fs.ts
-async function ensureDir(path) {
-	await mkdir(path, { recursive: true });
-}
-async function exists(path) {
-	try {
-		await stat(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function writeTextFile(path, content) {
-	await ensureDir(dirname(path));
-	await writeFile(path, content, "utf8");
-}
-async function readTextFile(path) {
-	return readFile(path, "utf8");
-}
-async function moveFile(from, to) {
-	await ensureDir(dirname(to));
-	await rename(from, to);
-}
-async function removeFile(path) {
-	await rm(path, { force: true });
-}
-
-//#endregion
-//#region src/execute/validate.ts
-const executeOpSchema = v.looseObject({
-	number: v.number(),
-	action: v.picklist([
-		"close",
-		"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"
-	]),
-	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 readAndValidateExecuteFile(path) {
-	const raw = await readTextFile(path);
-	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 = parsedResult.output;
-	const customErrors = validateExecuteRules(pending);
-	if (customErrors.length) throw new Error(`Invalid execute file: ${customErrors.join("; ")}`);
-	return pending;
-}
-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":
-			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;
-}
-
-//#endregion
-//#region src/execute/index.ts
-async function executePendingChanges(options) {
-	const allOps = await readAndValidateExecuteFile(options.executeFilePath);
-	const interactive = process.stdin.isTTY && !options.nonInteractive && options.config.cli.interactiveExecuteInTTY;
-	const selected = interactive ? await selectOperations(allOps) : allOps.map((op, index) => ({
-		op,
-		index
-	}));
-	const runId = createRunId();
-	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-	if (selected.length === 0) return {
-		runId,
-		createdAt,
-		mode: options.apply ? "apply" : "dry-run",
-		repo: options.repo,
-		planned: 0,
-		applied: 0,
-		failed: 0,
-		details: []
-	};
-	printPlan(selected.map((item) => item.op));
-	if (!options.apply) return {
-		runId,
-		createdAt,
-		mode: "dry-run",
-		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: describeAction(op)
-		}))
-	};
-	if (interactive) {
-		if (!await confirmApply(selected.length)) throw new Error("Execution cancelled");
-	}
-	const { owner, repo } = splitRepo$1(options.repo);
-	const octokit = createGitHubClient(options.token);
-	const details = [];
-	let applied = 0;
-	let failed = 0;
-	for (const { op, index } of selected) try {
-		const target = await applyOperation(octokit, owner, repo, op);
-		details.push({
-			op: index + 1,
-			action: op.action,
-			number: op.number,
-			target,
-			status: "applied",
-			message: describeAction(op)
-		});
-		applied += 1;
-	} catch (error) {
-		failed += 1;
-		details.push({
-			op: index + 1,
-			action: op.action,
-			number: op.number,
-			status: "failed",
-			message: error.message
-		});
-		if (!options.continueOnError) break;
-	}
-	return {
-		runId,
-		createdAt,
-		mode: "apply",
-		repo: options.repo,
-		planned: selected.length,
-		applied,
-		failed,
-		details
-	};
-}
-async function applyOperation(octokit, owner, repo, op) {
-	const issue = (await octokit.rest.issues.get({
-		owner,
-		repo,
-		issue_number: op.number
-	})).data;
-	const isPull = Boolean(issue.pull_request);
-	const target = isPull ? "pull" : "issue";
-	if (op.ifUnchangedSince) {
-		const remoteUpdatedAt = issue.updated_at;
-		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 octokit.rest.issues.update({
-				owner,
-				repo,
-				issue_number: op.number,
-				state: "closed"
-			});
-			break;
-		case "reopen":
-			await octokit.rest.issues.update({
-				owner,
-				repo,
-				issue_number: op.number,
-				state: "open"
-			});
-			break;
-		case "set-title":
-			await octokit.rest.issues.update({
-				owner,
-				repo,
-				issue_number: op.number,
-				title: op.title
-			});
-			break;
-		case "set-body":
-			await octokit.rest.issues.update({
-				owner,
-				repo,
-				issue_number: op.number,
-				body: op.body
-			});
-			break;
-		case "add-comment":
-			await octokit.rest.issues.createComment({
-				owner,
-				repo,
-				issue_number: op.number,
-				body: op.body
-			});
-			break;
-		case "add-labels":
-			await octokit.rest.issues.addLabels({
-				owner,
-				repo,
-				issue_number: op.number,
-				labels: op.labels
-			});
-			break;
-		case "remove-labels":
-			await removeLabels(octokit, owner, repo, op.number, op.labels);
-			break;
-		case "set-labels":
-			await octokit.rest.issues.setLabels({
-				owner,
-				repo,
-				issue_number: op.number,
-				labels: op.labels
-			});
-			break;
-		case "add-assignees":
-			await octokit.rest.issues.addAssignees({
-				owner,
-				repo,
-				issue_number: op.number,
-				assignees: op.assignees
-			});
-			break;
-		case "remove-assignees":
-			await octokit.rest.issues.removeAssignees({
-				owner,
-				repo,
-				issue_number: op.number,
-				assignees: op.assignees
-			});
-			break;
-		case "set-assignees":
-			await octokit.rest.issues.update({
-				owner,
-				repo,
-				issue_number: op.number,
-				assignees: op.assignees
-			});
-			break;
-		case "set-milestone": {
-			const milestone = await resolveMilestone(octokit, owner, repo, op.milestone);
-			await octokit.rest.issues.update({
-				owner,
-				repo,
-				issue_number: op.number,
-				milestone
-			});
-			break;
-		}
-		case "clear-milestone":
-			await octokit.rest.issues.update({
-				owner,
-				repo,
-				issue_number: op.number,
-				milestone: null
-			});
-			break;
-		case "lock":
-			await octokit.rest.issues.lock({
-				owner,
-				repo,
-				issue_number: op.number,
-				lock_reason: normalizeLockReason(op.reason)
-			});
-			break;
-		case "unlock":
-			await octokit.rest.issues.unlock({
-				owner,
-				repo,
-				issue_number: op.number
-			});
-			break;
-		case "request-reviewers":
-			ensurePullAction(op.action, op.number, isPull);
-			await octokit.rest.pulls.requestReviewers({
-				owner,
-				repo,
-				pull_number: op.number,
-				reviewers: op.reviewers
-			});
-			break;
-		case "remove-reviewers":
-			ensurePullAction(op.action, op.number, isPull);
-			await octokit.rest.pulls.removeRequestedReviewers({
-				owner,
-				repo,
-				pull_number: op.number,
-				reviewers: op.reviewers
-			});
-			break;
-		case "mark-ready-for-review":
-			ensurePullAction(op.action, op.number, isPull);
-			await octokit.request("POST /repos/{owner}/{repo}/pulls/{pull_number}/ready_for_review", {
-				owner,
-				repo,
-				pull_number: op.number
-			});
-			break;
-		case "convert-to-draft":
-			ensurePullAction(op.action, op.number, isPull);
-			await octokit.request("POST /repos/{owner}/{repo}/pulls/{pull_number}/convert-to-draft", {
-				owner,
-				repo,
-				pull_number: op.number
-			});
-			break;
-		default: throw new Error(`Unsupported action: ${String(op.action)}`);
-	}
-	return target;
-}
-async function removeLabels(octokit, owner, repo, number, labels) {
-	for (const label of labels) try {
-		await octokit.rest.issues.removeLabel({
-			owner,
-			repo,
-			issue_number: number,
-			name: label
-		});
-	} catch (error) {
-		if (error.status !== 404) throw error;
-	}
-}
-async function resolveMilestone(octokit, owner, repo, value) {
-	if (typeof value === "number") return value;
-	if (/^\d+$/.test(value)) return Number(value);
-	const matched = (await octokit.paginate(octokit.rest.issues.listMilestones, {
-		owner,
-		repo,
-		state: "all",
-		per_page: 100
-	})).find((item) => item.title === value);
-	if (!matched) throw new Error(`Milestone not found: ${value}`);
-	return matched.number;
-}
-function splitRepo$1(repo) {
-	const [owner, name] = repo.split("/");
-	if (!owner || !name) throw new Error(`Invalid repo slug: ${repo}`);
-	return {
-		owner,
-		repo: name
-	};
-}
-function describeAction(op) {
-	return `${op.action} #${op.number}`;
-}
-function createRunId() {
-	return `run_${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "")}_${Math.random().toString(36).slice(2, 7)}`;
-}
-async function selectOperations(ops) {
-	const result = await multiselect({
-		message: "Select operations to include",
-		options: ops.map((op, index) => ({
-			label: `${index + 1}. ${describeAction(op)}`,
-			value: index
-		})),
-		required: false
-	});
-	if (isCancel(result)) {
-		cancel("Operation selection cancelled");
-		throw new Error("Execution cancelled");
-	}
-	const selectedIndexes = new Set(result);
-	return ops.map((op, index) => ({
-		op,
-		index
-	})).filter((item) => selectedIndexes.has(item.index));
-}
-async function confirmApply(count) {
-	const result = await confirm({
-		message: `Apply ${count} operation(s) to GitHub?`,
-		initialValue: false
-	});
-	if (isCancel(result)) {
-		cancel("Execution cancelled");
-		return false;
-	}
-	return result;
-}
-function printPlan(ops) {
-	console.log(`Planned operations (${ops.length}):`);
-	for (const [index, op] of ops.entries()) console.log(`- ${index + 1}. ${describeAction(op)}`);
-}
-function ensurePullAction(action, number, isPull) {
-	if (!isPull) throw new Error(`Action ${action} requires #${number} to be a pull request`);
-}
-function normalizeLockReason(reason) {
-	if (!reason) return void 0;
-	if (reason === "too-heated") return "too heated";
-	return reason;
-}
-
-//#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: [
-					"close",
-					"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"
-				]
-			},
-			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"
-				]
-			}
-		}
-	}
-};
-async function writeExecuteSchema(storageDirAbsolute) {
-	const schemaPath = getExecuteSchemaPath(storageDirAbsolute);
-	await writeTextFile(schemaPath, `${JSON.stringify(executeSchema, null, 2)}\n`);
-	return schemaPath;
-}
-function getExecuteSchemaPath(storageDirAbsolute) {
-	return join(storageDirAbsolute, EXECUTE_SCHEMA_RELATIVE_PATH);
-}
-
-//#endregion
-//#region src/github/auth.ts
-const execFileAsync$1 = promisify(execFile);
-async function resolveAuthToken(options) {
-	if (options.preferGhCli) {
-		const token = await readTokenFromGhCli();
-		if (token) return token;
-	}
-	const envToken = readTokenFromEnv(options.tokenEnv);
-	if (envToken) return envToken;
-	if (!options.interactive || !process.stdin.isTTY) throw new Error("Missing GitHub token. Set GH_TOKEN/GITHUB_TOKEN or run gh auth login.");
-	return await promptForToken();
-}
-async function readTokenFromGhCli() {
-	try {
-		return (await execFileAsync$1("gh", ["auth", "token"])).stdout.trim() || void 0;
-	} catch {
-		return;
-	}
-}
-function readTokenFromEnv(envNames) {
-	for (const name of envNames) {
-		const value = process.env[name]?.trim();
-		if (value) return value;
-	}
-}
-async function promptForToken() {
-	const result = await password({
-		message: "Enter a GitHub token (PAT) for ghfs:",
-		validate: (value) => value?.trim().length ? void 0 : "Token is required"
-	});
-	if (isCancel(result)) {
-		cancel("Token prompt cancelled");
-		throw new Error("Token prompt cancelled");
-	}
-	return result.trim();
-}
-
-//#endregion
-//#region src/github/repo.ts
-const execFileAsync = promisify(execFile);
-async function resolveRepo(options) {
-	if (options.cliRepo) {
-		const repo = normalizeRepo(options.cliRepo);
-		if (!repo) throw new Error(`Invalid --repo value: ${options.cliRepo}`);
-		return {
-			repo,
-			source: "cli",
-			candidates: []
-		};
-	}
-	if (options.configRepo) {
-		const repo = normalizeRepo(options.configRepo);
-		if (!repo) throw new Error(`Invalid repo in ghfs.config.ts: ${options.configRepo}`);
-		return {
-			repo,
-			source: "config",
-			candidates: []
-		};
-	}
-	const candidates = [];
-	const gitCandidate = options.detectFromGit ? await detectRepoFromGit(options.cwd) : void 0;
-	const pkgCandidate = options.detectFromPackageJson ? await detectRepoFromPackageJson(options.cwd) : void 0;
-	if (gitCandidate) candidates.push(gitCandidate);
-	if (pkgCandidate) candidates.push(pkgCandidate);
-	if (gitCandidate && pkgCandidate && gitCandidate.repo !== pkgCandidate.repo) {
-		if (options.interactive && process.stdin.isTTY) {
-			const repo = await promptRepoChoice(gitCandidate, pkgCandidate);
-			return {
-				repo,
-				source: repo === gitCandidate.repo ? "git" : "package-json",
-				candidates
-			};
-		}
-		throw new Error(`Repo mismatch detected. git=${gitCandidate.repo} package.json=${pkgCandidate.repo}. Use --repo to disambiguate.`);
-	}
-	if (gitCandidate) return {
-		repo: gitCandidate.repo,
-		source: "git",
-		candidates
-	};
-	if (pkgCandidate) return {
-		repo: pkgCandidate.repo,
-		source: "package-json",
-		candidates
-	};
-	if (options.syncStateRepo) return {
-		repo: options.syncStateRepo,
-		source: "sync-state",
-		candidates
-	};
-	throw new Error("Could not resolve repository. Provide --repo or set repo in ghfs.config.ts.");
-}
-function normalizeRepo(input) {
-	const trimmed = input.trim();
-	if (!trimmed) return void 0;
-	const shortMatch = trimmed.match(/^([\w.-]+)\/([\w.-]+)$/);
-	if (shortMatch) return `${shortMatch[1]}/${stripGitSuffix(shortMatch[2])}`;
-	const githubPrefixMatch = trimmed.match(/^github:([\w.-]+)\/([\w.-]+)$/);
-	if (githubPrefixMatch) return `${githubPrefixMatch[1]}/${stripGitSuffix(githubPrefixMatch[2])}`;
-	const sshScpMatch = trimmed.match(/^git@github\.com:([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
-	if (sshScpMatch) return `${sshScpMatch[1]}/${stripGitSuffix(sshScpMatch[2])}`;
-	try {
-		const url = new URL(trimmed);
-		if (url.hostname !== "github.com") return void 0;
-		const segments = url.pathname.replace(/^\//, "").split("/").filter(Boolean);
-		if (segments.length < 2) return void 0;
-		return `${segments[0]}/${stripGitSuffix(segments[1])}`;
-	} catch {
-		return;
-	}
-}
-async function detectRepoFromGit(cwd) {
-	let stdout;
-	try {
-		stdout = (await execFileAsync("git", ["remote"], { cwd })).stdout;
-	} catch {
-		return;
-	}
-	const remotes = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-	if (!remotes.length) return void 0;
-	const orderedRemotes = prioritizeRemotes(remotes);
-	for (const remote of orderedRemotes) try {
-		const repo = normalizeRepo((await execFileAsync("git", [
-			"remote",
-			"get-url",
-			remote
-		], { cwd })).stdout.trim());
-		if (repo) return {
-			source: "git",
-			repo,
-			detail: `remote:${remote}`
-		};
-	} catch {
-		continue;
-	}
-}
-async function detectRepoFromPackageJson(cwd) {
-	const path = `${cwd}/package.json`;
-	if (!await exists(path)) return void 0;
-	let parsed;
-	try {
-		parsed = JSON.parse(await readTextFile(path));
-	} catch {
-		return;
-	}
-	if (!parsed || typeof parsed !== "object") return void 0;
-	const repository = parsed.repository;
-	if (typeof repository === "string") {
-		const repo = normalizeRepo(repository);
-		if (repo) return {
-			source: "package-json",
-			repo,
-			detail: "package.json#repository"
-		};
-	}
-	if (repository && typeof repository === "object") {
-		const url = repository.url;
-		if (typeof url === "string") {
-			const repo = normalizeRepo(url);
-			if (repo) return {
-				source: "package-json",
-				repo,
-				detail: "package.json#repository.url"
-			};
-		}
-	}
-}
-function prioritizeRemotes(remotes) {
-	const unique = [...new Set(remotes)];
-	const priority = ["origin", "upstream"];
-	const prioritized = priority.filter((name) => unique.includes(name));
-	const rest = unique.filter((name) => !priority.includes(name));
-	return [...prioritized, ...rest];
-}
-function stripGitSuffix(name) {
-	return name.replace(/\.git$/, "");
-}
-async function promptRepoChoice(gitCandidate, pkgCandidate) {
-	const result = await select({
-		message: "Detected conflicting GitHub repositories. Which one should ghfs use?",
-		options: [{
-			label: `${gitCandidate.repo} (${gitCandidate.detail})`,
-			value: gitCandidate.repo
-		}, {
-			label: `${pkgCandidate.repo} (${pkgCandidate.detail})`,
-			value: pkgCandidate.repo
-		}],
-		initialValue: gitCandidate.repo
-	});
-	if (isCancel(result)) {
-		cancel("Repository selection cancelled");
-		throw new Error("Repository selection cancelled");
-	}
-	return result;
-}
-
-//#endregion
-//#region src/sync/markdown.ts
-function renderIssueMarkdown(input) {
-	const frontmatter = {
-		schema: "ghfs/issue-doc@v1",
-		repo: input.repo,
-		number: input.number,
-		kind: input.kind,
-		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,
-		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(([, value]) => value !== void 0));
-	const sections = [
-		`# ${input.title}`,
-		"",
-		"## Description",
-		"",
-		input.body?.trim() || "_No description._",
-		"",
-		"## Comments",
-		""
-	];
-	if (input.comments.length === 0) sections.push("_No comments._");
-	else for (const comment of input.comments) {
-		sections.push(`### Comment ${comment.id} by @${comment.author} on ${comment.createdAt}`);
-		sections.push(`<!-- comment-id:${comment.id} updated:${comment.updatedAt} -->`);
-		sections.push("");
-		sections.push(comment.body?.trim() || "_No content._");
-		sections.push("");
-	}
-	return [
-		"---",
-		stringify(compactFrontmatter).trimEnd(),
-		"---",
-		"",
-		...sections,
-		""
-	].join("\n");
-}
-
-//#endregion
-//#region src/sync/paths.ts
-function getIssuesDir(storageDirAbsolute) {
-	return join(storageDirAbsolute, ISSUE_DIR_NAME);
-}
-function getClosedIssuesDir(storageDirAbsolute) {
-	return join(getIssuesDir(storageDirAbsolute), CLOSED_DIR_NAME);
-}
-function getIssueMarkdownPath(storageDirAbsolute, number, state) {
-	if (state === "closed") return join(getClosedIssuesDir(storageDirAbsolute), `${number}.md`);
-	return join(getIssuesDir(storageDirAbsolute), `${number}.md`);
-}
-function getClosedIssueMarkdownPath(storageDirAbsolute, number) {
-	return join(getClosedIssuesDir(storageDirAbsolute), `${number}.md`);
-}
-function getPrPatchPath(storageDirAbsolute, number) {
-	return join(getIssuesDir(storageDirAbsolute), `${number}.patch`);
-}
-
-//#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 !== 1) return createEmptySyncState();
-		return {
-			version: 1,
-			items: parsed.items ?? {},
-			executions: parsed.executions ?? [],
-			repo: parsed.repo,
-			lastSyncedAt: parsed.lastSyncedAt,
-			lastSince: parsed.lastSince
-		};
-	} catch {
-		return createEmptySyncState();
-	}
-}
-async function saveSyncState(storageDirAbsolute, state) {
-	await ensureDir(storageDirAbsolute);
-	await writeFile(getSyncStatePath(storageDirAbsolute), `${JSON.stringify(state, null, 2)}\n`, "utf8");
-}
-function createEmptySyncState() {
-	return {
-		version: 1,
-		items: {},
-		executions: []
-	};
-}
-function appendExecution(state, result, limit = 20) {
-	const nextExecutions = [result, ...state.executions].slice(0, limit);
-	return {
-		...state,
-		executions: nextExecutions
-	};
-}
-
-//#endregion
-//#region src/sync/index.ts
-async function syncRepository(options) {
-	const { owner, repo } = splitRepo(options.repo);
-	const octokit = createGitHubClient(options.token);
-	await ensureStorageStructure(options.config.storageDirAbsolute);
-	const syncState = await loadSyncState(options.config.storageDirAbsolute);
-	const since = resolveSince(options, syncState);
-	const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
-	const listState = options.config.sync.includeClosed ? "all" : "open";
-	const issues = await octokit.paginate(octokit.rest.issues.listForRepo, {
-		owner,
-		repo,
-		state: listState,
-		sort: "updated",
-		direction: "asc",
-		per_page: 100,
-		since
-	});
-	let written = 0;
-	let moved = 0;
-	let patchesWritten = 0;
-	let patchesDeleted = 0;
-	for (const issue of issues) {
-		const number = issue.number;
-		const kind = issue.pull_request ? "pull" : "issue";
-		const state = issue.state === "closed" ? "closed" : "open";
-		const comments = await octokit.paginate(octokit.rest.issues.listComments, {
-			owner,
-			repo,
-			issue_number: number,
-			per_page: 100
-		});
-		const pull = kind === "pull" ? await getPullMetadata(octokit, owner, repo, number) : void 0;
-		const markdown = renderIssueMarkdown({
-			repo: options.repo,
-			number,
-			kind,
-			state,
-			title: issue.title,
-			body: issue.body ?? "",
-			author: issue.user?.login ?? "unknown",
-			labels: normalizeLabels(issue.labels),
-			assignees: (issue.assignees ?? []).map((assignee) => assignee.login),
-			milestone: issue.milestone?.title ?? null,
-			createdAt: issue.created_at,
-			updatedAt: issue.updated_at,
-			closedAt: issue.closed_at,
-			lastSyncedAt: syncedAt,
-			comments: comments.map((comment) => ({
-				id: comment.id,
-				author: comment.user?.login ?? "unknown",
-				body: comment.body ?? "",
-				createdAt: comment.created_at,
-				updatedAt: comment.updated_at
-			})),
-			pr: pull
-		});
-		const targetPath = getIssueMarkdownPath(options.config.storageDirAbsolute, number, state);
-		const closedPath = getClosedIssueMarkdownPath(options.config.storageDirAbsolute, number);
-		const openPath = getIssueMarkdownPath(options.config.storageDirAbsolute, number, "open");
-		if (state === "open" && await exists(closedPath)) {
-			await moveFile(closedPath, openPath);
-			moved += 1;
-		}
-		if (state === "closed" && await exists(openPath)) {
-			await moveFile(openPath, closedPath);
-			moved += 1;
-		}
-		await writeTextFile(targetPath, markdown);
-		written += 1;
-		const patchPath = getPrPatchPath(options.config.storageDirAbsolute, number);
-		if (kind === "pull" && options.config.sync.writePrPatch && state === "open") {
-			await writeTextFile(patchPath, await downloadPullPatch(octokit, owner, repo, number));
-			patchesWritten += 1;
-		}
-		if (kind === "pull" && state === "closed" && options.config.sync.deleteClosedPrPatch) {
-			if (await exists(patchPath)) {
-				await removeFile(patchPath);
-				patchesDeleted += 1;
-			}
-		}
-		syncState.items[String(number)] = {
-			number,
-			kind,
-			state,
-			updatedAt: issue.updated_at,
-			filePath: relativeToStorage(options.config.storageDirAbsolute, targetPath),
-			patchPath: kind === "pull" && state === "open" ? relativeToStorage(options.config.storageDirAbsolute, patchPath) : void 0
-		};
-	}
-	syncState.repo = options.repo;
-	syncState.lastSyncedAt = syncedAt;
-	syncState.lastSince = since;
-	await saveSyncState(options.config.storageDirAbsolute, syncState);
-	return {
-		repo: options.repo,
-		since,
-		syncedAt,
-		scanned: issues.length,
-		written,
-		moved,
-		patchesWritten,
-		patchesDeleted
-	};
-}
-async function appendExecutionResult(storageDirAbsolute, result) {
-	await saveSyncState(storageDirAbsolute, appendExecution(await loadSyncState(storageDirAbsolute), result));
-}
-function resolveSince(options, syncState) {
-	if (options.full) return void 0;
-	if (options.since) return options.since;
-	return syncState.lastSyncedAt;
-}
-async function ensureStorageStructure(storageDirAbsolute) {
-	await ensureDir(getIssuesDir(storageDirAbsolute));
-	await ensureDir(getClosedIssuesDir(storageDirAbsolute));
-}
-function splitRepo(repo) {
-	const [owner, name] = repo.split("/");
-	if (!owner || !name) throw new Error(`Invalid repo slug: ${repo}`);
-	return {
-		owner,
-		repo: name
-	};
-}
-function normalizeLabels(labels) {
-	return labels.map((label) => {
-		if (typeof label === "string") return label;
-		return label.name ?? void 0;
-	}).filter((label) => Boolean(label));
-}
-async function getPullMetadata(octokit, owner, repo, number) {
-	const pull = (await octokit.rest.pulls.get({
-		owner,
-		repo,
-		pull_number: number
-	})).data;
-	return {
-		isDraft: pull.draft,
-		merged: pull.merged,
-		mergedAt: pull.merged_at,
-		baseRef: pull.base.ref,
-		headRef: pull.head.ref,
-		requestedReviewers: pull.requested_reviewers.map((reviewer) => reviewer.login)
-	};
-}
-async function downloadPullPatch(octokit, owner, repo, number) {
-	const result = await octokit.request("GET /repos/{owner}/{repo}/pulls/{pull_number}", {
-		owner,
-		repo,
-		pull_number: number,
-		mediaType: { format: "patch" }
-	});
-	if (typeof result.data === "string") return result.data;
-	throw new Error(`Unexpected patch response for pull #${number}`);
-}
-function relativeToStorage(storageDirAbsolute, absolutePath) {
-	if (absolutePath.startsWith(storageDirAbsolute)) return absolutePath.slice(storageDirAbsolute.length + 1);
-	return basename(absolutePath);
-}
-
-//#endregion
-//#region src/sync/status.ts
-async function getStatusSummary(config) {
-	const syncState = await loadSyncState(config.storageDirAbsolute);
-	const items = Object.values(syncState.items);
-	const openCount = items.filter((item) => item.state === "open").length;
-	const closedCount = items.filter((item) => item.state === "closed").length;
-	const lastExecution = syncState.executions[0];
-	return {
-		repo: syncState.repo,
-		lastSyncedAt: syncState.lastSyncedAt,
-		totalTracked: items.length,
-		openCount,
-		closedCount,
-		executionRuns: syncState.executions.length,
-		lastExecution: lastExecution ? {
-			runId: lastExecution.runId,
-			createdAt: lastExecution.createdAt,
-			mode: lastExecution.mode,
-			planned: lastExecution.planned,
-			applied: lastExecution.applied,
-			failed: lastExecution.failed
-		} : void 0
-	};
-}
-function printStatus(summary) {
-	console.log("ghfs status");
-	console.log(`- repo: ${summary.repo ?? "(not resolved yet)"}`);
-	console.log(`- last sync: ${summary.lastSyncedAt ?? "(never)"}`);
-	console.log(`- tracked items: ${summary.totalTracked} (open=${summary.openCount}, closed=${summary.closedCount})`);
-	console.log(`- execution runs: ${summary.executionRuns}`);
-	if (summary.lastExecution) {
-		console.log(`- last execution: ${summary.lastExecution.runId} at ${summary.lastExecution.createdAt}`);
-		console.log(`  mode=${summary.lastExecution.mode} planned=${summary.lastExecution.planned} applied=${summary.lastExecution.applied} failed=${summary.lastExecution.failed}`);
-	}
-}
-
-//#endregion
-//#region src/cli.ts
-const cli = cac("ghfs");
-setupSyncCommand(cli.command("sync", "Sync issues and pull requests to local mirror"));
-setupSyncCommand(cli.command("", "Sync issues and pull requests to local mirror"));
-cli.command("execute", "Execute operations from .ghfs/execute.yml").option("--repo <repo>", "GitHub repository in owner/name format").option("--file <file>", "Path to execute yml file").option("--apply", "Apply mutations to GitHub (default is dry-run)").option("--non-interactive", "Disable interactive prompts").option("--continue-on-error", "Continue applying ops after a failure").action(withErrorHandling(async (options) => {
-	const config = await resolveConfig();
-	const syncState = await loadSyncState(config.storageDirAbsolute);
-	const repo = await resolveRepo({
-		cwd: config.cwd,
-		cliRepo: options.repo,
-		configRepo: config.repo,
-		detectFromGit: config.detectRepo.fromGit,
-		detectFromPackageJson: config.detectRepo.fromPackageJson,
-		syncStateRepo: syncState.repo,
-		interactive: process.stdin.isTTY && !options.nonInteractive
-	});
-	const token = await resolveAuthToken({
-		preferGhCli: config.auth.preferGhCli,
-		tokenEnv: config.auth.tokenEnv,
-		interactive: process.stdin.isTTY && !options.nonInteractive
-	});
-	const executeFilePath = resolve(config.cwd, options.file ?? config.executeFile);
-	const result = await executePendingChanges({
-		config,
-		repo: repo.repo,
-		token,
-		executeFilePath,
-		apply: Boolean(options.apply),
-		nonInteractive: Boolean(options.nonInteractive),
-		continueOnError: Boolean(options.continueOnError)
-	});
-	await appendExecutionResult(config.storageDirAbsolute, result);
-	console.log(`Execution ${result.mode} finished. planned=${result.planned} applied=${result.applied} failed=${result.failed}`);
-	for (const detail of result.details) console.log(`- [${detail.status}] op ${detail.op}: ${detail.message}`);
-	if (result.failed > 0) process.exitCode = 1;
-}));
-cli.command("status", "Show local sync status").action(withErrorHandling(async () => {
-	printStatus(await getStatusSummary(await resolveConfig()));
-}));
-cli.command("schema", "Write execute schema to .ghfs/schema/execute.schema.json").action(withErrorHandling(async () => {
-	const schemaPath = await writeExecuteSchema((await resolveConfig()).storageDirAbsolute);
-	console.log(schemaPath);
-}));
-cli.help();
-cli.version("0.1.0");
-cli.parse();
-function setupSyncCommand(command) {
-	command.option("--repo <repo>", "GitHub repository in owner/name format").option("--since <iso>", "Only sync records updated since ISO datetime").option("--full", "Full sync ignoring previous cursor").action(withErrorHandling(async (options) => {
-		const config = await resolveConfig();
-		const syncState = await loadSyncState(config.storageDirAbsolute);
-		const repo = await resolveRepo({
-			cwd: config.cwd,
-			cliRepo: options.repo,
-			configRepo: config.repo,
-			detectFromGit: config.detectRepo.fromGit,
-			detectFromPackageJson: config.detectRepo.fromPackageJson,
-			syncStateRepo: syncState.repo,
-			interactive: process.stdin.isTTY
-		});
-		const token = await resolveAuthToken({
-			preferGhCli: config.auth.preferGhCli,
-			tokenEnv: config.auth.tokenEnv,
-			interactive: process.stdin.isTTY
-		});
-		const summary = await syncRepository({
-			config,
-			repo: repo.repo,
-			token,
-			since: options.since,
-			full: Boolean(options.full)
-		});
-		console.log(`Synced ${summary.repo} at ${summary.syncedAt}`);
-		console.log(`- since: ${summary.since ?? "(full)"}`);
-		console.log(`- scanned: ${summary.scanned}`);
-		console.log(`- markdown written: ${summary.written}`);
-		console.log(`- moved: ${summary.moved}`);
-		console.log(`- patch written: ${summary.patchesWritten}`);
-		console.log(`- patch deleted: ${summary.patchesDeleted}`);
-	}));
-}
-function withErrorHandling(fn) {
-	return (...args) => {
-		fn(...args).catch((error) => {
-			const message = error.message || String(error);
-			console.error(`ghfs error: ${message}`);
-			process.exit(1);
-		});
-	};
-}
-
-//#endregion
-export {  };