@contentrain/mcp 0.3.0 → 1.0.0

package/dist/apply-manager-CaTuu7Lj.mjs

@@ -0,0 +1,751 @@
+import { c as writeText, o as readText, r as pathExists } from "./fs-BbuGnVcG.mjs";
+import { t as readConfig } from "./config-CPlhDwsv.mjs";
+import { S as writeContent, _ as resolveMdFilePath, c as validateModelDefinition, h as resolveJsonFilePath, l as writeModel, m as resolveContentDir, o as listModels, s as readModel } from "./model-manager-BcWWu5l2.mjs";
+import { n as writeContext } from "./context-yh3cuw5N.mjs";
+import { t as checkBranchHealth } from "./branch-lifecycle-DB6sgeJi.mjs";
+import { n as createTransaction, t as buildBranchName } from "./transaction-BsECnmL5.mjs";
+import { extname, join } from "node:path";
+//#region src/core/apply-manager.ts
+const MAX_PATCHES = 100;
+/** File extensions allowed for patching — scannable source files only */
+const PATCHABLE_EXTENSIONS = new Set([
+	".vue",
+	".tsx",
+	".jsx",
+	".ts",
+	".js",
+	".mjs",
+	".astro",
+	".svelte"
+]);
+/** Directories that must never be patched */
+const FORBIDDEN_PATH_SEGMENTS = new Set([
+	".contentrain",
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".next",
+	".nuxt"
+]);
+function detectFileFramework(filePath) {
+	switch (extname(filePath).toLowerCase()) {
+		case ".vue": return "vue";
+		case ".svelte": return "svelte";
+		case ".tsx":
+		case ".jsx": return "jsx";
+		case ".astro": return "astro";
+		case ".ts":
+		case ".js":
+		case ".mjs": return "script";
+		default: return "script";
+	}
+}
+/**
+* Validate that a replacement expression uses the correct template syntax
+* for the target file's framework. Returns a warning string or null.
+*/
+function validateFrameworkExpression(filePath, newExpression, context) {
+	if (context !== "tag_text") return null;
+	switch (detectFileFramework(filePath)) {
+		case "vue":
+			if (!newExpression.includes("{{")) return `Vue file "${filePath}": tag text expression "${newExpression}" does not contain "{{" — expected Vue template syntax like {{ $t('key') }}`;
+			break;
+		case "jsx":
+			if (!newExpression.includes("{")) return `JSX file "${filePath}": tag text expression "${newExpression}" does not contain "{" — expected JSX syntax like {t('key')}`;
+			break;
+		case "svelte":
+			if (!newExpression.includes("{")) return `Svelte file "${filePath}": tag text expression "${newExpression}" does not contain "{" — expected Svelte syntax like {$t('key')}`;
+			break;
+		case "astro":
+			if (!newExpression.includes("{")) return `Astro file "${filePath}": tag text expression "${newExpression}" does not contain "{" — expected Astro syntax like {t('key')}`;
+			break;
+		case "script": return `Script file "${filePath}": tag text replacement not applicable for .ts/.js files`;
+	}
+	return null;
+}
+/**
+* Validate that a patch file path is safe and within allowed scope.
+* Returns an error message or null if valid.
+*/
+function validatePatchPath(filePath) {
+	const normalizedPath = filePath.replace(/\\/g, "/");
+	if (normalizedPath.includes("..")) return `Path traversal detected: "${filePath}"`;
+	if (normalizedPath.startsWith("/")) return `Absolute path not allowed: "${filePath}"`;
+	const segments = normalizedPath.split("/");
+	for (const seg of segments) if (FORBIDDEN_PATH_SEGMENTS.has(seg)) return `Patching files inside "${seg}/" is not allowed: "${filePath}"`;
+	const ext = extname(filePath).toLowerCase();
+	if (!PATCHABLE_EXTENSIONS.has(ext)) return `File extension "${ext}" is not patchable. Allowed: ${[...PATCHABLE_EXTENSIONS].join(", ")}. Path: "${filePath}"`;
+	return null;
+}
+/**
+* Perform a basic syntax check on a patched file.
+* Returns an error message or null if syntax appears valid.
+*/
+function checkSyntax(filePath, content) {
+	switch (extname(filePath).toLowerCase()) {
+		case ".ts":
+		case ".tsx":
+		case ".js":
+		case ".jsx":
+		case ".mjs": return checkJsSyntax(content);
+		case ".vue": return checkVueSyntax(content);
+		case ".svelte":
+		case ".astro": return checkTagBalance(content);
+		default: return null;
+	}
+}
+/**
+* Basic JS/TS syntax check: bracket/paren/brace balance + string literal closure.
+* This is intentionally conservative — it catches obvious breakage without
+* requiring a full parser.
+*/
+function checkJsSyntax(content) {
+	const stack = [];
+	const pairs = {
+		")": "(",
+		"]": "[",
+		"}": "{"
+	};
+	let inString = null;
+	let escaped = false;
+	let inLineComment = false;
+	let inBlockComment = false;
+	for (let i = 0; i < content.length; i++) {
+		const ch = content[i];
+		const next = content[i + 1];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (ch === "\\" && inString !== null) {
+			escaped = true;
+			continue;
+		}
+		if (!inString && !inBlockComment && ch === "/" && next === "/") {
+			inLineComment = true;
+			continue;
+		}
+		if (inLineComment) {
+			if (ch === "\n") inLineComment = false;
+			continue;
+		}
+		if (!inString && !inBlockComment && ch === "/" && next === "*") {
+			inBlockComment = true;
+			i++;
+			continue;
+		}
+		if (inBlockComment) {
+			if (ch === "*" && next === "/") {
+				inBlockComment = false;
+				i++;
+			}
+			continue;
+		}
+		if (inString !== null) {
+			if (ch === inString) inString = null;
+			else if (inString !== "`" && ch === "\n") return `Unterminated string literal near offset ${i}`;
+			continue;
+		}
+		if (ch === "\"" || ch === "'" || ch === "`") {
+			inString = ch;
+			continue;
+		}
+		if (ch === "(" || ch === "[" || ch === "{") stack.push(ch);
+		else if (ch === ")" || ch === "]" || ch === "}") {
+			const expected = pairs[ch];
+			if (stack.length === 0) return `Unmatched closing "${ch}" near offset ${i}`;
+			const top = stack.pop();
+			if (top !== expected) return `Mismatched bracket: expected closing for "${top}" but found "${ch}" near offset ${i}`;
+		}
+	}
+	if (inString !== null) return `Unterminated string literal (opened with ${inString})`;
+	if (stack.length > 0) return `Unclosed bracket "${stack[stack.length - 1]}" — ${stack.length} unclosed bracket(s)`;
+	return null;
+}
+/**
+* Vue SFC syntax check: ensure <template>, <script>, <style> tags are balanced.
+*/
+function checkVueSyntax(content) {
+	const tagBalance = checkTagBalance(content);
+	if (tagBalance) return tagBalance;
+	for (const tag of ["template", "script"]) {
+		const openRe = new RegExp(`<${tag}[\\s>]`, "g");
+		const closeRe = new RegExp(`</${tag}>`, "g");
+		const opens = content.match(openRe)?.length ?? 0;
+		const closes = content.match(closeRe)?.length ?? 0;
+		if (opens !== closes) return `Unbalanced <${tag}> tag: ${opens} opening vs ${closes} closing`;
+	}
+	return null;
+}
+/**
+* Basic tag balance check for HTML-like files.
+* Checks that self-closing tags are handled and major structural tags are balanced.
+*/
+function checkTagBalance(content) {
+	for (const tag of [
+		"div",
+		"section",
+		"main",
+		"header",
+		"footer",
+		"nav",
+		"article",
+		"aside",
+		"ul",
+		"ol",
+		"table"
+	]) {
+		const openRe = new RegExp(`<${tag}[\\s>]`, "g");
+		const closeRe = new RegExp(`</${tag}>`, "g");
+		const opens = content.match(openRe)?.length ?? 0;
+		const closes = content.match(closeRe)?.length ?? 0;
+		if (opens !== closes) return `Unbalanced <${tag}> tag: ${opens} opening vs ${closes} closing`;
+	}
+	return null;
+}
+async function applyExtract(projectRoot, input) {
+	const config = await readConfig(projectRoot);
+	if (!config) throw new Error("Project not initialized. Run contentrain_init first.");
+	const { extractions, dry_run } = input;
+	const existingModels = await listModels(projectRoot);
+	const existingIds = new Set(existingModels.map((m) => m.id));
+	const modelsToCreate = [];
+	const modelsToUpdate = [];
+	const contentFiles = [];
+	let totalEntries = 0;
+	const validationErrors = [];
+	for (const ext of extractions) {
+		const modelErrors = validateModelDefinition({
+			id: ext.model,
+			kind: ext.kind,
+			fields: ext.fields
+		});
+		if (modelErrors.length > 0) validationErrors.push(...modelErrors.map((e) => `[${ext.model}] ${e}`));
+		for (const entry of ext.entries) if (ext.kind === "dictionary") {
+			if (entry.data["id"] !== void 0 || entry.data["slug"] !== void 0) validationErrors.push(`[${ext.model}] Dictionary entries should not have id or slug`);
+			for (const [key, val] of Object.entries(entry.data)) if (typeof val !== "string") validationErrors.push(`[${ext.model}] Dictionary entry value for key "${key}" must be a string, got ${typeof val}`);
+		} else if (ext.kind === "document") {
+			if (!entry.slug && !entry.data["slug"]) validationErrors.push(`[${ext.model}] Document entries must have a slug`);
+		} else if (ext.kind === "collection") {
+			if (entry.slug !== void 0 || entry.data["slug"] !== void 0) validationErrors.push(`[${ext.model}] Collection entries should not have slug`);
+		} else if (ext.kind === "singleton") {
+			if (entry.data["id"] !== void 0 || entry.slug !== void 0 || entry.data["slug"] !== void 0) validationErrors.push(`[${ext.model}] Singleton entries should not have id or slug`);
+		}
+		if (existingIds.has(ext.model)) modelsToUpdate.push(ext.model);
+		else modelsToCreate.push(ext.model);
+		totalEntries += ext.entries.length;
+		let previewModel;
+		if (existingIds.has(ext.model)) {
+			const real = await readModel(projectRoot, ext.model);
+			if (real) previewModel = real;
+			else previewModel = {
+				id: ext.model,
+				kind: ext.kind,
+				domain: ext.domain,
+				i18n: ext.i18n ?? true
+			};
+		} else previewModel = {
+			id: ext.model,
+			kind: ext.kind,
+			domain: ext.domain,
+			i18n: ext.i18n ?? true
+		};
+		const cDir = resolveContentDir(projectRoot, previewModel);
+		for (const entry of ext.entries) {
+			const locale = entry.locale ?? config.locales.default;
+			if (ext.kind === "document" && entry.slug) contentFiles.push(resolveMdFilePath(cDir, previewModel, locale, entry.slug));
+			else contentFiles.push(resolveJsonFilePath(cDir, previewModel, locale));
+		}
+	}
+	const preview = {
+		models_to_create: modelsToCreate,
+		models_to_update: modelsToUpdate,
+		total_entries: totalEntries,
+		content_files: [...new Set(contentFiles)]
+	};
+	if (dry_run !== false) return {
+		dry_run: true,
+		preview,
+		...validationErrors.length > 0 ? { validation_errors: validationErrors } : {},
+		next_steps: [
+			...validationErrors.length > 0 ? [`WARNING: ${validationErrors.length} validation error(s) found — fix before executing`] : [],
+			"Review the preview above",
+			"Call contentrain_apply with mode:extract and dry_run:false to execute"
+		]
+	};
+	if (validationErrors.length > 0) return {
+		dry_run: false,
+		error: "Model validation failed — cannot execute extract with invalid model definitions",
+		validation_errors: validationErrors,
+		next_steps: ["Fix the validation errors and retry"]
+	};
+	const health = await checkBranchHealth(projectRoot);
+	if (health.blocked) return {
+		error: health.message,
+		action: "blocked",
+		hint: "Merge or delete old contentrain/* branches before executing normalize."
+	};
+	const branchName = buildBranchName("normalize", "extract");
+	const tx = await createTransaction(projectRoot, branchName, { workflowOverride: "review" });
+	const sourceMap = [];
+	const modelsCreated = [];
+	const modelsUpdated = [];
+	let entriesWritten = 0;
+	try {
+		await tx.write(async (wt) => {
+			for (const ext of extractions) {
+				const existing = await readModel(wt, ext.model);
+				if (existing) {
+					if (ext.fields) {
+						const merged = {
+							...existing.fields,
+							...ext.fields
+						};
+						if (Object.keys(ext.fields).filter((k) => !(k in (existing.fields ?? {}))).length > 0) {
+							existing.fields = merged;
+							await writeModel(wt, existing);
+							modelsUpdated.push(ext.model);
+						}
+					}
+				} else {
+					await writeModel(wt, {
+						id: ext.model,
+						name: ext.model.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" "),
+						kind: ext.kind,
+						domain: ext.domain,
+						i18n: ext.i18n ?? true,
+						fields: ext.fields
+					});
+					modelsCreated.push(ext.model);
+				}
+				const model = await readModel(wt, ext.model);
+				const entries = ext.entries.map((e) => ({
+					locale: e.locale,
+					slug: e.slug,
+					data: e.data
+				}));
+				await writeContent(wt, model, entries, await readConfig(wt) ?? config);
+				entriesWritten += entries.length;
+				for (const entry of ext.entries) if (ext.kind === "dictionary" && entry.sources) for (const s of entry.sources) sourceMap.push({
+					model: ext.model,
+					locale: entry.locale ?? config.locales.default,
+					value: s.value,
+					file: s.file,
+					line: s.line
+				});
+				else if (entry.source) sourceMap.push({
+					model: ext.model,
+					locale: entry.locale ?? config.locales.default,
+					value: entry.source.value,
+					file: entry.source.file,
+					line: entry.source.line
+				});
+			}
+			if (sourceMap.length > 0) {
+				const sourcesByModel = {};
+				for (const s of sourceMap) {
+					if (!sourcesByModel[s.model]) sourcesByModel[s.model] = {
+						source_files: [],
+						entry_count: 0
+					};
+					const modelEntry = sourcesByModel[s.model];
+					if (!modelEntry.source_files.includes(s.file)) modelEntry.source_files.push(s.file);
+					modelEntry.entry_count++;
+				}
+				const sourcesJson = JSON.stringify({
+					version: 1,
+					created_at: (/* @__PURE__ */ new Date()).toISOString(),
+					models: sourcesByModel
+				}, null, 2) + "\n";
+				await writeText(join(wt, ".contentrain", "normalize-sources.json"), sourcesJson);
+			}
+			await writeContext(wt, {
+				tool: "contentrain_apply",
+				model: extractions.map((e) => e.model).join(","),
+				locale: config.locales.default,
+				entries: extractions.flatMap((e) => e.entries.map((en) => en.slug ?? "entry"))
+			});
+		});
+		const commitMsg = `[contentrain] normalize: extract ${entriesWritten} entries to ${extractions.length} models`;
+		await tx.commit(commitMsg);
+		const gitResult = {
+			branch: branchName,
+			action: "pending-review",
+			commit: ""
+		};
+		try {
+			const completed = await tx.complete();
+			gitResult.action = completed.action;
+			gitResult.commit = completed.commit;
+		} catch {
+			gitResult.action = "pending-review";
+		} finally {
+			await tx.cleanup();
+		}
+		return {
+			dry_run: false,
+			results: {
+				models_created: modelsCreated,
+				models_updated: modelsUpdated,
+				entries_written: entriesWritten,
+				source_map: sourceMap
+			},
+			git: gitResult,
+			context_updated: true,
+			next_steps: [
+				"Run contentrain_validate to check the extracted content",
+				"Run contentrain_submit to push the branch for review",
+				"After review, proceed with mode:reuse to patch source files"
+			]
+		};
+	} catch (error) {
+		await tx.cleanup();
+		throw error;
+	}
+}
+async function applyReuse(projectRoot, input) {
+	const config = await readConfig(projectRoot);
+	if (!config) throw new Error("Project not initialized. Run contentrain_init first.");
+	const { scope, patches, dry_run } = input;
+	if (!scope.model && !scope.domain) throw new Error("Scope required: provide model or domain. Whole-project patching is not allowed.");
+	if (patches.length > MAX_PATCHES) throw new Error(`Too many patches (${patches.length}). Maximum ${MAX_PATCHES} per operation. Split into multiple calls.`);
+	if (scope.model) {
+		if (!await readModel(projectRoot, scope.model)) throw new Error(`Model "${scope.model}" not found. Run extract phase first.`);
+	}
+	const scopeWarnings = [];
+	for (const patch of patches) {
+		const pathError = validatePatchPath(patch.file);
+		if (pathError) throw new Error(`Invalid patch path: ${pathError}`);
+	}
+	if (scope.model || scope.domain) {
+		const models = await listModels(projectRoot);
+		const scopeModels = scope.model ? models.filter((m) => m.id === scope.model) : scope.domain ? models.filter((m) => m.domain === scope.domain) : models;
+		if (scopeModels.length === 0) throw new Error(`No models found for scope ${scope.model ? `model="${scope.model}"` : `domain="${scope.domain}"`}`);
+		const { autoDetectSourceDirs } = await import("./core/scan-config.mjs");
+		const sourceDirs = await autoDetectSourceDirs(projectRoot);
+		const allowedPrefixes = sourceDirs.map((d) => d === "." ? "" : d + "/");
+		for (const patch of patches) {
+			const normalizedPath = patch.file.replace(/\\/g, "/");
+			if (normalizedPath.startsWith(".contentrain/") || normalizedPath.includes("/.contentrain/")) throw new Error(`Cannot patch content/config files directly: "${patch.file}". Reuse patches source files only.`);
+			if (sourceDirs.length > 0 && sourceDirs[0] !== ".") {
+				if (!allowedPrefixes.some((prefix) => prefix === "" || normalizedPath.startsWith(prefix))) throw new Error(`Patch file "${patch.file}" is outside detected source directories (${sourceDirs.join(", ")}). Reuse patches must target source files within the project's source tree.`);
+			}
+		}
+		if (scope.model || scope.domain) {
+			const sourcesRaw = await readText(join(projectRoot, ".contentrain", "normalize-sources.json"));
+			if (!sourcesRaw) if (scopeModels.find((m) => m.id === scope.model)?.kind === "dictionary") scopeWarnings.push("normalize-sources.json not found. Dictionary models do not generate per-file source maps. Scope enforcement is based on source-tree locality only.");
+			else if (dry_run !== false) scopeWarnings.push("normalize-sources.json not found. Semantic scope enforcement is unavailable. Merge the extract branch first, then reuse will have full scope protection.");
+			else throw new Error("Cannot execute reuse: normalize-sources.json not found on base branch. The extract branch must be merged before reuse can execute. This ensures semantic scope enforcement protects against out-of-scope patching.");
+			else {
+				const sourcesData = JSON.parse(sourcesRaw);
+				let allowedSourceFiles = [];
+				let scopeLabel = "";
+				if (scope.model) {
+					const modelSources = sourcesData.models?.[scope.model]?.source_files;
+					if (modelSources) allowedSourceFiles = modelSources;
+					scopeLabel = `model "${scope.model}"`;
+				} else if (scope.domain) {
+					const domainModelIds = scopeModels.map((m) => m.id);
+					for (const modelId of domainModelIds) {
+						const modelSources = sourcesData.models?.[modelId]?.source_files;
+						if (modelSources) allowedSourceFiles.push(...modelSources);
+					}
+					allowedSourceFiles = [...new Set(allowedSourceFiles)];
+					scopeLabel = `domain "${scope.domain}"`;
+				}
+				if (allowedSourceFiles.length > 0) {
+					const outOfScopePatches = [];
+					for (const patch of patches) {
+						const normalizedPath = patch.file.replace(/\\/g, "/");
+						if (!allowedSourceFiles.includes(normalizedPath)) outOfScopePatches.push(patch.file);
+					}
+					if (outOfScopePatches.length > 0) throw new Error(`Scope enforcement: ${outOfScopePatches.length} patch file(s) are not associated with ${scopeLabel}. Out-of-scope files: ${outOfScopePatches.join(", ")}. Known source files: ${allowedSourceFiles.join(", ")}.`);
+				}
+			}
+		}
+	}
+	const patchesByFile = /* @__PURE__ */ new Map();
+	for (const patch of patches) {
+		if (!patchesByFile.has(patch.file)) patchesByFile.set(patch.file, []);
+		patchesByFile.get(patch.file).push(patch);
+	}
+	const filesToModify = [...patchesByFile.keys()];
+	const importsToAdd = patches.filter((p) => p.import_statement).length;
+	if (dry_run !== false) return {
+		dry_run: true,
+		preview: {
+			files_to_modify: filesToModify,
+			patches_count: patches.length,
+			imports_to_add: importsToAdd
+		},
+		...scopeWarnings.length > 0 ? { scope_warnings: scopeWarnings } : {},
+		next_steps: [
+			...scopeWarnings.length > 0 ? [`WARNING: ${scopeWarnings.length} patch file(s) not in extract source map — verify intent`] : [],
+			"Review the files and patches above",
+			"Call contentrain_apply with mode:reuse and dry_run:false to execute"
+		]
+	};
+	const reuseHealth = await checkBranchHealth(projectRoot);
+	if (reuseHealth.blocked) return {
+		dry_run: false,
+		error: `Branch blocked: ${reuseHealth.message}`,
+		next_steps: ["Merge or delete old contentrain/* branches before executing reuse."]
+	};
+	const scopeTarget = scope.model ?? scope.domain;
+	const branchName = buildBranchName("normalize/reuse", scopeTarget);
+	const tx = await createTransaction(projectRoot, branchName, { workflowOverride: "review" });
+	const filesModified = [];
+	let patchesApplied = 0;
+	let importsAdded = 0;
+	const patchesSkipped = [];
+	const frameworkWarnings = [];
+	const syntaxErrors = [];
+	try {
+		await tx.write(async (wt) => {
+			for (const [relFile, filePatches] of patchesByFile) {
+				const absPath = join(wt, relFile);
+				if (!await pathExists(absPath)) {
+					for (const p of filePatches) patchesSkipped.push({
+						file: relFile,
+						line: p.line,
+						reason: "file not found"
+					});
+					continue;
+				}
+				const content = await readText(absPath);
+				if (content === null) {
+					for (const p of filePatches) patchesSkipped.push({
+						file: relFile,
+						line: p.line,
+						reason: "file unreadable"
+					});
+					continue;
+				}
+				const sorted = [...filePatches].toSorted((a, b) => b.line - a.line);
+				const lines = content.split("\n");
+				let fileModified = false;
+				for (const patch of sorted) {
+					const isTagTextContext = (lines[patch.line - 1] ?? "").includes(`>${patch.old_value}<`);
+					const replacementContext = isTagTextContext ? "tag_text" : "other";
+					if (isTagTextContext) {
+						const fwWarning = validateFrameworkExpression(relFile, patch.new_expression, replacementContext);
+						if (fwWarning) frameworkWarnings.push({
+							file: relFile,
+							warning: fwWarning
+						});
+					}
+					if (applyPatchToLines(lines, patch)) {
+						patchesApplied++;
+						fileModified = true;
+					} else patchesSkipped.push({
+						file: relFile,
+						line: patch.line,
+						reason: "old_value not found at or near specified line"
+					});
+				}
+				const importStatements = new Set(filePatches.filter((p) => p.import_statement).map((p) => p.import_statement));
+				if (importStatements.size > 0) {
+					const added = addImportsToLines(lines, importStatements);
+					importsAdded += added;
+					if (added > 0) fileModified = true;
+				}
+				if (fileModified) {
+					const newContent = lines.join("\n");
+					await writeText(absPath, newContent);
+					filesModified.push(relFile);
+					const syntaxError = checkSyntax(relFile, newContent);
+					if (syntaxError) syntaxErrors.push({
+						file: relFile,
+						error: syntaxError
+					});
+				}
+			}
+			await writeContext(wt, {
+				tool: "contentrain_apply",
+				model: scopeTarget,
+				locale: config.locales.default
+			});
+		});
+		if (filesModified.length === 0) {
+			await tx.cleanup();
+			return {
+				dry_run: false,
+				results: {
+					files_modified: [],
+					patches_applied: 0,
+					patches_skipped: patchesSkipped,
+					imports_added: 0,
+					framework_warnings: frameworkWarnings.length > 0 ? frameworkWarnings : void 0
+				},
+				next_steps: ["No files were modified. Check patch definitions and try again."]
+			};
+		}
+		const commitMsg = `[contentrain] normalize: reuse ${scopeTarget} — patch ${filesModified.length} files (${patchesApplied} replacements)`;
+		await tx.commit(commitMsg);
+		const gitResult = {
+			branch: branchName,
+			action: "pending-review",
+			commit: ""
+		};
+		try {
+			const completed = await tx.complete();
+			gitResult.action = completed.action;
+			gitResult.commit = completed.commit;
+		} catch {
+			gitResult.action = "pending-review";
+		} finally {
+			await tx.cleanup();
+		}
+		return {
+			dry_run: false,
+			results: {
+				files_modified: filesModified,
+				patches_applied: patchesApplied,
+				patches_skipped: patchesSkipped,
+				imports_added: importsAdded,
+				framework_warnings: frameworkWarnings.length > 0 ? frameworkWarnings : void 0,
+				syntax_errors: syntaxErrors.length > 0 ? syntaxErrors : void 0
+			},
+			...scopeWarnings.length > 0 ? { scope_warnings: scopeWarnings } : {},
+			git: gitResult,
+			next_steps: [
+				"Run contentrain_validate to verify the patched files",
+				patchesSkipped.length > 0 ? `${patchesSkipped.length} patches were skipped — review and retry if needed` : "",
+				syntaxErrors.length > 0 ? `WARNING: ${syntaxErrors.length} file(s) may have syntax errors after patching — review manually` : "",
+				scopeWarnings.length > 0 ? `NOTE: ${scopeWarnings.length} patch file(s) not in extract source map` : "",
+				"Run contentrain_submit to push the branch for review"
+			].filter(Boolean)
+		};
+	} catch (error) {
+		await tx.cleanup();
+		throw error;
+	}
+}
+/**
+* Apply a single patch to a lines array. Mutates lines in place.
+* Uses line hint for proximity matching — searches ±10 lines from hint.
+*/
+function applyPatchToLines(lines, patch) {
+	const { line, old_value, new_expression } = patch;
+	const lineIdx = line - 1;
+	const searchStart = Math.max(0, lineIdx - 10);
+	const searchEnd = Math.min(lines.length, lineIdx + 11);
+	if (lineIdx >= 0 && lineIdx < lines.length) {
+		const replaced = replaceInLine(lines[lineIdx], old_value, new_expression);
+		if (replaced !== null) {
+			lines[lineIdx] = replaced;
+			return true;
+		}
+	}
+	for (let i = searchStart; i < searchEnd; i++) {
+		if (i === lineIdx) continue;
+		const replaced = replaceInLine(lines[i], old_value, new_expression);
+		if (replaced !== null) {
+			lines[i] = replaced;
+			return true;
+		}
+	}
+	return false;
+}
+/**
+* Replace old_value with new_expression in a single line.
+* Matches the string literal (quoted or unquoted tag text).
+* Returns the modified line, or null if not found.
+*
+* Guardrail #4: Safer patch matching — word boundary awareness and
+* ambiguity rejection for plain text fallback.
+*/
+function replaceInLine(line, oldValue, newExpression) {
+	for (const quote of [
+		"\"",
+		"'",
+		"`"
+	]) {
+		const quoted = `${quote}${oldValue}${quote}`;
+		if (line.includes(quoted)) return line.replace(quoted, newExpression);
+	}
+	if (line.includes(`>${oldValue}<`)) return line.replace(`>${oldValue}<`, `>${newExpression}<`);
+	if (line.includes(oldValue)) {
+		if (countOccurrences(line, oldValue) > 1) return null;
+		const idx = line.indexOf(oldValue);
+		const charBefore = idx > 0 ? line[idx - 1] : "";
+		const charAfter = idx + oldValue.length < line.length ? line[idx + oldValue.length] : "";
+		const oldStartsWithWord = oldValue.length > 0 && isWordChar(oldValue[0]);
+		const oldEndsWithWord = oldValue.length > 0 && isWordChar(oldValue[oldValue.length - 1]);
+		if (oldStartsWithWord && isWordChar(charBefore)) return null;
+		if (oldEndsWithWord && isWordChar(charAfter)) return null;
+		return line.replace(oldValue, newExpression);
+	}
+	return null;
+}
+/** Count non-overlapping occurrences of a substring */
+function countOccurrences(str, sub) {
+	let count = 0;
+	let pos = 0;
+	while (pos <= str.length - sub.length) {
+		const idx = str.indexOf(sub, pos);
+		if (idx === -1) break;
+		count++;
+		pos = idx + sub.length;
+	}
+	return count;
+}
+/** Check if a character is a word character (letter, digit, underscore) */
+function isWordChar(ch) {
+	return /\w/.test(ch);
+}
+/**
+* Add import statements to the top of a file (after existing imports).
+* Deduplicates — won't add if the import already exists.
+* Returns number of imports actually added.
+*/
+function addImportsToLines(lines, imports) {
+	let added = 0;
+	const existingContent = lines.join("\n");
+	let lastImportIdx = -1;
+	let inMultiLineImport = false;
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		if (inMultiLineImport) {
+			lastImportIdx = i;
+			if (trimmed.includes("}")) inMultiLineImport = false;
+			continue;
+		}
+		if (trimmed.startsWith("import ") || trimmed.startsWith("import{")) {
+			lastImportIdx = i;
+			if (trimmed.includes("{") && !trimmed.includes("}")) inMultiLineImport = true;
+			continue;
+		}
+		if (lastImportIdx >= 0 && trimmed.length > 0 && !trimmed.startsWith("//") && !trimmed.startsWith("/*") && !trimmed.startsWith("*")) break;
+	}
+	let insertAt;
+	if (lastImportIdx >= 0) insertAt = lastImportIdx + 1;
+	else {
+		insertAt = 0;
+		for (let i = 0; i < lines.length; i++) {
+			const trimmed = lines[i].trim();
+			if (i === 0 && trimmed.startsWith("#!")) {
+				insertAt = i + 1;
+				continue;
+			}
+			if (trimmed === "'use client'" || trimmed === "\"use client\"" || trimmed === "'use server'" || trimmed === "\"use server\"" || trimmed === "'use client';" || trimmed === "\"use client\";" || trimmed === "'use server';" || trimmed === "\"use server\";") {
+				insertAt = i + 1;
+				continue;
+			}
+			if (insertAt > 0 && trimmed.length > 0) break;
+			if (insertAt === 0 && trimmed.length > 0) break;
+		}
+	}
+	const toInsert = [];
+	for (const imp of imports) if (!existingContent.includes(imp)) {
+		toInsert.push(imp);
+		added++;
+	}
+	if (toInsert.length > 0) lines.splice(insertAt, 0, ...toInsert);
+	return added;
+}
+//#endregion
+export { detectFileFramework as a, validatePatchPath as c, checkSyntax as i, applyExtract as n, replaceInLine as o, applyReuse as r, validateFrameworkExpression as s, PATCHABLE_EXTENSIONS as t };
+
+//# sourceMappingURL=apply-manager-CaTuu7Lj.mjs.map