@mytegroupinc/myte-core 0.0.46 → 0.0.49

package/scripts/project-assistant-read-certification.js

@@ -0,0 +1,258 @@
+#!/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 { randomUUID } = require("node:crypto");
+
+const CLI_PATH = path.resolve(__dirname, "..", "cli.js");
+
+const ROUTE_MATRIX = [
+  { id: "doctor", kind: "transport", mutation: "none" },
+  { id: "config", kind: "read", mutation: "none" },
+  { id: "bootstrap", kind: "read/local-sync", mutation: "local_temp_only" },
+  { id: "feedback-sync", kind: "read/local-sync", mutation: "local_temp_only" },
+  { id: "sync-qaqc", kind: "read/local-sync", mutation: "local_temp_only" },
+  { id: "suggestions-sync", kind: "read/local-sync", mutation: "local_temp_only" },
+  { id: "feedback-get", kind: "read", mutation: "none", conditional: "feedback_id" },
+  { id: "feedback-history", kind: "read", mutation: "none", conditional: "feedback_id" },
+  { id: "feedback-prd-versions", kind: "read", mutation: "none", conditional: "feedback_id" },
+  { id: "feedback-prd-diff", kind: "read", mutation: "none", conditional: "version_id" },
+  { id: "query", kind: "inference-job", mutation: "ephemeral_job", conditional: "--include-query" },
+];
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) continue;
+    const key = token.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+    } else {
+      args[key] = next;
+      index += 1;
+    }
+  }
+  return args;
+}
+
+function parseJsonOutput(result, command) {
+  const text = String(result.stdout || "").trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${command} did not return JSON.`);
+  }
+}
+
+function safeCommandLabel(args) {
+  if (args[0] === "feedback") {
+    return `myte feedback ${String(args[1] || "").trim() || "<subcommand>"}`;
+  }
+  if (args[0] === "suggestions") {
+    return `myte suggestions ${String(args[1] || "").trim() || "<subcommand>"}`;
+  }
+  if (args[0] === "query") {
+    return "myte query <redacted>";
+  }
+  return `myte ${String(args[0] || "").trim() || "<command>"}`;
+}
+
+function runCli(args, { cwd, timeoutMs = 360000 } = {}) {
+  const started = Date.now();
+  const result = spawnSync(process.execPath, [CLI_PATH, ...args], {
+    cwd,
+    env: process.env,
+    encoding: "utf8",
+    timeout: timeoutMs,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  const command = safeCommandLabel(args);
+  const parsed = parseJsonOutput(result, command);
+  return {
+    id: command.replace(/^myte\s+/, "").replace(/\s+/g, "-"),
+    command,
+    ok: result.status === 0,
+    exit_code: result.status,
+    duration_ms: Date.now() - started,
+    data: parsed,
+    error: result.status === 0
+      ? null
+      : String(result.stderr || parsed?.message || "Command failed.").trim().slice(0, 2000),
+  };
+}
+
+function firstFeedbackId(feedbackPath) {
+  if (!fs.existsSync(feedbackPath)) return null;
+  const text = fs.readFileSync(feedbackPath, "utf8");
+  const match = text.match(/^\s*(?:-\s+)?feedback_id:\s*["']?([^"'\s]+)["']?\s*$/m);
+  return match ? match[1] : null;
+}
+
+function versionIdentifier(version) {
+  return String(version?.version_id || version?._id || "").trim() || null;
+}
+
+function versionDocumentIdentifier(version) {
+  const documentSet =
+    version?.prd_document_set && typeof version.prd_document_set === "object"
+      ? version.prd_document_set
+      : null;
+  const documents = Array.isArray(version?.prd_documents)
+    ? version.prd_documents
+    : Array.isArray(documentSet?.documents)
+      ? documentSet.documents
+      : [];
+  return String(
+    version?.primary_document_id
+      || documentSet?.primary_document_id
+      || documents[0]?.document_id
+      || "",
+  ).trim() || null;
+}
+
+function baseArgs(args) {
+  const result = [];
+  if (args["base-url"]) result.push("--base-url", String(args["base-url"]));
+  result.push("--timeout-ms", String(args["timeout-ms"] || 300000));
+  return result;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args["confirm-read"]) {
+    console.log(JSON.stringify({
+      ok: true,
+      dry_run: true,
+      message: "No network or project mutation was performed.",
+      route_matrix: ROUTE_MATRIX,
+      mutation_harnesses: [
+        "feedback-live-full-harness.js",
+        "mission-live-full-harness.js",
+        "mission-live-disposable-harness.js",
+      ],
+    }, null, 2));
+    return;
+  }
+  if (!process.env.MYTE_API_KEY && !process.env.MYTE_PROJECT_API_KEY) {
+    throw new Error("Missing MYTE_API_KEY or MYTE_PROJECT_API_KEY.");
+  }
+
+  const runId = String(args["run-id"] || randomUUID());
+  const workspace = path.resolve(
+    args.workspace || fs.mkdtempSync(path.join(os.tmpdir(), `myte-read-cert-${runId}-`)),
+  );
+  const outputDir = path.join(workspace, "MyteCommandCenter");
+  fs.mkdirSync(workspace, { recursive: true });
+  const shared = baseArgs(args);
+  const checks = [];
+
+  const doctor = runCli(["doctor", "--json", ...shared], { cwd: workspace, timeoutMs: 60000 });
+  checks.push({ ...doctor, data: doctor.data ? {
+    ok: doctor.data.ok,
+    failure_layer: doctor.data.failure_layer,
+    runtime: doctor.data.runtime,
+    api: doctor.data.api,
+    project_key: doctor.data.project_key,
+    proxy: doctor.data.proxy,
+    dns: doctor.data.dns,
+    direct_transport: doctor.data.direct_transport,
+    config_probe: doctor.data.config_probe,
+  } : null });
+  if (!doctor.ok) {
+    console.log(JSON.stringify({
+      ok: false,
+      run_id: runId,
+      workspace,
+      stopped_at: "doctor",
+      failure_layer: doctor.data?.failure_layer || "unknown",
+      checks,
+    }, null, 2));
+    process.exit(1);
+  }
+
+  checks.push(runCli(["config", "--json", ...shared], { cwd: workspace }));
+  checks.push(runCli(["bootstrap", "--output-dir", outputDir, "--json", ...shared], { cwd: workspace }));
+  checks.push(runCli(["feedback-sync", "--output-dir", outputDir, "--json", ...shared], { cwd: workspace }));
+  checks.push(runCli(["sync-qaqc", "--output-dir", outputDir, "--json", ...shared], { cwd: workspace }));
+  checks.push(runCli(["suggestions", "sync", "--output-dir", outputDir, "--json", ...shared], { cwd: workspace }));
+
+  const feedbackId = firstFeedbackId(path.join(outputDir, "data", "feedback.yml"));
+  if (feedbackId) {
+    checks.push(runCli(["feedback", "get", "--feedback-id", feedbackId, "--json", ...shared], { cwd: workspace }));
+    checks.push(runCli(["feedback", "history", "--feedback-id", feedbackId, "--json", ...shared], { cwd: workspace }));
+    const versionsCheck = runCli(
+      ["feedback", "prd-versions", "--feedback-id", feedbackId, "--json", ...shared],
+      { cwd: workspace },
+    );
+    checks.push(versionsCheck);
+    if (versionsCheck.ok) {
+      const versions = Array.isArray(versionsCheck.data?.versions)
+        ? versionsCheck.data.versions
+        : [];
+      const activeVersionId = String(
+        versionsCheck.data?.active_prd_version_id || "",
+      ).trim();
+      const targetVersion =
+        versions.find((version) => versionIdentifier(version) !== activeVersionId)
+        || versions[0];
+      const targetVersionId = versionIdentifier(targetVersion);
+      if (targetVersionId) {
+        const diffArgs = [
+          "feedback",
+          "prd-diff",
+          "--feedback-id",
+          feedbackId,
+          "--version-id",
+          targetVersionId,
+        ];
+        const documentId = versionDocumentIdentifier(targetVersion);
+        if (documentId) diffArgs.push("--document-id", documentId);
+        diffArgs.push("--json", ...shared);
+        checks.push(runCli(diffArgs, { cwd: workspace }));
+      }
+    }
+  }
+
+  if (args["include-query"]) {
+    checks.push(runCli([
+      "query",
+      "Goal: certify Project Assistant query transport. Ask: return the project title in one sentence.",
+      "--request-id",
+      `cert-read-${runId}`,
+      "--json",
+      ...shared,
+    ], { cwd: workspace }));
+  }
+
+  const failed = checks.filter((check) => !check.ok);
+  console.log(JSON.stringify({
+    ok: failed.length === 0,
+    run_id: runId,
+    workspace,
+    local_artifacts_only: true,
+    live_business_mutations: false,
+    checks: checks.map((check) => ({
+      id: check.id,
+      command: check.command,
+      ok: check.ok,
+      exit_code: check.exit_code,
+      duration_ms: check.duration_ms,
+      error: check.error,
+    })),
+    failed_count: failed.length,
+  }, null, 2));
+  if (failed.length) process.exit(1);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(JSON.stringify({ ok: false, message: error?.message || String(error) }, null, 2));
+  process.exit(1);
+}