sanjang 0.3.0 → 0.3.2

package/lib/engine/cache.ts

@@ -1,218 +0,0 @@
-import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
-import type { CacheApplyResult, CacheBuildResult, CacheValidation, LockfileInfo, SanjangConfig } from "../types.ts";
-
-const LOCKFILES: readonly string[] = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "bun.lock"];
-
-// ---------------------------------------------------------------------------
-// Lockfile helpers
-// ---------------------------------------------------------------------------
-
-export function findLockfile(dir: string): LockfileInfo | null {
-  for (const name of LOCKFILES) {
-    const p = join(dir, name);
-    if (existsSync(p)) return { path: p, name };
-  }
-  return null;
-}
-
-export function hashLockfile(lockfilePath: string): string {
-  const content = readFileSync(lockfilePath);
-  return createHash("sha256").update(content).digest("hex");
-}
-
-// ---------------------------------------------------------------------------
-// Cache directory
-// ---------------------------------------------------------------------------
-
-export function getCacheDir(projectRoot: string): string {
-  return join(projectRoot, ".sanjang", "cache");
-}
-
-function getCacheModulesDir(projectRoot: string, setupCwd: string): string {
-  const base = getCacheDir(projectRoot);
-  return setupCwd === "." ? join(base, "node_modules") : join(base, setupCwd, "node_modules");
-}
-
-function getHashFile(projectRoot: string, setupCwd: string = "."): string {
-  const base = getCacheDir(projectRoot);
-  const name = setupCwd === "." ? "lockfile.hash" : `lockfile-${setupCwd.replace(/\//g, "-")}.hash`;
-  return join(base, name);
-}
-
-// ---------------------------------------------------------------------------
-// Cache validation
-// ---------------------------------------------------------------------------
-
-export function isCacheValid(projectRoot: string, setupCwd: string): CacheValidation {
-  const cacheModules = getCacheModulesDir(projectRoot, setupCwd);
-  if (!existsSync(cacheModules)) {
-    return { valid: false, reason: "cache not found" };
-  }
-
-  const hashFile = getHashFile(projectRoot, setupCwd);
-  if (!existsSync(hashFile)) {
-    return { valid: false, reason: "no hash file" };
-  }
-
-  const srcDir = setupCwd === "." ? projectRoot : join(projectRoot, setupCwd);
-  const lockfile = findLockfile(srcDir);
-  if (!lockfile) {
-    return { valid: false, reason: "no lockfile in project" };
-  }
-
-  const storedHash = readFileSync(hashFile, "utf8").trim();
-  const currentHash = hashLockfile(lockfile.path);
-
-  if (storedHash !== currentHash) {
-    return { valid: false, reason: "lockfile changed" };
-  }
-
-  return { valid: true };
-}
-
-// ---------------------------------------------------------------------------
-// Find all node_modules dirs (monorepo support)
-// ---------------------------------------------------------------------------
-
-function findAllNodeModules(baseDir: string, maxDepth: number = 4): string[] {
-  const results: string[] = [];
-  function walk(dir: string, depth: number): void {
-    if (depth > maxDepth) return;
-    if (!existsSync(dir)) return;
-    let entries: import("node:fs").Dirent[];
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name === "node_modules") {
-        results.push(join(dir, entry.name));
-      } else if (!entry.name.startsWith(".")) {
-        walk(join(dir, entry.name), depth + 1);
-      }
-    }
-  }
-  walk(baseDir, 0);
-  return results;
-}
-
-// ---------------------------------------------------------------------------
-// Build cache
-// ---------------------------------------------------------------------------
-
-export async function buildCache(
-  projectRoot: string,
-  config: Pick<SanjangConfig, "dev" | "setup">,
-  onLog?: (msg: string) => void,
-): Promise<CacheBuildResult> {
-  const start = Date.now();
-  const setupCwd = config.dev?.cwd || ".";
-  const srcDir = setupCwd === "." ? projectRoot : join(projectRoot, setupCwd);
-  const modulesDir = join(srcDir, "node_modules");
-
-  const lockfile = findLockfile(srcDir);
-  if (!lockfile) {
-    return { success: false, error: "lockfile not found", duration: Date.now() - start };
-  }
-
-  if (!existsSync(modulesDir)) {
-    if (!config.setup) {
-      return { success: false, error: "no setup command and no node_modules", duration: Date.now() - start };
-    }
-
-    onLog?.("node_modules가 없습니다. 설치를 실행합니다...");
-    const exitCode = await runSetup(config.setup, projectRoot, onLog);
-    if (exitCode !== 0) {
-      return { success: false, error: `setup failed (exit ${exitCode})`, duration: Date.now() - start };
-    }
-
-    if (!existsSync(modulesDir)) {
-      return { success: false, error: "setup completed but node_modules not found", duration: Date.now() - start };
-    }
-  }
-
-  const allModules = findAllNodeModules(srcDir);
-  onLog?.(`캐시에 node_modules를 저장합니다... (${allModules.length}개 디렉토리)`);
-
-  const cacheDir = getCacheDir(projectRoot);
-  const cacheBase = setupCwd === "." ? cacheDir : join(cacheDir, setupCwd);
-
-  if (existsSync(cacheBase)) {
-    rmSync(cacheBase, { recursive: true, force: true });
-  }
-  mkdirSync(cacheBase, { recursive: true });
-
-  try {
-    for (const modDir of allModules) {
-      const rel = relative(srcDir, modDir);
-      const target = join(cacheBase, rel);
-      mkdirSync(join(target, ".."), { recursive: true });
-      cpSync(modDir, target, { recursive: true });
-    }
-  } catch (err) {
-    return { success: false, error: `cache copy failed: ${(err as Error).message}`, duration: Date.now() - start };
-  }
-
-  writeFileSync(getHashFile(projectRoot, setupCwd), hashLockfile(lockfile.path), "utf8");
-
-  const duration = Date.now() - start;
-  onLog?.(`캐시 저장 완료 (${allModules.length}개, ${(duration / 1000).toFixed(1)}초)`);
-  return { success: true, duration };
-}
-
-// ---------------------------------------------------------------------------
-// Apply cache to worktree
-// ---------------------------------------------------------------------------
-
-export function applyCacheToWorktree(projectRoot: string, wtPath: string, setupCwd: string): CacheApplyResult {
-  const start = Date.now();
-  const validity = isCacheValid(projectRoot, setupCwd);
-
-  if (!validity.valid) {
-    return { applied: false, reason: validity.reason };
-  }
-
-  const cacheBase = setupCwd === "." ? getCacheDir(projectRoot) : join(getCacheDir(projectRoot), setupCwd);
-  const targetBase = setupCwd === "." ? wtPath : join(wtPath, setupCwd);
-
-  const cachedModules = findAllNodeModules(cacheBase);
-  if (cachedModules.length === 0) {
-    return { applied: false, reason: "no cached node_modules found" };
-  }
-
-  try {
-    for (const cachedDir of cachedModules) {
-      const rel = relative(cacheBase, cachedDir);
-      const target = join(targetBase, rel);
-      mkdirSync(join(target, ".."), { recursive: true });
-      cpSync(cachedDir, target, { recursive: true });
-    }
-  } catch (err) {
-    return { applied: false, reason: `clone failed: ${(err as Error).message}` };
-  }
-
-  return { applied: true, duration: Date.now() - start, count: cachedModules.length };
-}
-
-// ---------------------------------------------------------------------------
-// Internal: run setup command
-// ---------------------------------------------------------------------------
-
-function runSetup(command: string, cwd: string, onLog?: (msg: string) => void): Promise<number> {
-  return new Promise((resolve) => {
-    const proc = spawn(command, [], {
-      cwd,
-      shell: true,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    proc.stdout.on("data", (d: Buffer) => onLog?.(d.toString().trimEnd()));
-    proc.stderr.on("data", (d: Buffer) => onLog?.(d.toString().trimEnd()));
-    proc.on("close", (code: number | null) => resolve(code ?? 1));
-    proc.on("error", () => resolve(1));
-  });
-}

package/lib/engine/config-hotfix.ts

@@ -1,161 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { deepFindEnvFiles } from "./smart-init.ts";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface ConfigFix {
-  type: "add-copyfiles" | "update-setup" | "info";
-  description: string;
-  patch: Record<string, unknown>; // the values to add/change
-}
-
-// ---------------------------------------------------------------------------
-// Pattern matchers
-// ---------------------------------------------------------------------------
-
-interface PatternMatcher {
-  test: RegExp;
-  buildFix: (projectRoot: string, match: RegExpMatchArray) => ConfigFix | null;
-}
-
-const PATTERNS: PatternMatcher[] = [
-  {
-    // SvelteKit / Vite: "does not provide an export named 'PUBLIC_*'"
-    test: /does not provide an export named '(PUBLIC_\w+)'/,
-    buildFix(projectRoot: string, _match: RegExpMatchArray): ConfigFix | null {
-      const envFiles = deepFindEnvFiles(projectRoot).filter(
-        (f) => !f.includes("example") && !f.includes("template") && !f.includes(".test"),
-      );
-      if (envFiles.length === 0) return null;
-      return {
-        type: "add-copyfiles",
-        description: `환경변수 참조 오류 — copyFiles에 ${envFiles.join(", ")}을 추가합니다.`,
-        patch: { copyFiles: envFiles },
-      };
-    },
-  },
-  {
-    // Port mismatch: "Port X is in use, trying another one"
-    test: /Port (\d+) is in use/,
-    buildFix(_projectRoot: string, match: RegExpMatchArray): ConfigFix | null {
-      const port = match[1];
-      return {
-        type: "info",
-        description: `포트 ${port}이(가) 이미 사용 중입니다. 다른 캠프가 실행 중인지 확인하세요.`,
-        patch: { _conflictPort: Number(port) },
-      };
-    },
-  },
-  {
-    // Module not found after fresh install → setup command might be wrong
-    test: /Cannot find module '([^']+)'/,
-    buildFix(_projectRoot: string, match: RegExpMatchArray): ConfigFix | null {
-      const moduleName = match[1];
-      return {
-        type: "update-setup",
-        description: `모듈 '${moduleName}'을(를) 찾을 수 없습니다. setup 명령이 올바른지 확인하세요.`,
-        patch: { _missingModule: moduleName },
-      };
-    },
-  },
-];
-
-// ---------------------------------------------------------------------------
-// suggestConfigFix — analyze logs and return a fix, or null
-// ---------------------------------------------------------------------------
-
-export function suggestConfigFix(projectRoot: string, logs: string[]): ConfigFix | null {
-  const combined = logs.join("\n");
-
-  for (const pattern of PATTERNS) {
-    const match = combined.match(pattern.test);
-    if (match) {
-      const fix = pattern.buildFix(projectRoot, match);
-      if (fix) return fix;
-    }
-  }
-
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// applyConfigFix — modify sanjang.config.js in place
-// ---------------------------------------------------------------------------
-
-const CONFIG_FILE = "sanjang.config.js";
-
-export function applyConfigFix(projectRoot: string, fix: ConfigFix): boolean {
-  const configPath = join(projectRoot, CONFIG_FILE);
-  if (!existsSync(configPath)) return false;
-
-  let content: string;
-  try {
-    content = readFileSync(configPath, "utf8");
-  } catch {
-    return false;
-  }
-
-  switch (fix.type) {
-    case "add-copyfiles": {
-      const newFiles = fix.patch.copyFiles as string[];
-      if (!newFiles || newFiles.length === 0) return false;
-      content = mergeCopyFiles(content, newFiles);
-      break;
-    }
-    case "update-setup": {
-      // Informational — we don't auto-change setup without explicit user input
-      return false;
-    }
-    case "info": {
-      // Purely informational, nothing to write
-      return false;
-    }
-    default:
-      return false;
-  }
-
-  try {
-    writeFileSync(configPath, content, "utf8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Merge new file paths into the existing copyFiles array inside the config
- * source text.  If copyFiles doesn't exist, insert it before the closing `};`.
- */
-function mergeCopyFiles(source: string, newFiles: string[]): string {
-  // Try to find existing copyFiles: [...]
-  const copyFilesRe = /copyFiles:\s*\[([^\]]*)\]/;
-  const match = source.match(copyFilesRe);
-
-  if (match) {
-    // Parse existing entries
-    const existing = match[1]!
-      .split(",")
-      .map((s) => s.trim().replace(/^['"]|['"]$/g, ""))
-      .filter(Boolean);
-
-    const merged = [...new Set([...existing, ...newFiles])];
-    const formatted = merged.map((f) => `'${f}'`).join(", ");
-    return source.replace(copyFilesRe, `copyFiles: [${formatted}]`);
-  }
-
-  // No copyFiles field — insert before the last `};`
-  const formatted = newFiles.map((f) => `'${f}'`).join(", ");
-  const insertion = `  copyFiles: [${formatted}],\n`;
-
-  const closingIdx = source.lastIndexOf("};");
-  if (closingIdx === -1) return source; // malformed config, bail
-
-  return source.slice(0, closingIdx) + insertion + source.slice(closingIdx);
-}

package/lib/engine/conflict.ts

@@ -1,33 +0,0 @@
-/**
- * Conflict detection and Claude-based resolution helpers.
- */
-
-/**
- * Parse `git status --porcelain` output to find conflicted files.
- * Conflict markers: UU (both modified), AA (both added), DD, AU, UA, DU, UD
- */
-export function parseConflictFiles(statusOutput: string | null | undefined): string[] {
-  if (!statusOutput?.trim()) return [];
-  return statusOutput
-    .trim()
-    .split("\n")
-    .filter((line) => /^(UU|AA|DD|AU|UA|DU|UD)\s/.test(line))
-    .map((line) => line.slice(3).trim());
-}
-
-/**
- * Build a Claude prompt to resolve merge conflicts.
- */
-export function buildConflictPrompt(conflictFiles: string[]): string {
-  return [
-    "아래 파일들에 git merge 충돌이 발생했습니다.",
-    "각 파일의 충돌 마커(<<<<<<< ======= >>>>>>>)를 읽고,",
-    "두 버전의 의도를 모두 살려서 충돌을 해결해주세요.",
-    "해결 후 충돌 마커는 완전히 제거해야 합니다.",
-    "",
-    "충돌 파일 목록:",
-    ...conflictFiles.map((f) => `- ${f}`),
-    "",
-    "각 파일을 읽고 수정해주세요.",
-  ].join("\n");
-}

package/lib/engine/diagnostics.ts

@@ -1,81 +0,0 @@
-import { execSync } from "node:child_process";
-
-interface ProcessInfo {
-  feLogs?: string[];
-  feExitCode: number | null;
-}
-
-interface PlaygroundInfo {
-  fePort: number;
-}
-
-interface DiagnosticCheck {
-  name: string;
-  status: string;
-  detail: string;
-  guide: string | null;
-}
-
-function tryExec(cmd: string): string | null {
-  try {
-    return execSync(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-  } catch {
-    return null;
-  }
-}
-
-function checkPortConflict(processInfo: ProcessInfo): DiagnosticCheck {
-  const combined = (processInfo.feLogs ?? []).join("");
-  const hit = /address already in use/i.test(combined);
-  return {
-    name: "port-conflict",
-    status: hit ? "error" : "ok",
-    detail: hit ? "다른 프로그램과 충돌이 발생했습니다." : "정상.",
-    guide: hit
-      ? '"중지" → "시작"을 눌러보세요. 계속되면 "삭제" 후 다시 만들어보세요.'
-      : null,
-  };
-}
-
-function checkFrontendExit(processInfo: ProcessInfo): DiagnosticCheck {
-  const { feExitCode, feLogs } = processInfo;
-
-  if (feExitCode === null || feExitCode === 0) {
-    return {
-      name: "frontend-exit",
-      status: "ok",
-      detail: feExitCode === 0 ? "Frontend가 정상 종료되었습니다." : "Frontend 프로세스 실행 중.",
-      guide: null,
-    };
-  }
-
-  const tail = (feLogs ?? []).join("").slice(-500);
-  const isModuleError = /MODULE_NOT_FOUND|Cannot find module/i.test(tail);
-  const guide = isModuleError
-    ? '필요한 패키지가 없어요. "처음부터 다시"를 눌러 의존성을 다시 설치해보세요.'
-    : '서버가 에러로 종료됐어요. "처음부터 다시"를 누르거나, "디버그" 버튼으로 로그를 복사해서 Claude에게 물어보세요.';
-  return {
-    name: "frontend-exit",
-    status: "error",
-    detail: `Frontend가 비정상 종료되었습니다 (코드 ${feExitCode}).`,
-    guide,
-  };
-}
-
-function checkFePort(pg: PlaygroundInfo): DiagnosticCheck {
-  const port = pg.fePort;
-  const output = tryExec(`lsof -i :${port} -t`);
-
-  return {
-    name: "fe-status",
-    status: output?.length ? "ok" : "warn",
-    detail: output?.length
-      ? "Frontend 서버가 실행 중입니다."
-      : "Frontend 서버가 응답하지 않습니다.",
-    guide: !output?.length ? '"시작" 버튼을 눌러보세요.' : null,
-  };
-}
-
-export async function buildDiagnostics(pg: PlaygroundInfo, processInfo: ProcessInfo): Promise<DiagnosticCheck[]> {
-  return [checkPortConflict(processInfo), checkFrontendExit(processInfo), checkFePort(pg)];
-}

package/lib/engine/naming.ts

@@ -1,93 +0,0 @@
-import { spawnSync } from "node:child_process";
-
-/**
- * Generate a short English slug from a task description using AI.
- * Returns null if AI is unavailable — caller should fallback to slugify().
- */
-export function aiSlugify(description: string): string | null {
-  try {
-    const result = spawnSync(
-      "claude",
-      ["-p", "--model", "haiku", `Convert this task description to a kebab-case English slug. Rules: 3-5 words, max 30 chars, lowercase, descriptive (not just one word), no explanation, output ONLY the slug.\n\nExample: "로그인 버튼 색상 변경" → "login-button-color-change"\nExample: "대시보드 차트 추가" → "dashboard-chart-add"\n\nTask: "${description}"`],
-      { encoding: "utf8", stdio: "pipe", timeout: 10_000 },
-    );
-    if (result.status !== 0) return null;
-    const slug = (result.stdout ?? "").trim().toLowerCase().replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "");
-    if (!slug || slug.length > 30) return null;
-    return slug;
-  } catch {
-    return null;
-  }
-}
-
-// Korean → romanized mappings for common dev terms
-const KOREAN_MAP: Record<string, string> = {
-  로그인: "login",
-  버튼: "button",
-  페이지: "page",
-  추가: "add",
-  수정: "fix",
-  삭제: "delete",
-  변경: "change",
-  개선: "improve",
-  색상: "color",
-  대시보드: "dashboard",
-  설정: "settings",
-  사용자: "user",
-  관리: "manage",
-  목록: "list",
-  검색: "search",
-  필터: "filter",
-  정렬: "sort",
-  알림: "notification",
-  권한: "permission",
-  기기: "device",
-  소프트웨어: "software",
-  자산: "asset",
-  구성원: "member",
-  보고서: "report",
-  차트: "chart",
-  테이블: "table",
-  폼: "form",
-  모달: "modal",
-  메뉴: "menu",
-  헤더: "header",
-  푸터: "footer",
-  사이드바: "sidebar",
-  카드: "card",
-  탭: "tab",
-  에러: "error",
-  로딩: "loading",
-  빈: "empty",
-  새: "new",
-  기존: "existing",
-};
-
-/**
- * Convert a task description (Korean or English) to a kebab-case branch-safe slug.
- * Max 50 chars.
- */
-export function slugify(text: string): string {
-  let result: string = text.toLowerCase();
-
-  // Replace known Korean words with English
-  for (const [ko, en] of Object.entries(KOREAN_MAP)) {
-    result = result.replaceAll(ko, en);
-  }
-
-  // Remove remaining non-ASCII (unmapped Korean etc.)
-  result = result.replace(/[^\x00-\x7F]/g, "");
-
-  // Replace non-alphanumeric with hyphens
-  result = result.replace(/[^a-z0-9]+/g, "-");
-
-  // Clean up leading/trailing/double hyphens
-  result = result.replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
-
-  // Truncate to 50 chars at word boundary
-  if (result.length > 50) {
-    result = result.slice(0, 50).replace(/-[^-]*$/, "");
-  }
-
-  return result || "camp";
-}

package/lib/engine/ports.ts

@@ -1,61 +0,0 @@
-import { execSync } from "node:child_process";
-import type { Camp, PortAllocation, PortStatus, PortsConfig } from "../types.ts";
-
-const portConfig: PortsConfig = {
-  fe: { base: 3000, slots: 8 },
-  be: { base: 8000, slots: 8 },
-};
-
-export function setPortConfig(config: Partial<PortsConfig>): void {
-  if (config?.fe) portConfig.fe = config.fe;
-  if (config?.be) portConfig.be = config.be;
-}
-
-export function portsForSlot(slot: number): { fePort: number; bePort: number } {
-  return {
-    fePort: portConfig.fe.base + slot,
-    bePort: portConfig.be.base + slot,
-  };
-}
-
-function isPortBusy(port: number): boolean {
-  try {
-    const out = execSync(`lsof -i :${port} -t 2>/dev/null`, { encoding: "utf8" }).trim();
-    return out.length > 0;
-  } catch {
-    return false;
-  }
-}
-
-export function scanPorts(): PortStatus[] {
-  const status: PortStatus[] = [];
-  const maxSlots = Math.max(portConfig.fe.slots, portConfig.be.slots);
-  for (let slot = 0; slot < maxSlots; slot++) {
-    const { fePort, bePort } = portsForSlot(slot);
-    status.push({
-      slot,
-      fePort,
-      feBusy: isPortBusy(fePort),
-      bePort,
-      beBusy: isPortBusy(bePort),
-    });
-  }
-  return status;
-}
-
-export function allocate(existingCamps: Pick<Camp, "slot">[]): PortAllocation {
-  const usedSlots = new Set(existingCamps.map((p) => p.slot));
-  const maxSlots = portConfig.fe.slots;
-
-  for (let slot = 1; slot < maxSlots; slot++) {
-    if (usedSlots.has(slot)) continue;
-    const { fePort, bePort } = portsForSlot(slot);
-    if (!isPortBusy(fePort) && !isPortBusy(bePort)) {
-      return { slot, fePort, bePort };
-    }
-  }
-
-  throw new Error("사용 가능한 포트가 없습니다. 다른 프로그램이 포트를 점유하고 있거나, 캠프를 정리해주세요.");
-}
-
-export function release(_name: string): void {}