@dev-guard/cli 0.1.0

package/dist/review.js

@@ -0,0 +1,653 @@
+import { defaultConfig, analyzeGeneratedDiffDrift, filterDiffTextForFiles, formatInferredDiffIntentClusters, inferredIntentToRequirement, inferredIntentToTaskType, scoreWorkflowQuality, filterDevGuardContextFiles, buildReviewFixPrompt, buildImpactHints, generateReviewResult, isAlwaysIgnoredContextPath, NoneAIProvider, OpenAIProvider } from "@dev-guard/core";
+import { copyTextToClipboard } from "./clipboard.js";
+import { loadConfig, readOpenAIApiKey } from "./config.js";
+import { fromRoot, readJsonFile, readTextFile, writeTextFile } from "./fs.js";
+import { getCommitGitChanges, getDiffForChangeFiles, getGitChanges, getStagedGitChanges } from "./git.js";
+import { formatProjectIdentityWarning, loadCurrentProjectIdentity, readStoredProjectIdentity, sameProjectIdentity } from "./project-identity.js";
+import { filterRelevantMarkdown } from "./rule-filter.js";
+import { updateRunLog } from "./runs.js";
+import { recordDriftTelemetry } from "./drift-telemetry.js";
+import { formatEffectiveTaskBasis, formatEffectiveRunSummary, formatEffectiveTaskContext, resolveEffectiveTaskContext } from "./effective-task.js";
+const untrackedFileLimit = 5;
+const perFileCharacterLimit = 4000;
+const totalUntrackedCharacterLimit = 12000;
+export async function runReview(root, args) {
+    const options = parseReviewOptions(args);
+    const review = await executeReview(root, { ...options });
+    if (!review) {
+        return;
+    }
+    const fixPrompt = buildReviewFixPrompt({
+        review: review.result,
+        taskMarkdown: review.taskMarkdown,
+        changedFiles: review.changedFiles,
+        changeFiles: review.changeFiles
+    });
+    if (options.output) {
+        await writeTextFile(fromRoot(root, options.output), `${review.result.markdown}\n`);
+        console.error(`dev-guard review: wrote ${options.output}`);
+    }
+    if (options.copyFix) {
+        const copyResult = await copyTextToClipboard(review.result.fixPrompt);
+        if (copyResult.ok) {
+            console.error("dev-guard review: copied Codex 재수정 프롬프트 to clipboard.");
+        }
+        else {
+            console.error(`dev-guard review: clipboard copy failed (${copyResult.reason}).`);
+        }
+    }
+    if (options.fixPrompt && options.copy) {
+        const copyResult = await copyTextToClipboard(fixPrompt.promptText);
+        if (copyResult.ok) {
+            console.error("dev-guard review: copied generated fix prompt to clipboard.");
+        }
+        else {
+            console.error(`dev-guard review: fix prompt clipboard copy failed (${copyResult.reason}).`);
+        }
+    }
+    if (review.runLog) {
+        await updateRunLog(root, review.runLog.id, {
+            status: "reviewed",
+            reviewResult: review.result.markdown,
+            fixPrompt: fixPrompt.promptText,
+            targetFiles: review.changedFiles,
+            reason: review.result.status
+        });
+    }
+    console.log(review.result.markdown);
+    if (options.fixPrompt) {
+        console.log("\n---\n");
+        console.log(fixPrompt.promptText);
+    }
+}
+export async function runFixPrompt(root, args) {
+    const options = parseFixPromptOptions(args);
+    const review = await executeReview(root, {
+        includeContextFiles: options.includeContextFiles,
+        staged: options.staged,
+        commit: options.commit,
+        runId: options.runId,
+        noRun: options.noRun
+    });
+    if (!review) {
+        return;
+    }
+    const fixPrompt = buildReviewFixPrompt({
+        review: review.result,
+        taskMarkdown: review.taskMarkdown,
+        changedFiles: review.changedFiles,
+        changeFiles: review.changeFiles
+    });
+    if (options.output) {
+        await writeTextFile(fromRoot(root, options.output), `${fixPrompt.promptText}\n`);
+        console.error(`dev-guard fix-prompt: wrote ${options.output}`);
+    }
+    if (options.copy) {
+        const copyResult = await copyTextToClipboard(fixPrompt.promptText);
+        if (copyResult.ok) {
+            console.error("dev-guard fix-prompt: copied to clipboard.");
+        }
+        else {
+            console.error(`dev-guard fix-prompt: clipboard copy failed (${copyResult.reason}).`);
+        }
+    }
+    if (review.runLog) {
+        await updateRunLog(root, review.runLog.id, {
+            status: "reviewed",
+            reviewResult: review.result.markdown,
+            fixPrompt: fixPrompt.promptText,
+            targetFiles: review.changedFiles,
+            reason: review.result.status
+        });
+    }
+    console.log(fixPrompt.promptText);
+}
+async function executeReview(root, options) {
+    const rawGitChanges = await loadReviewGitChanges(root, options);
+    const reviewChangeFiles = filterDevGuardContextFiles(rawGitChanges.changeFiles, options.includeContextFiles);
+    const reviewChangedFiles = [...new Set(reviewChangeFiles.map((file) => file.path))].sort();
+    if (reviewChangeFiles.length === 0) {
+        console.log("dev-guard review");
+        console.log("");
+        console.log("리뷰할 변경 사항 없음");
+        if (rawGitChanges.changeFiles.length > 0 && !options.includeContextFiles) {
+            console.log("Context files changed only. Include them with --include-context-files.");
+        }
+        return undefined;
+    }
+    const resolvedConfig = await loadConfig(root);
+    const config = resolvedConfig.config;
+    const providerName = config.ai?.provider ?? defaultConfig.ai.provider ?? "none";
+    const model = config.ai?.model ?? defaultConfig.ai.model ?? "gpt-4o-mini";
+    const openAIApiKey = readOpenAIApiKey();
+    const currentIdentity = await loadCurrentProjectIdentity(root).catch(() => undefined);
+    const [taskMarkdown, rulesMarkdown, mistakesMarkdown, projectStateMarkdown, decisionsMarkdown, memory, diffText, codeGraph] = await Promise.all([
+        readTextFile(fromRoot(root, ".devguard/task.md")),
+        readTextFile(fromRoot(root, ".devguard/rules.md")),
+        readTextFile(fromRoot(root, ".devguard/mistakes.md")),
+        readTextFile(fromRoot(root, "docs/PROJECT_STATE.md")),
+        readTextFile(fromRoot(root, "docs/DECISIONS.md")),
+        loadReviewMemory(root, reviewChangedFiles, currentIdentity),
+        getDiffForChangeFiles(root, reviewChangeFiles, { stagedOnly: options.staged, commitRef: options.commit }),
+        readJsonFile(fromRoot(root, ".devguard/code-graph.json"), [])
+    ]);
+    const impactHints = buildImpactHints(reviewChangedFiles, codeGraph);
+    const effective = await resolveEffectiveTaskContext({
+        root,
+        taskMarkdown,
+        gitChanges: { diffText, changedFiles: reviewChangedFiles, changeFiles: reviewChangeFiles },
+        reviewChangeFiles,
+        changedFiles: reviewChangedFiles,
+        codeGraph,
+        currentIdentity,
+        options: {
+            forceTask: options.forceTask,
+            fromDiff: options.fromDiff,
+            noRun: options.noRun,
+            runId: options.runId
+        }
+    });
+    for (const line of formatEffectiveTaskContext("dev-guard review", effective)) {
+        console.error(line);
+    }
+    for (const line of formatEffectiveTaskBasis(effective)) {
+        console.error(`dev-guard review: ${line}`);
+    }
+    if (effective.runSelection.warning) {
+        console.error(`dev-guard review: warning: ${effective.runSelection.warning}`);
+    }
+    const inferredClusters = effective.inferredTask;
+    const inferredIntent = inferredClusters.primaryIntent;
+    const effectiveTaskMarkdown = effective.effectiveTaskMarkdown;
+    // Step 6: Filter rules against effective task
+    const ruleRelevanceText = [effectiveTaskMarkdown, reviewChangedFiles.join("\n"), projectStateMarkdown, decisionsMarkdown].join("\n");
+    const filteredRules = filterRelevantMarkdown(rulesMarkdown, ruleRelevanceText, currentIdentity);
+    const filteredMistakes = filterRelevantMarkdown(mistakesMarkdown, ruleRelevanceText, currentIdentity);
+    const untrackedFileContexts = await collectUntrackedFileContexts(root, reviewChangeFiles.filter((file) => file.source === "untracked").map((file) => file.path), extractReviewKeywords(effectiveTaskMarkdown));
+    // Effective run: excluded when diff-first to prevent old requirement contamination
+    const effectiveRunLog = effective.effectiveRunLog;
+    const effectiveRunSummary = formatEffectiveRunSummary(effective);
+    if (options.heuristic || providerName === "none") {
+        console.error("dev-guard review");
+        console.error("- review mode: heuristic");
+        console.error(`- provider: ${providerName}`);
+        console.error(`- model: ${model}`);
+        console.error(`- config source: ${resolvedConfig.source}`);
+        console.error(`- API key source: ${resolvedConfig.env.apiKey.selectedKey ?? "none"}`);
+        if (providerName === "none" && !options.heuristic) {
+            console.error("- note: AI provider is none; using local heuristic fallback. Use --heuristic to request this explicitly.");
+        }
+        const heuristicResult = generateHeuristicReview({
+            changedFiles: reviewChangedFiles,
+            changeFiles: reviewChangeFiles,
+            diffText,
+            taskMarkdown: effectiveTaskMarkdown,
+            inferredClusters,
+            taskAvailable: effective.useTaskMarkdown,
+            anchorStale: !effective.useTaskMarkdown && (effective.anchorStatus === "stale" || effective.mode === "diff-first_uncertain"),
+            anchorAbsent: !effective.useTaskMarkdown && effective.anchorStatus === "absent",
+            anchorMode: effective.mode,
+            untrackedFileContexts,
+            impactHints,
+            providerName
+        });
+        const drift = analyzeGeneratedDiffDrift({
+            requirementText: effective.useTaskMarkdown ? taskMarkdown : inferredIntentToRequirement(inferredIntent),
+            taskMarkdown: effective.useTaskMarkdown ? taskMarkdown : "",
+            diffText: filterDiffTextForFiles(diffText, inferredIntent.changedFiles),
+            changedFiles: inferredIntent.changedFiles,
+            changeFiles: reviewChangeFiles.filter((file) => inferredIntent.changedFiles.includes(file.path)),
+            taskType: effective.useTaskMarkdown ? undefined : inferredIntentToTaskType(inferredIntent)
+        });
+        await recordDriftTelemetry(root, {
+            result: drift,
+            source: "review:heuristic",
+            subtype: extractTaskSubtype(effective.useTaskMarkdown ? taskMarkdown : effectiveTaskMarkdown)
+        }).catch((error) => console.error(`dev-guard review: telemetry warning: ${errorMessage(error)}`));
+        return {
+            result: heuristicResult,
+            taskMarkdown: effectiveTaskMarkdown,
+            changedFiles: reviewChangedFiles,
+            changeFiles: reviewChangeFiles,
+            runLog: effectiveRunLog
+        };
+    }
+    if (providerName === "openai" && !openAIApiKey) {
+        if (options.heuristic) {
+            // Unreachable because heuristic returns above, but keeps the error path explicit.
+            throw new Error("OpenAI API key 환경변수가 없습니다. heuristic review에는 API key가 필요 없습니다.");
+        }
+        throw new Error("OpenAI API key 환경변수가 없습니다. API key는 config에 저장하지 말고 `DEV_GUARD_OPENAI_API_KEY` 또는 `OPENAI_API_KEY`로 설정해 주세요. 로컬 검토는 `dev-guard review --heuristic`를 사용하세요.");
+    }
+    const provider = providerName === "openai"
+        ? new OpenAIProvider({
+            apiKey: openAIApiKey ?? "",
+            model,
+            temperature: config.ai?.temperature,
+            maxTokens: config.ai?.maxTokens,
+            reasoningEffort: config.ai?.reasoningEffort,
+            baseURL: config.ai?.baseURL
+        })
+        : new NoneAIProvider();
+    const result = await generateReviewResult(provider, {
+        taskMarkdown: effectiveTaskMarkdown,
+        rulesMarkdown: filteredRules.filteredMarkdown,
+        mistakesMarkdown: filteredMistakes.filteredMarkdown,
+        projectStateMarkdown,
+        decisionsMarkdown,
+        changedFiles: reviewChangedFiles,
+        changeFiles: reviewChangeFiles,
+        diffText,
+        untrackedFileContexts,
+        memorySummaries: memory.summaries,
+        projectMapMarkdown: memory.projectMapMarkdown,
+        runLog: effectiveRunLog,
+        runSelectionSummary: effectiveRunSummary,
+        impactHints
+    }, model);
+    const drift = analyzeGeneratedDiffDrift({
+        requirementText: effective.useTaskMarkdown ? taskMarkdown : inferredIntentToRequirement(inferredIntent),
+        taskMarkdown: effective.useTaskMarkdown ? taskMarkdown : "",
+        diffText: filterDiffTextForFiles(diffText, inferredIntent.changedFiles),
+        changedFiles: inferredIntent.changedFiles,
+        changeFiles: reviewChangeFiles.filter((file) => inferredIntent.changedFiles.includes(file.path)),
+        taskType: effective.useTaskMarkdown ? undefined : inferredIntentToTaskType(inferredIntent)
+    });
+    await recordDriftTelemetry(root, {
+        result: drift,
+        source: "review:ai",
+        subtype: extractTaskSubtype(effective.useTaskMarkdown ? taskMarkdown : effectiveTaskMarkdown)
+    }).catch((error) => console.error(`dev-guard review: telemetry warning: ${errorMessage(error)}`));
+    return {
+        result,
+        taskMarkdown: effectiveTaskMarkdown,
+        changedFiles: reviewChangedFiles,
+        changeFiles: reviewChangeFiles,
+        runLog: effectiveRunLog
+    };
+}
+function parseReviewOptions(args) {
+    const output = readOption(args, "--output");
+    const copyFix = args.includes("--copy-fix");
+    const copy = args.includes("--copy");
+    const fixPrompt = args.includes("--fix-prompt");
+    const includeContextFiles = args.includes("--include-context-files");
+    const staged = args.includes("--staged");
+    const commit = readOption(args, "--commit");
+    const runId = readOption(args, "--run");
+    const noRun = args.includes("--no-run");
+    const heuristic = args.includes("--heuristic");
+    const forceTask = args.includes("--task");
+    const fromDiff = args.includes("--from-diff");
+    if (staged && commit) {
+        throw new Error("--staged와 --commit은 함께 사용할 수 없습니다.");
+    }
+    if (noRun && runId) {
+        throw new Error("--no-run과 --run은 함께 사용할 수 없습니다.");
+    }
+    if (forceTask && fromDiff) {
+        throw new Error("--task와 --from-diff는 함께 사용할 수 없습니다.");
+    }
+    return {
+        output,
+        copyFix,
+        copy,
+        fixPrompt,
+        includeContextFiles,
+        staged,
+        commit,
+        runId,
+        noRun,
+        heuristic,
+        forceTask,
+        fromDiff
+    };
+}
+function parseFixPromptOptions(args) {
+    const output = readOption(args, "--output");
+    const copy = args.includes("--copy");
+    const includeContextFiles = args.includes("--include-context-files");
+    const staged = args.includes("--staged");
+    const commit = readOption(args, "--commit");
+    const runId = readOption(args, "--run");
+    const noRun = args.includes("--no-run");
+    if (staged && commit) {
+        throw new Error("--staged와 --commit은 함께 사용할 수 없습니다.");
+    }
+    if (noRun && runId) {
+        throw new Error("--no-run과 --run은 함께 사용할 수 없습니다.");
+    }
+    return {
+        output,
+        copy,
+        includeContextFiles,
+        staged,
+        commit,
+        runId,
+        noRun
+    };
+}
+function generateHeuristicReview(input) {
+    const findings = [];
+    const primaryFiles = input.inferredClusters?.primaryIntent.changedFiles ?? input.changedFiles;
+    const primaryChangeFiles = input.changeFiles.filter((file) => primaryFiles.includes(file.path));
+    const primaryDiff = input.inferredClusters ? filterDiffTextForFiles(input.diffText, primaryFiles) : input.diffText;
+    const drift = analyzeGeneratedDiffDrift({
+        requirementText: input.taskAvailable || !input.inferredClusters ? input.taskMarkdown : inferredIntentToRequirement(input.inferredClusters.primaryIntent),
+        taskMarkdown: input.taskAvailable || !input.inferredClusters ? input.taskMarkdown : "",
+        diffText: primaryDiff,
+        changedFiles: primaryFiles,
+        changeFiles: primaryChangeFiles,
+        taskType: input.taskAvailable || !input.inferredClusters ? undefined : inferredIntentToTaskType(input.inferredClusters.primaryIntent)
+    });
+    const quality = scoreWorkflowQuality({
+        drift,
+        changedFiles: primaryFiles,
+        diffText: primaryDiff,
+        changeFiles: primaryChangeFiles
+    });
+    const addedLines = input.diffText
+        .split("\n")
+        .filter((line) => line.startsWith("+") && !line.startsWith("+++"))
+        .map((line) => line.slice(1));
+    const removedLines = input.diffText
+        .split("\n")
+        .filter((line) => line.startsWith("-") && !line.startsWith("---"))
+        .map((line) => line.slice(1));
+    const taskType = extractTaskType(input.taskMarkdown);
+    const largeChange = input.changedFiles.length >= 12 || input.diffText.length > 30000;
+    const hasMarkdownMarkerProblem = /dev-guard:update:start/.test(input.diffText) && !/dev-guard:update:end/.test(input.diffText);
+    const i18nMigration = taskType === "i18n" ? detectLocaleResourceMigration(input.changedFiles, input.diffText, addedLines, removedLines) : false;
+    const addedKoreanOutsideLocale = taskType === "i18n" &&
+        addedLines.some((line) => /[가-힣]/.test(line)) &&
+        !input.changedFiles.some((file) => /(^|\/)(messages|locales?|i18n)\//i.test(file)) &&
+        !i18nMigration;
+    const duplicateHeadings = detectDuplicateMarkdownHeadings([...addedLines, ...input.untrackedFileContexts.map((context) => context.excerpt).join("\n")]);
+    if (largeChange) {
+        findings.push({ severity: "warning", text: "변경 파일 수나 diff 크기가 큽니다. 이번 task 범위 안의 변경인지 확인하세요." });
+    }
+    if (input.changeFiles.some((file) => file.source === "untracked")) {
+        findings.push({ severity: "info", text: "untracked 파일이 포함되어 있습니다. 새 파일이 commit 대상인지 확인하세요." });
+    }
+    if (addedKoreanOutsideLocale) {
+        findings.push({ severity: "critical", text: "i18n 작업에서 locale resource 밖에 한국어 사용자 노출 문자열이 추가된 정황이 있습니다." });
+    }
+    if (i18nMigration) {
+        findings.push({ severity: "info", text: "Korean copy moved to locale resource; default locale preserved." });
+    }
+    if (hasMarkdownMarkerProblem) {
+        findings.push({ severity: "critical", text: "dev-guard managed markdown marker가 깨진 정황이 있습니다." });
+    }
+    if (duplicateHeadings.length > 0) {
+        findings.push({ severity: "warning", text: `중복 markdown heading 후보: ${duplicateHeadings.slice(0, 5).join(", ")}` });
+    }
+    if (removedLines.length > 120 && addedLines.length < 10) {
+        findings.push({ severity: "warning", text: "삭제 라인이 많고 대체 추가가 적습니다. 의도한 삭제인지 확인하세요." });
+    }
+    if (drift.severity !== "low") {
+        findings.push({
+            severity: drift.severity === "high" ? "critical" : "warning",
+            text: `Potential drift detected: ${drift.reasons.join("; ") || "domain mismatch"} (score ${drift.driftScore})`
+        });
+    }
+    const actionableMixedDetails = input.inferredClusters?.secondaryDetails.filter((detail) => detail.severity !== "info") ?? [];
+    if (input.inferredClusters && actionableMixedDetails.length > 0) {
+        findings.push({
+            severity: input.inferredClusters.mixedRisk === "high" ? "warning" : "info",
+            text: `mixed diff clusters: ${formatInferredDiffIntentClusters(input.inferredClusters)}`
+        });
+    }
+    for (const hint of input.impactHints.filter((item) => item.importedByCount >= 5)) {
+        findings.push({
+            severity: "warning",
+            text: `dependency impact: ${hint.file} is imported by ${hint.importedByCount} files (${hint.affectedAreas.join(", ") || "unknown"}).`
+        });
+    }
+    const status = findings.some((finding) => finding.severity === "critical")
+        ? "needs_changes"
+        : findings.some((finding) => finding.severity === "warning")
+            ? "warning"
+            : "pass";
+    const findingLines = findings.length > 0 ? findings.map((finding) => `- [${finding.severity}] ${finding.text}`).join("\n") : "- 로컬 휴리스틱에서 blocking 문제를 찾지 못했습니다.";
+    const fixPrompt = status === "pass"
+        ? "재수정 프롬프트 불필요: heuristic review status가 pass입니다."
+        : [
+            "현재 diff를 로컬 휴리스틱 지적 기준으로 다시 확인해 주세요.",
+            "원래 요구사항과 직접 관련 없는 변경만 되돌리고, 필요한 수정은 최소 범위로 유지하세요.",
+            `확인 파일: ${input.changedFiles.slice(0, 12).join(", ") || "none"}`,
+            "blocking/warning 항목을 먼저 해결한 뒤 pnpm run build를 실행하세요."
+        ].join("\n");
+    const taskSourceNote = input.inferredClusters
+        ? input.anchorAbsent
+            ? `- task anchor absent; diff intent 기준으로 검토했습니다: ${formatInferredDiffIntentClusters(input.inferredClusters)}`
+            : input.anchorMode === "diff-first_uncertain"
+                ? `- task.md uncertain; diff intent 기준으로 검토했습니다: ${formatInferredDiffIntentClusters(input.inferredClusters)}`
+                : input.anchorStale
+                    ? `- task.md stale; diff intent 기준으로 검토했습니다: ${formatInferredDiffIntentClusters(input.inferredClusters)}`
+                    : input.taskAvailable
+                        ? `- task.md 기준으로 검토했습니다. diff clusters: ${formatInferredDiffIntentClusters(input.inferredClusters)}`
+                        : `- 원본 task prompt 없이 diff intent를 기준으로 검토했습니다: ${formatInferredDiffIntentClusters(input.inferredClusters)}`
+        : "- task.md 기준으로 검토했습니다.";
+    return {
+        status,
+        fixPrompt,
+        markdown: `status: ${status}
+
+## 결론
+${status === "pass" ? "로컬 휴리스틱 기준으로 커밋을 막을 명확한 문제는 없습니다." : "로컬 휴리스틱 기준으로 확인할 문제가 있습니다."}
+
+## 요구사항 충족 여부
+- AI semantic review는 실행하지 않았습니다.
+- 현재 결과는 diff/static heuristic 기준입니다.
+${taskSourceNote}
+
+## 범위 초과 수정
+${largeChange ? "- broad diff입니다. task scope와 변경 파일을 다시 비교하세요." : "- 뚜렷한 broad scope 신호는 없습니다."}
+
+## 규칙 위반 가능성
+${findingLines}
+
+## Drift 분석
+- severity: ${drift.severity}
+- score: ${drift.driftScore}
+- requirement domains: ${drift.requirementDomains.join(", ") || "none"}
+- diff domains: ${drift.generatedDomains.join(", ") || "none"}
+- requirement zones: ${drift.requirementZones.join(", ") || "none"}
+- diff zones: ${drift.generatedZones.join(", ") || "none"}
+- reasons: ${drift.reasons.join("; ") || "none"}
+
+## Impact 분석
+${formatReviewImpactHints(input.impactHints)}
+
+## Workflow Quality Score
+- Requirement Alignment Score: ${quality.requirementAlignment}
+- Drift Risk: ${quality.driftRisk}
+- Scope Safety: ${quality.scopeSafety}
+- Confidence: ${quality.confidence}
+
+## 반복 실수 가능성
+- ${input.providerName === "none" ? "provider 없이 실행된 fallback review입니다. 의미 검토가 필요하면 provider 설정 후 AI review를 실행하세요." : "명시적으로 요청한 heuristic review입니다. AI semantic review가 필요하면 --heuristic 없이 실행하세요."}
+
+## 확인이 필요한 파일
+${input.changedFiles.length > 0 ? input.changedFiles.slice(0, 20).map((file) => `- ${file}`).join("\n") : "- 없음"}
+
+## Codex 재수정 프롬프트
+${fixPrompt}
+
+## 커밋 가능 여부
+${status === "pass" ? "- 가능: build/check 결과를 추가 확인하세요." : "- 보류: 위 항목을 확인하세요."}`
+    };
+}
+function detectLocaleResourceMigration(changedFiles, diffText, addedLines, removedLines) {
+    const hasKoResource = changedFiles.some((file) => /(^|\/)(ko|ko-KR)\.(json|ts|tsx|js|yaml|yml)$/i.test(file) || /(^|\/)(messages|locales?|translations|dictionaries)\/.*ko/i.test(file));
+    const hasEnResource = changedFiles.some((file) => /(^|\/)(en|en-US)\.(json|ts|tsx|js|yaml|yml)$/i.test(file) || /(^|\/)(messages|locales?|translations|dictionaries)\/.*en/i.test(file));
+    const removedKoreanCopy = removedLines.some((line) => /["'`][^"'`]*[가-힣][^"'`]*["'`]/.test(line));
+    const koResourceCopy = addedLines.some((line) => /["'][\w.-]+["']\s*:\s*["'][^"']*[가-힣]/.test(line) || /ko\s*[:=]/i.test(line) && /[가-힣]/.test(line));
+    const tCallAdded = addedLines.some((line) => /\bt\(\s*["'][\w.-]+["']\s*\)|useTranslations|useI18n|getMessage|translate\(/i.test(line));
+    const defaultKo = /defaultLocale\s*[:=]\s*["']ko(?:-KR)?["']|fallbackLocale\s*[:=]\s*["']ko(?:-KR)?["']|locale\s*\?\?\s*["']ko(?:-KR)?["']/i.test(diffText);
+    const defaultEnAdded = addedLines.some((line) => /defaultLocale\s*[:=]\s*["']en(?:-US)?["']|fallbackLocale\s*[:=]\s*["']en(?:-US)?["']|locale\s*\?\?\s*["']en(?:-US)?["']/i.test(line));
+    return hasKoResource && hasEnResource && removedKoreanCopy && koResourceCopy && tCallAdded && (defaultKo || !defaultEnAdded);
+}
+function extractTaskType(markdown) {
+    const match = markdown.match(/type:\s*([a-z_]+)/i);
+    return match?.[1] ?? "";
+}
+function extractTaskSubtype(markdown) {
+    return markdown.match(/subtype:\s*([a-z_.]+)/i)?.[1];
+}
+function detectDuplicateMarkdownHeadings(lines) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const line of lines) {
+        const match = line.match(/^#{1,4}\s+(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const heading = match[1].trim().toLowerCase();
+        if (seen.has(heading)) {
+            duplicates.add(match[1].trim());
+        }
+        seen.add(heading);
+    }
+    return [...duplicates];
+}
+function formatReviewImpactHints(impactHints) {
+    if (impactHints.length === 0) {
+        return "- dependency impact hint 없음";
+    }
+    return impactHints
+        .slice(0, 5)
+        .map((hint) => `- ${hint.file}: imported by ${hint.importedByCount}; affected areas: ${hint.affectedAreas.join(", ") || "unknown"}`)
+        .join("\n");
+}
+async function loadReviewGitChanges(root, options) {
+    if (options.commit) {
+        return getCommitGitChanges(root, options.commit);
+    }
+    if (options.staged) {
+        return getStagedGitChanges(root);
+    }
+    return getGitChanges(root);
+}
+async function loadReviewMemory(root, changedFiles, currentIdentity) {
+    const [summaries, projectMapMarkdown, storedIdentity] = await Promise.all([
+        readJsonFile(fromRoot(root, ".devguard/file-summaries.json"), []),
+        readTextFile(fromRoot(root, ".devguard/project-map.md")),
+        readStoredProjectIdentity(root)
+    ]);
+    if (summaries.length > 0 && currentIdentity && !sameProjectIdentity(currentIdentity, storedIdentity)) {
+        console.error(`dev-guard review: warning: ${formatProjectIdentityWarning("scan cache", currentIdentity, storedIdentity)}`);
+        return { summaries: [], projectMapMarkdown: "" };
+    }
+    const changedFileSet = new Set(changedFiles);
+    const relatedSummaries = summaries
+        .filter((summary) => !isAlwaysIgnoredContextPath(summary.path))
+        .filter((summary) => changedFileSet.has(summary.path) || summary.relatedFiles.some((file) => changedFileSet.has(file)))
+        .slice(0, 12)
+        .map((summary) => ({
+        path: summary.path,
+        role: summary.role,
+        keywords: summary.keywords,
+        features: summary.features
+    }));
+    return {
+        summaries: relatedSummaries,
+        projectMapMarkdown
+    };
+}
+async function collectUntrackedFileContexts(root, paths, keywords) {
+    const contexts = [];
+    let totalLength = 0;
+    for (const path of paths.filter(isTextReviewFile).slice(0, untrackedFileLimit)) {
+        if (totalLength >= totalUntrackedCharacterLimit) {
+            break;
+        }
+        const remaining = totalUntrackedCharacterLimit - totalLength;
+        const content = await readTextFile(fromRoot(root, path));
+        if (!content.trim()) {
+            continue;
+        }
+        const excerpt = buildReviewExcerpt(content, keywords, Math.min(perFileCharacterLimit, remaining));
+        totalLength += excerpt.length;
+        contexts.push({
+            path,
+            excerpt,
+            truncated: content.length > excerpt.length
+        });
+    }
+    return contexts;
+}
+function extractReviewKeywords(markdown) {
+    const tokens = markdown.toLowerCase().match(/[a-z0-9가-힣]{3,}/g) ?? [];
+    const routeTokens = markdown.match(/[a-z0-9_.-]+\/[a-z0-9_./*-]+/gi) ?? [];
+    return [...new Set([...routeTokens, ...tokens])].slice(0, 30);
+}
+function buildReviewExcerpt(content, keywords, maxCharacters) {
+    const lines = content.split("\n");
+    const selected = new Set();
+    const headLineCount = Math.min(lines.length, 50);
+    for (let index = 0; index < headLineCount; index += 1) {
+        selected.add(index);
+    }
+    for (const keyword of keywords) {
+        const normalizedKeyword = keyword.toLowerCase().replace(/\*\*?$/g, "");
+        if (normalizedKeyword.length < 3) {
+            continue;
+        }
+        lines.forEach((line, index) => {
+            if (!line.toLowerCase().includes(normalizedKeyword)) {
+                return;
+            }
+            for (let cursor = Math.max(0, index - 8); cursor <= Math.min(lines.length - 1, index + 12); cursor += 1) {
+                selected.add(cursor);
+            }
+        });
+    }
+    const chunks = [];
+    let previous = -2;
+    for (const lineIndex of [...selected].sort((a, b) => a - b)) {
+        if (lineIndex > previous + 1 && chunks.length > 0) {
+            chunks.push("...");
+        }
+        chunks.push(`${lineIndex + 1}: ${lines[lineIndex]}`);
+        previous = lineIndex;
+        if (chunks.join("\n").length >= maxCharacters) {
+            break;
+        }
+    }
+    return trimToLimit(chunks.join("\n"), maxCharacters);
+}
+function isTextReviewFile(path) {
+    if (path.startsWith("node_modules/") ||
+        path.startsWith(".next/") ||
+        path.startsWith("dist/") ||
+        path.startsWith("build/") ||
+        path.startsWith("coverage/")) {
+        return false;
+    }
+    if (/\.(png|jpe?g|gif|webp|avif|ico|svg|ttf|otf|woff2?|mp4|mov|mp3|wav|pdf|zip|gz)$/i.test(path)) {
+        return false;
+    }
+    return /\.(ts|tsx|js|jsx|mjs|cjs|json|md|css|scss|sass|sql|toml|ya?ml|txt)$/i.test(path);
+}
+function trimToLimit(content, maxCharacters) {
+    if (content.length <= maxCharacters) {
+        return content;
+    }
+    return `${content.slice(0, Math.max(0, maxCharacters - 80)).trimEnd()}\n... truncated by dev-guard review context limit ...`;
+}
+function readOption(args, name) {
+    const index = args.indexOf(name);
+    if (index < 0) {
+        return undefined;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+        throw new Error(`${name} 옵션에는 값이 필요합니다.`);
+    }
+    return value;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=review.js.map