deel-local-cli 1.2.0 → 1.4.1

package/src/tools/desc.en.js

@@ -0,0 +1,221 @@
+/**
+ * 도구 설명 영어판 — 모델이 읽는 글이다.
+ *
+ * ── 왜 여기 따로 두나 ───────────────────────────────────────────────────
+ *
+ * index.js 의 한글 설명은 손대지 않는다. 저 글은 오래 겪으면서 한 문장씩
+ * 눌러 온 것이라(“앞부분을 다시 보내지 마라”, “파일 목록만 봐서는 안 보인다”),
+ * 그 파일을 두 언어로 갈라 놓으면 다음에 한쪽만 고치게 된다. 여기 표에
+ * 없는 것은 한글 설명이 그대로 나간다 — 화면 말과 같은 규칙이다.
+ *
+ * ── 왜 옮기나 ───────────────────────────────────────────────────────────
+ *
+ * 두 가지다. 하나는 영어로 켠 사람이 한국어 도구 설명을 받으면, 모델이
+ * 무엇을 골라야 할지를 못 읽는다는 것. 다른 하나는 **토큰**이다.
+ * 도구 정의는 매 요청에 통째로 실리는 고정 몫인데, 한글은 글자당 약 1토큰이고
+ * 영문은 약 3.6자당 1토큰이다. 32k 창에서 이 몫이 10% 를 넘게 먹고 있었다.
+ *
+ * ── 옮길 때 지킨 것 ─────────────────────────────────────────────────────
+ *
+ * 규칙을 한 줄도 안 뺐다. 특히 이런 줄들은 글자 그대로 옮겼다 —
+ * 빠지면 그 모델만 조용히 다르게 굴고, 그 차이는 몇 걸음 뒤에야 드러난다.
+ *
+ *   Edit  “먼저 Read 로 읽어야 한다”      · 안 읽고 고치는 것을 막는 자리
+ *   Append“앞부분을 다시 보내지 마라”     · 같은 자리에서 또 잘리는 것을 막는 자리
+ *   Bash  “끝나지 않는 것은 background”   · 시간 초과로 죽는 것을 막는 자리
+ *   Verify“확인 못 한 것은 못 했다고”     · 이 프로그램이 거짓말을 안 하게 하는 자리
+ *
+ * 도구 이름과 인자 이름은 **안 옮긴다.** 그건 식별자다. Task 의 목적·할일처럼
+ * 한글로 된 인자 이름도 그대로 둔다 — 이름을 바꾸면 그 도구가 아예 안 불린다.
+ */
+export const 도구설명EN = {
+  Read: {
+    desc: 'Read one file. Line numbers come back with it. You must read a file before editing it.'
+      + ' Excel files (.xlsx/.xlsm/.xls) can be read directly too — they come back as CSV per sheet.'
+      + ' Korean HWP, Word and PowerPoint documents (.hwpx/.docx/.pptx) read directly as well —'
+      + ' they come back as plain text. There is no need to ask the user to export anything.'
+      + ' All of these are read-only here, though.',
+    params: {
+      file_path: 'path of the file to read',
+      offset: 'first line (1-based). Only for large files',
+      limit: 'how many lines to read',
+    },
+  },
+  Write: {
+    desc: 'Create a file, or overwrite one completely. Use Edit to change part of a file.'
+      + ' **You can create several files in one call** — pass them as an array in files.'
+      + ' Do that when you are laying out a folder structure. One call per file means one model'
+      + ' round trip per file, and an eight-file skeleton loses minutes to that.',
+    params: {
+      file_path: 'path to write (single file)',
+      content: 'the whole file content (single file)',
+      files: 'several files at once. When you use this, leave file_path and content out.',
+    },
+  },
+  Append: {
+    desc: 'Append to the end of a file. This is how you build a large file — Write the first part,'
+      + ' then call Append repeatedly until it is complete. Splitting it and landing it for certain'
+      + ' beats trying to fit it in one call and getting cut off. No Read needed first — you are only'
+      + ' adding to the end, so there is nothing to read.',
+    params: {
+      file_path: 'path of the file to append to',
+      content: 'what to add at the end',
+    },
+  },
+  Edit: {
+    desc: 'Replace an exactly matching string in a file. You must Read it first.'
+      + ' **If there are several places to change, send them in one call as the edits array** —'
+      + ' they may even be in different files. One call per place means one model round trip per'
+      + ' place, and a six-place cleanup loses minutes to that.',
+    params: {
+      file_path: 'path of the file to edit (single edit)',
+      old_string: 'what to replace. Must be unique within the file',
+      new_string: 'what to replace it with',
+      replace_all: 'true to replace every occurrence',
+      edits: 'several places at once, applied in the order given. When you use this, leave the arguments above out.',
+    },
+  },
+  Glob: {
+    desc: 'Find files by name pattern. e.g. **/*.js, src/**/*.{ts,tsx}',
+    params: {
+      pattern: 'glob pattern',
+      path: 'folder to start from. Defaults to the whole working folder',
+    },
+  },
+  Grep: {
+    desc: 'Search file contents with a regular expression.',
+    params: {
+      pattern: 'regular expression',
+      path: 'folder or file to search',
+      glob: 'restrict which files. e.g. **/*.js',
+      output_mode: 'defaults to files_with_matches',
+      '-i': 'ignore case',
+      '-n': 'show line numbers',
+      head_limit: 'cap the number of results',
+    },
+  },
+  Skill: {
+    desc: 'Open one skill and read it. The list carries only names and descriptions,'
+      + ' so pick the one you need and pull its body with this.',
+    params: { name: 'skill name, exactly as listed' },
+  },
+  Bash: {
+    desc: 'Run a command. Commands that cannot be undone are blocked.'
+      + ' **Anything that never ends (dev servers, watch) must be started with background: true** —'
+      + ' called plainly it dies on timeout. After starting one, read its output with Jobs.',
+    params: {
+      command: 'the command to run',
+      description: 'one line on what this command does',
+      timeout: 'time limit in ms. Default 120000',
+      background: 'true for a command that never ends. Returns immediately; read it with Jobs',
+    },
+  },
+  WebFetch: {
+    desc: 'Read a web page. Read-only — nothing is sent. Use it to check documentation, an error'
+      + ' message, or how a library is used. Addresses on this machine or an internal network are'
+      + ' not read. Several calls to the same site go out one after another, so they cost that much'
+      + ' more time — fetch only what you need. Truncated JSON cannot be read, so if it comes back'
+      + ' cut, narrow the request or raise max_chars and call again.',
+    params: {
+      url: 'address to read (http/https)',
+      max_chars: 'maximum characters to pull. Left out, it is sized to the model. Raise it if the'
+        + ' material comes back cut (max 120000)',
+    },
+  },
+  Recall: {
+    desc: 'Search past sessions in this folder. When the user points back ("last time"), use this'
+      + ' instead of asking again. This does not search file contents — that is Grep.',
+    params: {
+      query: 'what to look for. Two or three words (e.g. "CP949 encoding")',
+      limit: 'how many to bring back (default 8)',
+      tools: 'also dig through tool results (default false)',
+    },
+  },
+  Remember: {
+    desc: 'Write one line that outlives this session. Rules the user set, promises made, mistakes'
+      + ' not to repeat. Do not record anything that only applies to this job, or anything a file'
+      + ' would tell you. This line rides on every later request — keep it to one sentence.',
+    params: { text: 'one line (e.g. "internal documents are read as CP949 and written back as CP949")' },
+  },
+  TodoWrite: {
+    desc: 'Create and update the todo list. For anything that takes several steps, build the list'
+      + ' first and update it the moment each step finishes. Always send the whole list. state is'
+      + ' one of todo / doing / done, and only one item may be doing at a time. The number of steps'
+      + ' is set by the size of the job — there is no fixed count and no cap. Do not squeeze unrelated'
+      + ' work into one line to hit a number. Write each step small enough to check on its own.',
+    params: { todos: 'the whole todo list. No cap — as many as the job needs' },
+  },
+  Verify: {
+    desc: 'Check that what you made actually works. Call this **before** you finish, without fail.'
+      + ' A file existing and a file working are different things — an unclosed tag, a src pointing'
+      + ' at a file that is not there, one missing bracket in JS: none of that shows in a file listing.'
+      + ' What can be run gets run (node --check, py_compile); what cannot gets read (HTML tag pairs,'
+      + ' missing references, CSS braces, JSON). Whatever it could not check, it tells you it could not.'
+      + ' Running tests or a build is Bash — that goes through the user for approval.',
+    params: { paths: 'files to check. Left out, it checks everything checkable in the working folder.' },
+  },
+  Outline: {
+    desc: 'See only the **skeleton** of a folder or file — per file, the names and line numbers of'
+      + ' functions, classes, types, and headings. Call this before touching code you did not write.'
+      + ' It tells you what is where for a fraction of what reading whole files costs. Pick the places'
+      + ' to change here, then Read **only those files**. Reads js/ts, py, java/kotlin, go, rust, c#,'
+      + ' md, html, css, sh, json.',
+    params: {
+      path: 'folder or file path. Defaults to the whole working folder',
+      pattern: 'narrow by name (e.g. **/*.js). Left out, everything',
+    },
+  },
+  Task: {
+    desc: 'Split a chunk of a large job off as a subtask and **run it separately.** The subtask works'
+      + ' start to finish in its own conversation and returns only a summary — the files it read do'
+      + ' not pile up in your window. That is why work that creates or edits several files has to be'
+      + ' divided this way to get to the end. One chunk must be finishable on its own (e.g. "create'
+      + ' index.html and style.css"). The subtask cannot see your conversation — put everything it'
+      + ' needs into 할일. Do not use this for one short job. Doing it yourself is faster.',
+    params: {
+      목적: 'this chunk in one line (e.g. "build the dashboard page skeleton")',
+      할일: 'everything the subtask has to do. It cannot see this conversation, so put the background,'
+        + ' the decisions, and the file paths here. Say what counts as done, too.',
+      모드: 'how the subtask works: code (builds and edits) · debug (finds causes) · ask (reads and'
+        + ' answers only). Defaults to code.',
+      모델: 'hand this chunk to a **different model**. Only profile names the user has configured'
+        + ' work (do not invent an address — it will not be accepted). Left out, it stays on the model'
+        + ' you are using. Handing routine work (formatting, repetitive edits, short summaries) to a'
+        + ' small model keeps your window from filling. Do the work that needs judgement yourself.',
+    },
+  },
+  Def: {
+    desc: 'Ask the language server **where a name is defined.** You get the location without reading'
+      + ' the file. Unlike Grep it does not hand you the wrong places — not the same name in a comment,'
+      + ' not the same name in a third-party library, not the same name inside a string.'
+      + ' Call this before touching code you did not write. Once you know where it is, Read only that file.'
+      + ' If the name exists in several places you get the list, and file_path picks one.',
+    params: {
+      name: 'the name to find (function, class, variable)',
+      file_path: 'the file the name is used in. Use it when the same name exists in several places',
+      line: 'line number inside file_path where the name appears (1-based)',
+    },
+  },
+  Refs: {
+    desc: 'Ask the language server for **every place a name is used.** Call it before you rename'
+      + ' something or change a function — this is what tells you how many places have to change together.'
+      + ' Unlike the hundreds of lines Grep gives you, only the places that really use it come back.'
+      + ' Grep still finds comments, config and docs, though: use this for the code and Grep for the rest'
+      + ' when you rename something outright.',
+    params: {
+      name: 'the name to find (function, class, variable)',
+      file_path: 'the file the name is defined in. Use it when the same name exists in several places',
+      line: 'line number inside file_path where the name appears (1-based)',
+      include_declaration: 'include the definition itself. Default false',
+    },
+  },
+  Jobs: {
+    desc: 'List, read, and end background commands (Bash with background). Called with no number,'
+      + ' you get the list. Given a number, you get whatever output arrived since last time.'
+      + ' If you started a server, you must end it when the job is done.',
+    params: {
+      번호: 'job number to look at. Left out, the list',
+      끝내기: 'true to end that job (stop)',
+    },
+  },
+};

package/src/tools/docs.js

@@ -0,0 +1,252 @@
+/**
+ * 사내 문서 읽기 — hwpx · docx · pptx → 글.
+ *
+ * ── 왜 필요한가 ─────────────────────────────────────────────────────────
+ *
+ * 사내망의 스펙·공문·회의록이 이 세 형식이다. 지금까지는 Read 가 "바이너리라
+ * 못 읽음" 으로 끝났고, 그 끝이 사고를 낳았다 — hwp 를 정리해 달라고 했더니
+ * Read 가 실패하자 모델이 Write 로 새로 써서 원본이 죽었다. 덮어쓰기는 이제
+ * 막혀 있지만, **읽기가 되면 그 길 자체가 없어진다.** 문서를 주고 "이대로
+ * 만들어" 라고 시키는 일이 비로소 된다.
+ *
+ * 해외 CLI 어느 것도 hwp 계열을 못 읽는다. 이 파일이 있는 자리(한국 사내망)가
+ * 이 프로그램이 도는 자리다.
+ *
+ * ── 왜 의존성 없이 되나 ─────────────────────────────────────────────────
+ *
+ * 셋 다 속은 ZIP + XML 이다(hwpx 는 한컴의 공개 규격 OWPML).
+ * ZIP 은 우리 zip 읽개(pack/zip.js)로, XML 은 xlsx 가 쓰는 작은 읽기(tags)로
+ * 푼다. 새로 들이는 것이 없다.
+ *
+ *   hwpx  Contents/section*.xml   글은 <hp:t>, 문단은 <hp:p>, 표는 <hp:tbl>
+ *   docx  word/document.xml       글은 <w:t>,  문단은 <w:p>,  표는 <w:tbl>
+ *   pptx  ppt/slides/slide*.xml   글은 <a:t>,  문단은 <a:p>,  장이 구획
+ *
+ * ── 읽기만 한다 ─────────────────────────────────────────────────────────
+ *
+ * 엑셀과 같은 이유로 고치기는 안 한다. 서식·그림·양식이 든 문서를 글로
+ * 왕복시키면 반드시 뭔가 잃는다. 잃은 채로 저장된 문서는 겉보기에 멀쩡해서,
+ * 잃은 것을 알아차렸을 때는 원본이 없다.
+ *
+ * 구형 hwp(OLE 복합문서)는 아예 다른 물건이라 여기서 안 다룬다. 대신 못
+ * 읽는다고 말할 때 **어떻게 하면 되는지**(한글에서 hwpx 로 저장)를 같이 준다 —
+ * 길 없는 거절은 모델을 우회로(새로 쓰기)로 몬다.
+ */
+import { readFileSync } from 'node:fs';
+import { extname, basename } from 'node:path';
+import { readZip, looksZip } from '../pack/zip.js';
+import { tags, unescapeXml } from './xlsx.js';
+
+const 확장자 = { '.hwpx': 'hwpx', '.docx': 'docx', '.pptx': 'pptx' };
+
+/** 이 길로 읽는 파일인가. 구형 .hwp 는 아니다 — 그건 별도 안내 대상이다. */
+export function isDocPath(p) {
+  if (typeof p !== 'string' || !p) return false;
+  return extname(p).toLowerCase() in 확장자;
+}
+
+/** 어떤 문서인가. */
+export function 종류(p) {
+  return 확장자[extname(String(p ?? '')).toLowerCase()] ?? null;
+}
+
+/** 구형 hwp 인가 (OLE 복합문서 서명). Read 가 안내문을 고를 때 쓴다. */
+export function looksOldHwp(경로, buf) {
+  if (extname(String(경로 ?? '')).toLowerCase() !== '.hwp') return false;
+  return buf.length >= 8 && buf.readUInt32LE(0) === 0xe011cfd0 && buf.readUInt32LE(4) === 0xe11ab1a1;
+}
+
+/** 구형 hwp 를 만났을 때 하는 말. 길을 같이 준다. */
+export function 옛hwp안내(보인이름) {
+  return `구형 hwp 형식이라 읽지 못합니다: ${보인이름}\n`
+    + '  한글(한컴오피스)에서 이 파일을 열어 **hwpx 로 저장**하면 그대로 읽을 수 있습니다.\n'
+    + '  (다른 이름으로 저장 → 파일 형식에서 hwpx 선택)\n'
+    + '  이 파일을 Write 로 새로 만들면 안 됩니다 — 원본이 사라집니다.';
+}
+
+/*
+ * ── XML → 문단들 ────────────────────────────────────────────────────────
+ *
+ * 형식마다 태그 이름만 다르고 뼈대는 같다: 문단 태그 사이의 글 태그를 모으고,
+ * 표 칸은 | 로 잇는다. 그래서 이름표만 형식별로 두고 걷는 것은 하나다.
+ *
+ * 이름 앞머리(hp: · w: · a:)는 문서마다 접두어가 다를 수 있어 **끝 이름**으로
+ * 견준다. 접두어는 XML 선언부가 정하는 별명일 뿐이라 값이 고정이 아니다.
+ */
+const 이름표 = {
+  hwpx: { 글: 't', 문단: 'p', 표: 'tbl', 행: 'tr', 칸: 'tc', 줄바꿈: null, 탭: null },
+  docx: { 글: 't', 문단: 'p', 표: 'tbl', 행: 'tr', 칸: 'tc', 줄바꿈: 'br', 탭: 'tab' },
+  pptx: { 글: 't', 문단: 'p', 표: 'tbl', 행: 'tr', 칸: 'tc', 줄바꿈: 'br', 탭: null },
+};
+
+const 끝이름 = (name) => {
+  const i = name.indexOf(':');
+  return i < 0 ? name : name.slice(i + 1);
+};
+
+/**
+ * XML 한 장을 문단 목록으로.
+ *
+ * 표는 행마다 한 줄로 펴고 칸을 ` | ` 로 잇는다. 칸을 그냥 이어 붙이면
+ * "이름값가1" 같은 덩어리가 되는데, 그건 뜻이 사라진 글이라 안 읽은 것보다
+ * 나쁘다 — 모델이 그걸 근거로 답한다.
+ */
+export function 문단뽑기(xml, 갈래) {
+  const 표기 = 이름표[갈래];
+  const 문단들 = [];
+
+  let 글모음 = [];        // 지금 문단의 글 조각들
+  let 표깊이 = 0;
+  let 행칸들 = null;      // 표 행 안일 때: 칸 글들
+  let 칸글 = null;        // 표 칸 안일 때: 그 칸의 글 조각들
+  let 글안 = false;       // <t> 안인가 — 글 태그 밖의 지시문·수식 글을 안 줍기 위해
+
+  const 문단닫기 = () => {
+    const 글 = 글모음.join('').trimEnd();
+    글모음 = [];
+    if (글.trim()) 문단들.push(글);
+  };
+
+  for (const t of tags(xml)) {
+    if (t.text !== undefined) {
+      if (!글안 || t.blank) continue;
+      const 글 = unescapeXml(t.text);
+      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 ? -1 : (t.selfClosing ? 0 : 1); continue; }
+    if (표깊이 > 0 && 이름 === 표기.행) {
+      if (t.closing) {
+        if (행칸들) 문단들.push(행칸들.map((x) => x.trim()).join(' | '));
+        행칸들 = null;
+      } else {
+        행칸들 = [];
+      }
+      continue;
+    }
+    if (표깊이 > 0 && 이름 === 표기.칸) {
+      if (t.closing) {
+        if (행칸들 && 칸글) 행칸들.push(칸글.join(''));
+        칸글 = null;
+      } else {
+        칸글 = [];
+      }
+      continue;
+    }
+
+    if (이름 === 표기.문단 && t.closing && !칸글) 문단닫기();
+  }
+  문단닫기();   // 안 닫힌 채 끝나는 문서도 있다. 마지막 글을 버리지 않는다.
+  return 문단들;
+}
+
+/*
+ * 형식별로 어느 파일이 알맹이인가.
+ *
+ * 이름을 **숫자로** 세운다. 글자로 세우면 slide10 이 slide2 앞에 온다 —
+ * 장 차례가 뒤섞인 발표 자료는 안 읽은 것보다 나쁘다.
+ */
+const 알맹이 = {
+  hwpx: { 골라 : /^Contents\/section(\d+)\.xml$/i, 구획이름: (n) => `구획 ${n + 1}` },
+  docx: { 골라 : /^word\/document\.xml$/i, 구획이름: () => '본문' },
+  pptx: { 골라 : /^ppt\/slides\/slide(\d+)\.xml$/i, 구획이름: (n, 번호) => `${번호}장` },
+};
+
+/**
+ * 문서 하나를 읽는다.
+ *
+ * @returns {{ok:true, 갈래, 덩이들:[{이름, 문단들}]} | {ok:false, error}}
+ * 던지지 않는다 — 깨진 파일은 도구 실행 한가운데서 만나는 것이라,
+ * 예외가 나면 "문서가 깨졌다" 가 "도구가 터졌다" 로 보고된다.
+ */
+export function readDoc(경로또는버퍼) {
+  const 갈래 = Buffer.isBuffer(경로또는버퍼) ? null : 종류(경로또는버퍼);
+  let buf;
+  try {
+    buf = Buffer.isBuffer(경로또는버퍼) ? 경로또는버퍼 : readFileSync(경로또는버퍼);
+  } catch (err) {
+    return { ok: false, error: `못 읽었습니다: ${err.message}` };
+  }
+  if (!갈래) return { ok: false, error: '어떤 문서인지 모르는 경로입니다' };
+  if (!looksZip(buf)) {
+    return { ok: false, error: `${갈래} 모양이 아닙니다 — 겉은 ${갈래} 인데 속이 zip 꾸러미가 아닙니다. 깨졌거나 다른 형식입니다.` };
+  }
+
+  let 꾸러미;
+  try {
+    꾸러미 = readZip(buf);
+  } catch (err) {
+    return { ok: false, error: `꾸러미를 풀지 못했습니다 — ${err.message}` };
+  }
+
+  const { 골라, 구획이름 } = 알맹이[갈래];
+  const 찾은 = [];
+  for (const [이름, 몸] of 꾸러미.files) {
+    const m = 골라.exec(이름.replace(/\\/g, '/'));
+    if (m) 찾은.push({ 번호: m[1] ? Number(m[1]) : 0, 몸 });
+  }
+  if (!찾은.length) {
+    return { ok: false, error: `${갈래} 꾸러미인데 본문을 찾지 못했습니다. 깨졌거나 비정상 파일입니다.` };
+  }
+  찾은.sort((a, b) => a.번호 - b.번호);
+
+  const 덩이들 = 찾은.map((s, i) => ({
+    이름: 구획이름(i, s.번호),
+    문단들: 문단뽑기(s.몸.toString('utf8'), 갈래),
+  }));
+  return { ok: true, 갈래, 덩이들 };
+}
+
+// 다 실어 봐야 창만 찬다. 엑셀(toText)과 같은 상한을 쓴다.
+const 최대글자 = 60000;
+
+/**
+ * 덩이들을 한 장의 글로.
+ *
+ * 자르면 잘랐다고 말한다 — 조용히 자르면 모델은 그게 전부인 줄 알고
+ * "문서에 그런 내용 없다" 고 답한다.
+ */
+export function toText(덩이들, { maxChars = 최대글자 } = {}) {
+  const 잘림 = [];
+  const 조각 = [];
+  let 셈 = 0;
+  let 여럿 = (덩이들?.length ?? 0) > 1;
+
+  for (const d of 덩이들 ?? []) {
+    if (여럿) 조각.push(`--- ${d.이름} ---`);
+    for (const 문단 of d.문단들) {
+      if (셈 + 문단.length > maxChars) {
+        잘림.push(`${maxChars.toLocaleString()}자에서 잘랐습니다 — 뒷부분은 안 실렸습니다`);
+        return { text: 조각.join('\n'), 잘림 };
+      }
+      조각.push(문단);
+      셈 += 문단.length + 1;
+    }
+  }
+  return { text: 조각.join('\n'), 잘림 };
+}
+
+/** 한 줄 요약. Read 의 summary 자리로 간다. */
+export function summarize(r) {
+  if (!r?.ok) return '';
+  const 문단수 = r.덩이들.reduce((n, d) => n + d.문단들.length, 0);
+  const 구획 = r.덩이들.length > 1 ? ` · ${r.갈래 === 'pptx' ? `${r.덩이들.length}장` : `구획 ${r.덩이들.length}개`}` : '';
+  return `${r.갈래}${구획} · ${문단수}문단`;
+}
+
+/** 고치려 들 때 하는 말. 엑셀과 같은 꼴 — 왜 안 되는지와 그럼 어떻게 하는지. */
+export function 문서는못고침(보인이름) {
+  const 갈 = 종류(보인이름) ?? '문서';
+  return `${갈} 문서는 이 도구로 고칠 수 없습니다: ${보인이름}\n`
+    + '  읽기만 됩니다 (글로 바꿔서 보여줍니다). 서식·그림·양식이 든 문서를\n'
+    + '  글로 왕복시키면 반드시 뭔가 잃기 때문입니다.\n'
+    + `  내용을 바꿔야 한다면 ${basename(String(보인이름))} 은 그대로 두고, 바뀐 내용을\n`
+    + '  글 파일(.md 등)로 따로 만들어 사용자에게 건네세요.';
+}