sanjang 0.3.1 → 0.3.3

package/dist/lib/config.js

@@ -0,0 +1,318 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { deepFindEnvFiles, detectSetupIssues } from "./engine/smart-init.js";
+const CONFIG_FILE = "sanjang.config.js";
+const DEFAULTS = {
+    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) {
+    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(__rewriteRelativeImportExtension(pathToFileURL(configPath).href));
+        const userConfig = mod.default || mod;
+        return mergeConfig(userConfig);
+    }
+    catch (err) {
+        console.error(`sanjang.config.js 로드 실패: ${err.message}`);
+        return { ...DEFAULTS, _autoDetected: false };
+    }
+}
+function mergeConfig(user) {
+    const config = { ...DEFAULTS };
+    if (typeof user.dev === "string") {
+        config.dev = { ...DEFAULTS.dev, command: user.dev };
+    }
+    else if (user.dev) {
+        config.dev = { ...DEFAULTS.dev, ...user.dev };
+    }
+    if (user.setup)
+        config.setup = user.setup;
+    if (user.copyFiles)
+        config.copyFiles = user.copyFiles;
+    if (user.backend)
+        config.backend = user.backend;
+    if (user.ports) {
+        const userPorts = user.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) {
+    const has = (f) => existsSync(join(projectRoot, f));
+    const readJson = (f) => {
+        try {
+            return JSON.parse(readFileSync(join(projectRoot, f), "utf8"));
+        }
+        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?.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) {
+    const entries = readdirSync(projectRoot, { withFileTypes: true });
+    const ignore = new Set(["node_modules", ".git", ".sanjang", "dist", "build", ".next", ".nuxt"]);
+    const apps = [];
+    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));
+}
+function detectTurboMainApp(root) {
+    // Scan apps/*/package.json for the main app (has dev script with --port or vite/next)
+    const appDirs = ["apps", "packages"];
+    const candidates = [];
+    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"));
+                const scripts = pkg.scripts;
+                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) {
+    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) {
+    const envFiles = [".env", ".env.local", ".env.development", ".env.development.local"];
+    return envFiles.filter((f) => existsSync(join(root, f)));
+}
+export function generateConfig(projectRoot, options = {}) {
+    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/dist/lib/engine/cache.d.ts

@@ -0,0 +1,7 @@
+import type { CacheApplyResult, CacheBuildResult, CacheValidation, LockfileInfo, SanjangConfig } from "../types.ts";
+export declare function findLockfile(dir: string): LockfileInfo | null;
+export declare function hashLockfile(lockfilePath: string): string;
+export declare function getCacheDir(projectRoot: string): string;
+export declare function isCacheValid(projectRoot: string, setupCwd: string): CacheValidation;
+export declare function buildCache(projectRoot: string, config: Pick<SanjangConfig, "dev" | "setup">, onLog?: (msg: string) => void): Promise<CacheBuildResult>;
+export declare function applyCacheToWorktree(projectRoot: string, wtPath: string, setupCwd: string): CacheApplyResult;

package/dist/lib/engine/cache.js

@@ -0,0 +1,183 @@
+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";
+const LOCKFILES = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "bun.lock"];
+// ---------------------------------------------------------------------------
+// Lockfile helpers
+// ---------------------------------------------------------------------------
+export function findLockfile(dir) {
+    for (const name of LOCKFILES) {
+        const p = join(dir, name);
+        if (existsSync(p))
+            return { path: p, name };
+    }
+    return null;
+}
+export function hashLockfile(lockfilePath) {
+    const content = readFileSync(lockfilePath);
+    return createHash("sha256").update(content).digest("hex");
+}
+// ---------------------------------------------------------------------------
+// Cache directory
+// ---------------------------------------------------------------------------
+export function getCacheDir(projectRoot) {
+    return join(projectRoot, ".sanjang", "cache");
+}
+function getCacheModulesDir(projectRoot, setupCwd) {
+    const base = getCacheDir(projectRoot);
+    return setupCwd === "." ? join(base, "node_modules") : join(base, setupCwd, "node_modules");
+}
+function getHashFile(projectRoot, setupCwd = ".") {
+    const base = getCacheDir(projectRoot);
+    const name = setupCwd === "." ? "lockfile.hash" : `lockfile-${setupCwd.replace(/\//g, "-")}.hash`;
+    return join(base, name);
+}
+// ---------------------------------------------------------------------------
+// Cache validation
+// ---------------------------------------------------------------------------
+export function isCacheValid(projectRoot, setupCwd) {
+    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, maxDepth = 4) {
+    const results = [];
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        if (!existsSync(dir))
+            return;
+        let entries;
+        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, config, onLog) {
+    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.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, wtPath, setupCwd) {
+    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.message}` };
+    }
+    return { applied: true, duration: Date.now() - start, count: cachedModules.length };
+}
+// ---------------------------------------------------------------------------
+// Internal: run setup command
+// ---------------------------------------------------------------------------
+function runSetup(command, cwd, onLog) {
+    return new Promise((resolve) => {
+        const proc = spawn(command, [], {
+            cwd,
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        proc.stdout.on("data", (d) => onLog?.(d.toString().trimEnd()));
+        proc.stderr.on("data", (d) => onLog?.(d.toString().trimEnd()));
+        proc.on("close", (code) => resolve(code ?? 1));
+        proc.on("error", () => resolve(1));
+    });
+}

package/dist/lib/engine/config-hotfix.d.ts

@@ -0,0 +1,7 @@
+export interface ConfigFix {
+    type: "add-copyfiles" | "update-setup" | "info";
+    description: string;
+    patch: Record<string, unknown>;
+}
+export declare function suggestConfigFix(projectRoot: string, logs: string[]): ConfigFix | null;
+export declare function applyConfigFix(projectRoot: string, fix: ConfigFix): boolean;

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

@@ -0,0 +1,129 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { deepFindEnvFiles } from "./smart-init.js";
+const PATTERNS = [
+    {
+        // SvelteKit / Vite: "does not provide an export named 'PUBLIC_*'"
+        test: /does not provide an export named '(PUBLIC_\w+)'/,
+        buildFix(projectRoot, _match) {
+            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, match) {
+            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, match) {
+            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, logs) {
+    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, fix) {
+    const configPath = join(projectRoot, CONFIG_FILE);
+    if (!existsSync(configPath))
+        return false;
+    let content;
+    try {
+        content = readFileSync(configPath, "utf8");
+    }
+    catch {
+        return false;
+    }
+    switch (fix.type) {
+        case "add-copyfiles": {
+            const newFiles = fix.patch.copyFiles;
+            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, newFiles) {
+    // 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/dist/lib/engine/conflict.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 declare function parseConflictFiles(statusOutput: string | null | undefined): string[];
+/**
+ * Build a Claude prompt to resolve merge conflicts.
+ */
+export declare function buildConflictPrompt(conflictFiles: string[]): string;