@mytegroupinc/myte-core 0.0.2

package/README.md

@@ -0,0 +1,10 @@
+# @mytegroupinc/myte-core
+
+Internal implementation package for the `myte` CLI.
+
+Most users should install the unscoped wrapper instead:
+- `npm i -g myte`
+- `npx myte@latest query "..." --with-diff`
+
+This package is published under the org scope for governance; the wrapper delegates here.
+

package/cli.js

@@ -0,0 +1,653 @@
+#!/usr/bin/env node
+/**
+ * Myte CLI (core)
+ *
+ * - Auth: MYTE_API_KEY (project key) from `.env` or env
+ * - Default API: https://api.myte.dev (override with MYTE_API_BASE or --base-url)
+ * - Deterministic diffs: fetch /api/project-assistant/config to get repo folder names
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const DEFAULT_API_BASE = "https://api.myte.dev";
+
+function findEnvPath(startDir) {
+  let cur = startDir;
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = path.join(cur, ".env");
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+
+function loadEnv() {
+  const envPath = findEnvPath(process.cwd());
+  try {
+    // eslint-disable-next-line global-require
+    const dotenv = require("dotenv");
+    dotenv.config(envPath ? { path: envPath } : undefined);
+    return;
+  } catch (err) {
+    if (!envPath || !fs.existsSync(envPath)) return;
+    const content = fs.readFileSync(envPath, "utf8");
+    content.split(/\r?\n/).forEach((line) => {
+      if (!line || line.trim().startsWith("#")) return;
+      const idx = line.indexOf("=");
+      if (idx === -1) return;
+      const key = line.slice(0, idx).trim();
+      const val = line.slice(idx + 1).trim();
+      if (key && !(key in process.env)) {
+        process.env[key] = val;
+      }
+    });
+  }
+}
+
+function splitCommand(argv) {
+  const known = new Set(["query", "ask", "chat", "config", "help", "--help", "-h"]);
+  const first = argv[0];
+  if (first && known.has(first)) {
+    const cmd = first === "--help" || first === "-h" ? "help" : first;
+    return { command: cmd, rest: argv.slice(1) };
+  }
+  return { command: "query", rest: argv };
+}
+
+function parseArgs(argv) {
+  try {
+    // eslint-disable-next-line global-require
+    return require("minimist")(argv, {
+      boolean: ["with-diff", "diff", "print-context", "dry-run", "fetch", "json"],
+      string: ["query", "q", "context", "ctx", "base-url", "timeout-ms", "diff-limit"],
+      alias: {
+        q: "query",
+        d: "with-diff",
+        c: "context",
+        h: "help",
+      },
+      default: {
+        fetch: true,
+      },
+    });
+  } catch (err) {
+    const parsed = { _: [] };
+    for (let i = 0; i < argv.length; i += 1) {
+      const token = argv[i];
+      if (token.startsWith("--no-")) {
+        const key = token.slice(5);
+        parsed[key] = false;
+        continue;
+      }
+      if (token.startsWith("--")) {
+        const key = token.slice(2);
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+          parsed[key] = next;
+          i += 1;
+        } else {
+          parsed[key] = true;
+        }
+      } else if (token.startsWith("-")) {
+        const key = token.slice(1);
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+          parsed[key] = next;
+          i += 1;
+        } else {
+          parsed[key] = true;
+        }
+      } else {
+        parsed._.push(token);
+      }
+    }
+    return parsed;
+  }
+}
+
+function printHelp() {
+  const text = [
+    "myte - Myte Project Assistant CLI",
+    "",
+    "Usage:",
+    "  myte query \"<text>\" [--with-diff] [--context \"...\"]",
+    "  myte config [--json]",
+    "  myte chat",
+    "",
+    "Auth:",
+    "  - Set MYTE_API_KEY in a workspace .env (or env var)",
+    "",
+    "Options:",
+    "  --with-diff           Include deterministic git diffs (project-scoped)",
+    "  --diff-limit <chars>  Truncate diff context to N chars (default: 200000)",
+    "  --timeout-ms <ms>     Request timeout (default: 300000)",
+    "  --base-url <url>      API base (default: https://api.myte.dev)",
+    "  --print-context       Print JSON payload and exit (no query call)",
+    "  --no-fetch            Don't git fetch origin main/master before diff",
+    "",
+    "Examples:",
+    "  myte query \"What changed in logging?\" --with-diff",
+    "  myte query \"...\" --with-diff --diff-limit 120000",
+    "  myte config",
+  ].join("\n");
+  console.log(text);
+}
+
+async function getFetch() {
+  if (typeof fetch !== "undefined") return fetch;
+  const mod = await import("node-fetch");
+  return mod.default;
+}
+
+function normalizeApiBase(baseRaw) {
+  const baseTrim = String(baseRaw || "").trim().replace(/\/+$/, "");
+  const base = baseTrim || DEFAULT_API_BASE;
+  return base.endsWith("/api") ? base : `${base}/api`;
+}
+
+async function fetchJsonWithTimeout(fetchFn, url, options, timeoutMs) {
+  const controller = typeof AbortController !== "undefined" ? new AbortController() : undefined;
+  const timeoutId =
+    controller && timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+  try {
+    const resp = await fetchFn(url, { ...options, signal: controller?.signal });
+    const text = await resp.text();
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      const err = new Error(`Non-JSON response (${resp.status}): ${text.slice(0, 500)}`);
+      err.status = resp.status;
+      throw err;
+    }
+    return { resp, body };
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+
+function buildContext(args, diffText) {
+  const ctx = args.context ?? args.ctx ?? args.c;
+  const extra = ctx === undefined ? [] : Array.isArray(ctx) ? ctx.map(String) : [String(ctx)];
+  if (diffText) extra.push(`Current git diff snapshot (project-configured):\n${diffText}`);
+  return extra;
+}
+
+const IGNORED_PATTERNS = [
+  /^node_modules\//,
+  /\.node$/,
+  /package-lock\.json$/,
+  /yarn\.lock$/,
+  /pnpm-lock\.ya?ml$/,
+  /\.DS_Store$/,
+  /\.log$/,
+  /\.env$/,
+  /^\.vscode\//,
+  /^\.idea\//,
+  /\.gitignore$/,
+  /\.eslint/,
+  /^\.next\//,
+  /^dist\//,
+  /^out\//,
+];
+
+function shouldIgnore(p) {
+  return IGNORED_PATTERNS.some((re) => re.test(p));
+}
+
+function hasGitDir(repoPath) {
+  return fs.existsSync(path.join(repoPath, ".git"));
+}
+
+function runGitDiff(repoPath, args, opts = {}) {
+  const res = spawnSync("git", args, {
+    cwd: repoPath,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 64 * 1024 * 1024,
+    ...opts,
+  });
+  if (res.status !== 0 && res.status !== 1) {
+    const msg = res.stderr || res.error?.message || "unknown git error";
+    const err = new Error(`git ${args.join(" ")} failed (${res.status}): ${msg}`);
+    err.code = res.status;
+    throw err;
+  }
+  return (res.stdout || "").trim();
+}
+
+function runGitOk(repoPath, args, opts = {}) {
+  const res = spawnSync("git", args, {
+    cwd: repoPath,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 16 * 1024 * 1024,
+    ...opts,
+  });
+  return res.status === 0;
+}
+
+function runGitTry(repoPath, args) {
+  try {
+    return runGitDiff(repoPath, args);
+  } catch {
+    return "";
+  }
+}
+
+function patchPaths(diff, prefix = "") {
+  if (!diff) return "";
+  return diff
+    .replace(
+      /^diff --git ([ab]\/|\/dev\/null)(.+?) ([ab]\/|\/dev\/null)(.+?)$/gm,
+      (_, aPre, a, bPre, b) =>
+        `diff --git ${aPre === "/dev/null" ? "/dev/null" : prefix + a} ${
+          bPre === "/dev/null" ? "/dev/null" : prefix + b
+        }`
+    )
+    .replace(
+      /^(---) ([ab]\/|\/dev\/null)(.+)$/gm,
+      (_, m, pre, p) => `${m} ${pre === "/dev/null" ? "/dev/null" : prefix + p}`
+    )
+    .replace(
+      /^(?:\+\+\+) ([ab]\/|\/dev\/null)(.+)$/gm,
+      (_, pre, p) => `+++ ${pre === "/dev/null" ? "/dev/null" : prefix + p}`
+    );
+}
+
+function filterDiff(diff) {
+  if (!diff) return "";
+  return diff
+    .split(/^diff --git /gm)
+    .filter((block) => {
+      if (!block.trim()) return false;
+      const m = block.match(/^([ab]\/\S+?) ([ab]\/\S+?)\n/);
+      if (
+        m &&
+        (shouldIgnore(m[1].replace(/^[ab]\//, "")) || shouldIgnore(m[2].replace(/^[ab]\//, "")))
+      ) {
+        return false;
+      }
+      return true;
+    })
+    .map((blk, i) => (i === 0 ? blk : `diff --git ${blk}`))
+    .join("");
+}
+
+function resolveConfiguredRepos(repoNames) {
+  const names = Array.isArray(repoNames) ? repoNames.map(String).map((s) => s.trim()).filter(Boolean) : [];
+  if (!names.length) return { mode: "none", root: null, repos: [], missing: [] };
+
+  const cwd = process.cwd();
+  const cwdBase = path.basename(cwd);
+  const cwdIsConfiguredRepo = names.includes(cwdBase) && hasGitDir(cwd);
+
+  const ancestors = [];
+  const scanStart = cwdIsConfiguredRepo ? path.dirname(cwd) : cwd;
+  let cur = scanStart;
+  for (let i = 0; i < 8; i += 1) {
+    ancestors.push(cur);
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+
+  for (const candidate of ancestors) {
+    const found = [];
+    for (const name of names) {
+      const abs = path.join(candidate, name);
+      if (hasGitDir(abs)) {
+        found.push({
+          name,
+          dir: name,
+          abs,
+          prefix: `${name.replace(/\\\\/g, "/")}/`,
+        });
+      }
+    }
+    if (found.length) {
+      const foundNames = new Set(found.map((r) => r.name));
+      const missing = names.filter((n) => !foundNames.has(n));
+      return { mode: "workspace", root: candidate, repos: found, missing };
+    }
+  }
+
+  if (cwdIsConfiguredRepo) {
+    const missing = names.filter((n) => n !== cwdBase);
+    return {
+      mode: "repo",
+      root: cwd,
+      repos: [
+        {
+          name: cwdBase,
+          dir: ".",
+          abs: cwd,
+          prefix: `${cwdBase.replace(/\\\\/g, "/")}/`,
+        },
+      ],
+      missing,
+    };
+  }
+
+  return { mode: "none", root: null, repos: [], missing: names };
+}
+
+function fetchBaseBranches(repoPath) {
+  if (runGitOk(repoPath, ["fetch", "origin", "main", "master", "--prune", "--quiet"])) return true;
+  return runGitOk(repoPath, ["fetch", "--all", "--prune", "--quiet"]);
+}
+
+function resolveBaseRef(repoPath) {
+  if (runGitOk(repoPath, ["rev-parse", "--verify", "refs/remotes/origin/main"])) return "origin/main";
+  if (runGitOk(repoPath, ["rev-parse", "--verify", "refs/remotes/origin/master"])) return "origin/master";
+  if (runGitOk(repoPath, ["rev-parse", "--verify", "refs/heads/main"])) return "main";
+  if (runGitOk(repoPath, ["rev-parse", "--verify", "refs/heads/master"])) return "master";
+  return null;
+}
+
+function collectGitDiff({ projectId, repoNames, maxChars, fetchRemote = true } = {}) {
+  try {
+    const resolved = resolveConfiguredRepos(repoNames);
+    const repos = resolved.repos || [];
+    if (!repos.length) {
+      const configured = Array.isArray(repoNames) ? repoNames.join(", ") : "";
+      const msg = [
+        "[myte] No configured repos found locally.",
+        `Configured repos (from project ${projectId || "unknown"}): ${configured || "(none)"}`,
+        "Run from within a configured repo, or a parent folder that contains the repo folders by name.",
+      ].join("\n");
+      throw new Error(msg);
+    }
+
+    let output = "";
+    if (projectId) output += `# Project: ${projectId}\n`;
+    output += `# Mode: ${resolved.mode}\n`;
+    output += `# Configured repos: ${Array.isArray(repoNames) ? repoNames.join(", ") : ""}\n`;
+    if (resolved.missing && resolved.missing.length) {
+      output += `# Missing locally (skipped): ${resolved.missing.join(", ")}\n`;
+    }
+    output += "\n";
+
+    for (const { name, dir, abs, prefix } of repos) {
+      if (fetchRemote) fetchBaseBranches(abs);
+
+      const headBranch = runGitTry(abs, ["rev-parse", "--abbrev-ref", "HEAD"]) || "HEAD";
+      const baseRef = resolveBaseRef(abs);
+
+      const baseDiffRaw = baseRef ? runGitDiff(abs, ["diff", "--no-color", "-U2", `${baseRef}...HEAD`]) : "";
+      const stagedRaw = runGitDiff(abs, ["diff", "--cached", "--no-color", "-U2"]);
+      const unstagedRaw = runGitDiff(abs, ["diff", "--no-color", "-U2"]);
+
+      const baseDiff = patchPaths(filterDiff(baseDiffRaw), prefix);
+      const staged = patchPaths(filterDiff(stagedRaw), prefix);
+      const unstaged = patchPaths(filterDiff(unstagedRaw), prefix);
+
+      const untracked = runGitTry(abs, ["ls-files", "--others", "--exclude-standard"])
+        .split("\n")
+        .filter(Boolean)
+        .filter((f) => !shouldIgnore(f));
+
+      let untrackedDiffs = "";
+      for (const file of untracked) {
+        const absFile = path.join(abs, file);
+        if (!fs.existsSync(absFile) || !fs.statSync(absFile).isFile()) continue;
+        const patch = runGitDiff(abs, ["diff", "--no-index", "--no-color", "/dev/null", file]);
+        if (patch) untrackedDiffs += patchPaths(patch, prefix) + "\n";
+      }
+
+      output += `### ${name} (${dir || "."})\n\n`;
+      output += `# ?? Base vs HEAD (${baseRef || "base-unresolved"}...HEAD | head=${headBranch})\n`;
+      if (baseDiff) output += `${baseDiff}\n\n`;
+      if (staged) output += `# ?? Staged changes\n${staged}\n\n`;
+      if (unstaged) output += `# ?? Unstaged changes\n${unstaged}\n\n`;
+      if (untrackedDiffs) output += `# ?? Untracked files (full contents below)\n${untrackedDiffs}\n`;
+
+      if (!baseDiff && !staged && !unstaged && !untrackedDiffs) {
+        output += "_No local changes - working tree clean_\n\n";
+      }
+    }
+
+    if (Number.isFinite(maxChars) && maxChars > 0 && output.length > maxChars) {
+      return `${output.slice(0, maxChars)}\n...[truncated to ${maxChars} chars]`;
+    }
+    return output.trim();
+  } catch (err) {
+    console.warn("Failed to collect git diffs:", err?.message || err);
+    return "";
+  }
+}
+
+async function fetchProjectConfig({ apiBase, key, timeoutMs }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}/project-assistant/config`;
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Config request failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    throw err;
+  }
+  return body.data || {};
+}
+
+async function callAssistantQuery({ apiBase, key, payload, timeoutMs }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}/project-assistant/query`;
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`,
+      },
+      body: JSON.stringify(payload),
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Query failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    throw err;
+  }
+  return body.data || {};
+}
+
+async function runConfig(args) {
+  const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+
+  const timeoutRaw = args["timeout-ms"] || args.timeoutMs || args.timeout_ms;
+  const timeoutParsed = timeoutRaw !== undefined ? Number(timeoutRaw) : 300_000;
+  const timeoutMs = Number.isFinite(timeoutParsed) ? timeoutParsed : 300_000;
+
+  const baseRaw = args["base-url"] || args.baseUrl || args.base_url || process.env.MYTE_API_BASE || DEFAULT_API_BASE;
+  const apiBase = normalizeApiBase(baseRaw);
+
+  let cfg;
+  try {
+    cfg = await fetchProjectConfig({ apiBase, key, timeoutMs });
+  } catch (err) {
+    console.error("Failed to fetch config:", err?.message || err);
+    process.exit(1);
+  }
+
+  const repoNames = Array.isArray(cfg.repo_names) ? cfg.repo_names : [];
+  const resolved = resolveConfiguredRepos(repoNames);
+  const payload = {
+    api_base: apiBase,
+    project_id: cfg.project_id,
+    repo_names: repoNames,
+    local: {
+      mode: resolved.mode,
+      root: resolved.root,
+      found: (resolved.repos || []).map((r) => r.name),
+      missing: resolved.missing || [],
+    },
+  };
+
+  if (args.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(`Project: ${payload.project_id || "(unknown)"}`);
+    console.log(`API base: ${payload.api_base}`);
+    console.log(`Configured repos: ${repoNames.join(", ") || "(none)"}`);
+    console.log(`Local mode: ${payload.local.mode}`);
+    if (payload.local.found.length) console.log(`Found locally: ${payload.local.found.join(", ")}`);
+    if (payload.local.missing.length) console.log(`Missing locally: ${payload.local.missing.join(", ")}`);
+  }
+}
+
+async function runQuery(args) {
+  const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+
+  const query = args.query || args.q || (Array.isArray(args._) ? args._.join(" ").trim() : "");
+  if (!query) {
+    console.error("Missing query text.");
+    printHelp();
+    process.exit(1);
+  }
+
+  const includeDiff = Boolean(args["with-diff"] || args.withDiff || args.diff || args.d);
+  const printContext = Boolean(args["print-context"] || args.printContext || args["dry-run"] || args.dryRun);
+
+  const fetchRemote = args.fetch !== undefined ? Boolean(args.fetch) : true;
+
+  const timeoutRaw = args["timeout-ms"] || args.timeoutMs || args.timeout_ms;
+  const timeoutParsed = timeoutRaw !== undefined ? Number(timeoutRaw) : 300_000;
+  const timeoutMs = Number.isFinite(timeoutParsed) ? timeoutParsed : 300_000;
+
+  const charLimitRaw = args["diff-limit"] || args.diffLimit || args.diff_limit;
+  const charLimitParsed = charLimitRaw !== undefined && charLimitRaw !== null ? Number(charLimitRaw) : 200_000;
+  const diffLimit = Number.isFinite(charLimitParsed) ? charLimitParsed : 200_000;
+
+  const baseRaw = args["base-url"] || args.baseUrl || args.base_url || process.env.MYTE_API_BASE || DEFAULT_API_BASE;
+  const apiBase = normalizeApiBase(baseRaw);
+
+  let diffText = "";
+  if (includeDiff) {
+    let cfg;
+    try {
+      cfg = await fetchProjectConfig({ apiBase, key, timeoutMs });
+    } catch (err) {
+      console.error("Failed to fetch project config (needed for diffs):", err?.message || err);
+      process.exit(1);
+    }
+    const repoNames = Array.isArray(cfg.repo_names) ? cfg.repo_names : [];
+    diffText = collectGitDiff({
+      projectId: cfg.project_id,
+      repoNames,
+      maxChars: diffLimit,
+      fetchRemote,
+    });
+    if (!diffText) {
+      console.error("No diff context collected. Ensure you're running from the workspace root (or within a configured repo).");
+      process.exit(1);
+    }
+  }
+
+  const payload = {
+    query,
+    additional_context: buildContext(args, diffText),
+  };
+
+  if (printContext) {
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(0);
+  }
+
+  let data;
+  try {
+    data = await callAssistantQuery({ apiBase, key, payload, timeoutMs });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      console.error(`Request timed out after ${timeoutMs}ms`);
+    } else {
+      console.error("Assistant query failed:", err?.message || err);
+    }
+    process.exit(1);
+  }
+
+  console.log("Answer:\n", data.answer || "(no answer)");
+  if (data.context_blocks?.length) console.log(`\nContext blocks: ${data.context_blocks.length}`);
+  if (data.telemetry) {
+    const t = data.telemetry;
+    const usage = t.usage || {};
+    console.log(`\nTelemetry: model=${t.model || "n/a"}, rag_used=${t.rag_used}, tokens_total=${usage.total_tokens || "n/a"}`);
+  }
+}
+
+async function runChat(args) {
+  const readline = require("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  console.log("myte chat (Ctrl+C to exit)");
+  rl.setPrompt("> ");
+  rl.prompt();
+
+  rl.on("line", async (line) => {
+    const text = String(line || "").trim();
+    if (!text) {
+      rl.prompt();
+      return;
+    }
+    try {
+      await runQuery({ ...args, _: [text] });
+    } catch (err) {
+      console.error(err?.message || err);
+    }
+    rl.prompt();
+  });
+}
+
+async function main() {
+  loadEnv();
+
+  const { command, rest } = splitCommand(process.argv.slice(2));
+  const args = parseArgs(rest);
+  if (args.help || command === "help") {
+    printHelp();
+    return;
+  }
+
+  if (command === "config") {
+    await runConfig(args);
+    return;
+  }
+
+  if (command === "chat") {
+    await runChat(args);
+    return;
+  }
+
+  // query/ask default
+  await runQuery(args);
+}
+
+main().catch((err) => {
+  console.error("Unexpected error:", err?.message || err);
+  process.exit(1);
+});
+

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@mytegroupinc/myte-core",
+  "version": "0.0.2",
+  "description": "Myte CLI core implementation (Project Assistant + deterministic diffs).",
+  "type": "commonjs",
+  "main": "cli.js",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "dotenv": "^16.5.0",
+    "minimist": "^1.2.8",
+    "node-fetch": "^3.3.2"
+  }
+}
+