deel-local-cli 0.8.0 → 1.0.0

package/src/tools/webfetch.js

@@ -12,6 +12,22 @@
 //   · 오프라인이면 아예 거절.
 //   · 받은 것은 글자만 뽑고 길이를 자른다.
 import { allowTemporarily, isOffline, isLocalHost } from '../safety/network.js';
+import { decode as decodeBytes } from './encoding.js';
+
+/**
+ * 받아 온 바이트를 글로. 머리글에 적힌 인코딩이 있으면 그것부터 믿는다.
+ *
+ * 파일을 읽을 때 쓰는 것과 같은 판단기(encoding.js)를 쓴다. 두 자리에 서로 다른
+ * 잣대를 두면, 같은 CP949 글이 파일로는 읽히고 웹으로는 깨지는 상태가 된다.
+ */
+function 웹글읽기(buf, 머리글) {
+  if (머리글 && !/^utf-?8$/.test(머리글)) {
+    try { return new TextDecoder(머리글, { fatal: false }).decode(buf); }
+    catch { /* 이 Node 가 모르는 이름이면 아래에서 알아서 본다 */ }
+  }
+  // euc-kr 인 페이지를 위해 힌트를 준다. 내용이 분명하면 내용이 이긴다.
+  return decodeBytes(buf, { fallback: 'euc-kr' }).text;
+}
 
 export const 방문기록 = [];
 
@@ -74,8 +90,28 @@ export async function webFetch(args, { allowPrivate = false } = {}) {
     const buf = Buffer.from(await res.arrayBuffer());
     if (buf.length > MAX_BYTES) return { error: `너무 큽니다 (${(buf.length / 1024 / 1024).toFixed(1)}MB).` };
 
-    let text = buf.toString('utf8');
+    /*
+     * 무엇으로 쓰여 있는지 알아보고 읽는다.
+     *
+     * 전에는 무조건 UTF-8 이었다. 사내 위키·공공기관 페이지는 아직 EUC-KR 이
+     * 흔한데, 그걸 UTF-8 로 읽으면 한글이 통째로 깨진다. 그 깨진 글이 그대로
+     * 모델에게 가고, 모델은 깨진 채로 요약한다 — 사용자는 왜 엉뚱한 답이
+     * 나오는지 알 수 없다. 파일을 읽을 때는 이미 알아보고 읽는데(encoding.js)
+     * 웹만 안 하고 있었다.
+     *
+     * 머리글(charset)이 있으면 그게 답이다. 없으면 내용을 보고 짐작한다.
+     */
+    const 머리글 = /charset=["']?([\w-]+)/i.exec(type)?.[1]?.toLowerCase() ?? null;
+    let text = 웹글읽기(buf, 머리글);
     if (/html/.test(type)) text = 태그벗기기(text);
+    // <meta charset> 이 머리글과 다르게 적혀 있는 페이지가 있다. 깨졌으면 그걸 믿고 다시 읽는다.
+    if (!머리글 && text.includes('�')) {
+      const meta = /<meta[^>]+charset=["']?([\w-]+)/i.exec(buf.toString('latin1').slice(0, 2000))?.[1]?.toLowerCase();
+      if (meta) {
+        text = 웹글읽기(buf, meta);
+        if (/html/.test(type)) text = 태그벗기기(text);
+      }
+    }
     const cut = text.length > max;
     if (cut) text = text.slice(0, max);
 

package/src/ui/ansi.js

@@ -5,6 +5,15 @@ const ON = (process.stdout.isTTY || process.env.FORCE_COLOR === '1') && process.
 
 const E = (n) => (s) => (ON ? `\x1b[${n}m${s}\x1b[0m` : String(s));
 
+// 흐린 글자의 밝기. 256색을 못 쓰는 옛 콘솔이면 90 으로 되돌린다.
+function GRAY() {
+  const 뜻 = String(process.env.DEEL_CONTRAST ?? '').toLowerCase();
+  if (뜻 === 'low') return 90;
+  const 옛콘솔 = process.env.TERM === 'dumb';
+  if (옛콘솔) return 뜻 === 'high' ? 37 : 90;
+  return 뜻 === 'high' ? '38;5;252' : '38;5;245';
+}
+
 export const c = {
   dim: E(2),
   bold: E(1),
@@ -17,7 +26,16 @@ export const c = {
   magenta: E(35),
   cyan: E(36),
   white: E(37),
-  gray: E(90),
+  // 흐린 글자.
+  //
+  // 예전에는 90(밝은 검정)이었는데, 배경이 어두우면 배경에 묻히고 밝으면
+  // 더 안 보인다. 실제로 "연한 글자가 잘 안 보인다" 는 말을 들었다.
+  // 그래서 어느 배경에서도 읽히는 중간 회색을 기본으로 쓴다.
+  //
+  // 눈에 맞게 바꿀 수 있다:
+  //   DEEL_CONTRAST=high  더 밝게 (밝은 배경이나 눈이 피로할 때)
+  //   DEEL_CONTRAST=low   예전처럼 흐리게
+  gray: E(GRAY()),
   // 밝은 계열 — 어두운 배경에서 본문과 구분이 필요할 때
   hred: E(91),
   hgreen: E(92),
@@ -41,6 +59,12 @@ export const cursor = {
 // 한글·한자·가나는 터미널에서 두 칸을 차지한다. 표 정렬이 이걸 모르면 어긋난다.
 export function width(str) {
   let w = 0;
+  // 없는 값은 빈 글자로 본다.
+  //
+  // String(null) 은 'null' 이라 폭이 4 로 나온다. 그러면 상태줄이 네 칸씩
+  // 어긋나고, 화면에는 'null' 이라는 글자가 그대로 찍힌다. 모델 이름이나
+  // 곁말은 없을 수 있는 값이라 실제로 여기로 들어온다.
+  if (str === null || str === undefined) return 0;
   for (const ch of String(str).replace(/\x1b\[[0-9;]*m/g, '')) {
     const cp = ch.codePointAt(0);
     if (
@@ -106,7 +130,13 @@ export function bar(used, total, cells = 32) {
 
 // 상태줄용 얇은 막대.
 export function gauge(ratio, cells = 10) {
-  const r = Math.min(1, Math.max(0, ratio));
+  // 숫자가 아니면 0 으로 본다.
+  //
+  // Math.min/max 는 NaN 을 그대로 흘린다. 그러면 repeat(NaN) 이 빈 글자가 되어
+  // 막대가 통째로 사라지고, 그만큼 상태줄이 밀린다. 컨텍스트 총량이 0 일 때
+  // used/total 이 실제로 NaN 이 된다 — 새 연결에서 드물게 나온다.
+  const n = Number(ratio);
+  const r = Number.isFinite(n) ? Math.min(1, Math.max(0, n)) : 0;
   const filled = Math.round(r * cells);
   const tone = r > 0.85 ? c.hred : r > 0.6 ? c.hyellow : c.hgreen;
   return tone('▰'.repeat(filled)) + c.gray('▱'.repeat(cells - filled));

package/src/ui/diff.js

@@ -0,0 +1,255 @@
+// 바뀐 자리를 줄 단위로 보여 준다.
+//
+// 왜 있어야 하나:
+//   auto 모드는 안 물어보고 고친다. 그게 이 도구의 속도인데, 화면에 "3군데"
+//   만 남으면 사람은 무엇이 바뀐지 모른 채 넘어간다. 되돌리기가 안전망이라도
+//   뭐가 바뀐지 모르면 되돌릴지 말지조차 못 정한다. 그래서 고친 자리는
+//   반드시 눈에 보여야 한다.
+//
+// 조심한 것:
+//   1) 큰 파일. LCS 표는 줄 수의 곱만큼 자리를 먹는다 — 1만 줄짜리 둘이면
+//      1억 칸이다. 그래서 앞뒤로 똑같은 부분을 먼저 잘라낸다. 파일 한 줄만
+//      고치는 흔한 경우는 이것만으로 표가 1×1 이 된다.
+//      그러고도 크면 LCS 를 포기하고 '이만큼이 통째로 바뀌었다' 로 물러선다.
+//      느린 것보다 대충이라도 빨리 보이는 편이 낫다.
+//   2) 줄 끝 표시(CRLF/LF). 눈에는 똑같은 줄이 전부 바뀐 것으로 나오면
+//      진짜 바뀐 곳을 못 찾는다. 그래서 그 경우를 따로 알아채서 말해 준다.
+//   3) 곁줄은 통째로 만들지 않는다. 20,000줄짜리에서 한 줄 고쳤다고 20,000개를
+//      늘어놓을 이유가 없다 — 필요한 자리만 그때그때 집어 온다.
+import { c, clip, cols } from './ansi.js';
+
+// LCS 표를 여기까지만 만든다. 넘으면 대충으로 물러선다. (4M 칸 = 16MB)
+const MAX_CELLS = 4_000_000;
+// 대충으로 물러섰을 때 실제로 만들어 둘 줄 수. 나머지는 세기만 한다.
+const MAX_COARSE = 2000;
+const TAB = '    ';
+
+/** 글을 줄로 나눈다. 마지막 개행이 있었는지는 따로 들고 있는다. */
+function 줄나누기(text) {
+  if (text === null || text === undefined) return { lines: [], eof: false, none: true };
+  const s = String(text);
+  if (s === '') return { lines: [], eof: false, none: false };
+  const eof = s.endsWith('\n');
+  const lines = (eof ? s.slice(0, -1) : s).split('\n');
+  return { lines, eof, none: false };
+}
+
+const 줄끝뗀것 = (arr) => arr.map((l) => (l.endsWith('\r') ? l.slice(0, -1) : l));
+const 같은가 = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+
+/**
+ * 두 글을 줄 단위로 비교한다.
+ *
+ * @param {string|null} before  없던 파일이면 null
+ * @param {string|null} after   지운 파일이면 null
+ * @returns {{
+ *   changed: boolean, added: number, removed: number,
+ *   isNew: boolean, isGone: boolean, eolOnly: boolean, eofChanged: boolean,
+ *   tooBig: boolean, omitted: number, hunks: Array<{from:number,to:number}>,
+ *   opAt: (p:number) => {t:string,a:number,b:number}|null, total: number,
+ *   linesA: string[], linesB: string[],
+ * }}
+ */
+export function diffLines(before, after, { context = 3, maxCells = MAX_CELLS } = {}) {
+  const A = 줄나누기(before);
+  const B = 줄나누기(after);
+  const linesA = A.lines;
+  const linesB = B.lines;
+
+  // 줄 끝 표시만 바뀐 것인가 — 내용은 그대로인데 \r 만 붙거나 떨어진 경우.
+  const 뗀A = 줄끝뗀것(linesA);
+  const 뗀B = 줄끝뗀것(linesB);
+  const eolOnly = !같은가(linesA, linesB) && 같은가(뗀A, 뗀B) && A.eof === B.eof;
+
+  // 앞뒤로 똑같은 부분을 잘라낸다. 여기서 대부분의 일이 끝난다.
+  let pre = 0;
+  const 짧은쪽 = Math.min(linesA.length, linesB.length);
+  while (pre < 짧은쪽 && linesA[pre] === linesB[pre]) pre++;
+  let suf = 0;
+  while (suf < 짧은쪽 - pre && linesA[linesA.length - 1 - suf] === linesB[linesB.length - 1 - suf]) suf++;
+
+  const midA = linesA.slice(pre, linesA.length - suf);
+  const midB = linesB.slice(pre, linesB.length - suf);
+
+  let script = [];
+  let added = 0;
+  let removed = 0;
+  let tooBig = false;
+  let omitted = 0;
+
+  if (midA.length === 0 && midB.length === 0) {
+    // 줄은 똑같다. 남은 차이는 마지막 개행뿐일 수 있다.
+  } else if (midA.length === 0 || midB.length === 0 || midA.length * midB.length > maxCells) {
+    // 한쪽이 통째로 비었거나, 표가 너무 크다 — 통째로 바뀐 것으로 본다.
+    tooBig = midA.length > 0 && midB.length > 0;
+    added = midB.length;
+    removed = midA.length;
+    const 몫 = tooBig ? Math.max(1, Math.floor(MAX_COARSE / 2)) : Infinity;
+    for (let i = 0; i < midA.length && i < 몫; i++) script.push({ t: '-', a: pre + i, b: -1 });
+    for (let j = 0; j < midB.length && j < 몫; j++) script.push({ t: '+', a: -1, b: pre + j });
+    omitted = Math.max(0, midA.length - 몫) + Math.max(0, midB.length - 몫);
+  } else {
+    script = LCS대본(midA, midB, pre);
+    for (const op of script) {
+      if (op.t === '+') added++;
+      else if (op.t === '-') removed++;
+    }
+  }
+
+  // 줄은 다 같은데 마지막 개행만 다른 경우. 마지막 줄이 바뀐 것으로 그린다.
+  let eofChanged = false;
+  if (added === 0 && removed === 0 && !A.none && !B.none && A.eof !== B.eof && linesA.length) {
+    eofChanged = true;
+    added = 1;
+    removed = 1;
+    const 끝 = linesA.length - 1;
+    script = [{ t: '-', a: 끝, b: -1 }, { t: '+', a: -1, b: linesB.length - 1 }];
+    // 대본이 맨 끝 한 줄을 대신하므로 꼬리 곁줄은 없다.
+    suf = 0;
+    pre = 끝;
+  }
+
+  const aTail = linesA.length - suf;
+  const bTail = linesB.length - suf;
+  const total = pre + script.length + suf;
+
+  // 자리 하나를 그때그때 집어 온다. 앞뒤 공통 부분은 만들어 두지 않는다.
+  const opAt = (p) => {
+    if (p < 0 || p >= total) return null;
+    if (p < pre) return { t: ' ', a: p, b: p };
+    const k = p - pre;
+    if (k < script.length) return script[k];
+    const t = k - script.length;
+    return { t: ' ', a: aTail + t, b: bTail + t };
+  };
+
+  // 바뀐 자리들을 곁줄을 붙여 덩어리로 묶는다.
+  const 바뀐자리 = [];
+  for (let k = 0; k < script.length; k++) if (script[k].t !== ' ') 바뀐자리.push(pre + k);
+
+  const hunks = [];
+  for (const p of 바뀐자리) {
+    const 마지막 = hunks[hunks.length - 1];
+    // 곁줄끼리 겹치거나 맞닿으면 한 덩어리로 합친다.
+    if (마지막 && p - 마지막.last <= context * 2 + 1) {
+      마지막.last = p;
+      마지막.to = Math.min(total - 1, p + context);
+    } else {
+      hunks.push({ from: Math.max(0, p - context), to: Math.min(total - 1, p + context), last: p });
+    }
+  }
+  for (const h of hunks) delete h.last;
+
+  return {
+    changed: added > 0 || removed > 0,
+    added, removed,
+    isNew: A.none && !B.none,
+    isGone: !A.none && B.none,
+    eolOnly, eofChanged, tooBig, omitted,
+    hunks, opAt, total, linesA, linesB,
+  };
+}
+
+/**
+ * 가장 긴 공통 부분 수열로 대본을 만든다.
+ *
+ * 표를 통째로 잡는다 — 되짚어 올라가려면 표가 있어야 한다. 크기는 부르는 쪽에서
+ * 이미 걸러 놨다. Uint32Array 를 쓰는 이유는 보통 배열보다 자리를 덜 먹고
+ * 빈칸 채우기가 빨라서다.
+ */
+function LCS대본(a, b, base) {
+  const n = a.length;
+  const m = b.length;
+  const W = m + 1;
+  const 표 = new Uint32Array((n + 1) * W);
+  for (let i = n - 1; i >= 0; i--) {
+    const 줄 = i * W;
+    const 다음 = (i + 1) * W;
+    const ai = a[i];
+    for (let j = m - 1; j >= 0; j--) {
+      표[줄 + j] = ai === b[j] ? 표[다음 + j + 1] + 1 : Math.max(표[다음 + j], 표[줄 + j + 1]);
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) { out.push({ t: ' ', a: base + i, b: base + j }); i++; j++; }
+    else if (표[(i + 1) * W + j] >= 표[i * W + j + 1]) { out.push({ t: '-', a: base + i, b: -1 }); i++; }
+    else { out.push({ t: '+', a: -1, b: base + j }); j++; }
+  }
+  while (i < n) { out.push({ t: '-', a: base + i, b: -1 }); i++; }
+  while (j < m) { out.push({ t: '+', a: -1, b: base + j }); j++; }
+  return out;
+}
+
+const 보기좋게 = (s) => String(s ?? '').replace(/\t/g, TAB).replace(/\r/g, '');
+
+/**
+ * 화면에 그릴 줄들을 만든다.
+ *
+ * @param {ReturnType<typeof diffLines>|null} d
+ * @param {{maxLines?:number, width?:number, indent?:string}} opts
+ */
+export function renderDiff(d, { maxLines = 40, width = 0, indent = '    ' } = {}) {
+  if (!d || !d.hunks) return [];
+  const 폭 = width > 0 ? width : Math.max(30, cols() - 18);
+  const out = [];
+
+  if (d.eolOnly) {
+    out.push(`${indent}${c.yellow('※')} ${c.gray('줄 끝 표시(CRLF/LF)만 바뀌었습니다 — 글자는 그대로입니다.')}`);
+  }
+  if (d.eofChanged) {
+    out.push(`${indent}${c.gray('※ 마지막 줄의 개행만 바뀌었습니다.')}`);
+  }
+  if (d.tooBig) {
+    out.push(`${indent}${c.gray('※ 너무 많이 바뀌어 자세히는 못 맞춥니다 — 통째로 바뀐 것으로 봅니다.')}`);
+  }
+  if (!d.hunks.length) return out;
+
+  const 번호폭 = String(Math.max(d.linesA?.length ?? 0, d.linesB?.length ?? 0)).length;
+  let 그린줄 = 0;
+  let 남은줄 = 0;
+  let 끊김 = false;
+
+  for (let h = 0; h < d.hunks.length; h++) {
+    const { from, to } = d.hunks[h];
+    if (h > 0) {
+      if (그린줄 >= maxLines) { 끊김 = true; }
+      else { out.push(`${indent}${c.gray('⋯')}`); }
+    }
+    for (let p = from; p <= to; p++) {
+      if (그린줄 >= maxLines) { 끊김 = true; 남은줄 += to - p + 1; break; }
+      const op = d.opAt(p);
+      if (!op) continue;
+      const 글 = clip(보기좋게(op.t === '-' ? d.linesA[op.a] : d.linesB[op.b]), 폭);
+      // 번호는 '지금 파일' 의 번호만 적는다.
+      //
+      // 없어진 줄에 옛 번호를 달면, 바로 위 곁줄의 새 번호와 같은 숫자가 나란히
+      // 찍힌다 — 서로 다른 파일의 번호가 한 줄에 섞여 보인다. 실제로 8번이
+      // 두 번 찍히는 화면이 나왔다. 없어진 줄은 지금 파일에 없으니 번호도 없다.
+      const n = op.t === '-' ? ' '.repeat(번호폭) : String(op.b + 1).padStart(번호폭);
+      if (op.t === '+') out.push(`${indent}${c.hgreen('+')} ${c.gray(n)} ${c.green(글)}`);
+      else if (op.t === '-') out.push(`${indent}${c.hred('-')} ${c.gray(n)} ${c.red(글)}`);
+      else out.push(`${indent}${c.gray(' ')} ${c.gray(n)} ${c.gray(글)}`);
+      그린줄++;
+    }
+    if (끊김) {
+      for (let k = h + 1; k < d.hunks.length; k++) 남은줄 += d.hunks[k].to - d.hunks[k].from + 1;
+      break;
+    }
+  }
+
+  남은줄 += d.omitted ?? 0;
+  if (남은줄 > 0) out.push(`${indent}${c.gray(`⋯ 외 ${남은줄.toLocaleString()}줄 더`)}`);
+  return out;
+}
+
+/** `+3 −1` 한 줄 요약. 안 바뀌었으면 빈 글. */
+export function shortStat(d) {
+  if (!d || !d.changed) return '';
+  const 조각 = [];
+  if (d.added) 조각.push(c.hgreen(`+${d.added}`));
+  if (d.removed) 조각.push(c.hred(`−${d.removed}`));
+  return 조각.join(' ');
+}

package/src/ui/level.js

@@ -18,8 +18,12 @@ export const LEVELS = {
     hint: '권장값으로 바로 시작',
     // 목록에 띄울 것. 나머지는 쳐도 먹지만 안 보인다.
     show: [
-      'help', 'code', 'plan', 'ask',
-      'model', 'scan', 'undo', 'clear', 'sessions', 'cost', 'level', 'exit',
+      'help', 'work', 'auto', 'code', 'plan', 'ask',
+      // ctx 를 초보 목록에 넣는다. 컨텍스트가 작게 잡히면 "왜 파일을 조금만 읽지"
+      // 가 되는데, 초보일수록 그 원인을 못 찾는다. 명령 하나로 끝나는 문제다.
+      // diff 는 초보에게 특히 필요하다. auto 모드는 안 물어보고 고치니,
+      // '무엇이 바뀌었나' 를 볼 통로가 없으면 되돌릴지 말지도 못 정한다.
+      'model', 'ctx', 'scan', 'diff', 'undo', 'clear', 'sessions', 'cost', 'level', 'exit',
     ],
     // 첫 실행에서 훑어 추천까지 해 준다
     autoScan: true,

package/src/ui/prompt.js

@@ -30,11 +30,23 @@ export function ask(label, { mask = false, def = '' } = {}) {
   process.stdout.write(prefix + (def ? c.gray(`[${def}] `) : ''));
   let buf = '';
   return readKeys((ch, done) => {
-    for (const ch1 of ch) {
+    // 글자 단위로 훑되 자리를 기억한다. 엔터에서 멈출 때 '남은 것' 을 알아야 해서다.
+    const 글자들 = [...ch];
+    for (let i = 0; i < 글자들.length; i++) {
+      const ch1 = 글자들[i];
       const code = ch1.charCodeAt(0);
       if (code === 3) { say(''); process.exit(130); }            // Ctrl+C
       if (code === 13 || code === 10) {                          // Enter
         say('');
+        // 한 덩어리에 여러 줄이 실려 올 수 있다 — 붙여넣기, 파이프 입력, 느린 터미널.
+        // 예전에는 엔터를 만나면 그 덩어리의 나머지를 그냥 버렸다. 그러면 이어서
+        // 물어보는 쪽이 아무것도 못 받고 멈춘 것처럼 보인다. 무엇이 사라졌는지도
+        // 화면에 안 남아서, 사람은 자기가 안 친 줄 안다.
+        // 그래서 되돌려 놓는다 — 다음에 읽는 쪽이 받아 간다.
+        let 다음 = i + 1;
+        if (code === 13 && 글자들[다음] === '\n') 다음++;         // CRLF 는 한 번으로 친다
+        const 남은것 = 글자들.slice(다음).join('');
+        if (남은것) { try { process.stdin.unshift(남은것); } catch { /* 못 돌려놔도 이 줄은 살린다 */ } }
         return done(buf.length ? buf : def);
       }
       if (code === 127 || code === 8) {                          // Backspace

package/src/ui/screen.js

@@ -0,0 +1,169 @@
+/**
+ * 화면 한 장.
+ *
+ * 왜 이 파일이 생겼나:
+ *   repl.js 안에 say()·process.stdout.write 가 79군데 흩어져 있었다. 그 상태로는
+ *   전체화면 화면(TUI)을 얹을 수가 없다 — 어디로 무엇이 나가는지 한 군데서 못 잡으니
+ *   두 화면이 같은 코드를 나눠 쓰려다 결국 둘 다 어중간해진다.
+ *
+ *   그래서 '무엇을 그린다' 와 '어떻게 그린다' 를 가른다. repl.js 는 이제
+ *   `화면.줄(...)`·`화면.답조각(...)` 처럼 **뜻**만 말하고, 그것을 줄로 흘릴지
+ *   칸에 담아 다시 그릴지는 여기서 정한다.
+ *
+ * 두 가지 구현이 있다:
+ *   줄화면(LineScreen)  지금까지의 그 화면. 위에서 아래로 흘러간다.
+ *                       파이프·기록·CI·`deel run`·검사가 전부 이것을 읽는다.
+ *   전체화면(TuiScreen) ui/tui.js. 사람이 터미널 앞에 앉아 있을 때만.
+ *
+ * **줄화면을 없애지 않는 것이 핵심이다.** 전체화면은 터미널을 통째로 점유하고
+ * 커서를 옮겨 가며 다시 그린다. 그 출력을 파일로 넘기면 제어문자 덩어리가 되고,
+ * CI 로그에서는 읽을 수가 없다. 그래서 두 벌을 갖고 상황에 따라 고른다.
+ */
+import { c, say, cursor, box, cols } from './ansi.js';
+import { statusLine, contextWarning } from './status.js';
+import { spin } from './spinner.js';
+
+/**
+ * 지금 이 자리에서 전체화면을 써도 되는가.
+ *
+ * 셋 다 맞아야 한다. 하나라도 아니면 줄화면이다 —
+ * 애매하면 줄화면이 맞다. 잘못 켜면 사용자 화면이 깨지지만,
+ * 잘못 안 켜면 그냥 지금까지의 화면일 뿐이다.
+ */
+export function 전체화면쓸까({ tui = null } = {}) {
+  if (tui === false) return false;              // deel --no-tui
+  if (!process.stdout.isTTY) return false;      // 파이프·기록·CI
+  if (!process.stdin.isTTY) return false;       // 입력이 파이프로 들어옴 (검사·데모)
+  if (process.env.TERM === 'dumb') return false;
+  if (process.env.CI) return false;
+  // 창이 너무 작으면 칸을 나눌 자리가 없다. 억지로 나누면 글자가 겹친다.
+  if ((process.stdout.columns ?? 0) < 60 || (process.stdout.rows ?? 0) < 16) return false;
+  if (tui === true) return true;
+  return true;
+}
+
+/**
+ * 줄로 흘려보내는 화면 — 지금까지의 그 화면.
+ *
+ * 여기 있는 메서드 하나하나가 전에 repl.js 에 흩어져 있던 출력 한 줄과
+ * **글자 하나까지 같아야 한다.** 검사가 전부 이 화면을 글로 읽고 있어서,
+ * 다르면 그 자리에서 잡힌다. 그게 이 갈라내기가 맞는지 재는 자다.
+ */
+export class LineScreen {
+  constructor() {
+    this.kind = 'line';
+    // 곧 지워질 줄이 화면에 있나. \r 로 커서만 앞으로 보내 놓고 안 지우면
+    // 다음에 오는 짧은 글이 그 줄 위에 겹쳐 찍힌다.
+    this.임시중 = false;
+    this.돌림 = null;
+  }
+
+  // ── 흘러가는 글 ────────────────────────────────────────────────────────
+
+  /** 한 줄. 이미 색이 입혀진 글을 받는다. */
+  줄(s = '') { this.임시지움(); say(s); }
+
+  /** 줄바꿈 없이 이어 붙인다 — 스트리밍으로 오는 답. */
+  붙임(s) { this.임시지움(); process.stdout.write(s); }
+
+  // ── 곧 지워질 표시 ─────────────────────────────────────────────────────
+
+  /**
+   * 기다리는 중. \r 로 커서만 앞으로 보낸다.
+   *
+   * 파이프일 때도 찍는다 — 데모·기록에서 '무엇을 기다리는 중이었나' 가
+   * 남아야 한다. 다만 지워야 할 줄로 세는 것은 터미널일 때만이다.
+   */
+  기다림(s) {
+    process.stdout.write(`  ${s}\r`);
+    if (process.stdout.isTTY) this.임시중 = true;
+  }
+
+  /** 생각하는 중. 글자 수가 계속 바뀌므로 터미널일 때만 그린다. */
+  생각(s) {
+    if (!process.stdout.isTTY) return;
+    cursor.clearLine();
+    process.stdout.write(`  ${s}`);
+    this.임시중 = true;
+  }
+
+  임시지움() {
+    if (this.임시중) { cursor.clearLine(); this.임시중 = false; }
+  }
+
+  /**
+   * 사람이 치고 있던 입력 줄을 지운다.
+   *
+   * Shift+Tab 으로 작업 모드를 돌릴 때처럼, 입력을 기다리는 도중에 화면에
+   * 한 줄을 끼워 넣어야 하는 자리가 있다. 안 지우면 `❯ ` 뒤에 새 글이 붙는다.
+   * 전체화면에서는 입력이 제 칸에 따로 있어서 지울 것이 없다.
+   */
+  입력지움() { cursor.clearLine(); }
+
+  /** 오래 걸리는 일에 돌아가는 표시를 세운다. */
+  돌리기(label) { this.돌림 = spin(label); return this.돌림; }
+
+  // spinner 가 멈추면서 이미 줄을 지우고 커서를 되살린다. 여기서 또 지우지 않는다 —
+  // 화면에 나가는 제어문자가 한 벌이라도 달라지면 그게 갈라내기의 흔적이 된다.
+  돌림멈춤(finalLine) {
+    if (!this.돌림) return;
+    this.돌림.stop(finalLine);
+    this.돌림 = null;
+  }
+
+  // ── 자리를 차지하는 것 ─────────────────────────────────────────────────
+
+  /** 켤 때 한 번 그리는 머리말 상자. */
+  머리말(lines) {
+    say('');
+    for (const l of box(lines, { tone: c.gray })) say('  ' + l);
+  }
+
+  /**
+   * 입력 자리. 위에 상태줄을 한 줄 깔고 그 아래에 커서를 둔다.
+   *
+   * 줄화면에서는 이게 매번 새로 찍힌다 — 대화가 길어지면 상태줄이 화면에
+   * 여러 번 남는다. 그게 흘러가는 화면의 성질이고, 기록으로 읽을 때는
+   * 오히려 그때그때 상태를 알 수 있어 낫다.
+   */
+  입력자리(session) {
+    say('');
+    say(statusLine(session));
+    const w = contextWarning(session);
+    if (w) say(` ${w}`);
+    process.stdout.write(` ${c.hcyan('❯')} `);
+  }
+
+  /** 오른쪽 칸에 들어갈 것들. 줄화면에는 오른쪽 칸이 없다. */
+  파일칸() { /* 줄화면은 안 그린다 */ }
+
+  할일칸() { /* 할 일은 나올 때마다 줄로 흘려보낸다 (repl.js 가 그린다) */ }
+
+  /** 창 크기가 바뀌었다. 줄화면은 다시 그릴 것이 없다. */
+  다시그림() { }
+
+  close() {
+    this.돌림멈춤();
+    this.임시지움();
+  }
+}
+
+/**
+ * 상황에 맞는 화면을 하나 고른다.
+ *
+ * 전체화면 쪽은 필요할 때만 읽어 들인다. 줄화면으로 돌 때 tui.js 를
+ * 파싱조차 안 하게 하려는 것이다 — `deel run` 이 조금이라도 빨리 시작해야 한다.
+ */
+export async function 화면고르기(opts = {}) {
+  if (!전체화면쓸까(opts)) return new LineScreen();
+  try {
+    const { TuiScreen } = await import('./tui.js');
+    return new TuiScreen(opts);
+  } catch (e) {
+    // 전체화면을 못 세우면 조용히 줄화면으로 간다. 화면 하나 때문에
+    // 프로그램이 안 뜨는 일은 없어야 한다.
+    const s = new LineScreen();
+    s.줄(`  ${c.gray(`전체화면을 못 켰습니다 — 줄 화면으로 갑니다. (${e.message})`)}`);
+    return s;
+  }
+}