@xmem-ai/memcode 4.0.2

package/dist/ink/termio/ansi.js

@@ -0,0 +1,69 @@
+const C0 = {
+  NUL: 0,
+  SOH: 1,
+  STX: 2,
+  ETX: 3,
+  EOT: 4,
+  ENQ: 5,
+  ACK: 6,
+  BEL: 7,
+  BS: 8,
+  HT: 9,
+  LF: 10,
+  VT: 11,
+  FF: 12,
+  CR: 13,
+  SO: 14,
+  SI: 15,
+  DLE: 16,
+  DC1: 17,
+  DC2: 18,
+  DC3: 19,
+  DC4: 20,
+  NAK: 21,
+  SYN: 22,
+  ETB: 23,
+  CAN: 24,
+  EM: 25,
+  SUB: 26,
+  ESC: 27,
+  FS: 28,
+  GS: 29,
+  RS: 30,
+  US: 31,
+  DEL: 127
+};
+const ESC = "\x1B";
+const BEL = "\x07";
+const SEP = ";";
+const ESC_TYPE = {
+  CSI: 91,
+  // [ - Control Sequence Introducer
+  OSC: 93,
+  // ] - Operating System Command
+  DCS: 80,
+  // P - Device Control String
+  APC: 95,
+  // _ - Application Program Command
+  PM: 94,
+  // ^ - Privacy Message
+  SOS: 88,
+  // X - Start of String
+  ST: 92
+  // \ - String Terminator
+};
+function isC0(byte) {
+  return byte < 32 || byte === 127;
+}
+function isEscFinal(byte) {
+  return byte >= 48 && byte <= 126;
+}
+export {
+  BEL,
+  C0,
+  ESC,
+  ESC_TYPE,
+  SEP,
+  isC0,
+  isEscFinal
+};

package/dist/ink/termio/csi.js

@@ -0,0 +1,243 @@
+import { ESC, ESC_TYPE, SEP } from "./ansi.js";
+const CSI_PREFIX = ESC + String.fromCharCode(ESC_TYPE.CSI);
+const CSI_RANGE = {
+  PARAM_START: 48,
+  PARAM_END: 63,
+  INTERMEDIATE_START: 32,
+  INTERMEDIATE_END: 47,
+  FINAL_START: 64,
+  FINAL_END: 126
+};
+function isCSIParam(byte) {
+  return byte >= CSI_RANGE.PARAM_START && byte <= CSI_RANGE.PARAM_END;
+}
+function isCSIIntermediate(byte) {
+  return byte >= CSI_RANGE.INTERMEDIATE_START && byte <= CSI_RANGE.INTERMEDIATE_END;
+}
+function isCSIFinal(byte) {
+  return byte >= CSI_RANGE.FINAL_START && byte <= CSI_RANGE.FINAL_END;
+}
+function csi(...args) {
+  if (args.length === 0) return CSI_PREFIX;
+  if (args.length === 1) return `${CSI_PREFIX}${args[0]}`;
+  const params = args.slice(0, -1);
+  const final = args[args.length - 1];
+  return `${CSI_PREFIX}${params.join(SEP)}${final}`;
+}
+const CSI = {
+  // Cursor movement
+  CUU: 65,
+  // A - Cursor Up
+  CUD: 66,
+  // B - Cursor Down
+  CUF: 67,
+  // C - Cursor Forward
+  CUB: 68,
+  // D - Cursor Back
+  CNL: 69,
+  // E - Cursor Next Line
+  CPL: 70,
+  // F - Cursor Previous Line
+  CHA: 71,
+  // G - Cursor Horizontal Absolute
+  CUP: 72,
+  // H - Cursor Position
+  CHT: 73,
+  // I - Cursor Horizontal Tab
+  VPA: 100,
+  // d - Vertical Position Absolute
+  HVP: 102,
+  // f - Horizontal Vertical Position
+  // Erase
+  ED: 74,
+  // J - Erase in Display
+  EL: 75,
+  // K - Erase in Line
+  ECH: 88,
+  // X - Erase Character
+  // Insert/Delete
+  IL: 76,
+  // L - Insert Lines
+  DL: 77,
+  // M - Delete Lines
+  ICH: 64,
+  // @ - Insert Characters
+  DCH: 80,
+  // P - Delete Characters
+  // Scroll
+  SU: 83,
+  // S - Scroll Up
+  SD: 84,
+  // T - Scroll Down
+  // Modes
+  SM: 104,
+  // h - Set Mode
+  RM: 108,
+  // l - Reset Mode
+  // SGR
+  SGR: 109,
+  // m - Select Graphic Rendition
+  // Other
+  DSR: 110,
+  // n - Device Status Report
+  DECSCUSR: 113,
+  // q - Set Cursor Style (with space intermediate)
+  DECSTBM: 114,
+  // r - Set Top and Bottom Margins
+  SCOSC: 115,
+  // s - Save Cursor Position
+  SCORC: 117,
+  // u - Restore Cursor Position
+  CBT: 90
+  // Z - Cursor Backward Tabulation
+};
+const ERASE_DISPLAY = ["toEnd", "toStart", "all", "scrollback"];
+const ERASE_LINE_REGION = ["toEnd", "toStart", "all"];
+const CURSOR_STYLES = [
+  { style: "block", blinking: true },
+  // 0 - default
+  { style: "block", blinking: true },
+  // 1
+  { style: "block", blinking: false },
+  // 2
+  { style: "underline", blinking: true },
+  // 3
+  { style: "underline", blinking: false },
+  // 4
+  { style: "bar", blinking: true },
+  // 5
+  { style: "bar", blinking: false }
+  // 6
+];
+function cursorUp(n = 1) {
+  return n === 0 ? "" : csi(n, "A");
+}
+function cursorDown(n = 1) {
+  return n === 0 ? "" : csi(n, "B");
+}
+function cursorForward(n = 1) {
+  return n === 0 ? "" : csi(n, "C");
+}
+function cursorBack(n = 1) {
+  return n === 0 ? "" : csi(n, "D");
+}
+function cursorTo(col) {
+  return csi(col, "G");
+}
+const CURSOR_LEFT = csi("G");
+function cursorPosition(row, col) {
+  return csi(row, col, "H");
+}
+const CURSOR_HOME = csi("H");
+function cursorMove(x, y) {
+  let result = "";
+  if (x < 0) {
+    result += cursorBack(-x);
+  } else if (x > 0) {
+    result += cursorForward(x);
+  }
+  if (y < 0) {
+    result += cursorUp(-y);
+  } else if (y > 0) {
+    result += cursorDown(y);
+  }
+  return result;
+}
+const CURSOR_SAVE = csi("s");
+const CURSOR_RESTORE = csi("u");
+function eraseToEndOfLine() {
+  return csi("K");
+}
+function eraseToStartOfLine() {
+  return csi(1, "K");
+}
+function eraseLine() {
+  return csi(2, "K");
+}
+const ERASE_LINE = csi(2, "K");
+function eraseToEndOfScreen() {
+  return csi("J");
+}
+function eraseToStartOfScreen() {
+  return csi(1, "J");
+}
+function eraseScreen() {
+  return csi(2, "J");
+}
+const ERASE_SCREEN = csi(2, "J");
+const ERASE_SCROLLBACK = csi(3, "J");
+function eraseLines(n) {
+  if (n <= 0) return "";
+  let result = "";
+  for (let i = 0; i < n; i++) {
+    result += ERASE_LINE;
+    if (i < n - 1) {
+      result += cursorUp(1);
+    }
+  }
+  result += CURSOR_LEFT;
+  return result;
+}
+function scrollUp(n = 1) {
+  return n === 0 ? "" : csi(n, "S");
+}
+function scrollDown(n = 1) {
+  return n === 0 ? "" : csi(n, "T");
+}
+function setScrollRegion(top, bottom) {
+  return csi(top, bottom, "r");
+}
+const RESET_SCROLL_REGION = csi("r");
+const PASTE_START = csi("200~");
+const PASTE_END = csi("201~");
+const FOCUS_IN = csi("I");
+const FOCUS_OUT = csi("O");
+const ENABLE_KITTY_KEYBOARD = csi(">1u");
+const DISABLE_KITTY_KEYBOARD = csi("<u");
+const ENABLE_MODIFY_OTHER_KEYS = csi(">4;2m");
+const DISABLE_MODIFY_OTHER_KEYS = csi(">4m");
+export {
+  CSI,
+  CSI_PREFIX,
+  CSI_RANGE,
+  CURSOR_HOME,
+  CURSOR_LEFT,
+  CURSOR_RESTORE,
+  CURSOR_SAVE,
+  CURSOR_STYLES,
+  DISABLE_KITTY_KEYBOARD,
+  DISABLE_MODIFY_OTHER_KEYS,
+  ENABLE_KITTY_KEYBOARD,
+  ENABLE_MODIFY_OTHER_KEYS,
+  ERASE_DISPLAY,
+  ERASE_LINE,
+  ERASE_LINE_REGION,
+  ERASE_SCREEN,
+  ERASE_SCROLLBACK,
+  FOCUS_IN,
+  FOCUS_OUT,
+  PASTE_END,
+  PASTE_START,
+  RESET_SCROLL_REGION,
+  csi,
+  cursorBack,
+  cursorDown,
+  cursorForward,
+  cursorMove,
+  cursorPosition,
+  cursorTo,
+  cursorUp,
+  eraseLine,
+  eraseLines,
+  eraseScreen,
+  eraseToEndOfLine,
+  eraseToEndOfScreen,
+  eraseToStartOfLine,
+  eraseToStartOfScreen,
+  isCSIFinal,
+  isCSIIntermediate,
+  isCSIParam,
+  scrollDown,
+  scrollUp,
+  setScrollRegion
+};

package/dist/ink/termio/dec.js

@@ -0,0 +1,48 @@
+import { csi } from "./csi.js";
+const DEC = {
+  CURSOR_VISIBLE: 25,
+  ALT_SCREEN: 47,
+  ALT_SCREEN_CLEAR: 1049,
+  MOUSE_NORMAL: 1e3,
+  MOUSE_BUTTON: 1002,
+  MOUSE_ANY: 1003,
+  MOUSE_SGR: 1006,
+  FOCUS_EVENTS: 1004,
+  BRACKETED_PASTE: 2004,
+  SYNCHRONIZED_UPDATE: 2026
+};
+function decset(mode) {
+  return csi(`?${mode}h`);
+}
+function decreset(mode) {
+  return csi(`?${mode}l`);
+}
+const BSU = decset(DEC.SYNCHRONIZED_UPDATE);
+const ESU = decreset(DEC.SYNCHRONIZED_UPDATE);
+const EBP = decset(DEC.BRACKETED_PASTE);
+const DBP = decreset(DEC.BRACKETED_PASTE);
+const EFE = decset(DEC.FOCUS_EVENTS);
+const DFE = decreset(DEC.FOCUS_EVENTS);
+const SHOW_CURSOR = decset(DEC.CURSOR_VISIBLE);
+const HIDE_CURSOR = decreset(DEC.CURSOR_VISIBLE);
+const ENTER_ALT_SCREEN = decset(DEC.ALT_SCREEN_CLEAR);
+const EXIT_ALT_SCREEN = decreset(DEC.ALT_SCREEN_CLEAR);
+const ENABLE_MOUSE_TRACKING = decset(DEC.MOUSE_NORMAL) + decset(DEC.MOUSE_BUTTON) + decset(DEC.MOUSE_ANY) + decset(DEC.MOUSE_SGR);
+const DISABLE_MOUSE_TRACKING = decreset(DEC.MOUSE_SGR) + decreset(DEC.MOUSE_ANY) + decreset(DEC.MOUSE_BUTTON) + decreset(DEC.MOUSE_NORMAL);
+export {
+  BSU,
+  DBP,
+  DEC,
+  DFE,
+  DISABLE_MOUSE_TRACKING,
+  EBP,
+  EFE,
+  ENABLE_MOUSE_TRACKING,
+  ENTER_ALT_SCREEN,
+  ESU,
+  EXIT_ALT_SCREEN,
+  HIDE_CURSOR,
+  SHOW_CURSOR,
+  decreset,
+  decset
+};

package/dist/ink/termio/esc.js

@@ -0,0 +1,38 @@
+function parseEsc(chars) {
+  if (chars.length === 0) return null;
+  const first = chars[0];
+  if (first === "c") {
+    return { type: "reset" };
+  }
+  if (first === "7") {
+    return { type: "cursor", action: { type: "save" } };
+  }
+  if (first === "8") {
+    return { type: "cursor", action: { type: "restore" } };
+  }
+  if (first === "D") {
+    return {
+      type: "cursor",
+      action: { type: "move", direction: "down", count: 1 }
+    };
+  }
+  if (first === "M") {
+    return {
+      type: "cursor",
+      action: { type: "move", direction: "up", count: 1 }
+    };
+  }
+  if (first === "E") {
+    return { type: "cursor", action: { type: "nextLine", count: 1 } };
+  }
+  if (first === "H") {
+    return null;
+  }
+  if ("()".includes(first) && chars.length >= 2) {
+    return null;
+  }
+  return { type: "unknown", sequence: `\x1B${chars}` };
+}
+export {
+  parseEsc
+};

package/dist/ink/termio/osc.js

@@ -0,0 +1,304 @@
+import { Buffer } from "buffer";
+import { env } from "../../utils/env.js";
+import { execFileNoThrow } from "../../utils/execFileNoThrow.js";
+import { BEL, ESC, ESC_TYPE, SEP } from "./ansi.js";
+const OSC_PREFIX = ESC + String.fromCharCode(ESC_TYPE.OSC);
+const ST = ESC + "\\";
+function osc(...parts) {
+  const terminator = env.terminal === "kitty" ? ST : BEL;
+  return `${OSC_PREFIX}${parts.join(SEP)}${terminator}`;
+}
+function wrapForMultiplexer(sequence) {
+  if (process.env["TMUX"]) {
+    const escaped = sequence.replaceAll("\x1B", "\x1B\x1B");
+    return `\x1BPtmux;${escaped}\x1B\\`;
+  }
+  if (process.env["STY"]) {
+    return `\x1BP${sequence}\x1B\\`;
+  }
+  return sequence;
+}
+function getClipboardPath() {
+  const nativeAvailable = process.platform === "darwin" && !process.env["SSH_CONNECTION"];
+  if (nativeAvailable) return "native";
+  if (process.env["TMUX"]) return "tmux-buffer";
+  return "osc52";
+}
+function tmuxPassthrough(payload) {
+  return `${ESC}Ptmux;${payload.replaceAll(ESC, ESC + ESC)}${ST}`;
+}
+async function tmuxLoadBuffer(text) {
+  if (!process.env["TMUX"]) return false;
+  const args = process.env["LC_TERMINAL"] === "iTerm2" ? ["load-buffer", "-"] : ["load-buffer", "-w", "-"];
+  const { code } = await execFileNoThrow("tmux", args, {
+    input: text,
+    useCwd: false,
+    timeout: 2e3
+  });
+  return code === 0;
+}
+async function setClipboard(text) {
+  const b64 = Buffer.from(text, "utf8").toString("base64");
+  const raw = osc(OSC.CLIPBOARD, "c", b64);
+  if (!process.env["SSH_CONNECTION"]) copyNative(text);
+  const tmuxBufferLoaded = await tmuxLoadBuffer(text);
+  if (tmuxBufferLoaded) return tmuxPassthrough(`${ESC}]52;c;${b64}${BEL}`);
+  return raw;
+}
+let linuxCopy;
+function copyNative(text) {
+  const opts = { input: text, useCwd: false, timeout: 2e3 };
+  switch (process.platform) {
+    case "darwin":
+      void execFileNoThrow("pbcopy", [], opts);
+      return;
+    case "linux": {
+      if (linuxCopy === null) return;
+      if (linuxCopy === "wl-copy") {
+        void execFileNoThrow("wl-copy", [], opts);
+        return;
+      }
+      if (linuxCopy === "xclip") {
+        void execFileNoThrow("xclip", ["-selection", "clipboard"], opts);
+        return;
+      }
+      if (linuxCopy === "xsel") {
+        void execFileNoThrow("xsel", ["--clipboard", "--input"], opts);
+        return;
+      }
+      void execFileNoThrow("wl-copy", [], opts).then((r) => {
+        if (r.code === 0) {
+          linuxCopy = "wl-copy";
+          return;
+        }
+        void execFileNoThrow("xclip", ["-selection", "clipboard"], opts).then(
+          (r2) => {
+            if (r2.code === 0) {
+              linuxCopy = "xclip";
+              return;
+            }
+            void execFileNoThrow("xsel", ["--clipboard", "--input"], opts).then(
+              (r3) => {
+                linuxCopy = r3.code === 0 ? "xsel" : null;
+              }
+            );
+          }
+        );
+      });
+      return;
+    }
+    case "win32":
+      void execFileNoThrow("clip", [], opts);
+      return;
+  }
+}
+function _resetLinuxCopyCache() {
+  linuxCopy = void 0;
+}
+const OSC = {
+  SET_TITLE_AND_ICON: 0,
+  SET_ICON: 1,
+  SET_TITLE: 2,
+  SET_COLOR: 4,
+  SET_CWD: 7,
+  HYPERLINK: 8,
+  ITERM2: 9,
+  // iTerm2 proprietary sequences
+  SET_FG_COLOR: 10,
+  SET_BG_COLOR: 11,
+  SET_CURSOR_COLOR: 12,
+  CLIPBOARD: 52,
+  KITTY: 99,
+  // Kitty notification protocol
+  RESET_COLOR: 104,
+  RESET_FG_COLOR: 110,
+  RESET_BG_COLOR: 111,
+  RESET_CURSOR_COLOR: 112,
+  SEMANTIC_PROMPT: 133,
+  GHOSTTY: 777,
+  // Ghostty notification protocol
+  TAB_STATUS: 21337
+  // Tab status extension
+};
+function parseOSC(content) {
+  const semicolonIdx = content.indexOf(";");
+  const command = semicolonIdx >= 0 ? content.slice(0, semicolonIdx) : content;
+  const data = semicolonIdx >= 0 ? content.slice(semicolonIdx + 1) : "";
+  const commandNum = parseInt(command, 10);
+  if (commandNum === OSC.SET_TITLE_AND_ICON) {
+    return { type: "title", action: { type: "both", title: data } };
+  }
+  if (commandNum === OSC.SET_ICON) {
+    return { type: "title", action: { type: "iconName", name: data } };
+  }
+  if (commandNum === OSC.SET_TITLE) {
+    return { type: "title", action: { type: "windowTitle", title: data } };
+  }
+  if (commandNum === OSC.HYPERLINK) {
+    const parts = data.split(";");
+    const paramsStr = parts[0] ?? "";
+    const url = parts.slice(1).join(";");
+    if (url === "") {
+      return { type: "link", action: { type: "end" } };
+    }
+    const params = {};
+    if (paramsStr) {
+      for (const pair of paramsStr.split(":")) {
+        const eqIdx = pair.indexOf("=");
+        if (eqIdx >= 0) {
+          params[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+        }
+      }
+    }
+    return {
+      type: "link",
+      action: {
+        type: "start",
+        url,
+        params: Object.keys(params).length > 0 ? params : void 0
+      }
+    };
+  }
+  if (commandNum === OSC.TAB_STATUS) {
+    return { type: "tabStatus", action: parseTabStatus(data) };
+  }
+  return { type: "unknown", sequence: `\x1B]${content}` };
+}
+function parseOscColor(spec) {
+  const hex = spec.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+  if (hex) {
+    return {
+      type: "rgb",
+      r: parseInt(hex[1], 16),
+      g: parseInt(hex[2], 16),
+      b: parseInt(hex[3], 16)
+    };
+  }
+  const rgb = spec.match(
+    /^rgb:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})$/i
+  );
+  if (rgb) {
+    const scale = (s) => Math.round(parseInt(s, 16) / (16 ** s.length - 1) * 255);
+    return {
+      type: "rgb",
+      r: scale(rgb[1]),
+      g: scale(rgb[2]),
+      b: scale(rgb[3])
+    };
+  }
+  return null;
+}
+function parseTabStatus(data) {
+  const action = {};
+  for (const [key, value] of splitTabStatusPairs(data)) {
+    switch (key) {
+      case "indicator":
+        action.indicator = value === "" ? null : parseOscColor(value);
+        break;
+      case "status":
+        action.status = value === "" ? null : value;
+        break;
+      case "status-color":
+        action.statusColor = value === "" ? null : parseOscColor(value);
+        break;
+    }
+  }
+  return action;
+}
+function* splitTabStatusPairs(data) {
+  let key = "";
+  let val = "";
+  let inVal = false;
+  let esc = false;
+  for (const c of data) {
+    if (esc) {
+      if (inVal) val += c;
+      else key += c;
+      esc = false;
+    } else if (c === "\\") {
+      esc = true;
+    } else if (c === ";") {
+      yield [key, val];
+      key = "";
+      val = "";
+      inVal = false;
+    } else if (c === "=" && !inVal) {
+      inVal = true;
+    } else if (inVal) {
+      val += c;
+    } else {
+      key += c;
+    }
+  }
+  if (key || inVal) yield [key, val];
+}
+function link(url, params) {
+  if (!url) return LINK_END;
+  const p = { id: osc8Id(url), ...params };
+  const paramStr = Object.entries(p).map(([k, v]) => `${k}=${v}`).join(":");
+  return osc(OSC.HYPERLINK, paramStr, url);
+}
+function osc8Id(url) {
+  let h = 0;
+  for (let i = 0; i < url.length; i++)
+    h = (h << 5) - h + url.charCodeAt(i) | 0;
+  return (h >>> 0).toString(36);
+}
+const LINK_END = osc(OSC.HYPERLINK, "", "");
+const ITERM2 = {
+  NOTIFY: 0,
+  BADGE: 2,
+  PROGRESS: 4
+};
+const PROGRESS = {
+  CLEAR: 0,
+  SET: 1,
+  ERROR: 2,
+  INDETERMINATE: 3
+};
+const CLEAR_ITERM2_PROGRESS = `${OSC_PREFIX}${OSC.ITERM2};${ITERM2.PROGRESS};${PROGRESS.CLEAR};${BEL}`;
+const CLEAR_TERMINAL_TITLE = `${OSC_PREFIX}${OSC.SET_TITLE_AND_ICON};${BEL}`;
+const CLEAR_TAB_STATUS = osc(
+  OSC.TAB_STATUS,
+  "indicator=;status=;status-color="
+);
+function supportsTabStatus() {
+  return process.env.USER_TYPE === "ant";
+}
+function tabStatus(fields) {
+  const parts = [];
+  const rgb = (c) => c.type === "rgb" ? `#${[c.r, c.g, c.b].map((n) => n.toString(16).padStart(2, "0")).join("")}` : "";
+  if ("indicator" in fields)
+    parts.push(`indicator=${fields.indicator ? rgb(fields.indicator) : ""}`);
+  if ("status" in fields)
+    parts.push(
+      `status=${fields.status?.replaceAll("\\", "\\\\").replaceAll(";", "\\;") ?? ""}`
+    );
+  if ("statusColor" in fields)
+    parts.push(
+      `status-color=${fields.statusColor ? rgb(fields.statusColor) : ""}`
+    );
+  return osc(OSC.TAB_STATUS, parts.join(";"));
+}
+export {
+  CLEAR_ITERM2_PROGRESS,
+  CLEAR_TAB_STATUS,
+  CLEAR_TERMINAL_TITLE,
+  ITERM2,
+  LINK_END,
+  OSC,
+  OSC_PREFIX,
+  PROGRESS,
+  ST,
+  _resetLinuxCopyCache,
+  getClipboardPath,
+  link,
+  osc,
+  parseOSC,
+  parseOscColor,
+  setClipboard,
+  supportsTabStatus,
+  tabStatus,
+  tmuxLoadBuffer,
+  wrapForMultiplexer
+};