sanjang 0.3.0

package/lib/engine/process.ts

@@ -0,0 +1,283 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { createConnection } from "node:net";
+import { join } from "node:path";
+import type { BroadcastMessage, EventCallback, SanjangConfig } from "../types.ts";
+import { campPath, getProjectRoot } from "./worktree.ts";
+
+interface CampProcessEntry {
+  feProc: ChildProcess | null;
+  feLogs: string[];
+  feExitCode: number | null;
+}
+
+export interface ProcessInfo {
+  feLogs: string[];
+  feExitCode: number | null;
+}
+
+const procs: Map<string, CampProcessEntry> = new Map();
+let projectConfig: SanjangConfig | null = null;
+let sharedBeProc: ChildProcess | null = null;
+
+export function setConfig(config: SanjangConfig): void {
+  projectConfig = config;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+// Detect actual port from dev server stdout (Vite: "➜  Local: http://localhost:3004/")
+function detectPortFromStdout(logs: string[], timeoutMs: number): Promise<number | null> {
+  return new Promise((resolve) => {
+    const deadline = Date.now() + timeoutMs;
+    // Patterns: Vite "Local:   http://localhost:PORT/", Next "- Local: http://localhost:PORT"
+    const portRe = /https?:\/\/localhost:(\d+)/;
+
+    function check(): void {
+      for (const line of logs) {
+        const match = portRe.exec(line);
+        if (match?.[1]) {
+          const port = parseInt(match[1], 10);
+          // Wait briefly for the port to actually be ready
+          const sock = createConnection({ port, host: "localhost" });
+          sock.once("connect", () => { sock.destroy(); resolve(port); });
+          sock.once("error", () => {
+            sock.destroy();
+            // Port printed but not ready yet, retry
+            if (Date.now() < deadline) setTimeout(check, 1000);
+            else resolve(port); // return the port anyway
+          });
+          return;
+        }
+      }
+      if (Date.now() >= deadline) {
+        resolve(null);
+      } else {
+        setTimeout(check, 1000);
+      }
+    }
+    check();
+  });
+}
+
+function waitForPort(port: number, timeoutMs: number): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + timeoutMs;
+    function attempt(): void {
+      const sock = createConnection({ port, host: "localhost" });
+      sock.once("connect", () => {
+        sock.destroy();
+        resolve();
+      });
+      sock.once("error", () => {
+        sock.destroy();
+        if (Date.now() >= deadline) {
+          reject(new Error(`포트 ${port}이 ${timeoutMs / 1000}초 내에 열리지 않았습니다.`));
+        } else {
+          setTimeout(attempt, 2000);
+        }
+      });
+    }
+    attempt();
+  });
+}
+
+function waitForHttp(url: string, timeoutMs: number): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + timeoutMs;
+    async function attempt(): Promise<void> {
+      try {
+        const res = await fetch(url);
+        if (res.ok) return resolve();
+      } catch {
+        /* not ready */
+      }
+      if (Date.now() >= deadline) {
+        reject(new Error(`HTTP 응답 없음 (${timeoutMs / 1000}초 초과)`));
+      } else {
+        setTimeout(attempt, 3000);
+      }
+    }
+    attempt();
+  });
+}
+
+function attachLogs(child: ChildProcess, logBuf: string[], source: string, onEvent: EventCallback): void {
+  function handleData(data: Buffer): void {
+    const text = data.toString();
+    logBuf.push(text);
+    for (const line of text.split("\n")) {
+      if (line.trim()) onEvent({ type: "log", source, data: line });
+    }
+  }
+  child.stdout?.on("data", handleData);
+  child.stderr?.on("data", handleData);
+}
+
+// ---------------------------------------------------------------------------
+// Backend (shared, optional)
+// ---------------------------------------------------------------------------
+
+async function ensureBackend(onEvent: EventCallback): Promise<void> {
+  const be = projectConfig?.backend;
+  if (!be) return; // No backend configured
+
+  // Check if already running
+  try {
+    const healthUrl = be.healthCheck?.startsWith("/")
+      ? `http://localhost:${be.port}${be.healthCheck}`
+      : `http://localhost:${be.port}`;
+    const res = await fetch(healthUrl);
+    if (res.ok) {
+      onEvent({ type: "log", source: "sanjang", data: `Backend(:${be.port}) 실행 중 ✓` });
+      return;
+    }
+  } catch {
+    /* not running */
+  }
+
+  onEvent({ type: "log", source: "sanjang", data: `Backend(:${be.port}) 시작 중...` });
+
+  const [cmd = "echo", ...args] = be.command.split(" ");
+  const cwd = be.cwd ? join(getProjectRoot(), be.cwd) : getProjectRoot();
+
+  const beProc = spawn(cmd, args, {
+    cwd,
+    env: { ...process.env, PORT: String(be.port), ...be.env },
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    shell: true,
+  });
+  beProc.unref();
+  sharedBeProc = beProc;
+  beProc.stdout?.on("data", (d: Buffer) => onEvent({ type: "log", source: "backend", data: d.toString() }));
+  beProc.stderr?.on("data", (d: Buffer) => onEvent({ type: "log", source: "backend", data: d.toString() }));
+
+  if (be.healthCheck) {
+    const healthUrl = be.healthCheck.startsWith("/") ? `http://localhost:${be.port}${be.healthCheck}` : be.healthCheck;
+    await waitForHttp(healthUrl, 60_000);
+  } else {
+    await waitForPort(be.port, 60_000);
+  }
+
+  onEvent({ type: "log", source: "sanjang", data: `Backend(:${be.port}) 시작 완료 ✓` });
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+interface StartCampParams {
+  name: string;
+  fePort: number;
+}
+
+export async function startCamp(pg: StartCampParams, onEvent: EventCallback): Promise<number> {
+  const { name, fePort } = pg;
+  const wtPath = campPath(name);
+  const dev = projectConfig?.dev;
+
+  if (!dev) throw new Error("dev command not configured");
+
+  const entry: CampProcessEntry = {
+    feProc: null,
+    feLogs: [],
+    feExitCode: null,
+  };
+  procs.set(name, entry);
+
+  // Step 1: Backend (optional, shared)
+  try {
+    await ensureBackend(onEvent);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    onEvent({ type: "log", source: "sanjang", data: `⚠️ Backend 시작 실패 — FE만 띄웁니다. (${message})` });
+  }
+
+  // Step 2: Frontend
+  onEvent({ type: "log", source: "sanjang", data: "Frontend 준비 중..." });
+  onEvent({ type: "status", data: "starting-frontend" });
+
+  // Build command — try to pass port flag if available, but always verify via stdout
+  const fullCommand = dev.portFlag ? `${dev.command} ${dev.portFlag} ${fePort}` : dev.command;
+  const cwd = dev.cwd ? join(wtPath, dev.cwd) : wtPath;
+
+  const feProc = spawn(fullCommand, [], {
+    cwd,
+    env: {
+      ...process.env,
+      ...dev.env,
+      ...(projectConfig?.backend
+        ? {
+            VITE_API_PROXY_TARGET: `http://localhost:${projectConfig.backend.port}`,
+          }
+        : {}),
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: true,
+  });
+
+  entry.feProc = feProc;
+  attachLogs(feProc, entry.feLogs, "frontend", onEvent);
+  feProc.on("exit", (code: number | null) => {
+    entry.feExitCode = code;
+    onEvent({ type: "process-exit", source: "frontend", data: code });
+  });
+
+  onEvent({ type: "status", data: "waiting-for-vite" });
+
+  // Always detect actual URL from stdout — never guess
+  const detectedPort = await detectPortFromStdout(entry.feLogs, 90_000);
+  if (!detectedPort) {
+    throw new Error("dev 서버가 시작되지 않았습니다. 로그를 확인하세요.");
+  }
+
+  const url = `http://localhost:${detectedPort}`;
+  onEvent({ type: "log", source: "sanjang", data: `Frontend 준비 완료 ✓` });
+  onEvent({ type: "url-detected", data: { url, port: detectedPort } });
+  onEvent({ type: "status", data: "running" });
+  return detectedPort;
+}
+
+export function stopCamp(name: string): void {
+  const entry = procs.get(name);
+  if (!entry) return;
+  if (entry.feProc && !entry.feProc.killed) {
+    entry.feProc.kill("SIGTERM");
+    // SIGKILL fallback if still alive after 5s
+    const proc = entry.feProc;
+    setTimeout(() => {
+      try {
+        if (!proc.killed) proc.kill("SIGKILL");
+      } catch {
+        /* already dead */
+      }
+    }, 5000);
+  }
+  procs.delete(name);
+}
+
+export function stopAllCamps(): void {
+  for (const [name] of procs) {
+    stopCamp(name);
+  }
+  // Kill shared backend if tracked
+  if (sharedBeProc && !sharedBeProc.killed) {
+    try {
+      sharedBeProc.kill("SIGTERM");
+    } catch {
+      /* ignore */
+    }
+    sharedBeProc = null;
+  }
+}
+
+export function getProcessInfo(name: string): ProcessInfo | null {
+  const entry = procs.get(name);
+  if (!entry) return null;
+  return {
+    feLogs: entry.feLogs,
+    feExitCode: entry.feExitCode,
+  };
+}

package/lib/engine/self-heal.ts

@@ -0,0 +1,130 @@
+import { existsSync, copyFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { execSync } from "node:child_process";
+
+// ---------------------------------------------------------------------------
+// Diagnosis: pattern-match logs to identify fixable issues
+// ---------------------------------------------------------------------------
+
+export interface HealAction {
+  type: "reinstall" | "copy-env" | "restart" | "ask-ai";
+  message: string;
+  auto: boolean; // can be fixed without human input
+}
+
+const PATTERNS: Array<{ test: RegExp; action: () => HealAction }> = [
+  {
+    test: /Cannot find module|MODULE_NOT_FOUND/i,
+    action: () => ({
+      type: "reinstall",
+      message: "필요한 패키지가 없습니다. 다시 설치합니다.",
+      auto: true,
+    }),
+  },
+  {
+    test: /does not provide an export named|env\/static\/public/i,
+    action: () => ({
+      type: "copy-env",
+      message: "환경 설정 파일이 없습니다. 메인에서 복사합니다.",
+      auto: true,
+    }),
+  },
+  {
+    test: /ENOENT.*\.env/i,
+    action: () => ({
+      type: "copy-env",
+      message: ".env 파일을 찾을 수 없습니다. 메인에서 복사합니다.",
+      auto: true,
+    }),
+  },
+  {
+    test: /403.*Forbidden|server\.fs\.allow/i,
+    action: () => ({
+      type: "reinstall",
+      message: "파일 접근 문제가 있습니다. 의존성을 다시 설치합니다.",
+      auto: true,
+    }),
+  },
+  {
+    test: /EADDRINUSE|address already in use/i,
+    action: () => ({
+      type: "restart",
+      message: "다른 프로그램과 충돌이 있습니다. 다시 시작합니다.",
+      auto: true,
+    }),
+  },
+];
+
+export function diagnoseFromLogs(logs: string[]): HealAction[] {
+  const combined = logs.join("\n");
+  const actions: HealAction[] = [];
+  const seenTypes = new Set<string>();
+
+  for (const pattern of PATTERNS) {
+    if (pattern.test.test(combined)) {
+      const action = pattern.action();
+      if (!seenTypes.has(action.type)) {
+        seenTypes.add(action.type);
+        actions.push(action);
+      }
+    }
+  }
+
+  return actions;
+}
+
+// ---------------------------------------------------------------------------
+// Heal: execute fixes
+// ---------------------------------------------------------------------------
+
+export interface HealResult {
+  action: HealAction;
+  success: boolean;
+  detail?: string;
+}
+
+export function executeHeal(
+  action: HealAction,
+  campPath: string,
+  projectRoot: string,
+  setupCommand: string | null,
+  copyFiles: string[],
+): HealResult {
+  switch (action.type) {
+    case "reinstall": {
+      if (!setupCommand) return { action, success: false, detail: "설치 명령이 없습니다." };
+      try {
+        execSync(setupCommand, { cwd: campPath, stdio: "pipe", timeout: 120_000, shell: true } as unknown as import("node:child_process").ExecSyncOptions);
+        return { action, success: true };
+      } catch {
+        return { action, success: false, detail: "설치에 실패했습니다." };
+      }
+    }
+
+    case "copy-env": {
+      let copied = 0;
+      for (const file of copyFiles) {
+        const src = join(projectRoot, file);
+        const dst = join(campPath, file);
+        if (existsSync(src) && !existsSync(dst)) {
+          try {
+            mkdirSync(dirname(dst), { recursive: true });
+            copyFileSync(src, dst);
+            copied++;
+          } catch { /* skip */ }
+        }
+      }
+      return { action, success: copied > 0, detail: copied > 0 ? `${copied}개 파일 복사됨` : "복사할 파일이 없습니다." };
+    }
+
+    case "restart":
+      // Restart is handled by the caller (stop + start)
+      return { action, success: true, detail: "재시작을 시도합니다." };
+
+    case "ask-ai":
+      return { action, success: false, detail: "자동 수정할 수 없습니다." };
+
+    default:
+      return { action, success: false, detail: "알 수 없는 액션입니다." };
+  }
+}

package/lib/engine/smart-init.ts

@@ -0,0 +1,136 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Deep env file scanner
+// ---------------------------------------------------------------------------
+
+const ENV_PATTERNS = [".env", ".env.local", ".env.development", ".env.development.local"];
+const SKIP_DIRS = new Set(["node_modules", ".git", ".sanjang", "dist", "build", ".next", ".nuxt", ".svelte-kit"]);
+
+export function deepFindEnvFiles(projectRoot: string, maxDepth: number = 4): string[] {
+  const results: string[] = [];
+
+  function walk(dir: string, depth: number): void {
+    if (depth > maxDepth) return;
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+
+    for (const entry of entries) {
+      if (entry.isFile() && ENV_PATTERNS.includes(entry.name)) {
+        results.push(relative(projectRoot, join(dir, entry.name)));
+      }
+      if (entry.isDirectory() && !SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+        walk(join(dir, entry.name), depth + 1);
+      }
+    }
+  }
+
+  walk(projectRoot, 0);
+  return results.sort();
+}
+
+// ---------------------------------------------------------------------------
+// Setup issue detector
+// ---------------------------------------------------------------------------
+
+export interface SetupIssue {
+  type: "env-reference-no-file" | "bun-cache-skip" | "missing-lockfile" | "turbo-no-filter";
+  message: string;
+  fix?: string;
+}
+
+export function detectSetupIssues(projectRoot: string): SetupIssue[] {
+  const issues: SetupIssue[] = [];
+
+  // 1. Check for env variable references without .env files
+  const hasEnvFile = ENV_PATTERNS.some(f => existsSync(join(projectRoot, f)));
+  if (!hasEnvFile) {
+    const envRefFound = scanForEnvReferences(projectRoot);
+    if (envRefFound) {
+      issues.push({
+        type: "env-reference-no-file",
+        message: "코드에서 환경변수를 참조하지만 .env 파일이 없습니다.",
+        fix: "프로젝트의 .env 파일을 찾아 copyFiles에 추가",
+      });
+    }
+  }
+
+  // 2. Check for bun (cache doesn't work with bun symlinks)
+  if (existsSync(join(projectRoot, "bun.lock")) || existsSync(join(projectRoot, "bun.lockb"))) {
+    issues.push({
+      type: "bun-cache-skip",
+      message: "bun 프로젝트는 캐시 대신 직접 설치합니다.",
+    });
+  }
+
+  // 3. Check for missing lockfile
+  const lockfiles = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "bun.lock"];
+  if (!lockfiles.some(f => existsSync(join(projectRoot, f)))) {
+    issues.push({
+      type: "missing-lockfile",
+      message: "lockfile이 없습니다. 의존성 설치가 느릴 수 있습니다.",
+      fix: "npm install 또는 bun install을 한 번 실행해주세요",
+    });
+  }
+
+  // 4. Check for turbo without filter (multiple apps)
+  if (existsSync(join(projectRoot, "turbo.json"))) {
+    const appCount = countTurboApps(projectRoot);
+    if (appCount > 1) {
+      issues.push({
+        type: "turbo-no-filter",
+        message: `${appCount}개 앱이 감지됨. --filter 없이 실행하면 모든 앱이 동시에 시작됩니다.`,
+        fix: "메인 앱에 --filter 적용",
+      });
+    }
+  }
+
+  return issues;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function scanForEnvReferences(dir: string, depth: number = 0): boolean {
+  if (depth > 3) return false;
+  const envPatterns = /import\.meta\.env\.|process\.env\.|PUBLIC_|VITE_|NEXT_PUBLIC_/;
+
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return false; }
+
+  for (const entry of entries) {
+    if (entry.isFile() && /\.(ts|js|tsx|jsx|svelte|vue)$/.test(entry.name)) {
+      try {
+        const content = readFileSync(join(dir, entry.name), "utf8").slice(0, 5000);
+        if (envPatterns.test(content)) return true;
+      } catch { continue; }
+    }
+    if (entry.isDirectory() && !SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+      if (scanForEnvReferences(join(dir, entry.name), depth + 1)) return true;
+    }
+  }
+  return false;
+}
+
+function countTurboApps(root: string): number {
+  let count = 0;
+  for (const dir of ["apps", "packages"]) {
+    const base = join(root, dir);
+    if (!existsSync(base)) continue;
+    let entries;
+    try { entries = readdirSync(base, { withFileTypes: true }); } catch { continue; }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pkgPath = join(base, entry.name, "package.json");
+      if (!existsSync(pkgPath)) continue;
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as Record<string, unknown>;
+        const scripts = pkg.scripts as Record<string, string> | undefined;
+        if (scripts?.dev) count++;
+      } catch { continue; }
+    }
+  }
+  return count;
+}

package/lib/engine/smart-pr.ts

@@ -0,0 +1,130 @@
+/**
+ * Smart PR description generator.
+ *
+ * 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";
+
+const TIMEOUT_MS = 30_000;
+
+interface SpawnResult {
+  stdout: string;
+  stderr: string;
+  code: number | null;
+  timedOut: boolean;
+}
+
+/**
+ * Run a command asynchronously with a timeout.
+ */
+function run(cmd: string, args: string[], opts: { cwd: string; timeoutMs: number }): Promise<SpawnResult> {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const child = spawn(cmd, args, {
+      cwd: opts.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, FORCE_COLOR: "0" },
+    });
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, opts.timeoutMs);
+
+    child.stdout.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("close", (code: number | null) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr, code, timedOut });
+    });
+
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr, code: null, timedOut });
+    });
+  });
+}
+
+/**
+ * Parse diff --stat output to extract file count.
+ * Example line: " 3 files changed, 10 insertions(+), 2 deletions(-)"
+ */
+export function parseDiffStatSummary(diffStat: string): string {
+  const trimmed = diffStat.trim();
+  if (!trimmed) return "변경사항이 없어요";
+
+  const lines = trimmed.split("\n");
+  const summaryLine = lines[lines.length - 1] ?? "";
+  const filesMatch = /(\d+)\s+files?\s+changed/.exec(summaryLine);
+  const insertMatch = /(\d+)\s+insertions?/.exec(summaryLine);
+  const deleteMatch = /(\d+)\s+deletions?/.exec(summaryLine);
+
+  const fileCount = filesMatch ? parseInt(filesMatch[1]!, 10) : 0;
+  const insertions = insertMatch ? parseInt(insertMatch[1]!, 10) : 0;
+  const deletions = deleteMatch ? parseInt(deleteMatch[1]!, 10) : 0;
+
+  if (fileCount === 0) return "변경사항이 없어요";
+
+  const parts: string[] = [`${fileCount}개 파일을 수정했어요`];
+  if (insertions > 0 || deletions > 0) {
+    parts.push(`(+${insertions}, -${deletions})`);
+  }
+  return parts.join(" ");
+}
+
+/**
+ * Check if claude CLI is available on PATH.
+ */
+function isClaudeAvailable(): boolean {
+  const result = spawnSync("which", ["claude"], { stdio: "pipe" });
+  return result.status === 0;
+}
+
+/**
+ * Generate a PR description for the given worktree path.
+ *
+ * 1. Runs `git diff --stat` and `git diff` in the worktree.
+ * 2. If claude CLI is available, asks it to summarise in Korean.
+ * 3. Falls back to a simple file-count summary otherwise.
+ */
+export async function generatePrDescription(wtPath: string): Promise<string> {
+  // Gather diff info
+  const [statResult, diffResult] = await Promise.all([
+    run("git", ["diff", "--stat", "HEAD"], { cwd: wtPath, timeoutMs: 10_000 }),
+    run("git", ["diff", "HEAD"], { cwd: wtPath, timeoutMs: 10_000 }),
+  ]);
+
+  const diffStat = statResult.stdout.trim();
+  const diff = diffResult.stdout;
+
+  if (!diffStat && !diff.trim()) {
+    return "변경사항이 없어요";
+  }
+
+  // Try claude CLI
+  if (isClaudeAvailable()) {
+    const diffSnippet = diff.slice(0, 500);
+    const prompt = `이 변경사항을 비개발자도 이해할 수 있게 한국어 2-3줄로 설명해줘:\n\n${diffStat}\n\n${diffSnippet}`;
+    const claudeResult = await run("claude", ["-p", prompt, "--output-format", "text"], {
+      cwd: wtPath,
+      timeoutMs: TIMEOUT_MS,
+    });
+
+    if (claudeResult.code === 0 && claudeResult.stdout.trim()) {
+      return claudeResult.stdout.trim();
+    }
+  }
+
+  // Fallback
+  return parseDiffStatSummary(diffStat);
+}