projectops 4.0.3 → 4.1.1

package/README.md

@@ -7,7 +7,7 @@
 > 이슈 등록부터 커밋, 보고서, 배포까지. 개발자는 코드만 작성하세요.
 
 <!-- AUTO-VERSION-SECTION: DO NOT EDIT MANUALLY -->
-## 최신 버전 : v4.0.2 (2026-07-08)
+## 최신 버전 : v4.0.4 (2026-07-08)
 
 [전체 버전 기록 보기](CHANGELOG.md)
 
@@ -218,8 +218,7 @@ bash <(curl -fsSL "https://raw.githubusercontent.com/Cassiiopeia/projectops/main
 |------|----------|-------|
 | `spring` | build.gradle | SSH+Docker 배포, Nexus |
 | `flutter` | pubspec.yaml | TestFlight, Play Store |
-| `react` | package.json | Docker |
-| `next` | package.json | Docker |
+| `react` (Next.js 포함) | package.json | Docker |
 | `node` | package.json | Docker |
 | `python` | pyproject.toml | SSH+Docker 배포 |
 | `react-native` | Info.plist + build.gradle | — |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "projectops",
-  "version": "4.0.3",
+  "version": "4.1.1",
   "description": "ProjectOps — 완전 자동화 GitHub 프로젝트 관리 템플릿 통합 CLI (구 SUH-DEVOPS-TEMPLATE 마법사)",
   "keywords": [
     "devops",

package/src/cli/help.js

@@ -8,8 +8,9 @@ export const HELP_TEXT = `projectops — GitHub 프로젝트 자동화 템플릿
   -m, --mode MODE          통합 모드 (full | version | workflows | issues | skills)
                            기본: interactive (대화형)
   -t, --type CSV           프로젝트 타입 csv (예: spring,react,python)
-                           지원: spring flutter next react react-native
+                           지원: spring flutter react react-native
                                  react-native-expo node python basic
+                           (next는 react로 흡수됨 — Next.js 프로젝트는 react 사용)
       --project-version V  통합 대상의 초기 버전 (예: 1.0.0). 미지정 시 자동 감지
       --paths "t=p,..."    타입별 프로젝트 경로 (모노레포). 예: flutter=app,react=client
       --nexus / --no-nexus            Nexus 라이브러리 publish 워크플로우 포함/제외

package/src/commands/full.js

@@ -19,7 +19,7 @@ import { ensureGitignore } from "../core/copy/gitignore.js";
 // context: { version, types, paths:Map, branch, versionCode, includeNexus, includeSecretBackup,
 //            force, repoName, resolvers, now, today }
 // tempDir: 획득된 템플릿. targetRoot: 통합 대상.
-export function runFull(context, tempDir, targetRoot = ".") {
+export function runFull(context, tempDir, targetRoot = ".", hooks = {}) {
   const { version, types = [], paths = new Map(), branch = "main", versionCode = 1,
     force = true, now, today, templateVersion = "unknown",
     includeNexus = false, includeSecretBackup = false } = context;
@@ -29,8 +29,8 @@ export function runFull(context, tempDir, targetRoot = ".") {
   for (const [t] of paths) pathMarkers.set(t, markerForType(t));
 
   // 3. 워크플로우 복사 (+ env 치환) — deploy 블록에 쓸 ask 값을 수집한다.
-  //    (.sh는 copy_workflows 후 update_version_yml_deploy로 deploy 블록을 붙인다.)
-  const wfCounters = copyWorkflows(context, tempDir, targetRoot);
+  //    hooks.decisions: 대화형 충돌 3지선 결정 Map (미지정=skip — 현행 force 동작)
+  const wfCounters = copyWorkflows(context, tempDir, targetRoot, hooks);
   const deployValues = wfCounters.deployValues || new Map(); // Map<type, Map<key,value>>
 
   // 1. version.yml 생성 (전체 재생성 — metadata → deploy → template 순, .sh 최종형과 동일)

package/src/commands/interactive.js

@@ -1,10 +1,19 @@
-// 대화형 마법사 (.sh interactive_mode 등가) — template_integrator.sh 4262~4411.
+// 대화형 마법사 (.sh interactive_mode 등가) — template_integrator.sh 4262~4411 + #446 UI 5층.
 // io 주입으로 테스트 가능. 실제 실행은 src/ui/prompts.js 함수를 io로 넘긴다.
+// 새 시각 층(banner/detectionLog/analysisCard/ideStatus/installKind/summary)과 저수준 엔진(engineIo)은
+// io의 "옵셔널 멤버" — 스텁이 생략하면 해당 층만 건너뛰고 실행 계약은 동일하다.
 import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 import { PATHS } from "../core/paths.js";
 import { remove } from "../core/fsutil.js";
 import { acquireTemplate, readTemplateVersion } from "../core/assets.js";
-import { detectTypes, detectVersion, detectDefaultBranch, detectRepoName } from "../core/detect-fs.js";
+import { detectTypes, detectVersion, detectDefaultBranch, detectRepoName, makeResolvers } from "../core/detect-fs.js";
+import { parseExisting } from "../core/version-yml.js";
+import { runBreakingCheck } from "../core/breaking-check.js";
+import { resolveProjectPaths } from "../core/paths-resolve.js";
+import { askAllOptionalWorkflows } from "../core/options-ask.js";
+import { promptEnvPlan } from "../ui/env-plan.js";
+import { listWorkflowConflicts } from "../core/copy/workflows.js";
 import { createContext, VALID_TYPES } from "../context.js";
 import { runFull } from "./full.js";
 import { runVersion } from "./version.js";
@@ -14,21 +23,40 @@ import { runSkills } from "./skills.js";
 import * as prompts from "../ui/prompts.js";
 
 const CANCEL = prompts.CANCEL;
+const isCancel = (v) => v === CANCEL || typeof v === "symbol";
 
 // io 기본값 = 실제 prompts. 테스트는 스텁 io 주입.
 // skills = runSkills 주입 지점(테스트가 실제 IDE CLI를 안 건드리게). 기본은 실제 runSkills.
 export async function runInteractive(baseCtx, { cwd = process.cwd(), source = { type: "git" }, clock, io = prompts, skills = runSkills } = {}) {
-  io.intro?.("projectops — 대화형 통합 마법사");
-
-  // 1) 모드 선택
-  const mode = await io.selectMode();
-  if (mode === CANCEL || mode == null) { io.cancelMessage?.("설치를 취소했습니다."); return 0; }
-
   const tempDir = join(cwd, PATHS.tempDir);
   try {
+    // 템플릿 먼저 획득 — 배너에 실제 템플릿 버전을 표시 (.sh는 원격 version.yml fetch L4270~4280 등가)
     acquireTemplate({ tempDir, source });
     const templateVersion = readTemplateVersion(tempDir);
 
+    // 층1 — 시작 배너 (#446 확정 시안 A). 스텁엔 banner 없음 → intro 폴백.
+    if (io.banner) io.banner({ version: templateVersion, modeLabel: "대화형 통합 마법사" });
+    else io.intro?.("projectops — 대화형 통합 마법사");
+
+    // 기존 version.yml — version/version_code/paths/옵션 보존의 단일 진실 (.sh SSoT L2208~2239)
+    const vyPath = join(cwd, "version.yml");
+    const existing = existsSync(vyPath) ? parseExisting(readFileSync(vyPath, "utf8")) : null;
+
+    // 층4 — IDE Skills 현재 상태 · 층5 — 신규/업데이트 판별 (#446)
+    io.ideStatus?.();
+    io.installKind?.({ currentTemplateVersion: existing?.templateVersion || "", templateVersion });
+
+    // 1) 모드 선택
+    const mode = await io.selectMode();
+    if (mode === CANCEL || mode == null) { io.cancelMessage?.("설치를 취소했습니다."); return 0; }
+
+    // Breaking Changes 게이트 (.sh execute_integration L4415~4420 — 모든 모드 공통, 대화형은 확인 질문)
+    const proceed = await runBreakingCheck({
+      cwd, tempDir, templateVersion,
+      askYesNo: (msg, def) => io.askYesNo(msg, def),
+    });
+    if (!proceed) { io.cancelMessage?.("통합을 안전하게 취소했습니다."); return 0; }
+
     // skills 모드 — IDE 스킬 설치 (템플릿 통합 없음). 대화형으로 실행.
     if (mode === "skills") {
       await skills({ templateVersion, tempDir, interactive: true });
@@ -40,68 +68,153 @@ export async function runInteractive(baseCtx, { cwd = process.cwd(), source = {
     if (mode === "issues") {
       const ctx = createContext({ ...baseCtx, mode, force: true });
       runIssues(ctx, tempDir, cwd);
+      io.summary?.({ mode, types: [], version: "", counters: {} }, cwd);
       io.outro?.("이슈·PR 템플릿을 설치했습니다.");
       return 0;
     }
 
-    // full/version/workflows — 감지
+    // full/version/workflows — 감지 (version은 기존 version.yml 최우선)
     let types = detectTypes(cwd);
-    let version = detectVersion(cwd);
+    let version = (existing?.version) || detectVersion(cwd);
     let branch = detectDefaultBranch(cwd);
     const repoName = detectRepoName(cwd);
-    let includeNexus = false, includeSecretBackup = false;
+    const versionCode = existing?.versionCode ?? 1; // 기존 빌드번호 보존
+    // 선택 워크플로우 초기값: version.yml 저장 옵션 (.sh read_template_options L2361 등가)
+    let includeNexus = existing?.options?.nexus ?? false;
+    let includeSecretBackup = existing?.options?.secretBackup ?? false;
     const showOptional = mode === "full" || mode === "workflows";
+    const realTty = process.stdout.isTTY === true;
+
+    // 층2 — 감지 로그 (#446)
+    io.detectionLog?.({ types, version, branch });
+
+    // 선택 워크플로우(Nexus/Secret) 질문 (.sh ask_all_optional_workflows L2707 — full/workflows만)
+    if (showOptional) {
+      const r = await askAllOptionalWorkflows({
+        tempDir, types, targetRoot: cwd,
+        current: { nexus: existing?.options?.nexus ?? null, secretBackup: existing?.options?.secretBackup ?? null },
+        force: false, tty: realTty,
+        io: { confirm: ({ message, initialValue }) => io.askYesNo(message, initialValue) },
+      });
+      includeNexus = r.nexus;
+      includeSecretBackup = r.secretBackup;
+    }
 
-    // 확인/수정 루프
+    // 확인/수정 루프 — ESC는 '머무르기' (.sh L1877~1881: 명시적 '아니오'만 종료)
+    let paths = new Map();
     let confirmed = false;
     while (!confirmed) {
-      io.note?.(summarize({ mode, types, version, branch, includeNexus, includeSecretBackup, showOptional }), "프로젝트 분석 결과");
+      // 층3 — 프로젝트 분석 개요 카드 (#446). 스텁엔 없음 → note 폴백.
+      if (io.analysisCard) {
+        io.analysisCard({ mode, modeLabel: modeLabel(mode), types, version, branch, includeNexus, includeSecretBackup, showOptional, paths });
+      } else {
+        io.note?.(summarize({ mode, types, version, branch, includeNexus, includeSecretBackup, showOptional }), "프로젝트 분석 결과");
+      }
       const choice = await io.confirmProjectMenu();
-      if (choice === CANCEL || choice === "cancel") { io.cancelMessage?.("설치를 취소했습니다."); return 0; }
+      if (choice === "cancel") { io.cancelMessage?.("설치를 취소했습니다."); return 0; }
+      if (isCancel(choice) || choice == null) continue; // ESC = 머무르기 (루프 재출력)
       if (choice === "continue") { confirmed = true; break; }
       // edit 루프
       let editing = true;
       while (editing) {
         const what = await io.editMenu({ showOptional });
-        if (what === CANCEL || what === "done") { editing = false; break; }
+        if (isCancel(what) || what === "done") { editing = false; break; }
         if (what === "type") {
           const t = await io.selectTypes(types);
-          if (t !== CANCEL && Array.isArray(t) && t.length) types = t;
+          if (!isCancel(t) && Array.isArray(t) && t.length) {
+            // 타입 집합이 실제로 바뀌면 경로 재해석 대상으로 초기화 (.sh L1984~1992 — 정렬 집합 비교)
+            const oldSorted = [...types].sort().join(",");
+            types = t.filter((x) => VALID_TYPES.includes(x));
+            if ([...types].sort().join(",") !== oldSorted) paths = new Map();
+          }
         } else if (what === "version") {
           const v = await io.askText("새 버전 (예: 1.0.0)", version);
-          if (v !== CANCEL) version = v;
+          if (!isCancel(v) && v !== version) {
+            // semver 형식 검증 (.sh L2010~2015)
+            if (/^\d+\.\d+\.\d+$/.test(v)) version = v;
+            else io.note?.("버전 형식이 올바르지 않습니다 (x.y.z 형태) — 기존 값을 유지합니다.", "⚠ 버전");
+          }
         } else if (what === "branch") {
           const b = await io.askText("기본 브랜치", branch);
-          if (b !== CANCEL) branch = b;
+          if (!isCancel(b) && b) branch = b;
         } else if (what === "nexus") {
           const y = await io.askYesNo("Nexus publish 워크플로우를 포함할까요?", includeNexus);
-          if (y !== CANCEL) includeNexus = y;
+          if (!isCancel(y)) includeNexus = y === true;
         } else if (what === "secret") {
           const y = await io.askYesNo("Secret 백업 워크플로우를 포함할까요?", includeSecretBackup);
-          if (y !== CANCEL) includeSecretBackup = y;
+          if (!isCancel(y)) includeSecretBackup = y === true;
         }
       }
     }
 
-    // 경로: 미지정 타입은 루트(basic 제외)
-    const paths = new Map();
-    for (const t of types) if (t !== "basic") paths.set(t, ".");
+    // 경로 확정 (.sh resolve_project_paths L1362~1589 — full/version만. 저장값·후보 스캔·질문)
+    if (mode === "full" || mode === "version") {
+      paths = await resolveProjectPaths({
+        root: cwd, types, paths, existingPaths: existing?.paths ?? new Map(),
+        force: false, tty: realTty, io: io.engineIo ?? {},
+      });
+    } else {
+      for (const t of types) if (t !== "basic" && !paths.has(t)) paths.set(t, existing?.paths.get(t) || ".");
+    }
+
+    // @wizard env 계획 질문 (.sh wf_prompt_env_plan L3220 — full/workflows만)
+    const resolvers = makeResolvers(cwd, repoName, paths);
+    let envValues = new Map(), envUseDefaults = true;
+    if (showOptional) {
+      const plan = await promptEnvPlan({
+        tempDir, types, io: io.engineIo ?? null, force: false,
+        resolvers, includeNexus, targetRoot: cwd, repoName,
+      });
+      envValues = plan.values;
+      envUseDefaults = plan.useDefaults;
+    }
 
     const { now, today } = clock || utcNow();
     const ctx = createContext({
-      mode, force: true, types, version, branch, paths, includeNexus, includeSecretBackup, repoName, templateVersion,
-      resolvers: {
-        repo: () => repoName, "spring-app-yml-dir": () => "", "spring-app-yml-path": () => "",
-        "flutter-root": () => paths.get("flutter") || ".",
-      },
-      now, today,
+      mode, force: true, types, version, versionCode, branch, paths, includeNexus, includeSecretBackup,
+      repoName, templateVersion, resolvers, envValues, envUseDefaults, now, today,
     });
     ctx.templateVersion = templateVersion;
 
-    if (mode === "full") runFull(ctx, tempDir, cwd);
-    else if (mode === "version") runVersion(ctx, tempDir, cwd);
-    else if (mode === "workflows") runWorkflows(ctx, tempDir, cwd);
+    // 기존 워크플로우 충돌 3지선 — 타입당 1회 결정을 파일에 캐시 적용 (.sh L3440~3508 UX 등가)
+    let hooks = {};
+    if (showOptional && io.engineIo?.select) {
+      const conflicts = listWorkflowConflicts(ctx, tempDir, cwd);
+      if (conflicts.length) {
+        const perType = new Map();
+        const decisions = new Map();
+        for (const { filename, type } of conflicts) {
+          if (!perType.has(type)) {
+            const sel = await io.engineIo.select({
+              message: `기존 워크플로우와 내용이 다른 파일이 있습니다 (${type}) — 어떻게 할까요?`,
+              options: [
+                { value: "skip", label: "건너뛰기 — 기존 파일 유지 (기본)" },
+                { value: "backup", label: ".bak 백업 후 새 버전으로 교체" },
+                { value: "template", label: "기존 유지 + 새 버전을 .template.yaml로 참고 추가" },
+              ],
+            });
+            perType.set(type, isCancel(sel) || sel == null ? "skip" : sel); // ESC = 건너뛰기 (.sh L3463)
+          }
+          decisions.set(filename, perType.get(type));
+        }
+        hooks = { decisions };
+      }
+    }
+
+    let result = null;
+    if (mode === "full") result = runFull(ctx, tempDir, cwd, hooks);
+    else if (mode === "version") result = runVersion(ctx, tempDir, cwd);
+    else if (mode === "workflows") result = runWorkflows(ctx, tempDir, cwd, hooks);
+
+    // 통합 후 IDE 스킬 제안 (.sh L4557 offer_ide_tools_install — 사전 질문 게이트, 기본 N)
+    const wantSkills = await io.askYesNo("AI 에이전트 스킬(Claude·Cursor·Gemini·Codex·PI)도 설치/업데이트할까요?", false);
+    if (wantSkills === true) await skills({ templateVersion, tempDir, interactive: true });
 
+    // 완료 요약 (.sh print_summary L5438)
+    io.summary?.({
+      mode, types, version,
+      counters: { workflows: result?.workflows?.copied ?? 0, utilModules: 0 },
+    }, cwd);
     io.outro?.(`통합 완료 — ${mode} 모드로 설치했습니다.`);
     return 0;
   } finally {

package/src/commands/workflows.js

@@ -8,9 +8,9 @@ import { copyWorkflows } from "../core/copy/workflows.js";
 import { copyScripts, copyConfigFolder, copySetupGuide } from "../core/copy/simple.js";
 import { copyUtilModules } from "../core/copy/util.js";
 
-export function runWorkflows(context, tempDir, targetRoot = ".") {
+export function runWorkflows(context, tempDir, targetRoot = ".", hooks = {}) {
   const { types = [], force = true } = context;
-  const wf = copyWorkflows(context, tempDir, targetRoot);
+  const wf = copyWorkflows(context, tempDir, targetRoot, hooks);
 
   // update_version_yml_deploy: 기존 version.yml이 있고 ask 값이 있을 때만 deploy 블록 갱신
   const vy = join(targetRoot, PATHS.versionFile);

package/src/context.js

@@ -1,6 +1,7 @@
 // 마법사 전역 상태를 하나의 객체로 명시화 (bash 전역 변수군 대체)
+// next 타입은 v4.1.0에서 react로 흡수됨 (breaking)
 export const VALID_TYPES = [
-  "spring", "flutter", "next", "react",
+  "spring", "flutter", "react",
   "react-native", "react-native-expo", "node", "python", "basic",
 ];
 

package/src/core/breaking-check.js

@@ -0,0 +1,65 @@
+// breaking-changes 확인 흐름 배선 (.sh check_breaking_changes L2506~2616 등가).
+// collectBreaking(순수 비교)은 breaking.js — 이 모듈은 로드(원격→clone본 폴백)·표시·확인 게이트.
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { collectBreaking } from "./breaking.js";
+import { parseExisting } from "./version-yml.js";
+
+const BC_URL = "https://raw.githubusercontent.com/Cassiiopeia/projectops/main/.github/config/breaking-changes.json";
+
+// 원격 우선(3초 타임아웃) → clone된 템플릿의 번들본 폴백 → 둘 다 실패 시 null(조용히 스킵 — .sh 등가)
+export async function loadBreakingJson(tempDir) {
+  try {
+    const res = await fetch(BC_URL, { signal: AbortSignal.timeout(3000) });
+    if (res.ok) return await res.json();
+  } catch { /* 원격 실패 — 폴백 */ }
+  try {
+    const p = join(tempDir, ".github", "config", "breaking-changes.json");
+    if (existsSync(p)) return JSON.parse(readFileSync(p, "utf8"));
+  } catch { /* 폴백 실패 — 스킵 */ }
+  return null;
+}
+
+// 반환: true=진행, false=사용자 취소.
+// opts:
+//   cwd             - 통합 대상 루트 (기존 version.yml에서 현재 템플릿 버전 읽음)
+//   tempDir         - clone된 템플릿 (번들 폴백용)
+//   templateVersion - 설치하려는 템플릿 버전 (.sh의 DEFAULT_VERSION 고정 버그를 실버전으로 교정 — 설계 D2)
+//   askYesNo        - async(message, defaultYes)→bool. null이면 비대화형: 경고만 출력 후 진행
+//   loader          - 테스트 주입용 (기본 loadBreakingJson)
+export async function runBreakingCheck({ cwd, tempDir, templateVersion, askYesNo = null, loader = loadBreakingJson }) {
+  const vy = join(cwd, "version.yml");
+  if (!existsSync(vy)) return true; // 신규 통합 — 비교 기준 없음
+  const { templateVersion: current } = parseExisting(readFileSync(vy, "utf8"));
+  if (!current) return true; // 템플릿 메타 없음(unknown) — .sh 동일하게 스킵
+
+  const json = await loader(tempDir);
+  if (!json) return true;
+
+  const { critical, warnings } = collectBreaking(json, current, templateVersion);
+  if (critical.length === 0 && warnings.length === 0) return true;
+
+  // 박스 표시 (.sh L2580~2603)
+  const e = (s = "") => process.stderr.write(s + "\n");
+  e("");
+  e("╔══════════════════════════════════════════════════════════════════╗");
+  e(`║  ⚠️  BREAKING CHANGES (v${current} → v${templateVersion})`);
+  e("╠══════════════════════════════════════════════════════════════════╣");
+  for (const c of critical) { e("║"); e(`║  [CRITICAL] ${c.version} - ${c.title || ""}`); e(`║  → ${c.message || ""}`); }
+  for (const w of warnings) { e("║"); e(`║  [WARNING] ${w.version} - ${w.title || ""}`); e(`║  → ${w.message || ""}`); }
+  e("║");
+  e("╚══════════════════════════════════════════════════════════════════╝");
+  e("");
+
+  if (critical.length > 0) {
+    if (askYesNo) {
+      // 대화형: 명시 확인 없으면 중단 (기본 N — .sh 등가)
+      const ok = await askYesNo("위 호환성 변경을 확인했고 계속 진행할까요?", false);
+      if (ok !== true) return false;
+    } else {
+      // 비대화형(--force): 게이트로 CI를 죽이지 않고 경고 후 진행 (.sh와 의도적 차이 — CI 친화)
+      e("⚠️  CRITICAL 호환성 변경이 있습니다 — 비대화형 실행이라 계속 진행합니다. 위 내용을 꼭 확인하세요.");
+    }
+  }
+  return true;
+}

package/src/core/copy/workflows.js

@@ -1,17 +1,19 @@
 // 워크플로우 복사 엔진 (.sh copy_workflows + _copy_workflows_for_type 등가).
-// 실측: template_integrator.sh 3398~3815. SP2-B는 --force 경로만 구현.
-// (대화형 3지선 메뉴·env 계획 질문은 SP2-C. force/비TTY의 기본 선택은 "건너뛰기"이므로 등가.)
+// 실측: 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 } from "../paths.js";
 import { exists, copyFileSync, listYamlFiles } from "../fsutil.js";
 import { isUnchanged, substituteEnv } from "../wizard-env.js";
 
-// 한 파일에 env 치환(기본값)을 적용해 대상 파일을 갱신 (.sh configure_workflow_env 등가).
-function configureEnv(targetPath, { type, projectPath = ".", repoName = "", resolvers = {}, collectAsks = null }) {
+// 한 파일에 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: true, projectPath, repoName, resolvers, collectAsks });
+  const out = substituteEnv(content, { type, useDefaults, values, projectPath, repoName, resolvers, collectAsks });
   writeFileSync(targetPath, out);
 }
 
@@ -33,12 +35,15 @@ function classify(srcDir, workflowsDir, envOpts) {
   return result;
 }
 
-// copy_workflows 본체.
-// context: { types:[], paths:Map, includeNexus, includeSecretBackup, force, repoName, resolvers }
-// tempDir: 다운로드 원본. targetRoot: 통합 대상 루트.
+// 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, tempDir, targetRoot = ".") {
-  const { types = [], paths = new Map(), includeNexus = false, includeSecretBackup = false, repoName = "", resolvers = {} } = context;
+export function copyWorkflows(context, tempDir, 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(tempDir, PATHS.workflowsDir, PATHS.projectTypesDir);
   if (!exists(projectTypesDir)) throw new Error("템플릿 저장소 구조 오류 — project-types 폴더를 찾지 못했습니다.");
@@ -46,7 +51,8 @@ export function copyWorkflows(context, tempDir, targetRoot = ".") {
   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 envOptsFor = (type) => ({ type, projectPath: paths.get(type) || ".", repoName, resolvers });
+  // values/useDefaults는 치환 경로에서만 의미 (isUnchanged는 내부에서 useDefaults:true 강제 — 가상 비교 무손상)
+  const envOptsFor = (type) => ({ type, projectPath: paths.get(type) || ".", repoName, resolvers, values: envValues, useDefaults: envUseDefaults });
 
   // (1) common — unchanged면 스킵, 아니면 무조건 덮어쓰기
   const commonDir = join(projectTypesDir, "common");
@@ -66,7 +72,7 @@ export function copyWorkflows(context, tempDir, targetRoot = ".") {
   // (2~4) 타입별
   for (const type of types) {
     const asks = new Map();
-    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { includeNexus, ...context, envOptsFor, collectAsks: asks }, counters);
+    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { includeNexus, ...context, envOptsFor, collectAsks: asks, decisions }, counters);
     if (asks.size) deployValues.set(type, asks);
   }
 
@@ -85,8 +91,66 @@ export function copyWorkflows(context, tempDir, targetRoot = ".") {
   return counters;
 }
 
+// changed(기존에 있고 내용이 바뀐) 파일 1개를 결정에 따라 처리 (.sh 3440~3508 3지선 case 등가).
+// 'skip'(기본): 기존 유지. 'backup': 기존→.bak 후 교체. 'template': 기존 유지 + 새 버전을 .template.yaml로.
+function applyDecision(decision, srcDir, workflowsDir, filename, counters) {
+  const src = join(srcDir, filename);
+  const dst = join(workflowsDir, filename);
+  if (decision === "backup") {
+    // .sh O) mv → cp: 기존을 .bak으로 백업 후 새 버전으로 교체
+    renameSync(dst, dst + ".bak");
+    copyFileSync(src, dst);
+    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";
+    copyFileSync(src, join(workflowsDir, templateName)); // cp가 기존 .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, tempDir, targetRoot = ".") {
+  const { types = [], paths = new Map(), includeNexus = false, repoName = "", resolvers = {} } = context;
+  const workflowsDir = join(targetRoot, PATHS.workflowsDir);
+  const projectTypesDir = join(tempDir, PATHS.workflowsDir, PATHS.projectTypesDir);
+  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).changed) conflicts.push({ filename: f, type });
+    }
+    const serverDeployDir = join(typeDir, "server-deploy");
+    if (exists(serverDeployDir) && !includeNexus) {
+      for (const f of classify(serverDeployDir, workflowsDir, envOpts).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, tempDir, targetRoot = ".", { onConflict } = {}) {
+  const decisions = new Map();
+  if (typeof onConflict === "function") {
+    for (const { filename, type } of listWorkflowConflicts(context, tempDir, targetRoot)) {
+      if (decisions.has(filename)) continue; // 파일명은 PROJECT-{TYPE}- prefix로 타입 간 유일
+      decisions.set(filename, await onConflict(filename, type));
+    }
+  }
+  return copyWorkflows(context, tempDir, targetRoot, { decisions });
+}
+
 function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters) {
-  const { includeNexus, force = false, paths = new Map(), repoName = "", resolvers = {}, envOptsFor, collectAsks = null } = ctx;
+  const { includeNexus, force = false, paths = new Map(), repoName = "", resolvers = {}, envOptsFor, collectAsks = null, decisions = new Map() } = ctx;
   const typeDir = join(projectTypesDir, type);
   const envOpts = envOptsFor(type);
   let unchangedNames = [];
@@ -97,9 +161,8 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
     unchangedNames = unchanged.slice();
     for (const f of unchanged) counters.skipped++;
     for (const f of newFiles) { copyFileSync(join(typeDir, f), join(workflowsDir, f)); counters.copied++; }
-    // changed: force/비TTY 기본은 "건너뛰기"(기존 유지)
-    if (!force) { /* 대화형 메뉴는 SP2-C */ }
-    for (const f of changed) counters.skipped++; // force 경로 = skip
+    // changed: 결정 Map에 따라 처리 (미지정=skip → 현행 force 동작과 동일)
+    for (const f of changed) applyDecision(decisions.get(f), typeDir, workflowsDir, f, counters);
   }
 
   // server-deploy
@@ -111,7 +174,7 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
       const { newFiles, unchanged, changed } = classify(serverDeployDir, workflowsDir, envOpts);
       for (const f of unchanged) counters.skipped++;
       for (const f of newFiles) { copyFileSync(join(serverDeployDir, f), join(workflowsDir, f)); counters.copied++; }
-      for (const f of changed) counters.skipped++; // force = skip
+      for (const f of changed) applyDecision(decisions.get(f), serverDeployDir, workflowsDir, f, counters);
     }
   }
 
@@ -139,7 +202,7 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
       const target = join(workflowsDir, filename);
       if (!existsSync(target)) continue;            // 건너뛴 파일 제외
       if (unchangedNames.includes(filename)) continue; // unchanged 제외
-      configureEnv(target, { type, projectPath: paths.get(type) || ".", repoName, resolvers, collectAsks });
+      configureEnv(target, { ...envOpts, collectAsks }); // env 계획 values/useDefaults 포함
     }
   }
 }

package/src/core/detect-fs.js

@@ -1,6 +1,6 @@
 // 실 파일시스템 프로젝트 감지 (.sh detect_* 실행부 등가).
 // SP2-A detect.js 순수 함수를 fs/git으로 구동한다.
-import { existsSync, readFileSync } from "node:fs";
+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";
@@ -62,3 +62,45 @@ function hasCommand(cmd) {
     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

@@ -6,8 +6,8 @@ export function classifyPackageText(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";
+  // next 타입은 v4.1.0에서 react로 흡수 — "next" 의존성이 있어도 react로 판정
+  if (s.includes('"react"') || s.includes('"next"')) return "react";
   return "node";
 }