project-auto-wizard 0.1.34 → 0.3.0

package/src/core/baseline.js

@@ -0,0 +1,76 @@
+// 설치 시점 baseline (issue #69) — 업데이트에서 "누가 바꿨는지"를 가르는 기준점.
+//
+// 왜 필요한가: isUnchanged()는 payload(theirs)와 설치본(ours)을 2-way로 비교한다.
+// base가 없으니 업스트림이 한 글자만 고쳐도 사용자가 손대지 않은 파일이 changed로 떨어지고,
+// 결국 "전부 skip(업데이트 못 받음)" 아니면 "전부 backup(사용자 수정 전멸)" 둘 중 하나만
+// 고를 수 있게 된다.
+//
+// 파일 사본이 아니라 해시만 남긴다 — 분류가 목적이지 자동 병합이 목적이 아니다.
+//
+// 해시를 두 개 두는 이유(이슈 원안은 하나였다): env 치환으로 사용자 값이 들어간 파일은
+// 디스크 내용과 "기본값으로 렌더한 결과"가 애초에 다르다. 하나로는 두 질문에 동시에 답할 수 없다.
+//   - installed : 설치 시점 우리가 디스크에 쓴 내용     → "사용자가 그 뒤에 손댔는가"
+//   - rendered  : 그 시점 payload를 기본값 치환한 결과  → "업스트림이 그 뒤에 바뀌었는가"
+//
+// installed는 우리가 실제로 쓴 파일에만 채운다. 사용자 수정본을 installed로 기록하면
+// "우리가 쓴 것"이라고 거짓말하는 셈이고, 다음 업데이트에서 그 파일이 조용히 덮인다.
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { writeText } from "./fsutil.js";
+
+export const BASELINE_DIR = ".github/.wizard";
+export const BASELINE_PATH = ".github/.wizard/baseline.json";
+
+export function sha256(text) {
+  return "sha256:" + createHash("sha256").update(String(text), "utf8").digest("hex");
+}
+
+// 없거나 깨졌으면 null — 호출부는 "base 미상"으로 폴백한다(조용히 빈 baseline을 쓰지 않는다.
+// 빈 baseline은 "기록이 없다"가 아니라 "전부 삭제됐다"로 오해될 수 있다).
+export function readBaseline(targetRoot = ".") {
+  const p = join(targetRoot, BASELINE_PATH);
+  if (!existsSync(p)) return null;
+  try {
+    const data = JSON.parse(readFileSync(p, "utf8"));
+    if (!data || typeof data !== "object" || typeof data.files !== "object" || data.files === null) return null;
+    return data;
+  } catch {
+    return null; // 손상된 baseline은 없는 것으로 취급 — 업데이트를 막지 않는다
+  }
+}
+
+// entries: Map<filename, {installed?:string|null, rendered:string}>
+// 기존 baseline은 병합 대상이다 — 이번 실행에서 건드리지 않은 파일의 기준점을 잃지 않는다.
+export function writeBaseline(targetRoot, { templateVersion, installedAt, entries, previous = null }) {
+  const files = { ...(previous?.files || {}) };
+  for (const [filename, entry] of entries) {
+    const prev = files[filename] || {};
+    files[filename] = {
+      // installed는 이번에 실제로 쓴 경우에만 갱신. 유지(skip)한 파일은 예전 기준점을 지킨다.
+      installed: entry.installed ?? prev.installed ?? null,
+      rendered: entry.rendered,
+    };
+  }
+  const out = {
+    templateVersion: templateVersion || "unknown",
+    installedAt: installedAt || "",
+    files,
+  };
+  writeText(join(targetRoot, BASELINE_PATH), JSON.stringify(out, null, 2) + "\n");
+  return out;
+}
+
+// baseline에는 있는데 디스크에 없는 파일 = 사용자가 지운 것.
+// 별도의 삭제 이력 파일이 필요 없다는 것이 이 설계의 부산물이다.
+// candidates: payload가 이번에 설치하려는 파일명 목록 (그 밖의 baseline 항목은 관심 없다)
+export function detectRemoved(baseline, candidates, workflowsDir) {
+  if (!baseline) return [];
+  const removed = [];
+  for (const filename of candidates) {
+    if (!baseline.files[filename]) continue;      // 우리가 설치한 적 없는 파일 — 판단 근거 없음
+    if (existsSync(join(workflowsDir, filename))) continue;
+    removed.push(filename);
+  }
+  return removed;
+}

package/src/core/copy/simple.js

@@ -6,9 +6,9 @@ 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에선 무의미하나 무해).
+// version_manager.py, changelog_manager.py, truncate_release_notes.py 무조건 덮어쓰기 (+chmod — Windows에선 무의미하나 무해).
 export function copyScripts(payloadRoot, targetRoot = ".") {
-  const scripts = ["version_manager.py", "changelog_manager.py"];
+  const scripts = ["version_manager.py", "changelog_manager.py", "truncate_release_notes.py", "issue_helper.py"];
   let copied = 0;
   for (const s of scripts) {
     const src = join(payloadRoot, PAYLOAD.scriptsDir, s);

package/src/core/copy/workflows.js

@@ -3,18 +3,22 @@
 // 대화형 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";
-import { isUnchanged, substituteEnv } from "../wizard-env.js";
+import { substituteEnv } from "../wizard-env.js";
 import { substitute } from "../branding.js";
+import { sha256, readBaseline } from "../baseline.js";
 
 // 원본 텍스트 로더 — context.branches가 있으면 {{MAIN_BRANCH}}/{{DEVELOP_BRANCH}} 치환 적용.
 // classify(unchanged 판정)와 실제 복사가 같은 치환본을 봐야 재실행 시 가짜 충돌이 없다.
-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;
   };
 }
 
@@ -34,34 +38,101 @@ function configureEnv(targetPath, { type, projectPath = ".", repoName = "", reso
   writeFileSync(targetPath, out);
 }
 
-// 3분류 (신규/unchanged/changed) — 대상 워크플로우 디렉토리 기준.
-// srcText: 브랜치 치환이 적용된 원본 로더 (makeSrcText).
-function classify(srcDir, workflowsDir, envOpts, srcText) {
-  const result = { newFiles: [], unchanged: [], changed: [] };
+// payload 원본을 "기본값으로 가상 치환한 최종형" — isUnchanged가 내부에서 쓰는 것과 같은 값이다.
+// baseline.rendered와 비교해 "업스트림이 바뀌었는가"를 판정하는 데 쓴다.
+function renderVirtual(templateContent, envOpts) {
+  return substituteEnv(templateContent, { ...envOpts, useDefaults: true });
+}
+
+// 분류 — 대상 워크플로우 디렉토리 기준. srcText: 브랜치 치환이 적용된 원본 로더 (makeSrcText).
+//
+// baseline이 있으면 3-way로 가른다 (issue #69). base가 없던 시절에는 업스트림이 한 글자만 고쳐도
+// 사용자가 손대지 않은 파일이 changed로 떨어져, "전부 skip" 아니면 "전부 backup" 둘 중 하나만
+// 고를 수 있었다.
+//
+//   ours === theirs                    → unchanged     이미 최신, 할 일 없음
+//   sha(ours) === base.installed       → upstreamOnly  사용자 미수정 → 질문 없이 교체
+//   sha(theirs) === base.rendered      → localOnly     업스트림 그대로 → 질문 없이 유지
+//   그 외                              → changed       진짜 충돌 → 질문
+//   디스크에 없는데 baseline에 있음     → removed       사용자가 지움 → 되살리기 전에 물어봄
+//
+// baseline이 없는 기존 설치는 base 미상이라 upstreamOnly/localOnly 판정을 할 수 없고,
+// 종전대로 unchanged/changed 2분류로 떨어진다(폴백). 그 실행에서 baseline이 심긴다.
+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);
-    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);
+    const base = baseline?.files?.[filename] || null;
+
+    if (!existsSync(dst)) {
+      // baseline에 있는데 디스크에 없다 = 우리가 깔았던 파일을 사용자가 지웠다.
+      // 별도의 삭제 이력 파일이 필요 없다는 것이 baseline 설계의 부산물이다.
+      if (base) result.removed.push(filename);
+      else result.newFiles.push(filename);
+      continue;
     }
+
+    const tpl = srcText(src);
+    const inst = readFileSync(dst, "utf8");
+    const theirs = renderVirtual(tpl, envOpts);
+    if (theirs === inst) { result.unchanged.push(filename); continue; }
+    if (base?.installed && sha256(inst) === base.installed) { result.upstreamOnly.push(filename); continue; }
+    if (base?.rendered && sha256(theirs) === base.rendered) { result.localOnly.push(filename); continue; }
+    result.changed.push(filename);
   }
   return result;
 }
 
+// 한 원본 디렉토리를 분류 결과대로 처리한다. common·타입별·server-deploy가 같은 규칙을 쓴다.
+// filter: trunk-based 제외 같은 파일 단위 필터.
+//
+// 자동 처리되는 두 버킷이 이 함수의 핵심이다 (issue #69):
+//   upstreamOnly — 사용자가 손대지 않았으니 그냥 최신으로 교체한다. 물어볼 이유가 없다.
+//   localOnly    — 업스트림이 그대로니 사용자 수정본을 그대로 둔다. 역시 물어볼 이유가 없다.
+function processDir(srcDir, workflowsDir, envOpts, ctx, counters, filter = () => true) {
+  const { srcText, baseline, decisions, restoreRemoved, baselineTargets } = ctx;
+  const c = classify(srcDir, workflowsDir, envOpts, srcText, baseline);
+  const track = (f, wrote) => baselineTargets.set(f, { srcPath: join(srcDir, f), envOpts, wrote });
+  const write = (f) => { writeText(join(workflowsDir, f), srcText(join(srcDir, f))); counters.copied++; counters.copiedFiles.push(f); track(f, true); };
+
+  for (const f of c.unchanged.filter(filter)) { counters.skipped++; track(f, false); }
+
+  for (const f of c.localOnly.filter(filter)) { counters.skipped++; counters.keptLocal.push(f); track(f, false); }
+
+  for (const f of c.newFiles.filter(filter)) write(f);
+
+  for (const f of c.upstreamOnly.filter(filter)) { write(f); counters.autoUpdated.push(f); }
+
+  // 사용자가 지운 파일은 조용히 되살리지 않는다. 복원 결정이 있을 때만 다시 쓴다.
+  // 되살리지 않은 파일은 baselineTargets에 넣지 않는다 — 디스크에 없어 해시할 것이 없고,
+  // 기존 baseline 항목은 병합으로 남아 다음 실행에서도 "지운 파일"로 인식된다.
+  for (const f of c.removed.filter(filter)) {
+    if (restoreRemoved.has(f)) { write(f); counters.restoredFiles.push(f); }
+    else counters.removedKept.push(f);
+  }
+
+  for (const f of c.changed.filter(filter)) {
+    const decision = decisions.get(f);
+    applyDecision(decision, srcDir, workflowsDir, f, counters, srcText);
+    // 'backup'만 대상 파일 자체를 새로 쓴다. 'template'은 다른 파일명이고 'skip'은 기존 유지.
+    track(f, decision === "backup");
+  }
+  return c;
+}
+
 // 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) 충돌 결정.
+// hooks: { decisions?: Map<filename, 'skip'|'backup'|'template'>,   — 진짜 충돌(changed) 결정
+//          restoreRemoved?: Set<filename> }                          — 사용자가 지운 파일 중 복원할 것
 //        미지정 파일은 'skip'(현행 force 동작 100% 유지). 대화형 수집은 copyWorkflowsInteractive 참조.
-// 반환: {copied, skipped, templateAdded, optionalCopied, backupAdded}
+// 반환: {copied, skipped, templateAdded, optionalCopied, backupAdded, autoUpdated, keptLocal, removedKept, restoredFiles}
 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 restoreRemoved = hooks.restoreRemoved instanceof Set ? hooks.restoreRemoved : new Set();
   const workflowsDir = join(targetRoot, PATHS.workflowsDir);
   const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
   if (!exists(projectTypesDir)) throw new Error("패키지 구조 오류 — payload/workflows 폴더를 찾지 못했습니다.");
@@ -70,31 +141,31 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
   const deployValues = new Map(); // Map<type, Map<key,value>> — deploy 블록용 ask 값
   counters.deployValues = deployValues;
   counters.copiedFiles = []; // 이번 실행에서 실제로 새로 쓰여진 파일명 (issue #19 — printSummary 정확성용)
-  const srcText = makeSrcText(context.branches || null);
-  // values/useDefaults는 치환 경로에서만 의미 (isUnchanged는 내부에서 useDefaults:true 강제 — 가상 비교 무손상)
+  counters.autoUpdated = [];    // 질문 없이 최신으로 교체된 파일 (사용자 미수정)
+  counters.keptLocal = [];      // 질문 없이 사용자 수정본을 유지한 파일 (업스트림 무변경)
+  counters.removedKept = [];    // 사용자가 지웠고 되살리지 않은 파일
+  counters.restoredFiles = [];  // 사용자가 지웠지만 복원하기로 한 파일
+  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 강제 — 가상 비교 무손상)
   const envOptsFor = (type) => ({ type, projectPath: paths.get(type) || ".", repoName, resolvers, values: envValues, useDefaults: envUseDefaults });
+  const dirCtx = { srcText, baseline, decisions, restoreRemoved, baselineTargets };
 
-  // (1) common — 타입별 워크플로우와 동일한 3지선(README 계약, issue #20 H3): unchanged면 스킵,
-  //     changed면 decisions Map 결정에 따름(미지정 시 skip — 기존 사용자 수정 보존).
+  // (1) common — 타입별과 동일 규칙 (README 계약, issue #20 H3).
   //     trunk-based 모드는 VERSION-CONTROL·AUTO-CHANGELOG 미설치 (RELEASE-PUBLISH 단독).
   const branchMode = context.branches?.mode || "pr-flow";
   const commonDir = join(projectTypesDir, "common");
   if (exists(commonDir)) {
     const notExcluded = (filename) => !(branchMode === "trunk-based" && TRUNK_BASED_EXCLUDED.has(filename));
-    const { newFiles, unchanged, changed } = classify(commonDir, workflowsDir, envOptsFor("common"), srcText);
-    counters.skipped += unchanged.filter(notExcluded).length;
-    for (const f of newFiles.filter(notExcluded)) {
-      writeText(join(workflowsDir, f), srcText(join(commonDir, f)));
-      counters.copied++;
-      counters.copiedFiles.push(f);
-    }
-    for (const f of changed.filter(notExcluded)) applyDecision(decisions.get(f), commonDir, workflowsDir, f, counters, srcText);
+    processDir(commonDir, workflowsDir, envOptsFor("common"), dirCtx, counters, notExcluded);
   }
 
   // (2~4) 타입별
   for (const type of types) {
     const asks = new Map();
-    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { includeNexus, ...context, envOptsFor, collectAsks: asks, decisions, srcText }, counters);
+    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { includeNexus, ...context, deployStyle, envOptsFor, collectAsks: asks, dirCtx }, counters);
     if (asks.size) deployValues.set(type, asks);
   }
 
@@ -105,15 +176,35 @@ 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);
+      baselineTargets.set(filename, { srcPath: join(secretDir, filename), envOpts: envOptsFor("common"), wrote: true });
     }
   }
 
+  counters.baselineTargets = baselineTargets; // 호출부(runFull)가 env 치환 완료 후 baseline을 기록한다
   return counters;
 }
 
+// copyWorkflows가 끝나고 env 치환까지 마친 뒤에 호출한다 — 그래야 디스크 내용이 최종형이다.
+// entries: Map<filename, {installed:string|null, rendered:string}>
+export function computeBaselineEntries(baselineTargets, workflowsDir, srcText) {
+  const entries = new Map();
+  for (const [filename, info] of baselineTargets) {
+    const dst = join(workflowsDir, filename);
+    if (!existsSync(dst)) continue;
+    const rendered = sha256(renderVirtual(srcText(info.srcPath), info.envOpts));
+    // installed는 이번에 우리가 쓴 파일에만 채운다. 사용자 수정본을 installed로 기록하면
+    // "우리가 쓴 것"이라고 거짓말하는 셈이고, 다음 업데이트에서 그 파일이 조용히 덮인다.
+    entries.set(filename, { installed: info.wrote ? sha256(readFileSync(dst, "utf8")) : null, rendered });
+  }
+  return entries;
+}
+
 // changed(기존에 있고 내용이 바뀐) 파일 1개를 결정에 따라 처리 (.sh 3440~3508 3지선 case 등가).
 // 'skip'(기본): 기존 유지. 'backup': 기존→.bak 후 교체. 'template': 기존 유지 + 새 버전을 .template.yaml로.
 function applyDecision(decision, srcDir, workflowsDir, filename, counters, srcText) {
@@ -139,38 +230,49 @@ function applyDecision(decision, srcDir, workflowsDir, filename, counters, srcTe
   counters.skipped++; // 'skip'/미지정/ESC → 기존 유지 (.sh S)·force 기본)
 }
 
-// 대상 워크플로우 디렉토리에서 changed(충돌) 파일 목록만 뽑는다 — copyWorkflowsInteractive의 사전 조사용.
+// 대화형 사전 조사 — 사람이 답해야 하는 것만 뽑는다 (issue #69).
 // copyWorkflows 본체와 동일한 classify 기준을 써야 결정 Map이 실제 처리 대상과 1:1로 맞는다.
 // common도 타입별과 동일하게 스캔한다 (issue #20 H3 — 이전에는 common 충돌이 질문조차 되지 않았다).
-export function listWorkflowConflicts(context, payloadRoot, targetRoot = ".") {
+// 반환: { conflicts: [{filename,type}], removed: [{filename,type}] }
+//   conflicts — 양쪽이 다 바뀐 진짜 충돌. upstreamOnly/localOnly는 자동 처리되므로 여기 없다.
+//   removed   — 우리가 깔았는데 사용자가 지운 파일. 되살리기 전에 물어봐야 한다.
+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 = []; // [{ filename, type }] — 엔진 처리 순서와 동일 (common → 타입 순회 → 직하위 → server-deploy)
+  const conflicts = []; // 엔진 처리 순서와 동일 (common → 타입 순회 → 직하위 → server-deploy)
+  const removed = [];
+
+  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 }); }
+  };
 
   const commonDir = join(projectTypesDir, "common");
   if (exists(commonDir)) {
-    const envOpts = { type: "common", projectPath: ".", repoName, resolvers };
-    for (const f of classify(commonDir, workflowsDir, envOpts, srcText).changed) {
-      if (branchMode === "trunk-based" && TRUNK_BASED_EXCLUDED.has(f)) continue;
-      conflicts.push({ filename: f, type: "common" });
-    }
+    collect(commonDir, { type: "common", projectPath: ".", repoName, resolvers }, "common",
+      (f) => branchMode === "trunk-based" && TRUNK_BASED_EXCLUDED.has(f));
   }
 
   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 });
-    }
+    if (exists(typeDir)) collect(typeDir, envOpts, 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 });
-    }
+    if (exists(serverDeployDir) && !includeNexus) collect(serverDeployDir, envOpts, type, () => false, keepDeploy);
   }
-  return conflicts;
+  return { conflicts, removed };
+}
+
+// 진짜 충돌 목록만 필요할 때 (기존 호출부 호환).
+export function listWorkflowConflicts(context, payloadRoot, targetRoot = ".") {
+  return surveyWorkflows(context, payloadRoot, targetRoot).conflicts;
 }
 
 // 대화형 진입점 (async) — 충돌마다 onConflict(filename, type)를 await해 결정 Map을 만든 뒤
@@ -189,23 +291,19 @@ export async function copyWorkflowsInteractive(context, payloadRoot, targetRoot
 }
 
 function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters) {
-  const { includeNexus, envOptsFor, collectAsks = null, decisions = new Map(), srcText } = 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);
-  let unchangedNames = [];
+  // env 치환에서 제외할 파일 — 손대지 않기로 한 것들(unchanged/localOnly/유지된 삭제분)에
+  // 치환을 다시 걸면 사용자 수정본을 덮어쓰게 된다.
+  const untouched = [];
 
   // 타입별 워크플로우 (직하위)
   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++;
-      counters.copiedFiles.push(f);
-    }
-    // changed: 결정 Map에 따라 처리 (미지정=skip → 현행 force 동작과 동일)
-    for (const f of changed) applyDecision(decisions.get(f), typeDir, workflowsDir, f, counters, srcText);
+    const c = processDir(typeDir, workflowsDir, envOpts, dirCtx, counters);
+    untouched.push(...c.unchanged, ...c.localOnly);
   }
 
   // server-deploy
@@ -214,43 +312,29 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
     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++;
-        counters.copiedFiles.push(f);
-      }
-      for (const f of changed) applyDecision(decisions.get(f), serverDeployDir, workflowsDir, f, counters, srcText);
+      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) && isUnchanged(body, readFileSync(dst, "utf8"), envOpts)) {
-        counters.skipped++;
-        continue;
-      }
-      if (existsSync(dst)) { renameSync(dst, dst + ".bak"); counters.backupAdded++; }
-      writeText(dst, body);
-      counters.optionalCopied++;
-      counters.copied++;
-      counters.copiedFiles.push(filename);
-    }
+    const c = processDir(nexusDir, workflowsDir, envOpts, dirCtx, counters);
+    untouched.push(...c.unchanged, ...c.localOnly);
   }
 
-  // env 치환 — 이 타입의 원본 디렉토리들에서 복사돼 존재하고 unchanged 아닌 파일만
+  // env 치환 — 이 타입의 원본 디렉토리들에서 복사돼 존재하고, 손대지 않기로 한 것이 아닌 파일만
   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 제외
+      if (srcDir === serverDeployDir && !keepDeploy(filename)) continue; // 안 고른 배포 방식
+      if (!existsSync(target)) continue;          // 건너뛴 파일 제외
+      if (untouched.includes(filename)) continue; // unchanged/localOnly 제외
       configureEnv(target, { ...envOpts, collectAsks }); // env 계획 values/useDefaults 포함
     }
   }
@@ -263,12 +347,16 @@ 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";
-  const plan = { newFiles: [], unchanged: [], changed: [] };
+  // upstreamOnly/localOnly/removed는 baseline이 있을 때만 채워진다 (issue #69).
+  const plan = { newFiles: [], unchanged: [], changed: [], upstreamOnly: [], localOnly: [], removed: [] };
+  const BUCKETS = ["newFiles", "unchanged", "changed", "upstreamOnly", "localOnly", "removed"];
 
   const merge = (result, type, excluded = null) => {
-    for (const bucket of ["newFiles", "unchanged", "changed"]) {
+    for (const bucket of BUCKETS) {
       for (const filename of result[bucket]) {
         if (excluded && excluded.has(filename)) continue;
         plan[bucket].push({ filename, type });
@@ -279,7 +367,7 @@ export function planWorkflows(context, payloadRoot, targetRoot = ".") {
   const commonDir = join(projectTypesDir, "common");
   if (exists(commonDir)) {
     const envOpts = { type: "common", projectPath: ".", repoName, resolvers };
-    merge(classify(commonDir, workflowsDir, envOpts, srcText), "common",
+    merge(classify(commonDir, workflowsDir, envOpts, srcText, baseline), "common",
       branchMode === "trunk-based" ? TRUNK_BASED_EXCLUDED : null);
   }
 
@@ -296,16 +384,16 @@ export function planWorkflows(context, payloadRoot, targetRoot = ".") {
   for (const type of types) {
     const envOpts = { type, projectPath: paths.get(type) || ".", repoName, resolvers };
     const typeDir = join(projectTypesDir, type);
-    if (exists(typeDir)) merge(classify(typeDir, workflowsDir, envOpts, srcText), type);
+    if (exists(typeDir)) merge(classify(typeDir, workflowsDir, envOpts, srcText, baseline), type);
 
     const serverDeployDir = join(typeDir, "server-deploy");
     if (exists(serverDeployDir) && !includeNexus) {
-      merge(classify(serverDeployDir, workflowsDir, envOpts, srcText), type);
+      merge(classify(serverDeployDir, workflowsDir, envOpts, srcText, baseline, deployFilter(deployStyle)), type);
     }
 
     const nexusDir = join(typeDir, "nexus");
     if (exists(nexusDir) && includeNexus) {
-      merge(classify(nexusDir, workflowsDir, envOpts, srcText), type);
+      merge(classify(nexusDir, workflowsDir, envOpts, srcText, baseline), type);
     }
   }
 

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 };
+}