project-auto-wizard 0.1.6 → 0.1.8

package/src/commands/uninstall.js

@@ -0,0 +1,129 @@
+// uninstall 모드 — revert(payload 파일명 일치분)보다 넓게, README/.gitignore/version.yml까지 선택적으로 제거.
+// 대화형 체크리스트 또는 --force + --purge-* 로 항목별 opt-in. revert.js는 건드리지 않고 읽기 전용으로만 재사용한다.
+import { join } from "node:path";
+import { existsSync, renameSync } from "node:fs";
+import { PATHS } from "../core/paths.js";
+import { remove } from "../core/fsutil.js";
+import { planRevert } from "./revert.js";
+import { removeVersionSectionFromReadme, hasVersionSection } from "../core/copy/readme.js";
+import { removeAutoAddedEntriesFromGitignore, hasAutoAddedEntries } from "../core/copy/gitignore.js";
+import { CANCEL } from "../ui/prompts.js";
+
+// selection: { workflows, scripts, coderabbit, readme, gitignore, versionYml } (모두 boolean).
+// 반환: 위와 동일한 키의 boolean/배열 — 실제로 제거 "대상"인지 여부(순수 함수, 아무것도 지우지 않음).
+export function planUninstall(payloadRoot, targetRoot, selection) {
+  const revertPlan = planRevert(payloadRoot, targetRoot);
+  return {
+    workflows: selection.workflows ? revertPlan.workflows : [],
+    scripts: selection.scripts ? revertPlan.scripts : [],
+    coderabbit: selection.coderabbit ? revertPlan.coderabbit : false,
+    readme: selection.readme ? hasVersionSection(targetRoot) : false,
+    gitignore: selection.gitignore ? hasAutoAddedEntries(targetRoot) : false,
+    versionYml: selection.versionYml ? existsSync(join(targetRoot, PATHS.versionFile)) : false,
+  };
+}
+
+// 반환: planUninstall과 동일한 형태 — 실제로 제거된 항목.
+export function runUninstall(context, payloadRoot, targetRoot, selection) {
+  const plan = planUninstall(payloadRoot, targetRoot, selection);
+  const wfDir = join(targetRoot, PATHS.workflowsDir);
+  for (const name of plan.workflows) remove(join(wfDir, name));
+  for (const name of plan.scripts) remove(join(targetRoot, PATHS.scriptsDir, name));
+  if (plan.coderabbit) {
+    const cr = join(targetRoot, ".coderabbit.yaml");
+    remove(cr);
+    if (existsSync(cr + ".bak")) renameSync(cr + ".bak", cr);
+  }
+  // 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 (plan.versionYml) remove(join(targetRoot, PATHS.versionFile));
+  return { ...plan, readme: readmeRemoved, gitignore: gitignoreRemoved };
+}
+
+// ── 대화형 체크리스트 흐름 ────────────────────────────────────────────
+const ITEM_DEFS = [
+  { key: "workflows", label: "워크플로우 (.github/workflows/PROJECT-*.yaml)" },
+  { key: "scripts", label: "스크립트 (.github/scripts/*.py)" },
+  { key: "coderabbit", label: ".coderabbit.yaml" },
+  { key: "readme", label: "README.md 버전 섹션 (AUTO-VERSION-SECTION)" },
+  { key: "gitignore", label: ".gitignore 자동 추가 항목" },
+  { key: "versionYml", label: "version.yml (버전/브랜치 설정 전체)" },
+];
+
+// 기본 체크 상태 — 설치 시 옵션(nexus/secret-backup/coderabbit)이 opt-in인 것과 대칭으로,
+// 여기서는 "안전 삭제" 3종만 기본 체크하고 나머지(readme/gitignore/versionYml)는 opt-in.
+export const SAFE_ITEMS = ["workflows", "scripts", "coderabbit"];
+
+function detectAvailableItems(payloadRoot, targetRoot) {
+  const revertPlan = planRevert(payloadRoot, targetRoot);
+  const presence = {
+    workflows: revertPlan.workflows.length > 0,
+    scripts: revertPlan.scripts.length > 0,
+    coderabbit: revertPlan.coderabbit,
+    readme: hasVersionSection(targetRoot),
+    gitignore: hasAutoAddedEntries(targetRoot),
+    versionYml: existsSync(join(targetRoot, PATHS.versionFile)),
+  };
+  return ITEM_DEFS.filter((d) => presence[d.key]).map((d) => ({ value: d.key, label: d.label }));
+}
+
+function toSelection(checkedKeys) {
+  const set = new Set(checkedKeys);
+  return {
+    workflows: set.has("workflows"), scripts: set.has("scripts"), coderabbit: set.has("coderabbit"),
+    readme: set.has("readme"), gitignore: set.has("gitignore"), versionYml: set.has("versionYml"),
+  };
+}
+
+function summarizeSelection(selection) {
+  const labelOf = Object.fromEntries(ITEM_DEFS.map((d) => [d.key, d.label]));
+  const chosen = Object.keys(selection).filter((k) => selection[k]).map((k) => `- ${labelOf[k]}`);
+  return chosen.length ? chosen.join("\n") : "(선택된 항목 없음)";
+}
+
+function summarizeResult(result) {
+  const lines = [];
+  if (result.workflows.length) lines.push(`워크플로우 ${result.workflows.length}개 제거`);
+  if (result.scripts.length) lines.push(`스크립트 ${result.scripts.length}개 제거`);
+  if (result.coderabbit) lines.push(".coderabbit.yaml 제거");
+  if (result.readme) lines.push("README.md 버전 섹션 제거");
+  if (result.gitignore) lines.push(".gitignore 자동 추가 항목 제거");
+  if (result.versionYml) lines.push("version.yml 제거");
+  return lines.length ? lines.join("\n") : "제거된 항목이 없습니다.";
+}
+
+// io 계약: engineIo.multiselect({message,options,initialValues}), askYesNo(msg,def),
+// note(text,title)?, cancelMessage(text)? — src/ui/prompts.js가 실물, 테스트는 스텁 주입.
+export async function runUninstallFlow(payloadRoot, targetRoot, io) {
+  const available = detectAvailableItems(payloadRoot, targetRoot);
+  if (available.length === 0) {
+    io.note?.("제거할 항목이 없습니다.", "완전 삭제");
+    return null;
+  }
+
+  const checked = await io.engineIo.multiselect({
+    message: "삭제할 항목을 선택하세요 (Space 토글, Enter 확정)",
+    options: available,
+    initialValues: available.map((o) => o.value).filter((v) => SAFE_ITEMS.includes(v)),
+  });
+  if (checked === CANCEL || !Array.isArray(checked) || checked.length === 0) {
+    io.cancelMessage?.("완전 삭제를 취소했습니다.");
+    return null;
+  }
+
+  const selection = toSelection(checked);
+  io.note?.(summarizeSelection(selection), "삭제 예정 항목");
+  const ok = await io.askYesNo("정말 삭제할까요? 되돌릴 수 없습니다.", false);
+  if (ok !== true) {
+    io.cancelMessage?.("완전 삭제를 취소했습니다.");
+    return null;
+  }
+
+  const result = runUninstall({}, payloadRoot, targetRoot, selection);
+  io.note?.(summarizeResult(result), "완전 삭제 완료");
+  return result;
+}

package/src/commands/version.js

@@ -14,7 +14,8 @@ import { ensureGitignore } from "../core/copy/gitignore.js";
 export function runVersion(context, payloadRoot, targetRoot = ".") {
   const { version, types = [], paths = new Map(), branch = "main", versionCode = 1,
     now, today, templateVersion = "unknown",
-    includeNexus = false, includeSecretBackup = false, includeCodeRabbit = false } = context;
+    includeNexus = false, includeSecretBackup = false, includeCodeRabbit = false,
+    includeSemverAuto } = context;
 
   const pathMarkers = new Map();
   for (const [t] of paths) pathMarkers.set(t, markerForType(t));
@@ -23,7 +24,7 @@ export function runVersion(context, payloadRoot, targetRoot = ".") {
     buildVersionYml({
       templateText: readVersionYmlTemplate(payloadRoot),
       version, types, paths, pathMarkers, branch, branches: context.branches, versionCode, now, today,
-      templateOptions: { templateVersion, includeNexus, includeSecretBackup, includeCodeRabbit: includeCodeRabbit === true, optionsDate: today },
+      templateOptions: { templateVersion, includeNexus, includeSecretBackup, includeCodeRabbit: includeCodeRabbit === true, includeSemverAuto: includeSemverAuto !== false, optionsDate: today },
     }));
   addVersionSectionToReadme(version, targetRoot);
   copyScripts(payloadRoot, targetRoot);

package/src/context.js

@@ -18,6 +18,7 @@ export function createContext(overrides = {}) {
     includeNexus: null,      // null=미설정, true/false=명시
     includeSecretBackup: null,
     includeCodeRabbit: null, // CodeRabbit opt-in (기본 false — version.yml options.coderabbit에 기록)
+    includeSemverAuto: null, // null=미설정(다운스트림에서 true로 해석), true/false=명시
     templateVersion: "",
     deployValues: new Map(), // "type.KEY" -> value
     counters: {},

package/src/core/copy/gitignore.js

@@ -1,6 +1,6 @@
 // .gitignore 보장 (.sh ensure_gitignore + normalize/check 등가) — template_integrator.sh 3996~4111.
 import { join } from "node:path";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 
 const REQUIRED_ENTRIES = ["/.idea", "/.claude/settings.local.json"];
 
@@ -53,3 +53,55 @@ export function ensureGitignore(targetRoot = ".") {
   writeFileSync(p, content);
   return { created: false, added: toAdd };
 }
+
+// ensureGitignore가 기존 파일에 배너 블록을 추가할 때 항상 이 정확한 시퀀스로 시작한다
+// (빈 줄 하나 + 3줄 배너). 배너 직후, REQUIRED_ENTRIES와 일치하는 라인이 연속되는 동안만
+// "마법사가 추가한 항목"이다 — 그 뒤에 사용자가 나중에 추가한 항목은 절대 건드리지 않는다.
+const BANNER =
+  "\n" +
+  "# ====================================================================\n" +
+  "# project-auto-wizard: Auto-added entries\n" +
+  "# ====================================================================\n";
+
+// .gitignore에 마법사가 추가한 항목이 있는지 확인 (체크리스트 노출 판단용).
+// 두 케이스: (1) 원래 없던 파일을 통째로(또는 그 뒤에 사용자가 이어 쓴 형태로) 새로 만든 경우
+// (2) 기존 파일에 배너 블록을 붙인 경우.
+export function hasAutoAddedEntries(targetRoot = ".") {
+  const p = join(targetRoot, ".gitignore");
+  if (!existsSync(p)) return false;
+  const content = readFileSync(p, "utf8");
+  return content.startsWith(NEW_FILE_CONTENT) || content.includes(BANNER);
+}
+
+// 반환: 'removed' | 'file-deleted' | 'skip-no-gitignore' | 'skip-not-found'
+export function removeAutoAddedEntriesFromGitignore(targetRoot = ".") {
+  const p = join(targetRoot, ".gitignore");
+  if (!existsSync(p)) return "skip-no-gitignore";
+  const content = readFileSync(p, "utf8");
+
+  // 원래 파일이 없었는데 마법사가 통째로 만든 경우 — 그 뒤에 사용자가 이어서 추가한 내용만 보존.
+  if (content.startsWith(NEW_FILE_CONTENT)) {
+    const remainder = content.slice(NEW_FILE_CONTENT.length);
+    if (remainder === "") {
+      rmSync(p);
+      return "file-deleted";
+    }
+    writeFileSync(p, remainder);
+    return "removed";
+  }
+
+  // 기존 파일에 배너 블록이 붙은 경우 — 배너 직후 REQUIRED_ENTRIES와 일치하는 라인이 연속되는
+  // 동안만 제거하고, 그 뒤(사용자가 나중에 추가한 항목)는 그대로 둔다.
+  const idx = content.indexOf(BANNER);
+  if (idx === -1) return "skip-not-found";
+  const afterBanner = idx + BANNER.length;
+  const lines = content.slice(afterBanner).split("\n");
+  let consumed = 0;
+  for (const line of lines) {
+    const isKnownEntry = REQUIRED_ENTRIES.some((e) => normalizeGitignoreEntry(line) === normalizeGitignoreEntry(e));
+    if (!isKnownEntry) break;
+    consumed += line.length + 1; // +1: split이 삼킨 "\n"
+  }
+  writeFileSync(p, content.slice(0, idx) + content.slice(afterBanner + consumed));
+  return "removed";
+}

package/src/core/copy/readme.js

@@ -1,6 +1,6 @@
 // README 버전 섹션 추가 (.sh add_version_section_to_readme 등가) — template_integrator.sh 2145~2181.
 import { join } from "node:path";
-import { existsSync, readFileSync, appendFileSync } from "node:fs";
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
 
 const MARKER = "<!-- AUTO-VERSION-SECTION";
 // ## (최신 버전|최신버전|Version|버전) : vX.Y.Z (대소문자 무시)
@@ -28,3 +28,54 @@ export function addVersionSectionToReadme(version, targetRoot = ".") {
   appendFileSync(p, section);
   return "added";
 }
+
+// addVersionSectionToReadme가 항상 파일 맨 끝에 붙이는 접두/접미 시퀀스.
+// 접두(SECTION_PREFIX)가 있으면 마법사가 append한 "블록"이다 — 이 블록은 항상 SECTION_TAIL
+// 라인으로 끝나므로, 그 지점까지만 잘라내야 그 뒤에 사용자가 나중에 덧붙인 내용(라이선스 절 등)을
+// 지우지 않는다("파일 끝까지" 자르면 사용자 콘텐츠가 소실된다).
+const SECTION_PREFIX = "\n---\n\n" + MARKER;
+const SECTION_TAIL = "[전체 버전 기록 보기](CHANGELOG.md)\n";
+// PROJECT-COMMON-README-VERSION-UPDATE.yaml(설치되는 CI)은 설치 시점에 이미 사용자가 자기 버전
+// 라인을 갖고 있던 README(addVersionSectionToReadme가 'skip-version-line'으로 건너뛴 경우)에는
+// '---' 구분자 없이 마커 주석 한 줄만 그 버전 라인 위에 끼워넣는다. 이 경우 버전 라인 자체는
+// 사용자 소유이므로 지우지 않고 마커 주석 한 줄만 제거한다.
+const MARKER_LINE = "<!-- AUTO-VERSION-SECTION: DO NOT EDIT MANUALLY -->\n";
+
+// README.md에 마법사(또는 설치된 CI)가 추가한 흔적이 있는지 확인 (체크리스트 노출 판단용).
+export function hasVersionSection(targetRoot = ".") {
+  const p = join(targetRoot, "README.md");
+  if (!existsSync(p)) return false;
+  const content = readFileSync(p, "utf8");
+  return content.includes(SECTION_PREFIX) || content.includes(MARKER_LINE);
+}
+
+// 반환: 'removed' | 'skip-no-readme' | 'skip-no-marker' | 'skip-unexpected-format'
+export function removeVersionSectionFromReadme(targetRoot = ".") {
+  const p = join(targetRoot, "README.md");
+  if (!existsSync(p)) return "skip-no-readme";
+  const content = readFileSync(p, "utf8");
+
+  const idx = content.indexOf(SECTION_PREFIX);
+  if (idx !== -1) {
+    // 마법사가 append한 전체 블록 케이스 — SECTION_TAIL 라인까지만 잘라내고 그 이후는 보존한다.
+    // tail을 못 찾거나(사용자가 그 줄을 지웠다면), 위저드 블록치고 너무 먼 곳에서 발견되면
+    // (사용자가 같은 문구를 자기 문서 어딘가로 옮겨 적은 경우) 그 사이 사용자 콘텐츠까지
+    // 지워버릴 수 있으므로 어디까지가 "마법사 구간"인지 확신할 수 없어 안전하게 포기한다.
+    // 위저드 블록은 버전 문자열이 길어져도 수백 바이트를 넘지 않는다.
+    const MAX_SECTION_LENGTH = 300;
+    const tailIdx = content.indexOf(SECTION_TAIL, idx);
+    if (tailIdx === -1 || tailIdx > idx + MAX_SECTION_LENGTH) return "skip-unexpected-format";
+    const cutEnd = tailIdx + SECTION_TAIL.length;
+    writeFileSync(p, content.slice(0, idx) + content.slice(cutEnd));
+    return "removed";
+  }
+
+  const markerIdx = content.indexOf(MARKER_LINE);
+  if (markerIdx !== -1) {
+    // CI가 사용자의 기존 버전 라인 위에 마커만 끼워넣은 케이스 — 버전 라인은 건드리지 않는다.
+    writeFileSync(p, content.slice(0, markerIdx) + content.slice(markerIdx + MARKER_LINE.length));
+    return "removed";
+  }
+
+  return "skip-no-marker";
+}

package/src/core/copy/workflows.js

@@ -231,3 +231,59 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
     }
   }
 }
+
+// 전체 워크플로우 분류(common + 타입별 + server-deploy + nexus opt-in) — status/dry-run 공용.
+// listWorkflowConflicts와 달리 common 디렉토리도 포함하고, changed뿐 아니라
+// newFiles/unchanged까지 전부 반환한다(읽기 전용 — 실제로 아무 파일도 쓰지 않는다).
+export function planWorkflows(context, payloadRoot, targetRoot = ".") {
+  const { types = [], paths = new Map(), includeNexus = false, includeSecretBackup = false, repoName = "", resolvers = {} } = context;
+  const workflowsDir = join(targetRoot, PATHS.workflowsDir);
+  const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
+  const srcText = makeSrcText(context.branches || null);
+  const branchMode = context.branches?.mode || "pr-flow";
+  const plan = { newFiles: [], unchanged: [], changed: [] };
+
+  const merge = (result, type, excluded = null) => {
+    for (const bucket of ["newFiles", "unchanged", "changed"]) {
+      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), "common",
+      branchMode === "trunk-based" ? TRUNK_BASED_EXCLUDED : null);
+  }
+
+  // secret-backup은 copyWorkflows처럼 신규 파일만 대상(기존 파일은 절대 덮어쓰지 않는 규약) —
+  // classify()의 changed 판정과 무관하게, 여기서도 존재 여부만으로 new/unchanged를 가른다.
+  const secretDir = join(commonDir, "secret-backup");
+  if (exists(secretDir) && includeSecretBackup) {
+    for (const filename of listYamlFiles(secretDir)) {
+      const dst = join(workflowsDir, filename);
+      plan[existsSync(dst) ? "unchanged" : "newFiles"].push({ filename, type: "common" });
+    }
+  }
+
+  for (const type of types) {
+    const envOpts = { type, projectPath: paths.get(type) || ".", repoName, resolvers };
+    const typeDir = join(projectTypesDir, type);
+    if (exists(typeDir)) merge(classify(typeDir, workflowsDir, envOpts, srcText), type);
+
+    const serverDeployDir = join(typeDir, "server-deploy");
+    if (exists(serverDeployDir) && !includeNexus) {
+      merge(classify(serverDeployDir, workflowsDir, envOpts, srcText), type);
+    }
+
+    const nexusDir = join(typeDir, "nexus");
+    if (exists(nexusDir) && includeNexus) {
+      merge(classify(nexusDir, workflowsDir, envOpts, srcText), type);
+    }
+  }
+
+  return plan;
+}

package/src/core/version-yml.js

@@ -7,7 +7,7 @@
 // 구 synology 키 등 다른 키는 어느 분기에도 안 걸려 자연히 무시된다.
 // (options-ask.js가 이 함수를 import한다 — 순환 방지 위해 여기(version-yml)에 정의.)
 export function parseTemplateOptions(content) {
-  const out = { nexus: null, secretBackup: null, coderabbit: null };
+  const out = { nexus: null, secretBackup: null, coderabbit: null, semverAuto: null };
   // 값 정규화: 따옴표 제거 + 트림 (.sh tr -d '"' | tr -d "'" | xargs 등가)
   const strip = (s) => String(s).replace(/["']/g, "").trim();
   let inTemplate = false;
@@ -37,6 +37,13 @@ export function parseTemplateOptions(content) {
         if (v === "false") out.coderabbit = false;
         continue;
       }
+      m = line.match(/^\s+semver_auto:\s*(.+)/);
+      if (m) {
+        const v = strip(m[1]);
+        if (v === "true") out.semverAuto = true;
+        if (v === "false") out.semverAuto = false;
+        continue;
+      }
       // 들여쓰기 0~4칸의 다른 키 → options 섹션 종료 (.sh L2404~2408)
       if (/^\s{0,4}[a-z_]+:/.test(line)) { inOptions = false; inTemplate = false; }
     }
@@ -137,7 +144,7 @@ export function buildVersionYml({
   const b = branches || { main: branch || "main", develop: "develop", mode: "pr-flow" };
   const {
     templateVersion = "unknown", includeNexus = false, includeSecretBackup = false,
-    includeCodeRabbit = false, optionsDate = today,
+    includeCodeRabbit = false, includeSemverAuto = true, optionsDate = today,
   } = templateOptions || {};
 
   // project_paths 블록 (full-line 토큰 {{PROJECT_PATHS}} — 없으면 라인 제거)
@@ -171,7 +178,7 @@ export function buildVersionYml({
     TEMPLATE_VERSION: templateVersion,
     MAIN_BRANCH: b.main, DEVELOP_BRANCH: b.develop, BRANCH_MODE: b.mode,
     OPT_NEXUS: String(includeNexus), OPT_SECRET_BACKUP: String(includeSecretBackup),
-    OPT_CODERABBIT: String(includeCodeRabbit),
+    OPT_CODERABBIT: String(includeCodeRabbit), OPT_SEMVER_AUTO: String(includeSemverAuto),
   };
 
   const out = [];

package/src/index.js

@@ -19,7 +19,12 @@ import { runFull } from "./commands/full.js";
 import { runVersion } from "./commands/version.js";
 import { runWorkflows } from "./commands/workflows.js";
 import { runRevert } from "./commands/revert.js";
+import { runUninstall, runUninstallFlow } from "./commands/uninstall.js";
+import * as prompts from "./ui/prompts.js";
 import { runInteractive } from "./commands/interactive.js";
+import { runStatus, printStatus } from "./commands/status.js";
+import { runDoctor, printDoctorReport } from "./commands/doctor.js";
+import { planDryRun, printDryRun } from "./commands/dry-run.js";
 
 // 패키지 버전 읽기 (-v/--version 출력용). src/../package.json.
 function readPkgVersion() {
@@ -58,8 +63,13 @@ export async function run(argv, { cwd = process.cwd(), payloadRoot, clock } = {}
 
   // 대화형 모드 — 인자 없이 실행 or --mode interactive
   if (opts.mode === "interactive") {
+    // --dry-run은 대화형 모드에서 조용히 무시되면 안 됨(실제 설치가 진행돼버림) — 명시 에러로 차단.
+    if (opts.dryRun) {
+      console.error("--dry-run은 --mode <full|version|workflows|revert|uninstall>와 함께 사용하세요 (대화형 모드에서는 지원하지 않습니다).");
+      return 1;
+    }
     if (!process.stdout.isTTY) {
-      console.error("대화형 입력이 불가능한 환경입니다. --mode <full|version|workflows|revert> 와 --force 를 지정하세요.");
+      console.error("대화형 입력이 불가능한 환경입니다. --mode <full|version|workflows|revert|uninstall> 와 --force 를 지정하세요.");
       return 1;
     }
     return await runInteractive({}, { cwd, payloadRoot: payload, clock });
@@ -67,17 +77,62 @@ export async function run(argv, { cwd = process.cwd(), payloadRoot, clock } = {}
 
   // revert 모드 — payload 유래 파일 제거 (감지·질문 불필요, --force 게이트만)
   if (opts.mode === "revert") {
-    if (!opts.force && !process.stdout.isTTY) {
+    // --dry-run은 파일을 쓰지 않으므로 --force 게이트를 우회한다 (status/doctor와 동일한 안전성).
+    if (!opts.force && !opts.dryRun && !process.stdout.isTTY) {
       console.error("비대화형 환경에서는 --force 옵션이 필요합니다.");
       return 1;
     }
+    if (opts.dryRun) {
+      printDryRun(planDryRun("revert", {}, payload, cwd));
+      return 0;
+    }
     const r = runRevert({}, payload, cwd);
     console.error(`제거됨 — 워크플로우 ${r.workflows.length}개, 스크립트 ${r.scripts.length}개${r.coderabbit ? ", .coderabbit.yaml" : ""}`);
     console.error("version.yml·README·.gitignore는 보존됩니다 (사용자 데이터).");
     return 0;
   }
+
+  // uninstall 모드 — revert보다 넓게 README·gitignore·version.yml까지 선택적으로 제거.
+  if (opts.mode === "uninstall") {
+    const safeSelection = {
+      workflows: true, scripts: true, coderabbit: true,
+      readme: opts.purgeReadme, gitignore: opts.purgeGitignore, versionYml: opts.purgeVersion,
+    };
+    if (opts.dryRun) {
+      printDryRun(planDryRun("uninstall", { uninstallSelection: safeSelection }, payload, cwd));
+      return 0;
+    }
+    if (opts.force) {
+      const r = runUninstall({}, payload, cwd, safeSelection);
+      const removed = [
+        `워크플로우 ${r.workflows.length}개`, `스크립트 ${r.scripts.length}개`,
+        r.coderabbit && ".coderabbit.yaml", r.readme && "README 버전 섹션",
+        r.gitignore && ".gitignore 자동 추가 항목", r.versionYml && "version.yml",
+      ].filter(Boolean).join(", ");
+      console.error(`제거됨 — ${removed}`);
+      return 0;
+    }
+    if (!process.stdout.isTTY) {
+      console.error("비대화형 환경에서는 --force 옵션이 필요합니다.");
+      return 1;
+    }
+    await runUninstallFlow(payload, cwd, prompts);
+    return 0;
+  }
+
+  // status 모드 — 읽기 전용, TTY/--force 무관하게 항상 동작
+  if (opts.mode === "status") {
+    printStatus(runStatus(payload, cwd));
+    return 0;
+  }
+  // doctor 모드 — 읽기 전용, TTY/--force 무관하게 항상 동작
+  if (opts.mode === "doctor") {
+    printDoctorReport(runDoctor(cwd));
+    return 0;
+  }
   // 명시 모드인데 --force 없으면 (비대화형 CLI는 --force 필요)
-  if (!opts.force && !process.stdout.isTTY) {
+  // --dry-run은 파일을 쓰지 않으므로 --force 게이트를 우회한다 (status/doctor와 동일한 안전성).
+  if (!opts.force && !opts.dryRun && !process.stdout.isTTY) {
     console.error("비대화형 환경에서는 --force 옵션이 필요합니다.");
     return 1;
   }
@@ -107,7 +162,7 @@ export async function run(argv, { cwd = process.cwd(), payloadRoot, clock } = {}
   });
   // pr-flow에서 develop이 원격에 없으면 자동 생성+push (--force 비대화형 — 질문 없음).
   // 원격 목록을 못 읽는 환경(git 없음·origin 없음)은 remoteBranches=[]지만 push 실패를 조용히 보고.
-  if (branches.mode === "pr-flow") {
+  if (branches.mode === "pr-flow" && !opts.dryRun) {
     const remoteBranches = await detectRemoteBranches(cwd);
     if (remoteBranches.length && !remoteBranches.includes(branches.develop)) {
       await ensureDevelopBranch({
@@ -127,6 +182,10 @@ export async function run(argv, { cwd = process.cwd(), payloadRoot, clock } = {}
     includeNexus: opts.includeNexus ?? existing?.options?.nexus ?? false,
     includeSecretBackup: opts.includeSecretBackup ?? existing?.options?.secretBackup ?? false,
     includeCodeRabbit: opts.includeCodeRabbit ?? existing?.options?.coderabbit ?? false,
+    // 기존 version.yml이 있는데 semver_auto 키가 아예 없었던 경우(신규 기능 추가 이전 설치·
+    // workflows-only 재실행) 조용히 true로 켜지면 애매한 커밋 하나로 major가 승격될 위험이 있다 —
+    // 기존 설치는 false로 안전하게 폴백, 완전 신규 설치만 true(기존 설계) 유지.
+    includeSemverAuto: opts.includeSemverAuto ?? existing?.options?.semverAuto ?? (existing ? false : true),
     repoName,
     // 실 resolver 4종 (.sh resolve_token 등가)
     resolvers: makeResolvers(cwd, repoName, paths),
@@ -142,6 +201,11 @@ export async function run(argv, { cwd = process.cwd(), payloadRoot, clock } = {}
   const proceed = await runBreakingCheck({ cwd, payloadRoot: payload, templateVersion: context.templateVersion });
   if (!proceed) return 0;
 
+  if (opts.dryRun) {
+    printDryRun(planDryRun(opts.mode, context, payload, cwd));
+    return 0;
+  }
+
   let result = null;
   switch (opts.mode) {
     case "full": result = runFull(context, payload, cwd); break;

package/src/ui/prompts.js

@@ -14,6 +14,7 @@ export async function selectMode() {
       { value: "version", label: "버전 관리만 — 버전 자동 증가·동기화 시스템만 설치" },
       { value: "workflows", label: "워크플로우만 — 빌드·배포 GitHub Actions만 설치" },
       { value: "revert", label: "되돌리기 — 마법사가 설치한 워크플로우·스크립트 제거" },
+      { value: "uninstall", label: "완전 삭제 — 마법사가 설치·수정한 모든 항목 제거(확인 후, README·gitignore·version.yml 포함)" },
     ],
   });
 }