@mytegroupinc/myte-core 0.0.28 → 0.0.30

package/lib/ai-gateway.js

@@ -1,115 +1,115 @@
-"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;
-    payload.response_format = { type: "json_object" };
-  }
-  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,
-};
+"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;
+    payload.response_format = { type: "json_object" };
+  }
+  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,28 +1,28 @@
-{
-  "name": "@mytegroupinc/myte-core",
-  "version": "0.0.28",
-  "description": "Myte CLI core implementation.",
-  "type": "commonjs",
-  "main": "cli.js",
-  "files": [
-    "README.md",
-    "cli.js",
-    "lib",
-    "scripts",
-    "package.json"
-  ],
-  "scripts": {
-    "test": "node --test"
-  },
-  "license": "MIT",
-  "engines": {
-    "node": ">=18"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "yaml": "^2.8.1"
-  }
-}
+{
+  "name": "@mytegroupinc/myte-core",
+  "version": "0.0.30",
+  "description": "Myte CLI core implementation.",
+  "type": "commonjs",
+  "main": "cli.js",
+  "files": [
+    "README.md",
+    "cli.js",
+    "lib",
+    "scripts",
+    "package.json"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "yaml": "^2.8.1"
+  }
+}

package/scripts/feedback-live-full-harness.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const CLI_PATH = path.resolve(__dirname, "..", "cli.js");
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) {
+      args._.push(token);
+      continue;
+    }
+    const key = token.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+      continue;
+    }
+    args[key] = next;
+    index += 1;
+  }
+  return args;
+}
+
+function requireConfirm(args) {
+  if (!args["confirm-live"]) {
+    throw new Error("Refusing live feedback mutations. Re-run with --confirm-live after backend/web deploy.");
+  }
+  if (!process.env.MYTE_API_KEY && !process.env.MYTE_PROJECT_API_KEY) {
+    throw new Error("Missing MYTE_API_KEY or MYTE_PROJECT_API_KEY.");
+  }
+}
+
+function runCli(cliArgs, cwd, { allowFailure = false } = {}) {
+  const result = spawnSync(process.execPath, [CLI_PATH, ...cliArgs], {
+    cwd,
+    env: process.env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  const stdout = String(result.stdout || "").trim();
+  let parsed = {};
+  if (stdout) {
+    try {
+      parsed = JSON.parse(stdout);
+    } catch (err) {
+      throw new Error(`Expected JSON from myte ${cliArgs.join(" ")}:\n${stdout}`);
+    }
+  }
+  if (result.status !== 0 && !allowFailure) {
+    throw new Error([
+      `Command failed: myte ${cliArgs.join(" ")}`,
+      result.stderr || stdout || "(no output)",
+    ].join("\n"));
+  }
+  return { status: result.status, stdout: parsed, stderr: String(result.stderr || "").trim() };
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function writePrd(workspace, title, index) {
+  const filePath = path.join(workspace, `feedback-live-harness-${index}.md`);
+  fs.writeFileSync(
+    filePath,
+    [
+      `# ${title}`,
+      "",
+      "## Goal",
+      "Disposable Feedback item created by the reusable live Feedback API harness.",
+      "",
+      "## Acceptance Criteria",
+      "- Feedback can be created from markdown.",
+      "- Feedback can enter the review membrane.",
+      "- Feedback can be batch-reviewed.",
+      "- Feedback can be batch-moved between active states.",
+      "- Feedback can be batch-archived and disappears from normal sync.",
+    ].join("\n"),
+    "utf8",
+  );
+  return filePath;
+}
+
+function loadFeedbackManifest(workspace) {
+  const manifestPath = path.join(workspace, "MyteCommandCenter", "data", "feedback.yml");
+  if (!fs.existsSync(manifestPath)) {
+    return { items: [] };
+  }
+  const text = fs.readFileSync(manifestPath, "utf8");
+  try {
+    const parsed = JSON.parse(text);
+    const items = []
+      .concat(Array.isArray(parsed.items) ? parsed.items : [])
+      .concat(Array.isArray(parsed.queue) ? parsed.queue : []);
+    return { items };
+  } catch (_err) {
+    // Older local files may still be YAML-like. Keep a small fallback parser so
+    // the harness can validate either shape without adding runtime deps.
+  }
+  const items = [];
+  let current = null;
+  for (const line of text.split(/\r?\n/)) {
+    const feedbackMatch = line.match(/^\s*-\s+feedback_id:\s*["']?([^"'\s]+)["']?\s*$/) || line.match(/^\s*feedback_id:\s*["']?([^"'\s]+)["']?\s*$/);
+    if (feedbackMatch) {
+      if (current) items.push(current);
+      current = { feedback_id: feedbackMatch[1] };
+      continue;
+    }
+    if (!current) continue;
+    const stateMatch = line.match(/^\s*feedback_state:\s*["']?([^"']+)["']?\s*$/);
+    if (stateMatch) {
+      current.feedback_state = stateMatch[1].trim();
+      continue;
+    }
+    const statusMatch = line.match(/^\s*status:\s*["']?([^"']+)["']?\s*$/);
+    if (statusMatch) {
+      current.status = statusMatch[1].trim();
+    }
+  }
+  if (current) items.push(current);
+  return { items };
+}
+
+function findFeedbackState(workspace, feedbackId) {
+  const manifest = loadFeedbackManifest(workspace);
+  const matches = (manifest.items || []).filter((candidate) => String(candidate.feedback_id || candidate.id || "") === String(feedbackId));
+  const item = [...matches].reverse().find((candidate) => candidate.feedback_state) || matches[matches.length - 1];
+  if (!item) return null;
+  const state = String(item.feedback_state || "").trim();
+  if (state) return state;
+  const status = String(item.status || "").trim().toLowerCase();
+  if (status === "pending") return "todo";
+  if (status === "resolved") return "completed";
+  if (status === "ignored") return "rejected";
+  if (status === "archived") return "archived";
+  return status || null;
+}
+
+function assertFeedbackPresent(workspace, feedbackIds, expectedState) {
+  for (const feedbackId of feedbackIds) {
+    const state = findFeedbackState(workspace, feedbackId);
+    assert(state, `Expected feedback ${feedbackId} to be present in feedback-sync output.`);
+    if (expectedState) {
+      assert(state === expectedState, `Expected feedback ${feedbackId} state ${expectedState}, got ${state}.`);
+    }
+  }
+}
+
+function assertFeedbackAbsent(workspace, feedbackIds) {
+  const manifest = loadFeedbackManifest(workspace);
+  const syncedIds = new Set((manifest.items || []).map((item) => String(item.feedback_id || item.id || "")));
+  for (const feedbackId of feedbackIds) {
+    assert(!syncedIds.has(String(feedbackId)), `Archived feedback ${feedbackId} is still present in normal feedback-sync output.`);
+  }
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  requireConfirm(args);
+
+  const workspace = path.resolve(
+    args.workspace || fs.mkdtempSync(path.join(os.tmpdir(), "myte-feedback-full-harness-")),
+  );
+  fs.mkdirSync(workspace, { recursive: true });
+
+  const baseArgs = [];
+  if (args["base-url"]) {
+    baseArgs.push("--base-url", String(args["base-url"]));
+  }
+
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const reason = String(args.reason || "Disposable live Feedback harness verification");
+  const createdFeedbackIds = [];
+  const reviewRequestIds = [];
+
+  try {
+    const prdFiles = [];
+    for (let index = 1; index <= 5; index += 1) {
+      const title = `TEST Feedback Harness ${stamp} ${index}`;
+      prdFiles.push(writePrd(workspace, title, index));
+    }
+
+    const create = runCli([
+      "create-prd",
+      ...prdFiles,
+      "--description",
+      "Disposable TEST Feedback created by the live Feedback harness.",
+      "--json",
+      ...baseArgs,
+    ], workspace).stdout;
+
+    const createdItems = Array.isArray(create.items) ? create.items : [];
+    for (const item of createdItems) {
+      if (item.status === "created" && item.feedback_id) {
+        createdFeedbackIds.push(String(item.feedback_id));
+      }
+    }
+    assert(createdFeedbackIds.length === 5, `Expected 5 created TEST feedback items, got ${createdFeedbackIds.length}: ${JSON.stringify(create, null, 2)}`);
+
+    runCli(["feedback-sync", "--json", ...baseArgs], workspace);
+    assertFeedbackPresent(workspace, createdFeedbackIds, "todo");
+
+    for (const feedbackId of createdFeedbackIds) {
+      const draft = runCli([
+        "feedback",
+        "status",
+        "--feedback-id",
+        feedbackId,
+        "--status",
+        "completed",
+        "--reason",
+        reason,
+        "--json",
+        ...baseArgs,
+      ], workspace).stdout;
+      assert(draft.artifact_path, `feedback status did not return artifact_path for ${feedbackId}`);
+
+      const submit = runCli([
+        "feedback",
+        "submit",
+        "--file",
+        draft.artifact_path,
+        "--json",
+        ...baseArgs,
+      ], workspace).stdout;
+      const requestId = String(submit.request?.request_id || submit.request?._id || "");
+      assert(requestId, `feedback submit did not return request id for ${feedbackId}: ${JSON.stringify(submit, null, 2)}`);
+      reviewRequestIds.push(requestId);
+    }
+
+    const blocked = runCli([
+      "feedback",
+      "move",
+      "--feedback-ids",
+      createdFeedbackIds.join(","),
+      "--from-state",
+      "todo",
+      "--to-state",
+      "in_progress",
+      "--reason",
+      "Harness should be blocked while review is pending.",
+      "--no-sync",
+      "--json",
+      ...baseArgs,
+    ], workspace, { allowFailure: true }).stdout;
+    assert(blocked.ok === false, "Batch direct feedback move unexpectedly succeeded while reviews were pending.");
+    assert(blocked.status === 409, `Expected 409 pending review block, got ${blocked.status}.`);
+    assert(blocked.data?.code === "pending_feedback_review", `Expected pending_feedback_review, got ${JSON.stringify(blocked, null, 2)}.`);
+
+    const review = runCli([
+      "feedback",
+      "review",
+      "--request-ids",
+      reviewRequestIds.join(","),
+      "--action",
+      "approve",
+      "--reason",
+      "Harness batch approval.",
+      "--json",
+      ...baseArgs,
+    ], workspace).stdout;
+    assert(review.ok !== false && review.updated_count === 5, `batch review failed: ${JSON.stringify(review, null, 2)}`);
+
+    runCli(["feedback-sync", "--json", ...baseArgs], workspace);
+    assertFeedbackPresent(workspace, createdFeedbackIds, "completed");
+
+    const reopen = runCli([
+      "feedback",
+      "move",
+      "--feedback-ids",
+      createdFeedbackIds.join(","),
+      "--from-state",
+      "completed",
+      "--to-state",
+      "in_progress",
+      "--reason",
+      "Harness active-state batch reopen.",
+      "--json",
+      ...baseArgs,
+    ], workspace).stdout;
+    assert(reopen.ok !== false && reopen.updated_count === 5, `batch active move failed: ${JSON.stringify(reopen, null, 2)}`);
+
+    runCli(["feedback-sync", "--json", ...baseArgs], workspace);
+    assertFeedbackPresent(workspace, createdFeedbackIds, "in_progress");
+
+    const archive = runCli([
+      "feedback",
+      "move",
+      "--feedback-ids",
+      createdFeedbackIds.join(","),
+      "--from-state",
+      "in_progress",
+      "--to-state",
+      "archived",
+      "--reason",
+      "Harness cleanup archive.",
+      "--json",
+      ...baseArgs,
+    ], workspace).stdout;
+    assert(archive.ok !== false && archive.updated_count === 5, `batch archive failed: ${JSON.stringify(archive, null, 2)}`);
+
+    runCli(["feedback-sync", "--json", ...baseArgs], workspace);
+    assertFeedbackAbsent(workspace, createdFeedbackIds);
+
+    const unarchive = runCli([
+      "feedback",
+      "move",
+      "--feedback-id",
+      createdFeedbackIds[0],
+      "--from-state",
+      "archived",
+      "--to-state",
+      "todo",
+      "--reason",
+      "Harness verifies project-key unarchive is blocked.",
+      "--no-sync",
+      "--json",
+      ...baseArgs,
+    ], workspace, { allowFailure: true }).stdout;
+    assert(unarchive.ok === false, "Project-key Feedback unarchive unexpectedly succeeded.");
+    assert(unarchive.status === 403, `Expected project-key unarchive to return 403, got ${unarchive.status}.`);
+    assert(unarchive.data?.code === "feedback_unarchive_not_supported_project_api", `Unexpected unarchive error: ${JSON.stringify(unarchive, null, 2)}`);
+
+    console.log(JSON.stringify({
+      ok: true,
+      workspace,
+      created_feedback_ids: createdFeedbackIds,
+      review_request_ids: reviewRequestIds,
+      pending_review_batch_block_verified: true,
+      batch_review_verified: true,
+      batch_active_move_verified: true,
+      batch_archive_verified: true,
+      archived_sync_exclusion_verified: true,
+      project_key_unarchive_block_verified: true,
+    }, null, 2));
+  } catch (err) {
+    if (createdFeedbackIds.length) {
+      try {
+        runCli([
+          "feedback",
+          "move",
+          "--feedback-ids",
+          createdFeedbackIds.join(","),
+          "--to-state",
+          "archived",
+          "--reason",
+          "Harness best-effort cleanup after failure.",
+          "--json",
+          ...baseArgs,
+        ], workspace, { allowFailure: true });
+      } catch (_cleanupErr) {
+        // Keep the original error. Cleanup is best effort and must not hide failure evidence.
+      }
+    }
+    const failure = {
+      ok: false,
+      workspace,
+      created_feedback_ids: createdFeedbackIds,
+      review_request_ids: reviewRequestIds,
+      message: err?.message || String(err),
+    };
+    console.error(JSON.stringify(failure, null, 2));
+    process.exit(1);
+  }
+}
+
+main();