@ez-corp/ez-context 0.1.0

package/dist/cli.js

@@ -0,0 +1,597 @@
+#!/usr/bin/env node
+import { a as writeWithMarkers, i as MARKER_START, n as emit, o as extractConventions, r as MARKER_END, s as createBridge, t as FORMAT_EMITTER_MAP } from "./emitters-D6bP4xWs.js";
+import { copyFile, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+
+//#region src/commands/generate.ts
+const DRY_RUN_PREVIEW_LINES = 20;
+const VALID_FORMATS = [
+	"claude",
+	"agents",
+	"cursor",
+	"copilot",
+	"skills",
+	"rulesync",
+	"ruler"
+];
+function parseFormats(raw) {
+	const formats = [...new Set(raw.split(",").map((s) => s.trim()).filter(Boolean))];
+	const invalid = formats.filter((f) => !VALID_FORMATS.includes(f));
+	if (invalid.length > 0) throw new Error(`Invalid format(s): ${invalid.join(", ")}. Valid: ${VALID_FORMATS.join(", ")}`);
+	return formats;
+}
+function truncatePreview(content) {
+	const lines = content.split("\n");
+	if (lines.length <= DRY_RUN_PREVIEW_LINES) return content;
+	return `${lines.slice(0, DRY_RUN_PREVIEW_LINES).join("\n")}\n... (${lines.length} lines total)`;
+}
+async function generateAction(pathArg, options) {
+	const projectPath = path.resolve(pathArg);
+	const spinner = ora("Analyzing project conventions...").start();
+	try {
+		const registry = await extractConventions(projectPath);
+		const conventionCount = registry.conventions.length;
+		spinner.succeed(`Found ${conventionCount} convention${conventionCount === 1 ? "" : "s"}`);
+		const confidenceThreshold = parseFloat(options.threshold ?? "0.7");
+		const outputDir = path.resolve(options.output ?? ".");
+		const formats = parseFormats(options.format ?? "claude,agents");
+		const emitOptions = {
+			outputDir,
+			confidenceThreshold,
+			dryRun: options.dryRun ?? false,
+			formats
+		};
+		const genSpinner = ora(formats.length === 2 && formats.includes("claude") && formats.includes("agents") ? "Generating context files..." : `Generating ${formats.length} context file${formats.length === 1 ? "" : "s"}...`).start();
+		const result = await emit(registry, emitOptions);
+		if (options.dryRun) {
+			genSpinner.succeed("Dry run complete");
+			console.log();
+			console.log(chalk.bold.yellow("╔══════════════════════════════════════╗"));
+			console.log(chalk.bold.yellow("║  DRY RUN -- no files will be written ║"));
+			console.log(chalk.bold.yellow("╚══════════════════════════════════════╝"));
+			console.log();
+			for (const [format, content] of Object.entries(result.rendered)) {
+				console.log(chalk.cyan(`--- ${format.toUpperCase()} ---`));
+				console.log(truncatePreview(content));
+				console.log();
+			}
+		} else {
+			genSpinner.succeed(`Generated ${result.filesWritten.length} file${result.filesWritten.length === 1 ? "" : "s"}`);
+			console.log();
+			console.log(chalk.bold.green("Generated files:"));
+			for (const filePath of result.filesWritten) {
+				const relPath = path.relative(outputDir, filePath);
+				console.log(`  ${chalk.cyan(relPath)}`);
+			}
+		}
+	} catch (err) {
+		spinner.fail("Analysis failed");
+		const message = err instanceof Error ? err.message : String(err);
+		console.error(chalk.red(message));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/inspect.ts
+function confidenceDot(confidence) {
+	if (confidence >= .8) return chalk.green("●");
+	if (confidence >= .6) return chalk.yellow("●");
+	return chalk.red("●");
+}
+async function inspectAction(pathArg, options) {
+	const projectPath = path.resolve(pathArg);
+	const spinner = ora("Analyzing project conventions...").start();
+	try {
+		const registry = await extractConventions(projectPath);
+		const totalCount = registry.conventions.length;
+		spinner.succeed(`Extracted ${totalCount} convention${totalCount === 1 ? "" : "s"}`);
+		const threshold = parseFloat(options.threshold ?? "0.7");
+		const filtered = registry.conventions.filter((c) => c.confidence >= threshold);
+		if (filtered.length === 0) {
+			console.log(chalk.yellow(`\nNo conventions found above ${threshold} confidence threshold. Try lowering --threshold.`));
+			return;
+		}
+		const byCategory = /* @__PURE__ */ new Map();
+		for (const convention of filtered) {
+			const group = byCategory.get(convention.category) ?? [];
+			group.push(convention);
+			byCategory.set(convention.category, group);
+		}
+		console.log();
+		for (const [category, conventions] of byCategory) {
+			console.log(chalk.bold(category.toUpperCase()));
+			for (const convention of conventions) {
+				const pct = Math.round(convention.confidence * 100);
+				console.log(`  ${confidenceDot(convention.confidence)} ${convention.pattern} ${chalk.gray(`(${pct}%)`)}`);
+			}
+			console.log();
+		}
+		const categoryCount = byCategory.size;
+		console.log(chalk.gray(`Found ${filtered.length} convention${filtered.length === 1 ? "" : "s"} across ${categoryCount} categor${categoryCount === 1 ? "y" : "ies"} (threshold: ${threshold})`));
+	} catch (err) {
+		spinner.fail("Analysis failed");
+		const message = err instanceof Error ? err.message : String(err);
+		console.error(chalk.red(message));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/core/drift/claim-extractor.ts
+/**
+* Matches boilerplate key-value lines that are structural metadata, not
+* behavioral claims. Applied AFTER bold/code stripping.
+*
+* Examples skipped:
+*   "Language: TypeScript"
+*   "Package Manager: bun"
+*/
+const BOILERPLATE_VALUE = /^(Language|Framework|Build|Package Manager|Test Runner|Pattern|Layers):\s/i;
+/**
+* Extract all testable claims from a markdown string.
+*
+* @param content   Raw markdown content of the context file
+* @param sourceFile Path to the source file (stored on each claim)
+* @returns Array of extracted claims, filtered and deduplicated
+*/
+function extractClaims(content, sourceFile) {
+	const claims = [];
+	const lines = content.split("\n");
+	let currentSection = "";
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		const lineNum = i + 1;
+		if (!line) continue;
+		if (line.startsWith("<!--")) continue;
+		if (line.includes("ez-context:")) continue;
+		const heading = line.match(/^#{1,3}\s+(.+)/);
+		if (heading) {
+			currentSection = heading[1].trim();
+			continue;
+		}
+		const bullet = line.match(/^[-*+]\s+(.+)/);
+		const numbered = !bullet ? line.match(/^\d+\.\s+(.+)/) : null;
+		const rawText = bullet ? bullet[1] : numbered ? numbered[1] : null;
+		if (!rawText) continue;
+		const text = rawText.replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").trim();
+		if (text.length < 10 || text.length > 300) continue;
+		if (BOILERPLATE_VALUE.test(text)) continue;
+		claims.push({
+			text,
+			sourceFile,
+			sourceLine: lineNum,
+			sourceSection: currentSection
+		});
+	}
+	return claims;
+}
+
+//#endregion
+//#region src/core/drift/claim-scorer.ts
+const GREEN_THRESHOLD = .65;
+const YELLOW_THRESHOLD = .4;
+const BATCH_SIZE = 10;
+function chunk(arr, size) {
+	const chunks = [];
+	for (let i = 0; i < arr.length; i += size) chunks.push(arr.slice(i, i + size));
+	return chunks;
+}
+function classifyScore(score) {
+	if (score >= GREEN_THRESHOLD) return "GREEN";
+	if (score >= YELLOW_THRESHOLD) return "YELLOW";
+	return "RED";
+}
+async function scoreSingleClaim(claim, bridge) {
+	const evidence = await bridge.search(claim.text, { k: 5 });
+	const topScore = evidence.length > 0 ? evidence[0].score : 0;
+	return {
+		claim,
+		status: classifyScore(topScore),
+		score: topScore,
+		evidence
+	};
+}
+/**
+* Score all claims by searching the code index in batches of BATCH_SIZE.
+*
+* @param claims     Claims to score
+* @param bridge     EzSearchBridge instance bound to the project
+* @param onProgress Optional callback fired after each batch: (done, total)
+* @returns          ScoredClaim[] in the same order as input claims
+*/
+async function scoreClaims(claims, bridge, onProgress) {
+	const total = claims.length;
+	const batches = chunk(claims, BATCH_SIZE);
+	const results = [];
+	let completed = 0;
+	for (const batch of batches) {
+		const batchResults = await Promise.all(batch.map((claim) => scoreSingleClaim(claim, bridge)));
+		results.push(...batchResults);
+		completed += batch.length;
+		onProgress?.(completed, total);
+	}
+	return results;
+}
+
+//#endregion
+//#region src/core/drift/report.ts
+/**
+* Compute the aggregate health score for a set of scored claims.
+* Returns 100 for empty input (no claims = no drift).
+*/
+function computeHealthScore(scoredClaims) {
+	if (scoredClaims.length === 0) return 100;
+	const mean = scoredClaims.reduce((sum, sc) => sum + sc.score, 0) / scoredClaims.length;
+	return Math.round(mean * 100);
+}
+/**
+* Build a DriftReport from a source file path and its scored claims.
+*/
+function buildDriftReport(sourceFile, scoredClaims) {
+	return {
+		sourceFile,
+		healthScore: computeHealthScore(scoredClaims),
+		scoredClaims
+	};
+}
+const STATUS_LABEL = {
+	GREEN: "Confirmed",
+	YELLOW: "Possibly Stale",
+	RED: "Contradicted"
+};
+/**
+* Render a drift report as a readable markdown string.
+*
+* Layout:
+*   # Drift Report
+*   Health score, source file, claim count
+*
+*   ## Confirmed (GREEN)
+*   - [GREEN] claim text (score: X.XX)
+*
+*   ## Possibly Stale (YELLOW)
+*   - [YELLOW] claim text (score: X.XX)
+*     - file: chunk_preview
+*
+*   ## Contradicted (RED)
+*   - [RED] claim text (score: X.XX)
+*     - file: chunk_preview
+*
+*   Summary: X confirmed, Y possibly stale, Z contradicted
+*/
+function renderDriftReport(report) {
+	const { sourceFile, healthScore, scoredClaims } = report;
+	const lines = [];
+	const green = scoredClaims.filter((sc) => sc.status === "GREEN");
+	const yellow = scoredClaims.filter((sc) => sc.status === "YELLOW");
+	const red = scoredClaims.filter((sc) => sc.status === "RED");
+	lines.push("# Drift Report");
+	lines.push("");
+	lines.push(`**Health Score:** ${healthScore}/100`);
+	lines.push(`**File:** ${sourceFile}`);
+	lines.push(`**Claims:** ${scoredClaims.length}`);
+	lines.push("");
+	const renderGroup = (group, status) => {
+		if (group.length === 0) return;
+		const label = STATUS_LABEL[status] ?? status;
+		lines.push(`## ${label} (${status})`);
+		lines.push("");
+		for (const sc of group) {
+			lines.push(`- [${sc.status}] ${sc.claim.text} (score: ${sc.score.toFixed(2)})`);
+			if (sc.status !== "GREEN") {
+				const topEvidence = sc.evidence.slice(0, 2);
+				for (const ev of topEvidence) {
+					const preview = ev.chunk.replace(/\s+/g, " ").trim().slice(0, 80);
+					lines.push(`  - ${ev.file}: ${preview}`);
+				}
+			}
+		}
+		lines.push("");
+	};
+	renderGroup(green, "GREEN");
+	renderGroup(yellow, "YELLOW");
+	renderGroup(red, "RED");
+	lines.push(`Summary: ${green.length} confirmed, ${yellow.length} possibly stale, ${red.length} contradicted`);
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/commands/drift.ts
+const CANDIDATE_FILES = [
+	"CLAUDE.md",
+	"AGENTS.md",
+	".cursorrules",
+	"CONTEXT.md"
+];
+function healthColor(score) {
+	if (score >= 70) return chalk.green(String(score));
+	if (score >= 40) return chalk.yellow(String(score));
+	return chalk.red(String(score));
+}
+async function driftAction(pathArg, options) {
+	const projectPath = path.resolve(pathArg);
+	const spinner = ora("Loading context files...").start();
+	try {
+		const bridge = await createBridge(projectPath);
+		if (!await bridge.hasIndex(projectPath)) {
+			spinner.fail("No search index found");
+			console.error(chalk.red("Run 'ez-context generate' or 'ez-search index .' first to create an index."));
+			process.exit(1);
+		}
+		let filePaths;
+		if (options.file) filePaths = [path.resolve(projectPath, options.file)];
+		else filePaths = CANDIDATE_FILES.map((name) => path.join(projectPath, name)).filter((p) => existsSync(p));
+		if (filePaths.length === 0) {
+			spinner.fail("No context files found");
+			console.error(chalk.red("No CLAUDE.md, AGENTS.md, .cursorrules, or CONTEXT.md found. Use --file to specify one."));
+			process.exit(1);
+		}
+		const claimsByFile = /* @__PURE__ */ new Map();
+		for (const filePath of filePaths) {
+			const claims = extractClaims(await readFile(filePath, "utf-8"), filePath);
+			claimsByFile.set(filePath, claims);
+		}
+		const allClaims = [...claimsByFile.values()].flat();
+		spinner.text = `Analyzing ${allClaims.length} claims...`;
+		const scoredAll = await scoreClaims(allClaims, bridge, (done, total) => {
+			spinner.text = `Checking claim ${done}/${total}...`;
+		});
+		const reports = filePaths.map((filePath) => {
+			const fileClaims = claimsByFile.get(filePath) ?? [];
+			return buildDriftReport(filePath, scoredAll.filter((sc) => fileClaims.some((c) => c === sc.claim)));
+		});
+		const overallScore = computeHealthScore(scoredAll);
+		spinner.succeed(`Drift analysis complete — health score: ${healthColor(overallScore)}/100`);
+		console.log();
+		for (const report of reports) {
+			console.log(renderDriftReport(report));
+			console.log();
+		}
+	} catch (err) {
+		spinner.fail("Drift analysis failed");
+		const message = err instanceof Error ? err.message : String(err);
+		console.error(chalk.red(message));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/core/updater.ts
+/**
+* Updater — targeted regeneration engine for `ez-context update`.
+*
+* Orchestrates:
+*   1. Marker validation (pre-flight check, markers strategy only)
+*   2. Drift detection (skip GREEN files, markers strategy only)
+*   3. File backup (before any write)
+*   4. Re-rendering (via FORMAT_EMITTER_MAP)
+*   5. Write-back (writeWithMarkers for markers strategy, writeFile for direct)
+*/
+/**
+* Pre-flight marker check for updateFile.
+*
+* Unlike writeWithMarkers (which silently appends on unpaired markers),
+* validateMarkers rejects unpaired markers so updateFile can abort safely.
+*
+* Returns:
+*   - { valid: true, mode: "append" }              — no markers, safe to append
+*   - { valid: true, mode: "splice", startIdx, endIdx } — well-formed pair
+*   - { valid: false, mode: "invalid", reason }    — unpaired or inverted markers
+*/
+function validateMarkers(content) {
+	const startIdx = content.indexOf(MARKER_START);
+	const endIdx = content.indexOf(MARKER_END);
+	const hasStart = startIdx !== -1;
+	const hasEnd = endIdx !== -1;
+	if (!hasStart && !hasEnd) return {
+		valid: true,
+		mode: "append"
+	};
+	if (hasStart && hasEnd) {
+		if (endIdx < startIdx) return {
+			valid: false,
+			mode: "invalid",
+			reason: "End marker appears before start marker (corrupted file)"
+		};
+		return {
+			valid: true,
+			mode: "splice",
+			startIdx,
+			endIdx
+		};
+	}
+	if (hasStart && !hasEnd) return {
+		valid: false,
+		mode: "invalid",
+		reason: "Unpaired ez-context marker: end marker missing"
+	};
+	return {
+		valid: false,
+		mode: "invalid",
+		reason: "Unpaired ez-context marker: start marker missing"
+	};
+}
+/**
+* Copy filePath to filePath.bak and return the backup path.
+* Returns null if the file does not exist.
+* Overwrites any existing .bak silently (represents state before this run).
+*/
+async function backupFile(filePath) {
+	if (!existsSync(filePath)) return null;
+	const backupPath = filePath + ".bak";
+	await copyFile(filePath, backupPath);
+	return backupPath;
+}
+/**
+* Look up the FORMAT_EMITTER_MAP entry whose filename suffix matches filePath.
+* Returns undefined if the file doesn't correspond to a known format.
+*/
+function findFormatEntry(filePath) {
+	const normalized = path.normalize(filePath);
+	for (const entry of Object.values(FORMAT_EMITTER_MAP)) if (normalized.endsWith(path.normalize(entry.filename))) return entry;
+}
+/**
+* Orchestrate drift detection and targeted re-rendering for a single file.
+*
+* The write strategy is determined by FORMAT_EMITTER_MAP:
+*   - "markers" strategy: drift detection + writeWithMarkers (default)
+*   - "direct" strategy:  always regenerate + writeFile (full overwrite)
+*
+* Flow for markers strategy:
+*   1. File existence check — skip if missing
+*   2. Marker validation — abort on invalid markers
+*   3. Drift check (splice mode only) — skip if all claims GREEN
+*   4. Backup creation
+*   5. Re-render + writeWithMarkers
+*
+* Flow for direct strategy:
+*   1. File existence check — skip if missing
+*   2. Backup creation
+*   3. Re-render + writeFile (full overwrite)
+*
+* @param filePath             Absolute path to the context file
+* @param registry             Pre-computed convention registry (NOT extracted per-file)
+* @param bridge               EzSearchBridge instance for drift scoring
+* @param confidenceThreshold  Confidence floor passed to the renderer (default 0.7)
+*/
+async function updateFile(filePath, registry, bridge, confidenceThreshold = .7) {
+	if (!existsSync(filePath)) return {
+		filePath,
+		action: "skipped",
+		reason: "File does not exist"
+	};
+	const formatEntry = findFormatEntry(filePath);
+	const strategy = formatEntry?.strategy ?? "markers";
+	const render = formatEntry?.render ?? FORMAT_EMITTER_MAP.claude.render;
+	if (strategy === "direct") {
+		const backupPath = await backupFile(filePath) ?? void 0;
+		await writeFile(filePath, render(registry, confidenceThreshold), "utf-8");
+		return {
+			filePath,
+			action: "updated",
+			reason: "Re-rendered (direct strategy)",
+			backupPath
+		};
+	}
+	const content = await readFile(filePath, "utf-8");
+	const validation = validateMarkers(content);
+	if (!validation.valid) return {
+		filePath,
+		action: "aborted",
+		reason: validation.reason
+	};
+	if (validation.mode === "splice") {
+		const claims = extractClaims(content, filePath);
+		if (claims.length === 0) return {
+			filePath,
+			action: "skipped",
+			reason: "No drift detected"
+		};
+		if (!(await scoreClaims(claims, bridge)).some((s) => s.status !== "GREEN")) return {
+			filePath,
+			action: "skipped",
+			reason: "No drift detected"
+		};
+	}
+	const backupPath = await backupFile(filePath) ?? void 0;
+	await writeWithMarkers(filePath, render(registry, confidenceThreshold));
+	return {
+		filePath,
+		action: "updated",
+		reason: "Re-rendered drifted sections",
+		backupPath
+	};
+}
+
+//#endregion
+//#region src/commands/update.ts
+async function updateAction(pathArg, options) {
+	const projectPath = path.resolve(pathArg);
+	const spinner = ora("Checking for drift...").start();
+	try {
+		const bridge = await createBridge(projectPath);
+		if (!await bridge.hasIndex(projectPath)) {
+			spinner.fail("No search index found");
+			console.error(chalk.red("Run 'ez-context generate' or 'ez-search index .' first to create an index."));
+			process.exit(1);
+		}
+		let filePaths;
+		if (options.file) filePaths = [path.resolve(projectPath, options.file)];
+		else filePaths = Object.values(FORMAT_EMITTER_MAP).map((entry) => path.join(projectPath, entry.filename)).filter((p) => existsSync(p));
+		if (filePaths.length === 0) {
+			spinner.fail("No context files found");
+			console.error(chalk.red("No generated context files found. Run 'ez-context generate' first, or use --file to specify one."));
+			process.exit(1);
+		}
+		if (options.dryRun) {
+			spinner.succeed("Dry run complete");
+			console.log();
+			console.log(chalk.bold.yellow("╔══════════════════════════════════════╗"));
+			console.log(chalk.bold.yellow("║  DRY RUN -- no files will be written ║"));
+			console.log(chalk.bold.yellow("╚══════════════════════════════════════╝"));
+			console.log();
+			for (const filePath of filePaths) {
+				const basename = path.basename(filePath);
+				const { readFile } = await import("node:fs/promises");
+				const claims = extractClaims(await readFile(filePath, "utf-8"), filePath);
+				if (claims.length === 0) {
+					console.log(`  ${chalk.gray("-")} ${basename} ${chalk.gray("(no claims to check)")}`);
+					continue;
+				}
+				if ((await scoreClaims(claims, bridge)).some((s) => s.status !== "GREEN")) console.log(`  ${chalk.yellow("~")} Would update ${chalk.cyan(basename)}`);
+				else console.log(`  ${chalk.gray("-")} Up to date: ${chalk.gray(basename)}`);
+			}
+			return;
+		}
+		spinner.text = "Extracting conventions...";
+		const registry = await extractConventions(projectPath);
+		const results = [];
+		for (const filePath of filePaths) {
+			spinner.text = `Updating ${path.basename(filePath)}...`;
+			const result = await updateFile(filePath, registry, bridge);
+			results.push(result);
+		}
+		const updated = results.filter((r) => r.action === "updated");
+		const aborted = results.filter((r) => r.action === "aborted");
+		if (updated.length === 0 && aborted.length === 0) spinner.succeed("All context files are up to date");
+		else if (updated.length > 0) spinner.succeed(`Updated ${updated.length} file${updated.length === 1 ? "" : "s"}`);
+		else spinner.fail("Update incomplete — some files could not be updated");
+		console.log();
+		for (const result of results) {
+			const basename = path.basename(result.filePath);
+			if (result.action === "updated") {
+				const backup = result.backupPath ? ` (backup: ${path.basename(result.backupPath)})` : "";
+				console.log(`  ${chalk.green("✓")} ${chalk.cyan(basename)}${chalk.gray(backup)}`);
+			} else if (result.action === "skipped") console.log(`  ${chalk.gray("-")} ${chalk.gray(basename)} ${chalk.gray(`(${result.reason})`)}`);
+			else console.log(`  ${chalk.yellow("⚠")} ${chalk.yellow(basename)} ${chalk.yellow(`(${result.reason})`)}`);
+		}
+		if (aborted.length > 0) {
+			console.log();
+			console.log(chalk.yellow(`Warning: ${aborted.length} file${aborted.length === 1 ? "" : "s"} could not be updated due to marker issues.`));
+		}
+	} catch (err) {
+		spinner.fail("Update failed");
+		const message = err instanceof Error ? err.message : String(err);
+		console.error(chalk.red(message));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+program.name("ez-context").description("Generate AI context files from any project").version("0.1.0");
+program.command("generate").description("Extract conventions and generate context files").argument("[path]", "project root to analyze", ".").option("--dry-run", "preview without writing files").option("-y, --yes", "non-interactive mode").option("--output <dir>", "output directory", ".").option("--threshold <number>", "confidence threshold 0-1", "0.7").option("--format <formats>", "output formats: claude,agents,cursor,copilot,skills,rulesync,ruler (comma-separated)", "claude,agents").action(generateAction);
+program.command("inspect").description("Display detected conventions").argument("[path]", "project root to analyze", ".").option("--threshold <number>", "confidence threshold 0-1", "0.7").action(inspectAction);
+program.command("drift").description("Check context files against code for semantic drift").argument("[path]", "project root to analyze", ".").option("--file <contextFile>", "specific context file to check").action(driftAction);
+program.command("update").description("Update drifted sections in context files, preserving manual edits").argument("[path]", "project root to analyze", ".").option("--file <contextFile>", "specific context file to update").option("--dry-run", "preview changes without writing files").option("-y, --yes", "non-interactive mode").action(updateAction);
+await program.parseAsync();
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.js.map