deel-local-cli 2.1.2 → 2.1.3

package/src/safety/gitsnap.js

@@ -0,0 +1,286 @@
+/**
+ * 셸이 바꾼 파일을 git 으로 알아내 되돌리기에 올린다 (2.1.3).
+ *
+ * ── 왜 이게 필요한가 ───────────────────────────────────────────────────
+ *
+ * Bash 의 되돌리기는 **명령줄에 적힌 이름**을 보고 떴다(tools/index.js 의 바꾸기전스냅샷). 셸이 푸는
+ * 와일드카드(`rm *.tmp`)와 스크립트 안에서 고치는 것(`npm run format` · `node 고치기.js` ·
+ * `npx prettier --write .`)은 이름이 명령줄에 없어 떠 둔 것이 없었고, /undo 뒤에도 그대로였다.
+ * 모델이 파일을 제일 많이 바꾸는 길이 바로 그 둘이다.
+ *
+ * ── 어떻게 ────────────────────────────────────────────────────────────
+ *
+ * 명령 **앞**에 `git status` 로 지금 고치던 것 · 안 올린 것을 보고, 그 파일들만 사본을 떠 둔다(보통 몇 개다).
+ * 명령 **뒤**에 한 번 더 보고 견준다.
+ *
+ *   앞에 깨끗했던 파일이 바뀌거나 사라졌다  → 앞 모습은 명령 전 HEAD 에 있다 (git 이 들고 있다). git 이 작업 폴더에
+ *                                          꺼내 줄 모습으로 받는다 — `git restore` 와 같다(줄 끝 변환까지 · 헤드꺼내기)
+ *   앞에 고치던 · 안 올린 파일이 바뀌었다   → 앞 모습은 떠 둔 사본
+ *   앞에 없던 파일이 생겼다                → 「원래 없던 자리」 — 되돌리면 지운다
+ *
+ * 그렇게 안 것을 되돌리기 이력(safety/undo.js)에 **여느 기록과 같은 모양으로** 적는다. 그러면 /undo 가
+ * 밖을 가리키는 기록 · 링크 너머 · 바이너리를 다루는 규칙을 그대로 탄다 — 되돌리는 길을 새로 만들지 않는다.
+ *
+ * ── 안 하는 것 ────────────────────────────────────────────────────────
+ *
+ *   · .git 에 아무것도 안 쓴다. `git add` 로 나무를 뜨는 길도 있었지만, 그러면 명령마다 남의 저장소에
+ *     객체를 쌓는다(큰 파일이면 크게). 읽기만 하는 status · cat-file 만 부르고, status 도
+ *     `--no-optional-locks` 로 색인을 안 고친다.
+ *   · 무시되는 파일(.gitignore)은 못 본다 — git 이 안 보는 자리다. 못 본 것을 되돌린다고 말하지 않는다.
+ *   · git 의 색인(스테이징)과 커밋은 안 되돌린다. 되돌리는 것은 작업 폴더의 파일이다.
+ *   · 저장소가 아니면 아무것도 안 한다(null). 없는 안전망을 있다고 하지 않는다.
+ */
+import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { 경로에서찾기 } from './which.js';
+
+// 명령 전에 사본을 떠 둘 파일의 상한. 넘친 것은 「못 떴다」 로 말한다.
+const 사본수상한 = 400;
+const 사본한개상한 = 4 * 1024 * 1024;
+const 사본합상한 = 32 * 1024 * 1024;
+// git 이 이보다 오래 걸리는 저장소면 이 판에서는 그만둔다 — 명령마다 사람이 기다린다.
+const 느림문턱 = 3000;
+// 앞 모습을 꺼내는 데는 더 기다린다 — 명령은 이미 돌았고, 여기서 끊기면 그 파일들을 되돌릴 수 없다.
+const 꺼내기문턱 = 10000;
+// 수정 시각이 이만큼 안쪽이면 시각을 못 믿는다 — FAT 은 2초 단위라, 한 틈에 두 번 쓰면 크기 · 시각이 같다.
+const 흐릿한틈 = 3000;
+
+/** 이 뿌리에서는 그만뒀다 (느리다). 프로세스가 사는 동안 기억한다. */
+const 그만둔곳 = new Set();
+let 깃자리 = undefined;
+
+function 깃찾기() {
+  // 작업 폴더 안의 git.exe 를 집지 않게 우리가 PATH 에서 찾는다 (which.js) — 절대 경로 칸만 본다.
+  if (깃자리 === undefined) 깃자리 = 경로에서찾기(['git']);
+  return 깃자리;
+}
+
+function 깃(뿌리, 인자, { 바이트 = false, 입력 = undefined, 제한 = 느림문턱 } = {}) {
+  const 파일 = 깃찾기();
+  if (!파일) return null;
+  const r = spawnSync(파일, ['--no-optional-locks', '-c', 'core.quotepath=false', ...인자], {
+    cwd: 뿌리, windowsHide: true, timeout: 제한, maxBuffer: 256 * 1024 * 1024,
+    // 입력은 Buffer 로 — 글로 주면 encoding 을 입력의 인코딩으로도 써서 'buffer' 에서 던진다.
+    encoding: 바이트 ? 'buffer' : 'utf8', input: 입력 === undefined ? undefined : Buffer.from(입력, 'utf8'),
+    // 사람이 켜 둔 페이저 · 비밀번호 묻기가 끼지 않게.
+    env: { ...process.env, GIT_PAGER: 'cat', GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0' },
+  });
+  if (r.error || r.status !== 0) return { ok: false, 느림: r.error?.code === 'ETIMEDOUT' || r.signal === 'SIGTERM' };
+  return { ok: true, out: r.stdout };
+}
+
+/**
+ * `git status --porcelain=v1 -z` 를 읽는다. 열쇠는 저장소 꼭대기 기준 경로(슬래시), 값은 두 글자 상태.
+ * 이름 바꾸기(R · C)는 옛 이름도 같이 올린다 — 옛 자리는 사라진 파일이다.
+ */
+function 상태읽기(뿌리) {
+  const r = 깃(뿌리, ['status', '--porcelain=v1', '-z', '--untracked-files=all', '--ignore-submodules=all', '--', '.']);
+  if (!r?.ok) return r?.느림 ? { 느림: true } : null;
+  const 표 = new Map();
+  const 칸 = String(r.out).split('\0');
+  for (let i = 0; i < 칸.length; i++) {
+    const 줄 = 칸[i];
+    if (줄.length < 4) continue;
+    const 상태 = 줄.slice(0, 2);
+    표.set(줄.slice(3), 상태);
+    if (상태[0] === 'R' || 상태[0] === 'C') {
+      const 옛 = 칸[++i];
+      if (옛 && 상태[0] === 'R') 표.set(옛, ' D');
+    }
+  }
+  return { 표 };
+}
+
+/*
+ * 저장소 꼭대기 기준 경로를 **작업 폴더 기준**으로. 밖이거나 deel 제 살림(.deel)이면 null.
+ *
+ * 절대 경로끼리 견주지 않는다 — 윈도우에서 git 이 주는 꼭대기(긴 이름 · 슬래시)와 우리 뿌리(짧은 이름 · 대소문자)가
+ * 글자로 달라, 안의 파일이 전부 밖으로 읽힐 수 있다. git 이 준 앞머리(`--show-prefix`)를 떼고 뿌리에 붙인다.
+ */
+const 살림꼴 = /(^|\/)\.deel(\/|$)/i;
+function 맡을경로(앞머리, 경로) {
+  if (!경로.startsWith(앞머리)) return null;
+  const rel = 경로.slice(앞머리.length);
+  if (!rel || 살림꼴.test(rel)) return null;
+  return rel;
+}
+
+function 모양(abs) {
+  try { const s = statSync(abs); return s.isFile() ? { 크기: s.size, 시각: s.mtimeMs } : { 폴더: true }; } catch { return null; }
+}
+
+/*
+ * 명령 전 HEAD 에 있던 모습을 **한꺼번에** 꺼낸다. 돌려주는 표: 경로 → Buffer(있던 모습) · null(HEAD 에 없던 것).
+ * 표에 없는 경로는 못 꺼낸 것이다 — 「없던 것」 과 다르다. 없던 것으로 적으면 /undo 가 멀쩡한 파일을 지운다.
+ * HEAD 부터 못 읽었으면 null.
+ *
+ * 파일마다 `git cat-file` 을 띄우면 포매터가 200 파일을 고친 뒤 윈도우에서 8초를 기다렸다. 두 번만 띄운다 —
+ * `--batch-check` 로 있나 없나를, `--batch --filters` 로 내용을. `--filters` 는 작업 폴더에 꺼낼 때의 변환
+ * (core.autocrlf 의 CRLF · .gitattributes)을 태운다. 안 태우면 윈도우용 git 기본값(autocrlf=true)에서
+ * /undo 가 CRLF 파일을 LF 로 되돌렸다.
+ *
+ * `--filters` 의 머리줄 크기는 변환 **전** 크기라 믿을 수 없다. 그래서 물음마다 뒤에 없는 개체 하나(아무도 못
+ * 맞출 제비 번호)를 물어, 그 「missing」 줄을 경계로 쓴다.
+ */
+function 헤드꺼내기(뿌리, 머리, 경로들) {
+  // 줄바꿈이 든 이름은 한 줄 물음에 못 싣는다 — 그 자리는 표에 없다(못 꺼냄).
+  const 실을것 = 경로들.filter((p) => !/[\r\n]/.test(p));
+  const 확인 = 깃(뿌리, ['cat-file', '--batch-check'], { 입력: `${[머리, ...실을것.map((p) => `${머리}:${p}`)].join('\n')}\n`, 제한: 꺼내기문턱 });
+  if (!확인?.ok) return null;
+  const 줄들 = String(확인.out).split('\n');
+  if (!/^[0-9a-f]+ commit \d+$/.test(줄들[0] ?? '')) return null;
+  const 표 = new Map();
+  const 꺼낼것 = [];
+  실을것.forEach((p, i) => {
+    const 줄 = 줄들[i + 1] ?? '';
+    if (줄.endsWith(' missing')) 표.set(p, null);                          // HEAD 에 없다 — 명령이 새로 만든 것
+    else { const m = /^([0-9a-f]+) blob \d+$/.exec(줄); if (m) 꺼낼것.push([p, m[1]]); }
+  });
+  if (!꺼낼것.length) return 표;
+  const 제비 = randomBytes(20).toString('hex');
+  const 내용 = 깃(뿌리, ['cat-file', '--batch', '--filters'], {
+    바이트: true, 제한: 꺼내기문턱, 입력: 꺼낼것.map(([p, oid]) => `${oid} ${p}\n${제비} x\n`).join(''),
+  });
+  if (!내용?.ok) return 표;
+  const 몸 = 내용.out;
+  const 경계 = Buffer.from(`\n${제비} missing\n`);
+  let i = 0;
+  for (const [p, oid] of 꺼낼것) {
+    const 머리끝 = 몸.indexOf(0x0a, i);
+    if (머리끝 < 0 || !몸.subarray(i, 머리끝).toString('latin1').startsWith(`${oid} blob `)) break;
+    const 끝 = 몸.indexOf(경계, 머리끝 + 1);
+    if (끝 < 0) break;
+    표.set(p, Buffer.from(몸.subarray(머리끝 + 1, 끝)));
+    i = 끝 + 경계.length;
+  }
+  return 표;
+}
+
+/**
+ * 명령 **앞** 모습을 뜬다.
+ *
+ * @returns {null | {뿌리, 앞머리, 머리, 표: Map, 사본: Map}}
+ *   null — 저장소가 아니거나, git 이 없거나, 이 저장소에서는 그만뒀다(느려서)
+ */
+export function 깃앞보기(뿌리) {
+  try {
+    뿌리 = resolve(String(뿌리));
+    if (그만둔곳.has(뿌리) || !깃찾기()) return null;
+    const 시작 = Date.now();
+    const 뜬때 = 시작;
+    // 앞머리와 HEAD 를 한 번에 묻는다 — 명령마다 도는 자리라 git 을 한 번 덜 띄운다. 커밋이 아직 없으면 HEAD 가
+    // 없어 실패하니, 그때만 앞머리를 따로 묻는다.
+    let 앞머리;
+    let 머리 = null;
+    const 둘 = 깃(뿌리, ['rev-parse', '--show-prefix', 'HEAD']);
+    if (둘?.ok) {
+      const 줄들 = String(둘.out).split('\n');
+      앞머리 = 줄들[0].trim();
+      머리 = (줄들[1] ?? '').trim() || null;
+    } else {
+      const 꼭 = 깃(뿌리, ['rev-parse', '--show-prefix']);
+      if (!꼭?.ok) return null;
+      앞머리 = String(꼭.out).trim();
+    }
+    const 상태 = 상태읽기(뿌리);
+    if (!상태 || 상태.느림 || Date.now() - 시작 > 느림문턱) {
+      if (상태?.느림 || Date.now() - 시작 > 느림문턱) 그만둔곳.add(뿌리);
+      return null;
+    }
+
+    // 고치던 것 · 안 올린 것의 사본. 이 파일들의 앞 모습은 git 에 없다.
+    const 사본 = new Map();
+    let 합 = 0;
+    for (const [경로] of 상태.표) {
+      const rel = 맡을경로(앞머리, 경로);
+      if (rel === null) continue;
+      const 꼴 = 모양(join(뿌리, rel));
+      if (!꼴) { 사본.set(경로, { 없음: true }); continue; }
+      if (꼴.폴더) continue;
+      if (사본.size >= 사본수상한 || 꼴.크기 > 사본한개상한 || 합 + 꼴.크기 > 사본합상한) {
+        사본.set(경로, { ...꼴, 못뜸: '사본 상한' });
+        continue;
+      }
+      try {
+        const buf = readFileSync(join(뿌리, rel));
+        합 += buf.length;
+        사본.set(경로, { ...꼴, buf });
+      } catch (err) { 사본.set(경로, { ...꼴, 못뜸: err?.code ?? '못 읽음' }); }
+    }
+    return { 뿌리, 앞머리, 머리, 표: 상태.표, 사본, 뜬때 };
+  } catch {
+    return null;   // 뜨다 터져서 명령이 못 도는 일은 없어야 한다
+  }
+}
+
+/**
+ * 명령 **뒤**에 견주고, 바뀐 것을 되돌리기 이력에 적는다.
+ *
+ * 이번 턴에 이미 뜬 파일은 안 적는다(History.떴나) — 그 기록이 턴 처음 모습이다. 낱말 보고 뜬 것과 겹쳐도 한 번이다.
+ *
+ * @returns {{뜬것: string[], 못뜬것: {abs: string, 왜: string}[]}}  뜬것 은 절대 경로
+ */
+export function 깃뒤적기(앞, { history } = {}) {
+  const 뜬것 = [];
+  const 못뜬것 = [];
+  if (!앞 || typeof history?.뒤늦은기록 !== 'function') return { 뜬것, 못뜬것 };
+  try {
+    const 뒤 = 상태읽기(앞.뿌리);
+    if (!뒤 || 뒤.느림) return { 뜬것, 못뜬것 };
+    const 할것 = [];   // [경로, abs, 지금, 앞모습] — 앞모습 이 '헤드' 면 아래에서 한꺼번에 꺼낸다
+    for (const 경로 of new Set([...앞.표.keys(), ...뒤.표.keys()])) {
+      const rel = 맡을경로(앞.앞머리, 경로);
+      if (rel === null) continue;
+      const abs = join(앞.뿌리, rel);
+      // 이번 턴에 이미 뜬 자리는 History.뒤늦은기록 이 거른다 — 그 기록이 턴 처음 모습이다.
+      const 지금 = 모양(abs);
+      if (지금?.폴더) continue;
+      const 떠둔것 = 앞.사본.get(경로);
+
+      let 앞모습;   // Buffer · null(없던 자리) · undefined(안 바뀜) · false(바뀌었는데 앞 모습이 없다)
+      if (앞.표.has(경로)) {
+        // 명령 전부터 고치던 · 안 올린 · 지워 둔 파일. 떠 둔 것과 지금이 같으면 안 바뀐 것이다.
+        if (!떠둔것) continue;                                   // 폴더였거나 안 맡는 자리
+        // 크기 · 시각이 같아도 그 시각이 뜬 때와 가까우면 믿지 않는다(흐릿한틈) — 한 틈에 두 번 쓴 것일 수 있다.
+        const 시각믿음 = 떠둔것.시각 < (앞.뜬때 ?? 0) - 흐릿한틈;
+        if (떠둔것.없음) 앞모습 = 지금 ? null : undefined;
+        else if (!지금) 앞모습 = 떠둔것.buf ?? false;
+        else if (지금.크기 === 떠둔것.크기 && 지금.시각 === 떠둔것.시각 && (시각믿음 || !떠둔것.buf)) 앞모습 = undefined;
+        else if (떠둔것.buf) {
+          let 지금것 = null;
+          try { 지금것 = readFileSync(abs); } catch { /* 못 읽으면 바뀐 것으로 본다 */ }
+          앞모습 = 지금것 && 지금것.equals(떠둔것.buf) ? undefined : 떠둔것.buf;
+        } else 앞모습 = false;
+        if (앞모습 === false) { 못뜬것.push({ abs, 왜: 떠둔것.못뜸 ?? '사본 없음' }); continue; }
+      } else {
+        // 명령 전에 깨끗했던 자리 — 앞 모습은 명령 전 HEAD 에 있다. 상태 글자(??)로 「새 파일」 을 가르지 않는다 —
+        // `git rm --cached` 로 추적만 뗀 파일도 ?? 로 나온다. HEAD 에 물어 가른다. 커밋이 아직 없으면 없던 자리다.
+        앞모습 = 앞.머리 ? '헤드' : null;
+      }
+      if (앞모습 === undefined) continue;
+      할것.push([경로, abs, 지금, 앞모습]);
+    }
+    const 헤드볼것 = 할것.filter((x) => x[3] === '헤드').map((x) => x[0]);
+    // 꺼내다 터져도 떠 둔 사본으로 적을 것은 적는다 — 꺼내지 못한 것만 「못 떴다」 로.
+    let 헤드 = null;
+    try { if (헤드볼것.length) 헤드 = 헤드꺼내기(앞.뿌리, 앞.머리, 헤드볼것); } catch { 헤드 = null; }
+    for (const [경로, abs, 지금, 앞것] of 할것) {
+      let 앞모습 = 앞것;
+      if (앞모습 === '헤드') {
+        앞모습 = 헤드?.get(경로);
+        if (앞모습 === undefined) { 못뜬것.push({ abs, 왜: 'git 에서 앞 모습을 못 꺼냈습니다' }); continue; }
+      }
+      if (앞모습 === null && !지금) continue;                    // 생겼다 사라졌다 — 되돌릴 것이 없다
+      const rec = history.뒤늦은기록(abs, 앞모습, 'Bash');
+      if (!rec) continue;
+      if (rec.skipped) 못뜬것.push({ abs, 왜: rec.skipped });
+      else 뜬것.push(abs);
+    }
+  } catch { /* 적다 터져도 명령은 이미 돌았다 — 적은 데까지만 말한다 */ }
+  return { 뜬것, 못뜬것 };
+}
+
+/** 검사가 원래대로 돌려놓을 때. */
+export function 깃뜨기잊기() { 그만둔곳.clear(); 깃자리 = undefined; }

package/src/safety/undo.js

@@ -327,6 +327,31 @@ export class History {
     return rec;
   }
 
+  /**
+   * 명령이 **이미 바꾼** 파일의 앞 모습을 적는다 (2.1.3 · safety/gitsnap.js).
+   *
+   * 앞 모습은 부르는 쪽이 준다 — git 이 들고 있던 것이나 명령 전에 떠 둔 사본. `앞` 이 Buffer 면 그 내용,
+   * null 이면 「원래 없던 자리」(되돌리면 지운다). 바이너리는 snapshot 과 같이 못 뜬 것으로 적고 크기를 남긴다.
+   * 이번 턴에 이미 뜬 자리면 안 적는다 — 그 기록이 턴 처음 모습이다.
+   */
+  뒤늦은기록(absPath, 앞, label) {
+    if (this.떴나(absPath)) return null;   // 이번 턴 처음 모습이 이미 있다
+    if (앞 === null) return this.없던자리기록(absPath, label);
+    const 뜬것 = 뜨기(Buffer.from(앞));
+    const rec = { turn: this.turn, at: new Date().toISOString(), path: absPath, before: 뜬것.before, label };
+    const 상대 = this.#상대(absPath);
+    if (상대 !== null) rec.rel = 상대;
+    if (뜬것.enc) rec.enc = 뜬것.enc;
+    if (뜬것.skipped) { rec.skipped = 뜬것.skipped; rec.크기 = 앞.length; }
+    this.#덧붙이기(rec);
+    this.#잠그기();
+    this.#이번턴.set(absPath, rec);
+    const 낮춘 = absPath.toLowerCase();
+    this.#낮춘이름.set(낮춘, [...(this.#낮춘이름.get(낮춘) ?? []), absPath]);
+    this.#maybePrune();
+    return rec;
+  }
+
   /*
    * ── 떠 놓고 **못 쓴** 기록을 거둔다 ───────────────────────────────────
    *
@@ -841,7 +866,11 @@ function 같은물건(p, q) {
 }
 
 function safeRead(p) {
-  const buf = readFileSync(p);
+  return 뜨기(readFileSync(p));
+}
+
+/** 바이트를 이력에 적을 모양으로 (safeRead 와 gitsnap 의 앞 모습이 같이 쓴다). */
+function 뜨기(buf) {
   // 바이너리는 내용을 담지 않는다. '없던 파일' 과는 다른 값으로 알린다 —
   // 이 둘을 같은 null 로 뭉쳐 놨던 것이 /undo 가 파일을 지우던 원인이다.
   if (looksBinary(buf)) return { before: null, skipped: '바이너리' };

package/src/safety/which.js

@@ -0,0 +1,37 @@
+// 실행 파일을 PATH 에서 **우리가** 찾는다 — 셸이나 운영체제가 찾게 두지 않는다.
+//
+// tools/verify.js 에서 떼어 냈다 (2.1.3). 되돌리기의 git 뜨기(safety/gitsnap.js)도 같은 자로 git 을 찾는다 —
+// 두 벌이면 언젠가 한 벌만 고친다. 여기는 fs 와 path 만 부른다(되돌리기는 설정이 깨져도 돌아야 하는 자리다).
+
+import { statSync } from 'node:fs';
+import { resolve, join, delimiter, isAbsolute, relative } from 'node:path';
+
+/**
+ * 이름으로 실행 파일을 PATH 에서 찾는다.
+ *
+ * 지금 폴더를 뜻하는 칸(빈 칸·`.`·상대 경로)과 작업 폴더 안의 칸은 건너뛴다. 그 자리의
+ * 파일은 저장소가 심을 수 있다. 윈도우에서는 `.exe` 만 본다 — `.cmd`·`.bat` 은 결국
+ * cmd.exe 를 부르는 것이라 셸을 안 거친다는 뜻이 없어진다.
+ *
+ * @returns {string|null} 절대 경로. 못 찾으면 null — 그러면 「도구가 없다」 로 말한다.
+ */
+export function 경로에서찾기(이름들, { env = process.env, 뿌리 = null } = {}) {
+  const 윈 = process.platform === 'win32';
+  // 윈도우 환경 이름은 대소문자를 안 가린다(Path · PATH). 거른 환경 객체는 평범한 객체라 직접 찾는다.
+  const 칸 = Object.keys(env ?? {}).find((k) => (윈 ? k.toUpperCase() === 'PATH' : k === 'PATH'));
+  const 목록 = String((칸 && env[칸]) ?? '').split(delimiter);
+  const 뿌리abs = 뿌리 ? resolve(뿌리) : null;
+  for (const 이름 of 이름들) {
+    for (const 날것 of 목록) {
+      const 폴더 = 날것.trim().replace(/^"(.*)"$/, '$1');
+      if (!폴더 || !isAbsolute(폴더)) continue;
+      if (뿌리abs) {
+        const rel = relative(뿌리abs, resolve(폴더));
+        if (rel === '' || (!rel.startsWith('..') && !isAbsolute(rel))) continue;
+      }
+      const 후보 = join(폴더, 윈 ? `${이름}.exe` : 이름);
+      try { if (statSync(후보).isFile()) return 후보; } catch { /* 여기엔 없다 */ }
+    }
+  }
+  return null;
+}

package/src/slash.js

@@ -0,0 +1,103 @@
+/**
+ * 슬래시 명령을 이름으로 찾는 규칙 — 대화 화면(commands.js)과 `deel run`(oneshot.js)이 같이 쓴다.
+ *
+ * 여기가 commands.js 안에 있었다. 그래서 `deel run` 은 이 셋을 쓰려고 대화 화면의 명령 전부
+ * (화면 · 설정 · 플러그인 · 스캔 …)를 읽었다. 규칙은 한 벌로 두되, 가벼운 자리로 뺀다 (2.1.3).
+ * commands.js 는 여기서 받아 그대로 내보낸다 — 부르던 자리는 안 바뀐다.
+ */
+/** `ext:ReviewCode` 의 꼬리 — 언제나 낮춰서 돌려준다. 찾기와 「비슷한 것」 이 같은 잣대를 쓰게 한다. */
+const 꼬리이름 = (이름) => String(이름 ?? '').split(':').pop().toLowerCase();
+
+/*
+ * ── 이 PC 에서 찾은 슬래시 명령을 이름으로 찾는다 ───────────────────────
+ *
+ * 대화 화면(commands.js 의 default 갈래)과 배치(oneshot.js)가 **같은 규칙**을 써야 한다. 같은 글자를
+ * 쳤는데 창에 따라 되고 안 되면 사람은 어느 쪽을 믿을지 정할 수 없다. 그래서 두 벌로 적지
+ * 않고 여기 한 군데에 둔다.
+ *
+ * 찾는 차례는 셋이다 — 적은 그대로 · 대소문자 무시 · 꼬리 이름.
+ * 마지막 칸이 `x.name.split(':').pop() === 낮춘` 이었다 (8회차 그밖 명령2). 왼쪽은 파일에
+ * 적힌 그대로고 오른쪽은 낮춘 말이라 둘이 만날 수가 없다. `ext:ReviewCode` 는 `/ReviewCode`
+ * 로도 `/reviewcode` 로도 「모르는 명령」 이었고, 「비슷한 것」 에도 안 떴다 — 깔려 있는
+ * 명령이 어느 길로도 안 보이는 자리다. 배치에서는 그대로 1 로 선다.
+ */
+export function 슬래시명령찾기(목록, 부른이름) {
+  const 것들 = 목록 ?? [];
+  const 낮춘 = String(부른이름 ?? '').toLowerCase();
+  return 것들.find((x) => x.name === 부른이름)
+    ?? 것들.find((x) => x.name.toLowerCase() === 낮춘)
+    ?? 것들.find((x) => 꼬리이름(x.name) === 낮춘)
+    ?? null;
+}
+
+/** 못 찾았을 때 「비슷한 것」 으로 늘어놓을 것. 찾기와 같은 잣대(낮춘 꼬리)를 쓴다. */
+export function 비슷한슬래시명령(목록, 부른이름, 몇 = 5) {
+  const 낮춘 = String(부른이름 ?? '').toLowerCase();
+  if (!낮춘) return [];
+  return (목록 ?? [])
+    .filter((x) => x.name.toLowerCase().includes(낮춘) || 낮춘.includes(꼬리이름(x.name)))
+    .slice(0, 몇);
+}
+
+/*
+ * 프롬프트 인자를 가른다. 빈칸으로 가르되 따옴표("…" · '…')로 묶은 것은 한 인자다 — 파일 이름에 빈칸이
+ * 든다. 마지막 인자는 남은 글을 **그대로** 받는다 — 여러 줄 코드를 넘기면 줄바꿈 · 들여쓰기가 살아야 한다.
+ * 남은 것이 통째로 한 따옴표 묶음이면 따옴표만 벗긴다.
+ */
+function 인자가르기(글, 몇) {
+  const s = String(글 ?? '');
+  const 값들 = [];
+  let i = 0;
+  for (let k = 0; k < 몇; k++) {
+    while (i < s.length && /\s/.test(s[i])) i++;
+    if (i >= s.length) break;
+    if (k === 몇 - 1) {
+      const 남은 = s.slice(i).trimEnd();
+      const 묶음 = /^(["'])((?:(?!\1)[\s\S])*)\1$/.exec(남은);
+      값들.push(묶음 ? 묶음[2] : 남은);
+      break;
+    }
+    const 끝 = s[i] === '"' || s[i] === "'" ? s.indexOf(s[i], i + 1) : -1;
+    if (끝 > i) { 값들.push(s.slice(i + 1, 끝)); i = 끝 + 1; continue; }
+    const 시작 = i;
+    while (i < s.length && !/\s/.test(s[i])) i++;
+    값들.push(s.slice(시작, i));
+  }
+  return 값들;
+}
+
+/**
+ * `/mcp__<서버>__<이름> 인자…` — MCP 서버가 낸 프롬프트를 받아 글로 편다 (2.1.3 · backend/mcp.js 의 프롬프트받기).
+ *
+ * 대화 화면과 `deel run` 이 같은 것을 쓴다 — 슬래시명령찾기 를 한 벌로 둔 것과 같은 까닭이다.
+ * 인자는 빈칸으로 갈라 적힌 차례대로 채우고, 마지막 인자가 나머지를 다 받는다(한 문장을 통째로 넘기게 ·
+ * 인자가르기).
+ *
+ * @returns null — 그런 프롬프트가 없다(부르는 쪽은 여느 슬래시 명령을 찾는다)
+ *          { 탈 } — 있는데 못 폈다 · { text, 서버이름, 이름 } — 모델에게 보낼 글
+ */
+export async function MCP프롬프트펴기(서버들, 부른이름, 인자글 = '', { signal = null } = {}) {
+  const { 이름풀기 } = await import('./backend/mcp.js');
+  const 갈린것 = 이름풀기(부른이름);
+  if (!갈린것) return null;
+  const 서버 = (서버들 ?? []).find((s) => s?.이름 === 갈린것.서버);
+  const 프롬프트 = (서버?.프롬프트 ?? []).find((p) => p?.name === 갈린것.도구);
+  if (!프롬프트) return null;
+  const 인자이름들 = (프롬프트.arguments ?? []).map((a) => a.name);
+  const 값들 = 인자가르기(인자글, 인자이름들.length);
+  const 인자 = {};
+  인자이름들.forEach((n, i) => { if (값들[i]) 인자[n] = 값들[i]; });
+  // hasOwn — 인자 이름이 constructor · toString 이면 `in` 은 Object 원형에서 찾아 「있다」 고 한다.
+  const 빠진것 = (프롬프트.arguments ?? []).filter((a) => a.required && !Object.hasOwn(인자, a.name)).map((a) => a.name);
+  if (빠진것.length) {
+    return { 탈: `인자가 모자랍니다 — /${부른이름} ${인자이름들.map((n) => `<${n}>`).join(' ')} (빠진 것: ${빠진것.join(' · ')})` };
+  }
+  if (!서버.쓸수있나()) return { 탈: `${서버.이름} 서버가 죽었습니다: ${서버.죽음 ?? '이유 모름'}` };
+  try {
+    const text = await 서버.프롬프트받기(프롬프트.name, 인자, { signal });
+    if (!text.trim()) return { 탈: `${서버.이름} 서버가 빈 프롬프트를 줬습니다` };
+    return { text, 서버이름: 서버.이름, 이름: 프롬프트.name };
+  } catch (e) {
+    return { 탈: `프롬프트를 못 받았습니다 — ${String(e?.message ?? e)}` };
+  }
+}

package/src/tools/importgraph.js

@@ -0,0 +1,107 @@
+/**
+ * 파일끼리 누가 누구를 불러 쓰나 — Outline 이 **많이 불리는 파일부터** 싣게 센다 (2.1.3).
+ *
+ * ── 왜 이게 필요한가 ───────────────────────────────────────────────────
+ *
+ * Outline 은 폴더의 뼈대를 최근에 손댄 순서로 싣고 창에 맞춰 뒤를 자른다. 그래서 오래 안 건드린 핵심 모듈 —
+ * 파일 수십 개가 불러 쓰는 것 — 이 큰 저장소에서 제일 먼저 잘렸다. 모델은 그 모듈이 있는 줄 모르고, 이미
+ * 있는 것을 새로 만든다.
+ *
+ * ── 무엇을 세나 ────────────────────────────────────────────────────────
+ *
+ *   js · ts   `import … from './x'` · `import './x'` · `import('./x')` · `require('./x')` · `export … from './x'`
+ *             — 점으로 시작하는 것만. 꾸러미 이름(`react`)은 이 폴더의 파일이 아니다.
+ *             확장자를 빼고 적은 것 · 폴더(index) · `.js` 로 적고 `.ts` 인 것까지 짚는다.
+ *   py        `from a.b import c` · `from .b import c` · `import a.b` — 모듈 파일과 `__init__.py`.
+ *
+ * 한 파일이 같은 곳을 여러 번 불러도 한 번이다. 정규식이라 문자열 속 `require('x')` 를 셀 수도 있다 —
+ * Outline 머리말과 같은 까닭으로 괜찮다. 여기 셈은 **무엇을 먼저 보여 줄지**에만 쓰인다.
+ * 읽는 양에 상한을 둔다. 넘으면 넘은 파일은 안 세고(불린 수 0), 그 사실은 부르는 쪽이 적는다.
+ */
+import { readFileSync, statSync } from 'node:fs';
+import { dirname, extname, join, resolve } from 'node:path';
+
+export const 셀파일상한 = 3000;
+const 한개상한 = 256 * 1024;
+
+const js확장 = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.mts', '.cts'];
+const js꼴 = new Set(js확장);
+const js무늬 = /(?:\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*|^\s*import\s+)(['"])(\.{1,2}\/[^'"\n]*|\.{1,2})\1/gm;
+const py무늬from = /^\s*from\s+(\.*)([\w.]*)\s+import\s+\(?([^\n#)]*)/gm;
+const py무늬import = /^\s*import\s+([\w.]+(?:\s+as\s+\w+)?(?:\s*,\s*[\w.]+(?:\s+as\s+\w+)?)*)/gm;
+
+/**
+ * @param {string} 뿌리  작업 폴더 (파이썬 절대 가져오기의 기준)
+ * @param {string[]} 파일들  절대 경로. 이 안에서만 짚고 센다.
+ * @returns {Map<string, number>} 절대 경로 → 그 파일을 불러 쓰는 **다른 파일** 수. 넘친 것이 있으면 `.넘침` 에 수.
+ */
+export function 들여옴세기(뿌리, 파일들, { 상한 = 셀파일상한 } = {}) {
+  const 셈 = new Map();
+  // 윈도우 · 맥은 대소문자를 안 가린다 — 적힌 글자와 디스크 글자가 달라도 같은 파일로 짚는다.
+  const 안가림 = process.platform === 'win32' || process.platform === 'darwin';
+  const 열쇠 = (p) => (안가림 ? p.toLowerCase() : p);
+  const 있는것 = new Map();
+  for (const p of 파일들) 있는것.set(열쇠(resolve(p)), resolve(p));
+  const 짚기 = (후보들) => { for (const c of 후보들) { const 찾음 = 있는것.get(열쇠(c)); if (찾음) return 찾음; } return null; };
+
+  const js짚기 = (파일, 적힌) => {
+    const t = resolve(dirname(파일), 적힌);
+    const 후보 = [t, ...js확장.map((e) => t + e), ...js확장.map((e) => join(t, `index${e}`))];
+    // ts 는 `./x.js` 로 적고 `x.ts` 를 둔다 (NodeNext).
+    const e = extname(t);
+    if (e === '.js' || e === '.mjs' || e === '.cjs') {
+      const 몸 = t.slice(0, -e.length);
+      후보.push(`${몸}.ts`, `${몸}.tsx`, `${몸}${e === '.mjs' ? '.mts' : e === '.cjs' ? '.cts' : '.ts'}`);
+    }
+    return 짚기(후보);
+  };
+  const py모듈 = (기준, 이름) => {
+    const 몸 = join(기준, ...이름.split('.').filter(Boolean));
+    return 짚기([`${몸}.py`, `${몸}.pyi`, join(몸, '__init__.py')]);
+  };
+
+  let 본수 = 0;
+  let 넘침 = 0;
+  for (const 파일 of 파일들) {
+    const e = extname(파일).toLowerCase();
+    const js = js꼴.has(e);
+    const py = e === '.py' || e === '.pyi';
+    if (!js && !py) continue;
+    if (본수 >= 상한) { 넘침++; continue; }
+    본수++;
+    let 글;
+    try {
+      if (statSync(파일).size > 한개상한) continue;
+      글 = readFileSync(파일, 'utf8');
+    } catch { continue; }
+    const 나 = resolve(파일);
+    const 부른것 = new Set();
+    if (js) {
+      for (const m of 글.matchAll(js무늬)) { const t = js짚기(나, m[2]); if (t) 부른것.add(t); }
+    } else {
+      for (const m of 글.matchAll(py무늬from)) {
+        const 점 = m[1].length;
+        const 모듈 = m[2];
+        let 기준 = resolve(뿌리);
+        if (점) { 기준 = dirname(나); for (let i = 1; i < 점; i++) 기준 = dirname(기준); }
+        if (모듈) { const t = py모듈(기준, 모듈); if (t) 부른것.add(t); }
+        // `from pkg import util` 의 util 이 하위 모듈일 수 있다.
+        for (const 이름 of m[3].split(',').map((x) => x.trim().split(/\s+/)[0]).filter((x) => /^\w+$/.test(x))) {
+          const t = py모듈(기준, 모듈 ? `${모듈}.${이름}` : 이름);
+          if (t) 부른것.add(t);
+        }
+      }
+      for (const m of 글.matchAll(py무늬import)) {
+        for (const 조각 of m[1].split(',')) {
+          const 이름 = 조각.trim().split(/\s+/)[0];
+          const t = py모듈(resolve(뿌리), 이름);
+          if (t) 부른것.add(t);
+        }
+      }
+    }
+    부른것.delete(나);
+    for (const t of 부른것) 셈.set(t, (셈.get(t) ?? 0) + 1);
+  }
+  셈.넘침 = 넘침;
+  return 셈;
+}

package/src/tools/index.js

@@ -18,13 +18,14 @@ import { TODO_TOOL } from './todo.js';
 import { TASK_TOOL } from './task.js';
 import { 고를말 } from '../agent/agents.js';
 import { OUTLINE_TOOL } from './outline.js';
-import { VERIFY_TOOL } from './verify.js';
+import { VERIFY_TOOL, 한파일문법 } from './verify.js';
 import { DEF_TOOL, REFS_TOOL } from './lsp.js';
 import { 편집후진단, 붙이기 as 진단붙이기, 데우기 } from '../lsp/diag.js';
 import { 프로젝트갈래 } from '../lsp/servers.js';
 import { allow as allowedIn } from '../agent/modes.js';
 import { 도구정의, 이름풀기 } from '../backend/mcp.js';
 import { 셸환경 } from '../safety/shellenv.js';
+import { 깃앞보기, 깃뒤적기 } from '../safety/gitsnap.js';
 import { isExcelPath, readExcel, toText as excelText, summarize as excelSummary } from './excel.js';
 import { isDocPath, readDoc, toText as docText, summarize as docSummary, looksOldHwp, 옛hwp안내, 문서는못고침 } from './docs.js';
 import { hwpx만들기, 만든말 } from './hwpxwrite.js';
@@ -725,6 +726,12 @@ function 나중에생긴것적기(떠본것, ctx) {
   for (const abs of 떠본것?.없던채뜬것 ?? []) {
     try { if (existsSync(abs) && !statSync(abs).isDirectory()) 떠본것.뜬것.push(ctx.scope.show(abs)); } catch { /* 넘어간다 */ }
   }
+  // 낱말로 못 짚은 것 — git 으로 견줘 안 것 (2.1.3 · safety/gitsnap.js). 이번 턴에 이미 뜬 것은 거기서 거른다.
+  if (떠본것?.깃앞) {
+    const 깃것 = 깃뒤적기(떠본것.깃앞, { history: ctx.history });
+    for (const abs of 깃것.뜬것) 떠본것.뜬것.push(ctx.scope.show(abs));
+    for (const x of 깃것.못뜬것) 떠본것.못뜬것.push(`${ctx.scope.show(x.abs)} (${x.왜})`);
+  }
 }
 
 /** 지금 파일이 몇 줄인가. 붙인 뒤 '얼마나 찼는지' 를 사실로 말해 주려고 센다. */
@@ -3109,6 +3116,12 @@ export const TOOLS = {
        * 그래도 손으로 옮기고 지우는 흔한 자리는 이걸로 덮인다.
        */
       const 떠본것 = 바꾸기전스냅샷(cmd, ctx);
+      /*
+       * git 저장소면 명령 앞 모습도 떠 둔다 (2.1.3 · safety/gitsnap.js). 낱말로는 못 짚는 자리 — 와일드카드 ·
+       * 스크립트 · 포매터가 바꾼 파일 — 를 명령 뒤에 견줘 되돌리기에 올린다. 뒤에서 도는 명령은 언제 끝날지
+       * 몰라 견줄 자리가 없으니 안 뜬다.
+       */
+      if (args.background !== true && ctx.history?.뒤늦은기록) 떠본것.깃앞 = 깃앞보기(ctx.scope.root);
       const 뜬것 = 떠본것.뜬것;
       /*
        * 못 뜬 것과 상한에 걸린 것은 **결과에 실어 보낸다.**
@@ -4118,6 +4131,16 @@ async function 고친뒤진단(name, r, ctx) {
     데우기(뿌리, 볼것[0]);
 
     const 것들 = await Promise.all(볼것.map((abs) => 편집후진단(뿌리, abs)));
+    /*
+     * 언어 서버가 말을 못 줬으면(없거나 · 아직 데우는 중) 문법만이라도 본다 (2.1.3 · verify.js 의 한파일문법).
+     * 서버가 답했으면 안 본다 — 오류 0개도 답이다. 두 번 보면 같은 탈을 두 줄로 적는다.
+     */
+    if (것들.some((d) => d === null)) {
+      const env = 셸환경(process.env, { 남길것: ctx.셸남길것 ?? [] }).env;
+      await Promise.all(볼것.map(async (abs, i) => {
+        if (것들[i] === null) 것들[i] = await 한파일문법(abs, { 뿌리, env });
+      }));
+    }
     let 답 = r;
     for (let i = 0; i < 볼것.length; i++) {
       답 = 진단붙이기(답, 것들[i], ctx.scope.show(볼것[i]));