project-auto-wizard 0.12.2 → 0.13.0

package/src/core/detect-fs.js

@@ -1,10 +1,11 @@
-// 실 파일시스템 프로젝트 감지 (.sh detect_* 실행부 등가).
+// 실 파일시스템 프로젝트 감지.
 // detect.js 순수 함수를 fs/git으로 구동한다.
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, basename } from "node:path";
 import { execFileSync } from "node:child_process";
 import { detectTypesFromMarkers, detectVersionFromFiles, detectBuildNumberFromFiles, detectJdkFromFiles, resolveMarkers } from "./detect.js";
 import { parseExisting } from "./version-yml.js";
+import { isValidBranchName } from "./branches.js";
 
 const hasFile = (root) => (rel) => existsSync(join(root, rel));
 const readFile = (root) => (rel) => {
@@ -18,22 +19,101 @@ function gitOut(root, args) {
 }
 
 // 타입 감지 — version.yml의 project_types 최우선(source of truth), 없으면 마커 스캔.
-export function detectTypes(root) {
+// paths: --paths로 받은 Map<type,path>. 모노레포는 루트에 마커가 없으므로 사용자가 적은 타입을 쓴다.
+// warn: 루트에 마커가 없어 basic으로 떨어질 때 하위 폴더에서 찾은 프로젝트를 알린다.
+export function detectTypes(root, { paths = new Map(), warn } = {}) {
   const vy = join(root, "version.yml");
   if (existsSync(vy)) {
     const { types } = parseExisting(readFileSync(vy, "utf8"));
     if (types.length) return types; // basic 포함, 명시돼 있으면 그대로
   }
-  return detectTypesFromMarkers({ has: hasFile(root), read: readFile(root) });
+  const fromRoot = detectTypesFromMarkers({ has: hasFile(root), read: readFile(root) });
+  if (paths.size) {
+    // --paths 순서가 주 타입을 정한다. 루트 package.json의 node는 다른 타입이 있으면 빼는
+    // 마커 스캔 규칙과 맞춘다.
+    const merged = [...new Set([...paths.keys(), ...fromRoot])].filter((t) => t !== "basic");
+    const types = merged.length > 1 ? merged.filter((t) => t !== "node" || paths.has("node")) : merged;
+    return types.length ? types : ["basic"];
+  }
+  if (fromRoot.length === 1 && fromRoot[0] === "basic" && warn) {
+    const found = findSubdirProjects(root);
+    if (found.length) {
+      const firstDir = new Map();
+      for (const { dir, types } of found) for (const t of types) if (!firstDir.has(t)) firstDir.set(t, dir);
+      const list = found.map(({ dir, types }) => `${dir}(${types.join(", ")})`).join(", ");
+      const hint = [...firstDir].map(([t, d]) => `${t}=${d}`).join(",");
+      warn(`⚠️  루트에서 프로젝트 파일을 찾지 못해 basic으로 설치합니다. 하위 폴더에서 발견: ${list}\n` +
+        `   모노레포라면 --paths "${hint}"로 다시 실행하세요.`);
+    }
+  }
+  return fromRoot;
 }
 
-// 버전 감지 — .sh detect_version 순서. jq는 package.json 파싱에 쓰인 적이 없어 게이트를 제거했다.
+// 루트 아래 2단계까지 프로젝트 마커가 있는 폴더를 찾는다 (모노레포 안내용).
+// 빌드 산출물·의존성·네이티브 폴더는 오탐만 늘리므로 들어가지 않고, 찾은 폴더의 하위도 보지 않는다.
+const SUBDIR_PRUNE = new Set(["node_modules", "build", "dist", "android", "ios", "venv", "__pycache__"]);
+function findSubdirProjects(root, maxDepth = 2) {
+  const found = [];
+  const walk = (rel, depth) => {
+    let entries;
+    try { entries = readdirSync(join(root, rel), { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (!e.isDirectory() || e.name.startsWith(".") || SUBDIR_PRUNE.has(e.name)) continue;
+      const childRel = rel ? `${rel}/${e.name}` : e.name;
+      const dir = join(root, childRel);
+      const types = detectTypesFromMarkers({ has: hasFile(dir), read: readFile(dir) });
+      if (types[0] !== "basic") found.push({ dir: childRel, types });
+      else if (depth + 1 < maxDepth) walk(childRel, depth + 1);
+    }
+  };
+  walk("", 0);
+  return found.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+
+// 버전 감지 — 타입별 버전 파일을 순서대로 읽는다.
 // hint: 폴백 경고에 붙일 해결 방법 안내 (대화형/CLI가 다르다).
-export function detectVersion(root, { warn = (m) => console.error(m), hint } = {}) {
-  const read = readFile(root);
+// 모노레포(--paths)는 버전 파일이 타입 폴더 안에 있다 — 루트만 보면 0.0.1/1로 초기화된다.
+// 주 타입 폴더 → 나머지 타입 폴더 → 루트 순으로 찾는다.
+function projectBases(types = [], paths = null) {
+  const bases = [];
+  for (const t of types) {
+    const p = paths?.get?.(t);
+    if (p && p !== "." && !bases.includes(p)) bases.push(p);
+  }
+  return bases.length ? [...bases, "."] : ["."];
+}
+
+// 첫 번째로 결과가 있는 기준 폴더의 값을 쓴다 — read와 list가 같은 폴더 우선순위를 따른다.
+function firstFromBases(bases, fn) {
+  return (rel) => {
+    for (const b of bases) {
+      const c = fn(b === "." ? rel : `${b}/${rel}`);
+      if (c != null) return c;
+    }
+    return null;
+  };
+}
+
+function readFromProject(root, types = [], paths = null) {
+  return firstFromBases(projectBases(types, paths), readFile(root));
+}
+
+// 하위 폴더 이름 목록 (React Native의 ios/<앱>/Info.plist 탐색용). 폴더가 없으면 null.
+function listFromProject(root, types = [], paths = null) {
+  const listDirs = (rel) => {
+    try {
+      return readdirSync(join(root, rel), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch { return null; }
+  };
+  return firstFromBases(projectBases(types, paths), listDirs);
+}
+
+export function detectVersion(root, { warn = (m) => console.error(m), hint, types = [], paths = null } = {}) {
+  const read = readFromProject(root, types, paths);
   const readJson = (rel) => { const c = read(rel); try { return c ? JSON.parse(c) : null; } catch { return null; } };
+  const list = listFromProject(root, types, paths);
   const gitTag = gitOut(root, ["describe", "--tags", "--abbrev=0"]);
-  return detectVersionFromFiles({ read, readJson, gitTag, warn, hint });
+  return detectVersionFromFiles({ read, readJson, list, gitTag, warn, hint, types });
 }
 
 // 타입별 실제 마커 파일 — 감지 로그·설치 로그가 같은 근거 파일을 인용하도록.
@@ -50,20 +130,28 @@ export function detectJdk(root, base = ".") {
 }
 
 // 빌드 번호 감지 — 신규 통합 시 pubspec.yaml/build.gradle/app.json에서 실제 빌드 번호를 읽는다.
-export function detectBuildNumber(root, { types = [], warn = (m) => console.error(m) } = {}) {
-  const read = readFile(root);
+export function detectBuildNumber(root, { types = [], paths = null, warn = (m) => console.error(m) } = {}) {
+  const read = readFromProject(root, types, paths);
   const readJson = (rel) => { const c = read(rel); try { return c ? JSON.parse(c) : null; } catch { return null; } };
   return detectBuildNumberFromFiles({ types, read, readJson, warn });
 }
 
 // 기본 브랜치 감지 — symbolic-ref → remote show → main.
-export function detectDefaultBranch(root) {
-  let b = gitOut(root, ["symbolic-ref", "refs/remotes/origin/HEAD"]);
-  if (b) return b.replace(/^refs\/remotes\/origin\//, "");
+// 빈 원격(remote add만 하고 push 전)은 remote show가 "HEAD branch: (unknown)"을 돌려준다. 이 값이
+// 워크플로우 트리거에 기록되면 릴리스 자동화가 조용히 멈추므로, 유효한 브랜치 이름만 인정하고
+// 아니면 로컬 현재 브랜치(첫 push 대상) → main 순으로 폴백하며 경고한다.
+// hint: 경고에 붙일 해결 방법 안내 (대화형/CLI가 다르다).
+export function detectDefaultBranch(root, { warn = null, hint = "" } = {}) {
+  const b = gitOut(root, ["symbolic-ref", "refs/remotes/origin/HEAD"]).replace(/^refs\/remotes\/origin\//, "");
+  if (isValidBranchName(b)) return b;
   const show = gitOut(root, ["remote", "show", "origin"]);
   const m = show.match(/HEAD branch:\s*(\S+)/);
-  if (m) return m[1];
-  return "main";
+  if (m && isValidBranchName(m[1])) return m[1];
+  if (!m) return "main"; // origin 없음 — 기존 규칙 그대로
+  const local = gitOut(root, ["symbolic-ref", "--short", "HEAD"]);
+  const fallback = isValidBranchName(local) ? local : "main";
+  warn?.(`⚠️  원격 기본 브랜치를 확인할 수 없어(빈 원격 레포 등) 릴리스 브랜치를 '${fallback}'(으)로 가정합니다.${hint ? ` ${hint}` : ""}`);
+  return fallback;
 }
 
 // 레포명 — git remote get-url origin 마지막 세그먼트, 실패 시 폴더명.
@@ -76,7 +164,7 @@ export function detectRepoName(root) {
   return basename(root);
 }
 
-// Spring application*.yml 탐색 (.sh resolve_spring_app_yml_dir/path L2767~2780 등가)
+// Spring application*.yml 탐색
 // find {base} -path "*/src/main/resources/application*.yml" | head -1 의 fs 재귀 구현.
 // 반환: root 기준 상대경로 (예: "server/src/main/resources/application.yml") 또는 "".
 //
@@ -87,9 +175,14 @@ export function detectRepoName(root) {
 // 같은 디렉토리에서는 프로파일 없는 기본 파일(application.yml/.yaml)을 우선한다. 파일명 정렬만
 // 쓰면 'application-dev.yml'이 'application.yml'보다 앞서(`-` < `.`) 프로파일 파일이 잡힌다.
 export function findSpringAppYml(root, base = ".") {
+  return findSpringConfig(root, base, /^application(-[^/]*)?\.ya?ml$/, /^application\.ya?ml$/);
+}
+
+// src/main/resources 아래에서 pattern에 맞는 설정 파일을 찾는다. basePattern(프로파일 없는 기본 파일)이
+// 나오면 그걸로 확정한다.
+function findSpringConfig(root, base, pattern, basePattern) {
   const startRel = base === "." ? "" : base;
   const PRUNE = new Set(["node_modules", ".git", "build", ".gradle", "target", ".idea"]);
-  const APP_YML = /^application(-[^/]*)?\.ya?ml$/;
   let hit = "";
   let hitIsBase = false;
   const walk = (rel, depth) => {
@@ -103,8 +196,8 @@ export function findSpringAppYml(root, base = ".") {
       if (e.isDirectory()) {
         if (PRUNE.has(e.name)) continue;
         walk(childRel, depth + 1);
-      } else if (APP_YML.test(e.name) && childRel.includes("src/main/resources/")) {
-        const isBase = /^application\.ya?ml$/.test(e.name);
+      } else if (pattern.test(e.name) && childRel.includes("src/main/resources/")) {
+        const isBase = basePattern.test(e.name);
         // 첫 매치는 일단 채택하고, 이후 기본 파일이 나오면 그걸로 승격한다.
         if (!hit || isBase) { hit = childRel; hitIsBase = isBase; }
       }
@@ -114,7 +207,17 @@ export function findSpringAppYml(root, base = ".") {
   return hit;
 }
 
-// 실 resolver 세트 생성 (.sh resolve_token 4종 등가) — index/interactive 공용.
+// 배포 워크플로우가 application-prod.yml을 만들 리소스 폴더.
+// Spring Initializr 기본 산출물은 application.properties라 yml만 찾으면 빈 값이 되어
+// __APPLICATION_YML_DIR__가 치환되지 않은 채 설치된다. yml → properties → 표준 경로 순으로 정한다.
+export function findSpringResourcesDir(root, base = ".") {
+  const f = findSpringAppYml(root, base)
+    || findSpringConfig(root, base, /^application(-[^/]*)?\.properties$/, /^application\.properties$/);
+  if (f) return f.split("/").slice(0, -1).join("/");
+  return base === "." ? "src/main/resources" : `${base}/src/main/resources`;
+}
+
+// @wizard 토큰 resolver 세트 생성 — index/interactive 공용.
 // paths: Map<type, path> (모노레포 경로).
 // flutterOptions: resolveFlutterOptions 결과 또는 같은 필드를 가진 context. null이면 Flutter 토큰이
 //   빈 값이라 템플릿 기본값(dart-define, store_only)이 그대로 남는다.
@@ -126,11 +229,11 @@ export function makeResolvers(root, repoName, paths, flutterOptions = null) {
     // ⚠️ 빈 문자열을 돌려주면 setEnvLine이 그 줄을 건너뛰어 __JAVA_VERSION__이 그대로 남는다
     //    (같은 실패 형태). 감지 실패 시 반드시 종전 기본값 21로 폴백한다.
     jdk: (t) => detectJdk(root, springBase(t)) || "21",
-    "spring-app-yml-dir": (t) => {
-      const f = findSpringAppYml(root, springBase(t));
-      return f ? f.split("/").slice(0, -1).join("/") : "";
-    },
-    "spring-app-yml-path": (t) => findSpringAppYml(root, springBase(t)) || "",
+    "spring-app-yml-dir": (t) => findSpringResourcesDir(root, springBase(t)),
+    // yml이 없는 프로젝트(properties 전용)는 리소스 폴더의 application.yml로 만든다 —
+    // properties 파일 자리에 YAML 내용을 쓰면 설정이 깨진다.
+    "spring-app-yml-path": (t) => findSpringAppYml(root, springBase(t))
+      || `${findSpringResourcesDir(root, springBase(t))}/application.yml`,
     "flutter-root": () => paths.get("flutter") || ".",
     // CI changes job의 경로 필터 — 타입별 프로젝트 루트. 단일 레포·common은 "."(항상 변경됨으로 판정).
     "project-path": (t) => paths.get(t) || ".",

package/src/core/detect.js

@@ -1,14 +1,20 @@
-// package.json 내용 분류 (.sh classify_package_json 등가) — 원본 파일 텍스트에 대한
-// grep 부분문자열 매칭. dependencies 파싱이 아니라 raw 텍스트 검사여야 등가.
-// 입력은 package.json의 원문 문자열(raw). 순서 중요.
+import {
+  typeInfo, FALLBACK_TYPE, MARKER_DETECTED_TYPES, PACKAGE_DETECTED_TYPES, PACKAGE_FALLBACK_TYPE,
+} from "./types.js";
+
+// package.json 분류 — 의존성 "키"를 정확히 비교한다. 원문 부분문자열로 보면 export 스크립트나
+// exponential-backoff가 expo로, react-native-web을 쓰는 웹앱이 react-native로, keywords의 "next"가
+// next로 오감지된다. 입력은 package.json 원문 문자열(raw). 판정 순서는 레지스트리의 detectOrder.
 export function classifyPackageText(raw) {
-  const s = String(raw || "");
-  if (s.includes("@react-native") || s.includes("react-native")) {
-    return s.includes("expo") ? "react-native-expo" : "react-native";
+  let pkg;
+  try { pkg = JSON.parse(String(raw || "")); } catch { return PACKAGE_FALLBACK_TYPE; }
+  if (!pkg || typeof pkg !== "object") return PACKAGE_FALLBACK_TYPE;
+  const deps = new Set();
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    const d = pkg[field];
+    if (d && typeof d === "object") for (const k of Object.keys(d)) deps.add(k);
   }
-  if (s.includes('"next"')) return "next";
-  if (s.includes('"react"')) return "react";
-  return "node";
+  return PACKAGE_DETECTED_TYPES.find((t) => deps.has(t.packageDep))?.id ?? PACKAGE_FALLBACK_TYPE;
 }
 
 // 편의: 파싱된 객체를 받는 경우 원문으로 재직렬화해 위 규칙 적용
@@ -17,77 +23,152 @@ export function classifyPackageJson(pkgOrRaw) {
   return classifyPackageText(raw);
 }
 
-// 마커 스캔 (동작명세 §3.1). has(relpath)=>bool 주입. node는 다른 타입 있으면 미추가.
+// 마커 스캔. has(relpath)=>bool 주입. node는 다른 타입 있으면 미추가.
 // read(relpath)=>string|null 로 package.json 원문을 받아 classifyPackageText에 넘긴다.
 export function detectTypesFromMarkers({ has, read }) {
   const types = [];
-  if (has("pubspec.yaml")) types.push("flutter");
-  if (has("build.gradle") || has("build.gradle.kts") || has("pom.xml")) types.push("spring");
-  if (has("pyproject.toml") || has("setup.py") || has("requirements.txt")) types.push("python");
-  if (has("go.mod")) types.push("go");
+  for (const t of MARKER_DETECTED_TYPES) if (t.markers.some(has)) types.push(t.id);
   if (has("package.json")) {
     const cls = classifyPackageText(read ? read("package.json") : "");
-    if (cls === "node") { if (types.length === 0) types.push("node"); }
+    if (cls === PACKAGE_FALLBACK_TYPE) { if (types.length === 0) types.push(cls); }
     else types.push(cls);
   }
-  return types.length ? [...new Set(types)] : ["basic"];
+  return types.length ? [...new Set(types)] : [FALLBACK_TYPE];
+}
+
+// 1.2.3-rc.1·1.2.3+7·1.2.0-SNAPSHOT 같은 prerelease/빌드 메타데이터는 x.y.z 코어만 쓴다.
+// version.yml은 x.y.z만 받으므로 감지 실패(0.0.1)로 떨어지는 것보다 코어가 정확하다.
+// 릴리스 시 읽기(payload/scripts/version_manager.py core_version)와 같은 규칙이어야 설치 직후 값이 유지된다.
+function coreVersion(v) {
+  const m = String(v ?? "").trim().match(/^v?(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.+-]*)?$/);
+  return m ? m[1] : null;
 }
 
-const VERSION_RE = /^\d+\.\d+\.\d+$/;
+// setup.py의 setup(version="x.y.z"). python_version 같은 다른 키는 단어 경계로 거른다.
+export function versionFromSetupPy(content) {
+  if (!content) return null;
+  const m = String(content).match(/(?<![\w.])version\s*=\s*["']([^"']+)["']/);
+  return m ? coreVersion(m[1]) : null;
+}
 
-// 버전 감지 (동작명세 §3.3) — 순서대로 첫 성공. read(relpath)=>string|null 주입.
+// React Native 앱 버전 — 릴리스 때 version_manager가 쓰는 파일(ios/<앱>/Info.plist,
+// android/app/build.gradle)에서 읽는다. package.json version은 동기화 대상이 아니라 기준이 되면 어긋난다.
+// $(MARKETING_VERSION) 참조나 템플릿 기본값 "1.0"처럼 x.y.z가 아니면 건너뛴다.
+// list(relDir)=>string[]|null 로 ios 아래 앱 폴더 이름을 받는다(Pods 등 깊은 plist는 보지 않는다).
+export function versionFromReactNative({ read, list }) {
+  for (const dir of [...(list?.("ios") || [])].sort()) {
+    const m = String(read(`ios/${dir}/Info.plist`) || "").match(/<key>CFBundleShortVersionString<\/key>\s*<string>([^<]*)<\/string>/);
+    const v = m && coreVersion(m[1]);
+    if (v) return v;
+  }
+  const m = String(read("android/app/build.gradle") || "").match(/versionName\s+"([^"]+)"/);
+  return m ? coreVersion(m[1]) : null;
+}
+
+// 버전 감지 — 순서대로 첫 성공. read(relpath)=>string|null 주입.
 // package.json은 이미 Node JSON.parse로 파싱을 마친 값이므로 jq 설치 여부와 무관하게 항상 사용한다.
 // hint: 폴백 경고 뒤에 붙일 "그럼 어떻게 고치나" 한 줄. 대화형과 CLI가 서로 다른 방법을
 // 안내해야 하므로 호출부가 정한다. 미지정 시 CLI 문구를 쓴다.
-export function detectVersionFromFiles({ read, readJson, gitTag, warn, hint }) {
-  const pkg = readJson?.("package.json");
-  if (pkg?.version && VERSION_RE.test(pkg.version)) return pkg.version;
+// types: 주 타입(첫 항목)의 버전 파일을 먼저 읽는다. 릴리스 때 version_manager가 주 타입
+// 파일과 version.yml을 비교하므로, 다른 타입 버전을 잡으면 첫 릴리스에서 버전이 뛴다.
+export function detectVersionFromFiles({ read, readJson, list, gitTag, warn, hint, types = [] }) {
   const grab = (content, re) => {
     for (const line of (content || "").split("\n")) {
       const m = line.match(re);
-      if (m && VERSION_RE.test(m[1])) return m[1];
+      if (m) { const v = coreVersion(m[m.length - 1]); if (v) return v; }
     }
     return null;
   };
-  let v;
-  const gradleRe = /version\s*=\s*["']?(\d+\.\d+\.\d+)/;
-  // Groovy DSL과 Kotlin DSL은 같은 문법(`version = "x.y.z"`)이라 정규식을 공유한다.
-  // .kts를 빼먹으면 Kotlin DSL Spring 프로젝트가 전부 0.0.1로 초기화된다.
-  if ((v = grab(read("build.gradle"), gradleRe))) return v;
-  if ((v = grab(read("build.gradle.kts"), gradleRe))) return v;
-  if ((v = versionFromPom(read("pom.xml")))) return v;
-  if ((v = grab(read("pubspec.yaml"), /^version:\s*(\d+\.\d+\.\d+)/))) return v;
-  if ((v = grab(read("pyproject.toml"), /version\s*=\s*["']?(\d+\.\d+\.\d+)/))) return v;
-  if (gitTag) { const t = String(gitTag).replace(/^v/, ""); if (VERSION_RE.test(t)) return t; }
+  // 줄 시작 앵커가 없으면 ext.kotlin_version 같은 의존성 버전 변수가 먼저 걸린다.
+  // 따옴표로 감싼 값만 본다 — 릴리스 때 동기화가 고칠 수 있는 형태가 이것뿐이다.
+  const gradleRe = /^\s*version\s*=\s*(["'])([^"'\n]*)\1/;
+  const sources = {
+    packageJson: () => coreVersion(readJson?.("package.json")?.version),
+    appJson: () => coreVersion(readJson?.("app.json")?.expo?.version),
+    // Groovy DSL과 Kotlin DSL은 같은 문법(`version = "x.y.z"`)이라 정규식을 공유한다.
+    // .kts를 빼먹으면 Kotlin DSL Spring 프로젝트가 전부 0.0.1로 초기화된다.
+    gradle: () => grab(read("build.gradle"), gradleRe),
+    gradleKts: () => grab(read("build.gradle.kts"), gradleRe),
+    pom: () => versionFromPom(read("pom.xml")),
+    pubspec: () => grab(read("pubspec.yaml"), /^version:\s*([^\s#]+)/),
+    pyproject: () => versionFromPyproject(read("pyproject.toml")),
+    setupPy: () => versionFromSetupPy(read("setup.py")),
+    reactNative: () => versionFromReactNative({ read, list }),
+  };
+  const order = [
+    ...(typeInfo(types[0])?.versionSources || []),
+    "packageJson", "gradle", "gradleKts", "pom", "pubspec", "pyproject", "setupPy",
+  ];
+  for (const key of new Set(order)) {
+    const v = sources[key]();
+    if (v) return v;
+  }
+  if (gitTag) { const t = coreVersion(gitTag); if (t) return t; }
   const tail = hint ?? "--project-version으로 직접 지정하거나 version.yml을 확인하세요.";
   warn?.(`⚠️  버전을 자동 감지하지 못해 기본값 0.0.1을 사용합니다 — ${tail}`);
   return "0.0.1";
 }
 
-// Maven pom.xml의 프로젝트 버전. <parent> 블록 안의 버전은 스프링 부트 BOM 버전이라
-// 프로젝트 버전이 아니다 — 그 구간을 지운 뒤 첫 <version>을 읽는다.
+// pyproject.toml의 패키지 버전. [tool.*] 등 다른 섹션의 `version =`은 도구 설정이라
+// [project]·[tool.poetry] 섹션 안에서만 읽는다.
+export function versionFromPyproject(content) {
+  if (!content) return null;
+  let section = "";
+  for (const line of String(content).split(/\r?\n/)) {
+    const h = line.match(/^\s*\[+\s*([^\]]+?)\s*\]+\s*(?:#.*)?$/);
+    if (h) { section = h[1]; continue; }
+    if (section !== "project" && section !== "tool.poetry") continue;
+    const m = line.match(/^\s*version\s*=\s*["']([^"']+)["']/);
+    if (m) return coreVersion(m[1]);
+  }
+  return null;
+}
+
+// Maven pom.xml의 프로젝트 버전 — <project> 바로 아래의 <version>만 본다.
+// <parent>(스프링 부트 BOM)나 <dependencies> 안의 버전은 프로젝트 버전이 아니므로 깊이로 구분한다.
+// 프로젝트 버전이 없으면(부모에서 상속) null — 의존성 버전을 대신 고르지 않는다.
 export function versionFromPom(content) {
   if (!content) return null;
-  const body = String(content).replace(/<parent>[\s\S]*?<\/parent>/g, "");
-  const m = body.match(/<version>\s*(\d+\.\d+\.\d+)[^<]*<\/version>/);
-  return m ? m[1] : null;
+  const text = String(content);
+  const tokenRe = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<![^>]*>|<(\/?)([A-Za-z_][\w.:-]*)[^>]*?(\/?)>/g;
+  const stack = [];
+  let start = -1;
+  let m;
+  while ((m = tokenRe.exec(text))) {
+    const name = m[2];
+    if (!name) continue;
+    if (m[1]) {
+      if (start >= 0 && stack.length === 2 && stack[1] === "version") {
+        return coreVersion(text.slice(start, m.index));
+      }
+      stack.pop();
+      continue;
+    }
+    if (m[3]) continue;
+    stack.push(name);
+    if (stack.length === 2 && name === "version") start = tokenRe.lastIndex;
+  }
+  return null;
 }
 
+// 타입의 대표 마커 파일. 마커가 없는 타입(basic)·미지 타입은 package.json을 돌려준다.
 export function markerForType(type) {
-  return { flutter: "pubspec.yaml", "react-native-expo": "app.json", python: "pyproject.toml", spring: "build.gradle", go: "go.mod" }[type] || "package.json";
+  return typeInfo(type)?.markers[0] || "package.json";
 }
 
+// 대표 파일 외의 보조 마커 (예: Spring의 build.gradle.kts·pom.xml).
 export function extraMarkers(type) {
-  return { python: ["setup.py", "requirements.txt"], spring: ["build.gradle.kts", "pom.xml"] }[type] || [];
+  return typeInfo(type)?.markers.slice(1) || [];
 }
 
 // 그 타입을 감지하는 데 실제로 쓰인 파일. markerForType은 타입당 대표 파일 하나를
 // 고정 반환하므로, build.gradle.kts만 있는 레포에서도 "build.gradle 발견"이라고 출력돼
 // 같은 설치 로그 안에서 경로 확정 화면과 파일명이 어긋났다. has()로 실재하는 것을 고른다.
-// 실재하는 후보가 없으면(감지 전 화면 등) 대표 파일을 쓴다.
-export function resolveMarker(type, has) {
+// 실재하는 후보가 없으면(감지 전 화면 등) 대표 파일을 쓴다. 단 "근거"로 보여줄 때는(fallback:false)
+// 빈 문자열을 돌려준다 — 직접 고른 타입에 없는 파일을 근거로 붙이면 감지된 것처럼 보인다.
+export function resolveMarker(type, has, { fallback = true } = {}) {
   const candidates = [markerForType(type), ...extraMarkers(type)];
-  return candidates.find(has) ?? candidates[0];
+  return candidates.find(has) ?? (fallback ? candidates[0] : "");
 }
 
 // 빌드 JDK 감지 — 배포 워크플로우의 JAVA_VERSION 기본값이 21로 고정돼 있어
@@ -124,7 +205,9 @@ export function resolveMarkers(types = [], has) {
   const out = new Map();
   for (const t of types) {
     if (t === "basic") continue;
-    out.set(t, resolveMarker(t, has));
+    // 실제로 있는 파일만 근거로 삼는다 — 없으면 맵에서 빠져 화면·로그가 "직접 선택"으로 다룬다.
+    const found = resolveMarker(t, has, { fallback: false });
+    if (found) out.set(t, found);
   }
   return out;
 }
@@ -137,7 +220,8 @@ export function detectBuildNumberFromFiles({ types = [], read, readJson, warn })
   const tryFlutter = () => {
     const content = read("pubspec.yaml");
     if (content == null) return null;
-    const m = content.match(/^version:\s*\d+\.\d+\.\d+\+(\d+)/m);
+    // 1.2.3-rc.1+4처럼 prerelease가 있어도 +N은 빌드 번호다(릴리스 시 읽기와 같은 규칙).
+    const m = content.match(/^version:\s*\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?\+(\d+)/m);
     if (m) return parseInt(m[1], 10);
     warn?.("⚠️  pubspec.yaml에 빌드 번호(+N)가 없어 version_code를 감지하지 못했습니다 — 기본값 1을 사용합니다. 실제 빌드 번호를 확인하세요.");
     return null;
@@ -160,10 +244,10 @@ export function detectBuildNumberFromFiles({ types = [], read, readJson, warn })
     warn?.("⚠️  app.json의 expo.android.versionCode가 없어 version_code를 감지하지 못했습니다 — 기본값 1을 사용합니다. 실제 빌드 번호를 확인하세요.");
     return null;
   };
+  const readers = { pubspec: tryFlutter, androidGradle: tryReactNative, expoAppJson: tryExpo };
   for (const t of types) {
-    if (t === "flutter") return tryFlutter();
-    if (t === "react-native") return tryReactNative();
-    if (t === "react-native-expo") return tryExpo();
+    const source = typeInfo(t)?.buildNumberSource;
+    if (source) return readers[source]();
   }
   return null;
 }

package/src/core/errors.js

@@ -0,0 +1,3 @@
+// 사용자 입력 오류 — 호출부(index.js)가 스택 없이 메시지만 출력하고 exit 1로 끝낸다.
+// core 모듈도 던지므로 cli가 아닌 core에 둔다(core → cli 역참조 방지).
+export class CliError extends Error {}

package/src/core/flutter-options.js

@@ -55,8 +55,9 @@ export function storeWorkflowFilter(stores) {
 //   손대지 않은 것(baseline의 installed 해시와 동일) → 삭제
 //   손댄 것                                          → .bak으로 옮긴다 (내용 보존, 트리거만 죽인다)
 // 사용자 소유인 Fastfile·ExportOptions.plist는 여기서 다루지 않는다 (워크플로우 파일만 대상).
+// dryRun이면 판정만 하고 파일은 건드리지 않는다 (--dry-run 미리보기용).
 // 반환: { removed:[], backedUp:[] }
-export function cleanupDeselectedStoreWorkflows(workflowsDir, installedFilenames, stores, baseline) {
+export function cleanupDeselectedStoreWorkflows(workflowsDir, installedFilenames, stores, baseline, { dryRun = false } = {}) {
   const keep = storeWorkflowFilter(stores);
   const removed = [];
   const backedUp = [];
@@ -69,10 +70,10 @@ export function cleanupDeselectedStoreWorkflows(workflowsDir, installedFilenames
     const known = baseline?.files?.[filename]?.installed;
     const untouched = 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);
     }
   }

package/src/core/fsutil.js

@@ -1,9 +1,9 @@
 // 파일시스템 공용 유틸 (LF 보존 바이트 복사). 텍스트는 그대로 복사해 원본 줄바꿈 유지.
 import {
   cpSync, existsSync, readFileSync, writeFileSync, mkdirSync,
-  readdirSync, rmSync,
+  readdirSync, rmSync, accessSync, constants,
 } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 
 export const exists = (p) => existsSync(p);
 export const readText = (p) => readFileSync(p, "utf8");
@@ -31,10 +31,9 @@ export function remove(p) {
 }
 
 // 디렉토리 직하위 .yaml/.yml 파일명 목록. 하위 폴더 제외.
-// 정렬 순서는 .sh의 glob `"$_dir"/*.yaml "$_dir"/*.yml` 와 일치시킨다:
-// 확장자로 1차 그룹(.yaml 먼저 → .yml 나중), 각 그룹 안에서 알파벳순.
-// (단순 .sort()는 확장자를 섞어 정렬해 .sh와 파일 순회 순서가 갈리고,
-//  그 결과 version.yml deploy 블록의 키 순서까지 달라진다. 확장자 그룹핑으로 바이트 등가 확보.)
+// 정렬 순서는 고정한다: 확장자로 1차 그룹(.yaml 먼저 → .yml 나중), 각 그룹 안에서 알파벳순.
+// (단순 .sort()는 확장자를 섞어 정렬해 기존 설치와 파일 순회 순서가 갈리고,
+//  그 결과 version.yml deploy 블록의 키 순서까지 달라진다. 확장자 그룹핑으로 재실행 결과를 바이트 단위로 유지.)
 export function listYamlFiles(dir) {
   if (!existsSync(dir)) return [];
   const names = readdirSync(dir, { withFileTypes: true })
@@ -44,3 +43,21 @@ export function listYamlFiles(dir) {
   const yml = names.filter((n) => n.endsWith(".yml")).sort();
   return [...yaml, ...yml];
 }
+
+// 쓰기 전에 권한을 미리 확인한다 — 중간에 EACCES로 멈추면 일부만 설치된 상태가 남고,
+// 다음 실행에서는 기준점(baseline)이 없어 이미 쓴 파일이 전부 충돌로 분류된다.
+// dirs: 파일을 만들 폴더(없으면 만들어질 가장 가까운 상위 폴더를 본다), files: 이미 있으면 덮어쓸 파일.
+// 반환: 쓸 수 없는 경로(root 기준 상대경로) 목록.
+export function findUnwritable(root, dirs = [], files = []) {
+  const writable = (p) => { try { accessSync(p, constants.W_OK); return true; } catch { return false; } };
+  const blocked = new Set();
+  for (const rel of dirs) {
+    let cur = rel;
+    while (cur !== "." && !existsSync(join(root, cur))) cur = dirname(cur);
+    if (!writable(join(root, cur))) blocked.add(cur);
+  }
+  for (const rel of files) {
+    if (existsSync(join(root, rel)) && !writable(join(root, rel))) blocked.add(rel);
+  }
+  return [...blocked];
+}