@mytegroupinc/myte-core 0.0.35 → 0.0.37

package/README.md

@@ -31,6 +31,10 @@ This package exists so the public wrapper can stay small and versioned cleanly.
   run, it installs the branded MyteCody engine from the Myte release manifest
   into a user-local Myte cache after signature/hash checks. Coding execution
   requires that engine, a reachable Myte AI Cody gateway, and `MYTEAI_API_KEY`.
+- `mytecody doctor` reports both the signed MyteCody engine state and this npm
+  package version. `mytecody update` updates the engine only. Use
+  `npm install -g myte@latest` to update the launcher and the Myte API CLI
+  commands shipped by npm.
 - The package does not bundle the large MyteCody engine binary. See
   `THIRD_PARTY_NOTICES.md` and `TRADEMARKS.md` for Codex lineage and Myte brand
   notices.

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,14 +11,19 @@ const {
   DEFAULT_MYTEAI_BASE,
   normalizeMyteAiBase,
 } = require("./lib/ai-gateway");
+const { createMyteSplash } = require("./lib/mytecody-splash");
 
+const PACKAGE_NAME = "myte";
 const PACKAGE_VERSION = require("./package.json").version;
+const DEFAULT_PACKAGE_LATEST_URL = "https://registry.npmjs.org/myte/latest";
 const DEFAULT_CHANNEL = "alpha";
 const DEFAULT_MODEL_ALIAS = "myte";
 const DEFAULT_CONTEXT_WINDOW = Number(process.env.MYTE_CODY_CONTEXT_WINDOW || 49152);
 const DEFAULT_AUTO_COMPACT_TOKENS = Number(process.env.MYTE_CODY_AUTO_COMPACT_TOKENS || 40960);
 const DEFAULT_TOOL_OUTPUT_TOKENS = Number(process.env.MYTE_CODY_TOOL_OUTPUT_TOKENS || 10000);
 const DEFAULT_AGENT_THREADS = Number(process.env.MYTE_CODY_AGENT_THREADS || 4);
+const CLIENT_BASE_INSTRUCTIONS =
+  "You are MyteCody, a coding agent running through the Myte coding gateway.";
 
 function findEnvPath(startDir) {
   let cur = startDir;
@@ -213,6 +218,10 @@ Usage:
   mytecody update [--json] [--manifest <url-or-file>]
   mytecody help
 
+Updates:
+  mytecody update              updates the signed MyteCody engine only
+  npm install -g myte@latest   updates this npm launcher and Myte API tools
+
 Network:
   The distributed MyteCody client uses the Myte AI gateway for coding
   inference. It can inspect local config without network, but coding requires
@@ -232,6 +241,7 @@ function commonStatus(args, envPath) {
     product: "MyteCody",
     command: "mytecody",
     package_version: PACKAGE_VERSION,
+    package: packageStatusBase(args),
     mode: "team-gateway",
     workspace: process.cwd(),
     env_file: envPath,
@@ -241,6 +251,16 @@ function commonStatus(args, envPath) {
       inference_base_url: codyInferenceBase(args),
       network_required_for_coding: true,
     },
+    instruction_pack: {
+      owner: "myte-cody-gateway",
+      client_embedded: false,
+    },
+    runtime: {
+      context_window: DEFAULT_CONTEXT_WINDOW,
+      auto_compact_tokens: DEFAULT_AUTO_COMPACT_TOKENS,
+      tool_output_tokens: DEFAULT_TOOL_OUTPUT_TOKENS,
+      max_concurrent_agent_threads: DEFAULT_AGENT_THREADS,
+    },
     release: {
       channel: String(args.channel || process.env.MYTE_CODY_RELEASE_CHANNEL || DEFAULT_CHANNEL),
       manifest_url: manifestUrl(args),
@@ -254,6 +274,103 @@ function commonStatus(args, envPath) {
   };
 }
 
+function packageLatestUrl(args = {}) {
+  return String(
+    args["package-latest-url"] ||
+      process.env.MYTE_CODY_PACKAGE_LATEST_URL ||
+      process.env.MYTE_PACKAGE_LATEST_URL ||
+      DEFAULT_PACKAGE_LATEST_URL,
+  );
+}
+
+function packageUpdateCheckEnabled(args = {}) {
+  if (args["package-update-check"] === false) return false;
+  return process.env.MYTE_CODY_PACKAGE_UPDATE_CHECK !== "0";
+}
+
+function packageStatusBase(args = {}) {
+  return {
+    name: PACKAGE_NAME,
+    installed_version: PACKAGE_VERSION,
+    latest_version: null,
+    update_available: null,
+    check_status: "not-checked",
+    latest_url: packageLatestUrl(args),
+    update_command: `npm install -g ${PACKAGE_NAME}@latest`,
+    engine_update_command: "mytecody update",
+  };
+}
+
+function parseSemverish(version) {
+  const main = String(version || "")
+    .trim()
+    .replace(/^v/i, "")
+    .split(/[+-]/)[0];
+  const match = main.match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!match) return null;
+  return [match[1], match[2] || "0", match[3] || "0"].map((part) => Number(part));
+}
+
+function compareSemverish(left, right) {
+  const leftParts = parseSemverish(left);
+  const rightParts = parseSemverish(right);
+  if (!leftParts || !rightParts) return String(left || "").localeCompare(String(right || ""));
+  for (let i = 0; i < 3; i += 1) {
+    if (leftParts[i] > rightParts[i]) return 1;
+    if (leftParts[i] < rightParts[i]) return -1;
+  }
+  return 0;
+}
+
+function isVersionNewer(latest, installed = PACKAGE_VERSION) {
+  return compareSemverish(latest, installed) > 0;
+}
+
+function packageUpdateTimeoutMs() {
+  const value = Number(process.env.MYTE_CODY_PACKAGE_UPDATE_TIMEOUT_MS || 1500);
+  return Number.isFinite(value) && value > 0 ? value : 1500;
+}
+
+async function checkPackageUpdate(args = {}) {
+  const status = packageStatusBase(args);
+  if (!packageUpdateCheckEnabled(args)) {
+    return { ...status, check_status: "skipped" };
+  }
+  try {
+    const response = await fetchJson(status.latest_url, {
+      timeoutMs: packageUpdateTimeoutMs(),
+    });
+    if (!response.ok) {
+      return {
+        ...status,
+        check_status: "unavailable",
+        registry_status: response.status,
+      };
+    }
+    const latestVersion = response.body && response.body.version ? String(response.body.version) : "";
+    if (!latestVersion) {
+      return { ...status, check_status: "invalid-response" };
+    }
+    return {
+      ...status,
+      latest_version: latestVersion,
+      update_available: isVersionNewer(latestVersion, PACKAGE_VERSION),
+      check_status: "ok",
+    };
+  } catch (error) {
+    return {
+      ...status,
+      check_status: "unavailable",
+      error: error && error.message ? error.message : String(error),
+    };
+  }
+}
+
+function packageUpdateNotice(packageStatus) {
+  if (!packageStatus || packageStatus.update_available !== true) return "";
+  return `myte package update available: ${packageStatus.latest_version} (installed ${packageStatus.installed_version}). Run ${packageStatus.update_command}`;
+}
+
 function printJson(payload) {
   console.log(JSON.stringify(payload, null, 2));
 }
@@ -267,6 +384,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";
@@ -590,26 +717,13 @@ function pathForToml(value) {
 
 function writeCodexModelCatalog() {
   fs.mkdirSync(codexHome(), { recursive: true });
-  const baseInstructions = [
-    "You are MyteCody, a coding agent running in the Myte terminal harness.",
-    "",
-    "You and the user share one local workspace. Start in the current repository and operate there by default. Inspect outside the current repository only when explicitly asked.",
-    "",
-    "Your job is to understand the user's intent, inspect the relevant files, run local commands when useful, edit files with the available patch tool, run focused verification, and stop when the task is actually handled.",
-    "",
-    "For documentation, architecture, and repo-summary work, verify each material claim independently before presenting it as implemented fact. Separate current implementation from planned direction and unknowns. Treat planning docs as intent unless source code, config, command output, or logs prove the behavior exists.",
-    "",
-    "For edits, prefer apply_patch. If a patch fails, read the error, inspect the target file again, and retry with a corrected patch. Do not claim completion until after inspecting the resulting file or relevant diff.",
-    "",
-    "Keep responses concise and factual. Do not invent commands, flags, telemetry names, tool behavior, context-window defaults, retrieval behavior, or implemented features.",
-  ].join("\n");
   const catalog = {
     models: [
       {
         slug: DEFAULT_MODEL_ALIAS,
         display_name: "Myte",
         description: "Myte AI coding model.",
-        base_instructions: baseInstructions,
+        base_instructions: CLIENT_BASE_INSTRUCTIONS,
         default_reasoning_level: "medium",
         supported_reasoning_levels: [
           { effort: "low", description: "Fast local coding pass." },
@@ -762,26 +876,40 @@ 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;
   }
 
+  let packageNotice = "";
+  try {
+    progress("checking myte package version");
+    packageNotice = packageUpdateNotice(await checkPackageUpdate(args));
+  } catch {
+    packageNotice = "";
+  }
+
   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 +921,9 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     MYTE_CODY_AUTH_TOKEN: token,
     MYTE_CODY_BRAND: "1",
   };
+  progress("opening MyteCody workspace");
+  await splash.stop();
+  if (packageNotice) statusLine(packageNotice);
   return new Promise((resolve) => {
     const child = spawn(command.cmd, launchArgs, {
       cwd: process.cwd(),
@@ -814,6 +945,7 @@ async function runDoctor(args, envPath) {
     ready_for_coding: false,
     ...commonStatus(args, envPath),
   };
+  payload.package = await checkPackageUpdate(args);
   if (args["probe-gateway"]) {
     payload.gateway.probe = await probeGateway(args);
   }
@@ -834,6 +966,17 @@ async function runDoctor(args, envPath) {
   if (payload.gateway.probe) {
     console.log(`gateway probe: ${payload.gateway.probe.ok ? "ok" : "failed"}`);
   }
+  console.log(`package:    ${payload.package.installed_version}`);
+  if (payload.package.check_status === "ok" && payload.package.update_available) {
+    console.log(`package update: ${payload.package.latest_version} available`);
+    console.log(`package command: ${payload.package.update_command}`);
+  } else if (payload.package.check_status === "ok") {
+    console.log("package update: current");
+  } else if (payload.package.check_status === "skipped") {
+    console.log("package update: skipped");
+  } else {
+    console.log(`package update: ${payload.package.check_status}`);
+  }
   console.log(`client:     ${payload.release.client_installed ? payload.release.client_version : "not installed"}`);
   console.log(`install:    ${payload.release.install_root}`);
   console.log("");
@@ -962,6 +1105,7 @@ async function runUpdate(args, envPath) {
     return 0;
   }
   console.log(dryRun ? "MYTE CODY update dry-run" : "MYTE CODY update");
+  console.log("scope: MyteCody engine only");
   console.log(`manifest: ${payload.manifest.source}`);
   console.log(`manifest read: ${payload.manifest.read_status}`);
   console.log(`platform: ${payload.release.platform}`);
@@ -977,6 +1121,7 @@ async function runUpdate(args, envPath) {
   if (payload.installed) {
     console.log(`installed: ${payload.installed.executable}`);
   }
+  console.log(`npm launcher/API tools: ${payload.package.update_command}`);
   return 0;
 }
 
@@ -1015,6 +1160,7 @@ if (require.main === module) {
 }
 
 module.exports = {
+  checkPackageUpdate,
   codexLaunchArgs,
   codexProviderArgs,
   codyInferenceBase,
@@ -1024,6 +1170,8 @@ module.exports = {
   ensureBrandedEngineInstalled,
   gatewayRoot,
   installedClientCommand,
+  isVersionNewer,
+  packageUpdateNotice,
   resolveCodexCommand,
   run,
   sha256Hex,

package/package.json

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