deel-local-cli 1.5.2 → 1.5.4

package/src/ui/office.js

@@ -78,9 +78,18 @@ const C = {
   화면: 45, 화면꺼짐: 239, 화면글: 123, 살: 223,
   머리: [52, 240, 94, 130], 옷: [67, 131, 71, 97],
   밤: 17, 별: 226, 낮: 111, 구름: 255,
+  새벽: 153, 노을: 173, 노을구름: 217, 별흐림: 250,
+  해: 226, 아침해: 229, 노을해: 208, 달: 230,
+  시계판: 253, 머그: 254, 커피: 94,
   종이: 255, 종이어둠: 250, 쪽지: 227, 쪽지끝: 120, 초록: 46, 넘침: 208,
 };
 
+// 하루가 가면 방도 저문다. [벽, 바닥]
+const 방색 = {
+  아침: [C.벽, C.바닥], 낮: [C.벽, C.바닥],
+  노을: [237, 137], 밤: [236, C.바닥줄],
+};
+
 // ── 픽셀 판 ─────────────────────────────────────────────────────────────
 class 판 {
   constructor(가로, 세로칸) {
@@ -187,16 +196,27 @@ function 자리색(자세, 머리, 옷) {
 export function 사무실줄들(상태, 폭) {
   const {
     일꾼들 = [], 읽은파일 = 0, 고친파일 = 0, 할일 = 0, 끝난일 = 0,
-    부른횟수 = 0, 창 = 0, 틱 = 0,
+    부른횟수 = 0, 창 = 0, 틱 = 0, 걸린초 = 0,
   } = 상태;
 
   const 가로 = Math.max(60, 폭);
   const p = new 판(가로, 세로);
-  p.칠하기(0, 0, 가로, 벽, C.벽);
-  p.칠하기(0, 벽, 가로, 1, C.굽도리);
-  p.칠하기(0, 벽 + 1, 가로, 세로 - 벽 - 1, C.바닥);
 
-  const 밤인가 = 창 > 0.55;
+  // 컨텍스트가 차는 만큼 하루가 간다. 넷으로 나눈다 — 둘이면 5% 와 50% 가
+  // 똑같은 대낮이라 창이 아무 말도 안 하게 된다.
+  const 하늘 = 창 >= 0.8 ? '밤' : 창 >= 0.55 ? '노을' : 창 >= 0.25 ? '낮' : '아침';
+
+  /*
+   * 방 안도 같이 저문다. 창만 어두워지고 벽은 대낮이면 창이 그림 액자처럼
+   * 보인다 — 저 창이 이 방의 창이라는 것이 안 읽힌다.
+   *
+   * 사람과 책상은 안 어둡게 한다. 이 방을 켠 이유가 자리를 읽는 것인데,
+   * 밤이라고 그게 안 보이면 분위기를 위해 본문을 버린 셈이 된다.
+   */
+  const [벽색, 바닥색] = 방색[하늘];
+  p.칠하기(0, 0, 가로, 벽, 벽색);
+  p.칠하기(0, 벽, 가로, 1, C.굽도리);
+  p.칠하기(0, 벽 + 1, 가로, 세로 - 벽 - 1, 바닥색);
 
   // 화이트보드 18×5 — 할 일. 끝난 것은 초록, 남은 것은 노랑.
   {
@@ -246,25 +266,100 @@ export function 사무실줄들(상태, 폭) {
     p.올리기(가로 - 15, 0, 그림, { R: C.검정, L: C.초록, l: C.쇠진, O: C.넘침 });
   }
 
-  // 창문 — 벽에 남는 자리만큼. 컨텍스트가 차면 밤이 된다.
+  /*
+   * ── 창밖 — 컨텍스트가 차는 만큼 하루가 간다 ──────────────────────────
+   *
+   * 아침 → 낮 → 노을 → 밤. 넷은 꾸밈이 아니라 **컨텍스트가 얼마나 찼는가**
+   * 하나를 네 칸으로 나눈 것이다. 노을이 들면 슬슬 접을 때고, 밤이면 이미
+   * 늦은 것이다 — 숫자를 안 읽고 곁눈으로 봐도 그게 보인다.
+   *
+   * 예전에는 낮/밤 둘뿐이라 5% 와 50% 가 똑같이 환한 대낮이었다. 컨텍스트가
+   * 반이나 찬 것과 거의 안 찬 것이 같은 그림이면, 이 창은 아무 말도 안 한다.
+   */
   {
     const 시작 = 21;
     const 남 = 가로 - 15 - 시작;
     const 창수 = Math.max(0, Math.floor(남 / 18));
+
+    /*
+     * 해는 동쪽에서 낮게 떠 한낮에 높이 오고, 서쪽으로 기울었다가 달로 바뀐다.
+     * 자리가 곧 시각이라, 세 칸짜리 하늘에서도 하루가 도는 것이 보인다.
+     * 3×2 로 그린다 — 2×1 짜리 점은 구름과 구별이 안 됐다.
+     */
+    const 하늘것 = {
+      아침: { k: 2, r: 1 }, 낮: { k: 4, r: 0 }, 노을: { k: 9, r: 1 }, 밤: { k: 10, r: 0 },
+    }[하늘];
+    const 칠 = {
+      아침: { F: C.쇠어둠, S: C.새벽, c: C.구름, o: C.아침해 },
+      낮: { F: C.쇠어둠, S: C.낮, c: C.구름, o: C.해 },
+      노을: { F: C.쇠어둠, S: C.노을, c: C.노을구름, o: C.노을해 },
+      밤: { F: C.쇠어둠, S: C.밤, c: C.별, o: C.달 },
+    }[하늘];
+
+    /*
+     * 구름은 흐르고 별은 깜빡인다. 이 둘만은 숫자가 아니다 — 방이 멈춰 있지
+     * 않다는 것만 말한다. 그래서 아주 느리게 둔다(구름 14판, 별 9판에 한 번).
+     * 빨리 움직이면 눈이 그쪽으로 끌려가서, 정작 읽어야 할 자리·쪽지·불빛을
+     * 안 보게 된다.
+     *
+     * 구름은 **덩어리**여야 한다. 칸마다 따로 주사위를 굴렸더니 흰 점이
+     * 흩뿌려져서, 구름이 아니라 화면 잡티로 보였다. 가운데 줄을 넓게 잡아
+     * 뭉게구름 모양을 만든다.
+     */
+    const 흐름 = Math.floor(틱 / 14);
+    const 깜빡 = Math.floor(틱 / 9);
+    const 구름폭 = [1, 3, 2];
+    const 구름인가 = (i, r, k) => {
+      for (const b of [0, 1]) {
+        const 중심 = ((i * 9 + b * 11 + 흐름) % 22) - 4;
+        if (Math.abs(k - 중심) <= 구름폭[r]) return true;
+      }
+      return false;
+    };
+
     for (let i = 0; i < 창수; i++) {
       const 그림 = ['FFFFFFFFFFFFFFFF'];
       for (let r = 0; r < 3; r++) {
         let 줄 = 'F';
         for (let k = 0; k < 14; k++) {
-          const h = (i * 37 + r * 19 + k * 11) % 29;
-          줄 += k === 7 ? 'F' : (밤인가 ? (h < 5 ? '*' : '.') : (h < 3 ? 'o' : ','));
+          if (k === 7) { 줄 += 'F'; continue; }               // 창틀 세로대
+          const 해자리 = (r === 하늘것.r || r === 하늘것.r + 1)
+            && k >= 하늘것.k && k < 하늘것.k + 3;
+          if (해자리) { 줄 += 'o'; continue; }
+          if (하늘 === '밤') {
+            const h = (i * 37 + r * 19 + k * 11) % 31;
+            줄 += (h < 4 && (h + 깜빡) % 4 !== 0) ? 'c' : 'S';
+          } else {
+            줄 += 구름인가(i, r, k) ? 'c' : 'S';
+          }
         }
         그림.push(줄 + 'F');
       }
       그림.push('FFFFFFFFFFFFFFFF');
-      p.올리기(시작 + i * 18, 0, 그림, 밤인가
-        ? { F: C.쇠어둠, '.': C.밤, '*': C.별 }
-        : { F: C.쇠어둠, ',': C.낮, o: C.구름 });
+      p.올리기(시작 + i * 18, 0, 그림, 칠);
+    }
+
+    /*
+     * 벽시계 — 이번 턴이 얼마나 걸렸나.
+     *
+     * 상자 오른쪽 끝에 걸린 시간이 이미 초로 찍히지만, 그건 읽어야 보인다.
+     * 바늘은 안 읽어도 보인다 — 한 바퀴가 1분이라, 두 바퀴째면 "오래 걸리는
+     * 중이구나" 가 숫자를 세기 전에 온다.
+     *
+     * 창을 놓고 남는 자리에만 건다. 좁은 터미널에서 시계 때문에 창이 하나
+     * 줄면 그건 손해다 — 창이 이 방의 본문이다.
+     */
+    const 남은칸 = 남 - 창수 * 18;
+    if (남은칸 >= 8) {
+      const cx = 시작 + 창수 * 18 + Math.floor((남은칸 - 7) / 2);
+      p.올리기(cx, 0, [' TTTTT ', 'TWWWWWT', 'TWWWWWT', 'TWWWWWT', ' TTTTT '],
+        { T: C.검정, W: C.시계판 });
+      // 한 바퀴에 1분. 7.5초마다 한 칸씩 — 도는 것이 보이면서도 매 판 다시
+      // 그릴 만큼 부산하지는 않다.
+      const 칸 = Math.floor((걸린초 % 60) / 7.5) % 8;
+      const [dx, dy] = [[0, -2], [1, -1], [2, 0], [1, 1], [0, 2], [-1, 1], [-2, 0], [-1, -1]][칸];
+      p.찍기(cx + 3, 2, C.검정);
+      p.찍기(cx + 3 + dx, 2 + dy, C.검정);
     }
   }
 
@@ -310,10 +405,29 @@ export function 사무실줄들(상태, 폭) {
     if (넘친자리 && i === 자리수 - 1) p.칠하기(x + 자리폭 - 2, y + 자리높이 - 3, 2, 2, C.넘침);
     // 조는 사람 머리 위 z
     if (자세 === '졸기' && 짝) p.칠하기(x + 13, y + 2, 2, 1, C.종이);
-    // 고친 파일은 책상 위 종이로
-    if (i < 고친파일) p.칠하기(x + 13, y + 9, 4, 1, C.종이);
+    /*
+     * 조는 자리에는 식은 커피가 있다.
+     *
+     * 이것도 지어낸 것이 아니라 조는 것과 **같은 수**(45초 넘김)를 한 번 더
+     * 다르게 보인 것이다. 자는 사람이 화면 뒤로 반쯤 숨는 자세라, 좁은
+     * 터미널에서는 조는지 자리를 비운 것인지 헷갈렸다. 머그는 안 숨는다.
+     */
+    if (자세 === '졸기') {
+      p.칠하기(x + 2, y + 10, 2, 2, C.머그);
+      p.칠하기(x + 2, y + 10, 2, 1, C.커피);
+    }
+    /*
+     * 고친 파일은 책상 위 종이로. 한 자리에 두 장까지.
+     *
+     * 전에는 자리마다 한 장이라 다섯 자리짜리 방에서 다섯 장이 상한이었고,
+     * 여섯 개를 고치나 스무 개를 고치나 같은 그림이었다. 자리당 두 장으로
+     * 두면 눈금이 두 배가 된다 — 없는 자리를 만들지 않으면서.
+     */
+    const 종이몫 = Math.min(2, Math.max(0, 고친파일 - i * 2));
+    for (let n = 0; n < 종이몫; n++) p.칠하기(x + 13 - n * 4, y + 9, 3, 1, C.종이);
   }
 
+
   return p.줄들();
 }
 
@@ -350,9 +464,22 @@ export const 최소폭 = 60;
  * 정해야지 화면 높이로 정하면 안 된다. 창을 줄였다 늘였다 할 때마다 상자 안
  * 그림이 기사였다 돌림표였다 하면 무슨 규칙인지 아무도 모른다.
  */
+/*
+ * 설정 파일에서 켜 뒀나. `/motion 사무실` 이 여기에 넣는다.
+ *
+ * motion.js 와 같은 이유로 파일을 여기서 안 읽는다 — 판마다 불리는 자리다.
+ * 환경변수가 이긴다(한 번만 다르게 보고 싶을 때, 그리고 검사가 쓰는 길).
+ */
+let 설정으로켰나 = false;
+export function 사무실설정(켬) { 설정으로켰나 = !!켬; }
+
 export function 켜달라했나() {
-  const v = String(process.env.DEEL_OFFICE ?? '').trim().toLowerCase();
-  return v === '1' || v === 'on' || v === '켬' || v === '사무실';
+  const raw = process.env.DEEL_OFFICE;
+  if (raw !== undefined) {
+    const v = String(raw).trim().toLowerCase();
+    return v === '1' || v === 'on' || v === '켬' || v === '사무실';
+  }
+  return 설정으로켰나;
 }
 
 export function 켜나(rows = process.stdout.rows, cols = process.stdout.columns) {
@@ -373,7 +500,7 @@ export function 켜나(rows = process.stdout.rows, cols = process.stdout.columns
  * @param {object} 일감   지금 도는 일 (없으면 null)
  * @param {number} 틱
  */
-export function 상태만들기(session, 일감, 틱 = 0, 할일들 = [], 도는하위 = 0) {
+export function 상태만들기(session, 일감, 틱 = 0, 할일들 = [], 도는하위 = 0, 함께도는 = 0) {
   const s = session ?? {};
   const 쓴것 = s.usage ?? {};
   const 총토큰 = (쓴것.in ?? 0) + (쓴것.out ?? 0);
@@ -386,6 +513,8 @@ export function 상태만들기(session, 일감, 틱 = 0, 할일들 = [], 도는
    * 것을 그대로 쓴다 — motion.js 가 쓰는 그 갈래다.
    */
   const 일꾼들 = [];
+  // 벽시계가 볼 값. 일이 없으면 0 — 바늘이 12 시에 선다.
+  let 걸린초 = 0;
   if (일감) {
     /*
      * 오래 끌면 존다.
@@ -398,6 +527,7 @@ export function 상태만들기(session, 일감, 틱 = 0, 할일들 = [], 도는
      */
     const 지난 = Number.isFinite(일감.시작) ? Date.now() - 일감.시작 : 0;
     const 오래됐나 = 일감.갈래 === '느긋' || 지난 >= 느긋해질때;
+    걸린초 = Math.floor(지난 / 1000);
     const 갈래 = 오래됐나 ? '졸기'
       : ['읽기', '웹'].includes(일감.갈래) ? '읽기'
         : ['쓰기', '명령', '답'].includes(일감.갈래) ? '쓰기' : '대기';
@@ -414,11 +544,26 @@ export function 상태만들기(session, 일감, 틱 = 0, 할일들 = [], 도는
      * 모른다고 두는 편이 낫다 — 자리가 찼다는 사실은 그대로 보인다.
      */
     일꾼들.push({ 갈래 });
+    /*
+     * 읽기 도구를 한꺼번에 돌리면 그만큼 진짜로 동시에 돈다.
+     *
+     * 방이 늘 한 명짜리로 보이던 진짜 이유가 여기 있었다. 하위 작업은
+     * loop.js 가 `for await` 로 기다리므로 **순서대로** 돈다 — 도는하위 는
+     * 사실상 0 아니면 1 이고, 겹치는 것은 하위가 또 하위를 떼어 낼 때뿐이다.
+     * 정작 동시에 도는 것은 읽기 묶음(loop.js 의 Promise.all)인데, 그 개수는
+     * 화면에 「3개를 함께 돌립니다」로 이미 찍히고 있었는데도 방만 안 봤다.
+     *
+     * 자세는 지어내는 것이 아니다. 묶어서 돌리는 것은 읽기 전용 도구뿐이라
+     * (Read·Glob·Grep·Skill·WebFetch) 저 자리는 전부 읽는 중인 게 맞다.
+     * 첫 자리는 이미 위에서 넣었으므로 하나를 뺀다.
+     */
+    for (let i = 1; i < Math.max(0, 함께도는); i++) 일꾼들.push({ 갈래: '읽기' });
     for (let i = 0; i < Math.max(0, 도는하위); i++) 일꾼들.push({ 갈래: '대기' });
   }
 
   return {
     일꾼들,
+    걸린초,
     읽은파일: s.filesRead?.size ?? 0,
     고친파일: s.changes?.size ?? 0,
     끝난일: 할일들.filter((t) => t.state === 'done').length,