xgen-dex-cli 1.6.0 → 1.7.1

package/dist/chunks/{tui-DTMX2JZ7.js → tui-H3VM2MGV.js}

@@ -6,7 +6,7 @@ import {
 
 // src/tui/index.tsx
 import { render } from "ink";
-import { stdout } from "node:process";
+import { stdin, stdout } from "node:process";
 
 // src/tui/app.tsx
 import { useCallback, useEffect as useEffect8, useState as useState11 } from "react";
@@ -189,7 +189,7 @@ function wrapToWidth(text, width) {
     }
     let line = "";
     let lineWidth = 0;
-    const flush2 = () => {
+    const flush = () => {
       lines.push(line);
       line = "";
       lineWidth = 0;
@@ -197,7 +197,7 @@ function wrapToWidth(text, width) {
     for (const word of paragraph.match(/\s+|\S+/g) ?? []) {
       const wordWidth = stringWidth(word);
       if (lineWidth > 0 && lineWidth + wordWidth > width) {
-        flush2();
+        flush();
         if (/^\s+$/.test(word)) continue;
       }
       if (wordWidth <= width) {
@@ -207,12 +207,12 @@ function wrapToWidth(text, width) {
       }
       for (const char of word) {
         const charWidth = stringWidth(char);
-        if (lineWidth + charWidth > width) flush2();
+        if (lineWidth + charWidth > width) flush();
         line += char;
         lineWidth += charWidth;
       }
     }
-    flush2();
+    flush();
   }
   return lines;
 }
@@ -288,7 +288,7 @@ import { Box as Box2, Text as Text2 } from "ink";
 
 // src/tui/ime-text-input.tsx
 import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
-import { Box, Text, useCursor, useInput } from "ink";
+import { Box, Text, useCursor, useInput, useStdin } from "ink";
 import stringWidth2 from "string-width";
 
 // src/tui/terminal-input.ts
@@ -374,10 +374,24 @@ var SPLIT = Object.fromEntries(
   ])
 );
 var EMPTY = {};
-function jamoOf(key) {
-  if (KEYS[key]) return KEYS[key];
+var SHIFTED_KEYS = /* @__PURE__ */ new Set(["r", "e", "q", "t", "w", "o", "p"]);
+function jamoOf(key, capsLock = false) {
+  const effective = capsLock ? swapCase(key) : key;
+  if (KEYS[effective]) return KEYS[effective];
+  const lower = effective.toLowerCase();
+  return lower === effective ? void 0 : KEYS[lower];
+}
+function swapCase(key) {
+  const lower = key.toLowerCase();
+  return key === lower ? key.toUpperCase() : lower;
+}
+function detectCapsLock(current, key) {
   const lower = key.toLowerCase();
-  return lower === key ? void 0 : KEYS[lower];
+  const upper = key.toUpperCase();
+  if (lower === upper) return current;
+  if (!KEYS[lower]) return current;
+  if (SHIFTED_KEYS.has(lower)) return current;
+  return key === upper;
 }
 function isVowel(jamo) {
   return JUNG.includes(jamo) || jamo === "\u3157" || jamo === "\u315C" || jamo === "\u3161";
@@ -450,8 +464,105 @@ function back(state) {
   if (cho) return { state: EMPTY, handled: true };
   return { state: EMPTY, handled: false };
 }
-function flush(state) {
-  return { commit: display(state), state: EMPTY };
+var IDLE = { state: EMPTY, keys: [], capsLock: false };
+function typeKey(session, key) {
+  const caps = detectCapsLock(session.capsLock, key);
+  let { state, keys } = session;
+  let commit = "";
+  if (caps !== session.capsLock && keys.length > 0) {
+    let rebuilt = EMPTY;
+    for (const previous of keys) {
+      const jamo2 = jamoOf(previous, caps);
+      if (!jamo2) continue;
+      const step = feed(rebuilt, jamo2);
+      commit += step.commit;
+      rebuilt = step.state;
+    }
+    state = rebuilt;
+  }
+  const jamo = jamoOf(key, caps);
+  if (!jamo) {
+    commit += display(state) + key;
+    return { session: { state: EMPTY, keys: [], capsLock: caps }, commit, composing: "" };
+  }
+  const result = feed(state, jamo);
+  commit += result.commit;
+  keys = result.commit ? [key] : [...keys, key];
+  return {
+    session: { state: result.state, keys, capsLock: caps },
+    commit,
+    composing: display(result.state)
+  };
+}
+function backspace(session) {
+  const stepped = back(session.state);
+  if (!stepped.handled) return { session, composing: "", handled: false };
+  return {
+    session: { ...session, state: stepped.state, keys: session.keys.slice(0, -1) },
+    composing: display(stepped.state),
+    handled: true
+  };
+}
+
+// src/tui/kitty.ts
+var ESC = "\x1B";
+var QUERY = `${ESC}[?u`;
+var KEY_CODES = {
+  57358: "capslock",
+  57449: "rightalt"
+};
+var CAPS_LOCK_BIT = 64;
+function parseKeyEvents(chunk) {
+  const events = [];
+  const pattern = /\u001B\[(\d+)(?::\d+)*(?:;(\d+)(?::(\d+))?)?(?:;[\d:]*)?u/g;
+  for (const match of chunk.matchAll(pattern)) {
+    const code = Number(match[1]);
+    const modifiers = match[2] ? Number(match[2]) - 1 : 0;
+    events.push({
+      name: KEY_CODES[code],
+      // eslint-disable-next-line no-bitwise
+      capsLock: (modifiers & CAPS_LOCK_BIT) !== 0,
+      eventType: match[3] ? Number(match[3]) : 1
+    });
+  }
+  return events;
+}
+function knownKittyTerminal(env = process.env) {
+  if (env.KITTY_WINDOW_ID) return true;
+  if (env.GHOSTTY_RESOURCES_DIR) return true;
+  const term = (env.TERM ?? "").toLowerCase();
+  if (term === "xterm-kitty" || term === "xterm-ghostty" || term.includes("foot")) return true;
+  const program = (env.TERM_PROGRAM ?? "").toLowerCase();
+  return program === "wezterm" || program === "ghostty" || program === "kitty";
+}
+async function supportsKittyKeyboard(streams, timeoutMs = 200, env = process.env) {
+  if (env.DEX_NO_KITTY === "1") return false;
+  if (!streams.stdout.isTTY || !streams.isTTY) return false;
+  if (knownKittyTerminal(env)) return true;
+  const wasRaw = streams.stdin.isRaw === true;
+  const wasPaused = !wasRaw;
+  streams.stdin.setRawMode?.(true);
+  streams.stdin.resume?.();
+  return new Promise((resolve) => {
+    let settled = false;
+    let seen = "";
+    const finish = (supported) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      streams.stdin.removeListener("data", onData);
+      if (!wasRaw) streams.stdin.setRawMode?.(false);
+      if (wasPaused) streams.stdin.pause?.();
+      resolve(supported);
+    };
+    const onData = (data) => {
+      seen += typeof data === "string" ? data : data.toString("utf8");
+      if (/\u001B\[\?\d*u/.test(seen)) finish(true);
+    };
+    const timer = setTimeout(() => finish(false), timeoutMs);
+    streams.stdin.on("data", onData);
+    streams.stdout.write(QUERY);
+  });
 }
 
 // src/tui/ime-text-input.tsx
@@ -487,6 +598,12 @@ function visibleInput(segments, cursor, maximumWidth) {
     cursorWidth: widthBeforeCursor
   };
 }
+function isHangulToggle(input, key) {
+  if (key.ctrl && (input === "`" || input === " " || input === "l")) return true;
+  if (key.meta && input === " ") return true;
+  if (key.shift && input === " ") return true;
+  return false;
+}
 function TerminalCursor({ x, y }) {
   const { setCursorPosition } = useCursor();
   setCursorPosition({ x, y });
@@ -499,7 +616,7 @@ function ImeTextInput(props) {
   const valueRef = useRef2(props.value);
   const cursorRef = useRef2(initialSegments.length);
   const pastingRef = useRef2(false);
-  const composingRef = useRef2(EMPTY);
+  const typingRef = useRef2(IDLE);
   const moveCursor = (next, length) => {
     const resolved = clamp(next, 0, length);
     cursorRef.current = resolved;
@@ -511,8 +628,26 @@ function ImeTextInput(props) {
     moveCursor(nextCursor, segments.length);
     props.onChange(nextValue);
   };
+  const { stdin: stdin2, isRawModeSupported } = useStdin();
+  const onModeKeyRef = useRef2(void 0);
+  onModeKeyRef.current = () => props.onHangulModeChange?.(!props.hangulMode);
   useEffect2(() => {
-    if (!props.focus || !props.hangulMode) composingRef.current = EMPTY;
+    if (!props.focus || !isRawModeSupported) return void 0;
+    const onData = (data) => {
+      const chunk = typeof data === "string" ? data : data.toString("utf8");
+      for (const event of parseKeyEvents(chunk)) {
+        typingRef.current = { ...typingRef.current, capsLock: event.capsLock };
+        if (event.eventType !== 1) continue;
+        if (event.name === "rightalt" || event.name === "capslock") onModeKeyRef.current?.();
+      }
+    };
+    stdin2?.on("data", onData);
+    return () => void stdin2?.off("data", onData);
+  }, [props.focus, isRawModeSupported, stdin2]);
+  useEffect2(() => {
+    if (!props.focus || !props.hangulMode) {
+      typingRef.current = { ...IDLE, capsLock: typingRef.current.capsLock };
+    }
   }, [props.focus, props.hangulMode]);
   useEffect2(() => {
     if (props.value === valueRef.current) return;
@@ -533,10 +668,9 @@ function ImeTextInput(props) {
       const current = graphemes(valueRef.current);
       const currentCursor = clamp(cursorRef.current, 0, current.length);
       const event = classifyInput(input, pastingRef.current);
-      const composing = composingRef.current;
-      const shown = display(composing);
+      const shown = display(typingRef.current.state);
       const settle = () => {
-        composingRef.current = EMPTY;
+        typingRef.current = { ...IDLE, capsLock: typingRef.current.capsLock };
       };
       if (event.kind === "paste-start") {
         settle();
@@ -555,7 +689,7 @@ function ImeTextInput(props) {
         }
         return;
       }
-      if (key.ctrl && (input === "`" || input === "l")) {
+      if (isHangulToggle(input, key)) {
         settle();
         props.onHangulModeChange?.(!props.hangulMode);
         return;
@@ -586,10 +720,10 @@ function ImeTextInput(props) {
         return;
       }
       if (key.backspace || key.delete) {
-        const stepped = back(composing);
+        const stepped = backspace(typingRef.current);
         if (stepped.handled) {
-          composingRef.current = stepped.state;
-          applyComposition(current, currentCursor, shown, "", display(stepped.state));
+          typingRef.current = stepped.session;
+          applyComposition(current, currentCursor, shown, "", stepped.composing);
           return;
         }
         if (currentCursor === 0) return;
@@ -603,30 +737,19 @@ function ImeTextInput(props) {
       }
       if (event.kind !== "text") return;
       if (props.hangulMode) {
-        let state = composing;
+        let session = typingRef.current;
         let previous = shown;
         let segments = current;
         let cursor2 = currentCursor;
         for (const character of event.text) {
-          const jamo = jamoOf(character);
-          if (!jamo) {
-            const flushed = flush(state);
-            state = flushed.state;
-            applyComposition(segments, cursor2, previous, flushed.commit + character, "");
-            segments = graphemes(valueRef.current);
-            cursor2 = cursorRef.current;
-            previous = "";
-            continue;
-          }
-          const result = feed(state, jamo);
-          state = result.state;
-          const next = display(state);
-          applyComposition(segments, cursor2, previous, result.commit, next);
+          const result = typeKey(session, character);
+          session = result.session;
+          applyComposition(segments, cursor2, previous, result.commit, result.composing);
           segments = graphemes(valueRef.current);
           cursor2 = cursorRef.current;
-          previous = next;
+          previous = result.composing;
         }
-        composingRef.current = state;
+        typingRef.current = session;
         return;
       }
       settle();
@@ -662,8 +785,16 @@ function Header(props) {
     ] }) : /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\uC124\uC815 \uD544\uC694" })
   ] });
 }
-function Footer({ text }) {
-  return /* @__PURE__ */ jsx2(Box2, { paddingX: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: text }) });
+function Footer({ text, mode }) {
+  return /* @__PURE__ */ jsxs2(Box2, { paddingX: 1, children: [
+    mode ? /* @__PURE__ */ jsxs2(Text2, { bold: true, color: mode === "\uD55C" ? "yellow" : "gray", children: [
+      "[",
+      mode,
+      "]",
+      " "
+    ] }) : null,
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, wrap: "truncate-end", children: text })
+  ] });
 }
 function Loading({ label = "\uBD88\uB7EC\uC624\uB294 \uC911..." }) {
   return /* @__PURE__ */ jsx2(Box2, { padding: 1, children: /* @__PURE__ */ jsxs2(Text2, { color: "cyan", children: [
@@ -1206,7 +1337,13 @@ function Dashboard(props) {
       }
     ),
     body,
-    /* @__PURE__ */ jsx6(Footer, { text: "Ctrl+Space \uD55C/\uC601 \xB7 Tab \uD328\uB110 \xB7 PgUp/PgDn \uC2A4\uD06C\uB864 \xB7 Ctrl+K \uBA85\uB839 \xB7 Ctrl+H \uAE30\uB85D \xB7 Ctrl+P \uD504\uB85C\uD544 \xB7 Esc \uCDE8\uC18C \xB7 Ctrl+Q \uC885\uB8CC" })
+    /* @__PURE__ */ jsx6(
+      Footer,
+      {
+        mode: hangulMode ? "\uD55C" : "EN",
+        text: "Ctrl+Space \uD55C/\uC601 \xB7 Tab \uD328\uB110 \xB7 PgUp/PgDn \uC2A4\uD06C\uB864 \xB7 Ctrl+K \uBA85\uB839 \xB7 Ctrl+H \uAE30\uB85D \xB7 Ctrl+P \uD504\uB85C\uD544 \xB7 Esc \uCDE8\uC18C \xB7 Ctrl+Q \uC885\uB8CC"
+      }
+    )
   ] });
 }
 
@@ -1633,25 +1770,26 @@ function RetryInput({ onRetry }) {
 }
 
 // src/tui/screen.ts
-var ESC = "\x1B";
-var ENTER_ALT_SCREEN = `${ESC}[?1049h`;
-var LEAVE_ALT_SCREEN = `${ESC}[?1049l`;
-var SHOW_CURSOR = `${ESC}[?25h`;
+var ESC2 = "\x1B";
+var ENTER_ALT_SCREEN = `${ESC2}[?1049h`;
+var LEAVE_ALT_SCREEN = `${ESC2}[?1049l`;
+var SHOW_CURSOR = `${ESC2}[?25h`;
 var DISABLE_REPORTS = [
-  `${ESC}[?1004l`,
+  `${ESC2}[?1004l`,
   // 포커스 들어옴/나감
-  `${ESC}[?1000l`,
+  `${ESC2}[?1000l`,
   // 마우스 클릭
-  `${ESC}[?1002l`,
+  `${ESC2}[?1002l`,
   // 마우스 드래그
-  `${ESC}[?1003l`,
+  `${ESC2}[?1003l`,
   // 마우스 이동 전부
-  `${ESC}[?1006l`
+  `${ESC2}[?1006l`
   // SGR 확장 좌표
 ].join("");
-var ENABLE_BRACKETED_PASTE = `${ESC}[?2004h`;
-var DISABLE_BRACKETED_PASTE = `${ESC}[?2004l`;
-function createScreenGuard(stream) {
+var ENABLE_BRACKETED_PASTE = `${ESC2}[?2004h`;
+var DISABLE_BRACKETED_PASTE = `${ESC2}[?2004l`;
+var POP_KITTY_KEYBOARD = `${ESC2}[<u`;
+function createScreenGuard(stream, options = {}) {
   const alt = Boolean(stream.isTTY);
   let entered = false;
   let restored = false;
@@ -1664,7 +1802,11 @@ function createScreenGuard(stream) {
     restore() {
       if (restored) return;
       restored = true;
-      if (entered) stream.write(DISABLE_BRACKETED_PASTE + LEAVE_ALT_SCREEN);
+      if (entered) {
+        stream.write(
+          (options.kittyKeyboard ? POP_KITTY_KEYBOARD : "") + DISABLE_BRACKETED_PASTE + LEAVE_ALT_SCREEN
+        );
+      }
       stream.write(SHOW_CURSOR);
     }
   };
@@ -1702,7 +1844,7 @@ async function writePreferences(preferences, env = process.env) {
 // src/tui/index.tsx
 import { jsx as jsx11 } from "react/jsx-runtime";
 async function runTui(engine) {
-  const screen = createScreenGuard(stdout);
+  let screen = createScreenGuard(stdout);
   const restore = () => screen.restore();
   const onSignal = () => {
     restore();
@@ -1712,6 +1854,8 @@ async function runTui(engine) {
   process.once("SIGINT", onSignal);
   process.once("SIGTERM", onSignal);
   const preferences = await readPreferences();
+  const kitty = await supportsKittyKeyboard({ stdin, stdout, isTTY: stdin.isTTY });
+  screen = createScreenGuard(stdout, { kittyKeyboard: kitty });
   screen.enter();
   try {
     const instance = render(
@@ -1727,7 +1871,21 @@ async function runTui(engine) {
       ),
       {
         exitOnCtrlC: true,
-        patchConsole: true
+        patchConsole: true,
+        // 모든 키를 이스케이프로 받아야 한/영 키(오른쪽 Alt)와 Caps Lock 이 사건으로
+        // 온다. 그런데 그렇게만 켜면 터미널이 **글쇠 코드만** 보내서 Shift+r 이
+        // 소문자 `r` 로 도착한다 — 된소리도 영문 대문자도 사라진다. 그래서 글자까지
+        // 함께 보내 달라고(reportAssociatedText) 요청한다.
+        ...kitty ? {
+          kittyKeyboard: {
+            mode: "enabled",
+            flags: [
+              "disambiguateEscapeCodes",
+              "reportAllKeysAsEscapeCodes",
+              "reportAssociatedText"
+            ]
+          }
+        } : {}
       }
     );
     await instance.waitUntilExit();
@@ -1741,4 +1899,4 @@ async function runTui(engine) {
 export {
   runTui
 };
-//# sourceMappingURL=tui-DTMX2JZ7.js.map
+//# sourceMappingURL=tui-H3VM2MGV.js.map