@mytegroupinc/myte-core 0.0.14 → 0.0.16

package/README.md

@@ -3,6 +3,8 @@
 Internal implementation package for the `myte` CLI.
 
 Most users should install the unscoped wrapper instead:
+- `npm install myte` then `npx myte ai "Explain this repository"`
+- `npm install myte` then `npx myte ai "Return a JSON object with risks and next_steps" --json-response`
 - `npm install myte` then `npx myte bootstrap`
 - `npm install myte` then `npx myte run-qaqc --mission-ids M001 --wait --sync`
 - `npm install myte` then `npx myte sync-qaqc`
@@ -48,6 +50,7 @@ Requirements:
 - Node `18+`
 - macOS, Linux, or Windows
 - `git` in `PATH` for `--with-diff`
+- `MYTEAI_API_KEY=<inference_api_key>` in env or `.env` for `myte ai`
 - `MYTE_API_KEY=<project_api_key>` in env or `.env`
 - repo folder names must match the project repo names configured in Myte, including casing on case-sensitive filesystems
 
@@ -73,7 +76,8 @@ Notes:
 - `sync-qaqc` keeps QAQC state in one deterministic file so the working set grows and shrinks with current active-mission reality.
 - `sync-qaqc` fully rewrites `MyteCommandCenter/data/qaqc.yml` on every sync and does not delete `MyteCommandCenter/data/missions/*.yml`.
 - `feedback-sync` writes one deterministic feedback snapshot under `MyteCommandCenter/data/feedback.yml`.
-- `feedback-sync` includes readable PRD text inline when PRD text exists.
+- `feedback-sync` keeps feedback metadata plus comment turns in `MyteCommandCenter/data/feedback.yml`.
+- `feedback-sync` writes full PRD context into `MyteCommandCenter/PRD/feedback-sync/*.md` and points to those files from `feedback.yml`.
 - `feedback-sync` fully replaces the feedback-owned sync file to avoid stale local feedback noise.
 - `feedback-sync` fully rewrites `MyteCommandCenter/data/feedback.yml` on every sync and does not delete `MyteCommandCenter/data/missions/*.yml`.
 - `suggestions sync` writes one merge-safe workflow file at `MyteCommandCenter/data/mission-ops.yml`.
@@ -114,6 +118,8 @@ Deterministic `create-prd` contract:
 - Optional structured fields: `priority`, `status`, `tags`, `assigned_user_email`, `assigned_user_id`, `due_date`, `repo_name`, `repo_id`, `preview_url`, `source`.
 
 Examples:
+- `npx myte ai "Explain what this project does"`
+- `npx myte ai "Return a JSON object with risks and next_steps" --json-response`
 - `npx myte bootstrap`
 - `npx myte run-qaqc --mission-ids "M001,M002" --wait --sync`
 - `npx myte sync-qaqc`

package/cli.js

@@ -11,6 +11,15 @@ const fs = require("fs");
 const path = require("path");
 const { createHash } = require("crypto");
 const { spawnSync } = require("child_process");
+const {
+  DEFAULT_MYTEAI_BASE,
+  buildSimpleAiPayload,
+  callMyteAiChat,
+  extractAssistantTextFromChatCompletion,
+  getMyteAiKey,
+  normalizeJsonAssistantText,
+  normalizeMyteAiBase,
+} = require("./lib/ai-gateway");
 
 const DEFAULT_API_BASE = "https://api.myte.dev";
 const REMOVED_COMMAND_MESSAGES = {
@@ -59,6 +68,7 @@ function loadEnv() {
 function splitCommand(argv) {
   const known = new Set([
     "query",
+    "ai",
     "ask",
     "chat",
     "config",
@@ -91,10 +101,11 @@ function parseArgs(argv) {
   try {
     // eslint-disable-next-line global-require
     const parsed = require("minimist")(argv, {
-      boolean: ["with-diff", "diff", "print-context", "dry-run", "fetch", "json", "stdin", "with-prd-text", "wait", "sync", "force"],
+      boolean: ["with-diff", "diff", "print-context", "dry-run", "fetch", "json", "stdin", "with-prd-text", "wait", "sync", "force", "json-response"],
       string: [
         "query",
         "q",
+        "payload-file",
         "context",
         "ctx",
         "file",
@@ -102,6 +113,9 @@ function parseArgs(argv) {
         "base-url",
         "timeout-ms",
         "diff-limit",
+        "max-output-tokens",
+        "max-tokens",
+        "temperature",
         "title",
         "description",
         "feedback-text",
@@ -171,6 +185,7 @@ function printHelp() {
     "",
     "Usage:",
     "  myte query \"<text>\" [--with-diff] [--context \"...\"]",
+    "  myte ai \"<text>\" [--json-response] [--max-output-tokens 500]",
     "  myte config [--json]",
     "  myte bootstrap [--output-dir ./MyteCommandCenter] [--json]",
     "  myte run-qaqc --mission-ids \"M001[,M002...]\" [--wait] [--sync] [--force] [--json]",
@@ -190,12 +205,17 @@ function printHelp() {
     "",
     "Run forms:",
     "  npm install myte   then npx myte query \"...\" --with-diff",
+    "  npm install myte   then npx myte ai \"Explain this code path\"",
     "  npm install myte   then npm exec myte -- query \"...\" --with-diff",
+    "  npm install myte   then npm exec myte -- ai \"Return JSON only\" --json-response",
     "  npm i -g myte      then myte query \"...\" --with-diff",
+    "  npm i -g myte      then myte ai \"Summarize this file\"",
     "  npx myte@latest query \"What changed in logging?\" --with-diff",
+    "  npx myte@latest ai \"Return a JSON checklist\" --json-response",
     "",
     "Auth:",
     "  - Set MYTE_API_KEY in a workspace .env (or env var)",
+    "  - Set MYTEAI_API_KEY in a workspace .env (or env var) for `myte ai`",
     "",
     "bootstrap contract:",
     "  - Run from the wrapper root that contains the project's configured repo folders",
@@ -246,13 +266,18 @@ function printHelp() {
     "",
     "feedback-sync contract:",
     "  - Runs from the wrapper root that contains the project's configured repo folders",
-    "  - Writes open project feedback and inline PRD context into one deterministic file: MyteCommandCenter/data/feedback.yml",
+    "  - Writes open project feedback metadata and conversation turns into MyteCommandCenter/data/feedback.yml",
+    "  - Stores full PRD context in MyteCommandCenter/PRD/feedback-sync/*.md and points to those files from feedback.yml",
     "",
     "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)",
+    "  --payload-file <path> Raw OpenAI-style chat-completions payload for `myte ai`",
+    "  --json-response       Ask the Myte AI gateway to return clean JSON only",
+    "  --max-output-tokens   Output token cap for `myte ai` simple queries",
+    "  --temperature <num>   Temperature for `myte ai` simple queries",
     "  --output-dir <path>   Command Center output directory (default: <wrapper-root>/MyteCommandCenter)",
     "  --file <path>         YAML/JSON payload file for suggestions create/revise/review",
     "  --stdin               Read supported command content from stdin instead of inline text or a file path",
@@ -266,7 +291,7 @@ function printHelp() {
     "  --target-contact-ids  Comma-separated client contact ObjectIds",
     "  --status <value>      Feedback status filter for feedback-sync (default: Pending)",
     "  --source <value>      Feedback source filter for feedback-sync",
-    "  --with-prd-text       Include extracted PRD text in feedback-sync (default: on)",
+    "  --with-prd-text       Include extracted PRD text so local PRD files can be materialized during feedback-sync (default: on)",
     "  --mission-ids <ids>   Comma-separated mission business ids for run-qaqc (quote multi-id values on PowerShell)",
     "  --actor-scope <id>    Actor workspace key inside mission-ops.yml (defaults to machine-cwd slug)",
     "  --wait                Poll batch status until terminal completion for run-qaqc",
@@ -278,6 +303,8 @@ function printHelp() {
     "",
     "Examples:",
     "  myte query \"What changed in logging?\" --with-diff",
+    "  myte ai \"Explain what this repository does\"",
+    "  myte ai \"Return a JSON object with risks and next_steps\" --json-response",
     "  myte bootstrap",
     "  myte suggestions sync",
     "  myte suggestions create",
@@ -1056,6 +1083,9 @@ async function fetchFeedbackSyncSnapshot({ apiBase, key, timeoutMs, filters = {}
   if (filters.includePrdText !== undefined) {
     url.searchParams.set("include_prd_text", filters.includePrdText ? "true" : "false");
   }
+  if (filters.includeCommentTurns !== undefined) {
+    url.searchParams.set("include_comment_turns", filters.includeCommentTurns ? "true" : "false");
+  }
   const { resp, body } = await fetchJsonWithTimeout(
     fetchFn,
     url.toString(),
@@ -1678,6 +1708,44 @@ function writeTextFile(filePath, value) {
   fs.writeFileSync(filePath, String(value || ""), "utf8");
 }
 
+function sanitizeFileSegment(value, fallback = "item") {
+  const cleaned = String(value || "")
+    .trim()
+    .replace(/[<>:"/\\|?*\x00-\x1F]/g, "-")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^\.+|\.+$/g, "")
+    .replace(/^-+|-+$/g, "");
+  return cleaned || fallback;
+}
+
+function toPosixRelativePath(rootPath, targetPath) {
+  return path.relative(rootPath, targetPath).split(path.sep).join("/");
+}
+
+function ensureTrailingNewline(value) {
+  const text = String(value || "");
+  if (!text) return "";
+  return text.endsWith("\n") ? text : `${text}\n`;
+}
+
+function normalizeFeedbackConversationTurns(turns) {
+  if (!Array.isArray(turns)) return [];
+  return turns
+    .map((turn) => {
+      const content = String(turn?.content || "").trim();
+      if (!content) return null;
+      const normalized = {
+        sender_name: firstNonEmptyString(turn?.sender_name, turn?.user_name, turn?.author_name) || "Unknown",
+        content,
+      };
+      const createdAt = firstNonEmptyString(turn?.created_at, turn?.timestamp);
+      if (createdAt) normalized.created_at = createdAt;
+      return normalized;
+    })
+    .filter(Boolean);
+}
+
 function readJsonFile(filePath) {
   if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) return null;
   try {
@@ -1895,8 +1963,11 @@ function writeQaqcSnapshot({ snapshot, wrapperRoot, outputDir }) {
 
 function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
   const { targetRoot, dataRoot } = resolveCommandCenterRoots(wrapperRoot, outputDir);
+  const prdSyncDir = path.join(targetRoot, "PRD", "feedback-sync");
 
   ensureDir(dataRoot);
+  ensureDir(prdSyncDir);
+  clearFileDirectory(prdSyncDir, [".md", ".markdown", ".txt"]);
   pruneLegacyCommandCenterArtifacts(dataRoot, { bootstrap: true, feedback: true });
 
   if (snapshot.project && typeof snapshot.project === "object") {
@@ -1904,15 +1975,58 @@ function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
   }
 
   const items = Array.isArray(snapshot.items) ? snapshot.items : [];
+  let prdFileCount = 0;
+  const materializedItems = items.map((rawItem, index) => {
+    const item = isPlainObject(rawItem) ? { ...rawItem } : {};
+    const feedbackId = stableItemId(item, ["feedback_id", "id"], `F${String(index + 1).padStart(3, "0")}`);
+    const conversationTurns = normalizeFeedbackConversationTurns(item.conversation_turns);
+    const prdText = String(item.prd_text || "").trim();
+
+    let contextSource = "description_only";
+    let contextNote = "No separate PRD. Use feedback_text as the context for this feedback item.";
+    let prdFile = null;
+
+    if (prdText) {
+      const prdFilename = `${sanitizeFileSegment(feedbackId, `feedback-${index + 1}`)}.md`;
+      const prdPath = path.join(prdSyncDir, prdFilename);
+      writeTextFile(prdPath, ensureTrailingNewline(prdText));
+      prdFile = toPosixRelativePath(targetRoot, prdPath);
+      contextSource = "prd_file";
+      contextNote = "Full PRD context is stored in the linked file.";
+      prdFileCount += 1;
+    } else if (item.has_prd_text) {
+      contextSource = "prd_declared_but_unavailable";
+      contextNote = "A separate PRD exists for this feedback item, but readable PRD text was not included in this sync snapshot.";
+    }
+
+    return {
+      ...item,
+      feedback_id: feedbackId,
+      conversation_turns: conversationTurns,
+      context_source: contextSource,
+      context_note: contextNote,
+      prd_file: prdFile,
+    };
+  });
+  const snapshotCounts = snapshot.counts && typeof snapshot.counts === "object"
+    ? { ...snapshot.counts }
+    : { total_feedback: materializedItems.length };
+  snapshotCounts.with_prd_files = prdFileCount;
+  if (snapshotCounts.with_conversation_turns === undefined) {
+    snapshotCounts.with_conversation_turns = materializedItems.filter((item) => Array.isArray(item?.conversation_turns) && item.conversation_turns.length > 0).length;
+  }
+
   const payload = scrubBootstrapValue({
-    schema_version: snapshot.schema_version || 1,
+    schema_version: snapshot.schema_version || 2,
     project: snapshot.project || null,
     repo_names: Array.isArray(snapshot.repo_names) ? snapshot.repo_names : [],
     filters: snapshot.filters && typeof snapshot.filters === "object" ? snapshot.filters : {},
-    counts: snapshot.counts && typeof snapshot.counts === "object"
-      ? snapshot.counts
-      : { total_feedback: items.length },
-    queue: items
+    counts: snapshotCounts,
+    artifacts: {
+      feedback_prd_root: "PRD/feedback-sync",
+      with_prd_files: prdFileCount,
+    },
+    queue: materializedItems
       .filter((item) => String(item?.status || "").trim().toLowerCase() !== "resolved")
       .map((item, index) => ({
         feedback_id: stableItemId(item, ["feedback_id", "id"], `F${String(index + 1).padStart(3, "0")}`),
@@ -1920,7 +2034,11 @@ function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
         priority: item?.priority || null,
         title: item?.title || null,
       })),
-    items,
+    items: materializedItems.map((item) => {
+      const nextItem = { ...item };
+      delete nextItem.prd_text;
+      return nextItem;
+    }),
     pagination: snapshot.pagination && typeof snapshot.pagination === "object" ? snapshot.pagination : undefined,
     generated_at: snapshot.generated_at || null,
     snapshot_hash: snapshot.snapshot_hash || null,
@@ -1930,6 +2048,7 @@ function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
   return {
     targetRoot,
     dataRoot,
+    prdSyncDir,
     manifest: payload,
   };
 }
@@ -2998,6 +3117,7 @@ async function runFeedbackSync(args) {
     status: firstNonEmptyString(args.status) || "Pending",
     source: firstNonEmptyString(args.source) || "",
     includePrdText,
+    includeCommentTurns: true,
   };
 
   let snapshot;
@@ -3053,7 +3173,7 @@ async function runFeedbackSync(args) {
       console.log(`Configured repos: ${summary.repo_names.join(", ") || "(none)"}`);
       console.log(`Found locally: ${summary.local.found.join(", ") || "(none)"}`);
       if (summary.local.missing.length) console.log(`Missing locally: ${summary.local.missing.join(", ")}`);
-      console.log(`Counts: total_feedback=${summary.counts.total_feedback || 0}, with_prd_text=${summary.counts.with_prd_text || 0}`);
+      console.log(`Counts: total_feedback=${summary.counts.total_feedback || 0}, with_prd_text=${summary.counts.with_prd_text || 0}, with_conversation_turns=${summary.counts.with_conversation_turns || 0}`);
       console.log("Dry run only - no files written.");
     }
     return;
@@ -3061,6 +3181,9 @@ async function runFeedbackSync(args) {
 
   const writeResult = writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir });
   summary.data_root = writeResult.dataRoot;
+  summary.prd_root = writeResult.prdSyncDir;
+  summary.counts = writeResult.manifest?.counts || summary.counts;
+  summary.artifacts = writeResult.manifest?.artifacts || null;
 
   if (args.json) {
     console.log(JSON.stringify(summary, null, 2));
@@ -3073,7 +3196,8 @@ async function runFeedbackSync(args) {
   console.log(`Configured repos: ${summary.repo_names.join(", ") || "(none)"}`);
   console.log(`Found locally: ${summary.local.found.join(", ") || "(none)"}`);
   if (summary.local.missing.length) console.log(`Missing locally: ${summary.local.missing.join(", ")}`);
-  console.log(`Wrote feedback: total_feedback=${summary.counts.total_feedback || 0}, with_prd_text=${summary.counts.with_prd_text || 0}`);
+  console.log(`Wrote feedback: total_feedback=${summary.counts.total_feedback || 0}, with_prd_text=${summary.counts.with_prd_text || 0}, with_conversation_turns=${summary.counts.with_conversation_turns || 0}`);
+  console.log(`PRD root: ${summary.prd_root}`);
   console.log(`Snapshot: ${summary.snapshot_hash || "n/a"}`);
 }
 
@@ -3509,6 +3633,111 @@ async function runSuggestions(args) {
   process.exit(1);
 }
 
+async function runAi(args) {
+  const key = getMyteAiKey(process.env);
+  if (!key) {
+    console.error("Missing MYTEAI_API_KEY in environment/.env");
+    process.exit(1);
+  }
+
+  const printContext = Boolean(args["print-context"] || args.printContext || args["dry-run"] || args.dryRun);
+  const timeoutMs = resolveTimeoutMs(args);
+  const baseRaw = args["base-url"] || args.baseUrl || args.base_url || process.env.MYTEAI_API_BASE || process.env.MYTE_AI_API_BASE || DEFAULT_MYTEAI_BASE;
+  const apiBase = normalizeMyteAiBase(baseRaw);
+  const jsonResponse = Boolean(args["json-response"] || args.jsonResponse || args.json_response);
+  const payloadFile = firstNonEmptyString(args["payload-file"], args.payloadFile, args.payload_file);
+
+  let payload;
+  if (payloadFile) {
+    const absPath = resolveInputFile(payloadFile, "AI payload");
+    try {
+      payload = JSON.parse(String(fs.readFileSync(absPath, "utf8") || ""));
+    } catch (err) {
+      console.error(`AI payload must be valid JSON: ${err?.message || err}`);
+      process.exit(1);
+    }
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+      console.error("AI payload file must contain one JSON object.");
+      process.exit(1);
+    }
+    if (jsonResponse && payload.myte_json_response === undefined) {
+      payload.myte_json_response = true;
+    }
+  } else {
+    const inlineQuery = firstNonEmptyString(args.query, args.q, Array.isArray(args._) ? args._.join(" ") : args._);
+    const useStdin = Boolean(args.stdin || (!process.stdin.isTTY && !inlineQuery));
+    let query = inlineQuery;
+    if (useStdin) {
+      query = String((await readStdinText()) || "").trim();
+    }
+    if (!query) {
+      console.error("Missing AI query text.");
+      printHelp();
+      process.exit(1);
+    }
+    payload = buildSimpleAiPayload({
+      query,
+      jsonResponse,
+      maxOutputTokens: firstNonEmptyString(args["max-output-tokens"], args.maxOutputTokens, args.max_output_tokens, args["max-tokens"], args.maxTokens, args.max_tokens),
+      temperature: firstNonEmptyString(args.temperature),
+    });
+  }
+
+  if (printContext) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  const fetchFn = await getFetch();
+  let responseBody;
+  try {
+    responseBody = await callMyteAiChat({
+      fetchFn,
+      apiBase,
+      apiKey: key,
+      payload,
+      timeoutMs,
+    });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      console.error(`Request timed out after ${timeoutMs}ms`);
+    } else {
+      console.error("Myte AI request failed:", err?.message || err);
+    }
+    process.exit(1);
+  }
+
+  let content = extractAssistantTextFromChatCompletion(responseBody);
+  let normalizedJson = null;
+  if (jsonResponse) {
+    try {
+      normalizedJson = normalizeJsonAssistantText(content);
+      content = normalizedJson.text;
+    } catch {
+      content = String(content || "").trim();
+    }
+  }
+
+  if (args.json) {
+    console.log(
+      JSON.stringify(
+        {
+          id: responseBody.id || null,
+          model: responseBody.model || null,
+          usage: responseBody.usage || null,
+          content,
+          parsed_json: normalizedJson ? normalizedJson.parsed : null,
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  console.log(content || "");
+}
+
 async function runQuery(args) {
   const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
   if (!key) {
@@ -3629,6 +3858,11 @@ async function main() {
     return;
   }
 
+  if (command === "ai") {
+    await runAi(args);
+    return;
+  }
+
   if (command === "bootstrap") {
     await runBootstrap(args);
     return;

package/lib/ai-gateway.js

@@ -0,0 +1,112 @@
+"use strict";
+
+const DEFAULT_MYTEAI_BASE = "https://api.myte.ai/v1";
+
+function normalizeMyteAiBase(baseRaw) {
+  const baseTrim = String(baseRaw || "").trim().replace(/\/+$/, "");
+  const base = baseTrim || DEFAULT_MYTEAI_BASE;
+  return /\/v1$/i.test(base) ? base : `${base}/v1`;
+}
+
+function getMyteAiKey(env = process.env) {
+  return String(env.MYTEAI_API_KEY || env.MYTE_AI_API_KEY || "").trim();
+}
+
+function buildSimpleAiPayload({ query, jsonResponse = false, maxOutputTokens, temperature }) {
+  const payload = {
+    messages: [{ role: "user", content: String(query || "").trim() }],
+  };
+  if (jsonResponse) payload.myte_json_response = true;
+  if (Number.isFinite(Number(maxOutputTokens)) && Number(maxOutputTokens) > 0) {
+    payload.max_tokens = Number(maxOutputTokens);
+  }
+  if (temperature !== undefined && temperature !== null && temperature !== "") {
+    const parsed = Number(temperature);
+    if (Number.isFinite(parsed)) payload.temperature = parsed;
+  }
+  return payload;
+}
+
+function extractAssistantTextFromChatCompletion(payload) {
+  const choices = Array.isArray(payload?.choices) ? payload.choices : [];
+  const first = choices[0] && typeof choices[0] === "object" ? choices[0] : {};
+  const message = first.message && typeof first.message === "object" ? first.message : {};
+  const content = message.content;
+  if (typeof content === "string") return content.trim();
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        if (typeof item === "string") return item;
+        if (!item || typeof item !== "object") return "";
+        if (typeof item.text === "string") return item.text;
+        if (typeof item.content === "string") return item.content;
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n")
+      .trim();
+  }
+  return "";
+}
+
+function stripJsonFences(text) {
+  const raw = String(text || "").trim();
+  const match = raw.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  if (match) return String(match[1] || "").trim();
+  return raw;
+}
+
+function normalizeJsonAssistantText(text) {
+  const stripped = stripJsonFences(text);
+  const parsed = JSON.parse(stripped);
+  return {
+    parsed,
+    text: JSON.stringify(parsed, null, 2),
+  };
+}
+
+async function callMyteAiChat({ fetchFn, apiBase, apiKey, payload, timeoutMs }) {
+  const controller = typeof AbortController !== "undefined" ? new AbortController() : undefined;
+  const timeoutId =
+    controller && timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+  try {
+    const response = await fetchFn(`${apiBase}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      signal: controller?.signal,
+      body: JSON.stringify(payload),
+    });
+    const text = await response.text();
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch (error) {
+      const err = new Error(`Non-JSON response (${response.status}): ${text.slice(0, 500)}`);
+      err.status = response.status;
+      throw err;
+    }
+    if (!response.ok) {
+      const err = new Error(body?.error?.message || body?.message || `Request failed (${response.status})`);
+      err.status = response.status;
+      err.body = body;
+      throw err;
+    }
+    return body;
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+
+module.exports = {
+  DEFAULT_MYTEAI_BASE,
+  buildSimpleAiPayload,
+  callMyteAiChat,
+  extractAssistantTextFromChatCompletion,
+  getMyteAiKey,
+  normalizeJsonAssistantText,
+  normalizeMyteAiBase,
+  stripJsonFences,
+};

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.14",
-  "description": "Myte CLI core implementation (Project Assistant + deterministic diffs).",
+  "version": "0.0.16",
+  "description": "Myte CLI core implementation (Project Assistant + Myte AI gateway).",
   "type": "commonjs",
   "main": "cli.js",
   "files": [
     "README.md",
     "cli.js",
+    "lib",
     "package.json"
   ],
   "scripts": {