@mytegroupinc/myte-core 0.0.49 → 0.0.50

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

@@ -21,6 +21,12 @@ const ROUTE_MATRIX = [
   { 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" },
+  {
+    id: "query-with-diff",
+    kind: "inference-job",
+    mutation: "temporary_tracked_fixture_and_ephemeral_job",
+    conditional: "--include-diff-query",
+  },
 ];
 
 function parseArgs(argv) {
@@ -87,6 +93,189 @@ function runCli(args, { cwd, timeoutMs = 360000 } = {}) {
   };
 }
 
+function runGit(args, cwd) {
+  const result = spawnSync("git", args, {
+    cwd,
+    env: process.env,
+    encoding: "utf8",
+    timeout: 60000,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  return {
+    ok: result.status === 0,
+    exit_code: result.status,
+    stdout: String(result.stdout || ""),
+    stderr: String(result.stderr || "").trim(),
+  };
+}
+
+function resolveDiffFixture(configData) {
+  const local = configData?.local && typeof configData.local === "object"
+    ? configData.local
+    : {};
+  const root = String(local.root || "").trim();
+  const found = Array.isArray(local.found) ? local.found.map(String) : [];
+  if (!root || !found.length) {
+    throw new Error("Diff certification requires at least one resolved configured repository.");
+  }
+
+  for (const repoName of found) {
+    const repoPath = path.resolve(root, repoName);
+    const status = runGit(["status", "--porcelain"], repoPath);
+    if (!status.ok || status.stdout.trim()) continue;
+
+    const tracked = runGit(["ls-files"], repoPath);
+    if (!tracked.ok) continue;
+    const candidates = tracked.stdout
+      .split(/\r?\n/)
+      .map((item) => item.trim())
+      .filter(Boolean)
+      .filter((item) => /(^|\/)readme(?:\.[a-z0-9]+)?$/i.test(item));
+    for (const relativePath of candidates) {
+      const filePath = path.resolve(repoPath, relativePath);
+      if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+        return {
+          repoName,
+          repoPath,
+          relativePath,
+          filePath,
+        };
+      }
+    }
+  }
+  throw new Error(
+    "Diff certification requires a clean configured repository with a tracked README file.",
+  );
+}
+
+function runDiffCertification({
+  args,
+  configData,
+  runId,
+  workspace,
+  shared,
+}) {
+  const fixture = resolveDiffFixture(configData);
+  const marker = `MYTE_CERT_DIFF_${runId.replace(/[^A-Za-z0-9_]/g, "_")}`;
+  const original = fs.readFileSync(fixture.filePath);
+  const originalStatus = runGit(["status", "--porcelain"], fixture.repoPath);
+  let contextCheck = null;
+  let queryCheck = null;
+  let restoreError = null;
+
+  try {
+    const separator = original.length && !original.toString("utf8").endsWith("\n")
+      ? "\n"
+      : "";
+    fs.appendFileSync(
+      fixture.filePath,
+      `${separator}\n<!-- ${marker} -->\n`,
+      "utf8",
+    );
+    const diffLimit = String(args["diff-limit"] || 500000);
+    const prompt = [
+      "Goal: certify project-scoped diff ingestion.",
+      `Evidence marker: ${marker}.`,
+      `Ask: return the exact marker and name ${fixture.repoName}/${fixture.relativePath}.`,
+    ].join(" ");
+    const commonDiffArgs = [
+      "query",
+      prompt,
+      "--with-diff",
+      "--no-fetch",
+      "--diff-limit",
+      diffLimit,
+      ...shared,
+    ];
+    const rawContextCheck = runCli(
+      [...commonDiffArgs, "--print-context"],
+      { cwd: workspace },
+    );
+    const contextText = Array.isArray(rawContextCheck.data?.additional_context)
+      ? rawContextCheck.data.additional_context.join("\n")
+      : "";
+    const markerPresent = contextText.includes(marker);
+    const fetchDisabled =
+      rawContextCheck.data?.diff_diagnostics?.fetch_remote === false;
+    contextCheck = {
+      ...rawContextCheck,
+      id: "query-with-diff-context",
+      command: "myte query <redacted> --with-diff --print-context",
+      ok: rawContextCheck.ok && markerPresent && fetchDisabled,
+      error: rawContextCheck.ok && markerPresent && fetchDisabled
+        ? null
+        : rawContextCheck.error
+          || "Diff context did not contain the marker or --no-fetch was not honored.",
+      data: {
+        marker_present: markerPresent,
+        fetch_remote: rawContextCheck.data?.diff_diagnostics?.fetch_remote,
+        truncated: rawContextCheck.data?.diff_diagnostics?.truncated,
+        fixture_repo: fixture.repoName,
+        fixture_file: fixture.relativePath,
+      },
+    };
+
+    if (contextCheck.ok) {
+      const rawQueryCheck = runCli(
+        [
+          ...commonDiffArgs,
+          "--request-id",
+          `cert-diff-${runId}`.slice(0, 128),
+          "--json",
+        ],
+        { cwd: workspace },
+      );
+      const answer = String(rawQueryCheck.data?.answer || "");
+      const answerContainsMarker = answer.includes(marker);
+      queryCheck = {
+        ...rawQueryCheck,
+        id: "query-with-diff",
+        command: "myte query <redacted> --with-diff",
+        ok: rawQueryCheck.ok && answerContainsMarker,
+        error: rawQueryCheck.ok && answerContainsMarker
+          ? null
+          : rawQueryCheck.error
+            || "Live diff-query answer did not contain the exact fixture marker.",
+        data: {
+          marker_present_in_answer: answerContainsMarker,
+          job_id: rawQueryCheck.data?.job_id || null,
+          request_id: rawQueryCheck.data?.request_id || null,
+        },
+      };
+    }
+  } finally {
+    try {
+      fs.writeFileSync(fixture.filePath, original);
+      const restoredStatus = runGit(["status", "--porcelain"], fixture.repoPath);
+      if (
+        !restoredStatus.ok
+        || restoredStatus.stdout !== originalStatus.stdout
+      ) {
+        restoreError = "Diff fixture repository did not return to its original clean status.";
+      }
+    } catch (error) {
+      restoreError = error?.message || String(error);
+    }
+  }
+
+  const checks = [];
+  if (contextCheck) checks.push(contextCheck);
+  if (queryCheck) checks.push(queryCheck);
+  checks.push({
+    id: "query-with-diff-fixture-restore",
+    command: "restore temporary tracked diff fixture",
+    ok: !restoreError,
+    exit_code: restoreError ? 1 : 0,
+    duration_ms: 0,
+    data: {
+      fixture_repo: fixture.repoName,
+      fixture_file: fixture.relativePath,
+    },
+    error: restoreError,
+  });
+  return checks;
+}
+
 function firstFeedbackId(feedbackPath) {
   if (!fs.existsSync(feedbackPath)) return null;
   const text = fs.readFileSync(feedbackPath, "utf8");
@@ -176,7 +365,8 @@ function main() {
     process.exit(1);
   }
 
-  checks.push(runCli(["config", "--json", ...shared], { cwd: workspace }));
+  const config = runCli(["config", "--json", ...shared], { cwd: workspace });
+  checks.push(config);
   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 }));
@@ -230,6 +420,28 @@ function main() {
     ], { cwd: workspace }));
   }
 
+  if (args["include-diff-query"]) {
+    if (!config.ok) {
+      checks.push({
+        id: "query-with-diff",
+        command: "myte query <redacted> --with-diff",
+        ok: false,
+        exit_code: 1,
+        duration_ms: 0,
+        data: null,
+        error: "Project config failed; diff certification could not resolve a repository.",
+      });
+    } else {
+      checks.push(...runDiffCertification({
+        args,
+        configData: config.data,
+        runId,
+        workspace,
+        shared,
+      }));
+    }
+  }
+
   const failed = checks.filter((check) => !check.ok);
   console.log(JSON.stringify({
     ok: failed.length === 0,