sanjang 0.3.7 → 0.4.1

package/dashboard/app.js

@@ -16,8 +16,12 @@ const logs = new Map();
 // Route inference — map file paths to preview routes
 // ---------------------------------------------------------------------------
 
+/** @type {Map<string, string|null>} Client-side cache for AI-inferred routes */
+const aiRouteCache = new Map();
+const AI_ROUTE_CACHE_MAX = 200;
+
 /**
- * Infer a preview route from a file path.
+ * Infer a preview route from a file path (sync, pattern-based).
  * Only works for file-based routing patterns (pages/, app/, views/).
  * Returns null if no route can be inferred.
  */
@@ -47,9 +51,45 @@ function inferRouteFromPath(filePath) {
       return route || '/';
     }
   }
+
+  // Return cached AI result if available
+  if (aiRouteCache.has(filePath)) return aiRouteCache.get(filePath);
+
   return null;
 }
 
+/**
+ * Fetch AI-inferred route from the server for a file path.
+ * Results are cached to avoid duplicate calls.
+ * @param {string} filePath
+ * @param {string} [framework]
+ * @returns {Promise<string|null>}
+ */
+async function inferRouteFromPathAI(filePath, framework) {
+  if (aiRouteCache.has(filePath)) return aiRouteCache.get(filePath);
+
+  // Mark as in-flight to prevent duplicate requests
+  if (aiRouteCache.size >= AI_ROUTE_CACHE_MAX) {
+    const oldest = aiRouteCache.keys().next().value;
+    aiRouteCache.delete(oldest);
+  }
+  aiRouteCache.set(filePath, null);
+
+  try {
+    const data = await api('POST', '/api/infer-route', { filePath, framework });
+    const route = data.route || null;
+    if (aiRouteCache.size >= AI_ROUTE_CACHE_MAX) {
+      const oldest = aiRouteCache.keys().next().value;
+      aiRouteCache.delete(oldest);
+    }
+    aiRouteCache.set(filePath, route);
+    return route;
+  } catch {
+    aiRouteCache.delete(filePath);
+    return null;
+  }
+}
+
 /**
  * Navigate the preview iframe to a given route.
  */
@@ -1629,24 +1669,59 @@ async function fetchAndRenderReport(campName, withAi = false) {
               const route = cat === 'ui' && file ? inferRouteFromPath(file.path) : null;
               return route
                 ? `<li class="ws-report-nav-item" onclick="navigatePreview('${escHtml(route)}')" title="${escHtml(file.path)} → ${escHtml(route)}">${escHtml(item)} <span class="ws-report-nav-hint">→ 보기</span></li>`
-                : `<li>${escHtml(item)}</li>`;
+                : `<li data-ai-route-path="${cat === 'ui' && file ? escHtml(file.path) : ''}">${escHtml(item)}</li>`;
             }).join('')}</ul>`
           : `<ul class="ws-report-cat-items">${files.map(f => {
               const route = cat === 'ui' ? inferRouteFromPath(f.path) : null;
               const label = `${escHtml(f.path.split('/').pop() || f.path)} ${f.status === '새 파일' ? '추가됨' : '수정됨'}`;
               return route
                 ? `<li class="ws-report-nav-item" onclick="navigatePreview('${escHtml(route)}')" title="${escHtml(f.path)} → ${escHtml(route)}">${label} <span class="ws-report-nav-hint">→ 보기</span></li>`
-                : `<li>${label}</li>`;
+                : `<li data-ai-route-path="${cat === 'ui' ? escHtml(f.path) : ''}">${label}</li>`;
             }).join('')}</ul>`
         }
       </div>`;
     }).join('');
 
+    // Async AI fallback: resolve routes for UI files that pattern matching missed
+    resolveAiRoutes(categoriesEl);
+
   } catch {
     section.style.display = 'none';
   }
 }
 
+/**
+ * After report renders, find UI file items that didn't get a route via pattern matching
+ * and attempt AI-based route inference for them, updating the DOM when routes are found.
+ * @param {HTMLElement} container
+ */
+async function resolveAiRoutes(container) {
+  const pending = [...container.querySelectorAll('li[data-ai-route-path]')];
+  const tasks = pending
+    .map(li => {
+      const filePath = li.getAttribute('data-ai-route-path');
+      if (!filePath) return null;
+      return { li, filePath, promise: inferRouteFromPathAI(filePath) };
+    })
+    .filter(Boolean);
+
+  const results = await Promise.allSettled(tasks.map(t => t.promise));
+
+  for (let i = 0; i < tasks.length; i++) {
+    const { li, filePath } = tasks[i];
+    const result = results[i];
+    const route = result.status === 'fulfilled' ? result.value : null;
+    if (route) {
+      const text = li.textContent;
+      li.className = 'ws-report-nav-item';
+      li.setAttribute('onclick', `navigatePreview('${escHtml(route)}')`);
+      li.setAttribute('title', `${filePath} → ${route}`);
+      li.innerHTML = `${escHtml(text)} <span class="ws-report-nav-hint">→ 보기</span>`;
+    }
+    li.removeAttribute('data-ai-route-path');
+  }
+}
+
 function transitionReportToSaved() {
   const section = document.getElementById('ws-report-section');
   if (!section || !lastReport) return;

package/dist/lib/config.js

@@ -9,6 +9,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
+import { claudeSync, extractJson, isDangerousCommand } from "./engine/ai.js";
 import { deepFindEnvFiles, detectSetupIssues } from "./engine/smart-init.js";
 const CONFIG_FILE = "sanjang.config.js";
 const DEFAULTS = {
@@ -190,6 +191,10 @@ export function detectProject(projectRoot) {
             copyFiles: findEnvFiles(projectRoot),
         };
     }
+    // AI fallback: ask Claude to analyze the project and suggest a dev command
+    const aiDetected = detectProjectWithAI(projectRoot, pkg);
+    if (aiDetected)
+        return aiDetected;
     return {
         framework: "unknown",
         dev: { command: "npm run dev", port: 3000, portFlag: "--port", cwd: ".", env: {} },
@@ -197,6 +202,63 @@ export function detectProject(projectRoot) {
         copyFiles: [],
     };
 }
+function detectProjectWithAI(projectRoot, pkg) {
+    const contextParts = [];
+    if (!existsSync(projectRoot))
+        return null;
+    const lsResult = readdirSync(projectRoot, { withFileTypes: true });
+    const listing = lsResult
+        .map((e) => `${e.isDirectory() ? "d" : "f"} ${e.name}`)
+        .join("\n");
+    contextParts.push(`## Files in project root:\n${listing}`);
+    if (pkg?.scripts) {
+        contextParts.push(`## package.json scripts:\n${JSON.stringify(pkg.scripts, null, 2)}`);
+    }
+    const makefilePath = join(projectRoot, "Makefile");
+    if (existsSync(makefilePath)) {
+        try {
+            const content = readFileSync(makefilePath, "utf8");
+            contextParts.push(`## Makefile (first 20 lines):\n${content.split("\n").slice(0, 20).join("\n")}`);
+        }
+        catch { /* ignore */ }
+    }
+    const prompt = `You are analyzing a software project to determine how to run its dev server.
+
+${contextParts.join("\n\n")}
+
+Based on these files, determine the correct command to start the development server.
+Respond with ONLY a JSON object (no markdown, no explanation):
+{"command": "the dev command", "port": 3000, "portFlag": "--port", "setup": "install command or null"}
+
+Rules:
+- command: the shell command to start the dev server
+- port: the default port number (number, not string)
+- portFlag: the CLI flag to override port, or null if not applicable
+- setup: the install/setup command, or null if none needed`;
+    const raw = claudeSync(prompt, { model: "haiku" });
+    if (!raw)
+        return null;
+    const suggestion = extractJson(raw);
+    if (!suggestion?.command || typeof suggestion.command !== "string")
+        return null;
+    if (isDangerousCommand(suggestion.command))
+        return null;
+    if (suggestion.setup && isDangerousCommand(suggestion.setup))
+        return null;
+    return {
+        framework: "AI-detected",
+        dev: {
+            command: suggestion.command,
+            port: typeof suggestion.port === "number" ? suggestion.port : 3000,
+            portFlag: suggestion.portFlag ?? null,
+            cwd: ".",
+            env: {},
+        },
+        setup: suggestion.setup ?? "npm install",
+        copyFiles: findEnvFiles(projectRoot),
+        _note: "Project type detected by AI. Verify the dev command is correct.",
+    };
+}
 /**
  * Scan first-level subdirectories for app candidates.
  * Returns array of { dir, framework, detected } sorted by dir name.

package/dist/lib/engine/ai.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared AI (Claude CLI) utilities.
+ *
+ * Centralises claude CLI availability checks, prompt execution,
+ * JSON extraction, and dangerous command detection so that engine
+ * modules do not duplicate these patterns.
+ */
+export declare function isClaudeAvailable(): boolean;
+export interface ClaudeSyncOptions {
+    model?: string;
+    timeout?: number;
+    cwd?: string;
+    outputFormat?: string;
+}
+/**
+ * Call `claude -p` synchronously and return trimmed stdout, or null on failure.
+ * Checks availability first (cached), strips markdown fences from output.
+ */
+export declare function claudeSync(prompt: string, opts?: ClaudeSyncOptions): string | null;
+/**
+ * Extract a JSON object or array from text that may contain markdown fences
+ * or surrounding prose. Returns parsed value or null.
+ */
+export declare function extractJson<T = unknown>(text: string): T | null;
+export declare function isDangerousCommand(cmd: string): boolean;

package/dist/lib/engine/ai.js

@@ -0,0 +1,100 @@
+/**
+ * Shared AI (Claude CLI) utilities.
+ *
+ * Centralises claude CLI availability checks, prompt execution,
+ * JSON extraction, and dangerous command detection so that engine
+ * modules do not duplicate these patterns.
+ */
+import { spawnSync } from "node:child_process";
+// ---------------------------------------------------------------------------
+// Claude CLI availability (cached)
+// ---------------------------------------------------------------------------
+let _claudeAvailable = null;
+export function isClaudeAvailable() {
+    if (_claudeAvailable === null) {
+        _claudeAvailable = spawnSync("which", ["claude"], { stdio: "pipe" }).status === 0;
+    }
+    return _claudeAvailable;
+}
+/**
+ * Call `claude -p` synchronously and return trimmed stdout, or null on failure.
+ * Checks availability first (cached), strips markdown fences from output.
+ */
+export function claudeSync(prompt, opts) {
+    if (!isClaudeAvailable())
+        return null;
+    const args = ["-p", prompt];
+    if (opts?.model)
+        args.push("--model", opts.model);
+    if (opts?.outputFormat)
+        args.push("--output-format", opts.outputFormat);
+    try {
+        const result = spawnSync("claude", args, {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: opts?.timeout ?? 15_000,
+            cwd: opts?.cwd,
+        });
+        if (result.status !== 0 || !result.stdout)
+            return null;
+        return result.stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// JSON extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extract a JSON object or array from text that may contain markdown fences
+ * or surrounding prose. Returns parsed value or null.
+ */
+export function extractJson(text) {
+    if (!text)
+        return null;
+    // Strip markdown code fences
+    const stripped = text.replace(/^```(?:json)?\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+    // Try direct parse first (common case: entire response is JSON)
+    try {
+        return JSON.parse(stripped);
+    }
+    catch { /* not pure JSON, try extraction */ }
+    // Find JSON boundaries by trying to parse from each opening bracket
+    for (let i = 0; i < stripped.length; i++) {
+        const ch = stripped[i];
+        if (ch !== "{" && ch !== "[")
+            continue;
+        // Try progressively shorter substrings from this position
+        for (let j = stripped.length; j > i; j--) {
+            const endCh = stripped[j - 1];
+            if ((ch === "{" && endCh !== "}") || (ch === "[" && endCh !== "]"))
+                continue;
+            try {
+                return JSON.parse(stripped.slice(i, j));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Dangerous command detection
+// ---------------------------------------------------------------------------
+const DANGEROUS_COMMAND_PATTERNS = [
+    /\brm\s+(-\w*[rf]|--recursive|--force)/i,
+    /\bsudo\b/i,
+    /\bcurl\b.*\|\s*\b(sh|bash|zsh)\b/i,
+    /\bwget\b.*\|\s*\b(sh|bash|zsh)\b/i,
+    /\bmkfs\b/i,
+    /\bdd\s+(if=|of=)/i,
+    /\b(shutdown|reboot|halt|poweroff)\b/i,
+    /\bchmod\s+777\b/i,
+    /\b>\s*\/dev\//i,
+    /:\(\)\{.*\|.*&\s*\}|fork\s+bomb/i,
+];
+export function isDangerousCommand(cmd) {
+    return DANGEROUS_COMMAND_PATTERNS.some((p) => p.test(cmd));
+}

package/dist/lib/engine/change-report.d.ts

@@ -5,6 +5,12 @@ type FileCategory = "ui" | "api" | "config" | "test" | "docs" | "other";
  * Rules are checked in priority order: test > ui > api > docs > config > other
  */
 export declare function categorizeFile(filePath: string): FileCategory;
+/**
+ * Re-classify "other" files using AI (claude -p --model haiku).
+ * Only file paths are sent — file contents are never read (cost/speed optimisation).
+ * On failure the original categories are preserved.
+ */
+export declare function recategorizeWithAI(files: ChangeReportFile[]): ChangeReportFile[];
 /**
  * Detect warnings from a list of categorized files.
  * Returns deduplicated warnings (one per type).
@@ -17,7 +23,9 @@ export declare function detectWarnings(files: ChangeReportFile[]): ChangeReportW
 export declare function buildChangeReport(rawFiles: {
     path: string;
     status: ChangeReportFile["status"];
-}[]): ChangeReport;
+}[], options?: {
+    ai?: boolean;
+}): ChangeReport;
 /**
  * Enrich a ChangeReport with AI-generated category-level descriptions.
  * Each category gets human-readable bullet points explaining what changed.

package/dist/lib/engine/change-report.js

@@ -1,5 +1,5 @@
-import { spawnSync } from "node:child_process";
 import { basename, extname } from "node:path";
+import { claudeSync, extractJson } from "./ai.js";
 /**
  * Classify a file path into one of the known categories.
  * Rules are checked in priority order: test > ui > api > docs > config > other
@@ -74,6 +74,41 @@ export function categorizeFile(filePath) {
     // 6. other
     return "other";
 }
+const VALID_AI_CATEGORIES = new Set(["ui", "api", "config", "test", "docs"]);
+/**
+ * Re-classify "other" files using AI (claude -p --model haiku).
+ * Only file paths are sent — file contents are never read (cost/speed optimisation).
+ * On failure the original categories are preserved.
+ */
+export function recategorizeWithAI(files) {
+    const otherFiles = files.filter((f) => f.category === "other");
+    if (otherFiles.length === 0)
+        return files;
+    const pathList = otherFiles.map((f) => f.path).join("\n");
+    const prompt = `아래 파일 경로들을 다음 카테고리 중 하나로 분류해: ui, api, config, test, docs
+경로만 보고 판단해.
+
+파일 목록:
+${pathList}
+
+JSON으로만 응답해 (다른 텍스트 없이):
+{ "파일경로": "카테고리", ... }`;
+    const raw = claudeSync(prompt, { model: "haiku" });
+    if (!raw)
+        return files;
+    const mapping = extractJson(raw);
+    if (!mapping)
+        return files;
+    return files.map((f) => {
+        if (f.category !== "other")
+            return f;
+        const aiCat = mapping[f.path];
+        if (typeof aiCat === "string" && VALID_AI_CATEGORIES.has(aiCat)) {
+            return { ...f, category: aiCat };
+        }
+        return f;
+    });
+}
 /**
  * Detect warnings from a list of categorized files.
  * Returns deduplicated warnings (one per type).
@@ -117,12 +152,15 @@ export function detectWarnings(files) {
  * Build a ChangeReport from raw file list (path + status).
  * summary and humanDescription are set to null — call generateReportSummary to enrich.
  */
-export function buildChangeReport(rawFiles) {
-    const files = rawFiles.map((f) => ({
+export function buildChangeReport(rawFiles, options) {
+    let files = rawFiles.map((f) => ({
         path: f.path,
         status: f.status,
         category: categorizeFile(f.path),
     }));
+    if (options?.ai) {
+        files = recategorizeWithAI(files);
+    }
     const byCategory = {};
     for (const f of files) {
         const cat = f.category;
@@ -192,30 +230,18 @@ JSON으로만 응답해 (다른 텍스트 없이):
 {"summary": "전체 한 줄 요약 (30자 이내)", "categories": {"ui": ["설명1", "설명2"], "api": ["설명1"], ...}}
 
 categories의 키는 반드시 다음 중 하나: ${Object.keys(report.byCategory).join(", ")}`;
-    try {
-        const result = spawnSync("claude", ["-p", prompt], {
-            encoding: "utf8",
-            timeout: 30_000,
-        });
-        if (result.status === 0 && result.stdout) {
-            const output = result.stdout.trim();
-            const jsonMatch = output.match(/\{[\s\S]*"summary"[\s\S]*"categories"[\s\S]*\}/);
-            if (jsonMatch) {
-                const parsed = JSON.parse(jsonMatch[0]);
-                if (parsed.summary && parsed.categories) {
-                    return {
-                        ...report,
-                        summary: parsed.summary,
-                        humanDescription: null,
-                        categoryDetails: parsed.categories,
-                    };
-                }
-            }
+    const raw = claudeSync(prompt, { model: "haiku", timeout: 30_000 });
+    if (raw) {
+        const parsed = extractJson(raw);
+        if (parsed?.summary && parsed?.categories) {
+            return {
+                ...report,
+                summary: parsed.summary,
+                humanDescription: null,
+                categoryDetails: parsed.categories,
+            };
         }
     }
-    catch {
-        // Fall through to fallback
-    }
     // Fallback: 파일 기반 설명 생성
     const fallbackDetails = {};
     for (const [cat, files] of Object.entries(report.byCategory)) {

package/dist/lib/engine/config-hotfix.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { claudeSync, extractJson, isDangerousCommand } from "./ai.js";
 import { deepFindEnvFiles } from "./smart-init.js";
 const PATTERNS = [
     {
@@ -42,10 +43,59 @@ const PATTERNS = [
     },
 ];
 // ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const CONFIG_FILE = "sanjang.config.js";
+/** Maximum characters of config content to include in AI prompts. */
+const MAX_CONFIG_CONTENT_FOR_PROMPT = 3000;
+// ---------------------------------------------------------------------------
+// AI helpers
+// ---------------------------------------------------------------------------
+function aiFallback(projectRoot, logs) {
+    const configPath = join(projectRoot, CONFIG_FILE);
+    const configContent = existsSync(configPath)
+        ? readFileSync(configPath, "utf8").slice(0, MAX_CONFIG_CONTENT_FOR_PROMPT)
+        : "(config file not found)";
+    const lastLines = logs.slice(-20).join("\n");
+    const prompt = [
+        "You are a build-config assistant for the sanjang dev tool.",
+        "Given the error log and the current sanjang.config.js, suggest a fix.",
+        "",
+        "## Error log (last 20 lines)",
+        lastLines,
+        "",
+        "## Current sanjang.config.js",
+        configContent,
+        "",
+        "Respond with ONLY a JSON object (no markdown fences, no explanation):",
+        '{ "type": "add-copyfiles" | "update-setup" | "info", "description": "<한국어 설명>", "patch": { ... } }',
+        "",
+        'For "update-setup", include patch.setup with the corrected shell command.',
+        'For "add-copyfiles", include patch.copyFiles with file paths array.',
+        'For "info", include a descriptive patch explaining the issue.',
+    ].join("\n");
+    const raw = claudeSync(prompt, { model: "haiku" });
+    if (!raw)
+        return null;
+    const parsed = extractJson(raw);
+    if (!parsed)
+        return null;
+    if (!parsed.type || !parsed.description || !parsed.patch)
+        return null;
+    if (!["add-copyfiles", "update-setup", "info"].includes(parsed.type))
+        return null;
+    if (parsed.type === "update-setup" && typeof parsed.patch.setup === "string") {
+        if (isDangerousCommand(parsed.patch.setup))
+            return null;
+    }
+    return parsed;
+}
+// ---------------------------------------------------------------------------
 // suggestConfigFix — analyze logs and return a fix, or null
 // ---------------------------------------------------------------------------
 export function suggestConfigFix(projectRoot, logs) {
     const combined = logs.join("\n");
+    // Fast path: pattern matching
     for (const pattern of PATTERNS) {
         const match = combined.match(pattern.test);
         if (match) {
@@ -54,12 +104,16 @@ export function suggestConfigFix(projectRoot, logs) {
                 return fix;
         }
     }
+    // Slow path: AI fallback — only if logs contain error signals
+    const hasErrorSignal = /\b(error|ERR!|FATAL|ENOSPC|EPERM|EACCES|TypeError|ReferenceError|SyntaxError|failed to|build failed)\b/i.test(combined);
+    if (hasErrorSignal) {
+        return aiFallback(projectRoot, logs);
+    }
     return null;
 }
 // ---------------------------------------------------------------------------
 // applyConfigFix — modify sanjang.config.js in place
 // ---------------------------------------------------------------------------
-const CONFIG_FILE = "sanjang.config.js";
 export function applyConfigFix(projectRoot, fix) {
     const configPath = join(projectRoot, CONFIG_FILE);
     if (!existsSync(configPath))
@@ -80,7 +134,7 @@ export function applyConfigFix(projectRoot, fix) {
             break;
         }
         case "update-setup": {
-            // Informational — we don't auto-change setup without explicit user input
+            // Informational only — don't auto-change setup without explicit user confirmation
             return false;
         }
         case "info": {

package/dist/lib/engine/conflict.d.ts

@@ -19,7 +19,9 @@ export interface ConflictSection {
  * Returns an array of conflict sections found in the file.
  */
 export declare function parseConflictSections(content: string): ConflictSection[];
-/**
- * Build a Claude prompt to resolve merge conflicts.
- */
-export declare function buildConflictPrompt(conflictFiles: string[]): string;
+/** Detail about a single file's conflict sections, used to embed content in the prompt. */
+export interface ConflictDetail {
+    path: string;
+    sections: ConflictSection[];
+}
+export declare function buildConflictPrompt(conflictFiles: string[], conflictDetails?: ConflictDetail[]): string;

package/dist/lib/engine/conflict.js

@@ -55,19 +55,59 @@ export function parseConflictSections(content) {
     }
     return sections;
 }
+/** Truncate text to a maximum number of lines. */
+function truncateLines(text, maxLines) {
+    const lines = text.split("\n");
+    if (lines.length <= maxLines)
+        return text;
+    return lines.slice(0, maxLines).join("\n") + `\n... (${lines.length - maxLines}줄 생략)`;
+}
 /**
  * Build a Claude prompt to resolve merge conflicts.
+ * When conflictDetails is provided, ours/theirs content is embedded directly
+ * so Claude can resolve without re-reading the files.
  */
-export function buildConflictPrompt(conflictFiles) {
-    return [
+/** Maximum lines to include per conflict side (ours/theirs) in the prompt. */
+const MAX_LINES_PER_SIDE = 50;
+export function buildConflictPrompt(conflictFiles, conflictDetails) {
+    const lines = [
         "아래 파일들에 git merge 충돌이 발생했습니다.",
-        "각 파일의 충돌 마커(<<<<<<< ======= >>>>>>>)를 읽고,",
         "두 버전의 의도를 모두 살려서 충돌을 해결해주세요.",
         "해결 후 충돌 마커는 완전히 제거해야 합니다.",
         "",
-        "충돌 파일 목록:",
-        ...conflictFiles.map((f) => `- ${f}`),
-        "",
-        "각 파일을 읽고 수정해주세요.",
-    ].join("\n");
+    ];
+    if (conflictDetails?.length) {
+        for (const detail of conflictDetails) {
+            lines.push(`## ${detail.path}`);
+            if (detail.sections.length === 0) {
+                lines.push("(충돌 섹션을 파싱하지 못했습니다. 파일을 직접 읽어주세요.)");
+            }
+            else {
+                for (let i = 0; i < detail.sections.length; i++) {
+                    const s = detail.sections[i];
+                    lines.push(`### 충돌 #${i + 1} (line ${s.startLine})`);
+                    lines.push("**Ours (현재 브랜치):**");
+                    lines.push("```");
+                    lines.push(truncateLines(s.ours, MAX_LINES_PER_SIDE));
+                    lines.push("```");
+                    lines.push("**Theirs (병합 대상):**");
+                    lines.push("```");
+                    lines.push(truncateLines(s.theirs, MAX_LINES_PER_SIDE));
+                    lines.push("```");
+                    lines.push("");
+                }
+            }
+            lines.push("");
+        }
+        lines.push("위 내용을 바탕으로 각 파일의 충돌을 해결해주세요.");
+    }
+    else {
+        lines.push("충돌 파일 목록:");
+        for (const f of conflictFiles) {
+            lines.push(`- ${f}`);
+        }
+        lines.push("");
+        lines.push("각 파일을 읽고 수정해주세요.");
+    }
+    return lines.join("\n");
 }