@mytegroupinc/myte-core 0.0.36 → 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/mytecody-cli.js

@@ -13,13 +13,17 @@ const {
 } = 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;
@@ -214,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
@@ -233,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,
@@ -242,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),
@@ -255,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));
 }
@@ -601,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." },
@@ -796,6 +899,14 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     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();
@@ -812,6 +923,7 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
   };
   progress("opening MyteCody workspace");
   await splash.stop();
+  if (packageNotice) statusLine(packageNotice);
   return new Promise((resolve) => {
     const child = spawn(command.cmd, launchArgs, {
       cwd: process.cwd(),
@@ -833,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);
   }
@@ -853,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("");
@@ -981,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}`);
@@ -996,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;
 }
 
@@ -1034,6 +1160,7 @@ if (require.main === module) {
 }
 
 module.exports = {
+  checkPackageUpdate,
   codexLaunchArgs,
   codexProviderArgs,
   codyInferenceBase,
@@ -1043,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.36",
+  "version": "0.0.37",
   "description": "Myte CLI core implementation.",
   "type": "commonjs",
   "main": "cli.js",