sanjang 0.3.6 → 0.4.1

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");
 }

package/dist/lib/engine/diagnostics.js

@@ -1,4 +1,9 @@
 import { execSync } from "node:child_process";
+import { claudeSync } from "./ai.js";
+/** Maximum character length for AI-generated guide messages. */
+const MAX_AI_GUIDE_LENGTH = 300;
+/** Number of log lines to send to AI for guide generation. */
+const AI_GUIDE_LOG_TAIL = 30;
 function tryExec(cmd) {
     try {
         return execSync(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
@@ -17,7 +22,28 @@ function checkPortConflict(processInfo) {
         guide: hit ? '"중지" → "시작"을 눌러보세요. 계속되면 "삭제" 후 다시 만들어보세요.' : null,
     };
 }
-function checkFrontendExit(processInfo) {
+const FALLBACK_GUIDE_MODULE = '필요한 패키지가 없어요. "처음부터 다시"를 눌러 의존성을 다시 설치해보세요.';
+const FALLBACK_GUIDE_GENERIC = '서버가 에러로 종료됐어요. "처음부터 다시"를 누르거나, "디버그" 버튼으로 로그를 복사해서 Claude에게 물어보세요.';
+function generateAiGuide(logLines) {
+    const tail = logLines.slice(-AI_GUIDE_LOG_TAIL).join("\n");
+    const prompt = `프론트엔드 개발 서버가 에러로 종료되었습니다. 아래 로그를 분석해서 비개발자에게 한 줄로 문제를 설명하고, 해결을 위해 어떤 버튼을 눌러야 하는지 알려주세요.
+
+사용 가능한 버튼: "처음부터 다시", "중지", "시작", "삭제", "디버그"
+
+로그 (마지막 30줄):
+${tail}
+
+규칙:
+- 반드시 한국어로, 한 줄로 답변하세요.
+- "~해보세요" 체로 끝내세요.
+- 버튼 이름은 큰따옴표로 감싸세요.
+- 마크다운이나 코드 블록 없이 순수 텍스트만 출력하세요.`;
+    const output = claudeSync(prompt, { model: "haiku", outputFormat: "text" });
+    if (!output || output.length > MAX_AI_GUIDE_LENGTH || output.includes("```"))
+        return null;
+    return output;
+}
+async function checkFrontendExit(processInfo) {
     const { feExitCode, feLogs } = processInfo;
     if (feExitCode === null || feExitCode === 0) {
         return {
@@ -27,16 +53,25 @@ function checkFrontendExit(processInfo) {
             guide: null,
         };
     }
-    const tail = (feLogs ?? []).join("").slice(-500);
+    const logLines = feLogs ?? [];
+    const tail = logLines.join("").slice(-500);
     const isModuleError = /MODULE_NOT_FOUND|Cannot find module/i.test(tail);
-    const guide = isModuleError
-        ? '필요한 패키지가 없어요. "처음부터 다시"를 눌러 의존성을 다시 설치해보세요.'
-        : '서버가 에러로 종료됐어요. "처음부터 다시"를 누르거나, "디버그" 버튼으로 로그를 복사해서 Claude에게 물어보세요.';
+    // Fast path: MODULE_NOT_FOUND has a clear fix, no AI needed
+    if (isModuleError) {
+        return {
+            name: "frontend-exit",
+            status: "error",
+            detail: `Frontend가 비정상 종료되었습니다 (코드 ${feExitCode}).`,
+            guide: FALLBACK_GUIDE_MODULE,
+        };
+    }
+    // AI path: ask Claude for a tailored guide, fallback to generic message
+    const aiGuide = generateAiGuide(logLines);
     return {
         name: "frontend-exit",
         status: "error",
         detail: `Frontend가 비정상 종료되었습니다 (코드 ${feExitCode}).`,
-        guide,
+        guide: aiGuide ?? FALLBACK_GUIDE_GENERIC,
     };
 }
 function checkFePort(pg) {
@@ -50,5 +85,5 @@ function checkFePort(pg) {
     };
 }
 export async function buildDiagnostics(pg, processInfo) {
-    return [checkPortConflict(processInfo), checkFrontendExit(processInfo), checkFePort(pg)];
+    return [checkPortConflict(processInfo), await checkFrontendExit(processInfo), checkFePort(pg)];
 }

package/dist/lib/engine/self-heal.d.ts

@@ -4,9 +4,14 @@ export interface HealAction {
     auto: boolean;
 }
 export declare function diagnoseFromLogs(logs: string[]): HealAction[];
+export interface AiDiagnosis {
+    cause: string;
+    action: "reinstall" | "copy-env" | "restart";
+    detail: string;
+}
 export interface HealResult {
     action: HealAction;
     success: boolean;
     detail?: string;
 }
-export declare function executeHeal(action: HealAction, campPath: string, projectRoot: string, setupCommand: string | null, copyFiles: string[]): HealResult;
+export declare function executeHeal(action: HealAction, campPath: string, projectRoot: string, setupCommand: string | null, copyFiles: string[], logs?: string[]): HealResult;

package/dist/lib/engine/self-heal.js

@@ -1,6 +1,9 @@
 import { execSync } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { claudeSync, extractJson } from "./ai.js";
+/** Number of log lines to send to AI for diagnosis. */
+const AI_DIAGNOSIS_LOG_TAIL = 30;
 const PATTERNS = [
     {
         test: /Cannot find module|MODULE_NOT_FOUND/i,
@@ -43,6 +46,8 @@ const PATTERNS = [
         }),
     },
 ];
+/** Broad regex to detect error signals in logs (used for ask-ai fallback). */
+const ERROR_SIGNAL = /\b(error|ERR!|FATAL|ENOSPC|EPERM|EACCES|TypeError|ReferenceError|SyntaxError|Segmentation fault|panic|Unhandled|uncaught|failed to|build failed)\b/i;
 export function diagnoseFromLogs(logs) {
     const combined = logs.join("\n");
     const actions = [];
@@ -56,9 +61,51 @@ export function diagnoseFromLogs(logs) {
             }
         }
     }
+    // Fallback: if no known pattern matched but logs contain error signals, ask AI
+    if (actions.length === 0 && ERROR_SIGNAL.test(combined)) {
+        actions.push({
+            type: "ask-ai",
+            message: "알려진 패턴이 아닙니다. AI에게 진단을 요청합니다.",
+            auto: true,
+        });
+    }
     return actions;
 }
-export function executeHeal(action, campPath, projectRoot, setupCommand, copyFiles) {
+function askAiForDiagnosis(logs, campPathStr) {
+    const tail = logs.slice(-AI_DIAGNOSIS_LOG_TAIL).join("\n");
+    const prompt = `You are a dev server error diagnostician. Analyze these logs and respond with ONLY a JSON object (no markdown, no code fences).
+
+Logs (last 30 lines from a dev server at ${campPathStr}):
+${tail}
+
+Respond with exactly this JSON structure:
+{"cause":"<root cause in Korean>","action":"<one of: reinstall|copy-env|restart>","detail":"<fix explanation in Korean>"}
+
+Rules:
+- action "reinstall": dependency issues (missing modules, version mismatch)
+- action "copy-env": missing env files or env variables
+- action "restart": port conflicts, zombie processes, or any other issue
+- Pick the closest matching action. Do NOT suggest shell commands.`;
+    const raw = claudeSync(prompt, { model: "haiku", timeout: 30_000, outputFormat: "text" });
+    if (!raw)
+        return null;
+    const parsed = extractJson(raw);
+    if (!parsed)
+        return null;
+    const validActions = ["reinstall", "copy-env", "restart"];
+    if (typeof parsed.cause !== "string" ||
+        typeof parsed.action !== "string" ||
+        !validActions.includes(parsed.action) ||
+        typeof parsed.detail !== "string") {
+        return null;
+    }
+    return {
+        cause: parsed.cause,
+        action: parsed.action,
+        detail: parsed.detail,
+    };
+}
+export function executeHeal(action, campPath, projectRoot, setupCommand, copyFiles, logs) {
     switch (action.type) {
         case "reinstall": {
             if (!setupCommand)
@@ -101,8 +148,26 @@ export function executeHeal(action, campPath, projectRoot, setupCommand, copyFil
         case "restart":
             // Restart is handled by the caller (stop + start)
             return { action, success: true, detail: "재시작을 시도합니다." };
-        case "ask-ai":
-            return { action, success: false, detail: "자동 수정할 수 없습니다." };
+        case "ask-ai": {
+            if (!logs || logs.length === 0) {
+                return { action, success: false, detail: "자동 수정할 수 없습니다." };
+            }
+            const diagnosis = askAiForDiagnosis(logs, campPath);
+            if (!diagnosis) {
+                return { action, success: false, detail: "AI 진단에 실패했습니다. 로그를 직접 확인해주세요." };
+            }
+            // Reuse existing heal logic for known action types
+            if (diagnosis.action === "reinstall") {
+                const sub = { type: "reinstall", message: diagnosis.detail, auto: true };
+                return executeHeal(sub, campPath, projectRoot, setupCommand, copyFiles);
+            }
+            if (diagnosis.action === "copy-env") {
+                const sub = { type: "copy-env", message: diagnosis.detail, auto: true };
+                return executeHeal(sub, campPath, projectRoot, setupCommand, copyFiles);
+            }
+            // diagnosis.action === "restart"
+            return { action, success: true, detail: `AI 진단: ${diagnosis.cause}\n→ ${diagnosis.detail}` };
+        }
         default:
             return { action, success: false, detail: "알 수 없는 액션입니다." };
     }

package/dist/lib/engine/smart-pr.js

@@ -4,7 +4,8 @@
  * Uses `claude -p` to generate a human-readable PR description from the diff.
  * Falls back to a simple file-count summary when the CLI is unavailable.
  */
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
+import { isClaudeAvailable } from "./ai.js";
 const TIMEOUT_MS = 30_000;
 /**
  * Run a command asynchronously with a timeout.
@@ -63,13 +64,6 @@ export function parseDiffStatSummary(diffStat) {
     }
     return parts.join(" ");
 }
-/**
- * Check if claude CLI is available on PATH.
- */
-function isClaudeAvailable() {
-    const result = spawnSync("which", ["claude"], { stdio: "pipe" });
-    return result.status === 0;
-}
 /**
  * Generate a PR description for the given worktree path.
  *

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

@@ -4,6 +4,7 @@ interface StashEntry {
     isSanjangSnapshot: boolean;
     date: string;
 }
+export declare function generateSnapshotLabel(campName: string): Promise<string>;
 export declare function saveSnapshot(name: string, label: string): Promise<void>;
 export declare function restoreSnapshot(name: string, index: number): Promise<void>;
 export declare function listSnapshots(name: string): Promise<StashEntry[]>;

package/dist/lib/engine/snapshot.js

@@ -1,6 +1,30 @@
 import { simpleGit } from "simple-git";
+import { claudeSync } from "./ai.js";
 import { campPath } from "./worktree.js";
 const STASH_PREFIX = "sanjang-snapshot:";
+/** Maximum character length for snapshot labels. */
+const MAX_SNAPSHOT_LABEL_LENGTH = 30;
+export async function generateSnapshotLabel(campName) {
+    const cwd = campPath(campName);
+    const git = simpleGit(cwd);
+    const now = new Date();
+    const timestamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+    try {
+        const diffStat = await git.raw(["diff", "--stat", "HEAD"]);
+        if (!diffStat?.trim()) {
+            return `변경 없음 (${timestamp})`;
+        }
+        const fileCount = diffStat.trim().split("\n").length;
+        const prompt = `다음은 git diff --stat 결과입니다. 이 변경사항을 15자 이내 한국어로 요약해주세요. 요약만 출력하고 다른 설명은 하지 마세요.\n\n${diffStat}`;
+        const label = claudeSync(prompt, { model: "haiku", timeout: 10_000, cwd });
+        if (label)
+            return label.slice(0, MAX_SNAPSHOT_LABEL_LENGTH);
+        return `${fileCount}개 파일 변경 (${timestamp})`;
+    }
+    catch {
+        return `스냅샷 (${timestamp})`;
+    }
+}
 export async function saveSnapshot(name, label) {
     const git = simpleGit(campPath(name));
     await git.raw(["stash", "push", "--include-untracked", "-m", `${STASH_PREFIX}${label}`]);

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

@@ -4,11 +4,17 @@
  * Aggregates open issues, PRs, and recent git activity to surface
  * actionable suggestions on the dashboard — no LLM required.
  */
+export type SuggestionType = "issue" | "pr" | "recent" | "ai-recommended";
 export interface Suggestion {
-    type: "issue" | "pr" | "recent";
+    type: SuggestionType;
     title: string;
     detail?: string;
     action?: string;
+    reason?: string;
+}
+export interface SuggestOptions {
+    /** Enable AI-powered priority recommendations (default: false) */
+    ai?: boolean;
 }
 /**
  * Suggest tasks the user might work on next.
@@ -17,5 +23,8 @@ export interface Suggestion {
  * If `gh` CLI is unavailable, returns git-based suggestions only.
  *
  * Results are sorted by relevance: PRs (이어하기) > Issues (이슈) > Recent (최근 작업).
+ *
+ * When `options.ai` is true, uses Claude (haiku) to generate top-3 priority
+ * recommendations prepended to the results. Falls back gracefully on failure.
  */
-export declare function suggestTasks(projectRoot: string): Promise<Suggestion[]>;
+export declare function suggestTasks(projectRoot: string, options?: SuggestOptions): Promise<Suggestion[]>;

package/dist/lib/engine/suggest.js

@@ -5,6 +5,7 @@
  * actionable suggestions on the dashboard — no LLM required.
  */
 import { spawn } from "node:child_process";
+import { claudeSync, extractJson } from "./ai.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -83,6 +84,32 @@ async function fetchRecentCommits(cwd) {
         };
     });
 }
+function getAiRecommendations(suggestions) {
+    if (suggestions.length === 0)
+        return [];
+    const summary = suggestions
+        .map((s) => `[${s.type}] ${s.title}${s.detail ? ` (${s.detail})` : ""}`)
+        .join("\n");
+    const prompt = `You are a dev productivity assistant. Given the developer's current work items below, pick the top 3 they should work on first. For each, explain in one line why it's the priority.
+
+Work items:
+${summary}
+
+Respond ONLY with a JSON array (no markdown, no code fences):
+[{ "title": "exact title from list", "reason": "one-line reason" }]`;
+    const raw = claudeSync(prompt, { model: "haiku" });
+    if (!raw)
+        return [];
+    const parsed = extractJson(raw);
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed
+        .filter((item) => typeof item === "object" &&
+        item !== null &&
+        typeof item.title === "string" &&
+        typeof item.reason === "string")
+        .slice(0, 3);
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -93,8 +120,11 @@ async function fetchRecentCommits(cwd) {
  * If `gh` CLI is unavailable, returns git-based suggestions only.
  *
  * Results are sorted by relevance: PRs (이어하기) > Issues (이슈) > Recent (최근 작업).
+ *
+ * When `options.ai` is true, uses Claude (haiku) to generate top-3 priority
+ * recommendations prepended to the results. Falls back gracefully on failure.
  */
-export async function suggestTasks(projectRoot) {
+export async function suggestTasks(projectRoot, options) {
     const results = [];
     // gh-dependent fetches — tolerate failure (gh not installed / no repo)
     const [issues, prs] = await Promise.allSettled([fetchIssues(projectRoot), fetchMyPrs(projectRoot)]);
@@ -114,5 +144,24 @@ export async function suggestTasks(projectRoot) {
     catch {
         // No git history — return whatever we have
     }
+    // AI-powered priority recommendations (opt-in)
+    if (options?.ai) {
+        const recommendations = getAiRecommendations(results);
+        if (recommendations.length > 0) {
+            const aiSuggestions = recommendations.map((rec) => {
+                // Try to find the original suggestion to preserve action/detail
+                const original = results.find((s) => s.title === rec.title);
+                return {
+                    type: "ai-recommended",
+                    title: rec.title,
+                    detail: original?.detail,
+                    action: original?.action,
+                    reason: rec.reason,
+                };
+            });
+            // Prepend AI recommendations before the regular results
+            return [...aiSuggestions, ...results];
+        }
+    }
     return results;
 }

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

@@ -3,12 +3,15 @@ export interface BranchInfo {
     remote: boolean;
     local: boolean;
     date: string;
-    category?: "default" | "feature" | "fix" | "other";
+    category?: "default" | "feature" | "fix" | "camp" | "other";
+    description?: string;
 }
 export declare function setProjectRoot(root: string): void;
 export declare function getProjectRoot(): string;
 export declare function campPath(name: string): string;
-export declare function listBranches(): Promise<BranchInfo[]>;
+export declare function listBranches(options?: {
+    enrich?: boolean;
+}): Promise<BranchInfo[]>;
 export declare function invalidateBranchCache(): void;
 export declare function startBranchRefresh(intervalMs?: number): ReturnType<typeof setInterval>;
 export declare function addWorktree(name: string, branch: string): Promise<void>;

package/dist/lib/engine/worktree.js

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import { simpleGit } from "simple-git";
+import { claudeSync, extractJson } from "./ai.js";
 import { getCampsDir } from "./state.js";
 let projectRoot = null;
 export function setProjectRoot(root) {
@@ -61,12 +62,52 @@ async function parseBranches() {
         else if (b.name.startsWith("fix/") || b.name.startsWith("hotfix/")) {
             b.category = "fix";
         }
+        else if (b.name.startsWith("camp/")) {
+            b.category = "camp";
+        }
         else {
             b.category = "other";
         }
     }
     return branches;
 }
+async function enrichBranchDescriptions(branches) {
+    const needDesc = branches.filter((b) => !b.description && b.category !== "default");
+    if (needDesc.length === 0)
+        return;
+    // Collect recent commit messages per branch (parallel)
+    const commitMap = {};
+    const logResults = await Promise.allSettled(needDesc.map(async (b) => {
+        const ref = b.local ? b.name : `origin/${b.name}`;
+        const log = await git().raw(["log", ref, "--oneline", "-5", "--no-merges"]);
+        return { name: b.name, log: log.trim() };
+    }));
+    for (const result of logResults) {
+        if (result.status === "fulfilled" && result.value.log) {
+            commitMap[result.value.name] = result.value.log;
+        }
+    }
+    if (Object.keys(commitMap).length === 0)
+        return;
+    const prompt = [
+        "아래는 git 브랜치별 최근 커밋 메시지입니다.",
+        "각 브랜치가 무슨 작업을 하는 브랜치인지 한 줄(20자 이내)로 설명해주세요.",
+        "JSON 형식으로만 응답: { \"브랜치명\": \"설명\", ... }",
+        "",
+        JSON.stringify(commitMap, null, 2),
+    ].join("\n");
+    const raw = claudeSync(prompt, { model: "haiku" });
+    if (!raw)
+        return;
+    const descriptions = extractJson(raw);
+    if (!descriptions)
+        return;
+    for (const b of needDesc) {
+        if (descriptions[b.name]) {
+            b.description = descriptions[b.name];
+        }
+    }
+}
 async function refreshBranches() {
     try {
         await git().fetch(["--prune"]);
@@ -79,11 +120,18 @@ async function refreshBranches() {
     _branchCacheTime = Date.now();
     return branches;
 }
-export async function listBranches() {
+export async function listBranches(options) {
+    let branches;
     if (_branchCache && Date.now() - _branchCacheTime < BRANCH_CACHE_TTL) {
-        return _branchCache;
+        branches = _branchCache;
+    }
+    else {
+        branches = await refreshBranches();
     }
-    return refreshBranches();
+    if (options?.enrich) {
+        await enrichBranchDescriptions(branches);
+    }
+    return branches;
 }
 export function invalidateBranchCache() {
     _branchCacheTime = 0;