deel-local-cli 1.20.12 → 2.0.0

package/src/tools/docs.js

@@ -110,6 +110,19 @@ export function 겉속다름말(갈래, 속) {
       + '  파일이 깨졌을 수 있습니다. 이 파일로는 더 해 볼 것이 없으니 사용자에게 알리세요.';
   }
   if (속.startsWith('옛 Office')) {
+    /*
+     * hwpx 만 길이 다르다. OLE 복합문서 서명은 옛 hwp 와 옛 Office 가 **똑같아서**,
+     * 이름만 hwpx 인 것은 십중팔구 옛 hwp 다. 그런데 soffice 에는 hwpx 로 바꾸는
+     * 길이 없다 — 없는 길을 알려 주면 모델은 그 명령을 실제로 불러 보고 실패하고,
+     * 사람은 그 왕복을 고스란히 문다. 진짜 길은 바로 아래 옛hwp안내 가 적어 둔
+     * 그것이다 (한글에서 hwpx 로 저장).
+     */
+    if (갈래 === 'hwpx') {
+      return `${머리} — 실제로는 옛 형식(OLE 복합문서)입니다. 옛 hwp 이거나 옛 Office 파일입니다.\n`
+        + '  한글(한컴오피스)에서 열어 **hwpx 로 저장**하면 그대로 읽을 수 있습니다\n'
+        + '  (다른 이름으로 저장 → 파일 형식에서 hwpx 선택).\n'
+        + '  soffice 로는 hwpx 로 못 바꿉니다 — 그 길은 없습니다.';
+    }
     return `${머리} — 실제로는 ${속} 입니다.\n`
       + `  이름만 ${갈래} 로 바뀐 옛 형식이라 이 도구로는 못 읽습니다.\n`
       + `  PowerPoint·Word 에서 열어 ${갈래} 로 다시 저장하거나,\n`
@@ -175,8 +188,33 @@ export function 문단뽑기(xml, 갈래, { 표를따로 = false } = {}) {
 
   let 글모음 = [];        // 지금 문단의 글 조각들
   let 표깊이 = 0;
-  let 행칸들 = null;      // 표 행 안일 때: 칸 글들
-  let 칸글 = null;        // 표 칸 안일 때: 그 칸의 글 조각들
+  /*
+   * ── 표 안의 표가 바깥 행을 통째로 지웠다 ────────────────────────────
+   *
+   * 사람이 본 것 —
+   *
+   *   ◧ Read(사업계획서.docx)
+   *     └ 담당 | 과장 | 부장
+   *
+   * 결재란만 나오고 「사업명」도 「예산」도 없다. 그런데 오류도, 잘림 알림도
+   * 없다. 나온 글은 멀쩡한 문장이라 **뭔가 빠졌다는 표가 아무 데도 안 난다.**
+   * 모델은 그게 문서 전부인 줄 알고 "그런 항목은 없습니다" 라고 답했다.
+   *
+   * 속에서 벌어진 일 — 표깊이는 세면서 그릇(행칸들·칸글)은 하나뿐이었다.
+   * 바깥 칸이 '사업명' 을 모으는 중에 안쪽 <tr> 이 행칸들을 새 [] 로, 안쪽
+   * <tc> 가 칸글을 새 [] 로 갈아 치웠다. 그 순간 '사업명' 이 사라졌고, 안쪽
+   * </tr> 이 행칸들을 null 로 되돌려 놓아서 바깥 </tc>·</tr> 은 담을 그릇이
+   * 없다며 아무것도 안 밀어 넣었다. 한국 관공서 양식은 표 안에 결재란을 두는
+   * 것이 표준이라, 하필 **값이 든 바깥 표**만 골라서 없어진 셈이다.
+   *
+   * 이제 지키는 규칙: 그릇은 표 깊이마다 따로 둔다. 안쪽 표가 무엇을 하든
+   * 바깥 층의 칸은 건드리지 않는다. 안쪽 행이 먼저 나오고 그 뒤에 바깥 행이
+   * 나오지만, 사라지는 것은 없다.
+   */
+  const 행칸들쌓임 = [];  // 깊이마다: 그 층 행에 담긴 칸 글들
+  const 칸글쌓임 = [];    // 깊이마다: 그 층 칸의 글 조각들
+  const 지금행칸들 = () => 행칸들쌓임[표깊이] ?? null;
+  const 지금칸글 = () => 칸글쌓임[표깊이] ?? null;
   let 글안 = false;       // <t> 안인가 — 글 태그 밖의 지시문·수식 글을 안 줍기 위해
 
   const 문단닫기 = () => {
@@ -189,40 +227,44 @@ export function 문단뽑기(xml, 갈래, { 표를따로 = false } = {}) {
     if (t.text !== undefined) {
       if (!글안 || t.blank) continue;
       const 글 = unescapeXml(t.text);
-      if (칸글) 칸글.push(글);
+      const 칸 = 지금칸글();
+      if (칸) 칸.push(글);
       else 글모음.push(글);
       continue;
     }
     const 이름 = 끝이름(t.name);
 
     if (이름 === 표기.글) { 글안 = !t.closing && !t.selfClosing; continue; }
-    if (표기.탭 && 이름 === 표기.탭 && !t.closing) { (칸글 ?? 글모음).push('\t'); continue; }
-    if (표기.줄바꿈 && 이름 === 표기.줄바꿈 && !t.closing) { (칸글 ?? 글모음).push('\n'); continue; }
+    if (표기.탭 && 이름 === 표기.탭 && !t.closing) { (지금칸글() ?? 글모음).push('\t'); continue; }
+    if (표기.줄바꿈 && 이름 === 표기.줄바꿈 && !t.closing) { (지금칸글() ?? 글모음).push('\n'); continue; }
 
     if (이름 === 표기.표) { 표깊이 += t.closing ? -1 : (t.selfClosing ? 0 : 1); continue; }
     if (표깊이 > 0 && 이름 === 표기.행) {
       if (t.closing) {
-        if (행칸들) {
-          const 칸 = 행칸들.map((x) => x.trim());
+        const 담긴것 = 지금행칸들();
+        if (담긴것) {
+          const 칸 = 담긴것.map((x) => x.trim());
           문단들.push(표를따로 ? { 행: 칸 } : 칸.join(' | '));
         }
-        행칸들 = null;
+        행칸들쌓임[표깊이] = null;
       } else {
-        행칸들 = [];
+        행칸들쌓임[표깊이] = [];
       }
       continue;
     }
     if (표깊이 > 0 && 이름 === 표기.칸) {
       if (t.closing) {
-        if (행칸들 && 칸글) 행칸들.push(칸글.join(''));
-        칸글 = null;
+        const 담긴것 = 지금행칸들();
+        const 모은글 = 지금칸글();
+        if (담긴것 && 모은글) 담긴것.push(모은글.join(''));
+        칸글쌓임[표깊이] = null;
       } else {
-        칸글 = [];
+        칸글쌓임[표깊이] = [];
       }
       continue;
     }
 
-    if (이름 === 표기.문단 && t.closing && !칸글) 문단닫기();
+    if (이름 === 표기.문단 && t.closing && !지금칸글()) 문단닫기();
   }
   문단닫기();   // 안 닫힌 채 끝나는 문서도 있다. 마지막 글을 버리지 않는다.
   return 문단들;
@@ -240,6 +282,16 @@ const 알맹이 = {
   pptx: { 골라 : /^ppt\/slides\/slide(\d+)\.xml$/i, 구획이름: (n, 번호) => `${번호}장` },
 };
 
+/** 꾸러미 속 이름표로 갈래를 짚는다. 경로 없이 버퍼만 받았을 때 쓴다. 모르면 null. */
+function 꾸러미갈래(꾸러미) {
+  for (const [갈, { 골라 }] of Object.entries(알맹이)) {
+    for (const 이름 of 꾸러미.files.keys()) {
+      if (골라.test(이름.replace(/\\/g, '/'))) return 갈;
+    }
+  }
+  return null;
+}
+
 /**
  * 문서 하나를 읽는다.
  *
@@ -248,16 +300,19 @@ const 알맹이 = {
  * 예외가 나면 "문서가 깨졌다" 가 "도구가 터졌다" 로 보고된다.
  */
 export function readDoc(경로또는버퍼, { 표를따로 = false } = {}) {
-  const 갈래 = Buffer.isBuffer(경로또는버퍼) ? null : 종류(경로또는버퍼);
+  const 버퍼로왔나 = Buffer.isBuffer(경로또는버퍼);
+  let 갈래 = 버퍼로왔나 ? null : 종류(경로또는버퍼);
   let buf;
   try {
-    buf = Buffer.isBuffer(경로또는버퍼) ? 경로또는버퍼 : readFileSync(경로또는버퍼);
+    buf = 버퍼로왔나 ? 경로또는버퍼 : readFileSync(경로또는버퍼);
   } catch (err) {
     return { ok: false, error: `못 읽었습니다: ${err.message}` };
   }
-  if (!갈래) return { ok: false, error: '어떤 문서인지 모르는 경로입니다' };
+  if (!갈래 && !버퍼로왔나) return { ok: false, error: '어떤 문서인지 모르는 경로입니다' };
   if (!looksZip(buf)) {
-    return { ok: false, error: 겉속다름말(갈래, 속내용(buf)), 끝났다: true };
+    return 갈래
+      ? { ok: false, error: 겉속다름말(갈래, 속내용(buf)), 끝났다: true }
+      : { ok: false, error: `문서 꾸러미가 아닙니다 — ${속내용(buf) ?? '무엇인지 알아보지 못했습니다'}`, 끝났다: true };
   }
 
   let 꾸러미;
@@ -266,6 +321,18 @@ export function readDoc(경로또는버퍼, { 표를따로 = false } = {}) {
   } catch (err) {
     return { ok: false, error: `꾸러미를 풀지 못했습니다 — ${err.message}` };
   }
+  /*
+   * 버퍼로 온 것은 **꾸러미 속을 보고** 갈래를 짚는다.
+   *
+   * 인자 이름이 `경로또는버퍼` 고 버퍼를 읽는 갈래까지 있는데 갈래는 경로의
+   * 확장자로만 정해서, 버퍼로 부르면 언제나 「어떤 문서인지 모르는 경로입니다」
+   * 였다 — 있는 척만 하는 죽은 길이다 (8회차). 확장자가 없으면 알맹이 이름표가
+   * 유일한 단서고, 셋은 서로 겹치지 않는다.
+   */
+  if (!갈래) 갈래 = 꾸러미갈래(꾸러미);
+  if (!갈래) {
+    return { ok: false, error: '어떤 문서인지 모르는 꾸러미입니다 — hwpx·docx·pptx 의 본문이 없습니다' };
+  }
 
   const { 골라, 구획이름 } = 알맹이[갈래];
   const 찾은 = [];
@@ -273,6 +340,15 @@ export function readDoc(경로또는버퍼, { 표를따로 = false } = {}) {
     const m = 골라.exec(이름.replace(/\\/g, '/'));
     if (m) 찾은.push({ 번호: m[1] ? Number(m[1]) : 0, 몸 });
   }
+  /*
+   * 목록에는 있는데 **못 푼** 구획 (2.0.0 3회차 사냥). readZip 이 건너뛴 것을 안 봐서, 석 장 중 한 장이 깨진
+   * 발표가 두 장짜리 온전한 글처럼 나갔다 — 모델은 그대로 「두 장입니다」 라고 요약한다. 그 자리에 못 읽었다는
+   * 문단을 세운다. 몇째 구획인지가 남아야 사람이 원본의 어디를 열어 볼지 안다.
+   */
+  for (const s of 꾸러미.skipped ?? []) {
+    const m = 골라.exec(String(s.name).replace(/\\/g, '/'));
+    if (m) 찾은.push({ 번호: m[1] ? Number(m[1]) : 0, 몸: null, 못푼까닭: s.why });
+  }
   if (!찾은.length) {
     return { ok: false, error: `${갈래} 꾸러미인데 본문을 찾지 못했습니다. 깨졌거나 비정상 파일입니다.` };
   }
@@ -280,7 +356,7 @@ export function readDoc(경로또는버퍼, { 표를따로 = false } = {}) {
 
   const 덩이들 = 찾은.map((s, i) => ({
     이름: 구획이름(i, s.번호),
-    문단들: 문단뽑기(s.몸.toString('utf8'), 갈래, { 표를따로 }),
+    문단들: s.몸 ? 문단뽑기(s.몸.toString('utf8'), 갈래, { 표를따로 }) : [`(이 구획은 못 읽었습니다 — ${s.못푼까닭})`],
   }));
   return { ok: true, 갈래, 덩이들 };
 }

package/src/tools/edit-match.js

@@ -9,6 +9,7 @@ const TIERS = [
   { id: 'trail',  label: '줄 끝 공백·줄바꿈 차이 무시' },
   { id: 'indent', label: '들여쓰기 차이 무시' },
   { id: 'space',  label: '모든 공백 차이 무시' },
+  { id: 'nfc',    label: '유니코드 정규화(NFC·NFD) 차이 무시' },
 ];
 
 const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -20,27 +21,41 @@ function pattern(needle, tier) {
       // 줄 끝 공백과 CRLF/LF 차이를 흡수한다.
       return lines.map((l) => esc(l.replace(/[ \t]+$/, ''))).join('[ \\t]*\\r?\\n');
     case 'indent':
-      // 줄 앞 들여쓰기까지 흡수한다.
-      return '[ \\t]*' + lines.map((l) => esc(l.trim())).join('[ \\t]*\\r?\\n[ \\t]*');
-    case 'space':
-      // 공백이라면 종류·개수를 가리지 않는다.
-      return esc(needle).replace(/\s+/g, '\\s+');
+      // 줄 앞 들여쓰기까지 흡수한다. 다만 끝이 줄바꿈이면(마지막 조각이 빈 줄) 그 뒤는 **다음 줄**이라
+      // 들여쓰기를 안 먹는다 — 먹으면 갈아 끼울 때 다음 줄이 들여쓰기를 잃었다 (6회차 Gemini 고침맞추기6).
+      return lines
+        .map((l, i) => (i > 0 && i === lines.length - 1 && !l.trim() ? '' : '[ \\t]*') + esc(l.trim()))
+        .join('[ \\t]*\\r?\\n');
+    case 'space': {
+      // 공백이라면 종류·개수를 가리지 않는다. 다만 **끝** 공백은 그 안의 줄바꿈 수만큼만 본다 — `\s+` 가
+      // 다음 줄 들여쓰기·빈 줄·줄바꿈까지 먹어 갈아 끼우면 사라졌다 (6회차 Gemini 고침맞추기6).
+      const 꼬리 = /\s*$/.exec(needle)[0];
+      const 몸 = esc(needle.slice(0, needle.length - 꼬리.length)).replace(/\s+/g, '\\s+');
+      const 줄 = (꼬리.match(/\n/g) ?? []).length;
+      if (줄) return 몸 + '[ \\t]*\\r?\\n'.repeat(줄);
+      return 꼬리 ? `${몸}[ \\t]*(?=\\s|$)` : 몸;
+    }
     default:
       return null;
   }
 }
 
 // 찾은 자리들을 모두 돌려준다.
-function findAll(text, needle, tier) {
+//
+// `전부` 는 replace_all 일 때다. 그때는 **정말 전부** 모은다 — 아래 상한 머리말.
+function findAll(text, needle, tier, { 전부 = false } = {}) {
   if (tier === 'exact') {
     const out = [];
     let i = 0;
     while ((i = text.indexOf(needle, i)) >= 0) {
       out.push({ start: i, end: i + needle.length });
-      i += needle.length || 1;
+      // 모호한지 볼 때는 **겹친 자리도** 센다. 겹치지 않게만 세면 `}\n}\n}` 안의 `}\n}` 두 자리가 한 곳으로
+      // 잡혀 첫 자리를 조용히 고쳤다 (6회차 Gemini 고침맞추기6). replace_all 은 여태처럼 안 겹치게 바꾼다.
+      i += 전부 ? needle.length || 1 : 1;
     }
     return out;
   }
+  if (tier === 'nfc') return 정규화로찾기(text, needle, 전부);
   const p = pattern(needle, tier);
   if (!p) return [];
   let re;
@@ -56,15 +71,140 @@ function findAll(text, needle, tier) {
   // 여기서는 못 찾은 것으로 친다. 정확히 일치하는 경우는 위에서 indexOf 로 이미
   // 처리했으니, 느슨하게 맞춰 보는 이 길만 포기하는 것이다.
   try {
-    for (const m of text.matchAll(re)) {
-      if (m[0].length === 0) continue;
-      out.push({ start: m.index, end: m.index + m[0].length });
-      if (out.length > 50) break;   // 너무 많으면 어차피 모호하다
+    if (전부) {
+      // replace_all 은 여태처럼 **안 겹치게** 걷는다 — 바꿀 자리를 고르는 길이다.
+      for (const m of text.matchAll(re)) {
+        if (m[0].length === 0) continue;
+        out.push({ start: m.index, end: m.index + m[0].length });
+      }
+    } else {
+      /*
+       * ── 모호한지 볼 때는 **겹친 자리도** 센다 (6회차 고침맞추기6dq G2) ──
+       *
+       * 위 「정확히」 단계는 `i += 1` 로 겹친 자리까지 세어 `}\n}\n}` 안의
+       * `}\n}` 두 자리를 모호로 막는다. 그런데 여기는 `matchAll` 이라 한 번
+       * 맞으면 그 끝까지 건너뛴다 — 같은 글에 들여쓰기만 붙으면(`  }` 세 줄,
+       * 파이썬·중괄호 닫는 줄에서 흔한 꼴) 두 자리 중 앞엣것 하나만 잡히고
+       * **조용히 첫 자리를 고쳤다.** 못 찾는 것보다 엉뚱한 곳을 고치는 것이
+       * 나쁘다는 이 파일의 원칙이 단계마다 달랐던 자리다.
+       *
+       * `exec` 로 한 칸씩 밀며 걷는다. 빈 맞춤은 제자리걸음이 되므로 건너뛴다.
+       *
+       * 다만 **끝자리가 같은 것은 한 자리다.** 이 단계의 무늬는 `[ \t]*` 로 시작해서
+       * `  foo` 의 0·1·2 어디서 시작해도 같은 자리에 닿는다 — 그걸 따로 세면 들여쓴
+       * 줄은 죄다 「2군데」 가 되어, 조이려던 것이 **멀쩡한 고치기를 다 막는다.**
+       * 먼저 나온 것(가장 이른 시작)을 남긴다 — matchAll 이 주던 자리와 같다.
+       */
+      const 끝본것 = new Set();
+      for (let i = 0; i <= text.length;) {
+        re.lastIndex = i;
+        const m = re.exec(text);
+        if (!m) break;
+        const 끝 = m.index + m[0].length;
+        if (m[0].length > 0 && !끝본것.has(끝)) { 끝본것.add(끝); out.push({ start: m.index, end: 끝 }); }
+        /*
+         * ── 이 상한은 **모호한지 볼 때만** 쓴다 ──────────────────────────
+         *
+         * 「너무 많으면 어차피 모호하다」 는 replace_all 이 아닐 때의 말이다.
+         * 그런데 replace_all 에도 똑같이 걸려서, 공백만 조금 달라 느슨하게 맞은
+         * 100군데 중 **51군데만** 바꾸고 「고침: (51군데)」 라고 답했다.
+         * 나머지 49군데는 그대로인데 모델은 다 바꾼 줄 알고 넘어간다. 정확히
+         * 맞은 경우(indexOf 길)는 상한이 없어서 느슨한 길에서만 새던 자리다.
+         */
+        if (out.length > 50) break;
+        i = m.index + 1;
+      }
     }
   } catch { return []; }
   return out;
 }
 
+/*
+ * ── 눈에는 같은 글자인데 **코드가 다른** 글 (NFC · NFD) ──────────────────
+ *
+ * 맥에서 만든 파일, 맥 파일 이름을 옮겨 적은 글, 일부 PDF 에서 긁은 글은 한글이
+ * 자모로 풀린 꼴(NFD — ㅎ+ㅏ+ㄴ)로 들어 있다. 모델은 늘 모아 쓴 꼴(NFC)로
+ * 적는다. 화면에는 둘 다 「한글」 인데 indexOf 도 위 느슨한 단계도 못 찾아서,
+ * 모델은 「찾지 못했습니다」 를 받고 Read 로 다시 읽고 **같은 글자로** 또 보내며
+ * 헛돌았다. `é` 를 e + ◌́ 로 적은 글도 같다. 공백은 흡수하면서 이건 못 했다.
+ *
+ * 둘 다 NFD 로 풀어 견준다. 풀기는 글자마다 따로 되고 결합 표시의 순서만
+ * 제자리에서 바뀌므로, **결합하는 글자가 아닌 자리**에서 시작하고 끝나는 곳은
+ * 원래 글의 자리로 되짚을 수 있다. 글자 한가운데(모음 자모 하나 · 결합 표시
+ * 하나)에서 시작하거나 끝나는 곳은 버린다 — 그걸 고치면 글자가 쪼개진다.
+ * 되짚은 자리는 한 번 더 정규화해 견주어 확인한다. 모호하면 거부하는 것은
+ * 다른 단계와 같다.
+ */
+const 결합하는글자 = /^[\p{M}ᅠ-ᇿힰ-퟿]/u;
+
+function 정규화로찾기(text, needle, 전부) {
+  const 풀린글 = text.normalize('NFD');
+  const 풀린바늘 = needle.normalize('NFD');
+  // 둘 다 이미 풀린 꼴이면 위 「정확히」 단계가 이미 본 것이다.
+  if (!풀린바늘 || (풀린글 === text && 풀린바늘 === needle)) return [];
+  // 바늘이 결합하는 글자로 시작하면 어느 자리든 글자 한가운데서 시작한다 (「아각」 의 ㅏ+각).
+  if (결합하는글자.test(풀린바늘)) return [];
+
+  const 자리들 = [];
+  for (let i = 풀린글.indexOf(풀린바늘); i >= 0; i = 풀린글.indexOf(풀린바늘, i + 1)) {
+    const 끝 = i + 풀린바늘.length;
+    // 바로 뒤가 결합하는 글자면 글자 한가운데서 끝난다 — 「각」 안의 「가」 를 고치면 받침이 딴 글자에 붙는다.
+    if (끝 < 풀린글.length && 결합하는글자.test(풀린글.slice(끝, 끝 + 1))) continue;
+    자리들.push([i, 끝]);
+    // 정확히 단계와 같다 — replace_all 이 아니면 겹친 자리도 세어 모호함을 가린다.
+    if (전부) i = 끝 - 1;
+    if (!전부 && 자리들.length > 50) break;
+  }
+  if (!자리들.length) return [];
+
+  // 풀린 글의 자리 → 원래 글의 자리. 글자(코드포인트)마다 풀린 길이를 더해 간다.
+  const 필요 = new Set(자리들.flat());
+  const 맨끝 = 자리들[자리들.length - 1][1];
+  const 되짚기 = new Map();
+  const 풀린길이 = new Map();
+  let t = 0;
+  let k = 0;
+  for (;;) {
+    if (필요.has(t) && !되짚기.has(t)) 되짚기.set(t, k);
+    if (k >= text.length || t >= 맨끝) break;
+    const cp = text.codePointAt(k);
+    const 폭 = cp > 0xFFFF ? 2 : 1;
+    let d = 폭;
+    if (cp >= 0xC0) {
+      d = 풀린길이.get(cp);
+      if (d === undefined) { d = String.fromCodePoint(cp).normalize('NFD').length; 풀린길이.set(cp, d); }
+    }
+    k += 폭;
+    t += d;
+  }
+  const 모은꼴 = needle.normalize('NFC');
+  const out = [];
+  for (const [i, 끝] of 자리들) {
+    const start = 되짚기.get(i);
+    const end = 되짚기.get(끝);
+    if (start === undefined || end === undefined || end <= start) continue;
+    if (text.slice(start, end).normalize('NFC') !== 모은꼴) continue;
+    out.push({ start, end });
+  }
+  return out;
+}
+
+/**
+ * 정규화 단계로 찾았으면 넣는 글도 **파일이 쓰는 꼴**로 맞춘다.
+ *
+ * NFD 파일 한가운데에 NFC 글을 넣으면 같은 파일 안에 두 꼴이 섞인다 — 다음
+ * 고치기에서 또 못 찾고, 맥의 파일 비교 도구는 멀쩡한 줄을 바뀌었다고 한다.
+ * 찾은 자리가 한 꼴로만 되어 있을 때만 맞춘다. 섞였으면 그대로 둔다.
+ */
+export function 꼴맞추기(newString, matched) {
+  const 풀린 = matched.normalize('NFD');
+  const 모은 = matched.normalize('NFC');
+  if (풀린 === 모은) return newString;
+  if (matched === 풀린) return newString.normalize('NFD');
+  if (matched === 모은) return newString.normalize('NFC');
+  return newString;
+}
+
 /**
  * @returns {{ok:true, spans, tier, tierLabel}} 또는
  *          {{ok:false, reason, tier?, count?, near?}}
@@ -73,7 +213,7 @@ export function findMatch(text, needle, { replaceAll = false } = {}) {
   if (!needle) return { ok: false, reason: 'empty' };
 
   for (const t of TIERS) {
-    const spans = findAll(text, needle, t.id);
+    const spans = findAll(text, needle, t.id, { 전부: replaceAll });
     if (!spans.length) continue;
     if (spans.length > 1 && !replaceAll) {
       return { ok: false, reason: 'ambiguous', tier: t.id, count: spans.length };
@@ -135,15 +275,74 @@ export function reindent(newString, matchedText, needle) {
   const shiftable = lines.every((l, i) => i === 0 || !l.trim() || l.startsWith(needleIndent));
   if (!shiftable) return newString;
 
+  const 더들여쓰기 = 단위바꾸개(fileIndent, needleIndent);
   return lines
     .map((l, i) => {
       if (i === 0) return fileIndent + l.replace(/^[ \t]*/, '');
       if (!l.trim()) return l;
-      return fileIndent + l.slice(needleIndent.length);
+      const 나머지 = l.slice(needleIndent.length);
+      const 더 = /^[ \t]*/.exec(나머지)[0];
+      return fileIndent + 더들여쓰기(더) + 나머지.slice(더.length);
     })
     .join('\n');
 }
 
+/*
+ * ── 바깥 들여쓰기만 갈아 끼우면 **안쪽이 섞인다** ─────────────────────────
+ *
+ * 위 reindent 는 줄 앞의 「모델 들여쓰기」 를 「파일 들여쓰기」 로 바꾸기만
+ * 했다. 탭으로 쓴 파일에 모델이 네 칸 공백으로 적어 보내면 이렇게 됐다:
+ *
+ *     파일      \tif (x) {\n\t\treturn 1;
+ *     모델      ····if (y) {\n········return 2;
+ *     넣은 것   \tif (y) {\n\t····return 2;     ← 탭 뒤에 공백 넷
+ *
+ * 바깥 한 단만 탭이고 그 안쪽 한 단은 모델의 공백이 그대로 남는다. 파이썬이면
+ * 그 자리에서 TabError 고, 아니어도 편집기마다 들여쓰기가 달리 보인다.
+ *
+ * 모델 들여쓰기와 파일 들여쓰기가 **한 종류씩**이고(탭만 · 공백만) 나누어
+ * 떨어질 때만 한 단의 폭을 알 수 있다 — 탭 하나를 모델이 몇 칸으로 적었나.
+ * 그 폭으로 안쪽 들여쓰기도 옮긴다. 폭을 모르면(바깥이 비었거나 섞였으면)
+ * 여태처럼 그대로 둔다. 어설피 고치면 더 나쁘다는 위 머리말과 같은 자세다.
+ */
+function 단위바꾸개(fileIndent, needleIndent) {
+  const 탭만 = (s) => /^\t+$/.test(s);
+  const 칸만 = (s) => /^ +$/.test(s);
+  if (탭만(fileIndent) && 칸만(needleIndent) && needleIndent.length % fileIndent.length === 0) {
+    const 폭 = needleIndent.length / fileIndent.length;
+    return (더) => (칸만(더) ? '\t'.repeat(Math.floor(더.length / 폭)) + ' '.repeat(더.length % 폭) : 더);
+  }
+  if (칸만(fileIndent) && 탭만(needleIndent) && fileIndent.length % needleIndent.length === 0) {
+    const 폭 = fileIndent.length / needleIndent.length;
+    return (더) => (탭만(더) ? ' '.repeat(더.length * 폭) : 더);
+  }
+  return (더) => 더;
+}
+
+/*
+ * ── 넣는 글의 줄끝은 **파일의 줄끝**을 따른다 ────────────────────────────
+ *
+ * 모델은 줄바꿈을 늘 `\n` 으로 적는다. 느슨하게 찾는 길(trail)은 그 차이를
+ * 흡수해서 CRLF 파일에서도 자리를 찾아 주는데, 넣는 쪽은 모델이 준 `\n` 을
+ * 그대로 넣었다. 그래서 `.bat` 두 줄을 세 줄로 고치면 —
+ *
+ *     @echo off\r\n set A=10\n set B=20\n set C=30\r\n goto :end\r\n
+ *
+ * 고친 자리만 LF 인 파일이 된다. cmd.exe 는 LF 만 있는 줄에서 레이블(goto)을
+ * 헛짚고, git 은 줄마다 바뀌었다고 하고, /diff 에는 글자가 같아 안 보인다.
+ *
+ * CRLF **만** 쓰는 파일일 때만 맞춘다. 이미 섞인 파일은 어느 쪽이 맞는지
+ * 모르니 손대지 않는다.
+ */
+export function CRLF뿐인가(text) {
+  const t = String(text ?? '');
+  return t.includes('\r\n') && !/(^|[^\r])\n/.test(t);
+}
+
+export function CRLF로(s) {
+  return String(s).replace(/\r?\n/g, '\r\n');
+}
+
 // 찾은 자리들을 실제로 바꾼다. 뒤에서부터 바꿔야 앞쪽 위치가 안 밀린다.
 export function applySpans(text, spans, makeReplacement) {
   let out = text;