project-auto-wizard 0.13.0 → 0.13.1

package/src/commands/uninstall.js

@@ -1,46 +1,14 @@
 // uninstall 모드 — 마법사가 설치한 파일(planRemoval 판별분)에 더해 README/.gitignore/version.yml까지
 // 선택적으로 제거한다. 대화형 체크리스트 또는 --force + --purge-* 로 항목별 opt-in.
 // core/removal-plan.js는 읽기 전용으로만 재사용한다(아무것도 지우지 않는 순수 함수).
-import { join, posix } from "node:path";
-import { existsSync, readdirSync, rmdirSync } from "node:fs";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
 import { PATHS } from "../core/paths.js";
-import { remove } from "../core/fsutil.js";
 import { planRemoval, backupArtifacts } from "../core/removal-plan.js";
-import { removeVersionSectionFromReadme, hasVersionSection } from "../core/copy/readme.js";
-import { removeAutoAddedEntriesFromGitignore, hasAutoAddedEntries } from "../core/copy/gitignore.js";
+import { executeRemoval } from "../core/removal-exec.js";
+import { hasVersionSection } from "../core/copy/readme.js";
+import { hasAutoAddedEntries } from "../core/copy/gitignore.js";
 import { CANCEL } from "../ui/prompts.js";
-import { logRemovals } from "../core/logger.js";
-
-// 파일을 지운 뒤 비게 된 상위 폴더를 레포 루트 직전까지 정리한다(마법사가 만든 fastlane/ 등).
-// 비어 있지 않은 폴더를 만나면 멈추므로 사용자 파일이 남은 폴더는 건드리지 않는다.
-export function pruneEmptyDirs(targetRoot, relDir) {
-  let rel = relDir;
-  while (rel && rel !== "." && rel !== "/") {
-    const abs = join(targetRoot, rel);
-    try {
-      if (readdirSync(abs).length) break;
-      rmdirSync(abs);
-    } catch { break; }
-    rel = posix.dirname(rel);
-  }
-}
-
-// Flutter 앱 파일 제거 — 미수정분만 plan에 들어오므로 그대로 지우고 빈 폴더를 정리한다.
-// 로그는 삭제가 끝난 뒤 한꺼번에 남기므로 기록할 항목을 done에 모은다.
-export function removeAppFiles(targetRoot, appFiles, done = []) {
-  for (const rel of appFiles) {
-    remove(join(targetRoot, rel));
-    pruneEmptyDirs(targetRoot, posix.dirname(rel));
-    done.push(["remove", "flutter-app", rel]);
-  }
-}
-
-// 설치물을 지운 뒤 비게 된 .github/workflows·.github/scripts(와 .github)를 정리한다.
-// 이번에 그 폴더에서 무언가를 지웠을 때만 — 원래 비어 있던 폴더까지 손대지 않는다.
-export function pruneInstallDirs(targetRoot, plan) {
-  if (plan.workflows.length || plan.baseline?.length) pruneEmptyDirs(targetRoot, PATHS.workflowsDir);
-  if (plan.scripts.length) pruneEmptyDirs(targetRoot, PATHS.scriptsDir);
-}
 
 // selection: { workflows, scripts, readme, gitignore, versionYml } (모두 boolean).
 // 반환: 위와 동일한 키의 boolean/배열 — 실제로 제거 "대상"인지 여부(순수 함수, 아무것도 지우지 않음).
@@ -65,24 +33,11 @@ export function planUninstall(payloadRoot, targetRoot, selection) {
 // 반환: planUninstall과 동일한 형태 — 실제로 제거된 항목.
 export function runUninstall(context, payloadRoot, targetRoot, selection) {
   const plan = planUninstall(payloadRoot, targetRoot, selection);
-  const wfDir = join(targetRoot, PATHS.workflowsDir);
-  const done = [];
-  for (const name of plan.workflows) { remove(join(wfDir, name)); done.push(["remove", "workflow", name]); }
-  for (const name of plan.scripts) { remove(join(targetRoot, PATHS.scriptsDir, name)); done.push(["remove", "script", name]); }
-  removeAppFiles(targetRoot, plan.appFiles, done);
-  for (const p of plan.baseline || []) { remove(join(targetRoot, p)); done.push(["remove", "metadata", p]); }
-  pruneInstallDirs(targetRoot, plan);
-  // removeVersionSectionFromReadme/removeAutoAddedEntriesFromGitignore는 plan이 "제거 대상"으로
-  // 판단했더라도 실제로는 안전하게 포기(skip-*)할 수 있다 — 반환 상태를 그대로 신뢰하지 않고
-  // 실제 결과로 plan을 덮어써서 호출부(CLI/대화형 요약)가 거짓 성공을 보고하지 않게 한다.
-  const readmeRemoved = plan.readme && removeVersionSectionFromReadme(targetRoot) === "removed";
-  const gitignoreStatus = plan.gitignore ? removeAutoAddedEntriesFromGitignore(targetRoot) : null;
-  const gitignoreRemoved = gitignoreStatus === "removed" || gitignoreStatus === "file-deleted";
-  if (readmeRemoved) done.push(["remove", "readme", "README.md 버전 섹션"]);
-  if (gitignoreStatus) done.push(["remove", "gitignore", `.gitignore 자동 추가 항목 (${gitignoreStatus})`]);
-  if (plan.versionYml) { remove(join(targetRoot, PATHS.versionFile)); done.push(["remove", "version", PATHS.versionFile]); }
-  logRemovals(targetRoot, done);
-  return { ...plan, readme: readmeRemoved, gitignore: gitignoreRemoved };
+  const { readme, gitignore } = executeRemoval(targetRoot, plan, {
+    logOrder: ["readme", "gitignore", "version"],
+    gitignoreDetail: (status) => `.gitignore 자동 추가 항목 (${status})`,
+  });
+  return { ...plan, readme, gitignore };
 }
 
 // ── 대화형 체크리스트 흐름 ────────────────────────────────────────────

package/src/core/copy/app-files.js

@@ -0,0 +1,28 @@
+// 타입 전용 앱 파일(사용자 소유, 없을 때만 생성) 설치 — 타입 훅(planAppFiles/copyAppFiles)을 돌려 합친다.
+// 어떤 파일이 대상인지는 훅이 정하므로 여기서는 타입 이름을 알지 못한다.
+import { hooksFor, typeInfo } from "../types.js";
+
+// 읽기 전용 — dry-run이 쓴다. 반환: { created:[], kept:[] }
+export function planTypeAppFiles(context, payloadRoot, targetRoot = ".") {
+  const result = { created: [], kept: [] };
+  for (const { hook } of hooksFor(context.types || [], "planAppFiles")) {
+    const r = hook(context, payloadRoot, targetRoot);
+    result.created.push(...r.created);
+    result.kept.push(...r.kept);
+  }
+  return result;
+}
+
+// onFile(tag, action, relPath): 파일마다 호출되는 로그 콜백. 반환: { created:[], kept:[] }
+export function copyTypeAppFiles(context, payloadRoot, targetRoot = ".", onFile = () => {}) {
+  const result = { created: [], kept: [] };
+  for (const { id, hook } of hooksFor(context.types || [], "copyAppFiles")) {
+    const tag = typeInfo(id).hooks.appFilesTag ?? id;
+    const r = hook(context, payloadRoot, targetRoot);
+    for (const f of r.created) onFile(tag, "create", f);
+    for (const f of r.kept) onFile(tag, "keep", f);
+    result.created.push(...r.created);
+    result.kept.push(...r.kept);
+  }
+  return result;
+}

package/src/core/copy/workflows.js

@@ -5,7 +5,7 @@ import { join, basename } from "node:path";
 import {
   deployFilter, isDeployWorkflow, activateDeployTrigger, payloadWorkflowNames, DEFAULT_DEPLOY_STYLE, NO_DEPLOY_STYLE,
 } from "../deploy-style.js";
-import { storeWorkflowFilter } from "../flutter-options.js";
+import { typeInfo } from "../types.js";
 import { existsSync, readFileSync, writeFileSync, renameSync } from "node:fs";
 import { PATHS, PAYLOAD, typeWorkflowDirs } from "../paths.js";
 import { exists, writeText, listYamlFiles } from "../fsutil.js";
@@ -50,10 +50,45 @@ export function readSavedDeployValues(targetRoot = ".") {
 export function buildTypeRootFilter(type, deployStyle, flutterStore, available = null) {
   const filters = [];
   if (deployStyle) filters.push(deployFilter(deployStyle, available));
-  if (type === "flutter" && Array.isArray(flutterStore)) filters.push(storeWorkflowFilter(flutterStore));
+  const typeFilter = typeInfo(type)?.hooks?.workflowFilter?.({ flutterStore });
+  if (typeFilter) filters.push(typeFilter);
   return (filename) => filters.every((keep) => keep(filename));
 }
 
+// 한 타입이 설치하는 원본 디렉토리를 순서대로 돌려준다 — 타입 루트 → 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, savedValues = null }) {
@@ -211,10 +246,9 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
 
   // (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 마커가 없어 이 루프가 없어도 드러나지 않았지만,
@@ -297,47 +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 available = payloadWorkflowNames(payloadRoot);
-  const keepDeploy = deployFilter(deployStyle, available);
-  const collect = (srcDir, envOpts, type, skipFile = () => false, filter = null) => {
-    const c = classify(srcDir, workflowsDir, envOpts, srcText, baseline, filter);
-    for (const f of c.changed) { if (!skipFile(f)) conflicts.push({ filename: f, type }); }
-    for (const f of c.removed) { if (!skipFile(f)) removed.push({ filename: f, type }); }
-  };
+  const values = context.envValues || new Map();
+  const useDefaults = context.envUseDefaults !== false;
 
-  const commonDir = join(projectTypesDir, "common");
-  if (exists(commonDir)) {
-    collect(commonDir, {
-      type: "common", projectPath: ".", repoName, resolvers,
-      values: context.envValues || new Map(), useDefaults: context.envUseDefaults !== false,
-    }, "common",
-      (f) => branchMode === "trunk-based" && TRUNK_BASED_EXCLUDED.has(f));
-  }
-
-  for (const type of types) {
+  for (const { srcDir, type, filter } of workflowSources(context, payloadRoot, { deployStyle, available })) {
     // 복사 엔진과 같은 값(이번 답변 포함)으로 분류해야 결정 목록이 실제 처리 대상과 맞는다.
-    const envOpts = {
-      type, projectPath: paths.get(type) || ".", repoName, resolvers, savedValues: saved.get(type) || null,
-      values: context.envValues || new Map(), useDefaults: context.envUseDefaults !== false,
-    };
-    const [typeDir, serverDeployDir] = typeWorkflowDirs(payloadRoot, type);
-    if (exists(typeDir)) {
-      collect(typeDir, envOpts, type, () => false, buildTypeRootFilter(type, deployStyle, flutterStore, available));
-    }
-    if (exists(serverDeployDir) && deployStyle !== NO_DEPLOY_STYLE) {
-      collect(serverDeployDir, envOpts, type, () => false, keepDeploy);
-    }
+    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) conflicts.push({ filename: f, type });
+    for (const f of c.removed) removed.push({ filename: f, type });
   }
   return { conflicts, removed };
 }
@@ -364,37 +377,23 @@ export async function copyWorkflowsInteractive(context, payloadRoot, targetRoot
 
 function copyWorkflowsForType(type, payloadRoot, workflowsDir, ctx, counters) {
   const { deployStyle = "", flutterStore = null, envOptsFor, collectAsks = null, dirCtx } = ctx;
-  const keepDeploy = deployFilter(deployStyle, dirCtx.available);
-  const keepTypeRoot = buildTypeRootFilter(type, deployStyle, flutterStore, dirCtx.available);
-  const { srcText, baselineTargets } = dirCtx;
-  const [typeDir, serverDeployDir] = typeWorkflowDirs(payloadRoot, 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·react/next처럼 서버 배포 워크플로우가 server-deploy 없이
-  // 타입 루트에 바로 있는 타입도 있어, 타입 루트에도 같은 배포 방식 필터를 건다.
-  if (exists(typeDir)) {
-    const c = processDir(typeDir, workflowsDir, envOpts, dirCtx, counters, keepTypeRoot);
-    untouched.push(...c.unchanged, ...c.localOnly);
-  }
-
-  // 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;          // 건너뛴 파일 제외
       // unchanged/localOnly와 치환 마커가 이미 없는 유지본은 다시 치환하지 않는다. 대신 deploy 블록이
       // 사라지지 않도록 저장값(없으면 기본값)으로 ask 값만 수집한다 — 파일은 건드리지 않는다.
@@ -411,44 +410,24 @@ function copyWorkflowsForType(type, payloadRoot, 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 saved = readSavedDeployValues(targetRoot);
   const available = payloadWorkflowNames(payloadRoot);
-  const branchMode = context.branches?.mode || "pr-flow";
   // 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, savedValues: saved.get(type) || null };
-    const [typeDir, serverDeployDir] = typeWorkflowDirs(payloadRoot, type);
-    if (exists(typeDir)) {
-      merge(classify(typeDir, workflowsDir, envOpts, srcText, baseline, buildTypeRootFilter(type, deployStyle, flutterStore, available)), type);
-    }
-
-    if (exists(serverDeployDir) && deployStyle !== NO_DEPLOY_STYLE) {
-      merge(classify(serverDeployDir, workflowsDir, envOpts, srcText, baseline, deployFilter(deployStyle, available)), type);
+      for (const filename of result[bucket]) plan[bucket].push({ filename, type });
     }
   }
 

package/src/core/detect.js

@@ -81,14 +81,60 @@ export function detectVersionFromFiles({ read, readJson, list, gitTag, warn, hin
   };
   // 줄 시작 앵커가 없으면 ext.kotlin_version 같은 의존성 버전 변수가 먼저 걸린다.
   // 따옴표로 감싼 값만 본다 — 릴리스 때 동기화가 고칠 수 있는 형태가 이것뿐이다.
-  const gradleRe = /^\s*version\s*=\s*(["'])([^"'\n]*)\1/;
+  const gradleRe = /^(\s*)version\s*=\s*(["'])([^"'\n]*)\2/;
+  // 들여쓰지 않은 `version =`을 우선하고, 없을 때만 allprojects/subprojects 블록 안의 들여쓴 줄을 쓴다.
+  // `node { version = '20.11.0' }` 같은 플러그인 설정 블록이 프로젝트 버전으로 읽히면 첫 릴리스에서 버전이 뛴다.
+  // 릴리스 때의 version_manager.py와 같은 규칙이어야 한다.
+  // 주석을 떼고 따옴표 안 글자는 공백으로 바꾼다 — url 'https://…'의 `//`나 문자열 속 중괄호가
+  // 블록 깊이 계산을 흐트러뜨리지 않게 한다. version_manager.py와 같은 규칙이어야 한다.
+  // quote는 이 줄이 시작될 때 열려 있던 따옴표다. 삼중따옴표(""" ''')는 여러 줄에 걸치므로
+  // { code, quote }로 줄 끝에서 열려 있는 따옴표를 돌려줘 다음 줄이 이어받게 한다.
+  // 한 줄짜리 따옴표는 줄 끝에서 닫힌 것으로 본다.
+  const gradleCode = (line, quote) => {
+    let out = "";
+    for (let i = 0; i < line.length;) {
+      const ch = line[i];
+      if (quote) {
+        if (ch === "\\" && i + 1 < line.length) { out += "  "; i += 2; continue; }
+        if (line.startsWith(quote, i)) { out += quote; i += quote.length; quote = ""; continue; }
+        out += " ";
+      } else if (line.startsWith('"""', i) || line.startsWith("'''", i)) {
+        quote = line.slice(i, i + 3); out += quote; i += 3; continue;
+      } else if (ch === "'" || ch === '"') { quote = ch; out += ch; }
+      else if (line.startsWith("//", i)) break;
+      else out += ch;
+      i++;
+    }
+    return { code: out, quote: quote.length === 3 ? quote : "" };
+  };
+  const gradleVersion = (content) => {
+    const top = [], shared = [], stack = [];
+    let quote = ""; // 여러 줄 문자열 안이면 그 따옴표. 문자열 속 줄은 코드가 아니다
+    for (const line of (content || "").split("\n")) {
+      const m = quote ? null : line.match(gradleRe);
+      if (m) {
+        if (m[1] === "") top.push(m[3]);
+        else if (stack.some((b) => b === "allprojects" || b === "subprojects")) shared.push(m[3]);
+      }
+      const r = gradleCode(line, quote);
+      quote = r.quote;
+      const code = r.code;
+      const name = code.match(/(\w+)\s*\{[^{}]*$/)?.[1] ?? "";
+      for (const ch of code) {
+        if (ch === "{") stack.push(name);
+        else if (ch === "}") stack.pop();
+      }
+    }
+    for (const v of top.length ? top : shared) { const c = coreVersion(v); if (c) return c; }
+    return null;
+  };
   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),
+    gradle: () => gradleVersion(read("build.gradle")),
+    gradleKts: () => gradleVersion(read("build.gradle.kts")),
     pom: () => versionFromPom(read("pom.xml")),
     pubspec: () => grab(read("pubspec.yaml"), /^version:\s*([^\s#]+)/),
     pyproject: () => versionFromPyproject(read("pyproject.toml")),

package/src/core/flutter-doctor.js

@@ -0,0 +1,49 @@
+// Flutter 진단 항목 — doctor가 타입 훅(doctorChecks)으로 호출한다.
+import { existsSync, readFileSync } from "node:fs";
+import { join, posix } from "node:path";
+import { PATHS } from "./paths.js";
+import { STORE_PLATFORMS, STORE_APP_FILES, parseStoreList, storeAppFilesFor } from "./flutter-options.js";
+import { inferInstalledStores } from "./installed-stores.js";
+
+const PLATFORM_ROW_NAME = { android: "Flutter Android 배포 파일", ios: "Flutter iOS 배포 파일" };
+const PLACEHOLDER_RE = /__[A-Z][A-Z0-9_]*__/g; // 감지 규칙은 ExportOptions.plist 템플릿·IOS-TESTFLIGHT 검증과 동일
+const EXPORT_OPTIONS_REL = STORE_APP_FILES.ios.find((rel) => rel.endsWith("ExportOptions.plist"));
+
+// Flutter 스토어 배포 진단 — 선택한 플랫폼의 필수 파일과 ExportOptions.plist 플레이스홀더.
+// 스토어 시크릿 등록 여부는 이번 범위 밖이다. 반환: doctor 결과 행 배열.
+export function flutterStoreChecks(cwd, existing, { docs }) {
+  const saved = existing.options.flutterStore == null ? null : parseStoreList(existing.options.flutterStore);
+  // 저장값 없는 기존 설치는 설치된 스토어 워크플로우로 추론한다 (interactive와 같은 규칙).
+  const stores = saved ?? inferInstalledStores(join(cwd, PATHS.workflowsDir));
+  const flutterRoot = existing.paths.get("flutter") || ".";
+  const rows = [];
+
+  for (const platform of STORE_PLATFORMS.filter((p) => stores.includes(p))) {
+    const files = storeAppFilesFor([platform]).map((rel) => posix.join(flutterRoot, rel));
+    const missing = files.filter((file) => !existsSync(join(cwd, file)));
+    const head = { name: PLATFORM_ROW_NAME[platform], purpose: "fastlane 스토어 업로드에 필요한 파일" };
+    rows.push(missing.length
+      ? {
+        ...head, status: "WARN", value: `없는 파일: ${missing.join(", ")}`,
+        impact: ["이 파일이 없으면 스토어 배포 워크플로우가 fastlane 단계에서 실패합니다."],
+        actions: ["마법사를 다시 실행하면 없는 파일만 새로 만들어 줍니다 (이미 있는 파일은 덮어쓰지 않음)"],
+        doc: docs.flutterStore,
+      }
+      : { ...head, status: "OK", value: `${files.length}개 있음` });
+  }
+
+  const plistPath = posix.join(flutterRoot, EXPORT_OPTIONS_REL);
+  if (stores.includes("ios") && existsSync(join(cwd, plistPath))) {
+    const head = { name: "ExportOptions.plist", purpose: "iOS 서명·내보내기 설정" };
+    const left = [...new Set(readFileSync(join(cwd, plistPath), "utf8").match(PLACEHOLDER_RE) ?? [])];
+    rows.push(left.length
+      ? {
+        ...head, status: "WARN", value: `채워지지 않은 값: ${left.join(", ")}`,
+        impact: ["채우지 않으면 IOS-TESTFLIGHT 워크플로우가 ExportOptions.plist 검증 단계에서 중단됩니다."],
+        actions: [`${plistPath} 의 플레이스홀더를 실제 값(Team ID · 번들 ID · 프로비저닝 프로파일 이름)으로 바꾸세요`],
+        doc: docs.flutterStore,
+      }
+      : { ...head, status: "OK", value: "플레이스홀더 없음" });
+  }
+  return rows;
+}

package/src/core/flutter-hooks.js

@@ -0,0 +1,29 @@
+// Flutter 타입 훅 — types.js 레지스트리의 flutter 항목이 가리키는 구현 모음.
+// 공통 코드는 flutter를 직접 알지 못하고 훅 이름으로만 호출한다(각 훅의 계약은 types.js 머리말 참고).
+import { storeWorkflowFilter, cleanupDeselectedStoreWorkflows } from "./flutter-options.js";
+import { planFlutterAppFiles, copyFlutterAppFiles } from "./copy/flutter-app.js";
+import { flutterStoreChecks } from "./flutter-doctor.js";
+
+// 저장값이 없으면 그 상태에서 실제로 적용되는 동작을 함께 알린다.
+function statusLabels(options) {
+  return [
+    ` env_mode=${options.envMode ?? "미설정(dotenv 유지)"}`,
+    ` flutter_store=${options.flutterStore ?? "미설정(둘 다 설치)"}`,
+    ` android_deploy_mode=${options.androidDeployMode ?? "미설정(store_only)"}`,
+    ` ios_deploy_mode=${options.iosDeployMode ?? "미설정(store_only)"}`,
+  ].join("");
+}
+
+export const flutterHooks = {
+  // 스토어 대상이 배열일 때만 스토어 워크플로우 필터를 건다(null=미결정 → 전부 설치).
+  workflowFilter: ({ flutterStore }) => (Array.isArray(flutterStore) ? storeWorkflowFilter(flutterStore) : null),
+  // 선택 해제된 스토어 워크플로우 정리 — 대상이 미결정(null)이면 아무것도 지우지 않는다.
+  cleanupWorkflows: (workflowsDir, installed, context, baseline, opts) => (Array.isArray(context.flutterStore)
+    ? cleanupDeselectedStoreWorkflows(workflowsDir, installed, context.flutterStore, baseline, opts)
+    : { removed: [], backedUp: [] }),
+  appFilesTag: "flutter-app",
+  planAppFiles: planFlutterAppFiles,
+  copyAppFiles: copyFlutterAppFiles,
+  statusLabels,
+  doctorChecks: flutterStoreChecks,
+};

package/src/core/removal-exec.js

@@ -0,0 +1,67 @@
+// uninstall·purge 공통 삭제 실행부 — 두 명령은 옵션을 삭제 계획으로 바꾸기만 하고,
+// 실제 삭제와 기록은 여기서 한 번에 처리한다. 대상 판별은 removal-plan.js(읽기 전용)가 맡는다.
+import { join, posix } from "node:path";
+import { readdirSync, rmdirSync } from "node:fs";
+import { PATHS } from "./paths.js";
+import { remove } from "./fsutil.js";
+import { removeVersionSectionFromReadme } from "./copy/readme.js";
+import { removeAutoAddedEntriesFromGitignore } from "./copy/gitignore.js";
+import { logRemovals } from "./logger.js";
+
+// 파일을 지운 뒤 비게 된 상위 폴더를 레포 루트 직전까지 정리한다(마법사가 만든 fastlane/ 등).
+// 비어 있지 않은 폴더를 만나면 멈추므로 사용자 파일이 남은 폴더는 건드리지 않는다.
+export function pruneEmptyDirs(targetRoot, relDir) {
+  let rel = relDir;
+  while (rel && rel !== "." && rel !== "/") {
+    const abs = join(targetRoot, rel);
+    try {
+      if (readdirSync(abs).length) break;
+      rmdirSync(abs);
+    } catch { break; }
+    rel = posix.dirname(rel);
+  }
+}
+
+// Flutter 앱 파일 제거 — 미수정분만 plan에 들어오므로 그대로 지우고 빈 폴더를 정리한다.
+// 로그는 삭제가 끝난 뒤 한꺼번에 남기므로 기록할 항목을 done에 모은다.
+export function removeAppFiles(targetRoot, appFiles, done = []) {
+  for (const rel of appFiles) {
+    remove(join(targetRoot, rel));
+    pruneEmptyDirs(targetRoot, posix.dirname(rel));
+    done.push(["remove", "flutter-app", rel]);
+  }
+}
+
+// 설치물을 지운 뒤 비게 된 .github/workflows·.github/scripts(와 .github)를 정리한다.
+// 이번에 그 폴더에서 무언가를 지웠을 때만 — 원래 비어 있던 폴더까지 손대지 않는다.
+export function pruneInstallDirs(targetRoot, plan) {
+  if (plan.workflows.length || plan.baseline?.length) pruneEmptyDirs(targetRoot, PATHS.workflowsDir);
+  if (plan.scripts.length) pruneEmptyDirs(targetRoot, PATHS.scriptsDir);
+}
+
+// plan: { workflows, scripts, appFiles, baseline, versionYml, readme, gitignore, changelog } — 모두 "삭제 대상" 여부/목록.
+// options.logOrder: 뒤쪽 항목(version·readme·gitignore·changelog)의 기록 순서 — 명령마다 기존 순서를 유지한다.
+// options.gitignoreDetail(status): .gitignore 기록 문구. null을 돌려주면 기록하지 않는다.
+// 반환: 실제로 제거된 결과 — readme/gitignore는 plan이 대상으로 봤어도 안전하게 포기(skip-*)될 수 있어 실제 결과로 덮어쓴다.
+export function executeRemoval(targetRoot, plan, { logOrder, gitignoreDetail }) {
+  const wfDir = join(targetRoot, PATHS.workflowsDir);
+  const done = [];
+  for (const name of plan.workflows) { remove(join(wfDir, name)); done.push(["remove", "workflow", name]); }
+  for (const name of plan.scripts) { remove(join(targetRoot, PATHS.scriptsDir, name)); done.push(["remove", "script", name]); }
+  removeAppFiles(targetRoot, plan.appFiles, done);
+  for (const p of plan.baseline || []) { remove(join(targetRoot, p)); done.push(["remove", "metadata", p]); }
+  pruneInstallDirs(targetRoot, plan);
+
+  const entries = { version: [], readme: [], gitignore: [], changelog: [] };
+  const readme = !!plan.readme && removeVersionSectionFromReadme(targetRoot) === "removed";
+  const gitignoreStatus = plan.gitignore ? removeAutoAddedEntriesFromGitignore(targetRoot) : null;
+  const gitignore = gitignoreStatus === "removed" || gitignoreStatus === "file-deleted";
+  if (plan.versionYml) { remove(join(targetRoot, PATHS.versionFile)); entries.version.push(["remove", "version", PATHS.versionFile]); }
+  for (const f of plan.changelog || []) { remove(join(targetRoot, f)); entries.changelog.push(["remove", "changelog", f]); }
+  if (readme) entries.readme.push(["remove", "readme", "README.md 버전 섹션"]);
+  const detail = gitignoreStatus && gitignoreDetail(gitignoreStatus);
+  if (detail) entries.gitignore.push(["remove", "gitignore", detail]);
+  for (const k of logOrder) done.push(...entries[k]);
+  logRemovals(targetRoot, done);
+  return { readme, gitignore };
+}

package/src/core/types.js

@@ -1,3 +1,5 @@
+import { flutterHooks } from "./flutter-hooks.js";
+
 // 프로젝트 타입 레지스트리 — 타입별 지식(감지 마커, 감지 순서, 버전·빌드 번호 파일)을 한 곳에 둔다.
 // 타입 목록·마커 맵·감지 체인은 모두 이 표에서 만들어지므로, 새 타입은 여기에 한 줄을 더하는 것에서 시작한다.
 // (릴리스 시점의 버전 파일 쓰기는 payload/scripts/version_manager.py가 따로 담당한다.)
@@ -13,6 +15,16 @@
 //   versionSources     설치 시 버전을 읽을 파일 키(detect.js의 sources) — 주 타입일 때 이 순서로 먼저 읽는다.
 //   buildNumberSource  모바일 빌드 번호를 읽을 파일 키(detect.js의 detectBuildNumberFromFiles).
 //   singleServerCd     배포 방식 변형 없이 서버 배포 CD가 하나뿐일 때 그 워크플로우 파일명.
+//   hooks              타입 전용 동작. 없는 훅은 "할 일 없음"이라 공통 코드는 hooksFor()로 있는 것만 호출한다.
+//     workflowFilter(context)                         타입 루트 워크플로우 파일 필터(filename → bool) 또는 null
+//     cleanupWorkflows(dir, installed, context, baseline, opts)
+//                                                     선택에서 빠진 워크플로우 정리 → { removed, backedUp }
+//     planAppFiles / copyAppFiles(context, payloadRoot, targetRoot)
+//                                                     사용자 소유 앱 파일(없을 때만 생성) 계획/복사 → { created, kept }
+//     appFilesTag                                     앱 파일 복사 로그의 분류 이름
+//     statusLabels(options)                           status 옵션 줄에 덧붙일 문자열
+//     doctorChecks(cwd, existing, { docs })           doctor 진단 행 배열
+// (타입 전용 옵션 해석·CLI 플래그·version.yml 블록·대화형 질문은 아직 각 호출부에 남아 있다.)
 export const TYPES = [
   {
     id: "spring",
@@ -26,6 +38,7 @@ export const TYPES = [
     detectBy: "markers", detectOrder: 1,
     versionSources: ["pubspec"],
     buildNumberSource: "pubspec",
+    hooks: flutterHooks,
   },
   {
     id: "next",
@@ -91,6 +104,16 @@ const BY_ID = new Map(TYPES.map((t) => [t.id, t]));
 // 알 수 없는 타입은 undefined — 호출부가 각자의 기본값을 정한다.
 export const typeInfo = (id) => BY_ID.get(id);
 
+// types 중 훅 name을 가진 것만 [{ id, hook }]으로 — 주어진 타입 순서를 유지한다.
+export function hooksFor(types, name) {
+  const found = [];
+  for (const id of types) {
+    const hook = BY_ID.get(id)?.hooks?.[name];
+    if (hook !== undefined) found.push({ id, hook });
+  }
+  return found;
+}
+
 // 표시 순서 그대로의 타입 이름 목록
 // VALID_TYPES·ALL_TYPES가 같은 배열을 공유하므로 한쪽에서 바꿔 다른 쪽이 오염되지 않게 고정한다.
 export const TYPE_IDS = Object.freeze(TYPES.map((t) => t.id));