deel-local-cli 1.15.1 → 1.16.0

package/src/commands.js

@@ -16,6 +16,7 @@ import { load, save, 저장시도, resolveKey, upsert, 열쇠보관, configPath
 import { 지금상태 as 지금열쇠상태, 받기설정, 잊기 as 받은열쇠잊기 } from './safety/authcmd.js';
 // 열쇠받기 명령을 정책이 못박아 뒀을 수 있다 — 받기설정 이 그 값을 같이 본다.
 import { 정책읽기 } from './safety/policy.js';
+import { 걸음수 } from './agent/budget.js';
 import { 제공자고르기 } from './providers/index.js';
 import { 종, 알릴만한초 } from './ui/notify.js';
 /*
@@ -1057,7 +1058,7 @@ export async function handle(line, session, ctx) {
     case 'work':
     case 'auto':
     case 'code': case 'plan': case 'architect':
-    case 'debug': case 'ask': case 'orchestrator': {
+    case 'debug': case 'ask': case 'inspect': case 'orchestrator': {
       // 인자 없이 /work 만 치면 지금 모드와 고를 수 있는 것을 보여 준다.
       if (name === 'work' && !arg.trim()) { showWork(session); return { handled: true }; }
 
@@ -1080,13 +1081,15 @@ export async function handle(line, session, ctx) {
       session.routed = null;
       const w = getWork(골라진);
       say('');
-      say(`  ${c.hcyan(w.glyph)} ${c.bold(보일이름(w.id))} ${c.gray('(' + w.en + ')')}  ${c.gray(보일한줄(w.id))}`);
-      say(`  ${c.gray('도구')}    ${canWrite(골라진) ? c.yellow('읽기 + 파일 바꾸기') : c.green('읽기만 — 파일을 못 바꿉니다')}`);
-      say(`  ${c.gray('생각')}    ${c.white(w.think ?? session.think)}${c.gray('·')}${c.magenta(w.effort)}   ${c.gray('최대 ' + w.steps + '걸음')}`);
+      // 영어 화면에서 이름과 영문 이름은 같은 글자다 — 「Inspect (Inspect)」 를 안 만든다.
+      const 곁이름 = 언어() === 'en' ? '' : ` ${c.gray(`(${w.en})`)}`;
+      say(`  ${c.hcyan(w.glyph)} ${c.bold(보일이름(w.id))}${곁이름}  ${c.gray(보일한줄(w.id))}`);
+      say(`  ${c.gray(pad(말('work.tools'), 6))}  ${canWrite(골라진) ? c.yellow(말('work.toolsWrite')) : c.green(말('work.toolsRead'))}`);
+      say(`  ${c.gray(pad(말('work.think'), 6))}  ${c.white(w.think ?? session.think)}${c.gray('·')}${c.magenta(w.effort)}   ${c.gray(말('work.steps', { n: 걸음수(w.id, session.conn?.ctx) }))}`);
       if (골라진 === 'auto') {
-        say(`  ${c.gray('앞으로는 한마디마다 알맞은 모드로 저절로 옮겨 갑니다.')}`);
+        say(`  ${c.gray(말('work.autoOn'))}`);
       } else {
-        say(`  ${c.gray('직접 고르셨으므로 저절로 바뀌지 않습니다. 다시 맡기려면')} ${c.cyan('/work 종합')}`);
+        say(`  ${c.gray(말('work.pinned'))} ${c.cyan(`/work ${보일이름('auto')}`)}`);
       }
       say('');
       return { handled: true };
@@ -3145,18 +3148,33 @@ const INIT_TEMPLATE = `# DEEL.md
 
 // /work 를 인자 없이 부르면 지금 모드와 고를 수 있는 것들을 보여 준다.
 function showWork(session) {
-  rule('작업 모드', 70);
+  rule(말('work.title'), 70);
+  /*
+   * 이름 칸을 **제일 긴 이름에 맞춰** 잡는다.
+   *
+   * 8칸으로 못 박아 뒀더니 Orchestrator(12자)가 칸을 넘어 다음 칸을 밀었다.
+   * 화면에 `OrchestratorOrchestrator` 라고 붙어 나왔다 — 사진을 찍어 보고서야
+   * 알았다. 목록의 값은 칸이 맞아야 목록이다.
+   */
+  const 이름들 = WORK_ORDER.map((k) => 보일이름(WORK_MODES[k].id));
+  const 칸너비 = Math.max(...이름들.map((n) => width(n))) + 2;
+  // 영어 화면에서는 이름과 영문 이름이 같은 글자다. 같은 것을 두 번 적지 않는다.
+  const 영문칸 = 언어() === 'en' ? 0 : 14;
+
   for (const k of WORK_ORDER) {
     const w = WORK_MODES[k];
     const 지금 = k === (normWork(session.work) ?? WORK_DEFAULT);
     const 표 = 지금 ? c.hgreen('●') : c.gray('·');
-    const 보임 = 보일이름(w.id);
-    const 이름 = 지금 ? c.bold(c.white(pad(보임, 8))) : c.gray(pad(보임, 8));
-    say(`  ${표} ${c.hcyan(w.glyph)} ${이름}${c.gray(pad(w.en, 14))}${c.gray(보일한줄(w.id))}`);
-    say(`        ${canWrite(k) ? c.gray('파일 바꿈') : c.green('읽기만')}${c.gray('  ·  생각 ' + (w.think ?? '그대로') + '·' + w.effort + '  ·  최대 ' + w.steps + '걸음')}`);
+    const 보임 = pad(보일이름(w.id), 칸너비);
+    const 이름 = 지금 ? c.bold(c.white(보임)) : c.gray(보임);
+    say(`  ${표} ${c.hcyan(w.glyph)} ${이름}${영문칸 ? c.gray(pad(w.en, 영문칸)) : ''}${c.gray(보일한줄(w.id))}`);
+    const 강도 = `${w.think ?? '—'}·${w.effort}`;
+    const 걸음 = 말('work.steps', { n: 걸음수(k, session.conn?.ctx) });
+    say(`        ${canWrite(k) ? c.gray(말('work.canEdit')) : c.green(말('work.readOnly'))}`
+      + `${c.gray(`  ·  ${말('work.think')} ${강도}  ·  ${걸음}`)}`);
   }
   say('');
-  say(`  ${c.gray('바꾸려면')} ${c.cyan('/plan')} ${c.cyan('/code')} ${c.cyan('/debug')} ${c.gray('…  또는')} ${c.cyan('Ctrl+O')} ${c.gray('로 차례로')}`);
-  say(`  ${c.gray('이건 승인 정책(')}${c.cyan('/mode')}${c.gray(')과 다른 축입니다 — 무엇을 하느냐 / 얼마나 물어보냐.')}`);
+  say(`  ${c.gray(말('work.howTo', { a: c.cyan('/plan'), b: c.cyan('/code'), c: c.cyan('/debug'), 키: c.cyan('Ctrl+O') }))}`);
+  say(`  ${c.gray(말('work.axis', { 명령: c.cyan('/mode') }))}`);
   say('');
 }

package/src/completion.js

@@ -39,6 +39,7 @@ export const 명령들 = [
   { 이름: 'doctor', 뜻: 'diagnose 와 같다', en: 'same as diagnose' },
   { 이름: 'pack', 뜻: '오프라인 반입용으로 묶는다', en: 'bundle for offline transfer' },
   { 이름: 'audit', 뜻: '무엇을 했는지 기록을 본다', en: 'show the record of what it did' },
+  { 이름: 'doc2md', 뜻: '문서·시안을 마크다운으로 (hwpx·docx·pptx·xlsx·pdf·fig)', en: 'document or design to Markdown (hwpx/docx/pptx/xlsx/pdf/fig)' },
   { 이름: 'sbom', 뜻: '무엇이 들었는지 목록을 낸다', en: 'list what is inside (SBOM)' },
   { 이름: 'scan', 뜻: '게이트웨이에 어떤 모델이 있나 훑는다', en: 'scan the gateway for available models' },
   { 이름: 'sessions', 뜻: '지난 대화 목록', en: 'list past conversations' },

package/src/i18n/en.js

@@ -70,6 +70,7 @@ export const en = {
   'cmd.architect.desc': 'work mode → architect (shapes the structure)',
   'cmd.debug.desc': 'work mode → debug (finds the cause)',
   'cmd.ask.desc': 'work mode → ask (explains only)',
+  'cmd.inspect.desc': 'work mode → inspect (audits for defects, changes nothing)',
   'cmd.orchestrator.desc': 'work mode → orchestrator (splits a big job up)',
   'cmd.undo.desc': 'undo the last turn — files and the conversation together',
   'cmd.undo.arg': '[turns]',
@@ -314,6 +315,18 @@ export const en = {
   'approve.strict.name': 'ask always',
   'approve.strict.short': 'always',
   'approve.strict.line': 'asks before every file edit and every command',
+  'work.title': 'Work modes',
+  'work.canEdit': 'edits files',
+  'work.readOnly': 'read-only',
+  'work.think': 'thinking',
+  'work.steps': 'up to {n} steps',
+  'work.tools': 'tools',
+  'work.toolsWrite': 'read + change files',
+  'work.toolsRead': 'read only — cannot change files',
+  'work.howTo': 'To switch: {a} {b} {c} …  or {키} to cycle',
+  'work.axis': 'A different axis from the approval policy ({명령}) — what you do / how much it asks.',
+  'work.autoOn': 'From here it moves to the right mode by itself, message by message.',
+  'work.pinned': 'You chose this, so it will not change by itself. To hand it back:',
   'level.beginner.name': 'beginner',
   'level.beginner.hint': 'start on the recommended settings',
   'level.developer.name': 'developer',

package/src/i18n/ja.js

@@ -57,6 +57,7 @@ export const ja = {
   'cmd.architect.desc': '作業モード → architect (構造を決める)',
   'cmd.debug.desc': '作業モード → debug (原因を突き止める)',
   'cmd.ask.desc': '作業モード → ask (説明だけ)',
+  'cmd.inspect.desc': '作業モード → inspect (欠陥を探す。直さない)',
   'cmd.orchestrator.desc': '作業モード → orchestrator (大きな仕事を分ける)',
   'cmd.undo.desc': '直前のターンを戻す — ファイルと会話をまとめて',
   'cmd.undo.arg': '[ターン数]',
@@ -281,6 +282,18 @@ export const ja = {
   'approve.strict.name': '毎回訊く',
   'approve.strict.short': '毎回',
   'approve.strict.line': 'ファイルを直すたび、コマンドを打つたびに訊きます',
+  'work.title': '作業モード',
+  'work.canEdit': 'ファイルを変更',
+  'work.readOnly': '読むだけ',
+  'work.think': '思考',
+  'work.steps': '最大 {n} ステップ',
+  'work.tools': 'ツール',
+  'work.toolsWrite': '読み取り + ファイル変更',
+  'work.toolsRead': '読み取りのみ — ファイルは変更できません',
+  'work.howTo': '切り替え: {a} {b} {c} …  または {키} で順に',
+  'work.axis': '承認ポリシー({명령})とは別の軸です — 何をするか / どれだけ聞くか。',
+  'work.autoOn': 'これからは一言ごとに適したモードへ自動で移ります。',
+  'work.pinned': 'ご自分で選んだので自動では変わりません。任せ直すには',
   'level.beginner.name': 'かんたん',
   'level.beginner.hint': '勧められた設定のまま始めます',
   'level.developer.name': '開発者',

package/src/i18n/ko.js

@@ -59,6 +59,7 @@ export const ko = {
   'cmd.architect.desc': '작업 모드 → 설계 (구조를 짠다)',
   'cmd.debug.desc': '작업 모드 → 디버그 (원인을 찾는다)',
   'cmd.ask.desc': '작업 모드 → 묻기 (설명만)',
+  'cmd.inspect.desc': '작업 모드 → 점검 (결함을 찾는다. 안 고침)',
   'cmd.orchestrator.desc': '작업 모드 → 총괄 (큰 일을 쪼개서)',
   'cmd.undo.desc': '직전 작업 되돌리기 — 파일과 대화를 같이',
   'cmd.undo.arg': '[턴수]',
@@ -303,6 +304,18 @@ export const ko = {
   'approve.strict.name': '모두 확인',
   'approve.strict.short': '모두',
   'approve.strict.line': '파일을 고치거나 명령을 돌리기 전에 매번 물어봅니다',
+  'work.title': '작업 모드',
+  'work.canEdit': '파일 바꿈',
+  'work.readOnly': '읽기만',
+  'work.think': '생각',
+  'work.steps': '최대 {n}걸음',
+  'work.tools': '도구',
+  'work.toolsWrite': '읽기 + 파일 바꾸기',
+  'work.toolsRead': '읽기만 — 파일을 못 바꿉니다',
+  'work.howTo': '바꾸려면 {a} {b} {c} …  또는 {키} 로 차례로',
+  'work.axis': '이건 승인 정책({명령})과 다른 축입니다 — 무엇을 하느냐 / 얼마나 물어보냐.',
+  'work.autoOn': '앞으로는 한마디마다 알맞은 모드로 저절로 옮겨 갑니다.',
+  'work.pinned': '직접 고르셨으므로 저절로 바뀌지 않습니다. 다시 맡기려면',
   'level.beginner.name': '쉬움',
   'level.beginner.hint': '권장값으로 바로 시작',
   'level.developer.name': '개발자',

package/src/i18n/zh.js

@@ -57,6 +57,7 @@ export const zh = {
   'cmd.architect.desc': '工作模式 → architect (定结构)',
   'cmd.debug.desc': '工作模式 → debug (找原因)',
   'cmd.ask.desc': '工作模式 → ask (只解释)',
+  'cmd.inspect.desc': '工作模式 → inspect (查找缺陷，不修改)',
   'cmd.orchestrator.desc': '工作模式 → orchestrator (把大活儿拆开)',
   'cmd.undo.desc': '撤销上一轮 — 文件和对话一起',
   'cmd.undo.arg': '[轮数]',
@@ -281,6 +282,18 @@ export const zh = {
   'approve.strict.name': '每次都问',
   'approve.strict.short': '每次',
   'approve.strict.line': '每改一个文件、每跑一条命令都问',
+  'work.title': '工作模式',
+  'work.canEdit': '会改文件',
+  'work.readOnly': '只读',
+  'work.think': '思考',
+  'work.steps': '最多 {n} 步',
+  'work.tools': '工具',
+  'work.toolsWrite': '读取 + 修改文件',
+  'work.toolsRead': '只读 — 不能修改文件',
+  'work.howTo': '切换：{a} {b} {c} …  或用 {키} 依次切换',
+  'work.axis': '这与审批策略（{명령}）是两条不同的轴 — 做什么 / 问多少。',
+  'work.autoOn': '之后会按每句话自动切到合适的模式。',
+  'work.pinned': '你自己选的，不会自动改变。要交回自动请用',
   'level.beginner.name': '新手',
   'level.beginner.hint': '按推荐设置开始',
   'level.developer.name': '开发者',

package/src/tools/doc2md.js

@@ -0,0 +1,266 @@
+/**
+ * 문서 → 마크다운.
+ *
+ * ── 왜 글이 아니라 마크다운인가 ─────────────────────────────────────────
+ *
+ * deel 은 이미 hwpx·docx·pptx·xlsx·pdf 와 Figma `.fig` 를 제 손으로 읽는다
+ * (docs.js · xlsx.js · pdf.js · fig.js). 다만 돌려주던 것이 **평평한 글**이었다.
+ * 표는 `이름 | 값 | 비고` 한 줄로 펴져 나갔고, 장 구분은 `--- 3장 ---` 이었다.
+ *
+ * 그게 왜 손해인가 — 읽는 쪽이 사람이 아니라 모델이기 때문이다. 마크다운
+ * 표는 모델이 「첫 줄이 머리글이고 셋째 칸이 비고」 라는 것을 그냥 안다.
+ * 평평한 줄에서는 그걸 매번 다시 짐작해야 하고, 칸이 빈 행이 하나 섞이면
+ * 거기서부터 어긋난다. 같은 바이트로 더 많이 전하는 쪽이 마크다운이다.
+ *
+ * 그리고 사람도 그대로 쓴다. `.md` 로 떨어뜨려 두면 그게 곧 문서다.
+ *
+ * ── 무엇을 새로 들이지 않나 ─────────────────────────────────────────────
+ *
+ * 아무것도. 읽는 일은 이미 있는 읽개들이 그대로 하고, 이 파일은 그것이
+ * 돌려준 것을 **그리기만** 한다. 의존성 0개는 그대로다.
+ *
+ * ── 표를 언제 표로 안 그리나 ────────────────────────────────────────────
+ *
+ * 칸이 열두 개를 넘으면 마크다운 표는 읽는 것이 아니라 가로로 흐르는 벽이
+ * 된다. 그때는 CSV 울타리로 떨어뜨리고 **왜 그랬는지 적는다.** 조용히
+ * 모양을 바꾸면, 표가 안 나오는 것이 파일 탓인지 우리 탓인지 알 길이 없다.
+ */
+import { basename, extname } from 'node:path';
+
+import { isDocPath, readDoc, summarize as docSummary } from './docs.js';
+import { isPdfPath, readPdf, summarize as pdfSummary } from './pdf.js';
+import { isFigPath, readFig, summarize as figSummary } from './fig.js';
+import { readXlsx, toCsv } from './xlsx.js';
+import { readFileSync } from 'node:fs';
+
+/** 엑셀 확장자. tools/index.js 가 쓰는 것과 같은 목록이다. */
+const 엑셀 = new Set(['.xlsx', '.xlsm']);
+
+/** 이 길로 마크다운을 만들 수 있는 파일인가. */
+export function 바꿀수있나(경로) {
+  const p = String(경로 ?? '');
+  return isDocPath(p) || isPdfPath(p) || isFigPath(p) || 엑셀.has(extname(p).toLowerCase());
+}
+
+/** 우리가 직접 읽는 갈래 목록 — 화면과 도움말이 같은 곳에서 가져간다. */
+export const 읽는갈래 = ['hwpx', 'docx', 'pptx', 'xlsx', 'pdf', 'fig'];
+
+// 다 실어 봐야 창만 찬다. 글로 낼 때와 같은 상한을 쓴다(docs.js · pdf.js).
+const 최대글자 = 60000;
+// 이보다 칸이 많으면 마크다운 표로 안 그린다 — 가로로 흐르는 벽이 된다.
+const 최대칸 = 12;
+
+/** 마크다운 표 칸 하나. `|` 와 줄바꿈은 표를 부수므로 바꿔 준다. */
+function 칸(v) {
+  return String(v ?? '')
+    .replace(/\|/g, '\\|')
+    .replace(/\r?\n/g, '<br>')
+    .trim();
+}
+
+/** 이 행들이 다 비었나. 빈 표를 그리면 머리글만 있는 유령 표가 남는다. */
+const 다비었나 = (행들) => 행들.every((r) => r.every((c) => !String(c ?? '').trim()));
+
+/**
+ * 행 목록을 마크다운 표로. 첫 행이 머리글이다.
+ *
+ * 칸 수가 행마다 다른 문서가 흔하다(합쳐진 칸). 제일 넓은 행에 맞춰 채운다 —
+ * 안 채우면 마크다운이 그 행부터 표로 안 읽는다.
+ */
+export function 표그리기(행들) {
+  const 있는것 = (행들 ?? []).filter((r) => Array.isArray(r) && r.length);
+  if (!있는것.length || 다비었나(있는것)) return '';
+
+  const 폭 = Math.max(...있는것.map((r) => r.length));
+  if (폭 > 최대칸) {
+    return ['```csv', toCsv(있는것.map((r) => [...r, ...Array(폭 - r.length).fill('')])), '```',
+      `(칸이 ${폭}개라 마크다운 표 대신 CSV 로 냈습니다 — 표로 그리면 가로로 흘러 못 읽습니다.)`,
+    ].join('\n');
+  }
+
+  const 채워 = (r) => [...r.map(칸), ...Array(폭 - r.length).fill('')];
+  const [머리, ...몸] = 있는것;
+  return [
+    `| ${채워(머리).join(' | ')} |`,
+    `|${' --- |'.repeat(폭)}`,
+    ...몸.map((r) => `| ${채워(r).join(' | ')} |`),
+  ].join('\n');
+}
+
+/**
+ * 글자 수를 세면서 조각을 담는 자. 넘치면 **넘쳤다고 말하고** 멈춘다.
+ *
+ * 조용히 자르면 모델은 그게 전부인 줄 알고 "문서에 그런 내용 없다" 고 답한다.
+ * 이 파일이 읽개들에서 그대로 물려받는 규칙이다.
+ */
+function 담개(maxChars) {
+  const 조각 = [];
+  const 말 = [];
+  let 셈 = 0;
+  let 찼나 = false;
+  return {
+    담기(글) {
+      if (찼나) return false;
+      const s = String(글 ?? '');
+      if (셈 + s.length > maxChars) {
+        찼나 = true;
+        말.push(`${maxChars.toLocaleString('en-US')}자에서 잘랐습니다 — 뒷부분은 안 실렸습니다`);
+        return false;
+      }
+      조각.push(s);
+      셈 += s.length + 1;
+      return true;
+    },
+    get 찼나() { return 찼나; },
+    끝내기: () => ({ md: 조각.join('\n\n'), 말 }),
+  };
+}
+
+/**
+ * 덩이 하나(장·구획·쪽)를 담는다.
+ *
+ * 표 행({행:[...]})이 잇달아 나오면 한 표로 묶는다. 사이에 글이 끼면 거기서
+ * 표가 끊긴 것이다 — 문서에서 표가 두 개로 나뉜 자리가 정확히 그 모양이다.
+ */
+function 덩이담기(담, 문단들, 머리글) {
+  if (머리글 && !담.담기(머리글)) return;
+  let 표 = [];
+  const 표비우기 = () => {
+    if (!표.length) return true;
+    const 그림 = 표그리기(표);
+    표 = [];
+    return 그림 ? 담.담기(그림) : true;
+  };
+  for (const 문단 of 문단들 ?? []) {
+    if (문단 && typeof 문단 === 'object' && Array.isArray(문단.행)) { 표.push(문단.행); continue; }
+    if (!표비우기()) return;
+    if (!담.담기(String(문단))) return;
+  }
+  표비우기();
+}
+
+/** 마크다운 제목에 파일 이름을 그대로 쓴다 — 어느 파일에서 나온 글인지가 남아야 한다. */
+const 제목 = (경로) => `# ${basename(String(경로 ?? ''))}`;
+
+function 문서를마크다운(경로, maxChars) {
+  const r = readDoc(경로, { 표를따로: true });
+  if (!r.ok) return { ok: false, error: r.error, 끝났다: r.끝났다 };
+
+  const 담 = 담개(maxChars);
+  담.담기(제목(경로));
+  const 여럿 = r.덩이들.length > 1;
+  for (const d of r.덩이들) {
+    덩이담기(담, d.문단들, 여럿 ? `## ${d.이름}` : '');
+    if (담.찼나) break;
+  }
+  const { md, 말 } = 담.끝내기();
+  return { ok: true, 갈래: r.갈래, md, 말, summary: docSummary(r) };
+}
+
+function 엑셀을마크다운(경로, maxChars) {
+  let r;
+  try {
+    r = readXlsx(readFileSync(경로));
+  } catch (err) {
+    return { ok: false, error: `엑셀을 읽지 못했습니다 — ${err.message}` };
+  }
+  const 담 = 담개(maxChars);
+  담.담기(제목(경로));
+  for (const s of r.sheets) {
+    // 숨긴 시트도 낸다. 다만 숨겨져 있었다고 적는다 — 그 사실이 값을 읽는
+    // 방식을 바꾼다(옛 판·임시 계산용인 일이 많다).
+    담.담기(`## ${s.name}${s.hidden ? ' (숨김 시트)' : ''}`);
+    const 그림 = 표그리기(s.rows);
+    if (!담.담기(그림 || '(빈 시트입니다.)')) break;
+  }
+  const { md, 말 } = 담.끝내기();
+  const 시트말 = `xlsx · 시트 ${r.sheets.length}개`;
+  return { ok: true, 갈래: 'xlsx', md, 말: [...말, ...(r.notes ?? [])], summary: 시트말 };
+}
+
+/**
+ * Figma 시안을 마크다운으로.
+ *
+ * 쪽마다 `## 쪽이름` 이 되고, 그 밑이 그대로 마크다운 목록이 된다 — 시안의
+ * 짜임이 곧 목록의 들여쓰기라, 옮겨 그릴 것이 없다.
+ */
+function fig를마크다운(경로, maxChars) {
+  const r = readFig(경로);
+  if (!r.ok) return { ok: false, error: r.error, 끝났다: r.끝났다 };
+
+  const 담 = 담개(maxChars);
+  담.담기(제목(경로));
+  for (const d of r.덩이들) {
+    if (!담.담기(`## ${d.이름}`)) break;
+    /*
+     * 나무 줄은 **붙여서** 한 덩이로 낸다.
+     *
+     * 여기만 다른 읽개와 다르다. 문서의 문단은 사이가 벌어져야 문단인데,
+     * 목록은 사이가 벌어지면 들여쓰기가 뜻을 잃는다. 그렇다고 쪽 하나를
+     * 통째로 한 덩이로 만들면, 넘칠 때 그 쪽이 통째로 사라진다 — 조용히
+     * 빠진 자리를 안 만드는 것이 이 파일의 규칙이라 그럴 수는 없다.
+     * 그래서 8천 자쯤에서 끊는다. 자를 자리가 줄 단위로 남는다.
+     */
+    let 뭉치 = [];
+    let 셈 = 0;
+    const 비우기 = () => {
+      if (!뭉치.length) return true;
+      const 글 = 뭉치.join('\n');
+      뭉치 = [];
+      셈 = 0;
+      return 담.담기(글);
+    };
+    for (const 줄 of d.문단들 ?? []) {
+      뭉치.push(String(줄));
+      셈 += String(줄).length + 1;
+      if (셈 >= 8000 && !비우기()) break;
+    }
+    if (!비우기()) break;
+  }
+  const { md, 말 } = 담.끝내기();
+  return { ok: true, 갈래: 'fig', md, 말: [...(r.말 ?? []), ...말], summary: figSummary(r) };
+}
+
+function pdf를마크다운(경로, maxChars) {
+  const r = readPdf(경로);
+  if (!r.ok) return { ok: false, error: r.error, 끝났다: r.끝났다 };
+
+  const 담 = 담개(maxChars);
+  담.담기(제목(경로));
+  const 왜표 = new Map((r.못읽은쪽 ?? []).map((x) => [x.번호, x]));
+  for (const d of r.덩이들) {
+    const 번호 = Number((d.이름.match(/^(\d+)/) ?? [])[1]);
+    담.담기(`## ${d.이름}`);
+    const 못 = 왜표.get(번호);
+    // 못 읽은 쪽을 조용히 건너뛰면 **없는 문서**가 된다. 쪽 자리에 왜 비었는지 적는다.
+    if (못 && !못.일부) { 담.담기(`> 이 쪽은 글로 못 읽었습니다 — ${못.왜}`); continue; }
+    덩이담기(담, d.문단들, '');
+    if (못?.일부) 담.담기(`> 이 쪽은 일부만 읽었습니다 — ${못.왜}`);
+    if (담.찼나) break;
+  }
+  const { md, 말 } = 담.끝내기();
+  return { ok: true, 갈래: 'pdf', md, 말, summary: pdfSummary(r) };
+}
+
+/**
+ * 문서 하나를 마크다운으로.
+ *
+ * 던지지 않는다. 깨진 파일은 도구 실행 한가운데서 만나는 것이라, 예외가 나면
+ * 「문서가 깨졌다」 가 「도구가 터졌다」 로 보고된다 — 읽개들이 다 지키는 규칙이다.
+ *
+ * @returns {{ok:true, 갈래:string, md:string, 말:string[], summary:string}
+ *          |{ok:false, error:string, 끝났다?:boolean}}
+ */
+export function 마크다운(경로, { maxChars = 최대글자 } = {}) {
+  const p = String(경로 ?? '');
+  if (엑셀.has(extname(p).toLowerCase())) return 엑셀을마크다운(p, maxChars);
+  if (isPdfPath(p)) return pdf를마크다운(p, maxChars);
+  if (isFigPath(p)) return fig를마크다운(p, maxChars);
+  if (isDocPath(p)) return 문서를마크다운(p, maxChars);
+  return {
+    ok: false,
+    error: `마크다운으로 바꿀 수 있는 갈래가 아닙니다: ${basename(p) || p}\n`
+      + `  직접 읽는 것: ${읽는갈래.join(' · ')}\n`
+      + '  옛 형식(.ppt·.doc·.xls·.hwp)은 이 PC 에 LibreOffice 가 있으면 Read 가 빌려 읽습니다.',
+  };
+}

package/src/tools/docs.js

@@ -162,7 +162,14 @@ const 끝이름 = (name) => {
  * "이름값가1" 같은 덩어리가 되는데, 그건 뜻이 사라진 글이라 안 읽은 것보다
  * 나쁘다 — 모델이 그걸 근거로 답한다.
  */
-export function 문단뽑기(xml, 갈래) {
+/**
+ * @param {object} [옵션]
+ * @param {boolean} [옵션.표를따로]  표 행을 { 행: [칸...] } 로 돌려준다.
+ *   기본값은 여태와 똑같이 `a | b` 한 줄이다. 마크다운으로 낼 때만 켠다
+ *   (tools/doc2md.js) — 마크다운 표는 칸이 몇 개인지 알아야 그릴 수 있고,
+ *   이어 붙인 한 줄에서 그걸 되짚으면 글에 든 | 하나에 표가 어긋난다.
+ */
+export function 문단뽑기(xml, 갈래, { 표를따로 = false } = {}) {
   const 표기 = 이름표[갈래];
   const 문단들 = [];
 
@@ -195,7 +202,10 @@ export function 문단뽑기(xml, 갈래) {
     if (이름 === 표기.표) { 표깊이 += t.closing ? -1 : (t.selfClosing ? 0 : 1); continue; }
     if (표깊이 > 0 && 이름 === 표기.행) {
       if (t.closing) {
-        if (행칸들) 문단들.push(행칸들.map((x) => x.trim()).join(' | '));
+        if (행칸들) {
+          const 칸 = 행칸들.map((x) => x.trim());
+          문단들.push(표를따로 ? { 행: 칸 } : 칸.join(' | '));
+        }
         행칸들 = null;
       } else {
         행칸들 = [];
@@ -237,7 +247,7 @@ const 알맹이 = {
  * 던지지 않는다 — 깨진 파일은 도구 실행 한가운데서 만나는 것이라,
  * 예외가 나면 "문서가 깨졌다" 가 "도구가 터졌다" 로 보고된다.
  */
-export function readDoc(경로또는버퍼) {
+export function readDoc(경로또는버퍼, { 표를따로 = false } = {}) {
   const 갈래 = Buffer.isBuffer(경로또는버퍼) ? null : 종류(경로또는버퍼);
   let buf;
   try {
@@ -270,7 +280,7 @@ export function readDoc(경로또는버퍼) {
 
   const 덩이들 = 찾은.map((s, i) => ({
     이름: 구획이름(i, s.번호),
-    문단들: 문단뽑기(s.몸.toString('utf8'), 갈래),
+    문단들: 문단뽑기(s.몸.toString('utf8'), 갈래, { 표를따로 }),
   }));
   return { ok: true, 갈래, 덩이들 };
 }