project-auto-wizard 0.12.2 → 0.13.1

package/src/core/copy/workflows.js

@@ -1,16 +1,18 @@
-// 워크플로우 복사 엔진 (.sh copy_workflows + _copy_workflows_for_type 등가).
-// 실측: template_integrator.sh 3398~3815.
+// 워크플로우 복사 엔진 — common → 타입별 → server-deploy 순으로 분류·복사·치환한다.
 // 대화형 3지선(기존 파일 충돌)은 copyWorkflowsInteractive(async)가 결정 Map을 만들어
 // 동기 엔진(copyWorkflows)에 hooks.decisions로 전달한다 — 기존 시그니처·force 동작 무변경.
 import { join, basename } from "node:path";
-import { deployFilter, isDeployWorkflow, activateDeployTrigger, DEFAULT_DEPLOY_STYLE, NO_DEPLOY_STYLE } from "../deploy-style.js";
-import { storeWorkflowFilter } from "../flutter-options.js";
+import {
+  deployFilter, isDeployWorkflow, activateDeployTrigger, payloadWorkflowNames, DEFAULT_DEPLOY_STYLE, NO_DEPLOY_STYLE,
+} from "../deploy-style.js";
+import { typeInfo } from "../types.js";
 import { existsSync, readFileSync, writeFileSync, renameSync } from "node:fs";
-import { PATHS, PAYLOAD } from "../paths.js";
+import { PATHS, PAYLOAD, typeWorkflowDirs } from "../paths.js";
 import { exists, writeText, listYamlFiles } from "../fsutil.js";
 import { substituteEnv } from "../wizard-env.js";
 import { substitute } from "../branding.js";
 import { sha256, readBaseline } from "../baseline.js";
+import { parseDeployBlock } from "../version-yml.js";
 import { log } from "../logger.js";
 
 // 원본 텍스트 로더 — context.branches가 있으면 {{MAIN_BRANCH}}/{{DEVELOP_BRANCH}} 치환 적용.
@@ -24,37 +26,84 @@ export function makeSrcText(branches, deployStyle = DEFAULT_DEPLOY_STYLE) {
   };
 }
 
-// trunk-based 모드에서 설치하지 않는 common 워크플로우 (DESIGN-SPEC §4 설치 매트릭스).
+// trunk-based 모드에서 설치하지 않는 common 워크플로우.
 // 릴리스 PR 흐름이 없으므로 RELEASE-PUBLISH 하나가 bump→changelog→tag→Release를 흡수한다.
 const TRUNK_BASED_EXCLUDED = new Set([
   "PROJECT-COMMON-VERSION-CONTROL.yaml",
   "PROJECT-COMMON-AUTO-CHANGELOG-CONTROL.yaml",
 ]);
 
-// 타입 루트 디렉토리에 거는 파일 필터 — "배포 안 함"의 CD 제외와 Flutter 스토어 대상 선택을 합성한다.
+// version.yml deploy 블록에 저장된 배포 값 — Map<type, Map<key,value>>.
+// 설치·분류·baseline이 같은 값을 기본값으로 써야 재실행 때 가짜 변경이 생기지 않는다.
+export function readSavedDeployValues(targetRoot = ".") {
+  const p = join(targetRoot, PATHS.versionFile);
+  if (!existsSync(p)) return new Map();
+  return parseDeployBlock(readFileSync(p, "utf8"));
+}
+
+// 타입 루트 디렉토리에 거는 파일 필터 — 배포 방식 필터와 Flutter 스토어 대상 선택을 합성한다.
 // copyWorkflowsForType·surveyWorkflows·planWorkflows가 같은 함수를 써야 설치·충돌 조사·status/dry-run이
 // 서로 다른 파일 집합을 보지 않는다. flutterStore가 배열이 아니면(null=미결정, 비대화형 기본) 스토어 필터는
 // 걸지 않는다. 필터가 없어도 항상 함수를 돌려준다 — processDir은 null을 받지 못한다.
-export function buildTypeRootFilter(type, deployStyle, flutterStore) {
+// go/python·react/next처럼 서버 배포 워크플로우가 타입 루트에 바로 있는 타입도 있어 배포 방식 필터를
+// 항상 건다. available(payload 파일명 집합)이 있어야 고른 방식이 없는 타입을 단일 서버 배포로 대체한다.
+export function buildTypeRootFilter(type, deployStyle, flutterStore, available = null) {
   const filters = [];
-  if (deployStyle === NO_DEPLOY_STYLE) filters.push(deployFilter(deployStyle));
-  if (type === "flutter" && Array.isArray(flutterStore)) filters.push(storeWorkflowFilter(flutterStore));
+  if (deployStyle) filters.push(deployFilter(deployStyle, available));
+  const typeFilter = typeInfo(type)?.hooks?.workflowFilter?.({ flutterStore });
+  if (typeFilter) filters.push(typeFilter);
   return (filename) => filters.every((keep) => keep(filename));
 }
 
-// 한 파일에 env 치환을 적용해 대상 파일을 갱신 (.sh configure_workflow_env 등가).
+// 한 타입이 설치하는 원본 디렉토리를 순서대로 돌려준다 — 타입 루트 → server-deploy.
+// 각 항목: { srcDir, type, filter }. 폴더 존재 여부와 "배포 안 함" 제외를 여기서 한 번에 판단한다.
+export function typeWorkflowSources(type, payloadRoot, { deployStyle, flutterStore = null, available = null }) {
+  const [typeDir, serverDeployDir] = typeWorkflowDirs(payloadRoot, type);
+  const sources = [];
+  // go/python·react/next처럼 서버 배포 워크플로우가 타입 루트에 바로 있는 타입도 있어 루트에도 배포 방식 필터를 건다.
+  if (exists(typeDir)) sources.push({ srcDir: typeDir, type, filter: buildTypeRootFilter(type, deployStyle, flutterStore, available) });
+  // "배포 안 함"이면 폴더째 제외
+  if (exists(serverDeployDir) && deployStyle !== NO_DEPLOY_STYLE) {
+    sources.push({ srcDir: serverDeployDir, type, filter: deployFilter(deployStyle, available) });
+  }
+  return sources;
+}
+
+// common 원본 — trunk-based 모드의 제외 필터를 반영한다. 폴더가 없으면 null.
+export function commonWorkflowSource(context, payloadRoot) {
+  const commonDir = join(payloadRoot, PAYLOAD.workflowsDir, "common");
+  if (!exists(commonDir)) return null;
+  const branchMode = context.branches?.mode || "pr-flow";
+  return {
+    srcDir: commonDir, type: "common",
+    filter: (filename) => !(branchMode === "trunk-based" && TRUNK_BASED_EXCLUDED.has(filename)),
+  };
+}
+
+// 설치 대상 워크플로우 원본을 엔진 처리 순서(common → 타입 순회 → 타입 루트 → server-deploy)로 내준다.
+// 복사·충돌 조사·미리보기 계획이 모두 이 순회를 써야 서로 다른 파일 집합을 보지 않는다.
+export function* workflowSources(context, payloadRoot, { deployStyle, available }) {
+  const { types = [], flutterStore = null } = context;
+  const common = commonWorkflowSource(context, payloadRoot);
+  if (common) yield common;
+  for (const type of types) yield* typeWorkflowSources(type, payloadRoot, { deployStyle, flutterStore, available });
+}
+
+// 한 파일에 env 치환을 적용해 대상 파일을 갱신.
 // values/useDefaults: env 계획(promptEnvPlan) 결과 — 미지정이면 기본값 경로(현행 force 동작).
-function configureEnv(targetPath, { type, projectPath = ".", repoName = "", resolvers = {}, collectAsks = null, values = new Map(), useDefaults = true }) {
+function configureEnv(targetPath, { type, projectPath = ".", repoName = "", resolvers = {}, collectAsks = null, values = new Map(), useDefaults = true, savedValues = null }) {
   const content = readFileSync(targetPath, "utf8");
   if (!content.includes("@wizard")) return;
-  const out = substituteEnv(content, { type, useDefaults, values, projectPath, repoName, resolvers, collectAsks });
+  const out = substituteEnv(content, { type, useDefaults, values, projectPath, repoName, resolvers, collectAsks, savedValues });
   writeFileSync(targetPath, out);
 }
 
-// payload 원본을 "기본값으로 가상 치환한 최종형" — isUnchanged가 내부에서 쓰는 것과 같은 값이다.
+// payload 원본을 "이번 실행이 쓸 값으로 가상 치환한 최종형" — 저장된 deploy 값(없으면 기본값)과
+// 이번에 답한 값을 반영한다. 기본값만 쓰면 기본값이 아닌 값으로 설치한 파일이 재실행마다 변경으로
+// 잡혀, 다시 쓰이면서 답한 값이 기본값으로 되돌아간다.
 // baseline.rendered와 비교해 "업스트림이 바뀌었는가"를 판정하는 데 쓴다.
 function renderVirtual(templateContent, envOpts) {
-  return substituteEnv(templateContent, { ...envOpts, useDefaults: true });
+  return substituteEnv(templateContent, { useDefaults: true, ...envOpts, collectAsks: null });
 }
 
 // 분류 — 대상 워크플로우 디렉토리 기준. srcText: 브랜치 치환이 적용된 원본 로더 (makeSrcText).
@@ -107,7 +156,7 @@ function classify(srcDir, workflowsDir, envOpts, srcText, baseline = null, filte
 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 track = (f, wrote, keepRendered = false) => baselineTargets.set(f, { srcPath: join(srcDir, f), envOpts, wrote, keepRendered });
   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)) {
@@ -147,12 +196,16 @@ function processDir(srcDir, workflowsDir, envOpts, ctx, counters, filter = () =>
     const decision = decisions.get(f);
     applyDecision(decision, srcDir, workflowsDir, f, counters, srcText);
     // 'backup'만 대상 파일 자체를 새로 쓴다. 'template'은 다른 파일명이고 'skip'은 기존 유지.
-    track(f, decision === "backup");
+    // skip은 업스트림 변경을 받지 않은 것이라 rendered를 예전 값으로 둔다 — 새 값으로 바꾸면 다음 실행에서
+    // "업스트림 무변경"으로 분류되어 그 변경을 영영 받을 수 없다.
+    const kept = decision !== "backup" && decision !== "template";
+    if (kept) counters.conflictKept.push(f);
+    track(f, decision === "backup", kept);
   }
   return c;
 }
 
-// copy_workflows 본체 (동기 — 기존 호출부 무변경).
+// 복사 엔진 본체 (동기 — 기존 호출부 무변경).
 // context: { types:[], paths:Map, force, repoName, resolvers,
 //            envValues?:Map<key,value>, envUseDefaults?:boolean }  ← env 계획(promptEnvPlan) 결과 주입점
 //            flutterStore?:string[]|null }  ← Flutter 스토어 대상 (null=필터 없음, 배열=선택된 플랫폼만)
@@ -177,20 +230,25 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
   counters.keptLocal = [];      // 질문 없이 사용자 수정본을 유지한 파일 (업스트림 무변경)
   counters.removedKept = [];    // 사용자가 지웠고 되살리지 않은 파일
   counters.restoredFiles = [];  // 사용자가 지웠지만 복원하기로 한 파일
+  counters.conflictKept = [];   // 양쪽이 다 바뀌어 기존 파일을 유지한 파일 (업스트림 변경 미반영)
   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 };
+  const saved = readSavedDeployValues(targetRoot);
+  const envOptsFor = (type) => ({
+    type, projectPath: paths.get(type) || ".", repoName, resolvers, values: envValues, useDefaults: envUseDefaults,
+    savedValues: saved.get(type) || null,
+  });
+  const available = payloadWorkflowNames(payloadRoot);
+  const dirCtx = { srcText, baseline, decisions, restoreRemoved, baselineTargets, available };
 
   // (1) common — 타입별과 동일 규칙 (README 계약).
   //     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 commonSource = commonWorkflowSource(context, payloadRoot);
+  if (commonSource) {
+    const { srcDir: commonDir, filter: notExcluded } = commonSource;
     const c = processDir(commonDir, workflowsDir, envOptsFor("common"), dirCtx, counters, notExcluded);
     // env 치환 — 타입별 폴더(copyWorkflowsForType)와 동일하게, 손대지 않기로 한 파일(unchanged/localOnly)은
     // 건너뛴다. common 최상위는 지금까지 @wizard 마커가 없어 이 루프가 없어도 드러나지 않았지만,
@@ -208,7 +266,7 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
   // (2~4) 타입별
   for (const type of types) {
     const asks = new Map();
-    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { ...context, deployStyle, envOptsFor, collectAsks: asks, dirCtx }, counters);
+    copyWorkflowsForType(type, payloadRoot, workflowsDir, { ...context, deployStyle, envOptsFor, collectAsks: asks, dirCtx }, counters);
     if (asks.size) deployValues.set(type, asks);
   }
 
@@ -218,12 +276,16 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
 
 // copyWorkflows가 끝나고 env 치환까지 마친 뒤에 호출한다 — 그래야 디스크 내용이 최종형이다.
 // entries: Map<filename, {installed:string|null, rendered:string}>
-export function computeBaselineEntries(baselineTargets, workflowsDir, srcText) {
+// savedDeploy: 이번 실행이 version.yml deploy 블록에 쓴 값(Map<type, Map<key,value>>). 다음 실행은 이 값을
+// 기본값으로 분류하므로 rendered도 같은 값으로 계산해야 재실행이 "업스트림 변경"으로 오인되지 않는다.
+export function computeBaselineEntries(baselineTargets, workflowsDir, srcText, savedDeploy = null) {
   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));
+    const envOpts = savedDeploy ? { ...info.envOpts, savedValues: savedDeploy.get(info.envOpts.type) || null } : info.envOpts;
+    // keepRendered: 충돌로 기존 파일을 유지함 — 예전 rendered를 그대로 두도록 null로 넘긴다(writeBaseline이 병합).
+    const rendered = info.keepRendered ? null : sha256(renderVirtual(srcText(info.srcPath), envOpts));
     // installed는 이번에 우리가 쓴 파일에만 채운다. 사용자 수정본을 installed로 기록하면
     // "우리가 쓴 것"이라고 거짓말하는 셈이고, 다음 업데이트에서 그 파일이 조용히 덮인다.
     entries.set(filename, { installed: info.wrote ? sha256(readFileSync(dst, "utf8")) : null, rendered });
@@ -231,13 +293,13 @@ export function computeBaselineEntries(baselineTargets, workflowsDir, srcText) {
   return entries;
 }
 
-// changed(기존에 있고 내용이 바뀐) 파일 1개를 결정에 따라 처리 (.sh 3440~3508 3지선 case 등가).
+// changed(기존에 있고 내용이 바뀐) 파일 1개를 결정에 따라 처리.
 // '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으로 백업 후 새 버전으로 교체
+    // 기존을 .bak으로 백업 후 새 버전으로 교체
     renameSync(dst, dst + ".bak");
     writeText(dst, srcText(src));
     counters.copied++;
@@ -247,16 +309,19 @@ function applyDecision(decision, srcDir, workflowsDir, filename, counters, srcTe
     return;
   }
   if (decision === "template") {
-    // .sh T) `${filename%.yaml}.template.yaml` — .yaml만 strip (.yml은 그대로 뒤에 붙음, .sh 동일)
+    // `${이름}.template.yaml` — .yaml만 떼고 붙인다 (.yml은 그대로 뒤에 붙는다)
     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 등가)
+    writeText(join(workflowsDir, templateName), srcText(src)); // 기존 .template.yaml 덮어씀
     counters.templateAdded++;
     counters.copiedFiles.push(templateName);
     log.info("copy", "template", `${filename} 유지 + ${templateName} 생성 (사용자 결정)`);
     return;
   }
-  counters.skipped++; // 'skip'/미지정/ESC → 기존 유지 (.sh S)·force 기본)
-  log.info("copy", "skip", `${filename} (사용자 결정: 기존 유지)`);
+  counters.skipped++; // 'skip'/미지정/ESC → 기존 유지 (force 기본)
+  // 결정이 없으면 사용자가 고른 게 아니라 --force 기본값이다 — 로그가 사실과 달라지지 않게 구분한다.
+  log.info("copy", "skip", decision
+    ? `${filename} (사용자 결정: 기존 유지, 업스트림 변경 미반영)`
+    : `${filename} (--force 기본값: 기존 유지, 업스트림 변경 미반영)`);
 }
 
 // 대화형 사전 조사 — 사람이 답해야 하는 것만 뽑는다.
@@ -266,39 +331,26 @@ function applyDecision(decision, srcDir, workflowsDir, filename, counters, srcTe
 //   conflicts — 양쪽이 다 바뀐 진짜 충돌. upstreamOnly/localOnly는 자동 처리되므로 여기 없다.
 //   removed   — 우리가 깔았는데 사용자가 지운 파일. 되살리기 전에 물어봐야 한다.
 export function surveyWorkflows(context, payloadRoot, targetRoot = ".") {
-  const { types = [], paths = new Map(), repoName = "", resolvers = {}, flutterStore = null } = context;
+  const { paths = new Map(), repoName = "", resolvers = {} } = context;
   const workflowsDir = join(targetRoot, PATHS.workflowsDir);
-  const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
   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 saved = readSavedDeployValues(targetRoot);
   const conflicts = []; // 엔진 처리 순서와 동일 (common → 타입 순회 → 직하위 → server-deploy)
   const removed = [];
-
-  const keepDeploy = deployFilter(deployStyle);
-  const collect = (srcDir, envOpts, type, skipFile = () => false, filter = null) => {
+  const available = payloadWorkflowNames(payloadRoot);
+  const values = context.envValues || new Map();
+  const useDefaults = context.envUseDefaults !== false;
+
+  for (const { srcDir, type, filter } of workflowSources(context, payloadRoot, { deployStyle, available })) {
+    // 복사 엔진과 같은 값(이번 답변 포함)으로 분류해야 결정 목록이 실제 처리 대상과 맞는다.
+    const envOpts = type === "common"
+      ? { type, projectPath: ".", repoName, resolvers, values, useDefaults }
+      : { type, projectPath: paths.get(type) || ".", repoName, resolvers, savedValues: saved.get(type) || null, values, useDefaults };
     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)) {
-    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)) {
-      collect(typeDir, envOpts, type, () => false, buildTypeRootFilter(type, deployStyle, flutterStore));
-    }
-    const serverDeployDir = join(typeDir, "server-deploy");
-    if (exists(serverDeployDir) && deployStyle !== NO_DEPLOY_STYLE) {
-      collect(serverDeployDir, envOpts, type, () => false, keepDeploy);
-    }
+    for (const f of c.changed) conflicts.push({ filename: f, type });
+    for (const f of c.removed) removed.push({ filename: f, type });
   }
   return { conflicts, removed };
 }
@@ -323,43 +375,32 @@ export async function copyWorkflowsInteractive(context, payloadRoot, targetRoot
   return copyWorkflows(context, payloadRoot, targetRoot, { decisions });
 }
 
-function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters) {
+function copyWorkflowsForType(type, payloadRoot, workflowsDir, ctx, counters) {
   const { deployStyle = "", flutterStore = null, envOptsFor, collectAsks = null, dirCtx } = ctx;
-  const keepDeploy = deployFilter(deployStyle);
-  const keepTypeRoot = buildTypeRootFilter(type, deployStyle, flutterStore);
-  const { srcText, baselineTargets } = dirCtx;
-  const typeDir = join(projectTypesDir, type);
+  const { srcText } = dirCtx;
+  const sources = typeWorkflowSources(type, payloadRoot, { deployStyle, flutterStore, available: dirCtx.available });
   const envOpts = envOptsFor(type);
   // env 치환에서 제외할 파일 — 손대지 않기로 한 것들(unchanged/localOnly/유지된 삭제분)에
   // 치환을 다시 걸면 사용자 수정본을 덮어쓰게 된다.
   const untouched = [];
 
-  // 타입별 워크플로우 (직하위). go/python처럼 CD 워크플로우가 server-deploy 없이 타입 루트에
-  // 바로 있는 타입도 있다 — "배포 안 함"일 때는 타입 루트에서도 CD 파일(SIMPLE-CICD 등)을
-  // 걸러야 한다. simple/nginx/traefik은 오늘과 동일하게 필터 없이 전부 복사한다.
-  if (exists(typeDir)) {
-    const c = processDir(typeDir, workflowsDir, envOpts, dirCtx, counters, keepTypeRoot);
-    untouched.push(...c.unchanged, ...c.localOnly);
-  }
-
-  // server-deploy
-  const serverDeployDir = join(typeDir, "server-deploy");
-  // "배포 안 함"이면 폴더째 제외 (복사 안 함)
-  if (exists(serverDeployDir) && deployStyle !== NO_DEPLOY_STYLE) {
-    const c = processDir(serverDeployDir, workflowsDir, envOpts, dirCtx, counters, keepDeploy);
+  for (const { srcDir, filter } of sources) {
+    const c = processDir(srcDir, workflowsDir, envOpts, dirCtx, counters, filter);
     untouched.push(...c.unchanged, ...c.localOnly);
   }
 
   // env 치환 — 이 타입의 원본 디렉토리들에서 복사돼 존재하고, 손대지 않기로 한 것이 아닌 파일만
-  for (const srcDir of [typeDir, serverDeployDir]) {
-    if (!exists(srcDir)) continue;
-    if (srcDir === serverDeployDir && deployStyle === NO_DEPLOY_STYLE) continue; // 폴더째 제외
+  for (const { srcDir, filter } of sources) {
     for (const filename of listYamlFiles(srcDir)) {
       const target = join(workflowsDir, filename);
-      if (srcDir === serverDeployDir && !keepDeploy(filename)) continue; // 안 고른 배포 방식
-      if (srcDir === typeDir && !keepTypeRoot(filename)) continue; // 타입 루트: 배제된 CD·안 고른 스토어 워크플로우
+      if (!filter(filename)) continue; // 배제된 CD·안 고른 배포 방식·안 고른 스토어 워크플로우
       if (!existsSync(target)) continue;          // 건너뛴 파일 제외
-      if (untouched.includes(filename)) continue; // unchanged/localOnly 제외
+      // unchanged/localOnly와 치환 마커가 이미 없는 유지본은 다시 치환하지 않는다. 대신 deploy 블록이
+      // 사라지지 않도록 저장값(없으면 기본값)으로 ask 값만 수집한다 — 파일은 건드리지 않는다.
+      if (untouched.includes(filename) || !readFileSync(target, "utf8").includes("@wizard")) {
+        if (collectAsks) substituteEnv(srcText(join(srcDir, filename)), { ...envOpts, useDefaults: true, collectAsks });
+        continue;
+      }
       configureEnv(target, { ...envOpts, collectAsks }); // env 계획 values/useDefaults 포함
     }
   }
@@ -369,43 +410,24 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
 // changed뿐 아니라 newFiles/unchanged까지 전부 반환한다는 점이 listWorkflowConflicts(changed만
 // 반환)와 다르다(읽기 전용 — 실제로 아무 파일도 쓰지 않는다).
 export function planWorkflows(context, payloadRoot, targetRoot = ".") {
-  const { types = [], paths = new Map(), repoName = "", resolvers = {}, flutterStore = null } = context;
+  const { paths = new Map(), repoName = "", resolvers = {} } = context;
   const workflowsDir = join(targetRoot, PATHS.workflowsDir);
-  const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
   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 saved = readSavedDeployValues(targetRoot);
+  const available = payloadWorkflowNames(payloadRoot);
   // upstreamOnly/localOnly/removed는 baseline이 있을 때만 채워진다.
   const plan = { newFiles: [], unchanged: [], changed: [], upstreamOnly: [], localOnly: [], removed: [] };
   const BUCKETS = ["newFiles", "unchanged", "changed", "upstreamOnly", "localOnly", "removed"];
 
-  const merge = (result, type, excluded = null) => {
+  for (const { srcDir, type, filter } of workflowSources(context, payloadRoot, { deployStyle, available })) {
+    const envOpts = type === "common"
+      ? { type, projectPath: ".", repoName, resolvers }
+      : { type, projectPath: paths.get(type) || ".", repoName, resolvers, savedValues: saved.get(type) || null };
+    const result = classify(srcDir, workflowsDir, envOpts, srcText, baseline, filter);
     for (const bucket of BUCKETS) {
-      for (const filename of result[bucket]) {
-        if (excluded && excluded.has(filename)) continue;
-        plan[bucket].push({ filename, type });
-      }
-    }
-  };
-
-  const commonDir = join(projectTypesDir, "common");
-  if (exists(commonDir)) {
-    const envOpts = { type: "common", projectPath: ".", repoName, resolvers };
-    merge(classify(commonDir, workflowsDir, envOpts, srcText, baseline), "common",
-      branchMode === "trunk-based" ? TRUNK_BASED_EXCLUDED : null);
-  }
-
-  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, baseline, buildTypeRootFilter(type, deployStyle, flutterStore)), type);
-    }
-
-    const serverDeployDir = join(typeDir, "server-deploy");
-    if (exists(serverDeployDir) && deployStyle !== NO_DEPLOY_STYLE) {
-      merge(classify(serverDeployDir, workflowsDir, envOpts, srcText, baseline, deployFilter(deployStyle)), type);
+      for (const filename of result[bucket]) plan[bucket].push({ filename, type });
     }
   }
 

package/src/core/deploy-style.js

@@ -2,8 +2,10 @@
 // Nginx 무중단과 Traefik 무중단을 동시에 쓰는 경우는 없으므로 하나만 설치한다.
 // 고른 것은 push 트리거까지 켜서 설치한다 — 설치했는데 안 도는 상태를 만들지 않는다.
 import { join } from "node:path";
-import { existsSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync } from "node:fs";
 import { sha256 } from "./baseline.js";
+import { PAYLOAD, typeWorkflowDirs } from "./paths.js";
+import { SINGLE_SERVER_CD_FILES } from "./types.js";
 
 // 파일명 접미사로 식별한다 — 타입 접두사(PROJECT-SPRING- 등)는 타입마다 다르기 때문.
 export const DEPLOY_STYLES = [
@@ -25,17 +27,81 @@ export const isDeployStyle = (v) => v === NO_DEPLOY_STYLE || DEPLOY_STYLES.some(
 // 이 파일이 CD 본체인가 (= 택1 대상인가). PR 프리뷰는 배포 방식과 직교하는 축이라 제외한다.
 export const isDeployWorkflow = (filename) => DEPLOY_STYLES.some((s) => filename.endsWith(s.suffix));
 
+const PREVIEW_SUFFIX = "-PR-PREVIEW.yaml";
+
+// 서버에 배포하는 워크플로우 전부 — CD 본체, 단일 CD(react·next), PR 프리뷰.
+// "배포 안 함"은 이 전부를 모든 타입에서 똑같이 뺀다. 일부만 빼면 서버 Secret 요구가 남는다.
+export const isServerDeployWorkflow = (filename) =>
+  isDeployWorkflow(filename) || SINGLE_SERVER_CD_FILES.has(filename) || filename.endsWith(PREVIEW_SUFFIX);
+
+// 선택한 타입 중 서버 배포 워크플로우를 가진 타입이 있는가 — payload 파일로 판정한다.
+// 없으면(node·flutter 등) 배포 방식은 설치 결과에 아무 영향이 없으므로 묻지도 기록하지도 않는다.
+export function hasServerDeployWorkflows(payloadRoot, types = []) {
+  return types.some((type) => typeWorkflowDirs(payloadRoot, type)
+    .some((dir) => existsSync(dir) && readdirSync(dir).some(isServerDeployWorkflow)));
+}
+
+// 선택한 타입 중 무중단(nginx·traefik) 워크플로우가 있는 타입이 있는가 — 없으면 무중단 선택지를 보이지 않는다.
+export function hasNonstopWorkflows(payloadRoot, types = []) {
+  const nonstop = DEPLOY_STYLES.filter((s) => s.value !== DEFAULT_DEPLOY_STYLE).map((s) => s.suffix);
+  return types.some((type) => typeWorkflowDirs(payloadRoot, type)
+    .some((dir) => existsSync(dir) && readdirSync(dir).some((f) => nonstop.some((sfx) => f.endsWith(sfx)))));
+}
+
+// payload/workflows/** 의 워크플로우 파일명 전체. 파일명은 PROJECT-{TYPE}- 접두사로 타입 간 유일하다.
+export function payloadWorkflowNames(payloadRoot) {
+  const names = new Set();
+  const root = join(payloadRoot, PAYLOAD.workflowsDir);
+  if (!existsSync(root)) return names;
+  for (const e of readdirSync(root, { recursive: true, withFileTypes: true })) {
+    if (e.isFile() && /\.ya?ml$/.test(e.name)) names.add(e.name);
+  }
+  return names;
+}
+
 // 모르는 값은 기본값으로 수렴시킨다. 빈 접미사를 돌려주면 endsWith("")가 항상 참이라
 // "전부 통과"가 되어, 잘못된 값이 조용히 CD 전부 설치로 새어나간다.
 const suffixOf = (style) =>
   (DEPLOY_STYLES.find((s) => s.value === style) ?? DEPLOY_STYLES.find((s) => s.value === DEFAULT_DEPLOY_STYLE)).suffix;
+const SIMPLE_SUFFIX = suffixOf(DEFAULT_DEPLOY_STYLE);
+
+// 고른 방식의 CD가 없는 타입의 단일 서버 배포 CD인가 (예: nginx를 골랐는데 python·go에는 NONSTOP이 없다).
+// 그런 타입은 단일 서버 배포로 대신 설치한다 — 설치 직후 지우거나 .bak으로 옮기면 배포가 사라진다.
+function isFallbackSimple(filename, style, available) {
+  if (!available || !filename.endsWith(SIMPLE_SUFFIX)) return false;
+  const prefix = filename.slice(0, -SIMPLE_SUFFIX.length);
+  return !available.has(prefix + suffixOf(style));
+}
 
 // 파일 필터 — 고른 방식의 CD만 통과. CD가 아닌 파일(PR 프리뷰·common 등)은 항상 통과.
-// "none"은 CD를 하나도 설치하지 않으므로 접미사 매칭 없이 CD 파일 전부를 거른다.
-export function deployFilter(style) {
-  if (style === NO_DEPLOY_STYLE) return (filename) => !isDeployWorkflow(filename);
+// "none"은 서버 배포 워크플로우(CD·단일 CD·PR 프리뷰)를 하나도 설치하지 않는다.
+// available: payload 워크플로우 파일명 집합(payloadWorkflowNames). 주면 고른 방식이 없는 타입은
+// 단일 서버 배포로 대체한다. 없으면 접미사만으로 가른다.
+export function deployFilter(style, available = null) {
+  if (style === NO_DEPLOY_STYLE) return (filename) => !isServerDeployWorkflow(filename);
   const suffix = suffixOf(style);
-  return (filename) => !isDeployWorkflow(filename) || filename.endsWith(suffix);
+  return (filename) => !isDeployWorkflow(filename) || filename.endsWith(suffix)
+    || isFallbackSimple(filename, style, available);
+}
+
+// 고른 방식(nginx·traefik)의 워크플로우가 없어 단일 서버 배포로 대신 설치하는 타입 목록 — 안내용.
+export function fallbackStyleTypes(payloadRoot, types = [], style) {
+  if (!style || style === NO_DEPLOY_STYLE || suffixOf(style) === SIMPLE_SUFFIX) return [];
+  return types.filter((type) => {
+    const files = typeWorkflowDirs(payloadRoot, type)
+      .filter((dir) => existsSync(dir)).flatMap((dir) => readdirSync(dir));
+    return files.some(isServerDeployWorkflow) && !files.some((f) => f.endsWith(suffixOf(style)));
+  });
+}
+
+// 실제로 설치되는 배포 방식 — 고른 무중단 방식의 워크플로우가 선택한 타입 어디에도 없으면 전부 단일 서버
+// 배포로 대신 설치되므로 simple이다. 고른 값을 그대로 기록하면 version.yml·status가 설치 상태와 어긋나고,
+// 다음 실행도 그 값을 기본값으로 이어받는다. 한 타입이라도 그 방식이 있으면 고른 값을 유지한다.
+export function effectiveDeployStyle(payloadRoot, types = [], style) {
+  if (!style || style === NO_DEPLOY_STYLE || suffixOf(style) === SIMPLE_SUFFIX) return style;
+  const installed = types.some((type) => typeWorkflowDirs(payloadRoot, type)
+    .some((dir) => existsSync(dir) && readdirSync(dir).some((f) => f.endsWith(suffixOf(style)))));
+  return installed ? style : DEFAULT_DEPLOY_STYLE;
 }
 
 // 무중단 템플릿은 push 트리거가 주석 처리된 채 들어 있다(기본 배포가 단일 서버라서).
@@ -73,24 +139,30 @@ export function activateDeployTrigger(content) {
 //   손대지 않은 것(baseline의 installed 해시와 동일) → 삭제. 물어볼 이유가 없다.
 //   손댄 것                                          → .bak으로 옮긴다. 내용은 지키고 트리거만 죽인다.
 //
+// opts.available  — payload 워크플로우 파일명 집합. 주면 그 안의 파일(마법사가 까는 파일)만 정리하고,
+//                   고른 방식이 없는 타입의 단일 서버 배포는 남긴다.
+// opts.justWritten — 이번 실행에서 마법사가 방금 쓴 파일. 첫 설치처럼 baseline이 없어도 수정본으로 오인하지 않는다.
+// opts.dryRun      — 판정만 하고 파일은 건드리지 않는다. --dry-run 미리보기가 실제 실행과 같은 판정을 쓰게 한다.
 // 반환: { removed:[], backedUp:[] } — 완료 화면·설치 기록에 그대로 보고한다.
-export function cleanupOtherDeployWorkflows(workflowsDir, installedFilenames, style, baseline) {
-  const keep = deployFilter(style);
+export function cleanupOtherDeployWorkflows(workflowsDir, installedFilenames, style, baseline, { available = null, justWritten = [], dryRun = false } = {}) {
+  const keep = deployFilter(style, available);
+  const written = new Set(justWritten);
   const removed = [];
   const backedUp = [];
 
   for (const filename of installedFilenames) {
-    if (!isDeployWorkflow(filename) || keep(filename)) continue;
+    if (!isServerDeployWorkflow(filename) || keep(filename)) continue;
+    if (available && !available.has(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;
+    const untouched = written.has(filename) || (known && sha256(readFileSync(p, "utf8")) === known);
     if (untouched) {
-      rmSync(p, { force: true });
+      if (!dryRun) rmSync(p, { force: true });
       removed.push(filename);
     } else {
-      renameSync(p, `${p}.bak`);
+      if (!dryRun) renameSync(p, `${p}.bak`);
       backedUp.push(filename);
     }
   }