kly 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,699 @@
+#!/usr/bin/env node
+import { C as openDatabase, E as saveState, F as isGitRepo, J as loadConfig, K as initKlyDir, M as getFileHistory, S as loadState, a as searchFilesWithRerank, c as buildDependencyGraph, d as renderGraphAscii, f as renderGraphSvg, i as searchFiles, l as generateMermaid, q as isInitialized, s as buildIndex, t as enrichErrorStack, w as removeBranchDb, x as listBranchDbs } from "./enrich-BHaZ2daX.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { getModel } from "@mariozechner/pi-ai";
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+//#region src/commands/output.ts
+/** Output data as JSON (default) or human-readable (--pretty). */
+function output(data, opts, prettyFormatter) {
+	if (opts.pretty && prettyFormatter) process.stdout.write(prettyFormatter(data) + "\n");
+	else process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+/** Output error to stderr and exit. Optionally show a hint with correct usage. */
+function error(message, hint) {
+	let msg = `Error: ${message}`;
+	if (hint) msg += `\n  ${hint}`;
+	process.stderr.write(msg + "\n");
+	process.exit(1);
+}
+/** Output warning to stderr. */
+function warn(message) {
+	process.stderr.write(`Warning: ${message}\n`);
+}
+/** Output info to stderr (for progress/status messages that shouldn't pollute stdout). */
+function info(message) {
+	process.stderr.write(`${message}\n`);
+}
+//#endregion
+//#region src/commands/shared.ts
+function ensureInitialized(root) {
+	if (!isInitialized(root)) error("Not initialized.", "kly init --provider <provider> --api-key <key>");
+}
+//#endregion
+//#region src/commands/build.ts
+async function runBuild(root, options = {}) {
+	ensureInitialized(root);
+	if (!options.quiet) info("building index...");
+	try {
+		const result = await buildIndex(root, {
+			full: options.full,
+			quiet: options.quiet,
+			onProgress: (progress) => {
+				if (!options.quiet) {
+					let msg = `indexing [${progress.total > 0 ? Math.round(progress.completed / progress.total * 100) : 100}%] ${progress.current || "..."}`;
+					if (progress.skipped > 0) msg += ` (${progress.skipped} unchanged)`;
+					process.stderr.write(`\r${msg}`);
+				}
+			}
+		});
+		if (!options.quiet) {
+			process.stderr.write("\r\x1B[K");
+			const parts = [];
+			if (result.newFiles > 0) parts.push(`${result.newFiles} new`);
+			if (result.updatedFiles > 0) parts.push(`${result.updatedFiles} updated`);
+			if (result.deletedFiles > 0) parts.push(`${result.deletedFiles} deleted`);
+			if (result.unchangedFiles > 0) parts.push(`${result.unchangedFiles} unchanged`);
+			const summary = parts.length > 0 ? parts.join(", ") : "no changes";
+			const duration = (result.durationMs / 1e3).toFixed(1);
+			const lines = [`indexed ${result.totalFiles} files (${summary})`, `branch: ${result.branch}`];
+			if (result.commit) lines.push(`commit: ${result.commit.slice(0, 7)}`);
+			lines.push(`duration: ${duration}s`);
+			process.stdout.write(lines.join("\n") + "\n");
+		}
+	} catch (err) {
+		process.stderr.write(`\r\x1b[K`);
+		process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}\n`);
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/commands/dependents.ts
+function formatDependents(data) {
+	const result = data;
+	if (result.dependents.length === 0) return `${result.file} is not imported by any indexed file`;
+	const lines = [`${result.file} is imported by ${result.dependents.length} file(s)`, ""];
+	for (const dep of result.dependents) lines.push(`  ${dep}`);
+	return lines.join("\n");
+}
+function runDependents(root, filePath, options = {}) {
+	ensureInitialized(root);
+	const db = openDatabase(root);
+	try {
+		if (!db.getFile(filePath)) error(`File not found in index: ${filePath}`, `kly query "${filePath.split("/").pop()}"`);
+		output({
+			file: filePath,
+			dependents: db.getDependents(filePath)
+		}, options, formatDependents);
+	} finally {
+		db.close();
+	}
+}
+//#endregion
+//#region src/commands/enrich.ts
+function readStdin() {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		process.stdin.on("data", (chunk) => chunks.push(chunk));
+		process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+		process.stdin.on("error", reject);
+		if (process.stdin.isTTY) reject(/* @__PURE__ */ new Error("no input"));
+	});
+}
+function parseFrames(input) {
+	let parsed;
+	try {
+		parsed = JSON.parse(input);
+	} catch {
+		error("Invalid JSON input.", "echo '[{\"file\":\"src/foo.ts\",\"line\":42}]' | kly enrich");
+	}
+	if (!Array.isArray(parsed)) error("Input must be a JSON array of ErrorFrame objects.", "kly enrich --frames '[{\"file\":\"src/foo.ts\",\"line\":42}]'");
+	for (const [i, frame] of parsed.entries()) {
+		if (!frame.file || typeof frame.file !== "string") error(`Frame ${i}: missing or invalid "file" field.`);
+		if (typeof frame.line !== "number") error(`Frame ${i}: missing or invalid "line" field.`);
+	}
+	return parsed;
+}
+async function runEnrich(root, options = {}) {
+	ensureInitialized(root);
+	let input;
+	if (options.frames) input = options.frames;
+	else try {
+		input = await readStdin();
+	} catch {
+		error("No input provided. Pass frames via --frames or stdin.", "echo '[{\"file\":\"src/foo.ts\",\"line\":42}]' | kly enrich\n  kly enrich --frames '[{\"file\":\"src/foo.ts\",\"line\":42}]'");
+	}
+	const frames = parseFrames(input.trim());
+	if (frames.length === 0) error("Empty frames array.");
+	const db = openDatabase(root);
+	try {
+		const result = enrichErrorStack(db, root, frames);
+		process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+	} finally {
+		db.close();
+	}
+}
+//#endregion
+//#region src/commands/gc.ts
+function runGc(root) {
+	ensureInitialized(root);
+	if (!isGitRepo(root)) {
+		warn("not a git repository, nothing to clean");
+		return;
+	}
+	const branchOutput = execSync("git branch --format='%(refname:short)'", {
+		cwd: root,
+		encoding: "utf-8"
+	}).trim();
+	const activeBranches = new Set(branchOutput.split("\n").filter(Boolean).map((b) => b.replace(/'/g, "").replace(/\//g, "--")));
+	activeBranches.add("default");
+	const dbNames = listBranchDbs(root);
+	const state = loadState(root);
+	let cleaned = 0;
+	for (const dbName of dbNames) {
+		if (activeBranches.has(dbName) || dbName.startsWith("_detached--")) continue;
+		removeBranchDb(root, dbName);
+		delete state.branches[dbName];
+		cleaned++;
+		info(`removed: ${dbName}.db`);
+	}
+	if (cleaned > 0) {
+		saveState(root, state);
+		info(`cleaned ${cleaned} stale database(s)`);
+	} else info("no stale databases found");
+}
+//#endregion
+//#region src/commands/graph.ts
+function formatGraph(data) {
+	const graph = data;
+	if (graph.nodes.length === 0) return "no files indexed yet. run `kly build` first.";
+	if (graph.edges.length === 0) return "no dependencies found between indexed files.";
+	const forward = /* @__PURE__ */ new Map();
+	const reverse = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		if (!forward.has(edge.from)) forward.set(edge.from, []);
+		forward.get(edge.from).push(edge.to);
+		if (!reverse.has(edge.to)) reverse.set(edge.to, []);
+		reverse.get(edge.to).push(edge.from);
+	}
+	const lines = [`${graph.nodes.length} node(s), ${graph.edges.length} edge(s)`, ""];
+	for (const node of graph.nodes) {
+		lines.push(node.path);
+		const deps = forward.get(node.path) || [];
+		const dependents = reverse.get(node.path) || [];
+		for (const d of deps) lines.push(`  -> ${d}`);
+		for (const d of dependents) lines.push(`  <- ${d}`);
+		if (deps.length === 0 && dependents.length === 0) lines.push("  (no connections)");
+		lines.push("");
+	}
+	return lines.join("\n").trimEnd();
+}
+function runGraph(root, options = {}) {
+	ensureInitialized(root);
+	const depth = options.depth ?? 2;
+	const format = options.format ?? (options.pretty ? "ascii" : "mermaid");
+	const db = openDatabase(root);
+	try {
+		const graph = buildDependencyGraph(db, {
+			focus: options.focus,
+			depth
+		});
+		if (options.focus && !graph.nodes.has(options.focus)) error(`File not in index: ${options.focus}`, `kly query "${options.focus.split("/").pop()}"`);
+		if (format === "mermaid" || format === "ascii" || format === "svg") {
+			const mermaid = generateMermaid(graph);
+			if (graph.nodes.size === 0) {
+				console.log("no files indexed yet. run `kly build` first.");
+				return;
+			}
+			if (graph.edges.length === 0) {
+				console.log("no dependencies found between indexed files.");
+				return;
+			}
+			switch (format) {
+				case "mermaid":
+					console.log(mermaid);
+					break;
+				case "ascii":
+					console.log(renderGraphAscii(mermaid));
+					break;
+				case "svg":
+					console.log(renderGraphSvg(mermaid));
+					break;
+			}
+			return;
+		}
+		output({
+			nodes: Array.from(graph.nodes.values()),
+			edges: graph.edges
+		}, options, formatGraph);
+	} finally {
+		db.close();
+	}
+}
+//#endregion
+//#region src/commands/history.ts
+function formatHistory(data) {
+	const result = data;
+	if (result.commits.length === 0) return `no git history found for ${result.file}`;
+	const lines = [];
+	for (const c of result.commits) {
+		const date = (/* @__PURE__ */ new Date(c.date * 1e3)).toISOString().slice(0, 10);
+		lines.push(`${c.hash.slice(0, 7)} @${c.author} ${date} ${c.message}`);
+	}
+	return lines.join("\n");
+}
+function runHistory(root, filePath, options = {}) {
+	ensureInitialized(root);
+	output({
+		file: filePath,
+		commits: getFileHistory(root, filePath, options.limit ?? 5)
+	}, options, formatHistory);
+}
+//#endregion
+//#region src/commands/hook.ts
+const HOOK_BEGIN = "# BEGIN kly";
+const HOOK_END = "# END kly";
+const HOOK_CONTENT = `${HOOK_BEGIN}
+kly build --quiet 2>/dev/null || true
+${HOOK_END}`;
+function runHook(root, action) {
+	if (action !== "install" && action !== "uninstall") error("Invalid action.", "kly hook install\n  kly hook uninstall");
+	const gitDir = path.join(root, ".git");
+	if (!fs.existsSync(gitDir)) error("Not a git repository.");
+	const hooksDir = path.join(gitDir, "hooks");
+	const hookPath = path.join(hooksDir, "post-commit");
+	if (action === "install") installHook(hooksDir, hookPath);
+	else uninstallHook(hookPath);
+}
+function installHook(hooksDir, hookPath) {
+	if (!fs.existsSync(hooksDir)) fs.mkdirSync(hooksDir, { recursive: true });
+	if (fs.existsSync(hookPath)) {
+		if (fs.readFileSync(hookPath, "utf-8").includes(HOOK_BEGIN)) {
+			info("kly hook already installed (no-op)");
+			return;
+		}
+		fs.appendFileSync(hookPath, `\n${HOOK_CONTENT}\n`);
+	} else fs.writeFileSync(hookPath, `#!/bin/sh\n${HOOK_CONTENT}\n`, { mode: 493 });
+	info("installed post-commit hook");
+}
+function uninstallHook(hookPath) {
+	if (!fs.existsSync(hookPath)) {
+		warn("no post-commit hook found (no-op)");
+		return;
+	}
+	const content = fs.readFileSync(hookPath, "utf-8");
+	if (!content.includes(HOOK_BEGIN)) {
+		warn("kly hook not found in post-commit (no-op)");
+		return;
+	}
+	const regex = new RegExp(`\\n?${HOOK_BEGIN}[\\s\\S]*?${HOOK_END}\\n?`, "g");
+	const updated = content.replace(regex, "\n").trim();
+	if (updated === "#!/bin/sh" || updated === "") fs.unlinkSync(hookPath);
+	else fs.writeFileSync(hookPath, updated + "\n", { mode: 493 });
+	info("uninstalled post-commit hook");
+}
+//#endregion
+//#region src/commands/init.ts
+const VALID_PROVIDERS = [
+	"openrouter",
+	"anthropic",
+	"openai",
+	"google",
+	"mistral",
+	"groq"
+];
+const DEFAULT_MODELS = {
+	openrouter: "anthropic/claude-haiku-4.5",
+	anthropic: "claude-haiku-4.5",
+	openai: "gpt-4o-mini",
+	google: "gemini-2.0-flash",
+	mistral: "mistral-small-latest",
+	groq: "llama-3.1-8b-instant"
+};
+const DEFAULT_INCLUDE = [
+	"**/*.ts",
+	"**/*.tsx",
+	"**/*.js",
+	"**/*.jsx",
+	"**/*.swift"
+];
+const DEFAULT_EXCLUDE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/.git/**",
+	"**/.kly/**",
+	"**/vendor/**",
+	"**/*.d.ts",
+	"**/*.test.*",
+	"**/*.spec.*",
+	"**/__tests__/**"
+];
+async function runInit(root, options = {}) {
+	if (options.provider && options.apiKey) {
+		runNonInteractive(root, options);
+		return;
+	}
+	await runInteractive(root, options);
+}
+function runNonInteractive(root, options) {
+	if (!VALID_PROVIDERS.includes(options.provider)) {
+		process.stderr.write(`Error: Invalid provider "${options.provider}".\n  Valid providers: ${VALID_PROVIDERS.join(", ")}\n  kly init --provider openrouter --api-key <key>\n`);
+		process.exit(1);
+	}
+	initKlyDir(root, {
+		llm: {
+			provider: options.provider,
+			model: options.model || DEFAULT_MODELS[options.provider] || "",
+			apiKey: options.apiKey
+		},
+		include: options.include?.length ? options.include : DEFAULT_INCLUDE,
+		exclude: options.exclude?.length ? options.exclude : DEFAULT_EXCLUDE
+	});
+	info("initialized .kly/ directory");
+	if (options.hook) if (fs.existsSync(path.join(root, ".git"))) {
+		runHook(root, "install");
+		info("installed post-commit hook");
+	} else process.stderr.write("Warning: Not a git repo, skipping hook install.\n");
+}
+async function runInteractive(root, _options) {
+	p.intro("kly init");
+	if (isInitialized(root)) p.log.warn(".kly/ directory already exists, reconfiguring...");
+	const provider = await p.select({
+		message: "Select LLM provider",
+		options: [
+			{
+				value: "openrouter",
+				label: "OpenRouter",
+				hint: "recommended, supports all models"
+			},
+			{
+				value: "anthropic",
+				label: "Anthropic"
+			},
+			{
+				value: "openai",
+				label: "OpenAI"
+			},
+			{
+				value: "google",
+				label: "Google"
+			},
+			{
+				value: "mistral",
+				label: "Mistral"
+			},
+			{
+				value: "groq",
+				label: "Groq"
+			}
+		]
+	});
+	if (p.isCancel(provider)) {
+		p.cancel("Init cancelled.");
+		process.exit(0);
+	}
+	const apiKey = await p.password({
+		message: `Enter your ${provider} API key`,
+		validate: (value) => {
+			if (!value || value.trim().length === 0) return "API key is required";
+		}
+	});
+	if (p.isCancel(apiKey)) {
+		p.cancel("Init cancelled.");
+		process.exit(0);
+	}
+	const model = await p.text({
+		message: "Model name",
+		initialValue: DEFAULT_MODELS[provider] || "",
+		validate: (value) => {
+			if (!value || value.trim().length === 0) return "Model name is required";
+		}
+	});
+	if (p.isCancel(model)) {
+		p.cancel("Init cancelled.");
+		process.exit(0);
+	}
+	initKlyDir(root, {
+		llm: {
+			provider,
+			model,
+			apiKey
+		},
+		include: DEFAULT_INCLUDE,
+		exclude: DEFAULT_EXCLUDE
+	});
+	p.log.success("Initialized .kly/ directory");
+	p.log.info("Edit .kly/config.yaml to customize settings");
+	if (fs.existsSync(path.join(root, ".git"))) {
+		const installHook = await p.confirm({
+			message: "Install post-commit hook for automatic indexing?",
+			initialValue: true
+		});
+		if (!p.isCancel(installHook) && installHook) runHook(root, "install");
+	}
+	p.outro("Done!");
+}
+//#endregion
+//#region src/commands/overview.ts
+function formatOverview(data) {
+	const overview = data;
+	if (overview.totalFiles === 0) return "no files indexed yet. run `kly build` first.";
+	const lines = [
+		`total_files: ${overview.totalFiles}`,
+		"",
+		"languages:"
+	];
+	const sorted = Object.entries(overview.languages).sort(([, a], [, b]) => b - a);
+	for (const [lang, count] of sorted) {
+		const pct = (count / overview.totalFiles * 100).toFixed(1);
+		lines.push(`  ${lang}: ${count} (${pct}%)`);
+	}
+	lines.push("", "files:");
+	for (const file of overview.files) {
+		lines.push(`  ${file.path}`);
+		if (file.description) lines.push(`    ${file.description}`);
+	}
+	return lines.join("\n");
+}
+function runOverview(root, options = {}) {
+	ensureInitialized(root);
+	const db = openDatabase(root);
+	try {
+		output({
+			totalFiles: db.getFileCount(),
+			languages: db.getLanguageStats(),
+			files: db.getAllFiles().map((f) => ({
+				path: f.path,
+				name: f.name,
+				description: f.description
+			}))
+		}, options, formatOverview);
+	} finally {
+		db.close();
+	}
+}
+//#endregion
+//#region src/commands/query.ts
+function formatResults(data) {
+	const results = data;
+	if (results.length === 0) return "no matching files found";
+	const lines = [`found ${results.length} file(s)`, ""];
+	for (const r of results) {
+		lines.push(r.path);
+		lines.push(`  name: ${r.name}`);
+		lines.push(`  description: ${r.description}`);
+		lines.push(`  score: ${r.score.toFixed(2)}`);
+		if (r.summary) {
+			const summary = r.summary.replace(/\s+/g, " ").trim();
+			lines.push(`  summary: ${summary.length > 120 ? summary.slice(0, 117) + "..." : summary}`);
+		}
+		if (r.symbols.length > 0) {
+			const shown = r.symbols.slice(0, 5);
+			const more = r.symbols.length - shown.length;
+			lines.push(`  symbols: ${shown.join(", ")}${more > 0 ? ` (+${more} more)` : ""}`);
+		}
+		lines.push("");
+	}
+	return lines.join("\n").trimEnd();
+}
+function toOutputData(results) {
+	return results.map((r) => ({
+		path: r.file.path,
+		name: r.file.name,
+		description: r.file.description,
+		score: r.score,
+		summary: r.file.summary,
+		language: r.file.language,
+		symbols: r.file.symbols.map((s) => s.name)
+	}));
+}
+async function runQuery(root, description, options = {}) {
+	ensureInitialized(root);
+	const limit = options.limit ?? 10;
+	const db = openDatabase(root);
+	try {
+		let results;
+		if (options.rerank) {
+			const config = loadConfig(root);
+			const model = getModel(config.llm.provider, config.llm.model);
+			const envKey = {
+				openrouter: "OPENROUTER_API_KEY",
+				anthropic: "ANTHROPIC_API_KEY",
+				openai: "OPENAI_API_KEY",
+				google: "GOOGLE_API_KEY",
+				mistral: "MISTRAL_API_KEY",
+				groq: "GROQ_API_KEY",
+				xai: "XAI_API_KEY"
+			}[config.llm.provider] || `${config.llm.provider.toUpperCase()}_API_KEY`;
+			if (config.llm.apiKey && !process.env[envKey]) process.env[envKey] = config.llm.apiKey;
+			if (options.pretty) info("reranking results with LLM...");
+			results = await searchFilesWithRerank(db, model, description, limit);
+		} else results = searchFiles(db, description, limit);
+		output(toOutputData(results), options, formatResults);
+	} finally {
+		db.close();
+	}
+}
+//#endregion
+//#region src/commands/show.ts
+function formatFile(data) {
+	const file = data;
+	const lines = [
+		`path: ${file.path}`,
+		`name: ${file.name}`,
+		`language: ${file.language}`,
+		`description: ${file.description}`
+	];
+	if (file.summary) lines.push(`summary: ${file.summary}`);
+	if (file.imports.length > 0) {
+		lines.push("", `imports (${file.imports.length}):`);
+		for (const imp of file.imports) lines.push(`  ${imp}`);
+	}
+	if (file.exports.length > 0) {
+		lines.push("", `exports (${file.exports.length}):`);
+		for (const exp of file.exports) lines.push(`  ${exp}`);
+	}
+	if (file.symbols.length > 0) {
+		lines.push("", `symbols (${file.symbols.length}):`);
+		for (const s of file.symbols) {
+			lines.push(`  ${s.kind} ${s.name}`);
+			if (s.description) lines.push(`    ${s.description}`);
+		}
+	}
+	lines.push("", `hash: ${file.hash}`, `indexed_at: ${file.indexedAt}`);
+	return lines.join("\n");
+}
+function runShow(root, filePath, options = {}) {
+	ensureInitialized(root);
+	const db = openDatabase(root);
+	try {
+		const fileIndex = db.getFile(filePath);
+		if (!fileIndex) error(`File not found in index: ${filePath}`, `kly query "${filePath.split("/").pop()}"`);
+		output({
+			path: fileIndex.path,
+			name: fileIndex.name,
+			description: fileIndex.description,
+			language: fileIndex.language,
+			summary: fileIndex.summary,
+			imports: fileIndex.imports,
+			exports: fileIndex.exports,
+			symbols: fileIndex.symbols,
+			hash: fileIndex.hash,
+			indexedAt: new Date(fileIndex.indexedAt).toISOString()
+		}, options, formatFile);
+	} finally {
+		db.close();
+	}
+}
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+program.name("kly").description("Code repository file-level indexing tool").version("0.2.0").showHelpAfterError().showSuggestionAfterError();
+program.command("init").description("Initialize kly in the current repository").option("--provider <name>", "LLM provider (openrouter, anthropic, openai, google, mistral, groq)").option("--model <name>", "Model name (default: provider-specific)").option("--api-key <key>", "API key (or set via env variable)").option("--hook", "Also install post-commit hook").option("--include <glob...>", "File include patterns").option("--exclude <glob...>", "File exclude patterns").addHelpText("after", `
+Examples:
+  kly init --provider openrouter --api-key sk-or-xxx
+  kly init --provider anthropic --model claude-haiku-4.5 --api-key sk-ant-xxx --hook
+  kly init                          # interactive mode (no flags)
+`).action(async (options) => {
+	await runInit(process.cwd(), options);
+});
+program.command("build").description("Build or update the repository index").option("--full", "Force full rebuild").option("--quiet", "Suppress output (for git hooks)").addHelpText("after", `
+Examples:
+  kly build                    # incremental build
+  kly build --full             # full rebuild
+  kly build --full --quiet     # CI / git hook mode
+`).action(async (options) => {
+	await runBuild(process.cwd(), options);
+});
+program.command("query <text>").description("Search indexed files by natural language description").option("--rerank", "Use LLM to rerank results for better relevance").option("--limit <n>", "Maximum results", "10").option("--pretty", "Human-readable output").addHelpText("after", `
+Examples:
+  kly query "authentication middleware"
+  kly query "error handling" --limit 5
+  kly query "database migration" --rerank
+  kly query "auth" --pretty
+`).action(async (text, options) => {
+	await runQuery(process.cwd(), text, {
+		rerank: options.rerank,
+		limit: options.limit ? parseInt(options.limit, 10) : void 0,
+		pretty: options.pretty
+	});
+});
+program.command("show <path>").description("Show indexed metadata for a file").option("--pretty", "Human-readable output").addHelpText("after", `
+Examples:
+  kly show src/auth.ts
+  kly show src/auth.ts --pretty
+`).action((filePath, options) => {
+	runShow(process.cwd(), filePath, options);
+});
+program.command("overview").description("Show repository index summary with language breakdown").option("--pretty", "Human-readable output").addHelpText("after", `
+Examples:
+  kly overview
+  kly overview --pretty
+`).action((options) => {
+	runOverview(process.cwd(), options);
+});
+program.command("graph").description("Show file dependency graph").option("--focus <path>", "Focus on a specific file").option("--depth <n>", "Traversal depth", "2").option("--format <type>", "Output format: mermaid, json, ascii, svg (default: mermaid, or ascii with --pretty)").option("--pretty", "Human-readable output").addHelpText("after", `
+Examples:
+  kly graph
+  kly graph --format ascii
+  kly graph --format svg --focus src/auth.ts --depth 3
+  kly graph --format mermaid
+  kly graph --pretty
+`).action((options) => {
+	runGraph(process.cwd(), {
+		focus: options.focus,
+		depth: options.depth ? parseInt(options.depth, 10) : void 0,
+		format: options.format,
+		pretty: options.pretty
+	});
+});
+program.command("dependents <path>").description("Show files that import the given file (reverse dependencies)").option("--pretty", "Human-readable output").addHelpText("after", `
+Examples:
+  kly dependents src/database.ts
+  kly dependents src/types.ts --pretty
+`).action((filePath, options) => {
+	runDependents(process.cwd(), filePath, options);
+});
+program.command("history <path>").description("Show recent git modification history for a file").option("--limit <n>", "Number of commits", "5").option("--pretty", "Human-readable output").addHelpText("after", `
+Examples:
+  kly history src/auth.ts
+  kly history src/auth.ts --limit 10
+  kly history src/auth.ts --pretty
+`).action((filePath, options) => {
+	runHistory(process.cwd(), filePath, {
+		limit: options.limit ? parseInt(options.limit, 10) : void 0,
+		pretty: options.pretty
+	});
+});
+program.command("enrich").description("Enrich error stack frames with file descriptions, dependencies, and git history").option("--frames <json>", "Error frames as JSON string").addHelpText("after", `
+Input: JSON array of ErrorFrame objects via --frames or stdin.
+Each frame: { "file": "path", "line": number, "column?": number, "function?": "name" }
+
+Examples:
+  echo '[{"file":"src/auth.ts","line":42}]' | kly enrich
+  kly enrich --frames '[{"file":"src/auth.ts","line":42,"function":"validate"}]'
+  cat error-frames.json | kly enrich
+`).action(async (options) => {
+	await runEnrich(process.cwd(), options);
+});
+program.command("hook <action>").description("Install or uninstall the post-commit hook").addHelpText("after", `
+Examples:
+  kly hook install
+  kly hook uninstall
+`).action((action) => {
+	runHook(process.cwd(), action);
+});
+program.command("gc").description("Remove databases for deleted git branches").addHelpText("after", `
+Examples:
+  kly gc
+`).action(() => {
+	runGc(process.cwd());
+});
+await program.parseAsync();
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map