project-auto-wizard 0.1.5

package/src/core/breaking.js

@@ -0,0 +1,26 @@
+// .sh compare_versions 등가: v 접두 제거, 3자리 숫자 비교, 누락 자리=0
+export function compareVersions(a, b) {
+  const parse = (v) => String(v).replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+  const pa = parse(a), pb = parse(b);
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i] ?? 0, y = pb[i] ?? 0;
+    if (x > y) return 1;
+    if (x < y) return -1;
+  }
+  return 0;
+}
+
+// breaking-changes.json에서 current < ver <= target 범위 항목 수집.
+// ⚠️ .sh 버그 수정: target은 하드코딩 1.3.14가 아니라 실제 templateVersion을 넘긴다 (D2).
+// _ 로 시작하는 키(메타) 제외. severity critical / 그 외(warning).
+export function collectBreaking(json, current, target) {
+  const critical = [], warnings = [];
+  for (const [ver, entry] of Object.entries(json || {})) {
+    if (ver.startsWith("_")) continue;
+    if (compareVersions(current, ver) < 0 && compareVersions(ver, target) <= 0) {
+      const rec = { version: ver, ...entry };
+      (entry?.severity === "critical" ? critical : warnings).push(rec);
+    }
+  }
+  return { critical, warnings };
+}

package/src/core/copy/coderabbit.js

@@ -0,0 +1,26 @@
+// .coderabbit.yaml 복사 (.sh copy_coderabbit_config 등가, force 경로).
+// 소스는 payload/coderabbit.yaml (npm 패키징 안전을 위해 무점 파일명으로 동봉 → 대상엔 .coderabbit.yaml).
+// Task 15에서 coderabbit opt-in true일 때만 호출하도록 재배선 예정.
+import { join } from "node:path";
+import { exists, copyFileSync } from "../fsutil.js";
+
+// 반환: 'skip-no-src' | 'copied-new' | 'overwritten-backup' | 'skip-non-tty'
+// opts: { force, tty }
+export function copyCoderabbit(payloadRoot, { force = false, tty = false } = {}, targetRoot = ".") {
+  const src = join(payloadRoot, "coderabbit.yaml");
+  if (!exists(src)) return "skip-no-src";
+  const dst = join(targetRoot, ".coderabbit.yaml");
+
+  if (exists(dst)) {
+    if (force) {
+      copyFileSync(dst, dst + ".bak"); // 백업 후 덮어쓰기
+      copyFileSync(src, dst);
+      return "overwritten-backup";
+    }
+    if (!tty) return "skip-non-tty"; // 비TTY & !force → 유지
+    // 대화형 메뉴는 SP2-C — 여기서는 force가 아니면 유지
+    return "skip-non-tty";
+  }
+  copyFileSync(src, dst); // 신규
+  return "copied-new";
+}

package/src/core/copy/gitignore.js

@@ -0,0 +1,55 @@
+// .gitignore 보장 (.sh ensure_gitignore + normalize/check 등가) — template_integrator.sh 3996~4111.
+import { join } from "node:path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+
+const REQUIRED_ENTRIES = ["/.idea", "/.claude/settings.local.json"];
+
+// .sh normalize_gitignore_entry: 주석 제거·트림·앞 / 제거·앞 ./ 제거·뒤 / 제거. 빈값이면 원본.
+export function normalizeGitignoreEntry(entry) {
+  let e = String(entry);
+  e = e.replace(/#.*$/, "");        // 주석 제거
+  e = e.trim();                      // 앞뒤 공백
+  e = e.replace(/^\//, "");         // 앞 /
+  e = e.replace(/^\.\//, "");       // 앞 ./
+  e = e.replace(/\/$/, "");         // 뒤 /
+  return e === "" ? String(entry) : e;
+}
+
+function entryExists(target, content) {
+  const nt = normalizeGitignoreEntry(target);
+  for (const line of content.split("\n")) {
+    if (/^\s*#/.test(line)) continue;
+    if (/^\s*$/.test(line)) continue;
+    if (normalizeGitignoreEntry(line) === nt) return true;
+  }
+  return false;
+}
+
+const NEW_FILE_CONTENT =
+  "# IDE Settings\n" +
+  "/.idea\n" +
+  "\n" +
+  "# Claude AI Settings\n" +
+  "/.claude/settings.local.json\n";
+
+// 반환: {created, added:[...]}
+export function ensureGitignore(targetRoot = ".") {
+  const p = join(targetRoot, ".gitignore");
+  if (!existsSync(p)) {
+    writeFileSync(p, NEW_FILE_CONTENT);
+    return { created: true, added: REQUIRED_ENTRIES.slice() };
+  }
+  let content = readFileSync(p, "utf8");
+  const toAdd = REQUIRED_ENTRIES.filter((e) => !entryExists(e, content));
+  if (toAdd.length === 0) return { created: false, added: [] };
+
+  // 파일 끝에 개행 없으면 추가 (.sh: tail -c 1 이 non-empty면 echo "")
+  if (content.length > 0 && !content.endsWith("\n")) content += "\n";
+  content += "\n";
+  content += "# ====================================================================\n";
+  content += "# project-auto-wizard: Auto-added entries\n";
+  content += "# ====================================================================\n";
+  for (const e of toAdd) content += e + "\n";
+  writeFileSync(p, content);
+  return { created: false, added: toAdd };
+}

package/src/core/copy/readme.js

@@ -0,0 +1,30 @@
+// README 버전 섹션 추가 (.sh add_version_section_to_readme 등가) — template_integrator.sh 2145~2181.
+import { join } from "node:path";
+import { existsSync, readFileSync, appendFileSync } from "node:fs";
+
+const MARKER = "<!-- AUTO-VERSION-SECTION";
+// ## (최신 버전|최신버전|Version|버전) : vX.Y.Z (대소문자 무시)
+const VERSION_LINE_RE = /##\s*(최신\s*버전|최신버전|Version|버전)\s*:\s*v[0-9]+\.[0-9]+\.[0-9]+/i;
+
+// README.md 없으면 스킵. 마커 또는 버전 라인 있으면 스킵. 없으면 파일 끝에 append.
+// 반환: 'skip-no-readme' | 'skip-marker' | 'skip-version-line' | 'added'
+export function addVersionSectionToReadme(version, targetRoot = ".") {
+  const p = join(targetRoot, "README.md");
+  if (!existsSync(p)) return "skip-no-readme";
+  const content = readFileSync(p, "utf8");
+  if (content.includes(MARKER)) return "skip-marker";
+  if (VERSION_LINE_RE.test(content)) return "skip-version-line";
+
+  // .sh: cat >> README.md << EOF — EOF 다음 첫 줄이 빈 줄이므로 append 본문은 "\n---\n..."로 시작.
+  // (원본 파일이 개행으로 끝난다는 전제는 .sh와 동일 — heredoc은 원본 끝에 그대로 붙는다.)
+  const section =
+    "\n" +
+    "---\n" +
+    "\n" +
+    "<!-- AUTO-VERSION-SECTION: DO NOT EDIT MANUALLY -->\n" +
+    `## 최신 버전 : v${version}\n` +
+    "\n" +
+    "[전체 버전 기록 보기](CHANGELOG.md)\n";
+  appendFileSync(p, section);
+  return "added";
+}

package/src/core/copy/simple.js

@@ -0,0 +1,23 @@
+// 단순 복사 함수 (무조건 덮어쓰기류).
+// payload 단일 진실: 스크립트는 payload/scripts/*.py → 사용자 레포 .github/scripts/ 로 설치된다.
+// 워크플로우 전부가 이 경로(python3 .github/scripts/*.py)를 호출하므로 누락 시 설치물이 런타임에 죽는다.
+import { join } from "node:path";
+import { chmodSync } from "node:fs";
+import { PATHS, PAYLOAD } from "../paths.js";
+import { exists, copyFileSync } from "../fsutil.js";
+
+// version_manager.py, changelog_manager.py 무조건 덮어쓰기 (+chmod — Windows에선 무의미하나 무해).
+export function copyScripts(payloadRoot, targetRoot = ".") {
+  const scripts = ["version_manager.py", "changelog_manager.py"];
+  let copied = 0;
+  for (const s of scripts) {
+    const src = join(payloadRoot, PAYLOAD.scriptsDir, s);
+    if (exists(src)) {
+      const dst = join(targetRoot, PATHS.scriptsDir, s);
+      copyFileSync(src, dst);
+      try { chmodSync(dst, 0o755); } catch { /* Windows 등 chmod 무의미 */ }
+      copied++;
+    }
+  }
+  return copied;
+}

package/src/core/copy/workflows.js

@@ -0,0 +1,233 @@
+// 워크플로우 복사 엔진 (.sh copy_workflows + _copy_workflows_for_type 등가).
+// 실측: template_integrator.sh 3398~3815.
+// 대화형 3지선(기존 파일 충돌)은 copyWorkflowsInteractive(async)가 결정 Map을 만들어
+// 동기 엔진(copyWorkflows)에 hooks.decisions로 전달한다 — 기존 시그니처·force 동작 무변경.
+import { join, basename } from "node:path";
+import { existsSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+import { PATHS, PAYLOAD } from "../paths.js";
+import { exists, writeText, listYamlFiles } from "../fsutil.js";
+import { isUnchanged, substituteEnv } from "../wizard-env.js";
+import { substitute } from "../branding.js";
+
+// 원본 텍스트 로더 — context.branches가 있으면 {{MAIN_BRANCH}}/{{DEVELOP_BRANCH}} 치환 적용.
+// classify(unchanged 판정)와 실제 복사가 같은 치환본을 봐야 재실행 시 가짜 충돌이 없다.
+function makeSrcText(branches) {
+  return (p) => {
+    const raw = readFileSync(p, "utf8");
+    return branches ? substitute(raw, branches) : raw;
+  };
+}
+
+// trunk-based 모드에서 설치하지 않는 common 워크플로우 (DESIGN-SPEC §4 설치 매트릭스).
+// 릴리스 PR 흐름이 없으므로 RELEASE-PUBLISH 하나가 bump→changelog→tag→Release를 흡수한다.
+const TRUNK_BASED_EXCLUDED = new Set([
+  "PROJECT-COMMON-VERSION-CONTROL.yaml",
+  "PROJECT-COMMON-AUTO-CHANGELOG-CONTROL.yaml",
+]);
+
+// 한 파일에 env 치환을 적용해 대상 파일을 갱신 (.sh configure_workflow_env 등가).
+// values/useDefaults: env 계획(promptEnvPlan) 결과 — 미지정이면 기본값 경로(현행 force 동작).
+function configureEnv(targetPath, { type, projectPath = ".", repoName = "", resolvers = {}, collectAsks = null, values = new Map(), useDefaults = true }) {
+  const content = readFileSync(targetPath, "utf8");
+  if (!content.includes("@wizard")) return;
+  const out = substituteEnv(content, { type, useDefaults, values, projectPath, repoName, resolvers, collectAsks });
+  writeFileSync(targetPath, out);
+}
+
+// 3분류 (신규/unchanged/changed) — 대상 워크플로우 디렉토리 기준.
+// srcText: 브랜치 치환이 적용된 원본 로더 (makeSrcText).
+function classify(srcDir, workflowsDir, envOpts, srcText) {
+  const result = { newFiles: [], unchanged: [], changed: [] };
+  for (const filename of listYamlFiles(srcDir)) {
+    const src = join(srcDir, filename);
+    const dst = join(workflowsDir, filename);
+    if (existsSync(dst)) {
+      const tpl = srcText(src);
+      const inst = readFileSync(dst, "utf8");
+      if (isUnchanged(tpl, inst, envOpts)) result.unchanged.push(filename);
+      else result.changed.push(filename);
+    } else {
+      result.newFiles.push(filename);
+    }
+  }
+  return result;
+}
+
+// copy_workflows 본체 (동기 — 기존 호출부 무변경).
+// context: { types:[], paths:Map, includeNexus, includeSecretBackup, force, repoName, resolvers,
+//            envValues?:Map<key,value>, envUseDefaults?:boolean }  ← env 계획(promptEnvPlan) 결과 주입점
+// hooks: { decisions?: Map<filename, 'skip'|'backup'|'template'> } — 기존 파일(changed) 충돌 결정.
+//        미지정 파일은 'skip'(현행 force 동작 100% 유지). 대화형 수집은 copyWorkflowsInteractive 참조.
+// 반환: {copied, skipped, templateAdded, optionalCopied}
+export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}) {
+  const { types = [], paths = new Map(), includeNexus = false, includeSecretBackup = false, repoName = "", resolvers = {}, envValues = new Map(), envUseDefaults = true } = context;
+  const decisions = hooks.decisions instanceof Map ? hooks.decisions : new Map();
+  const workflowsDir = join(targetRoot, PATHS.workflowsDir);
+  const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
+  if (!exists(projectTypesDir)) throw new Error("패키지 구조 오류 — payload/workflows 폴더를 찾지 못했습니다.");
+
+  const counters = { copied: 0, skipped: 0, templateAdded: 0, optionalCopied: 0 };
+  const deployValues = new Map(); // Map<type, Map<key,value>> — deploy 블록용 ask 값
+  counters.deployValues = deployValues;
+  const srcText = makeSrcText(context.branches || null);
+  // values/useDefaults는 치환 경로에서만 의미 (isUnchanged는 내부에서 useDefaults:true 강제 — 가상 비교 무손상)
+  const envOptsFor = (type) => ({ type, projectPath: paths.get(type) || ".", repoName, resolvers, values: envValues, useDefaults: envUseDefaults });
+
+  // (1) common — unchanged면 스킵, 아니면 무조건 덮어쓰기.
+  //     trunk-based 모드는 VERSION-CONTROL·AUTO-CHANGELOG 미설치 (RELEASE-PUBLISH 단독).
+  const branchMode = context.branches?.mode || "pr-flow";
+  const commonDir = join(projectTypesDir, "common");
+  if (exists(commonDir)) {
+    for (const filename of listYamlFiles(commonDir)) {
+      if (branchMode === "trunk-based" && TRUNK_BASED_EXCLUDED.has(filename)) continue;
+      const src = join(commonDir, filename);
+      const dst = join(workflowsDir, filename);
+      const body = srcText(src);
+      if (existsSync(dst) && isUnchanged(body, readFileSync(dst, "utf8"), envOptsFor("common"))) {
+        counters.skipped++;
+        continue;
+      }
+      writeText(dst, body);
+      counters.copied++;
+    }
+  }
+
+  // (2~4) 타입별
+  for (const type of types) {
+    const asks = new Map();
+    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { includeNexus, ...context, envOptsFor, collectAsks: asks, decisions, srcText }, counters);
+    if (asks.size) deployValues.set(type, asks);
+  }
+
+  // (5) common/secret-backup — 있으면 무조건 스킵/신규만 복사
+  const secretDir = join(commonDir, "secret-backup");
+  if (exists(secretDir) && includeSecretBackup) {
+    for (const filename of listYamlFiles(secretDir)) {
+      const dst = join(workflowsDir, filename);
+      if (existsSync(dst)) continue; // 이미 존재하면 스킵
+      writeText(dst, srcText(join(secretDir, filename)));
+      counters.optionalCopied++;
+      counters.copied++;
+    }
+  }
+
+  return counters;
+}
+
+// changed(기존에 있고 내용이 바뀐) 파일 1개를 결정에 따라 처리 (.sh 3440~3508 3지선 case 등가).
+// 'skip'(기본): 기존 유지. 'backup': 기존→.bak 후 교체. 'template': 기존 유지 + 새 버전을 .template.yaml로.
+function applyDecision(decision, srcDir, workflowsDir, filename, counters, srcText) {
+  const src = join(srcDir, filename);
+  const dst = join(workflowsDir, filename);
+  if (decision === "backup") {
+    // .sh O) mv → cp: 기존을 .bak으로 백업 후 새 버전으로 교체
+    renameSync(dst, dst + ".bak");
+    writeText(dst, srcText(src));
+    counters.copied++;
+    return;
+  }
+  if (decision === "template") {
+    // .sh T) `${filename%.yaml}.template.yaml` — .yaml만 strip (.yml은 그대로 뒤에 붙음, .sh 동일)
+    const templateName = (filename.endsWith(".yaml") ? filename.slice(0, -".yaml".length) : filename) + ".template.yaml";
+    writeText(join(workflowsDir, templateName), srcText(src)); // 기존 .template.yaml 덮어씀(.sh rm -f + cp 등가)
+    counters.templateAdded++;
+    return;
+  }
+  counters.skipped++; // 'skip'/미지정/ESC → 기존 유지 (.sh S)·force 기본)
+}
+
+// 대상 워크플로우 디렉토리에서 changed(충돌) 파일 목록만 뽑는다 — copyWorkflowsInteractive의 사전 조사용.
+// copyWorkflows 본체와 동일한 classify 기준을 써야 결정 Map이 실제 처리 대상과 1:1로 맞는다.
+export function listWorkflowConflicts(context, payloadRoot, targetRoot = ".") {
+  const { types = [], paths = new Map(), includeNexus = false, repoName = "", resolvers = {} } = context;
+  const workflowsDir = join(targetRoot, PATHS.workflowsDir);
+  const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
+  const srcText = makeSrcText(context.branches || null);
+  const conflicts = []; // [{ filename, type }] — 엔진 처리 순서와 동일 (타입 순회 → 직하위 → server-deploy)
+  for (const type of types) {
+    const envOpts = { type, projectPath: paths.get(type) || ".", repoName, resolvers };
+    const typeDir = join(projectTypesDir, type);
+    if (exists(typeDir)) {
+      for (const f of classify(typeDir, workflowsDir, envOpts, srcText).changed) conflicts.push({ filename: f, type });
+    }
+    const serverDeployDir = join(typeDir, "server-deploy");
+    if (exists(serverDeployDir) && !includeNexus) {
+      for (const f of classify(serverDeployDir, workflowsDir, envOpts, srcText).changed) conflicts.push({ filename: f, type });
+    }
+  }
+  return conflicts;
+}
+
+// 대화형 진입점 (async) — 충돌마다 onConflict(filename, type)를 await해 결정 Map을 만든 뒤
+// 동기 엔진에 위임한다. WHY 분리: copyWorkflows를 async로 바꾸면 await 없이 호출하는
+// 기존 호출부(runFull/runWorkflows)가 깨진다 — 시그니처 무변경 원칙.
+// onConflict 반환값: 'template' | 'skip' | 'backup' (그 외/미지정 → 'skip').
+export async function copyWorkflowsInteractive(context, payloadRoot, targetRoot = ".", { onConflict } = {}) {
+  const decisions = new Map();
+  if (typeof onConflict === "function") {
+    for (const { filename, type } of listWorkflowConflicts(context, payloadRoot, targetRoot)) {
+      if (decisions.has(filename)) continue; // 파일명은 PROJECT-{TYPE}- prefix로 타입 간 유일
+      decisions.set(filename, await onConflict(filename, type));
+    }
+  }
+  return copyWorkflows(context, payloadRoot, targetRoot, { decisions });
+}
+
+function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters) {
+  const { includeNexus, envOptsFor, collectAsks = null, decisions = new Map(), srcText } = ctx;
+  const typeDir = join(projectTypesDir, type);
+  const envOpts = envOptsFor(type);
+  let unchangedNames = [];
+
+  // 타입별 워크플로우 (직하위)
+  if (exists(typeDir)) {
+    const { newFiles, unchanged, changed } = classify(typeDir, workflowsDir, envOpts, srcText);
+    unchangedNames = unchanged.slice();
+    for (const f of unchanged) counters.skipped++;
+    for (const f of newFiles) { writeText(join(workflowsDir, f), srcText(join(typeDir, f))); counters.copied++; }
+    // changed: 결정 Map에 따라 처리 (미지정=skip → 현행 force 동작과 동일)
+    for (const f of changed) applyDecision(decisions.get(f), typeDir, workflowsDir, f, counters, srcText);
+  }
+
+  // server-deploy
+  const serverDeployDir = join(typeDir, "server-deploy");
+  if (exists(serverDeployDir)) {
+    if (includeNexus) {
+      // Nexus 프로젝트 → 폴더째 제외 (복사 안 함)
+    } else {
+      const { newFiles, unchanged, changed } = classify(serverDeployDir, workflowsDir, envOpts, srcText);
+      for (const f of unchanged) counters.skipped++;
+      for (const f of newFiles) { writeText(join(workflowsDir, f), srcText(join(serverDeployDir, f))); counters.copied++; }
+      for (const f of changed) applyDecision(decisions.get(f), serverDeployDir, workflowsDir, f, counters, srcText);
+    }
+  }
+
+  // nexus (opt-in)
+  const nexusDir = join(typeDir, "nexus");
+  if (exists(nexusDir) && includeNexus) {
+    for (const filename of listYamlFiles(nexusDir)) {
+      const src = join(nexusDir, filename);
+      const dst = join(workflowsDir, filename);
+      const body = srcText(src);
+      if (existsSync(dst) && isUnchanged(body, readFileSync(dst, "utf8"), envOpts)) {
+        counters.skipped++;
+        continue;
+      }
+      if (existsSync(dst)) renameSync(dst, dst + ".bak");
+      writeText(dst, body);
+      counters.optionalCopied++;
+      counters.copied++;
+    }
+  }
+
+  // env 치환 — 이 타입의 원본 디렉토리들에서 복사돼 존재하고 unchanged 아닌 파일만
+  for (const srcDir of [typeDir, serverDeployDir, nexusDir]) {
+    if (!exists(srcDir)) continue;
+    for (const filename of listYamlFiles(srcDir)) {
+      const target = join(workflowsDir, filename);
+      if (!existsSync(target)) continue;            // 건너뛴 파일 제외
+      if (unchangedNames.includes(filename)) continue; // unchanged 제외
+      configureEnv(target, { ...envOpts, collectAsks }); // env 계획 values/useDefaults 포함
+    }
+  }
+}

package/src/core/detect-fs.js

@@ -0,0 +1,106 @@
+// 실 파일시스템 프로젝트 감지 (.sh detect_* 실행부 등가).
+// SP2-A detect.js 순수 함수를 fs/git으로 구동한다.
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import { execFileSync } from "node:child_process";
+import { detectTypesFromMarkers, detectVersionFromFiles } from "./detect.js";
+import { parseExisting } from "./version-yml.js";
+
+const hasFile = (root) => (rel) => existsSync(join(root, rel));
+const readFile = (root) => (rel) => {
+  try { return readFileSync(join(root, rel), "utf8"); } catch { return null; }
+};
+
+function gitOut(root, args) {
+  try {
+    return execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch { return ""; }
+}
+
+// 타입 감지 — version.yml의 project_types 최우선(source of truth), 없으면 마커 스캔.
+export function detectTypes(root) {
+  const vy = join(root, "version.yml");
+  if (existsSync(vy)) {
+    const { types } = parseExisting(readFileSync(vy, "utf8"));
+    if (types.length) return types; // basic 포함, 명시돼 있으면 그대로
+  }
+  return detectTypesFromMarkers({ has: hasFile(root), read: readFile(root) });
+}
+
+// 버전 감지 — .sh detect_version 순서. jq 유무는 command 존재로 판정.
+export function detectVersion(root, { hasJq } = {}) {
+  const read = readFile(root);
+  const readJson = (rel) => { const c = read(rel); try { return c ? JSON.parse(c) : null; } catch { return null; } };
+  const jq = hasJq ?? hasCommand("jq");
+  const gitTag = gitOut(root, ["describe", "--tags", "--abbrev=0"]);
+  return detectVersionFromFiles({ read, readJson, hasJq: jq, gitTag });
+}
+
+// 기본 브랜치 감지 — symbolic-ref → remote show → main.
+export function detectDefaultBranch(root) {
+  let b = gitOut(root, ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+  if (b) return b.replace(/^refs\/remotes\/origin\//, "");
+  const show = gitOut(root, ["remote", "show", "origin"]);
+  const m = show.match(/HEAD branch:\s*(\S+)/);
+  if (m) return m[1];
+  return "main";
+}
+
+// 레포명 — git remote get-url origin 마지막 세그먼트, 실패 시 폴더명.
+export function detectRepoName(root) {
+  const url = gitOut(root, ["remote", "get-url", "origin"]);
+  if (url) {
+    const seg = url.replace(/\.git$/, "").split(/[/:]/).pop();
+    if (seg) return seg;
+  }
+  return basename(root);
+}
+
+function hasCommand(cmd) {
+  try {
+    execFileSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+    return true;
+  } catch { return false; }
+}
+
+// Spring application*.yml 탐색 (.sh resolve_spring_app_yml_dir/path L2767~2780 등가)
+// find {base} -path "*/src/main/resources/application*.yml" | head -1 의 fs 재귀 구현.
+// 반환: root 기준 상대경로 (예: "server/src/main/resources/application.yml") 또는 "".
+export function findSpringAppYml(root, base = ".") {
+  const startRel = base === "." ? "" : base;
+  const PRUNE = new Set(["node_modules", ".git", "build", ".gradle", "target", ".idea"]);
+  let hit = "";
+  const walk = (rel, depth) => {
+    if (hit || depth > 8) return; // head -1 등가 — 첫 매치에서 중단
+    let entries;
+    try { entries = readdirSync(join(root, rel), { withFileTypes: true }); } catch { return; }
+    // 정렬로 순회 순서 결정화 (find 순서 플랫폼 편차 제거)
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (hit) return;
+      const childRel = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        if (PRUNE.has(e.name)) continue;
+        walk(childRel, depth + 1);
+      } else if (/^application.*\.yml$/.test(e.name) && childRel.includes("src/main/resources/")) {
+        hit = childRel;
+      }
+    }
+  };
+  walk(startRel, 0);
+  return hit;
+}
+
+// 실 resolver 세트 생성 (.sh resolve_token 4종 등가) — index/interactive 공용.
+// paths: Map<type, path> (모노레포 경로).
+export function makeResolvers(root, repoName, paths) {
+  const springBase = (t) => paths.get(t || "spring") || paths.get("spring") || ".";
+  return {
+    repo: () => repoName,
+    "spring-app-yml-dir": (t) => {
+      const f = findSpringAppYml(root, springBase(t));
+      return f ? f.split("/").slice(0, -1).join("/") : "";
+    },
+    "spring-app-yml-path": (t) => findSpringAppYml(root, springBase(t)) || "",
+    "flutter-root": () => paths.get("flutter") || ".",
+  };
+}

package/src/core/detect.js

@@ -0,0 +1,62 @@
+// package.json 내용 분류 (.sh classify_package_json 등가) — 원본 파일 텍스트에 대한
+// grep 부분문자열 매칭. dependencies 파싱이 아니라 raw 텍스트 검사여야 등가.
+// 입력은 package.json의 원문 문자열(raw). 순서 중요.
+export function classifyPackageText(raw) {
+  const s = String(raw || "");
+  if (s.includes("@react-native") || s.includes("react-native")) {
+    return s.includes("expo") ? "react-native-expo" : "react-native";
+  }
+  if (s.includes('"next"')) return "next";
+  if (s.includes('"react"')) return "react";
+  return "node";
+}
+
+// 편의: 파싱된 객체를 받는 경우 원문으로 재직렬화해 위 규칙 적용
+export function classifyPackageJson(pkgOrRaw) {
+  const raw = typeof pkgOrRaw === "string" ? pkgOrRaw : JSON.stringify(pkgOrRaw || {});
+  return classifyPackageText(raw);
+}
+
+// 마커 스캔 (동작명세 §3.1). has(relpath)=>bool 주입. node는 다른 타입 있으면 미추가.
+// read(relpath)=>string|null 로 package.json 원문을 받아 classifyPackageText에 넘긴다.
+export function detectTypesFromMarkers({ has, read }) {
+  const types = [];
+  if (has("pubspec.yaml")) types.push("flutter");
+  if (has("build.gradle") || has("build.gradle.kts") || has("pom.xml")) types.push("spring");
+  if (has("pyproject.toml") || has("setup.py") || has("requirements.txt")) types.push("python");
+  if (has("package.json")) {
+    const cls = classifyPackageText(read ? read("package.json") : "");
+    if (cls === "node") { if (types.length === 0) types.push("node"); }
+    else types.push(cls);
+  }
+  return types.length ? [...new Set(types)] : ["basic"];
+}
+
+const VERSION_RE = /^\d+\.\d+\.\d+$/;
+
+// 버전 감지 (동작명세 §3.3) — 순서대로 첫 성공. read(relpath)=>string|null 주입.
+export function detectVersionFromFiles({ read, readJson, hasJq, gitTag }) {
+  const pkg = readJson?.("package.json");
+  if (hasJq && pkg?.version && VERSION_RE.test(pkg.version)) return pkg.version;
+  const grab = (content, re) => {
+    for (const line of (content || "").split("\n")) {
+      const m = line.match(re);
+      if (m && VERSION_RE.test(m[1])) return m[1];
+    }
+    return null;
+  };
+  let v;
+  if ((v = grab(read("build.gradle"), /version\s*=\s*["']?(\d+\.\d+\.\d+)/))) return v;
+  if ((v = grab(read("pubspec.yaml"), /^version:\s*(\d+\.\d+\.\d+)/))) return v;
+  if ((v = grab(read("pyproject.toml"), /version\s*=\s*["']?(\d+\.\d+\.\d+)/))) return v;
+  if (gitTag) { const t = String(gitTag).replace(/^v/, ""); if (VERSION_RE.test(t)) return t; }
+  return "0.0.1";
+}
+
+export function markerForType(type) {
+  return { flutter: "pubspec.yaml", "react-native-expo": "app.json", python: "pyproject.toml", spring: "build.gradle" }[type] || "package.json";
+}
+
+export function extraMarkers(type) {
+  return { python: ["setup.py", "requirements.txt"], spring: ["build.gradle.kts", "pom.xml"] }[type] || [];
+}

package/src/core/fsutil.js

@@ -0,0 +1,46 @@
+// 파일시스템 공용 유틸 (LF 보존 바이트 복사). 텍스트는 그대로 복사해 원본 줄바꿈 유지.
+import {
+  cpSync, existsSync, readFileSync, writeFileSync, mkdirSync,
+  readdirSync, rmSync,
+} from "node:fs";
+import { dirname } from "node:path";
+
+export const exists = (p) => existsSync(p);
+export const readText = (p) => readFileSync(p, "utf8");
+
+export function writeText(p, s) {
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, s);
+}
+
+// 단일 파일 복사 (부모 디렉토리 자동 생성, 바이트 그대로)
+export function copyFileSync(src, dst) {
+  mkdirSync(dirname(dst), { recursive: true });
+  cpSync(src, dst);
+}
+
+// 디렉토리 재귀 복사 (내용을 dst 하위로)
+export function copyDirSync(src, dst) {
+  mkdirSync(dst, { recursive: true });
+  cpSync(src, dst, { recursive: true });
+}
+
+// 파일/폴더 삭제 (없어도 무해)
+export function remove(p) {
+  rmSync(p, { recursive: true, force: true });
+}
+
+// 디렉토리 직하위 .yaml/.yml 파일명 목록. 하위 폴더 제외.
+// 정렬 순서는 .sh의 glob `"$_dir"/*.yaml "$_dir"/*.yml` 와 일치시킨다:
+// 확장자로 1차 그룹(.yaml 먼저 → .yml 나중), 각 그룹 안에서 알파벳순.
+// (단순 .sort()는 확장자를 섞어 정렬해 .sh와 파일 순회 순서가 갈리고,
+//  그 결과 version.yml deploy 블록의 키 순서까지 달라진다. 확장자 그룹핑으로 바이트 등가 확보.)
+export function listYamlFiles(dir) {
+  if (!existsSync(dir)) return [];
+  const names = readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isFile() && /\.(ya?ml)$/.test(e.name))
+    .map((e) => e.name);
+  const yaml = names.filter((n) => n.endsWith(".yaml")).sort();
+  const yml = names.filter((n) => n.endsWith(".yml")).sort();
+  return [...yaml, ...yml];
+}