project-auto-wizard 0.13.3 → 0.15.0

package/src/core/copy/gitignore.js

@@ -1,27 +1,29 @@
-// .gitignore 보장 — 마법사 자신이 만드는 충돌 백업 부산물(*.bak, *.template.yaml)만 대상으로 한다.
-// 마법사가 설치하는 것과 무관한 개인 개발환경 설정(IDE 등)은 마법사 책임 범위 밖.
-// 배너 블록은 종료 마커(BANNER_END)로 범위가 명확히 구분되어 있어, 그 안에 사용자가 다른 줄을
-// 끼워넣어도 REQUIRED_ENTRIES만 정확히 개별 제거하고 나머지는 보존한다.
-// 주의(의도된 트레이드오프): 이 수정 이전 버전으로 설치되어 종료 마커가 없는 배너가 이미 있는
-// 레포에서는, 배너 직후 REQUIRED_ENTRIES가 연속으로 이어지는 동안만 제거하는 구 방식으로
-// 폴백한다 — 이전 결정이 "이미 설치된 레포의 .gitignore는 소급 처리하지 않고 사용자 판단에
-// 맡긴다"고 명시하므로 별도 마이그레이션 로직을 추가하지 않는다.
+// .gitignore guarantee: covers only the conflict backup by-products the wizard itself creates
+// (*.bak, *.template.yaml). Personal dev-environment settings (IDE etc.) unrelated to what the wizard
+// installs are outside its responsibility.
+// The banner block is clearly delimited by the end marker (BANNER_END), so even if the user inserts other
+// lines inside it, only the REQUIRED_ENTRIES are removed individually and everything else is preserved.
+// Note (intended trade-off): in repos installed before this change, where the banner has no end marker,
+// we fall back to the old approach of removing only while REQUIRED_ENTRIES follow the banner consecutively.
+// An earlier decision states that .gitignore of already installed repos is not retroactively processed and is
+// left to the user, so no separate migration logic is added.
 import { join } from "node:path";
 import { existsSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { t, SUPPORTED_LANGUAGES } from "../../i18n/index.js";
 
-// 마법사가 설치하는 것과 무관한 개인 개발환경 항목(/.idea 등)은 마법사 책임 밖이므로 제거.
-// 대신 마법사 자신의 충돌 처리(workflows.js backup/template 결정)가
-// 실제로 만들어내는 부산물만 gitignore 대상으로 삼는다.
+// Personal dev-environment entries (/.idea etc.) are outside the wizard's responsibility, so they are excluded.
+// Only the by-products the wizard's own conflict handling (workflows.js backup/template decisions)
+// actually creates are gitignore targets.
 const REQUIRED_ENTRIES = ["*.bak", "*.template.yaml"];
 
-// 항목 정규화: 주석 제거·트림·앞 / 제거·앞 ./ 제거·뒤 / 제거. 빈값이면 원본.
+// Normalizes an entry: strip comment, trim, strip leading /, leading ./ and trailing /. Returns the original if empty.
 export function normalizeGitignoreEntry(entry) {
   let e = String(entry);
-  e = e.replace(/#.*$/, "");        // 주석 제거
-  e = e.trim();                      // 앞뒤 공백
-  e = e.replace(/^\//, "");         // 앞 /
-  e = e.replace(/^\.\//, "");       // 앞 ./
-  e = e.replace(/\/$/, "");         // 뒤 /
+  e = e.replace(/#.*$/, "");        // strip comment
+  e = e.trim();                      // surrounding whitespace
+  e = e.replace(/^\//, "");         // leading /
+  e = e.replace(/^\.\//, "");       // leading ./
+  e = e.replace(/\/$/, "");         // trailing /
   return e === "" ? String(entry) : e;
 }
 
@@ -35,13 +37,18 @@ function entryExists(target, content) {
   return false;
 }
 
-const NEW_FILE_CONTENT =
-  "# project-auto-wizard: 충돌 처리 시 생성되는 백업 파일 (안전하게 무시해도 됩니다)\n" +
+const newFileContent = (lang) =>
+  t("copy.gitignore.newFileHeader", {}, lang) + "\n" +
   "*.bak\n" +
   "*.template.yaml\n";
+// The header comment depends on the language it was written in, so a file created in one language must
+// still be recognized under another: check every supported language's variant.
+const NEW_FILE_CONTENT = () => newFileContent(undefined);
+const matchingNewFileContent = (content) =>
+  [NEW_FILE_CONTENT(), ...SUPPORTED_LANGUAGES.map(newFileContent)].find((c) => content.startsWith(c)) ?? null;
 
-// 쓰지 않고 판정만 한다 — 실제 갱신과 --dry-run 미리보기가 같은 판정을 쓰게 한다.
-// 반환: {created, added:[...]}
+// Only decides without writing, so the real update and the --dry-run preview share one decision.
+// Returns: {created, added:[...]}
 export function planGitignore(targetRoot = ".") {
   const p = join(targetRoot, ".gitignore");
   if (!existsSync(p)) return { created: true, added: REQUIRED_ENTRIES.slice() };
@@ -49,21 +56,21 @@ export function planGitignore(targetRoot = ".") {
   return { created: false, added: REQUIRED_ENTRIES.filter((e) => !entryExists(e, content)) };
 }
 
-// 반환: {created, added:[...]}
+// Returns: {created, added:[...]}
 export function ensureGitignore(targetRoot = ".") {
   const p = join(targetRoot, ".gitignore");
   const plan = planGitignore(targetRoot);
   if (plan.created) {
-    writeFileSync(p, NEW_FILE_CONTENT);
+    writeFileSync(p, NEW_FILE_CONTENT());
     return plan;
   }
   const toAdd = plan.added;
   if (toAdd.length === 0) return plan;
   let content = readFileSync(p, "utf8");
 
-  // BANNER는 "\n"으로 시작한다. 파일 끝에 개행이 없으면 그 "\n"이 마지막 줄을 끝내는 역할을 하고,
-  // 개행이 있으면 빈 줄 하나가 된다. 어느 쪽이든 제거 시 BANNER 앞까지 자르면 원문 그대로 돌아온다.
-  // (개행을 따로 보충하면 제거 후에도 원래 없던 끝 개행이 남는다.)
+  // BANNER starts with "\n". If the file lacks a trailing newline that "\n" terminates the last line;
+  // otherwise it becomes one blank line. Either way, cutting up to BANNER on removal restores the original text.
+  // (Adding a newline separately would leave a trailing newline that was not there originally.)
   content += BANNER;
   for (const e of toAdd) content += e + "\n";
   content += BANNER_END;
@@ -71,42 +78,44 @@ export function ensureGitignore(targetRoot = ".") {
   return { created: false, added: toAdd };
 }
 
-// ensureGitignore가 기존 파일에 배너 블록을 추가할 때 항상 이 정확한 시퀀스로 시작한다
-// ("\n" + 3줄 배너), 그리고 REQUIRED_ENTRIES 뒤에 BANNER_END로 끝난다. 배너~BANNER_END
-// 범위 안에서 REQUIRED_ENTRIES와 일치하는 줄만 개별 제거하고, 사용자가 그 사이/뒤에 추가한
-// 줄은 절대 건드리지 않는다.
+// When ensureGitignore adds a banner block to an existing file it always starts with this exact sequence
+// ("\n" + 3-line banner) and ends with BANNER_END after REQUIRED_ENTRIES. Only lines matching
+// REQUIRED_ENTRIES inside the banner..BANNER_END range are removed individually; lines the user added
+// between or after them are never touched.
+// The banner text is English in every language, so detection needs no language handling.
 const BANNER =
   "\n" +
   "# ====================================================================\n" +
   "# project-auto-wizard: Auto-added entries\n" +
   "# ====================================================================\n";
 
-// REQUIRED_ENTRIES 뒤에 오는 종료 마커 — 배너 블록의 "끝"을 명확히 구분해, 그 사이에 사용자가
-// 다른 줄을 끼워넣어도 removeAutoAddedEntriesFromGitignore가 정확한 범위 안에서 개별 제거할 수
-// 있게 한다. ensureGitignore가 기존 파일에 배너를 추가할 때만 함께 쓴다
-// (신규 파일 생성 케이스는 NEW_FILE_CONTENT를 통째로 쓰고 종료 마커는 쓰지 않는다 —
-// startsWith 전체 prefix 매칭이라 별도 마커가 필요 없다).
+// End marker after REQUIRED_ENTRIES: it clearly delimits the "end" of the banner block so that
+// removeAutoAddedEntriesFromGitignore can remove entries individually within the exact range even if the user
+// inserted other lines between them. Used only when ensureGitignore adds a banner to an existing file
+// (the new-file case writes NEW_FILE_CONTENT as a whole and no end marker; it is matched
+// by the full startsWith prefix, so no separate marker is needed).
 const BANNER_END = "# ==== project-auto-wizard: end of auto-added entries ====\n";
 
-// .gitignore에 마법사가 추가한 항목이 있는지 확인 (체크리스트 노출 판단용).
-// 두 케이스: (1) 원래 없던 파일을 통째로(또는 그 뒤에 사용자가 이어 쓴 형태로) 새로 만든 경우
-// (2) 기존 파일에 배너 블록을 붙인 경우.
+// Checks whether the wizard added entries to .gitignore (to decide on showing the checklist).
+// Two cases: (1) a file that did not exist was created as a whole (or with user content appended after it)
+// (2) a banner block was attached to an existing file.
 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);
+  return matchingNewFileContent(content) !== null || content.includes(BANNER);
 }
 
-// 반환: 'removed' | 'file-deleted' | 'skip-no-gitignore' | 'skip-not-found'
+// Returns: '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);
+  // The file did not exist and the wizard created it as a whole: keep only what the user appended after it.
+  const created = matchingNewFileContent(content);
+  if (created !== null) {
+    const remainder = content.slice(created.length);
     if (remainder === "") {
       rmSync(p);
       return "file-deleted";
@@ -115,14 +124,13 @@ export function removeAutoAddedEntriesFromGitignore(targetRoot = ".") {
     return "removed";
   }
 
-  // 기존 파일에 배너 블록이 붙은 경우.
+  // A banner block was attached to an existing file.
   const idx = content.indexOf(BANNER);
   if (idx === -1) return "skip-not-found";
   const afterBanner = idx + BANNER.length;
 
-  // 종료 마커가 있으면(이 수정 이후 설치분) 그 범위 안에서 REQUIRED_ENTRIES만 개별적으로
-  // 제거하고, 사용자가 그 사이에 끼워넣은 줄은 순서·연속 여부와 무관하게 그대로 보존한다
-  //.
+  // If the end marker exists (installed after this change), remove only REQUIRED_ENTRIES individually
+  // within that range and keep any lines the user inserted between them, regardless of order or adjacency.
   const endIdx = content.indexOf(BANNER_END, afterBanner);
   if (endIdx !== -1) {
     const region = content.slice(afterBanner, endIdx).split("\n");
@@ -133,14 +141,14 @@ export function removeAutoAddedEntriesFromGitignore(targetRoot = ".") {
     return "removed";
   }
 
-  // 종료 마커가 없는 구버전 설치(이 수정 이전) — 배너 직후 REQUIRED_ENTRIES가 연속으로
-  // 이어지는 동안만 제거하는 기존 방식으로 폴백한다 (동일한 소급 미처리 원칙).
+  // Old install without an end marker (before this change): fall back to the old approach of removing only
+  // while REQUIRED_ENTRIES follow the banner consecutively (same no-retroactive-processing principle).
   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"
+    consumed += line.length + 1; // +1: the "\n" swallowed by split
   }
   writeFileSync(p, content.slice(0, idx) + content.slice(afterBanner + consumed));
   return "removed";

package/src/core/copy/readme.js

@@ -1,26 +1,80 @@
-// README 버전 섹션 추가.
+// Appends the README version section.
 import { join } from "node:path";
 import { existsSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
+import { t, SUPPORTED_LANGUAGES } from "../../i18n/index.js";
 
 export const MARKER = "<!-- AUTO-VERSION-SECTION";
-// ## (최신 버전|최신버전|Version|버전) : vX.Y.Z (대소문자 무시)
-const VERSION_LINE_RE = /##\s*(최신\s*버전|최신버전|Version|버전)\s*:\s*v[0-9]+\.[0-9]+\.[0-9]+/i;
+// "## <latest version|latest-version|current/recent version|Version|version> : vX.Y.Z", where the Korean words are written as
+// \u escapes so this file stays free of Hangul (case-insensitive)
+const VERSION_LINE_RE = /##\s*(\uCD5C\uC2E0\s*\uBC84\uC804|\uCD5C\uC2E0\uBC84\uC804|(?:latest|current|recent)[\s-]*version|Version|\uBC84\uC804)\s*:\s*v[0-9]+\.[0-9]+\.[0-9]+/i;
 
-// 실행 로그용 설명 — 상태 코드만 남기면 나중에 로그를 읽는 사람이 의미를 다시 찾아봐야 한다.
+// Descriptions for the run log: a bare status code forces later readers to look up its meaning.
+// Getters keep the text lazy so it follows the language resolved at runtime.
 export const README_STATUS_LABEL = {
-  added: "README.md 끝에 버전 섹션 추가",
-  "skip-no-readme": "README.md가 없어 버전 섹션을 추가하지 않음",
-  "skip-marker": "이미 버전 섹션이 있어 그대로 둠",
-  "skip-version-line": "이미 버전 줄이 있어 그대로 둠",
+  get added() { return t("copy.readme.status.added"); },
+  get "skip-no-readme"() { return t("copy.readme.status.skipNoReadme"); },
+  get "skip-marker"() { return t("copy.readme.status.skipMarker"); },
+  get "skip-version-line"() { return t("copy.readme.status.skipVersionLine"); },
+  get "heading-updated"() { return t("copy.readme.status.headingUpdated"); },
 };
 
-// README.md 없으면 스킵. 마커 또는 버전 라인 있으면 스킵. 없으면 파일 끝에 append.
-// 반환: 'skip-no-readme' | 'skip-marker' | 'skip-version-line' | 'added'
-// 쓰지 않고 판정만 한다 — 실제 추가와 --dry-run 미리보기가 같은 판정을 쓰게 한다.
+// Bundled default heading text ("Latest Version", ...) without the "## " prefix and version part, per language.
+const defaultHeading = (lang) => t("copy.readme.versionHeading", { version: "0" }, lang).replace(/^##\s*/, "").replace(/\s*:\s*v0$/, "");
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+// Text of the history link line in a given language (without the trailing newline).
+const historyLink = (lang) => t("copy.readme.historyLink", {}, lang);
+
+// Rewrites the wizard-made block (marker line, heading line, blank line, history link line) that was written
+// in another language so it matches the current one. Only text that exactly equals another language's bundled
+// default is replaced: a heading or link the user edited is left alone, and so is anything not directly
+// under the marker (code-block examples, a README without the marker).
+// Returns the new content, or null when nothing needs to change.
+function refreshBlockLanguage(content) {
+  const currentHeading = defaultHeading();
+  const currentLink = historyLink();
+  const markerRe = new RegExp("^" + escapeRe(MARKER_LINE.trimEnd()) + "[ \\t]*\\r?\\n", "gm");
+  let out = "";
+  let last = 0;
+  let changed = false;
+  for (let m = markerRe.exec(content); m; m = markerRe.exec(content)) {
+    // An odd number of fence lines before the marker means it sits inside a code block (an example).
+    if ((content.slice(0, m.index).match(/^[ \t]*(```|~~~)/gm) || []).length % 2 === 1) continue;
+    const start = m.index + m[0].length;
+    let rest = content.slice(start);
+    let head = "";
+    // Heading line directly under the marker.
+    for (const lang of SUPPORTED_LANGUAGES) {
+      const heading = defaultHeading(lang);
+      if (heading === currentHeading) continue;
+      const hm = new RegExp("^## " + escapeRe(heading) + " : (?=v[0-9])").exec(rest);
+      if (hm) { head = "## " + currentHeading + " : "; rest = rest.slice(hm[0].length); changed = true; break; }
+    }
+    out += content.slice(last, start) + head;
+    last = start + (content.slice(start).length - rest.length);
+    // History link line: heading line, one blank line, then the link.
+    const lm = /^([^\r\n]*\r?\n\r?\n)([^\r\n]*)/.exec(rest);
+    if (lm) {
+      const linkStart = last + lm[1].length;
+      const isStale = SUPPORTED_LANGUAGES.some((lang) => historyLink(lang) !== currentLink && lm[2] === historyLink(lang));
+      if (isStale) {
+        out += content.slice(last, linkStart) + currentLink;
+        last = linkStart + lm[2].length;
+        changed = true;
+      }
+    }
+  }
+  return changed ? out + content.slice(last) : null;
+}
+
+// Skip when README.md is missing, or when a marker or version line exists. Otherwise append to the end.
+// Returns: 'skip-no-readme' | 'heading-updated' | 'skip-marker' | 'skip-version-line' | 'added'
+// Only decides without writing, so the real append and the --dry-run preview share one decision.
 export function planVersionSection(targetRoot = ".") {
   const p = join(targetRoot, "README.md");
   if (!existsSync(p)) return "skip-no-readme";
   const content = readFileSync(p, "utf8");
+  if (refreshBlockLanguage(content) !== null) return "heading-updated";
   if (content.includes(MARKER)) return "skip-marker";
   if (VERSION_LINE_RE.test(content)) return "skip-version-line";
   return "added";
@@ -28,39 +82,46 @@ export function planVersionSection(targetRoot = ".") {
 
 export function addVersionSectionToReadme(version, targetRoot = ".") {
   const status = planVersionSection(targetRoot);
-  if (status !== "added") return status;
   const p = join(targetRoot, "README.md");
+  if (status === "heading-updated") {
+    // Swap only the bundled default wording; version text after the colon stays as the workflow wrote it.
+    writeFileSync(p, refreshBlockLanguage(readFileSync(p, "utf8")));
+    return status;
+  }
+  if (status !== "added") return status;
   const content = readFileSync(p, "utf8");
 
-  // 기존 본문과 구분선 사이에 빈 줄을 두도록 append 본문은 "\n---\n..."로 시작.
+  // The appended body starts with "\n---\n..." to leave a blank line between the existing text and the rule.
   const section =
     "\n" +
     "---\n" +
     "\n" +
     "<!-- AUTO-VERSION-SECTION: DO NOT EDIT MANUALLY -->\n" +
-    `## 최신 버전 : v${version}\n` +
+    t("copy.readme.versionHeading", { version }) + "\n" +
     "\n" +
-    "[전체 버전 기록 보기](CHANGELOG.md)\n";
-  // 끝 개행이 없는 README에 그대로 붙이면 마지막 줄 바로 다음 줄에 "---"가 와서
-  // 마크다운이 그 줄을 제목(Setext h2)으로 바꿔 버린다 — 줄을 먼저 끝낸다.
+    t("copy.readme.historyLink") + "\n";
+  // Appending directly to a README without a trailing newline puts "---" right after the last line,
+  // and Markdown turns that line into a heading (Setext h2), so terminate the line first.
   const lead = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
   appendFileSync(p, lead + section);
   return "added";
 }
 
-// addVersionSectionToReadme가 항상 파일 맨 끝에 붙이는 접두/접미 시퀀스.
-// 접두(SECTION_PREFIX)가 있으면 마법사가 append한 "블록"이다 — 이 블록은 항상 SECTION_TAIL
-// 라인으로 끝나므로, 그 지점까지만 잘라내야 그 뒤에 사용자가 나중에 덧붙인 내용(라이선스 절 등)을
-// 지우지 않는다("파일 끝까지" 자르면 사용자 콘텐츠가 소실된다).
+// Prefix/suffix sequence that addVersionSectionToReadme always appends at the very end of the file.
+// If the prefix (SECTION_PREFIX) is present it is a "block" appended by the wizard. The block always ends
+// with the SECTION_TAIL line, so cut only up to that point; cutting "to the end of the file" would delete
+// content the user appended later (a license section etc.).
 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'으로 건너뛴 경우)에는
-// '---' 구분자 없이 마커 주석 한 줄만 그 버전 라인 위에 끼워넣는다. 이 경우 버전 라인 자체는
-// 사용자 소유이므로 지우지 않고 마커 주석 한 줄만 제거한다.
+// The tail text depends on the language it was installed in, so a section written in one language must
+// still be removable under another: candidates from every supported language are matched.
+const sectionTails = () => [...new Set(SUPPORTED_LANGUAGES.map((l) => t("copy.readme.historyLink", {}, l) + "\n"))];
+// For a README that already had the user's own version line at install time (addVersionSectionToReadme
+// skipped it as 'skip-version-line'), PROJECT-COMMON-README-VERSION-UPDATE.yaml (the installed CI) inserts
+// only a marker comment line above that version line, without the '---' separator. The version line itself
+// is user-owned, so only the marker comment line is removed in that case.
 const MARKER_LINE = "<!-- AUTO-VERSION-SECTION: DO NOT EDIT MANUALLY -->\n";
 
-// README.md에 마법사(또는 설치된 CI)가 추가한 흔적이 있는지 확인 (체크리스트 노출 판단용).
+// Checks whether the wizard (or the installed CI) left traces in README.md (to decide on showing the checklist).
 export function hasVersionSection(targetRoot = ".") {
   const p = join(targetRoot, "README.md");
   if (!existsSync(p)) return false;
@@ -68,7 +129,7 @@ export function hasVersionSection(targetRoot = ".") {
   return content.includes(SECTION_PREFIX) || content.includes(MARKER_LINE);
 }
 
-// 반환: 'removed' | 'skip-no-readme' | 'skip-no-marker' | 'skip-unexpected-format'
+// Returns: '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";
@@ -76,22 +137,27 @@ export function removeVersionSectionFromReadme(targetRoot = ".") {
 
   const idx = content.indexOf(SECTION_PREFIX);
   if (idx !== -1) {
-    // 마법사가 append한 전체 블록 케이스 — SECTION_TAIL 라인까지만 잘라내고 그 이후는 보존한다.
-    // tail을 못 찾거나(사용자가 그 줄을 지웠다면), 위저드 블록치고 너무 먼 곳에서 발견되면
-    // (사용자가 같은 문구를 자기 문서 어딘가로 옮겨 적은 경우) 그 사이 사용자 콘텐츠까지
-    // 지워버릴 수 있으므로 어디까지가 "마법사 구간"인지 확신할 수 없어 안전하게 포기한다.
-    // 위저드 블록은 버전 문자열이 길어져도 수백 바이트를 넘지 않는다.
+    // Whole block appended by the wizard: cut only up to the SECTION_TAIL line and keep everything after it.
+    // If the tail is missing (the user deleted that line), or is found too far away for a wizard block
+    // (the user copied the same text elsewhere in the document), user content in between could be deleted,
+    // and we cannot be sure where the "wizard section" ends, so give up safely.
+    // The wizard block stays within a few hundred bytes even with a long version string.
     const MAX_SECTION_LENGTH = 300;
-    const tailIdx = content.indexOf(SECTION_TAIL, idx);
+    let tailIdx = -1;
+    let tailLen = 0;
+    for (const tail of sectionTails()) {
+      const i = content.indexOf(tail, idx);
+      if (i !== -1 && (tailIdx === -1 || i < tailIdx)) { tailIdx = i; tailLen = tail.length; }
+    }
     if (tailIdx === -1 || tailIdx > idx + MAX_SECTION_LENGTH) return "skip-unexpected-format";
-    const cutEnd = tailIdx + SECTION_TAIL.length;
+    const cutEnd = tailIdx + tailLen;
     writeFileSync(p, content.slice(0, idx) + content.slice(cutEnd));
     return "removed";
   }
 
   const markerIdx = content.indexOf(MARKER_LINE);
   if (markerIdx !== -1) {
-    // CI가 사용자의 기존 버전 라인 위에 마커만 끼워넣은 케이스 — 버전 라인은 건드리지 않는다.
+    // The CI inserted only the marker above the user's existing version line; leave the version line alone.
     writeFileSync(p, content.slice(0, markerIdx) + content.slice(markerIdx + MARKER_LINE.length));
     return "removed";
   }

package/src/core/copy/simple.js

@@ -1,15 +1,16 @@
-// 단순 복사 함수 (무조건 덮어쓰기류).
-// payload 단일 진실: 스크립트는 payload/scripts/*.py → 사용자 레포 .github/scripts/ 로 설치된다.
-// 워크플로우 전부가 이 경로(python3 .github/scripts/*.py)를 호출하므로 누락 시 설치물이 런타임에 죽는다.
+// Simple copy functions (unconditional overwrite).
+// Single source of truth: scripts in payload/scripts/*.py are installed to .github/scripts/ in the user repo.
+// All workflows call this path (python3 .github/scripts/*.py), so a missing script breaks the install at runtime.
 import { join } from "node:path";
 import { chmodSync, readFileSync, readdirSync, rmSync, rmdirSync } from "node:fs";
 import { PATHS, PAYLOAD } from "../paths.js";
 import { exists, copyFileSync } from "../fsutil.js";
 
-export const SCRIPT_NAMES = ["version_manager.py", "changelog_manager.py", "truncate_release_notes.py", "issue_helper.py"];
+// messages.py is the shared message catalog the other scripts and the workflows import/call.
+export const SCRIPT_NAMES = ["version_manager.py", "changelog_manager.py", "truncate_release_notes.py", "issue_helper.py", "messages.py"];
 
-// 파일별로 무엇이 일어날지 계산한다(아무것도 쓰지 않음) — 실제 복사와 --dry-run이 같은 판정을 쓴다.
-// 반환: [{ name, action: "create" | "overwrite" | "unchanged" }]
+// Computes what will happen per file (writes nothing), so the real copy and --dry-run share one decision.
+// Returns: [{ name, action: "create" | "overwrite" | "unchanged" }]
 export function planScripts(payloadRoot, targetRoot = ".") {
   const out = [];
   for (const name of SCRIPT_NAMES) {
@@ -23,22 +24,22 @@ export function planScripts(payloadRoot, targetRoot = ".") {
   return out;
 }
 
-// 스크립트는 항상 payload 버전으로 덮어쓴다 (+chmod — Windows에선 무의미하나 무해).
-// 사용자가 고친 스크립트도 덮이므로, 호출부가 로그에 남길 수 있게 파일별 결과를 돌려준다.
+// Scripts are always overwritten with the payload version (+chmod, meaningless but harmless on Windows).
+// User-edited scripts are overwritten too, so per-file results are returned for the caller to log.
 export function copyScripts(payloadRoot, targetRoot = ".") {
   const results = planScripts(payloadRoot, targetRoot);
   for (const { name } of results) {
     const dst = join(targetRoot, PATHS.scriptsDir, name);
     copyFileSync(join(payloadRoot, PAYLOAD.scriptsDir, name), dst);
-    try { chmodSync(dst, 0o755); } catch { /* Windows 등 chmod 무의미 */ }
+    try { chmodSync(dst, 0o755); } catch { /* chmod is meaningless on Windows etc. */ }
   }
   return results;
 }
 
-// 예전 버전의 워크플로우는 스크립트 import가 남긴 바이트코드를 봇 커밋에 섞어 올렸다.
-// 지금은 생성 자체를 막지만 이미 커밋된 pyc는 업데이트로 사라지지 않으므로 여기서 지운다.
-// 범위는 마법사 스크립트 폴더의 pyc와 그 __pycache__뿐이다 — 다른 경로는 건드리지 않는다.
-// 반환: 지울(지운) 파일의 targetRoot 기준 상대 경로 목록 — 삭제는 사용자가 설치 파일과 함께 커밋한다
+// Older workflow versions committed bytecode left by script imports into bot commits.
+// Generation is now prevented, but already committed pyc files do not vanish on update, so they are removed here.
+// Scope is only the pyc files in the wizard scripts folder and its __pycache__; no other path is touched.
+// Returns paths (relative to targetRoot) of files to remove (removed); the user commits the deletion with the installed files.
 export function planScriptBytecode(targetRoot = ".") {
   const base = join(targetRoot, PATHS.scriptsDir);
   const list = (rel) => {
@@ -55,8 +56,8 @@ export function removeScriptBytecode(targetRoot = ".") {
   const removed = planScriptBytecode(targetRoot);
   for (const rel of removed) rmSync(join(targetRoot, rel), { force: true });
   if (removed.some((rel) => rel.includes("/__pycache__/"))) {
-    // 비었을 때만 지운다 — 다른 파일이 있으면 그대로 둔다
-    try { rmdirSync(join(targetRoot, PATHS.scriptsDir, "__pycache__")); } catch { /* 비어 있지 않음 */ }
+    // remove only when empty; leave it if other files exist
+    try { rmdirSync(join(targetRoot, PATHS.scriptsDir, "__pycache__")); } catch { /* not empty */ }
   }
   return removed;
 }