@mytegroupinc/myte-core 0.0.35 → 0.0.36

package/lib/mytecody-splash.js

@@ -0,0 +1,251 @@
+"use strict";
+
+const FRAME_MS = 48;
+const MIN_MS = 850;
+const FRAMES = 32;
+const WIDTH = 84;
+const HEIGHT = 64;
+const RX = 32.5;
+const RY = 27.5;
+const CYAN = [93, 226, 255];
+const BLUE = [45, 150, 255];
+const DIM = [45, 72, 102];
+const WHITE = [229, 244, 255];
+const SOFT = [92, 132, 172];
+
+const NODES = [
+  [-68, 0], [-55, -110], [-55, -35], [-55, 35], [-55, 110],
+  [-35, -150], [-35, -90], [-35, -30], [-35, 30], [-35, 90], [-35, 150],
+  [-15, -165], [-15, -110], [-15, -55], [-15, 0], [-15, 55], [-15, 110], [-15, 165],
+  [15, -165], [15, -110], [15, -55], [15, 0], [15, 55], [15, 110], [15, 165],
+  [35, -150], [35, -90], [35, -30], [35, 30], [35, 90], [35, 150],
+  [55, -110], [55, -35], [55, 35], [55, 110], [68, 0],
+];
+
+const LINKS = [
+  [0, 1], [0, 2], [0, 3], [0, 4], [1, 5], [2, 6], [2, 7], [3, 8], [3, 9], [4, 10],
+  [5, 11], [6, 12], [7, 13], [8, 15], [9, 16], [10, 17], [11, 18], [12, 19],
+  [13, 20], [14, 21], [15, 22], [16, 23], [17, 24], [18, 25], [19, 26], [20, 27],
+  [21, 28], [22, 29], [23, 30], [24, 30], [25, 31], [26, 31], [27, 32], [28, 33],
+  [29, 34], [30, 35], [31, 35], [32, 35], [33, 35], [34, 35],
+];
+
+const BRAILLE = [[0x01, 0x08], [0x02, 0x10], [0x04, 0x20], [0x40, 0x80]];
+
+function envTruthy(name, fallback = false) {
+  const value = process.env[name];
+  if (value == null || value === "") return fallback;
+  return !["0", "false", "no", "off"].includes(String(value).toLowerCase());
+}
+
+function ansi(rgb, text, opts = {}) {
+  if (process.env.NO_COLOR || process.env.MYTE_CODY_SPLASH_ASCII === "1") return text;
+  const flags = [opts.bold ? "1" : null, opts.dim ? "2" : null, `38;2;${rgb[0]};${rgb[1]};${rgb[2]}`]
+    .filter(Boolean)
+    .join(";");
+  return `\x1b[${flags}m${text}\x1b[0m`;
+}
+
+function mix(a, b, t) {
+  return a.map((v, i) => Math.round(v + (b[i] - v) * t));
+}
+
+function grid() {
+  return Array.from({ length: HEIGHT }, () =>
+    Array.from({ length: WIDTH }, () => ({ v: 0, n: false })),
+  );
+}
+
+function put(g, x, y, value, node = false) {
+  const px = Math.round(x);
+  const py = Math.round(y);
+  if (py < 0 || py >= HEIGHT || px < 0 || px >= WIDTH) return;
+  if (value > g[py][px].v) g[py][px] = { v: value, n: g[py][px].n || node };
+  else if (node) g[py][px].n = true;
+}
+
+function dot(g, x, y, value, radius = 0.85, node = false) {
+  const r = Math.ceil(radius);
+  for (let dy = -r; dy <= r; dy += 1) {
+    for (let dx = -r; dx <= r; dx += 1) {
+      const d = Math.sqrt(dx * dx + dy * dy);
+      if (d <= radius) put(g, x + dx, y + dy, value * (1 - d / (radius + 0.8)), node);
+    }
+  }
+}
+
+function project(latDeg, lonDeg, phase) {
+  const lat = (latDeg * Math.PI) / 180;
+  const lon = (lonDeg * Math.PI) / 180;
+  const cosLat = Math.cos(lat);
+  const x = cosLat * Math.sin(lon);
+  const y = Math.sin(lat);
+  const z = cosLat * Math.cos(lon);
+  const rp = { x: x * Math.cos(phase) + z * Math.sin(phase), z: -x * Math.sin(phase) + z * Math.cos(phase) };
+  return { x: WIDTH / 2 - 0.5 + rp.x * RX, y: HEIGHT / 2 - 0.5 - y * RY, z: rp.z };
+}
+
+function drawCurve(g, points, base = 0.08, radius = 0.75) {
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    const steps = Math.max(2, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) * 1.7));
+    for (let s = 0; s <= steps; s += 1) {
+      const t = s / steps;
+      const z = a.z + (b.z - a.z) * t;
+      const front = Math.max(0, (z + 1) / 2);
+      const fade = Math.max(0, (z + 0.38) / 1.38);
+      dot(g, a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, base * fade + front * 0.21, radius);
+    }
+  }
+}
+
+function lonBetween(a, b, t) {
+  let delta = b - a;
+  if (delta > 180) delta -= 360;
+  if (delta < -180) delta += 360;
+  let value = a + delta * t;
+  if (value > 180) value -= 360;
+  if (value < -180) value += 360;
+  return value;
+}
+
+function drawFrame(index) {
+  const phase = (index / FRAMES) * Math.PI * 2;
+  const g = grid();
+  const cx = WIDTH / 2 - 0.5;
+  const cy = HEIGHT / 2 - 0.5;
+
+  for (let deg = 0; deg < 360; deg += 1) {
+    const a = (deg * Math.PI) / 180;
+    const pulse = 0.22 + 0.18 * Math.max(0, 1 - Math.abs((((a - phase + Math.PI) % (Math.PI * 2)) - Math.PI)) / 1.1);
+    dot(g, cx + Math.cos(a) * RX, cy + Math.sin(a) * RY, pulse + 0.27, 1.0);
+  }
+  for (const lat of [-60, -42, -24, -8, 8, 24, 42, 60]) {
+    const pts = [];
+    for (let lon = -180; lon <= 180; lon += 3) pts.push(project(lat, lon, phase));
+    drawCurve(g, pts, 0.07, 0.55);
+  }
+  for (const lon of [-150, -105, -60, -20, 20, 60, 105, 150]) {
+    const pts = [];
+    for (let lat = -76; lat <= 76; lat += 3) pts.push(project(lat, lon, phase));
+    drawCurve(g, pts, 0.055, 0.48);
+  }
+  for (const [a, b] of LINKS) {
+    const start = NODES[a];
+    const end = NODES[b];
+    const pts = [];
+    for (let s = 0; s <= 14; s += 1) {
+      const t = s / 14;
+      pts.push(project(start[0] + (end[0] - start[0]) * t, lonBetween(start[1], end[1], t), phase));
+    }
+    drawCurve(g, pts, 0.035, 0.45);
+  }
+  NODES.forEach(([lat, lon], i) => {
+    const p = project(lat, lon, phase);
+    const front = Math.max(0, (p.z + 1) / 2);
+    const pulse = 0.5 + 0.5 * Math.sin(phase * 2.2 + i * 0.75);
+    dot(g, p.x, p.y, 0.28 + front * 0.42 + pulse * 0.24, (front > 0.48 ? 1.55 : 0.9) + pulse * 0.45, true);
+  });
+
+  const rows = Math.floor(HEIGHT / 4);
+  const cols = Math.floor(WIDTH / 2);
+  const lines = [];
+  for (let y = 0; y < rows; y += 1) {
+    let line = "";
+    for (let x = 0; x < cols; x += 1) {
+      let mask = 0;
+      let value = 0;
+      let node = false;
+      for (let dy = 0; dy < 4; dy += 1) {
+        for (let dx = 0; dx < 2; dx += 1) {
+          const px = g[y * 4 + dy][x * 2 + dx];
+          if (px.v <= 0.11) continue;
+          mask |= BRAILLE[dy][dx];
+          value = Math.max(value, px.v);
+          node = node || px.n;
+        }
+      }
+      if (!mask) line += " ";
+      else line += ansi(node ? mix(CYAN, WHITE, Math.min(0.35, value * 0.28)) : mix(DIM, BLUE, Math.min(0.8, value)), String.fromCharCode(0x2800 + mask), { bold: node && value > 0.62, dim: value < 0.25 });
+    }
+    lines.push(line.replace(/\s+$/u, ""));
+  }
+  return lines;
+}
+
+function shouldShowSplash() {
+  if (!envTruthy("MYTE_CODY_SPLASH", true)) return false;
+  if (process.env.CI && process.env.MYTE_CODY_SPLASH_FORCE !== "1") return false;
+  return Boolean(process.stdout.isTTY || process.env.MYTE_CODY_SPLASH_FORCE === "1");
+}
+
+function buildLines(frame, status) {
+  return [
+    "",
+    ...drawFrame(frame),
+    "",
+    `  ${ansi(WHITE, "MYTE CODY", { bold: true })}${ansi(SOFT, " - Your Tech Your Way")}`,
+    `  ${ansi(BLUE, "sovereign coding gateway", { bold: true })}`,
+    `  ${ansi(CYAN, "◆", { bold: true })} ${ansi(SOFT, status || "opening workspace")}`,
+  ];
+}
+
+function createMyteSplash() {
+  const enabled = shouldShowSplash();
+  let frame = 0;
+  let lineCount = 0;
+  let rendered = false;
+  let timer = null;
+  let started = 0;
+  let status = "opening workspace";
+
+  function render() {
+    if (!enabled) return;
+    const lines = buildLines(frame, status);
+    if (rendered) process.stdout.write(`\x1b[${lineCount}F\x1b[J`);
+    process.stdout.write(`${lines.join("\n")}\n`);
+    lineCount = lines.length;
+    rendered = true;
+    frame = (frame + 1) % FRAMES;
+  }
+
+  function start(initialStatus) {
+    if (!enabled || timer) return;
+    status = initialStatus || status;
+    started = Date.now();
+    process.stdout.write("\x1b[?25l");
+    render();
+    timer = setInterval(render, FRAME_MS);
+  }
+
+  function setStatus(nextStatus) {
+    if (nextStatus) status = String(nextStatus);
+  }
+
+  async function stop() {
+    if (!enabled) return;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    const remaining = Math.max(0, MIN_MS - (Date.now() - started));
+    if (remaining) await new Promise((resolve) => setTimeout(resolve, remaining));
+    if (rendered) process.stdout.write(`\x1b[${lineCount}F\x1b[J`);
+    process.stdout.write("\x1b[?25h");
+    rendered = false;
+    lineCount = 0;
+  }
+
+  return { enabled, start, setStatus, stop };
+}
+
+function previewPlain() {
+  const strip = (text) => text.replace(/\x1b\[[0-9;]*m/g, "");
+  return [0, 8, 16, 24].map((frame) => buildLines(frame, "checking signed release manifest").map(strip).join("\n")).join("\n\n");
+}
+
+module.exports = {
+  createMyteSplash,
+  previewPlain,
+};

package/mytecody-cli.js

@@ -11,6 +11,7 @@ const {
   DEFAULT_MYTEAI_BASE,
   normalizeMyteAiBase,
 } = require("./lib/ai-gateway");
+const { createMyteSplash } = require("./lib/mytecody-splash");
 
 const PACKAGE_VERSION = require("./package.json").version;
 const DEFAULT_CHANNEL = "alpha";
@@ -267,6 +268,16 @@ function statusLine(message) {
   console.error(`[MYTE CODY] ${message}`);
 }
 
+function setupProgress(splash) {
+  return (message) => {
+    if (splash && splash.enabled) {
+      splash.setStatus(message);
+      return;
+    }
+    statusLine(message);
+  };
+}
+
 function formatBytes(bytes) {
   const value = Number(bytes || 0);
   if (!Number.isFinite(value) || value <= 0) return "unknown size";
@@ -762,26 +773,32 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     console.error("MyteCody requires MYTEAI_API_KEY for coding.");
     return 1;
   }
-  statusLine("preparing trusted workspace");
+  const splash = createMyteSplash();
+  const progress = setupProgress(splash);
+  splash.start("preparing trusted workspace");
+  progress("preparing trusted workspace");
   writeCodexConfig(args);
   try {
-    const install = await ensureBrandedEngineInstalled(args, envPath, { progress: statusLine });
+    const install = await ensureBrandedEngineInstalled(args, envPath, { progress });
     if (install.ok && install.installed) {
-      statusLine(`engine installed: ${install.payload.installed.version}`);
+      progress(`engine installed: ${install.payload.installed.version}`);
     } else if (install.ok) {
-      statusLine("engine ready");
+      progress("engine ready");
     } else if (!install.ok) {
+      await splash.stop();
       console.error(`MyteCody branded engine could not be verified: ${install.reason || "unknown"}.`);
       console.error("Run `mytecody update` with access to the Myte release manifest.");
       return 1;
     }
   } catch (error) {
+    await splash.stop();
     console.error(`MyteCody engine verification failed: ${error && error.message ? error.message : error}`);
     return 1;
   }
 
   const command = resolveCodexCommand();
   if (!command) {
+    await splash.stop();
     console.error("MyteCody branded engine is not installed.");
     console.error("Run `mytecody update` with access to the Myte release manifest.");
     return 1;
@@ -793,6 +810,8 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     MYTE_CODY_AUTH_TOKEN: token,
     MYTE_CODY_BRAND: "1",
   };
+  progress("opening MyteCody workspace");
+  await splash.stop();
   return new Promise((resolve) => {
     const child = spawn(command.cmd, launchArgs, {
       cwd: process.cwd(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "description": "Myte CLI core implementation.",
   "type": "commonjs",
   "main": "cli.js",