@ez-corp/ez-context 0.1.0

package/dist/emitters-D6bP4xWs.js

@@ -0,0 +1,1849 @@
+import { z } from "zod";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path, { dirname, join, relative, resolve } from "node:path";
+import { parse } from "smol-toml";
+import { globby } from "globby";
+import yaml, { load } from "js-yaml";
+import { Project, SyntaxKind } from "ts-morph";
+import { EzSearchError, index, query } from "@ez-corp/ez-search";
+import { existsSync } from "node:fs";
+
+//#region src/core/schema.ts
+const ConventionCategorySchema = z.enum([
+	"stack",
+	"naming",
+	"architecture",
+	"error_handling",
+	"testing",
+	"imports",
+	"other"
+]);
+const EvidenceRefSchema = z.object({
+	file: z.string(),
+	line: z.number().int().positive().nullable()
+});
+const ConventionEntrySchema = z.object({
+	id: z.uuid(),
+	category: ConventionCategorySchema,
+	pattern: z.string().min(1),
+	confidence: z.number().min(0).max(1),
+	evidence: z.array(EvidenceRefSchema),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+const StackInfoSchema = z.object({
+	language: z.string(),
+	framework: z.string().optional(),
+	testRunner: z.string().optional(),
+	buildTool: z.string().optional(),
+	packageManager: z.string().optional(),
+	nodeVersion: z.string().optional()
+});
+const ArchitectureInfoSchema = z.object({
+	pattern: z.string().optional(),
+	layers: z.array(z.string()),
+	entryPoints: z.array(z.string()).optional()
+});
+const ConventionRegistrySchema = z.object({
+	version: z.literal("1"),
+	projectPath: z.string(),
+	generatedAt: z.string().datetime(),
+	stack: StackInfoSchema,
+	conventions: z.array(ConventionEntrySchema),
+	architecture: ArchitectureInfoSchema,
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+
+//#endregion
+//#region src/core/registry.ts
+/**
+* Create a new empty ConventionRegistry for the given project path.
+* The returned registry passes ConventionRegistrySchema validation.
+*/
+function createRegistry(projectPath) {
+	const registry = {
+		version: "1",
+		projectPath,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		stack: { language: "unknown" },
+		conventions: [],
+		architecture: { layers: [] }
+	};
+	const result = ConventionRegistrySchema.safeParse(registry);
+	if (!result.success) throw new Error(`createRegistry produced invalid registry: ${JSON.stringify(result.error.issues)}`);
+	return result.data;
+}
+/**
+* Add a convention entry to the registry, auto-generating a UUID for the id.
+* Returns a new registry (does not mutate the input).
+*/
+function addConvention(registry, entry) {
+	const newEntry = {
+		id: crypto.randomUUID(),
+		...entry
+	};
+	const updated = {
+		...registry,
+		conventions: [...registry.conventions, newEntry]
+	};
+	const result = ConventionRegistrySchema.safeParse(updated);
+	if (!result.success) throw new Error(`addConvention produced invalid registry: ${JSON.stringify(result.error.issues)}`);
+	return result.data;
+}
+
+//#endregion
+//#region src/extractors/index.ts
+/**
+* Run all extractors in parallel via Promise.allSettled so that a single
+* failing extractor does not abort the others.
+*
+* Fulfilled entries are added to the registry immutably via `addConvention`.
+* Rejected extractors emit a console.warn and are skipped.
+*/
+async function runExtractors(extractors, ctx, registry) {
+	const results = await Promise.allSettled(extractors.map((e) => e.extract(ctx).then((entries) => ({
+		extractor: e,
+		entries
+	}))));
+	let current = registry;
+	for (const [i, result] of results.entries()) if (result.status === "fulfilled") for (const entry of result.value.entries) current = addConvention(current, entry);
+	else console.warn(`[runExtractors] Extractor "${extractors[i].name}" failed:`, result.reason);
+	return current;
+}
+
+//#endregion
+//#region src/extractors/static/package-json.ts
+const FRAMEWORK_MAP = {
+	react: "React",
+	vue: "Vue",
+	"@angular/core": "Angular",
+	next: "Next.js",
+	nuxt: "Nuxt",
+	svelte: "Svelte",
+	hono: "Hono",
+	express: "Express",
+	fastify: "Fastify",
+	koa: "Koa"
+};
+const TEST_RUNNER_MAP = {
+	vitest: "Vitest",
+	jest: "Jest",
+	mocha: "Mocha",
+	jasmine: "Jasmine",
+	ava: "Ava"
+};
+function allDeps(pkg) {
+	return {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+}
+const EVIDENCE$1 = [{
+	file: "package.json",
+	line: null
+}];
+const packageJsonExtractor = {
+	name: "package-json",
+	async extract(ctx) {
+		const filePath = join(ctx.projectPath, "package.json");
+		try {
+			await access(filePath);
+		} catch {
+			return [];
+		}
+		let pkg;
+		try {
+			const raw = await readFile(filePath, "utf-8");
+			pkg = JSON.parse(raw);
+		} catch {
+			return [];
+		}
+		const deps = allDeps(pkg);
+		const entries = [];
+		const language = "typescript" in deps || "@types/node" in deps ? "TypeScript" : "JavaScript";
+		entries.push({
+			category: "stack",
+			pattern: `Language: ${language}`,
+			confidence: .95,
+			evidence: EVIDENCE$1,
+			metadata: { language }
+		});
+		for (const [pkg_name, label] of Object.entries(FRAMEWORK_MAP)) if (pkg_name in deps) {
+			const version = deps[pkg_name];
+			entries.push({
+				category: "stack",
+				pattern: `Framework: ${label}`,
+				confidence: 1,
+				evidence: EVIDENCE$1,
+				metadata: {
+					framework: label,
+					version
+				}
+			});
+			break;
+		}
+		for (const [pkg_name, label] of Object.entries(TEST_RUNNER_MAP)) if (pkg_name in deps) {
+			entries.push({
+				category: "testing",
+				pattern: `Test runner: ${label}`,
+				confidence: .95,
+				evidence: EVIDENCE$1,
+				metadata: { testRunner: label }
+			});
+			break;
+		}
+		if (typeof pkg.packageManager === "string") {
+			const pmName = pkg.packageManager.split("@")[0];
+			if (pmName) entries.push({
+				category: "stack",
+				pattern: `Package manager: ${pmName}`,
+				confidence: 1,
+				evidence: EVIDENCE$1,
+				metadata: { packageManager: pmName }
+			});
+		}
+		if (pkg.type === "module") entries.push({
+			category: "imports",
+			pattern: `ES modules (package.json "type": "module")`,
+			confidence: 1,
+			evidence: EVIDENCE$1,
+			metadata: { moduleSystem: "esm" }
+		});
+		const scripts = pkg.scripts ?? {};
+		for (const [scriptName, command] of Object.entries(scripts)) {
+			const isTestScript = scriptName === "test" || scriptName.startsWith("test:");
+			if (isTestScript || scriptName === "build" || scriptName === "lint") entries.push({
+				category: isTestScript ? "testing" : "stack",
+				pattern: `Script "${scriptName}": ${command}`,
+				confidence: 1,
+				evidence: EVIDENCE$1,
+				metadata: {
+					scriptName,
+					command
+				}
+			});
+		}
+		return entries;
+	}
+};
+
+//#endregion
+//#region src/extractors/static/lockfile.ts
+const LOCKFILES = [
+	{
+		file: "bun.lock",
+		manager: "bun"
+	},
+	{
+		file: "bun.lockb",
+		manager: "bun"
+	},
+	{
+		file: "pnpm-lock.yaml",
+		manager: "pnpm"
+	},
+	{
+		file: "yarn.lock",
+		manager: "yarn"
+	},
+	{
+		file: "package-lock.json",
+		manager: "npm"
+	}
+];
+const lockfileExtractor = {
+	name: "lockfile",
+	async extract(ctx) {
+		for (const { file, manager } of LOCKFILES) try {
+			await access(join(ctx.projectPath, file));
+			return [{
+				category: "stack",
+				pattern: `Package manager: ${manager}`,
+				confidence: 1,
+				evidence: [{
+					file,
+					line: null
+				}],
+				metadata: { packageManager: manager }
+			}];
+		} catch {}
+		return [];
+	}
+};
+
+//#endregion
+//#region src/extractors/static/tsconfig.ts
+const EVIDENCE = [{
+	file: "tsconfig.json",
+	line: null
+}];
+/**
+* Strip single-line // comments and trailing commas so JSON.parse accepts
+* tsconfig.json files that use non-standard JSON.
+*/
+function stripTsConfigNonStandardJson(raw) {
+	return raw.replace(/\/\/[^\n]*/g, "").replace(/,(\s*[}\]])/g, "$1");
+}
+const tsconfigExtractor = {
+	name: "tsconfig",
+	async extract(ctx) {
+		const filePath = join(ctx.projectPath, "tsconfig.json");
+		try {
+			await access(filePath);
+		} catch {
+			return [];
+		}
+		let config;
+		try {
+			const raw = await readFile(filePath, "utf-8");
+			config = JSON.parse(stripTsConfigNonStandardJson(raw));
+		} catch {
+			return [];
+		}
+		const co = config.compilerOptions ?? {};
+		const entries = [];
+		if (co.strict === true) entries.push({
+			category: "stack",
+			pattern: "TypeScript strict mode enabled",
+			confidence: 1,
+			evidence: EVIDENCE,
+			metadata: { strict: true }
+		});
+		const notable = {};
+		for (const key of [
+			"target",
+			"module",
+			"moduleResolution"
+		]) if (co[key] !== void 0) notable[key] = co[key];
+		if (Object.keys(notable).length > 0) entries.push({
+			category: "stack",
+			pattern: "TypeScript compiler options configured",
+			confidence: 1,
+			evidence: EVIDENCE,
+			metadata: notable
+		});
+		if (co.paths && Object.keys(co.paths).length > 0) entries.push({
+			category: "imports",
+			pattern: "Uses TypeScript path aliases",
+			confidence: 1,
+			evidence: EVIDENCE,
+			metadata: { aliases: co.paths }
+		});
+		return entries;
+	}
+};
+
+//#endregion
+//#region src/extractors/static/go-mod.ts
+const goModExtractor = {
+	name: "go-mod",
+	async extract(ctx) {
+		const filePath = join(ctx.projectPath, "go.mod");
+		try {
+			await access(filePath);
+		} catch {
+			return [];
+		}
+		let raw;
+		try {
+			raw = await readFile(filePath, "utf-8");
+		} catch {
+			return [];
+		}
+		const lines = raw.split("\n");
+		let moduleName = "";
+		let goVersion = "";
+		let dependencyCount = 0;
+		let inRequireBlock = false;
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!moduleName) {
+				const moduleMatch = trimmed.match(/^module\s+(\S+)/);
+				if (moduleMatch?.[1]) {
+					moduleName = moduleMatch[1];
+					continue;
+				}
+			}
+			if (!goVersion) {
+				const goMatch = trimmed.match(/^go\s+(\S+)/);
+				if (goMatch?.[1]) {
+					goVersion = goMatch[1];
+					continue;
+				}
+			}
+			if (trimmed === "require (") {
+				inRequireBlock = true;
+				continue;
+			}
+			if (inRequireBlock) {
+				if (trimmed === ")") inRequireBlock = false;
+				else if (trimmed.length > 0 && !trimmed.startsWith("//")) dependencyCount++;
+				continue;
+			}
+			if (trimmed.match(/^require\s+\S+\s+v\S+/)) dependencyCount++;
+		}
+		if (!moduleName) return [];
+		return [{
+			category: "stack",
+			pattern: `Go project (${moduleName})`,
+			confidence: 1,
+			evidence: [{
+				file: "go.mod",
+				line: null
+			}],
+			metadata: {
+				language: "Go",
+				moduleName,
+				goVersion: goVersion || null,
+				dependencyCount
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/extractors/static/cargo-toml.ts
+const cargoTomlExtractor = {
+	name: "cargo-toml",
+	async extract(ctx) {
+		const filePath = join(ctx.projectPath, "Cargo.toml");
+		try {
+			await access(filePath);
+		} catch {
+			return [];
+		}
+		let cargo;
+		try {
+			cargo = parse(await readFile(filePath, "utf-8"));
+		} catch {
+			return [];
+		}
+		const packageName = cargo.package?.name;
+		if (!packageName) return [];
+		const dependencyCount = Object.keys(cargo.dependencies ?? {}).length;
+		return [{
+			category: "stack",
+			pattern: `Rust project (${packageName})`,
+			confidence: 1,
+			evidence: [{
+				file: "Cargo.toml",
+				line: null
+			}],
+			metadata: {
+				language: "Rust",
+				packageName,
+				dependencyCount
+			}
+		}];
+	}
+};
+
+//#endregion
+//#region src/extractors/static/ci.ts
+const BUILD_KEYWORDS = [
+	"build",
+	"compile",
+	"tsc",
+	"tsdown"
+];
+const TEST_KEYWORDS = [
+	"test",
+	"vitest",
+	"jest",
+	"pytest",
+	"cargo test",
+	"go test"
+];
+const LINT_KEYWORDS = [
+	"lint",
+	"eslint",
+	"biome",
+	"clippy",
+	"ruff"
+];
+function categorizeCommand(cmd) {
+	const lower = cmd.toLowerCase();
+	if (TEST_KEYWORDS.some((kw) => lower.includes(kw))) return "testing";
+	if (BUILD_KEYWORDS.some((kw) => lower.includes(kw))) return "stack";
+	if (LINT_KEYWORDS.some((kw) => lower.includes(kw))) return "stack";
+	return null;
+}
+/**
+* Extract run commands from a GitHub Actions workflow YAML.
+* Traverses jobs.*.steps[].run
+*/
+function extractGithubActionsCommands(doc, filePath) {
+	const matched = [];
+	const raw = [];
+	if (!doc || typeof doc !== "object") return {
+		matched,
+		raw
+	};
+	const jobs = doc["jobs"];
+	if (!jobs || typeof jobs !== "object") return {
+		matched,
+		raw
+	};
+	for (const job of Object.values(jobs)) {
+		if (!job || typeof job !== "object") continue;
+		const steps = job["steps"];
+		if (!Array.isArray(steps)) continue;
+		for (const step of steps) {
+			if (!step || typeof step !== "object") continue;
+			const run = step["run"];
+			if (typeof run !== "string") continue;
+			for (const line of run.split("\n")) {
+				const trimmed = line.trim();
+				if (!trimmed) continue;
+				raw.push(trimmed);
+				const category = categorizeCommand(trimmed);
+				if (category !== null) matched.push({
+					command: trimmed,
+					category,
+					ciFile: filePath
+				});
+			}
+		}
+	}
+	return {
+		matched,
+		raw
+	};
+}
+/** Keys that are not job definitions in GitLab CI top-level. */
+const GITLAB_RESERVED = new Set([
+	"stages",
+	"variables",
+	"include",
+	"default",
+	"workflow",
+	"image",
+	"services",
+	"before_script",
+	"after_script",
+	"cache",
+	"artifacts"
+]);
+/**
+* Extract script commands from a GitLab CI YAML.
+* Traverses top-level job keys (skipping reserved keys), looks for script arrays.
+*/
+function extractGitlabCiCommands(doc, filePath) {
+	const matched = [];
+	const raw = [];
+	if (!doc || typeof doc !== "object") return {
+		matched,
+		raw
+	};
+	for (const [key, job] of Object.entries(doc)) {
+		if (GITLAB_RESERVED.has(key)) continue;
+		if (!job || typeof job !== "object") continue;
+		const script = job["script"];
+		const scripts = Array.isArray(script) ? script : typeof script === "string" ? [script] : [];
+		for (const cmd of scripts) {
+			if (typeof cmd !== "string") continue;
+			const trimmed = cmd.trim();
+			if (!trimmed) continue;
+			raw.push(trimmed);
+			const category = categorizeCommand(trimmed);
+			if (category !== null) matched.push({
+				command: trimmed,
+				category,
+				ciFile: filePath
+			});
+		}
+	}
+	return {
+		matched,
+		raw
+	};
+}
+const ciExtractor = {
+	name: "ci",
+	async extract(ctx) {
+		const ciFiles = await globby([
+			".github/workflows/*.yml",
+			".github/workflows/*.yaml",
+			".gitlab-ci.yml"
+		], {
+			cwd: ctx.projectPath,
+			gitignore: false,
+			followSymbolicLinks: false,
+			absolute: false
+		});
+		if (ciFiles.length === 0) return [];
+		const entries = [];
+		for (const relPath of ciFiles) {
+			const absPath = join(ctx.projectPath, relPath);
+			let raw;
+			try {
+				raw = await readFile(absPath, "utf-8");
+			} catch {
+				continue;
+			}
+			let doc;
+			try {
+				doc = load(raw);
+			} catch {
+				continue;
+			}
+			const { matched, raw: rawCmds } = relPath.includes(".gitlab-ci") ? extractGitlabCiCommands(doc, relPath) : extractGithubActionsCommands(doc, relPath);
+			if (rawCmds.length > 0 || matched.length > 0) for (const { command, category } of matched) entries.push({
+				category,
+				pattern: `CI command: ${command}`,
+				confidence: .9,
+				evidence: [{
+					file: relative(ctx.projectPath, absPath) || relPath,
+					line: null
+				}],
+				metadata: {
+					command,
+					ciFile: relPath,
+					rawCommands: rawCmds
+				}
+			});
+		}
+		return entries;
+	}
+};
+
+//#endregion
+//#region src/utils/fs.ts
+/** Directories and paths that are always excluded from file listings. */
+const ALWAYS_SKIP = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/generated/**",
+	"**/.ez-search/**",
+	"**/.ez-context/**",
+	"**/.git/**"
+];
+/**
+* List project files while respecting .gitignore (INTG-04) and always
+* skipping common generated/build directories.
+*
+* @returns Relative paths sorted alphabetically.
+*/
+async function listProjectFiles(options) {
+	const { cwd, extensions = [
+		"ts",
+		"js",
+		"json",
+		"md"
+	], additionalIgnore = [] } = options;
+	return (await globby(extensions.length === 1 ? `**/*.${extensions[0]}` : `**/*.{${extensions.join(",")}}`, {
+		cwd,
+		gitignore: true,
+		ignore: [...ALWAYS_SKIP, ...additionalIgnore],
+		followSymbolicLinks: false,
+		absolute: false
+	})).sort();
+}
+
+//#endregion
+//#region src/extractors/static/project-structure.ts
+/** Top-level test directory prefixes — files here are directory-based, not co-located. */
+const TEST_DIR_PREFIXES = [
+	"test/",
+	"tests/",
+	"__tests__/"
+];
+const TEST_PATTERNS = [
+	{
+		glob: "**/*.test.{ts,tsx,js,jsx}",
+		location: "co-located",
+		style: "*.test.ts style"
+	},
+	{
+		glob: "**/*.spec.{ts,tsx,js,jsx}",
+		location: "co-located",
+		style: "*.spec.ts style"
+	},
+	{
+		glob: "test/**/*.{ts,tsx,js,jsx}",
+		location: "test/ directory",
+		style: "test/ directory"
+	},
+	{
+		glob: "tests/**/*.{ts,tsx,js,jsx}",
+		location: "tests/ directory",
+		style: "tests/ directory"
+	},
+	{
+		glob: "__tests__/**/*.{ts,tsx,js,jsx}",
+		location: "__tests__/ directory",
+		style: "__tests__/ directory"
+	}
+];
+const projectStructureExtractor = {
+	name: "project-structure",
+	async extract(ctx) {
+		const entries = [];
+		for (const { glob, location, style } of TEST_PATTERNS) {
+			let matches = await globby(glob, {
+				cwd: ctx.projectPath,
+				gitignore: true,
+				ignore: [...ALWAYS_SKIP],
+				followSymbolicLinks: false,
+				absolute: false
+			});
+			if (location === "co-located") matches = matches.filter((f) => !TEST_DIR_PREFIXES.some((prefix) => f.startsWith(prefix)));
+			if (matches.length === 0) continue;
+			const count = matches.length;
+			const confidence = Math.min(.95, .5 + count * .05);
+			const evidenceFiles = matches.slice(0, 5);
+			entries.push({
+				category: "testing",
+				pattern: `Test files in ${location} (${style})`,
+				confidence,
+				evidence: evidenceFiles.map((f) => ({
+					file: f,
+					line: null
+				})),
+				metadata: {
+					testFileCount: count,
+					location,
+					style
+				}
+			});
+		}
+		return entries;
+	}
+};
+
+//#endregion
+//#region src/extractors/code/naming.ts
+/**
+* Classify the naming convention of a single identifier.
+* Returns null for short names (< 4 chars) or unclassifiable names.
+*/
+function classifyCase(name) {
+	if (name.length < 4) return null;
+	if (/^[A-Z][A-Z0-9_]{3,}$/.test(name)) return "UPPER_SNAKE_CASE";
+	if (/^[A-Z][a-zA-Z0-9]+$/.test(name)) return "PascalCase";
+	if (/^[a-z][a-z0-9_]+$/.test(name) && name.includes("_")) return "snake_case";
+	if (/^[a-z][a-zA-Z0-9]+$/.test(name) && /[A-Z]/.test(name)) return "camelCase";
+	return null;
+}
+const namingExtractor = {
+	name: "naming",
+	async extract(ctx) {
+		const files = await listProjectFiles({
+			cwd: ctx.projectPath,
+			extensions: [
+				"ts",
+				"tsx",
+				"js",
+				"jsx"
+			]
+		});
+		if (files.length === 0) return [];
+		const maxFiles = ctx.options?.maxFilesForAst ?? 200;
+		const filesToAnalyse = files.slice(0, maxFiles);
+		const project = new Project({
+			compilerOptions: {
+				allowJs: true,
+				noEmit: true
+			},
+			skipFileDependencyResolution: true
+		});
+		const absPaths = filesToAnalyse.map((f) => `${ctx.projectPath}/${f}`);
+		project.addSourceFilesAtPaths(absPaths);
+		const functions = {};
+		const variables = {};
+		const classes = {};
+		const counts = {
+			functions,
+			variables,
+			classes
+		};
+		for (const sf of project.getSourceFiles()) {
+			for (const fn of sf.getFunctions()) {
+				const name = fn.getName();
+				if (!name) continue;
+				const kind = classifyCase(name);
+				if (kind) functions[kind] = (functions[kind] ?? 0) + 1;
+			}
+			for (const decl of sf.getVariableDeclarations()) {
+				const kind = classifyCase(decl.getName());
+				if (kind) variables[kind] = (variables[kind] ?? 0) + 1;
+			}
+			for (const cls of sf.getClasses()) {
+				const name = cls.getName();
+				if (!name) continue;
+				const kind = classifyCase(name);
+				if (kind) classes[kind] = (classes[kind] ?? 0) + 1;
+			}
+		}
+		const entries = [];
+		for (const [entityType, caseCounts] of Object.entries(counts)) {
+			const total = Object.values(caseCounts).reduce((a, b) => a + b, 0);
+			if (total < 3) continue;
+			let dominant = null;
+			let dominantCount = 0;
+			for (const [kind, count] of Object.entries(caseCounts)) if (count > dominantCount) {
+				dominant = kind;
+				dominantCount = count;
+			}
+			if (!dominant) continue;
+			const confidence = Math.min(.95, dominantCount / total);
+			if (confidence < .6) continue;
+			entries.push({
+				category: "naming",
+				pattern: `${entityType} use ${dominant} naming`,
+				confidence,
+				evidence: [{
+					file: "src/**/*.ts",
+					line: null
+				}],
+				metadata: {
+					entityType,
+					dominantCase: dominant,
+					counts: caseCounts,
+					sampleSize: total
+				}
+			});
+		}
+		return entries;
+	}
+};
+
+//#endregion
+//#region src/extractors/code/imports.ts
+/** Known path alias prefixes used across JS/TS ecosystems. */
+const ALIAS_PREFIXES = [
+	"@/",
+	"~/",
+	"#/",
+	"$lib/"
+];
+function hasPathAlias(specifier) {
+	return ALIAS_PREFIXES.some((prefix) => specifier.startsWith(prefix));
+}
+/**
+* Check whether a source file looks like a barrel file:
+* - Has at least one export declaration
+* - Has no function, class, or variable declarations
+*/
+function isBarrelFile(sourceFile) {
+	if (!(sourceFile.getExportDeclarations().length > 0)) return false;
+	const hasFunctions = sourceFile.getFunctions().length > 0;
+	const hasClasses = sourceFile.getClasses().length > 0;
+	const hasVars = sourceFile.getVariableDeclarations().length > 0;
+	return !hasFunctions && !hasClasses && !hasVars;
+}
+/**
+* Build a set of absolute paths for barrel files (index.ts/js variants).
+* Since skipFileDependencyResolution prevents module resolution,
+* we identify barrel files upfront and match imports by path.
+*/
+function buildBarrelFileSet(project) {
+	const barrels = /* @__PURE__ */ new Set();
+	for (const sf of project.getSourceFiles()) {
+		const filePath = sf.getFilePath();
+		const baseName = filePath.split("/").pop() ?? "";
+		if (/^index\.[tj]sx?$/.test(baseName) && isBarrelFile(sf)) barrels.add(filePath);
+	}
+	return barrels;
+}
+/** Resolve a relative import specifier to candidate absolute paths. */
+function resolveRelativeImport(importingFile, specifier) {
+	const base = resolve(dirname(importingFile), specifier);
+	const exts = [
+		".ts",
+		".tsx",
+		".js",
+		".jsx"
+	];
+	const candidates = [];
+	for (const ext of exts) candidates.push(base + ext);
+	for (const ext of exts) candidates.push(join(base, "index" + ext));
+	return candidates;
+}
+const importsExtractor = {
+	name: "imports",
+	async extract(ctx) {
+		const files = await listProjectFiles({
+			cwd: ctx.projectPath,
+			extensions: [
+				"ts",
+				"tsx",
+				"js",
+				"jsx"
+			]
+		});
+		if (files.length === 0) return [];
+		const maxFiles = ctx.options?.maxFilesForAst ?? 200;
+		const filesToAnalyse = files.slice(0, maxFiles);
+		const project = new Project({
+			compilerOptions: {
+				allowJs: true,
+				noEmit: true
+			},
+			skipFileDependencyResolution: true
+		});
+		const absPaths = filesToAnalyse.map((f) => `${ctx.projectPath}/${f}`);
+		project.addSourceFilesAtPaths(absPaths);
+		const barrelFiles = buildBarrelFileSet(project);
+		let relativeCount = 0;
+		let externalCount = 0;
+		let barrelCount = 0;
+		let aliasCount = 0;
+		for (const sf of project.getSourceFiles()) for (const imp of sf.getImportDeclarations()) {
+			const specifier = imp.getModuleSpecifierValue();
+			if (imp.isModuleSpecifierRelative()) {
+				relativeCount++;
+				if (resolveRelativeImport(sf.getFilePath(), specifier).some((c) => barrelFiles.has(c))) barrelCount++;
+			} else {
+				externalCount++;
+				if (hasPathAlias(specifier)) aliasCount++;
+			}
+		}
+		const totalImports = relativeCount + externalCount;
+		if (totalImports === 0) return [];
+		const entries = [];
+		const evidence = [{
+			file: "src/**/*.ts",
+			line: null
+		}];
+		const relRatio = relativeCount / totalImports;
+		let orgPattern;
+		if (relRatio >= .75) orgPattern = "Predominantly relative imports";
+		else if (relRatio <= .25) orgPattern = "Predominantly external imports";
+		else orgPattern = "Mix of relative and external imports";
+		const sizeConfidence = Math.min(.95, .5 + totalImports / 100 * .45);
+		entries.push({
+			category: "imports",
+			pattern: orgPattern,
+			confidence: sizeConfidence,
+			evidence,
+			metadata: {
+				relativeCount,
+				externalCount,
+				totalImports,
+				relativeRatio: Math.round(relRatio * 100) / 100
+			}
+		});
+		if (barrelCount > 0) {
+			const barrelRatio = barrelCount / relativeCount;
+			entries.push({
+				category: "imports",
+				pattern: "Uses barrel file (index) imports",
+				confidence: Math.min(.95, .5 + barrelRatio * .45),
+				evidence,
+				metadata: {
+					barrelCount,
+					relativeCount
+				}
+			});
+		}
+		if (aliasCount > 0) entries.push({
+			category: "imports",
+			pattern: "Uses path aliases (@/ prefix)",
+			confidence: 1,
+			evidence,
+			metadata: { aliasCount }
+		});
+		return entries;
+	}
+};
+
+//#endregion
+//#region src/extractors/code/error-handling.ts
+const staticErrorHandlingExtractor = {
+	name: "static-error-handling",
+	async extract(ctx) {
+		const files = await listProjectFiles({
+			cwd: ctx.projectPath,
+			extensions: [
+				"ts",
+				"tsx",
+				"js",
+				"jsx"
+			]
+		});
+		if (files.length === 0) return [];
+		const maxFiles = ctx.options?.maxFilesForAst ?? 200;
+		const filesToAnalyse = files.slice(0, maxFiles);
+		const project = new Project({
+			compilerOptions: {
+				allowJs: true,
+				noEmit: true
+			},
+			skipFileDependencyResolution: true
+		});
+		const absPaths = filesToAnalyse.map((f) => `${ctx.projectPath}/${f}`);
+		project.addSourceFilesAtPaths(absPaths);
+		let tryCatchFileCount = 0;
+		let tryCatchTotalCount = 0;
+		let customErrorClassCount = 0;
+		const tryCatchEvidence = [];
+		const customErrorEvidence = [];
+		for (const sf of project.getSourceFiles()) {
+			const relPath = sf.getFilePath().replace(ctx.projectPath + "/", "");
+			const tryStatements = sf.getDescendantsOfKind(SyntaxKind.TryStatement);
+			if (tryStatements.length > 0) {
+				tryCatchFileCount++;
+				tryCatchTotalCount += tryStatements.length;
+				if (tryCatchEvidence.length < 5) tryCatchEvidence.push(relPath);
+			}
+			for (const cls of sf.getClasses()) {
+				const heritage = cls.getExtends();
+				if (heritage && /\bError\b/.test(heritage.getText())) {
+					customErrorClassCount++;
+					if (customErrorEvidence.length < 5) customErrorEvidence.push(relPath);
+				}
+			}
+		}
+		const entries = [];
+		const totalFiles = filesToAnalyse.length;
+		if (tryCatchTotalCount >= 2) {
+			const fileSpread = tryCatchFileCount / totalFiles;
+			const densityBoost = Math.min(.2, tryCatchTotalCount * .05);
+			const confidence = Math.min(.95, .5 + fileSpread * .35 + densityBoost);
+			entries.push({
+				category: "error_handling",
+				pattern: "try/catch imperative error handling",
+				confidence,
+				evidence: tryCatchEvidence.map((file) => ({
+					file,
+					line: null
+				})),
+				metadata: {
+					style: "try-catch",
+					fileCount: tryCatchFileCount,
+					totalCount: tryCatchTotalCount
+				}
+			});
+		}
+		if (customErrorClassCount >= 1) {
+			const confidence = Math.min(.95, .5 + customErrorClassCount / totalFiles * .45);
+			entries.push({
+				category: "error_handling",
+				pattern: "custom error class hierarchy",
+				confidence,
+				evidence: customErrorEvidence.map((file) => ({
+					file,
+					line: null
+				})),
+				metadata: {
+					style: "custom-error-class",
+					classCount: customErrorClassCount
+				}
+			});
+		}
+		return entries;
+	}
+};
+
+//#endregion
+//#region src/core/ez-search-bridge.ts
+/**
+* ez-search bridge — thin adapter over @ez-corp/ez-search.
+*
+* This is the ONLY file that imports from @ez-corp/ez-search.
+* All other modules interact with ez-search via the EzSearchBridge interface.
+*/
+var EzSearchBridgeImpl = class {
+	constructor(projectPath) {
+		this.projectPath = projectPath;
+	}
+	async hasIndex(projectPath) {
+		return existsSync(join(projectPath, ".ez-search"));
+	}
+	async ensureIndex(projectPath) {
+		if (await this.hasIndex(projectPath)) return;
+		await index(projectPath);
+	}
+	async search(searchQuery, options = {}) {
+		const { k = 10 } = options;
+		let raw;
+		try {
+			raw = await query(searchQuery, {
+				topK: k,
+				projectDir: this.projectPath,
+				autoIndex: false
+			});
+		} catch (err) {
+			if (err instanceof EzSearchError && err.code === "NO_INDEX") return [];
+			throw err;
+		}
+		const results = [];
+		for (const hit of raw.code) results.push({
+			file: hit.file,
+			chunk: hit.text,
+			score: hit.score
+		});
+		for (const hit of raw.text) results.push({
+			file: hit.file,
+			chunk: hit.text,
+			score: hit.score
+		});
+		results.sort((a, b) => b.score - a.score);
+		return results.slice(0, k);
+	}
+	async embed(_text) {
+		throw new Error("embed() is not yet supported by the ez-search bridge. Use search() for semantic retrieval.");
+	}
+};
+/**
+* Create an EzSearchBridge bound to the given project directory.
+*/
+async function createBridge(projectPath) {
+	return new EzSearchBridgeImpl(projectPath);
+}
+
+//#endregion
+//#region src/extractors/semantic/error-handling.ts
+const PATTERNS = [
+	{
+		style: "try-catch",
+		pattern: "try/catch imperative error handling",
+		test: (content) => /\btry\s*\{/.test(content) && /\bcatch\s*\(/.test(content)
+	},
+	{
+		style: "result-type",
+		pattern: "Result/Either functional error handling",
+		test: (content) => /\bResult<|\bOk\(|\bErr\(|\bisOk\b|\bisErr\b|\bneverthrow\b/.test(content)
+	},
+	{
+		style: "custom-error-class",
+		pattern: "custom error class hierarchy",
+		test: (content) => /class\s+\w+Error\b|\bnew\s+\w+Error\(/.test(content)
+	},
+	{
+		style: "error-boundary",
+		pattern: "React error boundary components",
+		test: (content) => /\bErrorBoundary\b|\bcomponentDidCatch\b/.test(content)
+	}
+];
+const errorHandlingExtractor = {
+	name: "error-handling",
+	async extract(ctx) {
+		const bridge = await createBridge(ctx.projectPath);
+		if (!await bridge.hasIndex(ctx.projectPath)) return [];
+		const [general, resultType, customErrors] = await Promise.all([
+			bridge.search("error handling try catch throw exception", { k: 30 }),
+			bridge.search("Result Ok Err return error value", { k: 20 }),
+			bridge.search("custom error class extends Error", { k: 20 })
+		]);
+		const fileContentMap = /* @__PURE__ */ new Map();
+		for (const result of [
+			...general,
+			...resultType,
+			...customErrors
+		]) {
+			const existing = fileContentMap.get(result.file) ?? "";
+			fileContentMap.set(result.file, existing + "\n" + result.chunk);
+		}
+		const totalUniqueFiles = fileContentMap.size;
+		if (totalUniqueFiles === 0) return [];
+		const entries = [];
+		for (const patternDef of PATTERNS) {
+			const matchingFiles = [];
+			for (const [file, content] of fileContentMap) if (patternDef.test(content)) matchingFiles.push(file);
+			if (matchingFiles.length < 2) continue;
+			const confidence = Math.min(.95, .5 + matchingFiles.length / totalUniqueFiles * .45);
+			entries.push({
+				category: "error_handling",
+				pattern: patternDef.pattern,
+				confidence,
+				evidence: matchingFiles.slice(0, 5).map((file) => ({
+					file,
+					line: null
+				})),
+				metadata: {
+					style: patternDef.style,
+					fileCount: matchingFiles.length
+				}
+			});
+		}
+		return entries;
+	}
+};
+
+//#endregion
+//#region src/extractors/semantic/architecture.ts
+/** Get directory paths under src/ (or project root if no src/). */
+function extractSourceDirs(files) {
+	const dirs = /* @__PURE__ */ new Set();
+	for (const f of files) {
+		const parts = f.split("/");
+		if (parts.length < 2) continue;
+		if (parts[0] === "src" && parts.length >= 3) dirs.add(`src/${parts[1]}`);
+		else if (parts[0] !== "src") dirs.add(parts[0]);
+	}
+	return dirs;
+}
+/** Normalise a directory name to lower case for matching. */
+function normalise(dir) {
+	return dir.split("/").pop().toLowerCase();
+}
+/** Detect MVC: >= 2 of models/, views/, controllers/, routes/ */
+function detectMVC(sourceDirs) {
+	const mvc = [
+		"model",
+		"models",
+		"view",
+		"views",
+		"controller",
+		"controllers",
+		"route",
+		"routes"
+	];
+	const found = [];
+	for (const dir of sourceDirs) if (mvc.includes(normalise(dir))) found.push(dir);
+	return new Set(found.map((d) => normalise(d).replace(/s$/, ""))).size >= 2 ? found : [];
+}
+/** Detect feature-based: files under features/, modules/, pages/ with >= 5 files total. */
+function detectFeatureBased(files) {
+	const featurePattern = /\/(features?|modules?|pages?)\//i;
+	const featureDirs = /* @__PURE__ */ new Set();
+	let count = 0;
+	for (const f of files) if (featurePattern.test(f)) {
+		count++;
+		const match = f.match(/^(.*?\/(features?|modules?|pages?))\//i);
+		if (match) featureDirs.add(match[1]);
+	}
+	return count >= 5 ? Array.from(featureDirs) : [];
+}
+/** Detect layer-based architecture (DDD / hexagonal / clean arch). */
+function detectLayerBased(sourceDirs) {
+	const layerPatterns = [
+		"domain",
+		"application",
+		"infrastructure",
+		"service",
+		"services",
+		"repository",
+		"repositories",
+		"handler",
+		"handlers",
+		"usecase",
+		"usecases",
+		"core",
+		"data",
+		"presentation"
+	];
+	const found = [];
+	for (const dir of sourceDirs) if (layerPatterns.includes(normalise(dir))) found.push(dir);
+	return new Set(found.map((d) => normalise(d))).size >= 2 ? found : [];
+}
+const architectureExtractor = {
+	name: "architecture",
+	async extract(ctx) {
+		const files = await listProjectFiles({
+			cwd: ctx.projectPath,
+			extensions: [
+				"ts",
+				"js",
+				"tsx",
+				"jsx",
+				"py",
+				"rb",
+				"go",
+				"rs"
+			]
+		});
+		const sourceDirs = extractSourceDirs(files);
+		const mvcDirs = detectMVC(sourceDirs);
+		const featureDirs = detectFeatureBased(files);
+		const layerDirs = detectLayerBased(sourceDirs);
+		let detectedPattern = null;
+		let detectedLayers = [];
+		if (mvcDirs.length > 0) {
+			detectedPattern = "MVC";
+			detectedLayers = mvcDirs;
+		} else if (featureDirs.length > 0) {
+			detectedPattern = "feature-based";
+			detectedLayers = featureDirs;
+		} else if (layerDirs.length > 0) {
+			detectedPattern = "layer-based";
+			detectedLayers = layerDirs;
+		}
+		if (!detectedPattern) return [];
+		const bridge = await createBridge(ctx.projectPath);
+		const hasIdx = await bridge.hasIndex(ctx.projectPath);
+		let confidence = .7;
+		const evidence = detectedLayers.slice(0, 3).map((dir) => ({
+			file: dir,
+			line: null
+		}));
+		if (hasIdx) {
+			const searchResults = await bridge.search("model view controller route handler service repository", { k: 20 });
+			if (searchResults.length > 0) {
+				confidence = .85;
+				for (const r of searchResults.slice(0, 2)) evidence.push({
+					file: r.file,
+					line: null
+				});
+			}
+		}
+		const seen = /* @__PURE__ */ new Set();
+		const deduped = evidence.filter(({ file }) => {
+			if (seen.has(file)) return false;
+			seen.add(file);
+			return true;
+		});
+		return [{
+			category: "architecture",
+			pattern: patternLabel(detectedPattern),
+			confidence,
+			evidence: deduped.slice(0, 5),
+			metadata: {
+				architecturePattern: detectedPattern,
+				layers: detectedLayers
+			}
+		}];
+	}
+};
+function patternLabel(p) {
+	switch (p) {
+		case "MVC": return "MVC architecture pattern";
+		case "feature-based": return "Feature-based architecture";
+		case "layer-based": return "Layer-based architecture";
+	}
+}
+
+//#endregion
+//#region src/core/pipeline.ts
+const ALL_EXTRACTORS = [
+	packageJsonExtractor,
+	lockfileExtractor,
+	tsconfigExtractor,
+	goModExtractor,
+	cargoTomlExtractor,
+	ciExtractor,
+	projectStructureExtractor,
+	namingExtractor,
+	importsExtractor,
+	staticErrorHandlingExtractor,
+	errorHandlingExtractor,
+	architectureExtractor
+];
+/**
+* Deduplicate evidence by file+line combination.
+*/
+function deduplicateEvidence(evidence) {
+	const seen = /* @__PURE__ */ new Set();
+	return evidence.filter((e) => {
+		const key = `${e.file}:${e.line ?? "null"}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+/**
+* Deduplicate conventions by category+pattern.
+* For duplicates, keep the one with higher confidence.
+* Merge evidence arrays from duplicates.
+*/
+function deduplicateConventions(conventions) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const entry of conventions) {
+		const key = `${entry.category}:${entry.pattern}`;
+		const existing = grouped.get(key);
+		if (!existing) grouped.set(key, entry);
+		else {
+			const winner = entry.confidence > existing.confidence ? entry : existing;
+			const mergedEvidence = deduplicateEvidence([...existing.evidence, ...entry.evidence]);
+			grouped.set(key, {
+				...winner,
+				evidence: mergedEvidence
+			});
+		}
+	}
+	return Array.from(grouped.values());
+}
+/**
+* Populate StackInfo from extracted conventions via a post-extraction pass.
+* Conventions are processed in array order; first match wins for each field.
+*/
+function populateStackInfo(registry) {
+	const stack = { ...registry.stack };
+	for (const entry of registry.conventions) {
+		const meta = entry.metadata ?? {};
+		if (entry.category === "stack") {
+			if (!stack.language || stack.language === "unknown") {
+				if (typeof meta.language === "string") stack.language = meta.language;
+			}
+			if (!stack.framework && typeof meta.framework === "string") stack.framework = meta.framework;
+			if (!stack.testRunner && typeof meta.testRunner === "string") stack.testRunner = meta.testRunner;
+			if (!stack.packageManager && typeof meta.packageManager === "string") stack.packageManager = meta.packageManager;
+			if (!stack.buildTool) {
+				if (typeof meta.buildTool === "string") stack.buildTool = meta.buildTool;
+				else if (typeof meta.scriptName === "string" && meta.scriptName === "build" && typeof meta.command === "string") stack.buildTool = meta.command.split(" ")[0];
+			}
+		}
+		if (entry.category === "testing") {
+			if (!stack.testRunner && typeof meta.testRunner === "string") stack.testRunner = meta.testRunner;
+		}
+	}
+	return {
+		...registry,
+		stack
+	};
+}
+/**
+* Populate ArchitectureInfo from extracted conventions via a post-extraction pass.
+* First architecture convention with the relevant metadata wins.
+*/
+function populateArchitectureInfo(registry) {
+	const arch = { ...registry.architecture };
+	for (const entry of registry.conventions) if (entry.category === "architecture") {
+		if (!arch.pattern && typeof entry.metadata?.architecturePattern === "string") arch.pattern = entry.metadata.architecturePattern;
+		if (arch.layers.length === 0 && Array.isArray(entry.metadata?.layers)) arch.layers = entry.metadata.layers;
+	}
+	return {
+		...registry,
+		architecture: arch
+	};
+}
+/**
+* Run the full extraction pipeline against the given project path.
+*
+* 1. Runs all extractors in parallel (Promise.allSettled)
+* 2. Deduplicates conventions by category+pattern (higher confidence wins)
+* 3. Populates StackInfo from convention metadata
+* 4. Populates ArchitectureInfo from convention metadata
+* 5. Validates and returns the final ConventionRegistry
+*/
+async function extractConventions(projectPath, options) {
+	const populated = await runExtractors(ALL_EXTRACTORS, {
+		projectPath,
+		options
+	}, createRegistry(projectPath));
+	const withArch = populateArchitectureInfo(populateStackInfo({
+		...populated,
+		conventions: deduplicateConventions(populated.conventions)
+	}));
+	return ConventionRegistrySchema.parse(withArch);
+}
+
+//#endregion
+//#region src/emitters/writer.ts
+const MARKER_START = "<!-- ez-context:start -->";
+const MARKER_END = "<!-- ez-context:end -->";
+/**
+* Write content into the marker section of filePath.
+*
+* Three paths:
+* 1. File does not exist: creates it with markers wrapping content.
+* 2. File exists, no markers (or only one marker): appends the section at the end.
+* 3. File exists with both markers: splices new content between existing markers,
+*    preserving everything outside.
+*/
+async function writeWithMarkers(filePath, content) {
+	const wrapped = `${MARKER_START}\n${content}\n${MARKER_END}`;
+	if (!existsSync(filePath)) {
+		await writeFile(filePath, wrapped + "\n", "utf-8");
+		return;
+	}
+	const existing = await readFile(filePath, "utf-8");
+	const startIdx = existing.indexOf(MARKER_START);
+	const endIdx = existing.indexOf(MARKER_END);
+	if (startIdx === -1 || endIdx === -1) {
+		await writeFile(filePath, existing + (existing.endsWith("\n") ? "\n" : "\n\n") + wrapped + "\n", "utf-8");
+		return;
+	}
+	const before = existing.slice(0, startIdx);
+	const after = existing.slice(endIdx + 23);
+	await writeFile(filePath, before + wrapped + after, "utf-8");
+}
+
+//#endregion
+//#region src/emitters/render-helpers.ts
+/**
+* Extract script commands from a filtered list of convention entries.
+* Shared by agents-md and renderConventionsBody.
+*/
+function extractCommands(filtered) {
+	const commands = [];
+	for (const entry of filtered) {
+		const meta = entry.metadata;
+		if (meta && typeof meta["command"] === "string" && typeof meta["scriptName"] === "string") commands.push({
+			scriptName: meta["scriptName"],
+			command: meta["command"]
+		});
+	}
+	return commands;
+}
+/**
+* Check if a stack-category convention should appear in the Conventions section.
+* Stack entries that map to StackInfo fields (language, framework, etc.) are already
+* shown in the Stack section. Others (e.g. "TypeScript strict mode") are convention-worthy.
+*/
+function isStackConventionWorthy(entry, stack) {
+	if (entry.category !== "stack") return false;
+	const meta = entry.metadata ?? {};
+	if (typeof meta["language"] === "string" && stack.language !== "unknown") return false;
+	if (typeof meta["framework"] === "string" && stack.framework) return false;
+	if (typeof meta["buildTool"] === "string" && stack.buildTool) return false;
+	if (typeof meta["packageManager"] === "string" && stack.packageManager) return false;
+	if (typeof meta["scriptName"] === "string") return false;
+	return true;
+}
+/**
+* Check if a convention entry is redundant with the Stack or Commands sections.
+* - "Test runner: X" in testing category duplicates Stack > Test Runner
+* - Entries with metadata.scriptName duplicate the Commands section
+*/
+function isRedundantConvention(entry) {
+	if (entry.category === "testing" && entry.pattern.startsWith("Test runner:")) return true;
+	if (entry.metadata && typeof entry.metadata["scriptName"] === "string") return true;
+	return false;
+}
+/**
+* Render conventions body as markdown lines.
+* Used by cursor-mdc, skill-md, rulesync-md, ruler-md, copilot-md.
+*/
+function renderConventionsBody(registry, confidenceThreshold) {
+	const filtered = registry.conventions.filter((c) => c.confidence >= confidenceThreshold);
+	const lines = [];
+	const s = registry.stack;
+	if (s.language !== "unknown" || Boolean(s.framework) || Boolean(s.buildTool) || Boolean(s.packageManager) || Boolean(s.testRunner)) {
+		lines.push("## Stack");
+		if (s.language !== "unknown") lines.push(`- Language: ${s.language}`);
+		if (s.framework) lines.push(`- Framework: ${s.framework}`);
+		if (s.buildTool) lines.push(`- Build: ${s.buildTool}`);
+		if (s.packageManager) lines.push(`- Package Manager: ${s.packageManager}`);
+		if (s.testRunner) lines.push(`- Test Runner: ${s.testRunner}`);
+		lines.push("");
+	}
+	const a = registry.architecture;
+	if (Boolean(a.pattern) || (a.layers?.length ?? 0) > 0) {
+		lines.push("## Architecture");
+		if (a.pattern) lines.push(`- Pattern: ${a.pattern}`);
+		if (a.layers && a.layers.length > 0) lines.push(`- Layers: ${a.layers.join(", ")}`);
+		lines.push("");
+	}
+	const categoryMap = /* @__PURE__ */ new Map();
+	for (const entry of filtered) {
+		if (entry.category === "architecture") continue;
+		if (entry.category === "stack" && !isStackConventionWorthy(entry, s)) continue;
+		if (isRedundantConvention(entry)) continue;
+		const list = categoryMap.get(entry.category) ?? [];
+		list.push(entry.pattern);
+		categoryMap.set(entry.category, list);
+	}
+	if (categoryMap.size > 0) {
+		lines.push("## Conventions");
+		for (const [category, patterns] of categoryMap) for (const pattern of patterns) lines.push(`- **${category}**: ${pattern}`);
+		lines.push("");
+	}
+	const commands = extractCommands(filtered);
+	if (commands.length > 0) {
+		lines.push("## Commands");
+		for (const cmd of commands) lines.push(`- \`${cmd.scriptName}\`: \`${cmd.command}\``);
+		lines.push("");
+	}
+	return lines;
+}
+
+//#endregion
+//#region src/emitters/claude-md.ts
+function prepData$1(registry, confidenceThreshold) {
+	const filtered = registry.conventions.filter((c) => c.confidence >= confidenceThreshold);
+	const categoryMap = /* @__PURE__ */ new Map();
+	for (const entry of filtered) {
+		if (entry.category === "architecture") continue;
+		if (entry.category === "stack") {
+			const meta = entry.metadata ?? {};
+			if (typeof meta["language"] === "string") continue;
+			if (typeof meta["framework"] === "string") continue;
+			if (typeof meta["buildTool"] === "string") continue;
+			if (typeof meta["packageManager"] === "string") continue;
+			if (typeof meta["scriptName"] === "string") continue;
+		}
+		if (isRedundantConvention(entry)) continue;
+		const list = categoryMap.get(entry.category) ?? [];
+		list.push(entry);
+		categoryMap.set(entry.category, list);
+	}
+	const conventionGroups = [];
+	for (const [category, entries] of categoryMap) conventionGroups.push({
+		category,
+		entries
+	});
+	const hasStack = registry.stack.language !== "unknown" || Boolean(registry.stack.framework) || Boolean(registry.stack.buildTool) || Boolean(registry.stack.packageManager) || Boolean(registry.stack.testRunner);
+	const hasArchitecture = Boolean(registry.architecture.pattern) || (registry.architecture.layers?.length ?? 0) > 0;
+	return {
+		stack: registry.stack,
+		architecture: registry.architecture,
+		conventionGroups,
+		hasStack,
+		hasArchitecture
+	};
+}
+function renderClaudeMd(registry, confidenceThreshold) {
+	const data = prepData$1(registry, confidenceThreshold);
+	const lines = [];
+	lines.push("# Project Context");
+	if (data.hasStack) {
+		lines.push("");
+		lines.push("## Stack");
+		if (data.stack.language !== "unknown") lines.push(`- Language: ${data.stack.language}`);
+		if (data.stack.framework) lines.push(`- Framework: ${data.stack.framework}`);
+		if (data.stack.buildTool) lines.push(`- Build: ${data.stack.buildTool}`);
+		if (data.stack.packageManager) lines.push(`- Package Manager: ${data.stack.packageManager}`);
+		if (data.stack.testRunner) lines.push(`- Test Runner: ${data.stack.testRunner}`);
+	}
+	if (data.conventionGroups.length > 0) {
+		lines.push("");
+		lines.push("## Conventions");
+		for (const group of data.conventionGroups) for (const entry of group.entries) lines.push(`- **${group.category}**: ${entry.pattern}`);
+	}
+	if (data.hasArchitecture) {
+		lines.push("");
+		lines.push("## Architecture");
+		if (data.architecture.pattern) lines.push(`- Pattern: ${data.architecture.pattern}`);
+		if (data.architecture.layers && data.architecture.layers.length > 0) lines.push(`- Layers: ${data.architecture.layers.join(", ")}`);
+	}
+	return lines.join("\n") + "\n";
+}
+
+//#endregion
+//#region src/emitters/agents-md.ts
+function prepData(registry, confidenceThreshold) {
+	const filtered = registry.conventions.filter((c) => c.confidence >= confidenceThreshold);
+	const commands = extractCommands(filtered);
+	const byCategory = (cat) => filtered.filter((c) => c.category === cat);
+	const testingConventions = byCategory("testing");
+	const namingConventions = byCategory("naming");
+	const importConventions = byCategory("imports");
+	const gitConventions = filtered.filter((c) => c.pattern.toLowerCase().includes("git") || c.category === "other" && c.pattern.toLowerCase().includes("commit"));
+	const hasTesting = Boolean(registry.stack.testRunner) || testingConventions.length > 0;
+	const hasProjectStructure = Boolean(registry.architecture.pattern) || (registry.architecture.layers?.length ?? 0) > 0;
+	const hasCodeStyle = namingConventions.length > 0 || importConventions.length > 0;
+	return {
+		commands,
+		testRunner: registry.stack.testRunner ?? null,
+		testingConventions,
+		namingConventions,
+		importConventions,
+		gitConventions,
+		architecture: registry.architecture,
+		hasTesting,
+		hasProjectStructure,
+		hasCodeStyle
+	};
+}
+function renderAgentsMd(registry, confidenceThreshold) {
+	const data = prepData(registry, confidenceThreshold);
+	const lines = [];
+	lines.push("# AGENTS.md");
+	if (data.commands.length > 0) {
+		lines.push("");
+		lines.push("## Commands");
+		for (const cmd of data.commands) lines.push(`- \`${cmd.scriptName}\`: \`${cmd.command}\``);
+	}
+	if (data.hasTesting) {
+		lines.push("");
+		lines.push("## Testing");
+		if (data.testRunner) lines.push(`- Test runner: ${data.testRunner}`);
+		for (const entry of data.testingConventions) lines.push(`- ${entry.pattern}`);
+	}
+	if (data.hasProjectStructure) {
+		lines.push("");
+		lines.push("## Project Structure");
+		if (data.architecture.pattern) lines.push(`- Architecture: ${data.architecture.pattern}`);
+		if (data.architecture.layers && data.architecture.layers.length > 0) lines.push(`- Layers: ${data.architecture.layers.join(", ")}`);
+	}
+	if (data.hasCodeStyle) {
+		lines.push("");
+		lines.push("## Code Style");
+		for (const entry of data.namingConventions) lines.push(`- **naming**: ${entry.pattern}`);
+		for (const entry of data.importConventions) lines.push(`- **imports**: ${entry.pattern}`);
+	}
+	if (data.gitConventions.length > 0) {
+		lines.push("");
+		lines.push("## Git Workflow");
+		for (const entry of data.gitConventions) lines.push(`- ${entry.pattern}`);
+	}
+	lines.push("");
+	lines.push("## Boundaries");
+	lines.push("- Do not modify auto-generated sections between ez-context markers");
+	return lines.join("\n") + "\n";
+}
+
+//#endregion
+//#region src/emitters/cursor-mdc.ts
+/**
+* Render a Cursor MDC rule file (.cursor/rules/ez-context.mdc).
+*
+* Format: YAML frontmatter + markdown body.
+* - description: shown in Cursor UI
+* - globs: empty string (not null/omitted) per Cursor docs
+* - alwaysApply: true ensures conventions are always in context
+*/
+function renderCursorMdc(registry, confidenceThreshold) {
+	const frontmatter = yaml.dump({
+		description: "Project conventions extracted by ez-context",
+		globs: "",
+		alwaysApply: true
+	}).trimEnd();
+	const bodyLines = renderConventionsBody(registry, confidenceThreshold);
+	while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1] === "") bodyLines.pop();
+	return `---\n${frontmatter}\n---\n\n${bodyLines.join("\n")}\n`;
+}
+
+//#endregion
+//#region src/emitters/copilot-md.ts
+/**
+* Render a GitHub Copilot instructions file (.github/copilot-instructions.md).
+*
+* Format: Plain markdown, no YAML frontmatter.
+* GitHub Copilot reads the entire file; HTML comment markers are used
+* for idempotent updates via writeWithMarkers.
+*/
+function renderCopilotMd(registry, confidenceThreshold) {
+	const lines = [];
+	lines.push("<!-- Generated by ez-context. Do not edit between markers. -->");
+	lines.push("");
+	lines.push("# Copilot Instructions");
+	lines.push("");
+	const bodyLines = renderConventionsBody(registry, confidenceThreshold);
+	while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1] === "") bodyLines.pop();
+	lines.push(...bodyLines);
+	return lines.join("\n") + "\n";
+}
+
+//#endregion
+//#region src/emitters/skill-md.ts
+/**
+* Render a SKILL.md module file (.skills/ez-context/SKILL.md).
+*
+* Format: YAML frontmatter + markdown body.
+* - name: must match directory name (ez-context)
+* - description: max 1024 chars, describes what AND when to use
+* Body stays under 5000 tokens (~3750 words) as per SKILL.md spec.
+*/
+function renderSkillMd(registry, confidenceThreshold) {
+	const frontmatter = yaml.dump({
+		name: "ez-context",
+		description: "Project conventions and coding standards for this codebase. Use when writing new code, reviewing patterns, or understanding project architecture."
+	}).trimEnd();
+	const bodyLines = renderConventionsBody(registry, confidenceThreshold);
+	while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1] === "") bodyLines.pop();
+	return `---\n${frontmatter}\n---\n\n${bodyLines.join("\n")}\n`;
+}
+
+//#endregion
+//#region src/emitters/rulesync-md.ts
+/**
+* Render a Rulesync rule file (.rulesync/rules/ez-context.md).
+*
+* Format: YAML frontmatter + markdown body.
+* - targets: specifies which AI tools receive this rule
+* ez-context writes INTO .rulesync/rules/; Rulesync distributes to tools.
+*/
+function renderRulesyncMd(registry, confidenceThreshold) {
+	const frontmatter = yaml.dump({
+		description: "Project conventions extracted by ez-context",
+		targets: [
+			"cursor",
+			"copilot",
+			"windsurf"
+		]
+	}).trimEnd();
+	const bodyLines = renderConventionsBody(registry, confidenceThreshold);
+	while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1] === "") bodyLines.pop();
+	return `---\n${frontmatter}\n---\n\n${bodyLines.join("\n")}\n`;
+}
+
+//#endregion
+//#region src/emitters/ruler-md.ts
+/**
+* Render a Ruler rule file (.ruler/ez-context.md).
+*
+* Format: Plain markdown, no YAML frontmatter.
+* Ruler recursively discovers all .md files in .ruler/ and distributes them.
+* ez-context writes a single .ruler/ez-context.md as an additive conventions file.
+*/
+function renderRulerMd(registry, confidenceThreshold) {
+	const lines = [];
+	lines.push("# Project Conventions (ez-context)");
+	lines.push("");
+	const bodyLines = renderConventionsBody(registry, confidenceThreshold);
+	while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1] === "") bodyLines.pop();
+	lines.push(...bodyLines);
+	return lines.join("\n") + "\n";
+}
+
+//#endregion
+//#region src/emitters/index.ts
+const FORMAT_EMITTER_MAP = {
+	claude: {
+		render: renderClaudeMd,
+		filename: "CLAUDE.md",
+		strategy: "markers"
+	},
+	agents: {
+		render: renderAgentsMd,
+		filename: "AGENTS.md",
+		strategy: "markers"
+	},
+	cursor: {
+		render: renderCursorMdc,
+		filename: path.join(".cursor", "rules", "ez-context.mdc"),
+		strategy: "direct"
+	},
+	copilot: {
+		render: renderCopilotMd,
+		filename: path.join(".github", "copilot-instructions.md"),
+		strategy: "markers"
+	},
+	skills: {
+		render: renderSkillMd,
+		filename: path.join(".skills", "ez-context", "SKILL.md"),
+		strategy: "direct"
+	},
+	rulesync: {
+		render: renderRulesyncMd,
+		filename: path.join(".rulesync", "rules", "ez-context.md"),
+		strategy: "markers"
+	},
+	ruler: {
+		render: renderRulerMd,
+		filename: path.join(".ruler", "ez-context.md"),
+		strategy: "direct"
+	}
+};
+/**
+* Emit output files for the given ConventionRegistry.
+*
+* Defaults to ["claude", "agents"] for backward compatibility.
+* In dryRun mode, returns rendered content without writing any files.
+*/
+async function emit(registry, options) {
+	const threshold = options.confidenceThreshold ?? .7;
+	const formats = options.formats ?? ["claude", "agents"];
+	const rendered = {};
+	for (const format of formats) rendered[format] = FORMAT_EMITTER_MAP[format].render(registry, threshold);
+	const claudeMd = rendered["claude"] ?? "";
+	const agentsMd = rendered["agents"] ?? "";
+	if (options.dryRun) return {
+		rendered,
+		claudeMd,
+		agentsMd,
+		filesWritten: []
+	};
+	const filesWritten = [];
+	for (const format of formats) {
+		const entry = FORMAT_EMITTER_MAP[format];
+		const filePath = path.join(options.outputDir, entry.filename);
+		await mkdir(path.dirname(filePath), { recursive: true });
+		if (entry.strategy === "direct") await writeFile(filePath, rendered[format], "utf-8");
+		else await writeWithMarkers(filePath, rendered[format]);
+		filesWritten.push(filePath);
+	}
+	return {
+		rendered,
+		claudeMd,
+		agentsMd,
+		filesWritten
+	};
+}
+
+//#endregion
+export { EvidenceRefSchema as _, writeWithMarkers as a, ALWAYS_SKIP as c, addConvention as d, createRegistry as f, ConventionRegistrySchema as g, ConventionEntrySchema as h, MARKER_START as i, listProjectFiles as l, ConventionCategorySchema as m, emit as n, extractConventions as o, ArchitectureInfoSchema as p, MARKER_END as r, createBridge as s, FORMAT_EMITTER_MAP as t, runExtractors as u, StackInfoSchema as v };
+//# sourceMappingURL=emitters-D6bP4xWs.js.map