sanjang 0.3.0

package/lib/config.ts

@@ -0,0 +1,337 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import type { DetectedApp, DetectedProject, GenerateConfigResult, SanjangConfig } from "./types.ts";
+import { deepFindEnvFiles, detectSetupIssues } from "./engine/smart-init.ts";
+
+const CONFIG_FILE: string = "sanjang.config.js";
+
+const DEFAULTS: SanjangConfig = {
+  dev: {
+    command: "npm run dev",
+    port: 3000,
+    portFlag: "--port",
+    cwd: ".",
+    env: {},
+  },
+  setup: null,
+  copyFiles: [],
+  backend: null,
+  ports: {
+    fe: { base: 3000, slots: 8 },
+    be: { base: 8000, slots: 8 },
+  },
+};
+
+/**
+ * Load sanjang.config.js from project root.
+ * Returns merged config with defaults.
+ */
+export async function loadConfig(projectRoot: string): Promise<SanjangConfig> {
+  const configPath = join(projectRoot, CONFIG_FILE);
+
+  if (!existsSync(configPath)) {
+    console.warn("⚠️ sanjang.config.js를 찾을 수 없습니다. 기본 설정을 사용합니다.");
+    console.warn("  → sanjang init 으로 프로젝트에 맞는 설정을 생성하세요.");
+    return { ...DEFAULTS, _autoDetected: false };
+  }
+
+  try {
+    const mod = await import(pathToFileURL(configPath).href);
+    const userConfig = mod.default || mod;
+    return mergeConfig(userConfig);
+  } catch (err) {
+    console.error(`sanjang.config.js 로드 실패: ${(err as Error).message}`);
+    return { ...DEFAULTS, _autoDetected: false };
+  }
+}
+
+function mergeConfig(user: Record<string, unknown>): SanjangConfig {
+  const config: SanjangConfig = { ...DEFAULTS };
+
+  if (typeof user.dev === "string") {
+    config.dev = { ...DEFAULTS.dev, command: user.dev };
+  } else if (user.dev) {
+    config.dev = { ...DEFAULTS.dev, ...(user.dev as Partial<SanjangConfig["dev"]>) };
+  }
+
+  if (user.setup) config.setup = user.setup as string;
+  if (user.copyFiles) config.copyFiles = user.copyFiles as string[];
+  if (user.backend) config.backend = user.backend as SanjangConfig["backend"];
+  if (user.ports) {
+    const userPorts = user.ports as Partial<SanjangConfig["ports"]>;
+    config.ports = {
+      fe: { ...DEFAULTS.ports.fe, ...userPorts.fe },
+      be: { ...DEFAULTS.ports.be, ...userPorts.be },
+    };
+  }
+
+  return config;
+}
+
+/**
+ * Auto-detect project type and generate config.
+ */
+export function detectProject(projectRoot: string): DetectedProject {
+  const has = (f: string): boolean => existsSync(join(projectRoot, f));
+  const readJson = (f: string): Record<string, unknown> | null => {
+    try {
+      return JSON.parse(readFileSync(join(projectRoot, f), "utf8")) as Record<string, unknown>;
+    } catch {
+      return null;
+    }
+  };
+
+  // Framework detection
+  if (has("next.config.js") || has("next.config.mjs") || has("next.config.ts")) {
+    return {
+      framework: "Next.js",
+      dev: { command: "npx next dev", port: 3000, portFlag: "-p", cwd: ".", env: {} },
+      setup: has("bun.lockb") ? "bun install" : has("pnpm-lock.yaml") ? "pnpm install" : "npm install",
+      copyFiles: findEnvFiles(projectRoot),
+    };
+  }
+
+  if (has("nuxt.config.js") || has("nuxt.config.ts")) {
+    return {
+      framework: "Nuxt",
+      dev: { command: "npx nuxt dev", port: 3000, portFlag: "--port", cwd: ".", env: {} },
+      setup: detectPackageManager(projectRoot),
+      copyFiles: findEnvFiles(projectRoot),
+    };
+  }
+
+  if (has("svelte.config.js") || has("svelte.config.ts")) {
+    return {
+      framework: "SvelteKit",
+      dev: { command: "npx vite dev", port: 5173, portFlag: "--port", cwd: ".", env: {} },
+      setup: detectPackageManager(projectRoot),
+      copyFiles: findEnvFiles(projectRoot),
+    };
+  }
+
+  if (has("angular.json")) {
+    return {
+      framework: "Angular",
+      dev: { command: "npx ng serve", port: 4200, portFlag: "--port", cwd: ".", env: {} },
+      setup: "npm install",
+      copyFiles: findEnvFiles(projectRoot),
+    };
+  }
+
+  if (has("vite.config.js") || has("vite.config.ts") || has("vite.config.mjs")) {
+    return {
+      framework: "Vite",
+      dev: { command: "npx vite dev", port: 5173, portFlag: "--port", cwd: ".", env: {} },
+      setup: detectPackageManager(projectRoot),
+      copyFiles: findEnvFiles(projectRoot),
+    };
+  }
+
+  // ClojureScript / shadow-cljs (root or common subdirectories)
+  const shadowDirs = [".", "frontend", "client", "web", "app"];
+  for (const dir of shadowDirs) {
+    const prefix = dir === "." ? "" : `${dir}/`;
+    if (has(`${prefix}shadow-cljs.edn`)) {
+      const hasBb = has(`${prefix}bb.edn`);
+      return {
+        framework: "shadow-cljs",
+        dev: { command: hasBb ? "bb dev" : "npx shadow-cljs watch app", port: 3000, portFlag: null, cwd: dir, env: {} },
+        setup: "npm install",
+        copyFiles: findEnvFiles(projectRoot),
+      };
+    }
+  }
+
+  // Monorepo detection
+  if (has("turbo.json")) {
+    const mainApp = detectTurboMainApp(projectRoot);
+    const filter = mainApp ? ` --filter=${mainApp.name}` : "";
+    const port = mainApp?.port ?? 3000;
+    return {
+      framework: "Turborepo",
+      dev: { command: `npx turbo run dev${filter}`, port, portFlag: null, cwd: ".", env: {} },
+      setup: detectPackageManager(projectRoot),
+      copyFiles: findEnvFiles(projectRoot),
+      _note: mainApp
+        ? `Turborepo: filtered to ${mainApp.name} (port ${port}).`
+        : "Turborepo detected. You may need to adjust the dev command to filter a specific app.",
+    };
+  }
+
+  // Fallback: package.json scripts
+  const pkg = readJson("package.json");
+  if ((pkg?.scripts as Record<string, unknown> | undefined)?.dev) {
+    return {
+      framework: "Node.js",
+      dev: { command: "npm run dev", port: 3000, portFlag: "--port", cwd: ".", env: {} },
+      setup: detectPackageManager(projectRoot),
+      copyFiles: findEnvFiles(projectRoot),
+    };
+  }
+
+  return {
+    framework: "unknown",
+    dev: { command: "npm run dev", port: 3000, portFlag: "--port", cwd: ".", env: {} },
+    setup: "npm install",
+    copyFiles: [],
+  };
+}
+
+/**
+ * Scan first-level subdirectories for app candidates.
+ * Returns array of { dir, framework, detected } sorted by dir name.
+ */
+export function detectApps(projectRoot: string): DetectedApp[] {
+  const entries = readdirSync(projectRoot, { withFileTypes: true });
+  const ignore = new Set(["node_modules", ".git", ".sanjang", "dist", "build", ".next", ".nuxt"]);
+
+  const apps: DetectedApp[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith(".") || ignore.has(entry.name)) continue;
+
+    const subPath = join(projectRoot, entry.name);
+    const detected = detectProject(subPath);
+    if (detected.framework === "unknown") continue;
+
+    apps.push({
+      dir: entry.name,
+      framework: detected.framework,
+      detected,
+    });
+  }
+
+  return apps.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+
+interface TurboAppInfo {
+  name: string;
+  port: number;
+}
+
+function detectTurboMainApp(root: string): TurboAppInfo | null {
+  // Scan apps/*/package.json for the main app (has dev script with --port or vite/next)
+  const appDirs = ["apps", "packages"];
+  const candidates: TurboAppInfo[] = [];
+
+  for (const dir of appDirs) {
+    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;
+      // Skip storybook, demo, docs apps
+      if (/storybook|demo|docs|e2e|test/i.test(entry.name)) 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;
+        const devScript = scripts?.dev;
+        if (!devScript) continue;
+        const portMatch = devScript.match(/--port\s+(\d+)/);
+        const port = portMatch?.[1] ? parseInt(portMatch[1], 10) : 3000;
+        candidates.push({ name: entry.name, port });
+      } catch { continue; }
+    }
+  }
+
+  // Prefer app with explicit port, then first candidate
+  return candidates.find(c => c.port !== 3000) ?? candidates[0] ?? null;
+}
+
+function detectPackageManager(root: string): string {
+  if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock"))) return "bun install";
+  if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync(join(root, "yarn.lock"))) return "yarn install";
+  return "npm install";
+}
+
+function findEnvFiles(root: string): string[] {
+  const envFiles = [".env", ".env.local", ".env.development", ".env.development.local"];
+  return envFiles.filter((f) => existsSync(join(root, f)));
+}
+
+export function generateConfig(
+  projectRoot: string,
+  options: { appDir?: string; force?: boolean } = {},
+): GenerateConfigResult {
+  const { appDir, force } = options;
+  const configPath = join(projectRoot, CONFIG_FILE);
+
+  if (existsSync(configPath) && !force) {
+    return { created: false, message: "sanjang.config.js already exists." };
+  }
+
+  // Detect from selected app subdirectory or root
+  const detectRoot = appDir ? join(projectRoot, appDir) : projectRoot;
+  const detected = detectProject(detectRoot);
+
+  // Override cwd and setup for subdirectory apps
+  if (appDir && appDir !== ".") {
+    detected.dev.cwd = appDir;
+    if (detected.setup) {
+      detected.setup = `cd '${appDir.replace(/'/g, "'\\''")}' && ${detected.setup}`;
+    }
+  }
+
+  // Smart env detection — scan entire project tree, not just root
+  detected.copyFiles = deepFindEnvFiles(projectRoot).filter(
+    // Exclude .env.example, .env.test, .env.template
+    (f) => !f.includes("example") && !f.includes("template") && !f.includes(".test"),
+  );
+
+  // Detect potential issues
+  const issues = detectSetupIssues(detectRoot);
+
+  const lines = [
+    "export default {",
+    `  // ${detected.framework} detected`,
+    "",
+    "  // Dev server command",
+    "  dev: {",
+    `    command: '${detected.dev.command}',`,
+    `    port: ${detected.dev.port},`,
+    `    portFlag: ${detected.dev.portFlag ? `'${detected.dev.portFlag}'` : "null"},`,
+    `    cwd: '${detected.dev.cwd}',`,
+    "  },",
+    "",
+  ];
+
+  if (detected.setup) {
+    lines.push(`  // Install dependencies after creating a camp`);
+    lines.push(`  setup: ${JSON.stringify(detected.setup)},`);
+    lines.push("");
+  }
+
+  if (detected.copyFiles.length) {
+    lines.push("  // Copy gitignored files from main repo");
+    lines.push(`  copyFiles: ${JSON.stringify(detected.copyFiles)},`);
+    lines.push("");
+  }
+
+  if (detected._note) {
+    lines.push(`  // NOTE: ${detected._note}`);
+    lines.push("");
+  }
+
+  lines.push("  // (optional) Backend server");
+  lines.push("  // backend: {");
+  lines.push("  //   command: 'npm run start:api',");
+  lines.push("  //   port: 8000,");
+  lines.push("  //   healthCheck: '/health',");
+  lines.push("  // },");
+  lines.push("};");
+  lines.push("");
+
+  writeFileSync(configPath, lines.join("\n"), "utf8");
+
+  return {
+    created: true,
+    framework: detected.framework,
+    configPath,
+    message: `sanjang.config.js created (${detected.framework} detected).`,
+  };
+}

package/lib/engine/cache.ts

@@ -0,0 +1,218 @@
+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));
+  });
+}