@yr-kits/dev-copilot 0.1.1 → 0.1.2

package/dist/run-bridge-cli-DVLGcVgq.mjs

@@ -0,0 +1,1510 @@
+import { createServer } from "node:http";
+import { execFile, spawn } from "node:child_process";
+import { promises } from "node:fs";
+import path, { delimiter, join } from "node:path";
+import { promisify } from "node:util";
+import os, { homedir, tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { access, copyFile, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+
+//#region src/bridge/shared/config/bridge-config.ts
+const DEFAULT_ALLOWED_PATHS = [
+	"app",
+	"src",
+	"widgets",
+	"features",
+	"entities",
+	"shared",
+	"components"
+];
+const createDevCopilotBridgeConfig = (config) => {
+	return {
+		rootDir: config.rootDir,
+		host: config.host ?? "127.0.0.1",
+		port: config.port ?? 3339,
+		corsOrigin: config.corsOrigin ?? "*",
+		agent: config.agent ?? "codex",
+		allowedPaths: config.allowedPaths ?? DEFAULT_ALLOWED_PATHS
+	};
+};
+
+//#endregion
+//#region src/bridge/shared/lib/temp-path.ts
+const createTempPath = (prefix, extension = "") => {
+	const suffix = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+	return path.join(os.tmpdir(), `${prefix}-${suffix}${extension}`);
+};
+
+//#endregion
+//#region src/bridge/lib/patch.ts
+const execFileAsync$1 = promisify(execFile);
+const getChangedFiles = (patchPreview) => {
+	const regex = /^\+\+\+ b\/(.+)$/gm;
+	const changedFiles = /* @__PURE__ */ new Set();
+	let match = regex.exec(patchPreview);
+	while (match) {
+		changedFiles.add(match[1]);
+		match = regex.exec(patchPreview);
+	}
+	return [...changedFiles];
+};
+const getGitApplyDirectoryArgs = async (cwd) => {
+	try {
+		const { stdout } = await execFileAsync$1("git", ["rev-parse", "--show-prefix"], { cwd });
+		const prefix = stdout.trim().replace(/\/$/, "");
+		return prefix ? ["--directory", prefix] : [];
+	} catch {
+		return [];
+	}
+};
+const withOriginalLineIndent = (content, oldText, newText) => {
+	if (!newText.includes("\n")) return newText;
+	const matchIndex = content.indexOf(oldText);
+	if (matchIndex < 0) return newText;
+	const lineStartIndex = content.lastIndexOf("\n", matchIndex) + 1;
+	const indent = content.slice(lineStartIndex, matchIndex).match(/^[ \t]*/)?.[0] ?? "";
+	return indent ? newText.replaceAll("\n", `\n${indent}`) : newText;
+};
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const createWhitespaceTolerantPattern = (value) => {
+	const tokens = value.trim().split(/\s+/).filter(Boolean);
+	if (!tokens.length) return null;
+	return new RegExp(tokens.map(escapeRegExp).join("\\s+"));
+};
+const replaceText = (content, oldText, newText) => {
+	if (content.includes(oldText)) return {
+		replaced: true,
+		content: content.replace(oldText, withOriginalLineIndent(content, oldText, newText))
+	};
+	const match = createWhitespaceTolerantPattern(oldText)?.exec(content);
+	if (!match) return {
+		replaced: false,
+		content
+	};
+	const matchedText = match[0];
+	return {
+		replaced: true,
+		content: content.replace(matchedText, withOriginalLineIndent(content, matchedText, newText))
+	};
+};
+const validatePatchPaths = (patchPreview, validatePath) => {
+	const changedFiles = getChangedFiles(patchPreview);
+	if (!changedFiles.length) throw new Error("패치에서 변경 파일을 찾을 수 없습니다.");
+	changedFiles.forEach(validatePath);
+	return changedFiles;
+};
+const checkUnifiedPatch = async (patchPreview, cwd) => {
+	const tempFilePath = createTempPath("dev-copilot-check", ".patch");
+	await promises.writeFile(tempFilePath, patchPreview, "utf-8");
+	try {
+		await execFileAsync$1("git", [
+			"apply",
+			"--check",
+			...await getGitApplyDirectoryArgs(cwd),
+			tempFilePath
+		], { cwd });
+	} catch (error) {
+		const detail = error instanceof Error && "stderr" in error ? String(error.stderr) : error instanceof Error ? error.message : "알 수 없는 patch 검증 오류";
+		throw new Error(`적용 가능한 diff를 생성하지 못했습니다: ${detail.trim()}`);
+	} finally {
+		await promises.rm(tempFilePath, { force: true });
+	}
+};
+const createGitPatch = async (filePath, oldContent, newContent) => {
+	const tempDir = createTempPath("dev-copilot-diff");
+	const oldFilePath = path.join(tempDir, "old", filePath);
+	const newFilePath = path.join(tempDir, "new", filePath);
+	await promises.mkdir(path.dirname(oldFilePath), { recursive: true });
+	await promises.mkdir(path.dirname(newFilePath), { recursive: true });
+	await promises.writeFile(oldFilePath, oldContent, "utf-8");
+	await promises.writeFile(newFilePath, newContent, "utf-8");
+	try {
+		const { stdout } = await execFileAsync$1("git", [
+			"diff",
+			"--no-index",
+			"--no-ext-diff",
+			"--src-prefix=a/",
+			"--dst-prefix=b/",
+			"--",
+			path.join("old", filePath),
+			path.join("new", filePath)
+		], { cwd: tempDir }).catch((error) => {
+			const typedError = error;
+			if (typedError.code === 1 && typedError.stdout) return { stdout: typedError.stdout };
+			throw error;
+		});
+		return stdout.replaceAll(`a/old/${filePath}`, `a/${filePath}`).replaceAll(`b/new/${filePath}`, `b/${filePath}`);
+	} finally {
+		await promises.rm(tempDir, {
+			force: true,
+			recursive: true
+		});
+	}
+};
+const createPatchFromTextReplacements = async (replacements, cwd, validatePath) => {
+	const byPath = /* @__PURE__ */ new Map();
+	for (const replacement of replacements) {
+		const normalizedPath = validatePath(replacement.path);
+		const current = byPath.get(normalizedPath) ?? [];
+		current.push(replacement);
+		byPath.set(normalizedPath, current);
+	}
+	const patches = [];
+	for (const [filePath, fileReplacements] of byPath.entries()) {
+		const absolutePath = path.join(cwd, filePath);
+		const oldContent = await promises.readFile(absolutePath, "utf-8");
+		let newContent = oldContent;
+		for (const replacement of fileReplacements) {
+			const result = replaceText(newContent, replacement.oldText, replacement.newText);
+			if (!result.replaced) throw new Error(`원문을 파일에서 찾을 수 없습니다: ${filePath}`);
+			newContent = result.content;
+		}
+		if (newContent === oldContent) continue;
+		patches.push(await createGitPatch(filePath, oldContent, newContent));
+	}
+	const patchPreview = patches.join("\n");
+	if (!patchPreview.trim()) throw new Error("변경할 내용이 없습니다.");
+	return patchPreview;
+};
+const applyUnifiedPatch = async (patchPreview, cwd, actor) => {
+	const tempFilePath = createTempPath("dev-copilot", ".patch");
+	await promises.writeFile(tempFilePath, patchPreview, "utf-8");
+	try {
+		const directoryArgs = await getGitApplyDirectoryArgs(cwd);
+		const { stdout: statOutput } = await execFileAsync$1("git", [
+			"apply",
+			"--numstat",
+			...directoryArgs,
+			tempFilePath
+		], { cwd });
+		if (!statOutput.trim()) throw new Error("patch가 실제 파일 변경을 만들지 않았습니다.");
+		await execFileAsync$1("git", [
+			"apply",
+			"--check",
+			...directoryArgs,
+			tempFilePath
+		], { cwd });
+		await execFileAsync$1("git", [
+			"apply",
+			...directoryArgs,
+			tempFilePath
+		], { cwd });
+		return {
+			actor,
+			changedFiles: getChangedFiles(patchPreview)
+		};
+	} catch (error) {
+		const detail = error instanceof Error && "stderr" in error ? String(error.stderr) : error instanceof Error ? error.message : "알 수 없는 patch 적용 오류";
+		throw new Error(`patch 적용에 실패했습니다: ${detail.trim()}`);
+	} finally {
+		await promises.rm(tempFilePath, { force: true });
+	}
+};
+
+//#endregion
+//#region src/bridge/lib/guards.ts
+const resolveAndValidatePath = (filePath, allowedPaths, rootDir) => {
+	if (!filePath) throw new Error("허용되지 않은 파일 경로입니다.");
+	let normalizedInput = filePath.replaceAll("\\", "/");
+	if (rootDir) {
+		const normalizedRootDir = rootDir.replaceAll("\\", "/").replace(/\/+$/, "");
+		if (normalizedInput.startsWith(`${normalizedRootDir}/`)) normalizedInput = normalizedInput.slice(normalizedRootDir.length + 1);
+	}
+	if (path.isAbsolute(normalizedInput) || normalizedInput.includes("..")) throw new Error("허용되지 않은 파일 경로입니다.");
+	const normalized = normalizedInput;
+	const firstSegment = normalized.split("/")[0];
+	if (!(allowedPaths.includes(".") || allowedPaths.includes("*")) && !allowedPaths.includes(firstSegment)) throw new Error(`허용 경로 외 파일은 수정할 수 없습니다: ${firstSegment}`);
+	return normalized;
+};
+
+//#endregion
+//#region src/bridge/lib/store.ts
+const patchStore = /* @__PURE__ */ new Map();
+const TTL_MS = 1e3 * 60 * 15;
+const pruneExpired = () => {
+	const now = Date.now();
+	for (const [key, value] of patchStore.entries()) if (now - value.createdAt > TTL_MS) patchStore.delete(key);
+};
+const createProposedPatch = (patchPreview, allowedPaths) => {
+	pruneExpired();
+	const patchId = randomUUID();
+	const approvalToken = `approve:${patchId}`;
+	patchStore.set(patchId, {
+		patchId,
+		approvalToken,
+		patchPreview,
+		allowedPaths,
+		createdAt: Date.now()
+	});
+	return {
+		patchId,
+		approvalToken
+	};
+};
+const getProposedPatch = (patchId, approvalToken) => {
+	pruneExpired();
+	const item = patchStore.get(patchId);
+	if (!item || item.approvalToken !== approvalToken) return null;
+	return item;
+};
+const deleteProposedPatch = (patchId) => {
+	patchStore.delete(patchId);
+};
+
+//#endregion
+//#region src/bridge/features/patch-flow/patch-flow-service.ts
+const sanitizeAllowedPaths = (fileHints) => {
+	if (!fileHints?.length) return null;
+	const sanitized = fileHints.map((value) => value.trim()).filter(Boolean).filter((value) => value === "." || value === "*" || /^[A-Za-z0-9._-]+$/.test(value));
+	return sanitized.length ? Array.from(new Set(sanitized)) : null;
+};
+const resolveAllowedPathsWithSrcFallback = (config, fileHints) => {
+	const resolved = sanitizeAllowedPaths(fileHints) ?? config.allowedPaths;
+	if (!resolved.includes(".") && !resolved.includes("*") && !resolved.includes("src")) return [...resolved, "src"];
+	return resolved;
+};
+const buildPatchPreview = async (changes, config, allowedPaths) => {
+	if (!changes?.length) return "";
+	return createPatchFromTextReplacements(changes, config.rootDir, (filePath) => resolveAndValidatePath(filePath, allowedPaths, config.rootDir));
+};
+const validatePatchPreview = async (patchPreview, config, allowedPaths) => {
+	validatePatchPaths(patchPreview, (filePath) => resolveAndValidatePath(filePath, allowedPaths, config.rootDir));
+	await checkUnifiedPatch(patchPreview, config.rootDir);
+};
+const saveProposedPatch = (patchPreview, allowedPaths) => {
+	return createProposedPatch(patchPreview, allowedPaths);
+};
+const applySavedPatch = async (config, patchId, approvalToken) => {
+	const proposedPatch = getProposedPatch(patchId, approvalToken);
+	if (!proposedPatch) throw new Error("유효하지 않거나 만료된 patchId입니다.");
+	validatePatchPaths(proposedPatch.patchPreview, (filePath) => resolveAndValidatePath(filePath, proposedPatch.allowedPaths?.length ? proposedPatch.allowedPaths : config.allowedPaths, config.rootDir));
+	const result = await applyUnifiedPatch(proposedPatch.patchPreview, config.rootDir, "local-codex-bridge");
+	deleteProposedPatch(patchId);
+	return result;
+};
+
+//#endregion
+//#region src/bridge/shared/http/read-json-body.ts
+const readJsonBody = async (request) => {
+	const chunks = [];
+	for await (const chunk of request) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	const raw = Buffer.concat(chunks).toString("utf-8");
+	return JSON.parse(raw);
+};
+
+//#endregion
+//#region src/bridge/shared/http/respond.ts
+const createCorsHeaders = (config) => ({
+	"Access-Control-Allow-Origin": config.corsOrigin,
+	"Access-Control-Allow-Methods": "GET,POST,OPTIONS",
+	"Access-Control-Allow-Headers": "Content-Type",
+	"Content-Type": "application/json; charset=utf-8"
+});
+const sendJson = (response, config, statusCode, payload) => {
+	response.writeHead(statusCode, createCorsHeaders(config));
+	response.end(JSON.stringify(payload));
+};
+
+//#endregion
+//#region src/bridge/features/apply/apply-route.ts
+const toPatchSummary = (changedFiles) => {
+	return changedFiles.length === 1 ? "1개 파일에 수정이 반영되었습니다." : `${changedFiles.length}개 파일에 수정이 반영되었습니다.`;
+};
+const handleApplyRoute = async (request, response, config) => {
+	const payload = await readJsonBody(request);
+	if (!payload.patchId || !payload.approvalToken) {
+		sendJson(response, config, 400, { error: "patchId와 approvalToken이 필요합니다." });
+		return;
+	}
+	const result = await applySavedPatch(config, payload.patchId, payload.approvalToken);
+	sendJson(response, config, 200, {
+		applied: true,
+		changedFiles: result.changedFiles,
+		summary: toPatchSummary(result.changedFiles)
+	});
+};
+
+//#endregion
+//#region src/bridge/internal/agents/edit-response-schema.ts
+const agentEditResponseSchema = {
+	type: "object",
+	properties: {
+		message: { type: "string" },
+		warnings: {
+			type: "array",
+			items: { type: "string" }
+		},
+		changes: {
+			type: "array",
+			minItems: 1,
+			items: {
+				type: "object",
+				properties: {
+					path: { type: "string" },
+					oldText: { type: "string" },
+					newText: { type: "string" }
+				},
+				required: [
+					"path",
+					"oldText",
+					"newText"
+				],
+				additionalProperties: false
+			}
+		}
+	},
+	required: [
+		"message",
+		"warnings",
+		"changes"
+	],
+	additionalProperties: false
+};
+const agentEditResponseSchemaJson = JSON.stringify(agentEditResponseSchema);
+
+//#endregion
+//#region src/bridge/internal/agents/constants.ts
+const DEFAULT_AGENT_TIMEOUT_MS = 12e4;
+const DEFAULT_AGENT_MAX_BUFFER_BYTES = 1024 * 1024 * 5;
+const STATUS_CHECK_TIMEOUT_MS = 1e4;
+const QUICK_STATUS_CHECK_TIMEOUT_MS = 5e3;
+const MODEL_STATUS_CHECK_TIMEOUT_MS = 3e4;
+
+//#endregion
+//#region src/bridge/internal/agents/agent-response.ts
+const findFirstString = (value) => {
+	if (typeof value === "string") {
+		const text = value.trim();
+		return text ? text : null;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const found = findFirstString(item);
+			if (found) return found;
+		}
+		return null;
+	}
+	if (value && typeof value === "object") {
+		const record = value;
+		for (const key of [
+			"result",
+			"message",
+			"output",
+			"text",
+			"content"
+		]) if (key in record) {
+			const found = findFirstString(record[key]);
+			if (found) return found;
+		}
+		for (const nestedValue of Object.values(record)) {
+			const found = findFirstString(nestedValue);
+			if (found) return found;
+		}
+	}
+	return null;
+};
+const normalizeAgentBridgeResponse = (value) => {
+	return {
+		message: typeof value.message === "string" ? value.message : "",
+		patchPreview: value.patchPreview,
+		changes: value.changes,
+		warnings: Array.isArray(value.warnings) ? value.warnings : []
+	};
+};
+const parseJsonLikeText = (text) => {
+	const trimmed = text.trim();
+	const jsonText = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i)?.[1]?.trim() ?? trimmed;
+	return JSON.parse(jsonText);
+};
+const parseClaudeJsonOutput = (raw) => {
+	const parsed = JSON.parse(raw);
+	return {
+		parsed,
+		text: findFirstString(parsed) ?? ""
+	};
+};
+const parseClaudeEditResponse = (raw) => {
+	const { parsed, text } = parseClaudeJsonOutput(raw);
+	return normalizeAgentBridgeResponse(parsed.structured_output && typeof parsed.structured_output === "object" ? parsed.structured_output : parseJsonLikeText(text));
+};
+const parseCodexEditResponse = (raw) => {
+	return normalizeAgentBridgeResponse(parseJsonLikeText(raw));
+};
+const parseAnswerResponse = (rawOutput) => {
+	return {
+		message: rawOutput.trim(),
+		warnings: []
+	};
+};
+
+//#endregion
+//#region src/bridge/internal/agents/cli-error.ts
+const extractCliErrorDetails = (error) => {
+	const record = error && typeof error === "object" ? error : null;
+	const message = error instanceof Error ? error.message : String(error);
+	const stderr = typeof record?.stderr === "string" ? record.stderr : "";
+	const stdout = typeof record?.stdout === "string" ? record.stdout : "";
+	const signal = typeof record?.signal === "string" ? record.signal : "";
+	const killed = record?.killed === true;
+	return {
+		message,
+		stderr,
+		stdout,
+		signal,
+		killed,
+		merged: [
+			message,
+			stderr,
+			stdout,
+			signal,
+			killed ? "killed" : ""
+		].map((part) => part.trim()).filter(Boolean).join("\n")
+	};
+};
+const isCliTimeout = (details) => {
+	return /SIGTERM|timed out|timeout/i.test(details.merged);
+};
+const isCliCommandMissing = (details) => {
+	return /ENOENT/.test(details.merged);
+};
+
+//#endregion
+//#region src/bridge/internal/agents/run-cli.ts
+const runCli = (command, args, options) => {
+	return new Promise((resolve, reject) => {
+		const maxBuffer = options.maxBuffer ?? DEFAULT_AGENT_MAX_BUFFER_BYTES;
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				NO_COLOR: "1",
+				...options.env
+			}
+		});
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		let stdoutLength = 0;
+		let stderrLength = 0;
+		let settled = false;
+		const timeout = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			child.kill("SIGTERM");
+			const error = /* @__PURE__ */ new Error(`${command} 실행 시간이 초과되었습니다.`);
+			Object.assign(error, {
+				signal: "SIGTERM",
+				killed: true
+			});
+			reject(error);
+		}, options.timeoutMs);
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			child.kill("SIGTERM");
+			reject(error);
+		};
+		child.stdout.on("data", (chunk) => {
+			stdoutLength += chunk.length;
+			if (stdoutLength > maxBuffer) {
+				fail(/* @__PURE__ */ new Error(`${command} stdout이 허용된 크기를 초과했습니다.`));
+				return;
+			}
+			stdoutChunks.push(chunk);
+		});
+		child.stderr.on("data", (chunk) => {
+			stderrLength += chunk.length;
+			if (stderrLength > maxBuffer) {
+				fail(/* @__PURE__ */ new Error(`${command} stderr가 허용된 크기를 초과했습니다.`));
+				return;
+			}
+			stderrChunks.push(chunk);
+		});
+		child.on("error", (error) => {
+			fail(error);
+		});
+		child.on("close", (code, signal) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+			const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+			if (code === 0) {
+				resolve({
+					stdout,
+					stderr
+				});
+				return;
+			}
+			const error = new Error(stderr || `${command} 실행에 실패했습니다. code=${code ?? "unknown"}`);
+			Object.assign(error, {
+				stdout,
+				stderr,
+				signal,
+				killed: signal === "SIGTERM",
+				code
+			});
+			reject(error);
+		});
+	});
+};
+
+//#endregion
+//#region src/bridge/internal/agents/claude-command.ts
+let claudeCommandPromise = null;
+const CLAUDE_SMOKE_MODEL = process.env.DEV_COPILOT_CLAUDE_MODEL ?? "haiku";
+const getPathExecutableNames$1 = () => {
+	if (process.platform !== "win32") return ["claude"];
+	return ["claude", ...(process.env.PATHEXT?.split(";").filter(Boolean) ?? [
+		".EXE",
+		".CMD",
+		".BAT"
+	]).map((ext) => `claude${ext.toLowerCase()}`)];
+};
+const collectClaudeCandidates = () => {
+	const candidates = [];
+	const envCommand = process.env.DEV_COPILOT_CLAUDE_BIN?.trim();
+	if (envCommand) candidates.push({
+		command: envCommand,
+		source: "env"
+	});
+	const executableNames = getPathExecutableNames$1();
+	const pathCandidates = (process.env.PATH ?? "").split(delimiter).filter(Boolean).flatMap((pathDir) => executableNames.map((name) => join(pathDir, name)));
+	for (const command of pathCandidates) candidates.push({
+		command,
+		source: "path"
+	});
+	return Array.from(new Map(candidates.map((candidate) => [candidate.command, candidate])).values());
+};
+const canRunClaude = async (command) => {
+	try {
+		await runCli(command, [
+			"-p",
+			"--output-format",
+			"json",
+			"--model",
+			CLAUDE_SMOKE_MODEL,
+			"--tools",
+			"",
+			"--strict-mcp-config",
+			"--mcp-config",
+			"{\"mcpServers\":{}}",
+			"--",
+			"OK만 출력해줘."
+		], {
+			cwd: process.cwd(),
+			timeoutMs: QUICK_STATUS_CHECK_TIMEOUT_MS,
+			maxBuffer: 1024 * 128
+		});
+		return true;
+	} catch {
+		return false;
+	}
+};
+const resolveClaudeCommand = async () => {
+	if (claudeCommandPromise) return claudeCommandPromise;
+	claudeCommandPromise = (async () => {
+		const candidates = collectClaudeCandidates();
+		const envCandidate = candidates.find((candidate) => candidate.source === "env");
+		if (envCandidate) return envCandidate.command;
+		for (const candidate of candidates) if (await canRunClaude(candidate.command)) return candidate.command;
+		return process.env.DEV_COPILOT_CLAUDE_BIN?.trim() || "claude";
+	})();
+	return claudeCommandPromise;
+};
+
+//#endregion
+//#region src/bridge/internal/prompts.ts
+const buildAgentPrompt = (request) => {
+	if (request.mode === "answer") return [
+		"Answer the user's web overlay request.",
+		"Do not modify files.",
+		"Use the provided project context when it is relevant.",
+		"Respond in Korean.",
+		"Keep the answer concise and actionable.",
+		"",
+		`Current route: ${request.route ?? "unknown"}`,
+		`Selected text:\n${request.selectedText || "(none)"}`,
+		`User prompt:\n${request.prompt}`,
+		`Previous AI response:\n${request.previousResponse ?? "(none)"}`,
+		`Project context:\n${request.projectContext ?? "(none)"}`
+	].join("\n");
+	return [
+		"You are a local code-edit proposal generator called from a web overlay.",
+		"Do not modify files directly.",
+		"Return JSON only.",
+		"Do not generate unified diff directly.",
+		"Put repository-relative file path(path), exact old text(oldText), and replacement text(newText) into the changes array.",
+		"Never use absolute paths. The path must be relative to the repository root, for example src/features/article/model/data.ts.",
+		"oldText must exactly match the file content and must not use ellipsis.",
+		"If the selected text spans multiple rendered lines, use the actual file text from project context for oldText.",
+		"newText must be meaningfully different from oldText.",
+		"Ground the proposal in the selected text, user prompt, and provided project context.",
+		"Write the message field in Korean.",
+		"",
+		`Current route: ${request.route ?? "unknown"}`,
+		`Allowed path hints: ${(request.fileHints ?? []).join(", ") || "(none)"}`,
+		`Selected text:\n${request.selectedText || "(none)"}`,
+		`User prompt:\n${request.prompt}`,
+		`Previous AI response:\n${request.previousResponse ?? "(none)"}`,
+		`Project context:\n${request.projectContext ?? "(none)"}`
+	].join("\n");
+};
+
+//#endregion
+//#region src/bridge/entities/agent/status.ts
+const createAuthenticatedStatus = (params) => ({
+	available: true,
+	authenticated: true,
+	agent: params.agent,
+	message: params.message,
+	model: params.model
+});
+const createLoginRequiredStatus = (params) => ({
+	available: params.available ?? true,
+	authenticated: false,
+	agent: params.agent,
+	message: params.message,
+	loginCommand: params.loginCommand
+});
+const createUnavailableStatus = (params) => ({
+	available: false,
+	authenticated: false,
+	agent: params.agent,
+	message: params.message
+});
+const createUnauthenticatedStatus = (params) => ({
+	available: params.available ?? true,
+	authenticated: false,
+	agent: params.agent,
+	message: params.message,
+	loginCommand: params.loginCommand
+});
+
+//#endregion
+//#region src/bridge/internal/agents/claude-adapter.ts
+const CLAUDE_MODEL = process.env.DEV_COPILOT_CLAUDE_MODEL ?? "haiku";
+const CLAUDE_TIMEOUT_MS = Number(process.env.DEV_COPILOT_CLAUDE_TIMEOUT_MS ?? DEFAULT_AGENT_TIMEOUT_MS);
+const AUTH_ERROR_PATTERN = /401|authentication|invalid authentication credentials|please run \/login|claude\s*\/login|로그인/i;
+const toClaudeErrorMessage = (error) => {
+	const details = extractCliErrorDetails(error);
+	if (isCliTimeout(details)) return "Claude Code 응답 시간이 초과되었습니다. 잠시 후 다시 시도해 주세요.";
+	if (AUTH_ERROR_PATTERN.test(details.merged)) return "Claude Code 로그인이 필요합니다. 터미널에서 `claude /login`을 실행해 주세요.";
+	if (isCliCommandMissing(details)) return "Claude CLI를 찾을 수 없습니다. Claude Code CLI 설치 상태를 확인해 주세요.";
+	return details.message;
+};
+const claudeAdapter = {
+	agent: "claude",
+	async run(request) {
+		const claudeCommand = await resolveClaudeCommand();
+		const prompt = buildAgentPrompt(request);
+		const args = [
+			"-p",
+			"--output-format",
+			"json",
+			"--model",
+			CLAUDE_MODEL,
+			"--tools",
+			"",
+			"--strict-mcp-config",
+			"--mcp-config",
+			"{\"mcpServers\":{}}",
+			...request.mode === "edit" ? ["--json-schema", agentEditResponseSchemaJson] : [],
+			"--",
+			prompt
+		];
+		try {
+			const { stdout } = await runCli(claudeCommand, args, {
+				cwd: request.cwd,
+				timeoutMs: Number(process.env.DEV_COPILOT_AGENT_TIMEOUT_MS ?? CLAUDE_TIMEOUT_MS)
+			});
+			if (request.mode === "answer") {
+				const { text } = parseClaudeJsonOutput(stdout);
+				return parseAnswerResponse(text);
+			}
+			return parseClaudeEditResponse(stdout);
+		} catch (error) {
+			throw new Error(toClaudeErrorMessage(error));
+		}
+	},
+	async getStatus(cwd) {
+		try {
+			await runCli(await resolveClaudeCommand(), ["--version"], {
+				cwd,
+				timeoutMs: QUICK_STATUS_CHECK_TIMEOUT_MS,
+				maxBuffer: 1024 * 32
+			});
+			return createAuthenticatedStatus({
+				agent: "claude",
+				message: "Claude Code CLI에 로그인되어 있습니다.",
+				model: CLAUDE_MODEL
+			});
+		} catch (error) {
+			const details = extractCliErrorDetails(error);
+			if (isCliCommandMissing(details)) return createUnavailableStatus({
+				agent: "claude",
+				message: "Claude CLI를 찾을 수 없습니다."
+			});
+			if (AUTH_ERROR_PATTERN.test(details.merged)) return createLoginRequiredStatus({
+				agent: "claude",
+				message: "Claude Code 로그인이 필요합니다.",
+				loginCommand: "claude /login"
+			});
+			return createUnauthenticatedStatus({
+				agent: "claude",
+				message: isCliTimeout(details) ? "Claude Code 상태 확인 시간이 초과되었습니다. 잠시 후 다시 시도해 주세요." : `Claude Code 상태 확인에 실패했습니다: ${details.message}`,
+				loginCommand: isCliTimeout(details) ? void 0 : "claude /login"
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/bridge/internal/agents/codex-command.ts
+let codexCommandPromise = null;
+const canAccess = async (path) => {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const getPathExecutableNames = () => {
+	if (process.platform !== "win32") return ["codex"];
+	return ["codex", ...(process.env.PATHEXT?.split(";").filter(Boolean) ?? [
+		".EXE",
+		".CMD",
+		".BAT"
+	]).map((ext) => `codex${ext.toLowerCase()}`)];
+};
+const collectCodexCandidates = async () => {
+	const executableNames = getPathExecutableNames();
+	const candidates = [];
+	const pathCandidates = (process.env.PATH ?? "").split(delimiter).filter(Boolean).flatMap((pathDir) => executableNames.map((name) => join(pathDir, name)));
+	for (const command of pathCandidates) if (await canAccess(command)) candidates.push({ command });
+	return Array.from(new Map(candidates.map((candidate) => [candidate.command, candidate])).values());
+};
+const parseCodexVersion = (output) => {
+	const version = output.match(/\d+\.\d+\.\d+(?:[-+][^\s]+)?/)?.[0];
+	if (!version) return null;
+	return { version };
+};
+const resolveCandidate = async (candidate) => {
+	const { stdout, stderr } = await runCli(candidate.command, ["--version"], {
+		cwd: process.cwd(),
+		timeoutMs: STATUS_CHECK_TIMEOUT_MS,
+		maxBuffer: 1024 * 128
+	});
+	const parsedVersion = parseCodexVersion(`${stdout}\n${stderr}`);
+	if (!parsedVersion) return null;
+	return {
+		...candidate,
+		...parsedVersion
+	};
+};
+const resolveCodexCommand = async () => {
+	if (codexCommandPromise) return codexCommandPromise;
+	codexCommandPromise = (async () => {
+		const candidates = await collectCodexCandidates();
+		const available = (await Promise.all(candidates.map(async (candidate) => {
+			try {
+				return await resolveCandidate(candidate);
+			} catch {
+				return null;
+			}
+		}))).filter((candidate) => Boolean(candidate));
+		if (!available.length) throw new Error("Codex CLI를 찾을 수 없습니다.");
+		return available[0].command;
+	})();
+	return codexCommandPromise;
+};
+
+//#endregion
+//#region src/bridge/internal/agents/codex-home.ts
+let codexExecutionEnvPromise = null;
+const copyIfExists = async (sourcePath, targetPath) => {
+	try {
+		await access(sourcePath);
+		await copyFile(sourcePath, targetPath);
+	} catch {
+		return;
+	}
+};
+const writeIsolatedConfig = async (targetPath) => {
+	try {
+		if (await readFile(targetPath, "utf-8") === "") return;
+	} catch {}
+	await writeFile(targetPath, "", "utf-8");
+};
+const resolveSourceCodexHome = (env = process.env) => {
+	return env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+};
+const createIsolatedCodexHome = async (sourceCodexHome) => {
+	const isolatedCodexHome = await mkdtemp(join(tmpdir(), "dev-copilot-codex-home-"));
+	await copyIfExists(join(sourceCodexHome, "auth.json"), join(isolatedCodexHome, "auth.json"));
+	await copyIfExists(join(sourceCodexHome, ".credentials.json"), join(isolatedCodexHome, ".credentials.json"));
+	await writeIsolatedConfig(join(isolatedCodexHome, "config.toml"));
+	return isolatedCodexHome;
+};
+const getCodexExecutionEnv = async (options) => {
+	if (codexExecutionEnvPromise) return codexExecutionEnvPromise;
+	codexExecutionEnvPromise = (async () => {
+		return { CODEX_HOME: await createIsolatedCodexHome(options?.sourceCodexHome ?? resolveSourceCodexHome()) };
+	})();
+	return codexExecutionEnvPromise;
+};
+
+//#endregion
+//#region src/bridge/internal/agents/codex-health.ts
+const CODEX_MODEL$1 = process.env.DEV_COPILOT_CODEX_MODEL ?? "gpt-5.3-codex";
+let codexHealthPromise = null;
+const isAuthenticatedFromStatus = (statusOutput) => {
+	const normalized = statusOutput.toLowerCase();
+	if (/not logged in|login required|로그인 필요/.test(normalized)) return false;
+	return /logged in|로그인됨|로그인되어/.test(normalized);
+};
+const createSchemaSmokePayload = () => JSON.stringify({
+	message: "ok",
+	warnings: [],
+	changes: [{
+		path: "src/App.tsx",
+		oldText: "before",
+		newText: "after"
+	}]
+});
+const createPromptJsonSmokePayload = () => JSON.stringify({
+	message: "ok",
+	warnings: [],
+	changes: [{
+		path: "src/App.tsx",
+		oldText: "before",
+		newText: "after"
+	}]
+});
+const runExecSmokeTest = async (command, cwd, env) => {
+	const outputPath = createTempPath("dev-copilot-codex-answer-smoke", ".txt");
+	try {
+		await runCli(command, [
+			"exec",
+			"--ephemeral",
+			"--model",
+			CODEX_MODEL$1,
+			"--cd",
+			cwd,
+			"--sandbox",
+			"read-only",
+			"--skip-git-repo-check",
+			"--output-last-message",
+			outputPath,
+			"OK만 출력해줘."
+		], {
+			cwd,
+			timeoutMs: MODEL_STATUS_CHECK_TIMEOUT_MS,
+			maxBuffer: 1024 * 512,
+			env
+		});
+		if (!(await readFile(outputPath, "utf-8")).trim()) throw new Error("Codex CLI smoke test output이 비어 있습니다.");
+	} finally {
+		await rm(outputPath, { force: true });
+	}
+};
+const runEditSchemaSmokeTest = async (command, cwd, env) => {
+	const outputPath = createTempPath("dev-copilot-codex-edit-smoke", ".json");
+	const schemaPath = createTempPath("dev-copilot-codex-edit-schema", ".json");
+	try {
+		await writeFile(schemaPath, JSON.stringify(agentEditResponseSchema), "utf-8");
+		await runCli(command, [
+			"exec",
+			"--ephemeral",
+			"--model",
+			CODEX_MODEL$1,
+			"--cd",
+			cwd,
+			"--sandbox",
+			"read-only",
+			"--skip-git-repo-check",
+			"--output-last-message",
+			outputPath,
+			"--output-schema",
+			schemaPath,
+			"message에 ok, warnings에 빈 배열, changes에 한 개의 수정 항목만 담아 JSON으로 응답해줘."
+		], {
+			cwd,
+			timeoutMs: MODEL_STATUS_CHECK_TIMEOUT_MS,
+			maxBuffer: 1024 * 512,
+			env
+		});
+		const output = await readFile(outputPath, "utf-8");
+		if (output.trim() !== createSchemaSmokePayload()) JSON.parse(output);
+	} finally {
+		await rm(outputPath, { force: true });
+		await rm(schemaPath, { force: true });
+	}
+};
+const runEditPromptJsonSmokeTest = async (command, cwd, env) => {
+	const outputPath = createTempPath("dev-copilot-codex-edit-prompt-json-smoke", ".json");
+	try {
+		await runCli(command, [
+			"exec",
+			"--ephemeral",
+			"--model",
+			CODEX_MODEL$1,
+			"--cd",
+			cwd,
+			"--sandbox",
+			"read-only",
+			"--skip-git-repo-check",
+			"--output-last-message",
+			outputPath,
+			[
+				"Return JSON only.",
+				"Respond with an object that has message, warnings, and changes.",
+				"warnings must be an empty array.",
+				"changes must contain exactly one object with path, oldText, and newText.",
+				"Use this exact payload:",
+				createPromptJsonSmokePayload()
+			].join("\n")
+		], {
+			cwd,
+			timeoutMs: MODEL_STATUS_CHECK_TIMEOUT_MS,
+			maxBuffer: 1024 * 512,
+			env
+		});
+		const normalized = (await readFile(outputPath, "utf-8")).trim().replace(/^```json\s*|\s*```$/g, "");
+		const parsed = JSON.parse(normalized);
+		if (JSON.stringify(parsed) !== createPromptJsonSmokePayload()) throw new Error("Codex CLI prompt-json smoke test payload mismatch");
+	} finally {
+		await rm(outputPath, { force: true });
+	}
+};
+const getCodexHealthCheck = async (cwd) => {
+	if (codexHealthPromise) return codexHealthPromise;
+	codexHealthPromise = (async () => {
+		let command;
+		try {
+			command = await resolveCodexCommand();
+		} catch (error) {
+			return {
+				status: "unavailable",
+				message: error instanceof Error ? error.message : "Codex CLI를 찾을 수 없습니다."
+			};
+		}
+		const env = await getCodexExecutionEnv();
+		try {
+			const { stdout, stderr } = await runCli(command, ["login", "status"], {
+				cwd,
+				timeoutMs: STATUS_CHECK_TIMEOUT_MS,
+				maxBuffer: 1024 * 128,
+				env
+			});
+			const statusText = stdout.trim() || stderr.trim();
+			if (statusText && !isAuthenticatedFromStatus(statusText)) return {
+				status: "login_required",
+				message: statusText || "Codex CLI 로그인이 필요합니다.",
+				loginCommand: "codex login",
+				command
+			};
+		} catch (error) {
+			const details = extractCliErrorDetails(error);
+			if (isCliTimeout(details)) return {
+				status: "timeout",
+				message: "Codex CLI 상태 확인 중 시간이 초과되었습니다.",
+				command
+			};
+			if (isCliCommandMissing(details)) return {
+				status: "unavailable",
+				message: "Codex CLI를 실행할 수 없습니다."
+			};
+			if (isCliCommandMissing(details)) return {
+				status: "unavailable",
+				message: "Codex CLI를 실행할 수 없습니다."
+			};
+		}
+		try {
+			await runExecSmokeTest(command, cwd, env);
+		} catch (error) {
+			const details = extractCliErrorDetails(error);
+			return {
+				status: isCliTimeout(details) ? "timeout" : "exec_failed",
+				message: isCliTimeout(details) ? "Codex CLI 답변 smoke test 중 시간이 초과되었습니다." : "Codex CLI 답변 smoke test에 실패했습니다.",
+				command
+			};
+		}
+		try {
+			await runEditSchemaSmokeTest(command, cwd, env);
+		} catch (error) {
+			if (isCliTimeout(extractCliErrorDetails(error))) return {
+				status: "timeout",
+				message: "Codex CLI edit schema smoke test 중 시간이 초과되었습니다.",
+				command
+			};
+			try {
+				await runEditPromptJsonSmokeTest(command, cwd, env);
+				return {
+					status: "ready",
+					message: "Codex CLI가 prompt-json fallback으로 응답 준비를 마쳤습니다.",
+					command,
+					model: CODEX_MODEL$1,
+					editStrategy: "prompt-json"
+				};
+			} catch {
+				return {
+					status: "schema_failed",
+					message: "Codex CLI edit 응답 스키마 smoke test에 실패했습니다.",
+					command
+				};
+			}
+		}
+		return {
+			status: "ready",
+			message: "Codex CLI가 응답 준비를 마쳤습니다.",
+			command,
+			model: CODEX_MODEL$1,
+			editStrategy: "output-schema"
+		};
+	})();
+	return codexHealthPromise;
+};
+
+//#endregion
+//#region src/bridge/internal/agents/codex-adapter.ts
+const CODEX_MODEL = process.env.DEV_COPILOT_CODEX_MODEL ?? "gpt-5.3-codex";
+const CODEX_TIMEOUT_MS = Number(process.env.DEV_COPILOT_CODEX_TIMEOUT_MS ?? DEFAULT_AGENT_TIMEOUT_MS);
+const isCodexLoginRequiredError = (error) => {
+	const details = extractCliErrorDetails(error);
+	return /not logged in|login required|authentication|unauthorized/i.test(details.merged);
+};
+const toCodexErrorMessage = (error) => {
+	const details = extractCliErrorDetails(error);
+	if (/requires a newer version of Codex/i.test(details.merged)) return ["현재 설치된 Codex CLI 버전과 모델 조합이 호환되지 않습니다.", "Codex CLI를 업데이트하거나 DEV_COPILOT_CODEX_MODEL 값을 호환 가능한 모델로 지정해 주세요."].join(" ");
+	if (/migration .* is missing in the resolved migrations/i.test(details.merged)) return ["Codex 로컬 상태 DB 마이그레이션 오류가 발생했습니다.", "Codex CLI를 최신 버전으로 업데이트한 뒤 다시 시도해 주세요."].join(" ");
+	if (/Error loading config\.toml: invalid transport/i.test(details.merged)) return [
+		"현재 Codex CLI가 Codex 설정 파일의 MCP 형식을 해석하지 못했습니다.",
+		"Dev Copilot이 호환되는 Codex 실행 파일을 자동으로 찾지 못했습니다.",
+		"Codex CLI를 업데이트한 뒤 다시 시도해 주세요."
+	].join(" ");
+	if (isCodexLoginRequiredError(error)) return "Codex CLI 로그인이 필요합니다. 터미널에서 `codex login`을 실행해 주세요.";
+	if (isCliCommandMissing(details)) return "Codex CLI를 찾을 수 없습니다. Codex CLI 설치 상태를 확인해 주세요.";
+	return details.message;
+};
+const codexAdapter = {
+	agent: "codex",
+	async warmup(cwd) {
+		await getCodexHealthCheck(cwd);
+	},
+	async run(request) {
+		const health = await getCodexHealthCheck(request.cwd);
+		if (health.status !== "ready" || !health.command) throw new Error(health.message);
+		const codexCommand = health.command;
+		const outputPath = createTempPath("dev-copilot-codex", ".json");
+		const schemaPath = createTempPath("dev-copilot-codex-schema", ".json");
+		const useOutputSchema = health.editStrategy !== "prompt-json";
+		if (request.mode === "edit" && useOutputSchema) await promises.writeFile(schemaPath, JSON.stringify(agentEditResponseSchema), "utf-8");
+		const prompt = request.mode === "edit" && !useOutputSchema ? [
+			buildAgentPrompt(request),
+			"",
+			"Return a JSON object only.",
+			"Do not include markdown fences unless strictly necessary.",
+			"The object must contain message, warnings, and changes.",
+			"warnings must be an array of strings.",
+			"changes must be an array of { path, oldText, newText } objects."
+		].join("\n") : buildAgentPrompt(request);
+		const env = await getCodexExecutionEnv();
+		const args = [
+			"exec",
+			"--ephemeral",
+			"--model",
+			CODEX_MODEL,
+			"--cd",
+			request.cwd,
+			"--sandbox",
+			"read-only",
+			"--skip-git-repo-check",
+			"--output-last-message",
+			outputPath,
+			...request.mode === "edit" && useOutputSchema ? ["--output-schema", schemaPath] : [],
+			prompt
+		];
+		try {
+			await runCli(codexCommand, args, {
+				cwd: request.cwd,
+				maxBuffer: DEFAULT_AGENT_MAX_BUFFER_BYTES,
+				timeoutMs: Number(process.env.DEV_COPILOT_AGENT_TIMEOUT_MS ?? CODEX_TIMEOUT_MS),
+				env
+			});
+			if (request.mode === "answer") return parseAnswerResponse(await promises.readFile(outputPath, "utf-8"));
+			return parseCodexEditResponse(await promises.readFile(outputPath, "utf-8"));
+		} catch (error) {
+			throw new Error(toCodexErrorMessage(error));
+		} finally {
+			await promises.rm(outputPath, { force: true });
+			await promises.rm(schemaPath, { force: true });
+		}
+	},
+	async getStatus(cwd) {
+		const health = await getCodexHealthCheck(cwd);
+		if (health.status === "ready") return createAuthenticatedStatus({
+			agent: "codex",
+			message: "Codex CLI에 로그인되어 있습니다.",
+			model: health.model ?? CODEX_MODEL
+		});
+		if (health.status === "login_required") return createLoginRequiredStatus({
+			agent: "codex",
+			message: health.message,
+			loginCommand: health.loginCommand ?? "codex login"
+		});
+		if (health.status === "unavailable") return createUnavailableStatus({
+			agent: "codex",
+			message: health.message
+		});
+		return createUnauthenticatedStatus({
+			agent: "codex",
+			message: health.message
+		});
+	}
+};
+
+//#endregion
+//#region src/bridge/features/agent-runner/resolve-agent-adapter.ts
+const adapters = {
+	codex: codexAdapter,
+	claude: claudeAdapter
+};
+const testAdapters = {};
+const resolveAgentAdapter = (agent) => {
+	return testAdapters[agent] ?? adapters[agent];
+};
+
+//#endregion
+//#region src/bridge/features/project-context/search-strategies.ts
+const execFileAsync = promisify(execFile);
+const normalize = (value) => value.replaceAll("\\", "/").replace(/^\.\//, "");
+const walk = async (rootDir, relativeDir, files, limit) => {
+	if (files.length >= limit) return;
+	const absoluteDir = path.join(rootDir, relativeDir);
+	const entries = await promises.readdir(absoluteDir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (files.length >= limit) return;
+		const relativePath = normalize(path.join(relativeDir, entry.name));
+		if ([
+			"node_modules",
+			".next",
+			".git",
+			"dist",
+			"build",
+			"coverage"
+		].some((name) => relativePath.includes(`/${name}/`) || relativePath.startsWith(`${name}/`))) continue;
+		if (entry.isDirectory()) {
+			await walk(rootDir, relativePath, files, limit);
+			continue;
+		}
+		if (entry.isFile()) files.push(relativePath);
+	}
+};
+const searchWithRg = async (config, query, limit) => {
+	const { stdout } = await execFileAsync("rg", [
+		"--line-number",
+		"--fixed-strings",
+		"--color",
+		"never",
+		"--glob",
+		"!node_modules/**",
+		"--glob",
+		"!.next/**",
+		"--glob",
+		"!.git/**",
+		query,
+		...config.allowedDirs
+	], {
+		cwd: config.rootDir,
+		maxBuffer: 1024 * 1024
+	});
+	return stdout.split("\n").filter(Boolean).slice(0, limit).map((line) => {
+		const [filePath, lineNumber, ...rest] = line.split(":");
+		return {
+			path: filePath,
+			line: Number(lineNumber),
+			text: rest.join(":").trim()
+		};
+	});
+};
+const searchWithNode = async (config, query, limit) => {
+	const files = [];
+	for (const dir of config.allowedDirs) try {
+		await walk(config.rootDir, dir, files, 500);
+	} catch {
+		continue;
+	}
+	const results = [];
+	for (const filePath of files) {
+		if (results.length >= limit) break;
+		try {
+			(await promises.readFile(path.join(config.rootDir, filePath), "utf-8")).slice(0, 1e5).split("\n").forEach((line, index) => {
+				if (results.length < limit && line.includes(query)) results.push({
+					path: filePath,
+					line: index + 1,
+					text: line.trim()
+				});
+			});
+		} catch {
+			continue;
+		}
+	}
+	return results;
+};
+const searchProjectText = async (config, query, limit) => {
+	if (!query.trim()) return [];
+	try {
+		return await searchWithRg(config, query, limit);
+	} catch {
+		return searchWithNode(config, query, limit);
+	}
+};
+const compact = (value) => value.replace(/\s+/g, "");
+const searchProjectTextIgnoringWhitespace = async (config, query, limit) => {
+	const compactQuery = compact(query);
+	if (!compactQuery) return [];
+	const files = [];
+	for (const dir of config.allowedDirs) try {
+		await walk(config.rootDir, dir, files, 500);
+	} catch {
+		continue;
+	}
+	const results = [];
+	for (const filePath of files) {
+		if (results.length >= limit) break;
+		try {
+			(await promises.readFile(path.join(config.rootDir, filePath), "utf-8")).slice(0, 1e5).split("\n").forEach((line, index) => {
+				if (results.length < limit && compact(line).includes(compactQuery)) results.push({
+					path: filePath,
+					line: index + 1,
+					text: line.trim()
+				});
+			});
+		} catch {
+			continue;
+		}
+	}
+	return results;
+};
+
+//#endregion
+//#region src/bridge/features/project-context/build-project-context.ts
+const findBySelectedText = async (rootDir, allowedDirs, text) => {
+	const normalized = text.replace(/\s+/g, " ").trim();
+	const candidates = [
+		normalized,
+		normalized.slice(0, 120),
+		...normalized.split(/[.!?]\s+/).filter((item) => item.length > 12)
+	];
+	for (const candidate of candidates) {
+		const results = await searchProjectText({
+			rootDir,
+			allowedDirs
+		}, candidate, 8);
+		if (results.length) return {
+			query: candidate,
+			results
+		};
+	}
+	for (const candidate of candidates) {
+		const results = await searchProjectTextIgnoringWhitespace({
+			rootDir,
+			allowedDirs
+		}, candidate, 8);
+		if (results.length) return {
+			query: `${candidate} (ignore-whitespace)`,
+			results
+		};
+	}
+	return {
+		query: normalized,
+		results: []
+	};
+};
+const buildCopilotProjectContext = async (rootDir, allowedDirs, params) => {
+	const routeQuery = params.route?.startsWith("/") ? `app${params.route === "/" ? "" : params.route}/page.tsx` : params.route;
+	const selectedText = params.selectedText?.trim();
+	const textMatches = selectedText ? await findBySelectedText(rootDir, allowedDirs, selectedText) : {
+		query: "",
+		results: []
+	};
+	const routeMatches = routeQuery ? await searchProjectText({
+		rootDir,
+		allowedDirs
+	}, routeQuery, 5) : [];
+	return JSON.stringify({
+		project: { allowedDirs },
+		requestContext: {
+			route: params.route,
+			fileHints: params.fileHints
+		},
+		selectedTextLookup: textMatches,
+		routeLookup: routeMatches,
+		guidance: "selectedTextLookup.results의 path와 text를 우선 사용해 path/oldText/newText 수정안을 작성하세요."
+	}, null, 2);
+};
+
+//#endregion
+//#region src/bridge/features/chat/chat-route.ts
+const isCopilotAgent$1 = (value) => {
+	return value === "codex" || value === "claude";
+};
+const handleChatRoute = async (request, response, config) => {
+	const payload = await readJsonBody(request);
+	const effectiveAllowedPaths = resolveAllowedPathsWithSrcFallback(config, payload.context?.fileHints);
+	const adapter = resolveAgentAdapter(isCopilotAgent$1(payload.context?.agent) ? payload.context.agent : config.agent);
+	if (!payload.prompt?.trim()) {
+		sendJson(response, config, 400, { error: "프롬프트를 입력해 주세요." });
+		return;
+	}
+	const projectContext = await buildCopilotProjectContext(config.rootDir, effectiveAllowedPaths, {
+		selectedText: payload.selectedText,
+		route: payload.context?.route,
+		fileHints: payload.context?.fileHints
+	});
+	const agentResponse = await adapter.run({
+		selectedText: payload.selectedText ?? "",
+		prompt: payload.prompt,
+		mode: payload.mode,
+		route: payload.context?.route,
+		fileHints: payload.context?.fileHints,
+		previousResponse: payload.context?.previousResponse,
+		projectContext,
+		cwd: config.rootDir
+	});
+	if (payload.mode === "answer") {
+		sendJson(response, config, 200, {
+			message: agentResponse.message,
+			warnings: agentResponse.warnings
+		});
+		return;
+	}
+	let patchPreview = "";
+	try {
+		patchPreview = await buildPatchPreview(agentResponse.changes, config, effectiveAllowedPaths);
+	} catch (error) {
+		sendJson(response, config, 200, {
+			message: agentResponse.message ?? "에이전트가 수정안을 만들었지만 실제 파일 내용과 매칭하지 못했습니다.",
+			warnings: [...agentResponse.warnings ?? [], error instanceof Error ? error.message : "수정안 생성에 실패했습니다."]
+		});
+		return;
+	}
+	if (!patchPreview) {
+		sendJson(response, config, 200, {
+			message: agentResponse.message ?? "패치 제안을 생성하지 못했습니다.",
+			warnings: [...agentResponse.warnings ?? [], "적용 가능한 변경 목록이 없어 패치 미리보기와 적용 버튼을 만들 수 없습니다."]
+		});
+		return;
+	}
+	try {
+		await validatePatchPreview(patchPreview, config, effectiveAllowedPaths);
+	} catch (error) {
+		sendJson(response, config, 200, {
+			message: agentResponse.message ?? "에이전트가 수정안을 만들었지만 적용 가능한 diff 형식이 아닙니다.",
+			patchPreview,
+			warnings: [...agentResponse.warnings ?? [], error instanceof Error ? error.message : "patch 검증에 실패했습니다."]
+		});
+		return;
+	}
+	const patch = saveProposedPatch(patchPreview, effectiveAllowedPaths);
+	sendJson(response, config, 200, {
+		message: agentResponse.message ?? "에이전트가 패치 미리보기를 생성했습니다.",
+		patchPreview,
+		patchId: patch.patchId,
+		warnings: agentResponse.warnings ?? []
+	});
+};
+
+//#endregion
+//#region src/bridge/features/status/status-route.ts
+const isCopilotAgent = (value) => {
+	return value === "codex" || value === "claude";
+};
+const handleStatusRoute = async (_request, response, config, url) => {
+	const queryAgent = url.searchParams.get("agent");
+	sendJson(response, config, 200, await resolveAgentAdapter(isCopilotAgent(queryAgent) ? queryAgent : config.agent).getStatus(config.rootDir));
+};
+
+//#endregion
+//#region src/bridge/shared/http/error-mapper.ts
+const toBridgeErrorMessage = (error) => {
+	if (error instanceof Error) return error.message;
+	return "브리지 서버 처리 중 오류가 발생했습니다.";
+};
+
+//#endregion
+//#region src/bridge/app/create-bridge-server.ts
+const createDevCopilotBridgeServer = (config) => {
+	return createServer(async (request, response) => {
+		const method = request.method ?? "GET";
+		const url = new URL(request.url ?? "/", `http://${config.host}:${config.port}`);
+		if (method === "OPTIONS") {
+			response.writeHead(204, createCorsHeaders(config));
+			response.end();
+			return;
+		}
+		try {
+			if (method === "GET" && url.pathname === "/status") {
+				await handleStatusRoute(request, response, config, url);
+				return;
+			}
+			if (method === "POST" && url.pathname === "/chat") {
+				await handleChatRoute(request, response, config);
+				return;
+			}
+			if (method === "POST" && url.pathname === "/apply") {
+				await handleApplyRoute(request, response, config);
+				return;
+			}
+			sendJson(response, config, 404, { error: "지원하지 않는 경로입니다." });
+		} catch (error) {
+			sendJson(response, config, 500, { error: toBridgeErrorMessage(error) });
+		}
+	});
+};
+
+//#endregion
+//#region src/bridge/app/run-bridge-cli.ts
+const resolveAgent = (value) => {
+	if (value === "claude") return "claude";
+	return "codex";
+};
+const runDevCopilotBridgeCli = async (argv) => {
+	const portFlagIndex = argv.findIndex((value) => value === "-p");
+	const portFlagValue = portFlagIndex >= 0 ? argv[portFlagIndex + 1] : void 0;
+	const positionalPort = argv.find((value) => /^\d+$/.test(value));
+	const resolvedPort = portFlagValue ? Number(portFlagValue) : positionalPort ? Number(positionalPort) : Number(process.env.DEV_COPILOT_BRIDGE_PORT ?? 3339);
+	const positionalAgent = argv.find((value) => value === "codex" || value === "claude");
+	const config = createDevCopilotBridgeConfig({
+		rootDir: process.cwd(),
+		host: process.env.DEV_COPILOT_BRIDGE_HOST,
+		port: Number.isFinite(resolvedPort) ? resolvedPort : 3339,
+		corsOrigin: process.env.DEV_COPILOT_BRIDGE_CORS_ORIGIN ?? "*",
+		agent: resolveAgent(positionalAgent),
+		allowedPaths: (process.env.DEV_COPILOT_ALLOWED_PATHS ?? "app,src,widgets,features,entities,shared,components").split(",").map((value) => value.trim()).filter(Boolean)
+	});
+	const server = createDevCopilotBridgeServer(config);
+	await new Promise((resolve, reject) => {
+		server.once("error", (error) => {
+			reject(error);
+		});
+		server.listen(config.port, config.host, () => {
+			process.stdout.write(`[dev-copilot-bridge] listening on http://${config.host}:${config.port}\n`);
+			resolve();
+		});
+	});
+	resolveAgentAdapter(config.agent).warmup?.(config.rootDir).catch((error) => {
+		process.stderr.write(`[dev-copilot-bridge] startup health check failed: ${error instanceof Error ? error.message : String(error)}\n`);
+	});
+};
+
+//#endregion
+export { createDevCopilotBridgeServer as n, createDevCopilotBridgeConfig as r, runDevCopilotBridgeCli as t };
+//# sourceMappingURL=run-bridge-cli-DVLGcVgq.mjs.map