project-auto-wizard 0.2.0 → 0.3.0

package/src/core/copy/workflows.js

@@ -3,6 +3,7 @@
 // 대화형 3지선(기존 파일 충돌)은 copyWorkflowsInteractive(async)가 결정 Map을 만들어
 // 동기 엔진(copyWorkflows)에 hooks.decisions로 전달한다 — 기존 시그니처·force 동작 무변경.
 import { join, basename } from "node:path";
+import { deployFilter, isDeployWorkflow, activateDeployTrigger, DEFAULT_DEPLOY_STYLE } from "../deploy-style.js";
 import { existsSync, readFileSync, writeFileSync, renameSync } from "node:fs";
 import { PATHS, PAYLOAD } from "../paths.js";
 import { exists, writeText, listYamlFiles } from "../fsutil.js";
@@ -12,10 +13,12 @@ import { sha256, readBaseline } from "../baseline.js";
 
 // 원본 텍스트 로더 — context.branches가 있으면 {{MAIN_BRANCH}}/{{DEVELOP_BRANCH}} 치환 적용.
 // classify(unchanged 판정)와 실제 복사가 같은 치환본을 봐야 재실행 시 가짜 충돌이 없다.
-export function makeSrcText(branches) {
+export function makeSrcText(branches, deployStyle = DEFAULT_DEPLOY_STYLE) {
   return (p) => {
     const raw = readFileSync(p, "utf8");
-    return branches ? substitute(raw, branches) : raw;
+    const out = branches ? substitute(raw, branches) : raw;
+    // 고른 배포 방식의 CD는 push 트리거를 켜서 설치한다 — 설치했는데 안 도는 상태를 만들지 않는다.
+    return isDeployWorkflow(basename(p)) ? activateDeployTrigger(out) : out;
   };
 }
 
@@ -55,9 +58,10 @@ function renderVirtual(templateContent, envOpts) {
 //
 // baseline이 없는 기존 설치는 base 미상이라 upstreamOnly/localOnly 판정을 할 수 없고,
 // 종전대로 unchanged/changed 2분류로 떨어진다(폴백). 그 실행에서 baseline이 심긴다.
-function classify(srcDir, workflowsDir, envOpts, srcText, baseline = null) {
+function classify(srcDir, workflowsDir, envOpts, srcText, baseline = null, filter = null) {
   const result = { newFiles: [], unchanged: [], changed: [], upstreamOnly: [], localOnly: [], removed: [] };
   for (const filename of listYamlFiles(srcDir)) {
+    if (filter && !filter(filename)) continue;
     const src = join(srcDir, filename);
     const dst = join(workflowsDir, filename);
     const base = baseline?.files?.[filename] || null;
@@ -141,7 +145,8 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
   counters.keptLocal = [];      // 질문 없이 사용자 수정본을 유지한 파일 (업스트림 무변경)
   counters.removedKept = [];    // 사용자가 지웠고 되살리지 않은 파일
   counters.restoredFiles = [];  // 사용자가 지웠지만 복원하기로 한 파일
-  const srcText = makeSrcText(context.branches || null);
+  const deployStyle = context.deployStyle || DEFAULT_DEPLOY_STYLE;
+  const srcText = makeSrcText(context.branches || null, deployStyle);
   const baseline = readBaseline(targetRoot);
   const baselineTargets = new Map(); // filename -> { srcPath, envOpts, wrote }
   // values/useDefaults는 치환 경로에서만 의미 (renderVirtual은 useDefaults:true 강제 — 가상 비교 무손상)
@@ -160,7 +165,7 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
   // (2~4) 타입별
   for (const type of types) {
     const asks = new Map();
-    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { includeNexus, ...context, envOptsFor, collectAsks: asks, dirCtx }, counters);
+    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { includeNexus, ...context, deployStyle, envOptsFor, collectAsks: asks, dirCtx }, counters);
     if (asks.size) deployValues.set(type, asks);
   }
 
@@ -171,6 +176,9 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
       const dst = join(workflowsDir, filename);
       if (existsSync(dst)) continue; // 이미 존재하면 스킵
       writeText(dst, srcText(join(secretDir, filename)));
+      // 이 경로는 타입별 복사 루프 밖이라 env 치환 루프가 닿지 않는다. 여기서 직접 걸어주지
+      // 않으면 이 파일의 @wizard 마커가 통째로 무시돼 __PROJECT_NAME__ 같은 값이 그대로 설치된다.
+      configureEnv(dst, envOptsFor("common"));
       counters.optionalCopied++;
       counters.copied++;
       counters.copiedFiles.push(filename);
@@ -232,14 +240,16 @@ export function surveyWorkflows(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 deployStyle = context.deployStyle || DEFAULT_DEPLOY_STYLE;
+  const srcText = makeSrcText(context.branches || null, deployStyle);
   const baseline = readBaseline(targetRoot);
   const branchMode = context.branches?.mode || "pr-flow";
   const conflicts = []; // 엔진 처리 순서와 동일 (common → 타입 순회 → 직하위 → server-deploy)
   const removed = [];
 
-  const collect = (srcDir, envOpts, type, skipFile = () => false) => {
-    const c = classify(srcDir, workflowsDir, envOpts, srcText, baseline);
+  const keepDeploy = deployFilter(deployStyle);
+  const collect = (srcDir, envOpts, type, skipFile = () => false, filter = null) => {
+    const c = classify(srcDir, workflowsDir, envOpts, srcText, baseline, filter);
     for (const f of c.changed) { if (!skipFile(f)) conflicts.push({ filename: f, type }); }
     for (const f of c.removed) { if (!skipFile(f)) removed.push({ filename: f, type }); }
   };
@@ -255,7 +265,7 @@ export function surveyWorkflows(context, payloadRoot, targetRoot = ".") {
     const typeDir = join(projectTypesDir, type);
     if (exists(typeDir)) collect(typeDir, envOpts, type);
     const serverDeployDir = join(typeDir, "server-deploy");
-    if (exists(serverDeployDir) && !includeNexus) collect(serverDeployDir, envOpts, type);
+    if (exists(serverDeployDir) && !includeNexus) collect(serverDeployDir, envOpts, type, () => false, keepDeploy);
   }
   return { conflicts, removed };
 }
@@ -281,7 +291,8 @@ export async function copyWorkflowsInteractive(context, payloadRoot, targetRoot
 }
 
 function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters) {
-  const { includeNexus, envOptsFor, collectAsks = null, dirCtx } = ctx;
+  const { includeNexus, deployStyle = "", envOptsFor, collectAsks = null, dirCtx } = ctx;
+  const keepDeploy = deployFilter(deployStyle);
   const { srcText, baselineTargets } = dirCtx;
   const typeDir = join(projectTypesDir, type);
   const envOpts = envOptsFor(type);
@@ -301,29 +312,19 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
     if (includeNexus) {
       // Nexus 프로젝트 → 폴더째 제외 (복사 안 함)
     } else {
-      const c = processDir(serverDeployDir, workflowsDir, envOpts, dirCtx, counters);
+      const c = processDir(serverDeployDir, workflowsDir, envOpts, dirCtx, counters, keepDeploy);
       untouched.push(...c.unchanged, ...c.localOnly);
     }
   }
 
-  // nexus (opt-in)
+  // nexus (opt-in) — 라이브러리 publish 계열(Nexus + GitHub Packages).
+  // 다른 폴더와 같은 processDir을 쓴다. 종전에는 이 경로만 별도 로직으로 "존재하면 무조건
+  // .bak 후 교체"였는데, 그러면 사용자가 손댄 publish 워크플로우가 재실행마다 묻지도 않고
+  // 밀린다. baseline 3-way·충돌 3지선을 다른 워크플로우와 동일하게 적용한다.
   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) && renderVirtual(body, envOpts) === readFileSync(dst, "utf8")) {
-        counters.skipped++;
-        continue;
-      }
-      if (existsSync(dst)) { renameSync(dst, dst + ".bak"); counters.backupAdded++; }
-      writeText(dst, body);
-      counters.optionalCopied++;
-      counters.copied++;
-      counters.copiedFiles.push(filename);
-      baselineTargets.set(filename, { srcPath: src, envOpts, wrote: true });
-    }
+    const c = processDir(nexusDir, workflowsDir, envOpts, dirCtx, counters);
+    untouched.push(...c.unchanged, ...c.localOnly);
   }
 
   // env 치환 — 이 타입의 원본 디렉토리들에서 복사돼 존재하고, 손대지 않기로 한 것이 아닌 파일만
@@ -331,6 +332,7 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
     if (!exists(srcDir)) continue;
     for (const filename of listYamlFiles(srcDir)) {
       const target = join(workflowsDir, filename);
+      if (srcDir === serverDeployDir && !keepDeploy(filename)) continue; // 안 고른 배포 방식
       if (!existsSync(target)) continue;          // 건너뛴 파일 제외
       if (untouched.includes(filename)) continue; // unchanged/localOnly 제외
       configureEnv(target, { ...envOpts, collectAsks }); // env 계획 values/useDefaults 포함
@@ -345,7 +347,8 @@ export function planWorkflows(context, payloadRoot, targetRoot = ".") {
   const { types = [], paths = new Map(), includeNexus = false, includeSecretBackup = false, repoName = "", resolvers = {} } = context;
   const workflowsDir = join(targetRoot, PATHS.workflowsDir);
   const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
-  const srcText = makeSrcText(context.branches || null);
+  const deployStyle = context.deployStyle || DEFAULT_DEPLOY_STYLE;
+  const srcText = makeSrcText(context.branches || null, deployStyle);
   const baseline = readBaseline(targetRoot);
   const branchMode = context.branches?.mode || "pr-flow";
   // upstreamOnly/localOnly/removed는 baseline이 있을 때만 채워진다 (issue #69).
@@ -385,7 +388,7 @@ export function planWorkflows(context, payloadRoot, targetRoot = ".") {
 
     const serverDeployDir = join(typeDir, "server-deploy");
     if (exists(serverDeployDir) && !includeNexus) {
-      merge(classify(serverDeployDir, workflowsDir, envOpts, srcText, baseline), type);
+      merge(classify(serverDeployDir, workflowsDir, envOpts, srcText, baseline, deployFilter(deployStyle)), type);
     }
 
     const nexusDir = join(typeDir, "nexus");

package/src/core/deploy-style.js

@@ -0,0 +1,90 @@
+// 배포 방식 (이슈 #80) — 서버 배포 CD 워크플로우는 서로 대체재다.
+// Nginx 무중단과 Traefik 무중단을 동시에 쓰는 경우는 없으므로 하나만 설치한다.
+// 고른 것은 push 트리거까지 켜서 설치한다 — 설치했는데 안 도는 상태를 만들지 않는다.
+import { join } from "node:path";
+import { existsSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { sha256 } from "./baseline.js";
+
+// 파일명 접미사로 식별한다 — 타입 접두사(PROJECT-SPRING- 등)는 타입마다 다르기 때문.
+export const DEPLOY_STYLES = [
+  { value: "simple", suffix: "-SIMPLE-CICD.yaml", label: "단일 서버 배포 — 컨테이너를 내렸다 올린다 (가장 단순, 짧은 다운타임)" },
+  { value: "nginx", suffix: "-NONSTOP-NGINX-CICD.yaml", label: "무중단 배포 (Nginx) — nginx config의 proxy_pass 포트를 Blue/Green으로 토글" },
+  { value: "traefik", suffix: "-NONSTOP-TRAEFIK-CICD.yaml", label: "무중단 배포 (Traefik) — Traefik 라우팅으로 Blue/Green 전환" },
+];
+
+export const DEFAULT_DEPLOY_STYLE = "simple";
+
+export const isDeployStyle = (v) => DEPLOY_STYLES.some((s) => s.value === v);
+
+// 이 파일이 CD 본체인가 (= 택1 대상인가). PR 프리뷰는 배포 방식과 직교하는 축이라 제외한다.
+export const isDeployWorkflow = (filename) => DEPLOY_STYLES.some((s) => filename.endsWith(s.suffix));
+
+// 모르는 값은 기본값으로 수렴시킨다. 빈 접미사를 돌려주면 endsWith("")가 항상 참이라
+// "전부 통과"가 되어, 잘못된 값이 조용히 CD 전부 설치로 새어나간다.
+const suffixOf = (style) =>
+  (DEPLOY_STYLES.find((s) => s.value === style) ?? DEPLOY_STYLES.find((s) => s.value === DEFAULT_DEPLOY_STYLE)).suffix;
+
+// 파일 필터 — 고른 방식의 CD만 통과. CD가 아닌 파일(PR 프리뷰·common 등)은 항상 통과.
+export function deployFilter(style) {
+  const suffix = suffixOf(style);
+  return (filename) => !isDeployWorkflow(filename) || filename.endsWith(suffix);
+}
+
+// 무중단 템플릿은 push 트리거가 주석 처리된 채 들어 있다(기본 배포가 단일 서버라서).
+// 사용자가 그 방식을 고른 이상 트리거는 켜져 있어야 한다 — 안 그러면 설치해도 아무 일이
+// 일어나지 않고 사용자가 YAML을 직접 고쳐야 한다.
+//
+// 첫 `on:` 블록 안에서 `# ` 두 글자만 떼므로 안쪽 들여쓰기 계층이 그대로 보존된다.
+// 설명문 주석은 벗겨낸 내용이 push/branches/- 로 시작하지 않아 건드리지 않는다.
+const TRIGGER_CONTENT = /^\s*(push:|branches:|- )/;
+
+export function activateDeployTrigger(content) {
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  const lines = content.split(/\r?\n/);
+  let inOn = false;
+  let changed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^on:\s*$/.test(line)) { inOn = true; continue; }
+    if (!inOn) continue;
+    if (/^\S/.test(line)) break; // 최상위 키를 다시 만나면 on 블록 종료
+    const m = line.match(/^(\s*)# ?(.*)$/);
+    if (!m || !TRIGGER_CONTENT.test(m[2])) continue;
+    lines[i] = `${m[1]}${m[2]}`;
+    changed = true;
+  }
+  return changed ? lines.join(eol) : content;
+}
+
+// 방식을 바꿔 재설치했을 때 이전 CD를 정리한다.
+//
+// 남겨두면 이전 방식의 push 트리거가 살아 있어 배포가 두 번 돈다. 그렇다고 사용자에게
+// "직접 지우세요"라고 떠넘기면 설치가 끝나도 레포가 정상이 아닌 상태로 남는다. 마법사가
+// 깐 파일은 마법사가 정리한다.
+//
+//   손대지 않은 것(baseline의 installed 해시와 동일) → 삭제. 물어볼 이유가 없다.
+//   손댄 것                                          → .bak으로 옮긴다. 내용은 지키고 트리거만 죽인다.
+//
+// 반환: { removed:[], backedUp:[] } — 완료 화면·설치 기록에 그대로 보고한다.
+export function cleanupOtherDeployWorkflows(workflowsDir, installedFilenames, style, baseline) {
+  const keep = deployFilter(style);
+  const removed = [];
+  const backedUp = [];
+
+  for (const filename of installedFilenames) {
+    if (!isDeployWorkflow(filename) || keep(filename)) continue;
+    const p = join(workflowsDir, filename);
+    if (!existsSync(p)) continue;
+
+    const known = baseline?.files?.[filename]?.installed;
+    const untouched = known && sha256(readFileSync(p, "utf8")) === known;
+    if (untouched) {
+      rmSync(p, { force: true });
+      removed.push(filename);
+    } else {
+      renameSync(p, `${p}.bak`);
+      backedUp.push(filename);
+    }
+  }
+  return { removed, backedUp };
+}

package/src/core/detect-fs.js

@@ -3,7 +3,7 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, basename } from "node:path";
 import { execFileSync } from "node:child_process";
-import { detectTypesFromMarkers, detectVersionFromFiles, detectBuildNumberFromFiles } from "./detect.js";
+import { detectTypesFromMarkers, detectVersionFromFiles, detectBuildNumberFromFiles, detectJdkFromFiles, resolveMarkers } from "./detect.js";
 import { parseExisting } from "./version-yml.js";
 
 const hasFile = (root) => (rel) => existsSync(join(root, rel));
@@ -28,11 +28,25 @@ export function detectTypes(root) {
 }
 
 // 버전 감지 — .sh detect_version 순서. jq는 package.json 파싱에 쓰인 적이 없어 게이트를 제거했다(이슈 #22 L4).
-export function detectVersion(root, { warn = (m) => console.error(m) } = {}) {
+// hint: 폴백 경고에 붙일 해결 방법 안내 (대화형/CLI가 다르다 — 이슈 #80).
+export function detectVersion(root, { warn = (m) => console.error(m), hint } = {}) {
   const read = readFile(root);
   const readJson = (rel) => { const c = read(rel); try { return c ? JSON.parse(c) : null; } catch { return null; } };
   const gitTag = gitOut(root, ["describe", "--tags", "--abbrev=0"]);
-  return detectVersionFromFiles({ read, readJson, gitTag, warn });
+  return detectVersionFromFiles({ read, readJson, gitTag, warn, hint });
+}
+
+// 타입별 실제 마커 파일 (이슈 #77) — 감지 로그·설치 로그가 같은 근거 파일을 인용하도록.
+export function detectMarkers(root, types = []) {
+  return resolveMarkers(types, hasFile(root));
+}
+
+// 빌드 JDK 감지 (이슈 #82) — 배포 워크플로우 JAVA_VERSION 기본값에 실측값을 쓰기 위해.
+// base: 모노레포에서 spring 프로젝트 루트 (레포 루트 기준 상대경로).
+export function detectJdk(root, base = ".") {
+  const rel = base && base !== "." ? (r) => `${base}/${r}` : (r) => r;
+  const read = readFile(root);
+  return detectJdkFromFiles({ read: (r) => read(rel(r)) });
 }
 
 // 빌드 번호 감지 — 신규 통합 시 pubspec.yaml/build.gradle/app.json에서 실제 빌드 번호를 읽는다 (이슈 #41).
@@ -65,23 +79,34 @@ export function detectRepoName(root) {
 // 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") 또는 "".
+//
+// .yaml도 인정한다 (이슈 #81). Spring은 .yml/.yaml을 모두 공식 지원하는데 종전 정규식이
+// .yml만 봐서, application.yaml을 쓰는 프로젝트는 이 값이 빈 문자열이 되고 그 결과
+// __APPLICATION_YML_DIR__ 가 치환되지 않은 채 설치됐다.
+//
+// 같은 디렉토리에서는 프로파일 없는 기본 파일(application.yml/.yaml)을 우선한다. 파일명 정렬만
+// 쓰면 'application-dev.yml'이 'application.yml'보다 앞서(`-` < `.`) 프로파일 파일이 잡힌다.
 export function findSpringAppYml(root, base = ".") {
   const startRel = base === "." ? "" : base;
   const PRUNE = new Set(["node_modules", ".git", "build", ".gradle", "target", ".idea"]);
+  const APP_YML = /^application(-[^/]*)?\.ya?ml$/;
   let hit = "";
+  let hitIsBase = false;
   const walk = (rel, depth) => {
-    if (hit || depth > 8) return; // head -1 등가 — 첫 매치에서 중단
+    if (hitIsBase || depth > 8) return; // 기본 파일을 찾았으면 더 볼 필요가 없다
     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;
+      if (hitIsBase) 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;
+      } else if (APP_YML.test(e.name) && childRel.includes("src/main/resources/")) {
+        const isBase = /^application\.ya?ml$/.test(e.name);
+        // 첫 매치는 일단 채택하고, 이후 기본 파일이 나오면 그걸로 승격한다.
+        if (!hit || isBase) { hit = childRel; hitIsBase = isBase; }
       }
     }
   };
@@ -95,6 +120,10 @@ export function makeResolvers(root, repoName, paths) {
   const springBase = (t) => paths.get(t || "spring") || paths.get("spring") || ".";
   return {
     repo: () => repoName,
+    // 빌드 JDK (이슈 #82) — 배포 워크플로우 JAVA_VERSION의 기본값. 프로젝트 툴체인을 실측한다.
+    // ⚠️ 빈 문자열을 돌려주면 setEnvLine이 그 줄을 건너뛰어 __JAVA_VERSION__이 그대로 남는다
+    //    (이슈 #81과 같은 실패 형태). 감지 실패 시 반드시 종전 기본값 21로 폴백한다.
+    jdk: (t) => detectJdk(root, springBase(t)) || "21",
     "spring-app-yml-dir": (t) => {
       const f = findSpringAppYml(root, springBase(t));
       return f ? f.split("/").slice(0, -1).join("/") : "";

package/src/core/detect.js

@@ -36,7 +36,9 @@ const VERSION_RE = /^\d+\.\d+\.\d+$/;
 
 // 버전 감지 (동작명세 §3.3) — 순서대로 첫 성공. read(relpath)=>string|null 주입.
 // package.json은 이미 Node JSON.parse로 파싱을 마친 값이므로 jq 설치 여부와 무관하게 항상 사용한다(이슈 #22 L4).
-export function detectVersionFromFiles({ read, readJson, gitTag, warn }) {
+// hint: 폴백 경고 뒤에 붙일 "그럼 어떻게 고치나" 한 줄. 대화형과 CLI가 서로 다른 방법을
+// 안내해야 하므로(이슈 #80) 호출부가 정한다. 미지정 시 CLI 문구를 쓴다.
+export function detectVersionFromFiles({ read, readJson, gitTag, warn, hint }) {
   const pkg = readJson?.("package.json");
   if (pkg?.version && VERSION_RE.test(pkg.version)) return pkg.version;
   const grab = (content, re) => {
@@ -47,14 +49,29 @@ export function detectVersionFromFiles({ read, readJson, gitTag, warn }) {
     return null;
   };
   let v;
-  if ((v = grab(read("build.gradle"), /version\s*=\s*["']?(\d+\.\d+\.\d+)/))) return v;
+  const gradleRe = /version\s*=\s*["']?(\d+\.\d+\.\d+)/;
+  // Groovy DSL과 Kotlin DSL은 같은 문법(`version = "x.y.z"`)이라 정규식을 공유한다.
+  // .kts를 빼먹으면 Kotlin DSL Spring 프로젝트가 전부 0.0.1로 초기화된다 (이슈 #77).
+  if ((v = grab(read("build.gradle"), gradleRe))) return v;
+  if ((v = grab(read("build.gradle.kts"), gradleRe))) return v;
+  if ((v = versionFromPom(read("pom.xml")))) 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; }
-  warn?.("⚠️  버전을 자동 감지하지 못해 기본값 0.0.1을 사용합니다 — --project-version으로 직접 지정하거나 version.yml을 확인하세요.");
+  const tail = hint ?? "--project-version으로 직접 지정하거나 version.yml을 확인하세요.";
+  warn?.(`⚠️  버전을 자동 감지하지 못해 기본값 0.0.1을 사용합니다 — ${tail}`);
   return "0.0.1";
 }
 
+// Maven pom.xml의 프로젝트 버전 (이슈 #77). <parent> 블록 안의 버전은 스프링 부트 BOM 버전이라
+// 프로젝트 버전이 아니다 — 그 구간을 지운 뒤 첫 <version>을 읽는다.
+export function versionFromPom(content) {
+  if (!content) return null;
+  const body = String(content).replace(/<parent>[\s\S]*?<\/parent>/g, "");
+  const m = body.match(/<version>\s*(\d+\.\d+\.\d+)[^<]*<\/version>/);
+  return m ? m[1] : null;
+}
+
 export function markerForType(type) {
   return { flutter: "pubspec.yaml", "react-native-expo": "app.json", python: "pyproject.toml", spring: "build.gradle" }[type] || "package.json";
 }
@@ -63,6 +80,54 @@ export function extraMarkers(type) {
   return { python: ["setup.py", "requirements.txt"], spring: ["build.gradle.kts", "pom.xml"] }[type] || [];
 }
 
+// 그 타입을 감지하는 데 실제로 쓰인 파일 (이슈 #77). markerForType은 타입당 대표 파일 하나를
+// 고정 반환하므로, build.gradle.kts만 있는 레포에서도 "build.gradle 발견"이라고 출력돼
+// 같은 설치 로그 안에서 경로 확정 화면과 파일명이 어긋났다. has()로 실재하는 것을 고른다.
+// 실재하는 후보가 없으면(감지 전 화면 등) 대표 파일을 쓴다.
+export function resolveMarker(type, has) {
+  const candidates = [markerForType(type), ...extraMarkers(type)];
+  return candidates.find(has) ?? candidates[0];
+}
+
+// 빌드 JDK 감지 (이슈 #82) — 배포 워크플로우의 JAVA_VERSION 기본값이 21로 고정돼 있어
+// toolchain이 다른 프로젝트(예: 25)는 그대로 Enter를 누르면 러너 JDK와 어긋나 빌드가 깨진다.
+// 빌드 번호를 프로젝트 파일에서 읽는 detectBuildNumberFromFiles와 같은 방식으로 실측한다.
+// 반환: "21" 같은 메이저 버전 문자열, 못 찾으면 null.
+export function detectJdkFromFiles({ read }) {
+  const pick = (content, patterns) => {
+    if (!content) return null;
+    for (const re of patterns) {
+      const m = String(content).match(re);
+      // JavaVersion.VERSION_1_8 처럼 1_8 표기는 8로 정규화한다.
+      if (m) return m[1] === "1_8" ? "8" : m[1].replace("1_", "");
+    }
+    return null;
+  };
+  const gradlePatterns = [
+    /JavaLanguageVersion\.of\((\d+)\)/,                  // toolchain (Gradle 권장 표기)
+    /JavaVersion\.VERSION_(\d+(?:_\d+)?)/,               // sourceCompatibility = JavaVersion.VERSION_21
+    /(?:source|target)Compatibility\s*=?\s*["'](\d+)["']/, // sourceCompatibility = '17'
+  ];
+  let v;
+  if ((v = pick(read("build.gradle.kts"), gradlePatterns))) return v;
+  if ((v = pick(read("build.gradle"), gradlePatterns))) return v;
+  if ((v = pick(read("pom.xml"), [
+    /<java\.version>\s*(\d+(?:\.\d+)?)\s*<\/java\.version>/,
+    /<maven\.compiler\.(?:source|release)>\s*(\d+(?:\.\d+)?)\s*<\//,
+  ]))) return v.replace(/^1\./, "");
+  return null;
+}
+
+// 타입별 실제 마커 파일 맵 — 감지 로그·설치 로그가 같은 근거를 쓰도록 한 곳에서 만든다.
+export function resolveMarkers(types = [], has) {
+  const out = new Map();
+  for (const t of types) {
+    if (t === "basic") continue;
+    out.set(t, resolveMarker(t, has));
+  }
+  return out;
+}
+
 // 빌드 번호 감지 (이슈 #41) — 신규 통합 시 pubspec.yaml/build.gradle/app.json에 이미 기록된
 // 빌드 번호를 읽어 version_code가 항상 1로 초기화되는 걸 막는다. types 배열에서 먼저 매칭되는
 // 첫 타입만 사용한다(다른 감지 로직의 types[0]=primary 관례와 동일). read(rel)=>string|null,

package/src/core/install-log.js

@@ -0,0 +1,182 @@
+// 설치 로그 (이슈 #79) — 실행마다 "무엇을 어떤 값으로 설치했는지"를 레포에 한 건 남긴다.
+//
+// 왜 필요한가: version.yml에는 버전·타입·경로·브랜치·옵션만 남는다. 감지 근거, 질문별 답변,
+// 특히 환경설정 답변(도메인·포트·볼륨 경로)은 워크플로우 YAML 안으로 흩어질 뿐 한 곳에
+// 기록되지 않아, 배포가 실패했을 때 "설치할 때 뭘로 답했더라"를 역추적할 방법이 없었다.
+// 터미널 스크롤백은 에이전트가 볼 수 없고 다른 클론에도 남지 않는다.
+//
+// 위치는 .github/.wizard/ 아래 — 마법사가 이미 baseline.json을 두는 자기 메타데이터 폴더다.
+// 새 최상위 폴더를 만들 이유가 없고, 삭제 모드에서도 경계가 이 폴더 하나로 끝난다.
+import { join } from "node:path";
+import { writeText } from "./fsutil.js";
+
+export const LOG_DIR = ".github/.wizard/logs";
+
+// 값에 비밀이 들어갈 수 있는 키 — 현재 질문 항목에는 없지만(도메인·경로·포트·인증 '방식'),
+// 앞으로 추가될 때 그냥 평문으로 커밋되지 않도록 처음부터 걸어둔다. 이 파일은 커밋 대상이다.
+const SECRET_KEY_RE = /(PASSWORD|SECRET|TOKEN|KEY|CREDENTIAL)/i;
+const MASK = "***";
+
+export function maskValue(key, value) {
+  // SSH_AUTH_METHOD처럼 "방식"만 담는 키는 비밀이 아니다 — 이름에 KEY가 들어가도 마스킹하지 않는다.
+  if (key === "SSH_AUTH_METHOD") return value;
+  return SECRET_KEY_RE.test(key) ? MASK : value;
+}
+
+// "2026-08-12 18:15:30" → "20260812-181530". 파일명이 곧 정렬 키가 되도록.
+export function stampFrom(now = "") {
+  const m = String(now).match(/(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})/);
+  if (!m) return "unknown";
+  return `${m[1]}${m[2]}${m[3]}-${m[4]}${m[5]}${m[6]}`;
+}
+
+export function logFilename(now, action = "install") {
+  return `${stampFrom(now)}-${action}.md`;
+}
+
+const yamlStr = (v) => `"${String(v ?? "").replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+const yamlList = (arr) => `[${(arr || []).map(yamlStr).join(", ")}]`;
+
+// 마크다운 렌더 — 상단은 기계가 읽는 front matter, 아래는 사람이 읽는 본문.
+// 에이전트가 파싱만 해도 핵심을 얻고, 사람이 열면 그대로 읽힌다.
+export function renderInstallLog(d = {}) {
+  const {
+    action = "install", at = "", templateVersion = "",
+    previousTemplateVersion = "", mode = "", types = [], markers = new Map(),
+    version = "", branch = "", branches = null, paths = new Map(),
+    options = {}, answers = [], result = {}, unresolved = [], secrets = new Map(),
+    warnings = [], cleanup = null,
+  } = d;
+
+  const L = [];
+  L.push("---");
+  L.push(`action: ${yamlStr(action)}`);
+  L.push(`at: ${yamlStr(at)}`);
+  L.push(`template_version: ${yamlStr(templateVersion)}`);
+  if (previousTemplateVersion) L.push(`previous_template_version: ${yamlStr(previousTemplateVersion)}`);
+  L.push(`mode: ${yamlStr(mode)}`);
+  L.push(`project_types: ${yamlList(types)}`);
+  L.push(`version: ${yamlStr(version)}`);
+  L.push(`default_branch: ${yamlStr(branch)}`);
+  if (branches) {
+    L.push(`branches: { main: ${yamlStr(branches.main)}, develop: ${yamlStr(branches.develop)}, mode: ${yamlStr(branches.mode)} }`);
+  }
+  L.push(`unresolved_count: ${unresolved.length}`);
+  L.push(`required_secrets: ${yamlList([...secrets.keys()])}`);
+  L.push("---");
+  L.push("");
+  L.push(`# 설치 로그 — ${at}`);
+  L.push("");
+  L.push("project-auto-wizard가 이 레포에 무엇을 설치했는지 남긴 기록입니다. 직접 편집하지 마세요.");
+  L.push("");
+
+  L.push("## 실행");
+  L.push("");
+  L.push("| 항목 | 값 |");
+  L.push("|---|---|");
+  L.push(`| 동작 | ${action === "install" ? "신규 설치" : action === "update" ? "업데이트" : action} |`);
+  L.push(`| 템플릿 버전 | ${previousTemplateVersion ? `${previousTemplateVersion} → ${templateVersion}` : templateVersion || "-"} |`);
+  L.push(`| 설치 모드 | ${mode || "-"} |`);
+  L.push("");
+
+  L.push("## 감지 결과");
+  L.push("");
+  L.push("| 항목 | 값 | 근거 |");
+  L.push("|---|---|---|");
+  for (const t of types) {
+    L.push(`| 타입 | ${t} | ${markers?.get?.(t) || "직접 선택"} |`);
+  }
+  L.push(`| 버전 | ${version} | ${d.versionSource || "자동 감지"} |`);
+  L.push(`| 브랜치 | ${branch} | git |`);
+  for (const [t, p] of paths) L.push(`| 경로 (${t}) | ${p} | |`);
+  L.push("");
+  if (warnings.length) {
+    L.push("감지 중 경고:");
+    L.push("");
+    for (const w of warnings) L.push(`- ${w}`);
+    L.push("");
+  }
+
+  L.push("## 선택 항목");
+  L.push("");
+  L.push("| 항목 | 값 |");
+  L.push("|---|---|");
+  L.push(`| 라이브러리 publish (Nexus·GitHub Packages) | ${options.nexus ? "포함" : "제외"} |`);
+  L.push(`| Secret 서버 백업 | ${options.secretBackup ? "포함" : "제외"} |`);
+  L.push(`| 자동 버전 승격 | ${options.semverAuto === false ? "사용 안 함" : "사용"} |`);
+  L.push(`| 서버 배포 방식 | ${options.deployStyle || "-"} |`);
+  L.push("");
+
+  L.push("## 환경설정 답변");
+  L.push("");
+  if (!answers.length) {
+    L.push("이 설치에서는 환경설정 질문이 없었습니다.");
+  } else {
+    L.push("`기본값` 열이 `예`면 질문에서 그대로 Enter를 누른 값입니다. 배포가 예상과 다르게 동작하면 여기부터 확인하세요.");
+    L.push("");
+    L.push("| 키 | 항목 | 값 | 기본값 | 사용처 |");
+    L.push("|---|---|---|---|---|");
+    for (const a of answers) {
+      L.push(`| \`${a.key}\` | ${a.label} | \`${maskValue(a.key, a.value)}\` | ${a.isDefault ? "예" : "아니오"} | ${a.scope || ""} |`);
+    }
+  }
+  L.push("");
+
+  L.push("## 설치 결과");
+  L.push("");
+  const sec = (title, items, fmt = (x) => `- \`${x}\``) => {
+    if (!items || !items.length) return;
+    L.push(`### ${title} (${items.length})`);
+    L.push("");
+    for (const it of items) L.push(fmt(it));
+    L.push("");
+  };
+  sec("새로 설치된 파일", result.copiedFiles);
+  sec("이전 배포 방식 정리 — 삭제", cleanup?.removed);
+  sec("이전 배포 방식 정리 — .bak 백업 (수정 내용 보존)", cleanup?.backedUp);
+  sec("건너뛴 파일", result.skippedFiles);
+  sec("백업 후 교체한 파일", result.backupFiles);
+  if (result.gitignoreUpdated) { L.push("`.gitignore`를 갱신했습니다 (충돌 백업 파일 무시 항목 추가)."); L.push(""); }
+
+  L.push("## 남은 할 일");
+  L.push("");
+  if (unresolved.length) {
+    L.push("### ⚠️ 값이 채워지지 않은 항목");
+    L.push("");
+    L.push("마법사가 값을 계산하지 못해 플레이스홀더가 그대로 남았습니다. **이 상태로는 해당 워크플로우가 정상 동작하지 않습니다.** 직접 채워 주세요.");
+    L.push("");
+    L.push("| 파일 | 줄 | 토큰 |");
+    L.push("|---|---|---|");
+    for (const u of unresolved) L.push(`| \`${u.filename}\` | ${u.line} | \`${u.token}\` |`);
+    L.push("");
+  }
+  if (secrets.size) {
+    L.push("### 등록해야 하는 GitHub Secret");
+    L.push("");
+    L.push("Settings > Secrets and variables > Actions 에서 등록합니다. 등록 전에는 해당 워크플로우가 실패합니다.");
+    L.push("");
+    L.push("| Secret | 사용하는 워크플로우 |");
+    L.push("|---|---|");
+    for (const [name, users] of secrets) L.push(`| \`${name}\` | ${users.map((u) => `\`${u}\``).join(", ")} |`);
+    L.push("");
+  }
+  if (!unresolved.length && !secrets.size) {
+    L.push("추가로 조치할 항목이 없습니다.");
+    L.push("");
+  }
+
+  return L.join("\n") + "\n";
+}
+
+// 로그 기록. 실패해도 설치 자체는 성공으로 끝나야 하므로 예외를 삼키고 null을 돌려준다 —
+// 로그를 못 남긴 것이 설치를 되돌릴 이유는 아니다.
+export function writeInstallLog(targetRoot, data = {}) {
+  try {
+    const filename = logFilename(data.at, data.action || "install");
+    const rel = `${LOG_DIR}/${filename}`;
+    writeText(join(targetRoot, rel), renderInstallLog(data));
+    return { path: rel };
+  } catch {
+    return null;
+  }
+}

package/src/core/options-ask.js

@@ -82,8 +82,11 @@ export async function askAllOptionalWorkflows({
   // ② Nexus: 각 타입의 nexus/ 폴더 (현재 spring만 존재, .sh L2719~2725)
   for (const t of types) {
     nexus = await askOptionalWorkflow({
-      dir: join(ptDir, t, "nexus"), icon: "📦", short: "Nexus 라이브러리 publish",
-      desc: "라이브러리/모듈을 Maven 저장소(Nexus)에 배포하는 워크플로우입니다. 일반 서버 배포가 아니라 라이브러리 프로젝트에만 필요합니다.",
+      // GitHub Packages publish도 같은 '라이브러리 배포' 계열이라 이 질문이 함께 관장한다 (이슈 #80).
+      // 종전에는 Nexus만 묻고 GitHub Packages는 무조건 설치돼, "라이브러리 배포 필요 없다"고
+      // 답한 사용자에게 라이브러리 배포 워크플로우가 깔렸다.
+      dir: join(ptDir, t, "nexus"), icon: "📦", short: "라이브러리 publish (Nexus · GitHub Packages)",
+      desc: "라이브러리/모듈을 Maven 저장소(Nexus)나 GitHub Packages에 배포하는 워크플로우입니다. 일반 서버 배포가 아니라 라이브러리 프로젝트에만 필요합니다. 포함하면 서버 배포 워크플로우는 설치되지 않습니다.",
       current: nexus, force, tty, io, forceAsk, say,
     });
   }