project-auto-wizard 0.12.2 → 0.13.0

package/src/core/logger.js

@@ -6,7 +6,7 @@
 // 왜 로컬 전용인가: 상세도를 제약하지 않기 위해서다. 로그 디렉토리에 .gitignore를 직접
 // 두어 그 폴더만 추적에서 뺀다 — 루트 .gitignore는 건드리지 않는다.
 import { appendFileSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 export const LOG_DIR = ".github/.wizard/logs";
 const KEEP = 20;              // 유지할 로그 파일 수
@@ -17,7 +17,7 @@ const GITIGNORE_BODY = "*\n!.gitignore\n";
 const SECRET_KEY_RE = /(PASSWORD|SECRET|TOKEN|KEY|CREDENTIAL)/i;
 const MASK = "***";
 
-let state = null; // { file, clock, startedAt, disabled }
+let state = null; // { targetRoot, name, header, file, rel, clock, startedAt, disabled }
 
 export function maskValue(key, value) {
   // SSH_AUTH_METHOD처럼 "방식"만 담는 키는 비밀이 아니다 — 이름에 KEY가 들어가도 마스킹하지 않는다.
@@ -32,8 +32,26 @@ export function stampFrom(now = "") {
   return `${m[1]}${m[2]}${m[3]}-${m[4]}${m[5]}${m[6]}`;
 }
 
-export function logFilename(now, action = "install") {
-  return `${stampFrom(now)}-${action}.log`;
+// 초 단위 이름만 쓰면 같은 초에 연달아 실행할 때 앞 실행의 로그를 덮어쓴다 — 밀리초를 붙인다.
+// 밀리초도 시각 순서라 이름 정렬이 곧 실행 순서라는 전제(rotate)는 그대로 유지된다.
+export function logFilename(now, action = "install", ms = 0) {
+  return `${stampFrom(now)}-${String(ms).padStart(3, "0")}-${action}.log`;
+}
+
+// 같은 이름이 이미 있으면(다른 프로세스가 같은 밀리초에 연 경우) -2, -3을 붙여 새로 만든다.
+// wx 플래그로 "없을 때만 생성"을 원자적으로 판정해 동시 실행끼리도 서로 덮어쓰지 않는다.
+function createUnique(dir, base, header) {
+  const stem = base.replace(/\.log$/, "");
+  for (let n = 1; n < 100; n++) {
+    const name = n === 1 ? base : `${stem}-${n}.log`;
+    try {
+      writeFileSync(join(dir, name), header, { flag: "wx" });
+      return name;
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+    }
+  }
+  throw new Error(`로그 파일 이름이 모두 사용 중입니다: ${base}`);
 }
 
 // 최근 KEEP개만 남기고 오래된 것부터 지운다. 파일명이 시각 오름차순이라 이름 정렬로 충분하다.
@@ -45,31 +63,39 @@ function rotate(dir) {
   }
 }
 
+// 파일은 첫 기록 때 만든다 — 읽기 전용 모드(status/doctor)나 인자 검증에서 거부된 실행처럼
+// 아무것도 바꾸지 않은 실행이 대상 레포에 로그 폴더와 헤더만 있는 파일을 남기지 않도록.
 export function initLogger(targetRoot, opts = {}) {
-  const { action = "install", now = "", argv = [], templateVersion = "unknown", clock = () => new Date() } = opts;
+  const { action = "install", now = "", argv = [], templateVersion = "unknown", clock = () => new Date(),
+    ms = new Date().getUTCMilliseconds() } = opts;
+  // 시각은 UTC다 — 로컬 시간대로 읽으면 몇 시간 어긋나 보이므로 헤더에 밝혀 둔다.
+  const header =
+    `=== project-auto-wizard v${templateVersion} | ${action} | ${now} UTC ===\n` +
+    `argv    : ${["project-auto-wizard", ...argv].join(" ")}\n` +
+    `node    : ${process.version} | ${process.platform} ${process.arch}\n` +
+    `target  : ${targetRoot}\n\n`;
+  const st = { targetRoot, name: logFilename(now, action, ms), header, file: "", rel: "", clock, startedAt: Date.now(), disabled: false };
+  state = st;
+  return { get path() { return st.rel; } };
+}
+
+// 첫 기록 직전에 로그 파일을 연다. 실패하면 이후 기록을 끈다.
+function open(st) {
   try {
-    const dir = join(targetRoot, LOG_DIR);
+    const dir = join(st.targetRoot, LOG_DIR);
     mkdirSync(dir, { recursive: true });
     // 사용자가 직접 둔 .gitignore가 있으면 존중한다.
     const gi = join(dir, ".gitignore");
     if (!existsSync(gi)) writeFileSync(gi, GITIGNORE_BODY);
     rotate(dir);
-
-    const rel = `${LOG_DIR}/${logFilename(now, action)}`;
-    const file = join(targetRoot, rel);
-    const header =
-      `=== project-auto-wizard v${templateVersion} | ${action} | ${now} ===\n` +
-      `argv    : ${["project-auto-wizard", ...argv].join(" ")}\n` +
-      `node    : ${process.version} | ${process.platform} ${process.arch}\n` +
-      `target  : ${targetRoot}\n\n`;
-    writeFileSync(file, header);
-    state = { file, rel, clock, startedAt: Date.now(), disabled: false };
-    return { path: rel };
+    st.rel = `${LOG_DIR}/${createUnique(dir, st.name, st.header)}`;
+    st.file = join(st.targetRoot, st.rel);
+    return true;
   } catch (e) {
     // 로그를 못 남긴 것이 설치를 되돌릴 이유는 아니다 — 다만 조용히 삼키지는 않는다.
+    st.disabled = true;
     process.stderr.write(`[warn] 실행 로그를 시작하지 못했습니다: ${e.message}\n`);
-    state = null;
-    return null;
+    return false;
   }
 }
 
@@ -108,6 +134,7 @@ function hhmmss(date) {
 
 function write(level, scope, action, detail = "") {
   if (!state || state.disabled) return;
+  if (!state.file && !open(state)) return;
   try {
     const line = `${hhmmss(state.clock())} ${level}  ${String(scope).padEnd(SCOPE_W)}  ${String(action).padEnd(ACTION_W)}  ${detail}`.trimEnd();
     appendFileSync(state.file, line + "\n");
@@ -125,6 +152,7 @@ export const log = {
   // rows: Array<[label, value]> — 라벨 폭을 맞춰 정렬한다.
   summary(rows = []) {
     if (!state || state.disabled || !rows.length) return;
+    if (!state.file && !open(state)) return;
     // 한글은 터미널에서 2칸을 차지한다 — 문자 수로 맞추면 눈으로 볼 때 어긋난다.
     const w = Math.max(...rows.map(([k]) => dispWidth(k)));
     const body = rows.map(([k, v]) => `${k}${" ".repeat(w - dispWidth(k))} : ${v}`).join("\n");
@@ -136,6 +164,14 @@ export const log = {
   },
 };
 
+// 로그 폴더(.github/.wizard)째 지울 수 있는 삭제 실행용. 지우기 전에 쓰면 기록이 함께 사라지며
+// ENOENT 경고가 나고, 지운 뒤에 쓰면 폴더를 되살려 완전 삭제 뒤에도 흔적이 남는다.
+// 그래서 기록을 모았다가 폴더가 남아 있을 때만 쓴다(지워졌다면 결과는 화면 출력으로 대신한다).
+export function logRemovals(targetRoot, entries = []) {
+  if (!existsSync(dirname(join(targetRoot, LOG_DIR)))) return;
+  for (const [scope, action, detail] of entries) write("INFO", scope, action, detail);
+}
+
 export function closeLogger() {
   state = null;
 }

package/src/core/paths-resolve.js

@@ -1,5 +1,4 @@
-// 타입별 프로젝트 경로 감지·확정 (.sh find_type_path_candidates L1249~1311 /
-// resolve_project_paths L1362~1589 등가). 모노레포에서 각 타입의 버전 파일이
+// 타입별 프로젝트 경로 감지·확정. 모노레포에서 각 타입의 버전 파일이
 // 어느 폴더에 있는지 5단계 우선순위로 확정한다.
 //
 // io 주입 계약(readline-engine 시그니처 그대로):
@@ -10,24 +9,24 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { markerForType as baseMarkerForType, resolveMarker } from "./detect.js";
-import { normalizePath, CliError } from "../cli/args.js";
+import { TYPES, typeInfo } from "./types.js";
+import { normalizePath, isRepoRelativePath } from "./paths.js";
+import { CliError } from "./errors.js";
 
-// 취소(ESC/Ctrl+C)는 CANCEL 심볼 — ui를 import하지 않고 심볼 여부로만 판정 (core→ui 역참조 방지)
+// 취소(ESC)는 CANCEL 심볼(Ctrl+C는 엔진이 예외로 중단시킨다) — ui를 import하지 않고 심볼 여부로만 판정 (core→ui 역참조 방지)
 const isCancel = (v) => typeof v === "symbol";
 
-// 타입의 대표 마커 파일명 (.sh marker_for_type L1220~1229 등가).
-// detect.js는 미지 타입에 package.json을 기본 반환하지만 .sh는 빈 문자열 — 등가를 위해 래핑.
-const KNOWN_MARKER_TYPES = new Set([
-  "flutter", "react", "next", "node", "react-native", "react-native-expo", "python", "spring", "go",
-]);
+// 타입의 대표 마커 파일명.
+// detect.js는 미지 타입에 package.json을 기본 반환하지만, 경로 탐색에서는 마커가 없는 타입(basic 등)을 빈 문자열로 구분해야 해서 래핑한다.
+const KNOWN_MARKER_TYPES = new Set(TYPES.filter((t) => t.markers.length).map((t) => t.id));
 export function markerForType(type) {
   return KNOWN_MARKER_TYPES.has(type) ? baseMarkerForType(type) : "";
 }
 
 // 디렉토리에 실재하는 마커 파일명 반환 — resolveMarker의 fs 구동판.
-// (.sh existing_marker_in_dir L1232~1245: spring build.gradle/.kts/pom.xml, python pyproject/setup.py/requirements.txt)
+// (보조 마커 포함: spring build.gradle/.kts/pom.xml, python pyproject/setup.py/requirements.txt)
 export function existingMarkerInDir(type, dir) {
-  if (!markerForType(type)) return ""; // .sh 등가: 미지 타입은 빈 문자열
+  if (!markerForType(type)) return ""; // 미지 타입은 빈 문자열
   return resolveMarker(type, (n) => existsSync(join(dir, n)));
 }
 
@@ -42,7 +41,7 @@ function walkFindDirs(root, { prune, match, maxDepth = 3 }) {
       const childDepth = depth + 1;
       const childRel = rel ? `${rel}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        // prune 폴더는 하위 전체 제외 (.sh find -prune 등가)
+        // prune 폴더는 하위 전체 제외
         if (prune.has(e.name)) continue;
         // 자식 파일이 depth ≤ maxDepth 안에 들어올 때만 하강
         if (childDepth < maxDepth) walk(childRel, childDepth);
@@ -54,13 +53,13 @@ function walkFindDirs(root, { prune, match, maxDepth = 3 }) {
     }
   };
   walk("", 0);
-  return [...new Set(hits)].sort(); // sort -u 등가
+  return [...new Set(hits)].sort(); // 중복 제거 + 정렬
 }
 
-// 타입별 마커 파일 후보 검색 (.sh find_type_path_candidates L1249~1311 등가).
+// 타입별 마커 파일 후보 검색.
 // 반환: 후보 디렉토리 상대경로 배열 (루트는 ".").
 export function findTypePathCandidates(root, type) {
-  // ── Spring 멀티모듈: settings.gradle(.kts) 폴더 = 모듈 루트로 축약 (.sh L1255~1268) ──
+  // ── Spring 멀티모듈: settings.gradle(.kts) 폴더 = 모듈 루트로 축약 ──
   // version_manager가 그 폴더 아래 build.gradle 전부를 갱신하므로 하위 모듈을 펼치지 않는다.
   // android/ 의 settings.gradle(Flutter/RN)은 spring이 아니므로 prune.
   if (type === "spring") {
@@ -72,23 +71,15 @@ export function findTypePathCandidates(root, type) {
     // settings.gradle 없음 → 단일 모듈, 아래 build.gradle 폴백
   }
 
-  const namesByType = {
-    flutter: ["pubspec.yaml"],
-    react: ["package.json"], next: ["package.json"], node: ["package.json"],
-    "react-native": ["package.json"],
-    "react-native-expo": ["app.json"],
-    python: ["pyproject.toml", "setup.py", "requirements.txt"],
-    spring: ["build.gradle", "build.gradle.kts", "pom.xml"],
-    go: ["go.mod"],
-  };
-  const names = namesByType[type];
-  if (!names) return [];
+  // 레지스트리의 마커 순서가 곧 우선순위다 (대표 파일 먼저).
+  const names = typeInfo(type)?.markers;
+  if (!names?.length) return [];
 
   const prune = new Set([
     "node_modules", ".git", "build", "dist", ".dart_tool", "android", "ios",
     ".gradle", "venv", ".venv", "__pycache__",
   ]);
-  // 우선순위 높은 마커에서 발견되면 그것만 사용 (.sh L1281~1288)
+  // 우선순위 높은 마커에서 발견되면 그것만 사용
   let found = [];
   for (const n of names) {
     found = walkFindDirs(root, { prune, match: (name) => name === n });
@@ -97,13 +88,13 @@ export function findTypePathCandidates(root, type) {
 
   return found.filter((d) => {
     if (type === "flutter") {
-      // example/ 제외 + lib/ 동반 확인 — 오탐 방지 (.sh L1298~1303)
+      // example/ 제외 + lib/ 동반 확인 — 오탐 방지
       if (d.includes("example")) return false;
       const libDir = d === "." ? join(root, "lib") : join(root, d, "lib");
       if (!existsSync(libDir)) return false;
     }
     if (type === "spring") {
-      // Flutter/RN의 android/build.gradle 오탐 제외 (.sh L1304~1307)
+      // Flutter/RN의 android/build.gradle 오탐 제외
       if (d.includes("android")) return false;
     }
     return true;
@@ -111,7 +102,7 @@ export function findTypePathCandidates(root, type) {
 }
 
 // 선택된 모든 타입의 경로를 감지·확인하여 Map<type,path> 확정
-// (.sh resolve_project_paths L1362~1589 등가 — 5단계 우선순위).
+// (5단계 우선순위).
 //   ① paths에 이미 있음(--paths) → 유지
 //   ② 루트에 마커 존재 → "." 자동
 //   ③ existingPaths(version.yml 저장값)
@@ -123,11 +114,11 @@ export async function resolveProjectPaths({
 }) {
   const say = io.log || ((m) => process.stderr.write(`${m}\n`));
   const result = new Map(paths); // --paths 사전값 유지 (호출부 Map은 불변)
-  const targets = types.filter((t) => t !== "basic"); // basic은 경로 불필요 (.sh L1400)
+  const targets = types.filter((t) => t !== "basic"); // basic은 경로 불필요
   if (targets.length === 0) return result;
 
   const total = targets.length;
-  // ── 도입부 안내 (.sh L1407~1434 — 감지 결과 + 무엇을 할지 설명) ──
+  // ── 도입부 안내 (감지 결과 + 무엇을 할지 설명) ──
   say("");
   if (total > 1) say(`🔍 멀티타입 프로젝트가 감지되었습니다 — 총 ${total}개 타입`);
   else say(`🔍 ${targets[0]} 프로젝트가 감지되었습니다 — 총 1개 타입`);
@@ -141,17 +132,22 @@ export async function resolveProjectPaths({
     idx += 1;
     const prog = `[${idx}/${total}]`;
 
-    // ① --paths 등으로 이미 지정됨 → 최우선 (.sh L1441~1446)
+    // ① --paths 등으로 이미 지정됨 → 최우선
     if (result.get(t)) {
       const p = result.get(t);
       if (!existsSync(join(root, p))) {
         throw new CliError(`--paths로 지정한 경로가 존재하지 않습니다: '${t}=${p}'`);
       }
       say(`  ${t} → ${p} (--paths 지정)`);
+      // 막지는 않는다(마커 없이 쓰는 구성도 있다) — 오타로 엉뚱한 폴더를 준 경우를 알린다.
+      const pm = existingMarkerInDir(t, join(root, p));
+      if (pm && !existsSync(join(root, p, pm))) {
+        say(`  ⚠️ ${p}에 ${t} 프로젝트 파일(${pm})이 없습니다 — 경로가 맞는지 확인하세요.`);
+      }
       continue;
     }
 
-    // ② 루트에 마커 존재 → "." 자동 확정 (.sh L1449~1455, 보조 마커 포함)
+    // ② 루트에 마커 존재 → "." 자동 확정 (보조 마커 포함)
     const rootMarker = existingMarkerInDir(t, root);
     if (rootMarker && existsSync(join(root, rootMarker))) {
       result.set(t, ".");
@@ -159,14 +155,14 @@ export async function resolveProjectPaths({
       continue;
     }
 
-    // ③ 기존 version.yml 저장값 → 기본 제안값 (.sh L1458~1466)
+    // ③ 기존 version.yml 저장값 → 기본 제안값
     const existing = existingPaths.get(t) || "";
 
-    // ④ 후보 검색 (.sh L1469~1471)
+    // ④ 후보 검색
     const candidates = findTypePathCandidates(root, t);
     let chosen = "";
 
-    // ── ⑤-a 비대화형 (--force 또는 TTY 없음, .sh L1476~1489 — root 폴백 의도적 불포함) ──
+    // ── ⑤-a 비대화형 (--force 또는 TTY 없음 — root 폴백 의도적 불포함) ──
     if (force || !tty) {
       if (existing) {
         chosen = existing;
@@ -183,7 +179,7 @@ export async function resolveProjectPaths({
       continue;
     }
 
-    // ── ⑤-b 대화형: 후보 개수별 분기 (.sh L1492~1525) ──
+    // ── ⑤-b 대화형: 후보 개수별 분기 ──
     if (candidates.length === 1) {
       const cand = candidates[0];
       const candMarker = existingMarkerInDir(t, cand === "." ? root : join(root, cand));
@@ -200,21 +196,21 @@ export async function resolveProjectPaths({
     } else if (candidates.length > 1) {
       say("");
       say(`  ${prog} 🔍 ${t}: 경로 후보 ${candidates.length}개 발견`);
-      // 후보들 + '직접 입력' 메뉴 — value 자체를 한국어로 (센티넬 노출 방지, .sh L1508~1521)
+      // 후보들 + '직접 입력' 메뉴 — value 자체를 한국어로 (센티넬 노출 방지)
       const options = candidates.map((c) => ({
         value: c,
         label: `${c} (${existingMarkerInDir(t, c === "." ? root : join(root, c))})`,
       }));
       options.push({ value: "직접 입력", label: "직접 입력" });
       const sel = await io.select({ message: `  ${t} 프로젝트 루트를 선택하세요`, options });
-      // ESC(취소)도 직접 입력으로 폴백 (.sh `|| _sel="직접 입력"`)
+      // ESC(취소)도 직접 입력으로 폴백
       if (!isCancel(sel) && sel != null && sel !== "직접 입력") chosen = sel;
     } else {
       say("");
       say(`  ⚠️ ${prog} ${t}: 프로젝트를 찾지 못했습니다 (maxdepth 3).`);
     }
 
-    // ── 직접 입력 루프 (위에서 미확정 시, .sh L1528~1553) ──
+    // ── 직접 입력 루프 (위에서 미확정 시) ──
     while (!chosen) {
       const hintMarker = existingMarkerInDir(t, root);
       let prompt = `  ${t} 프로젝트 루트 경로 입력 (${hintMarker} 이 있는 폴더, 예: server, app — 루트면 그냥 Enter`;
@@ -223,16 +219,23 @@ export async function resolveProjectPaths({
       let input = await io.text({ message: prompt, defaultValue: "" });
       if (isCancel(input) || input == null) input = ""; // ESC → 빈값 (아래 폴백)
       input = String(input).trim();
-      // 빈값 → 기존값 또는 루트 (.sh L1541~1543) — normalizePath 전에 판정
+      // 빈값 → 기존값 또는 루트 — normalizePath 전에 판정
       input = input === "" ? (existing || ".") : normalizePath(input);
-      // 검증: 입력 경로에 마커 존재 확인 (보조 마커 포함, .sh L1544~1552)
+      if (!isRepoRelativePath(input)) {
+        say(`  ⚠️ '${input}'은(는) 레포 밖 경로입니다 — 레포 루트 기준 상대경로로 입력하세요.`);
+        continue;
+      }
+      // 검증: 입력 경로에 마커 존재 확인 (보조 마커 포함)
       const m = existingMarkerInDir(t, input === "." ? root : join(root, input));
       if (m && existsSync(join(root, input === "." ? "" : input, m))) {
         chosen = input;
       } else {
         say(`  ⚠️ ${input}/${m} 파일이 없습니다.`);
-        const forceOk = await io.confirm({ message: "  그래도 이 경로를 사용할까요?", initialValue: false });
-        if (forceOk === true) chosen = input;
+        // 기본(Enter)·ESC는 이 경로를 그대로 쓴다 — 기본을 '아니오'로 두면 마커가 아직 없는 타입
+        // (프로젝트 생성 전에 미리 추가한 타입 등)은 Enter만으로는 빠져나갈 수 없었다.
+        // 다시 입력하려면 '아니오'를 명시적으로 고른다. 경로는 version.yml project_paths에서 나중에 고칠 수 있다.
+        const forceOk = await io.confirm({ message: "  그래도 이 경로를 사용할까요? (아니오 = 다시 입력)", initialValue: true });
+        if (forceOk !== false) chosen = input;
       }
     }
 
@@ -240,7 +243,7 @@ export async function resolveProjectPaths({
     say(`  ✅ ${t} → ${chosen}`);
   }
 
-  // ── 요약 + 같은 마커 파일 중복 경고 (.sh L1559~1587) ──
+  // ── 요약 + 같은 마커 파일 중복 경고 ──
   say("");
   say("📂 타입별 버전 파일 경로 확정:");
   const fileToTypes = new Map(); // 마커 파일 상대경로 → 그 파일을 쓰는 타입들
@@ -253,7 +256,7 @@ export async function resolveProjectPaths({
   }
   for (const [file, ts] of fileToTypes) {
     if (ts.length > 1) {
-      // 멱등 동작이라 막지는 않고 경고만 (.sh L1577~1586)
+      // 멱등 동작이라 막지는 않고 경고만
       say(`  ⚠️ 같은 파일(${file})을 여러 타입(${ts.join(" ")})이 바라봅니다.`);
       say("     → sync 때 모두 같은 버전이 기록됩니다. 동작에는 문제없지만 의도한 구성인지 확인하세요.");
     }

package/src/core/paths.js

@@ -1,16 +1,41 @@
 // 경로 상수 — 설치 대상(사용자 레포) 경로 + payload 내부 레이아웃.
+import { join } from "node:path";
+
 export const PATHS = {
   versionFile: "version.yml",
   workflowsDir: ".github/workflows",
   scriptsDir: ".github/scripts",
 };
 
-// payload/ 내부 레이아웃 (payload 단일 진실 — DESIGN-SPEC §3)
+// payload/ 내부 레이아웃 (payload 단일 진실)
 export const PAYLOAD = {
   workflowsDir: "workflows",   // payload/workflows/{common,spring,flutter,...}
   scriptsDir: "scripts",       // payload/scripts/*.py
   configDir: "config",         // payload/config/wizard-prompts.yml 등 (마법사 런타임용)
 };
 
+// 타입 하나의 워크플로우 원본 폴더 [타입 직하위, server-deploy 하위] — 존재 여부는 호출부가 확인한다.
+// 설치·충돌 조사·미리보기·배포 방식 판정이 같은 폴더 구성을 봐야 결과가 서로 어긋나지 않는다.
+export function typeWorkflowDirs(payloadRoot, type) {
+  const typeDir = join(payloadRoot, PAYLOAD.workflowsDir, type);
+  return [typeDir, join(typeDir, "server-deploy")];
+}
+
 export const WORKFLOW_PREFIX = "PROJECT";
 export const WORKFLOW_COMMON_PREFIX = "PROJECT-COMMON";
+
+// 경로 정규화: 앞뒤 공백·\→/·끝 /·앞 ./ 제거, 빈값→"."
+export function normalizePath(p) {
+  let s = String(p).trim();
+  s = s.replace(/\\/g, "/");
+  s = s.replace(/\/+$/, "");   // 끝 /
+  s = s.replace(/^\.\//, "");  // 앞 ./
+  return s === "" ? "." : s;
+}
+
+// 정규화된 경로가 레포 안(상대경로, '..' 없음)인가. 레포 밖을 가리키면 설치 파일(fastlane 등)이
+// 옆 레포에 만들어지고 워크플로우 paths 필터도 동작하지 않는다.
+export function isRepoRelativePath(p) {
+  if (/^\//.test(p) || /^[A-Za-z]:/.test(p)) return false;
+  return !p.split("/").includes("..");
+}

package/src/core/release-options.js

@@ -0,0 +1,23 @@
+// 릴리스 옵션(semver_auto·copilot_ai) 값 결정 규칙 — 비대화형(index.js)과 대화형(interactive.js)이 공유한다.
+// 우선순위: 명시값(CLI 플래그·질문 답변) → version.yml 저장값 → 기본값. 경로마다 따로 두면
+// 같은 레포가 실행 방식에 따라 다른 설정으로 설치된다.
+
+// 명시값과 저장값만 반영한다 — null이면 아직 정해지지 않은 것(대화형은 이 값으로 질문 여부를 가른다).
+export function pickReleaseOptions(explicit = {}, existing = null) {
+  return {
+    semverAuto: explicit.semverAuto ?? existing?.options?.semverAuto ?? null,
+    copilotAi: explicit.copilotAi ?? existing?.options?.copilotAi ?? null,
+  };
+}
+
+// 최종값 — 정해지지 않은 옵션에 기본값을 채운다.
+// semver_auto: 신규 설치만 true. 기존 version.yml에 키가 없던 설치(기능 추가 이전 설치)가 조용히 켜지면
+//   애매한 커밋 하나로 major가 승격될 수 있어 false로 둔다.
+// copilot_ai: AI Credits를 소비하는 opt-in이라 신규·기존 모두 명시하지 않으면 false.
+export function resolveReleaseOptions(explicit = {}, existing = null) {
+  const { semverAuto, copilotAi } = pickReleaseOptions(explicit, existing);
+  return {
+    includeSemverAuto: semverAuto === null ? !existing : semverAuto !== false,
+    includeCopilotAi: copilotAi === true,
+  };
+}

package/src/core/removal-plan.js

@@ -8,30 +8,24 @@
 // 없는(그러나 파일명은 여전히 현재 payload와 일치하는) 기존 설치 전체를 인식하지 못하는 회귀가
 // 생긴다 — 그래서 두 방식을 합집합으로 병행한다. 마커는 이 수정 이후 배포되는 payload 템플릿부터
 // 포함되므로, (b) 경로가 실제로 새로 잡아내는 것은 "이름이 바뀌거나 삭제된, 마커가 있는" 파일뿐이다.
+// 단, 마커는 사용자가 워크플로우를 복사해 이름만 바꾼 파일에도 그대로 따라간다. 그래서 (b)는
+// baseline에 설치 기록이 있는 파일명만 인정하고, baseline이 없는 구버전 설치에서만 PROJECT-* 접두로 대신 판단한다.
 // 사용자가 직접 만든 워크플로우·version.yml·README·.gitignore는 대상이 아니다
 // (version.yml은 사용자 버전 데이터 — 제거 대상이 아니라 산출물이다).
 //
 // 이 파일은 원래 src/commands/revert.js였다. revert 모드는 uninstall의 부분집합이라 제거됐고
 //, 판별 로직만 남아 commands가 아닌 core로 옮겨졌다.
-import { join } from "node:path";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { PATHS, PAYLOAD } from "./paths.js";
-import { BASELINE_DIR, BASELINE_PATH } from "./baseline.js";
+import { join, isAbsolute } from "node:path";
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync } from "node:fs";
+import { PATHS } from "./paths.js";
+import { BASELINE_DIR, BASELINE_PATH, readBaseline, appFileHash, sha256 } from "./baseline.js";
+import { LOG_DIR } from "./logger.js";
+import { payloadWorkflowNames } from "./deploy-style.js";
+import { SCRIPT_NAMES } from "./copy/simple.js";
 
 // payload/workflows/**/*.yaml 첫 줄에 심어둔 고정 마커 — 이 값이 바뀌면 과거 설치분과의 매칭이 끊긴다.
 export const MANAGED_WORKFLOW_MARKER = "# project-auto-wizard:managed-workflow";
 
-// payload/workflows/** 전체(하위 폴더 포함)의 yaml 파일명 집합.
-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;
-}
-
 // 설치된 워크플로우 디렉토리(평면 구조)에서 관리 마커로 시작하는 파일명 집합.
 // .bak/.template.yaml 백업본도 원본 텍스트를 그대로 복사한 것이라 마커를 그대로 갖고 있어
 // 확장자나 파일명 유추 없이 동일한 방식으로 인식된다.
@@ -46,11 +40,29 @@ function markedWorkflowNames(wfDir) {
   return names;
 }
 
+// 마커가 있는 파일이 마법사가 설치한 것인지 — .bak/.template.yaml 백업본은 원본 파일명으로 따진다.
+// recorded: baseline의 파일명 집합, baseline이 없으면 null.
+function isInstalledName(name, recorded) {
+  if (!recorded) return name.startsWith("PROJECT-");
+  const stem = name.endsWith(".bak") ? name.slice(0, -".bak".length) : name;
+  const candidates = [name, stem];
+  if (stem.endsWith(".template.yaml")) {
+    const base = stem.slice(0, -".template.yaml".length);
+    candidates.push(base, base + ".yaml");
+  }
+  return candidates.some((c) => recorded.has(c));
+}
+
+// 충돌 처리·정리로 생긴 백업 파생 파일(.bak/.template.yaml) — .gitignore 자동 추가 항목이 가리는 대상이다.
+// 워크플로우를 남기는 삭제에서 이 파일들이 남으면 .gitignore 항목도 남겨야 git 상태에 드러나지 않는다.
+export const backupArtifacts = (names) => names.filter((n) => n.endsWith(".bak") || n.endsWith(".template.yaml"));
+
 // 아무것도 지우지 않는 순수 함수 — uninstall/purge/--dry-run이 공유한다.
 export function planRemoval(payloadRoot, targetRoot = ".") {
   const removedWf = new Set();
   const removedScripts = [];
   const wfDir = join(targetRoot, PATHS.workflowsDir);
+  const baseline = readBaseline(targetRoot);
   if (existsSync(wfDir)) {
     // (a) 현재 payload와 파일명이 일치하는 것 — 마커 유무 무관(기존 설치 회귀 방지).
     for (const name of payloadWorkflowNames(payloadRoot)) {
@@ -61,13 +73,57 @@ export function planRemoval(payloadRoot, targetRoot = ".") {
       if (existsSync(p + ".bak")) removedWf.add(name + ".bak");
     }
     // (b) 관리 마커로 시작하는 것 — payload에서 이름이 바뀌거나 삭제된 파일도 인식.
-    for (const name of markedWorkflowNames(wfDir)) removedWf.add(name);
+    const recorded = baseline ? new Set(Object.keys(baseline.files)) : null;
+    for (const name of markedWorkflowNames(wfDir)) {
+      if (isInstalledName(name, recorded)) removedWf.add(name);
+    }
   }
-  for (const s of ["version_manager.py", "changelog_manager.py", "truncate_release_notes.py", "issue_helper.py"]) {
+  for (const s of SCRIPT_NAMES) {
     if (existsSync(join(targetRoot, PATHS.scriptsDir, s))) removedScripts.push(s);
   }
+  // Flutter 앱 파일(Fastfile 등)은 마법사가 새로 만들었고 내용이 그대로인 것만 — 값을 채워 넣은 파일은 사용자 것이다.
+  const appFiles = [];
+  for (const [rel, hash] of Object.entries(baseline?.appFiles || {})) {
+    if (rel.split(/[\\/]/).includes("..") || isAbsolute(rel)) continue; // 레포 밖 경로는 신뢰하지 않는다
+    const p = join(targetRoot, rel);
+    if (existsSync(p) && appFileHash(readFileSync(p, "utf8")) === hash) appFiles.push(rel);
+  }
   // baseline은 마법사가 만든 내부 상태 파일이다 — 설치물을 지우면 함께 사라져야 한다.
   // 남겨두면 다음 설치가 "예전에 깔았다가 사용자가 지운 파일"로 오인해 전부 removed로 분류한다.
-  const baseline = existsSync(join(targetRoot, BASELINE_PATH)) ? [BASELINE_DIR] : [];
-  return { workflows: [...removedWf], scripts: removedScripts, baseline };
+  // 실행 로그(.wizard/logs)만 남은 경우도 같은 폴더째 지운다 — 설치물을 다 지운 뒤 로그 폴더만 남으면
+  // "완전 삭제"가 아니다.
+  const baselineDirs = existsSync(join(targetRoot, BASELINE_PATH)) || existsSync(join(targetRoot, LOG_DIR)) ? [BASELINE_DIR] : [];
+  return { workflows: [...removedWf], scripts: removedScripts, appFiles, baseline: baselineDirs };
+}
+
+// 업데이트 때 정리할 옛 워크플로우 — 마법사가 설치했지만(baseline 기록 + 관리 마커) 지금 payload에는 없는 파일.
+// payload에서 이름이 바뀌거나 빠진 파일이라, 남겨두면 옛 트리거·옛 절차로 계속 돈다.
+// baseline에 없는 파일은 대상이 아니다 — 사용자가 마법사 파일을 복사해 만든 워크플로우일 수 있다.
+export function findStaleWorkflows(payloadRoot, targetRoot = ".", baseline = null) {
+  if (!baseline?.files) return [];
+  const current = payloadWorkflowNames(payloadRoot);
+  return [...markedWorkflowNames(join(targetRoot, PATHS.workflowsDir))]
+    .filter((n) => /\.ya?ml$/.test(n) && !n.endsWith(".template.yaml") && !current.has(n) && baseline.files[n])
+    .sort();
+}
+
+// 배포 방식 정리와 같은 규칙 — 손대지 않은 파일(installed 해시 일치)은 삭제, 손댄 파일은 .bak으로 옮겨
+// 내용은 지키고 트리거만 끈다. dryRun이면 판정만 하고 파일은 건드리지 않는다 (--dry-run 미리보기용).
+export function cleanupStaleWorkflows(targetRoot, names, baseline, { dryRun = false } = {}) {
+  const wfDir = join(targetRoot, PATHS.workflowsDir);
+  const removed = [];
+  const backedUp = [];
+  for (const name of names) {
+    const p = join(wfDir, name);
+    if (!existsSync(p)) continue;
+    const known = baseline?.files?.[name]?.installed;
+    if (known && sha256(readFileSync(p, "utf8")) === known) {
+      if (!dryRun) rmSync(p, { force: true });
+      removed.push(name);
+    } else {
+      if (!dryRun) renameSync(p, `${p}.bak`);
+      backedUp.push(name);
+    }
+  }
+  return { removed, backedUp };
 }