semantic-js-mcp 0.8.0

package/scripts/ci-smoke.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+import {deepStrictEqual, strictEqual} from "node:assert";
+import {spawn} from "node:child_process";
+import {mkdtemp, rm, writeFile} from "node:fs/promises";
+import {tmpdir} from "node:os";
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+import {
+  CI_EXIT_CODE,
+  CI_STATUS,
+  COLLECTION_STATUS,
+  DIAGNOSTIC_SEVERITY,
+  EVIDENCE_STATUS,
+  PRESENTATION_MODE,
+  PRODUCT,
+  RESULT_SCHEMA,
+  SERVER_VERSION,
+  TOOL,
+} from "../protocol.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const evaluator = path.join(root, "scripts", "semantic-js-mcp-ci.mjs");
+const workspace = await mkdtemp(path.join(tmpdir(), "semantic-js-mcp-ci-smoke-"));
+
+function runEvaluator(inputFile) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [evaluator, inputFile], {stdio: ["ignore", "pipe", "pipe"]});
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => resolve({code, stdout, stderr}));
+  });
+}
+
+async function evaluate(name, input, expectedStatus, expectedExitCode) {
+  const file = path.join(workspace, `${name}.json`);
+  await writeFile(file, JSON.stringify(input));
+  const execution = await runEvaluator(file);
+  strictEqual(execution.stderr, "", `${name} wrote stderr`);
+  strictEqual(execution.code, expectedExitCode, `${name} returned the wrong process exit code`);
+  const result = JSON.parse(execution.stdout);
+  deepStrictEqual({status: result.status, exitCode: result.exitCode}, {status: expectedStatus, exitCode: expectedExitCode});
+}
+
+function canonicalResult(tool, collectionStatus, result, extra = {}) {
+  return {
+    server: {name: PRODUCT.NAME, version: SERVER_VERSION},
+    resultSchema: {name: RESULT_SCHEMA.NAME, version: RESULT_SCHEMA.VERSION},
+    tool,
+    request: {},
+    result,
+    collection: {status: collectionStatus},
+    presentation: {mode: PRESENTATION_MODE.ALL_ITEMS},
+    continueWith: [],
+    ...extra,
+  };
+}
+
+try {
+  await evaluate("pass", canonicalResult(TOOL.COUNT_REFERENCES, COLLECTION_STATUS.COMPLETE, {}), CI_STATUS.PASS, CI_EXIT_CODE.PASS);
+  await evaluate(
+    "fail",
+    canonicalResult(TOOL.DIAGNOSTICS, COLLECTION_STATUS.COMPLETE, {
+      evidence: {status: EVIDENCE_STATUS.VERIFIED},
+      diagnosticsForCurrentDocument: {items: [{severity: DIAGNOSTIC_SEVERITY.ERROR}]},
+    }),
+    CI_STATUS.FAIL,
+    CI_EXIT_CODE.FAIL,
+  );
+  await evaluate(
+    "untrusted",
+    canonicalResult(TOOL.DIAGNOSTICS, COLLECTION_STATUS.PARTIAL, {evidence: {status: EVIDENCE_STATUS.UNTRUSTED}}),
+    CI_STATUS.UNTRUSTED,
+    CI_EXIT_CODE.UNTRUSTED,
+  );
+  await evaluate(
+    "untrusted-diagnostics-cannot-pass-with-complete-collection",
+    canonicalResult(TOOL.DIAGNOSTICS, COLLECTION_STATUS.COMPLETE, {
+      evidence: {status: EVIDENCE_STATUS.UNTRUSTED},
+      diagnosticsForCurrentDocument: null,
+    }),
+    CI_STATUS.UNTRUSTED,
+    CI_EXIT_CODE.UNTRUSTED,
+  );
+  await evaluate(
+    "blocked",
+    canonicalResult(TOOL.REFERENCES, COLLECTION_STATUS.FAILED, {}, {error: {code: "fixture"}}),
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+  );
+  await evaluate(
+    "missing-canonical-identity",
+    {
+      tool: TOOL.COUNT_REFERENCES,
+      collection: {status: COLLECTION_STATUS.COMPLETE},
+      result: {},
+    },
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+  );
+  await evaluate(
+    "wrong-result-schema-version",
+    {
+      ...canonicalResult(TOOL.COUNT_REFERENCES, COLLECTION_STATUS.COMPLETE, {}),
+      resultSchema: {name: RESULT_SCHEMA.NAME, version: RESULT_SCHEMA.VERSION + 1},
+    },
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+  );
+  await evaluate(
+    "unknown-tool",
+    {
+      ...canonicalResult(TOOL.COUNT_REFERENCES, COLLECTION_STATUS.COMPLETE, {}),
+      tool: "unknown_tool",
+    },
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+  );
+  await evaluate(
+    "unknown-presentation-mode",
+    {
+      ...canonicalResult(TOOL.COUNT_REFERENCES, COLLECTION_STATUS.COMPLETE, {}),
+      presentation: {mode: "unknown-mode"},
+    },
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+  );
+  await evaluate(
+    "unknown-continuation-tool",
+    {
+      ...canonicalResult(TOOL.COUNT_REFERENCES, COLLECTION_STATUS.COMPLETE, {}),
+      continueWith: [{tool: "unknown_tool"}],
+    },
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+  );
+  process.stdout.write(`${JSON.stringify({ciStatuses: Object.values(CI_STATUS), exitCodes: CI_EXIT_CODE}, null, 2)}\n`);
+} finally {
+  await rm(workspace, {recursive: true, force: true});
+}

package/scripts/distribution-policy.mjs

@@ -0,0 +1,33 @@
+export const REQUIRED_PACKAGE_FILE = Object.freeze({
+  PACKAGE_MANIFEST: "package.json",
+  PRETTIER_CONFIGURATION: ".prettierrc.json",
+  README: "README.md",
+  LICENSE: "LICENSE",
+  CLI: "cli.mjs",
+  SERVER: "server.mjs",
+  PROTOCOL: "protocol.mjs",
+  RUNTIME: "lib/runtime.mjs",
+  DOCTOR: "lib/doctor.mjs",
+  MCP_CONFIGURATION: ".mcp.json",
+  CODEX_PLUGIN_MANIFEST: ".codex-plugin/plugin.json",
+  SEMANTIC_NAVIGATION_SKILL: "skills/semantic-navigation/SKILL.md",
+});
+
+export const NPM_AUTOMATIC_PACKAGE_FILE = Object.freeze([
+  REQUIRED_PACKAGE_FILE.PACKAGE_MANIFEST,
+  REQUIRED_PACKAGE_FILE.README,
+  REQUIRED_PACKAGE_FILE.LICENSE,
+]);
+
+const WINDOWS_PLATFORM = "win32";
+const WINDOWS_COMMAND_SUFFIX = ".cmd";
+
+export function npmExecutableName(name, platform = process.platform) {
+  if (platform === WINDOWS_PLATFORM) return `${name}${WINDOWS_COMMAND_SUFFIX}`;
+  return name;
+}
+
+export function packagePathIsAllowed(file, declaredFiles) {
+  if (NPM_AUTOMATIC_PACKAGE_FILE.includes(file)) return true;
+  return declaredFiles.some((entry) => (entry.endsWith("/") ? file.startsWith(entry) : file === entry));
+}

package/scripts/distribution-smoke.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+import {spawn} from "node:child_process";
+import {mkdtemp, mkdir, readFile, realpath, rm, writeFile} from "node:fs/promises";
+import {tmpdir} from "node:os";
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+import {
+  CLI_ARGUMENT,
+  CLI_MESSAGE,
+  PROCESS_EXIT_CODE,
+  DOCTOR_DISTRIBUTION_ACCEPTED_STATUS,
+  PRODUCT,
+  SERVER_VERSION,
+  NODE_EVENT,
+} from "../protocol.mjs";
+import {REQUIRED_PACKAGE_FILE, npmExecutableName, packagePathIsAllowed} from "./distribution-policy.mjs";
+
+const sourceRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const workspace = await mkdtemp(path.join(tmpdir(), `${PRODUCT.NAME}-distribution-smoke-`));
+const packageOutput = path.join(workspace, "package");
+const consumer = path.join(workspace, "consumer");
+const npmCache = path.join(workspace, "npm-cache");
+const npmCli = process.env.npm_execpath;
+const npmEnvironment = {...process.env, npm_config_cache: npmCache};
+
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {stdio: ["ignore", "pipe", "pipe"], ...options});
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on(NODE_EVENT.CLOSE, (exitCode) => resolve({exitCode, stdout, stderr}));
+  });
+}
+
+function runNpm(args, cwd) {
+  if (npmCli) return run(process.execPath, [npmCli, ...args], {cwd, env: npmEnvironment});
+  return run("npm", args, {cwd, env: npmEnvironment});
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+try {
+  await mkdir(packageOutput, {recursive: true});
+  await mkdir(consumer, {recursive: true});
+  await mkdir(npmCache, {recursive: true});
+  const packed = await runNpm(["pack", "--json", "--pack-destination", packageOutput], sourceRoot);
+  assert(packed.exitCode === 0, `npm pack failed: ${packed.stderr}`);
+  const packResult = JSON.parse(packed.stdout)[0];
+  const packedPaths = packResult.files.map((item) => item.path);
+  const sourceManifest = JSON.parse(await readFile(path.join(sourceRoot, "package.json"), "utf8"));
+  for (const requiredFile of Object.values(REQUIRED_PACKAGE_FILE)) {
+    assert(packedPaths.includes(requiredFile), `Tarball omitted required file: ${requiredFile}`);
+  }
+  for (const packedPath of packedPaths) {
+    assert(packagePathIsAllowed(packedPath, sourceManifest.files), `Tarball included a file outside the public allowlist: ${packedPath}`);
+  }
+
+  const tarball = path.join(packageOutput, packResult.filename);
+  await writeFile(path.join(consumer, "package.json"), JSON.stringify({private: true}));
+  const installed = await runNpm(["install", "--ignore-scripts", "--no-audit", "--no-fund", "--prefer-offline", tarball], consumer);
+  assert(installed.exitCode === 0, `Tarball installation failed: ${installed.stderr}`);
+
+  const installedRoot = await realpath(path.join(consumer, "node_modules", PRODUCT.NAME));
+  const binaryName = npmExecutableName(PRODUCT.NAME);
+  const binary = path.join(consumer, "node_modules", ".bin", binaryName);
+  const isolatedPath = (process.env.PATH || "")
+    .split(path.delimiter)
+    .filter((entry) => entry && !path.resolve(entry).startsWith(sourceRoot))
+    .join(path.delimiter);
+  const doctor = await run(binary, ["doctor"], {cwd: consumer, env: {...process.env, PATH: isolatedPath}});
+  const version = await run(binary, [CLI_ARGUMENT.VERSION], {cwd: consumer, env: {...process.env, PATH: isolatedPath}});
+  assert(
+    version.exitCode === PROCESS_EXIT_CODE.SUCCESS && version.stdout.trim() === SERVER_VERSION,
+    "Installed executable returned the wrong version",
+  );
+  const help = await run(binary, [CLI_ARGUMENT.HELP], {cwd: consumer, env: {...process.env, PATH: isolatedPath}});
+  assert(help.exitCode === PROCESS_EXIT_CODE.SUCCESS && help.stdout.includes(PRODUCT.NAME), "Installed executable did not return help");
+  const invalid = await run(binary, ["unknown-command"], {cwd: consumer, env: {...process.env, PATH: isolatedPath}});
+  assert(
+    invalid.exitCode === PROCESS_EXIT_CODE.FAILURE && invalid.stderr.includes(CLI_MESSAGE.UNKNOWN_COMMAND),
+    "Installed executable accepted an unknown command",
+  );
+  const doctorResult = JSON.parse(doctor.stdout);
+  assert(
+    DOCTOR_DISTRIBUTION_ACCEPTED_STATUS.includes(doctorResult.status),
+    `Installed doctor returned ${doctorResult.status}: ${JSON.stringify(doctorResult, null, 2)}\n${doctor.stderr}`,
+  );
+  assert((await realpath(doctorResult.installationRoot)) === installedRoot, "Doctor resolved runtime files outside the installed package");
+  const installedDependencyRoot = await realpath(path.join(consumer, "node_modules"));
+  for (const component of doctorResult.runtime.components) {
+    const componentFile = await realpath(component.file);
+    assert(
+      componentFile.startsWith(`${installedDependencyRoot}${path.sep}`),
+      `Runtime component resolved outside the installed dependency tree: ${component.file}`,
+    );
+    assert(!componentFile.startsWith(`${sourceRoot}${path.sep}`), `Runtime component reused the source checkout: ${component.file}`);
+  }
+  assert(!doctorResult.installationRoot.startsWith(sourceRoot), "Installed doctor reused the source checkout");
+
+  const installedManifest = JSON.parse(await readFile(path.join(installedRoot, "package.json"), "utf8"));
+  process.stdout.write(
+    `${JSON.stringify(
+      {
+        package: {name: installedManifest.name, version: installedManifest.version, filename: packResult.filename},
+        packedFiles: packedPaths.length,
+        unpackedBytes: packResult.unpackedSize,
+        installedRoot,
+        executable: {version: version.stdout.trim(), help: "ok", invalidCommand: "rejected"},
+        doctor: {status: doctorResult.status, exitCode: doctorResult.exitCode, checks: doctorResult.checks.length},
+        sourceCheckoutReused: false,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+} finally {
+  await rm(workspace, {recursive: true, force: true});
+}

package/scripts/generate-protocol-reference.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+import {readFile, writeFile} from "node:fs/promises";
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+import {
+  ACCOUNTING_STATUS,
+  COLLECTION_STATUS,
+  CI_EXIT_CODE,
+  CI_REASON,
+  CI_STATUS,
+  CLI_ARGUMENT,
+  CLI_COMMAND,
+  CLI_MESSAGE,
+  CONFIGURATION_FILE,
+  CONTENT_FRESHNESS,
+  DEFAULT,
+  DEFINITION_MATCH,
+  DEFINITION_RESOLUTION_METHOD,
+  DIAGNOSTIC_EVIDENCE_REASON,
+  DIAGNOSTIC_FRESHNESS,
+  DIAGNOSTIC_SEVERITY,
+  DOCTOR_CHECK,
+  DOCTOR_DISTRIBUTION_ACCEPTED_STATUS,
+  DOCTOR_REASON,
+  DOCTOR_STATUS_PRIORITY,
+  EVIDENCE_STATUS,
+  ENVIRONMENT_VARIABLE,
+  ERROR_CODE,
+  EVIDENCE_TYPE,
+  FINGERPRINT_ALGORITHM,
+  FORBIDDEN_PUBLIC_FIELD,
+  INTERNAL_RESOLUTION_SOURCE,
+  LANGUAGE_ID,
+  LIMIT_MODE,
+  NODE_EVENT,
+  PRESENTATION_MODE,
+  PACKAGE_PATH,
+  PRODUCT,
+  REFERENCE_DISCOVERY_METHOD,
+  REFERENCE_SET_CHANGE_TYPE,
+  REQUIRED_RUNTIME_COMPONENT,
+  RUNTIME_COMMAND,
+  RUNTIME_REQUIREMENT,
+  RUNTIME_REQUIREMENT_KIND,
+  RESULT_SCHEMA,
+  SERVER_VERSION,
+  SIGNATURE_SOURCE,
+  PROCESS_EXIT_CODE,
+  RUNTIME_STATUS,
+  TOOL_ORDER,
+  TYPESCRIPT_PROJECT_KIND,
+  SOURCE_EXCLUDED_GLOBS,
+  SOURCE_EXTENSION,
+  SOURCE_FILE_GLOBS,
+  WORKSPACE_CONFIGURATION_FILE_NAMES,
+  WORKSPACE_ROOT_MARKER_FILE_NAMES,
+  UNRESOLVED_REFERENCE_REASON,
+  VUE_SCRIPT_LANGUAGE,
+} from "../protocol.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const outputFile = path.join(root, "skills", "semantic-navigation", "references", "protocol-literals.md");
+
+function section(title, values) {
+  return [`## ${title}`, "", ...Object.values(values).map((value) => `- \`${value}\``), ""].join("\n");
+}
+
+function namedSection(title, values) {
+  return [
+    `## ${title}`,
+    "",
+    ...Object.entries(values).map(([name, value]) => `- \`${name}\`: \`${Array.isArray(value) ? value.join(",") : value}\``),
+    "",
+  ].join("\n");
+}
+
+const content =
+  [
+    "# Protocol Literals",
+    "",
+    "Generated from `protocol.mjs`. Do not edit this file directly.",
+    "",
+    `Server version: \`${SERVER_VERSION}\``,
+    `Server name: \`${PRODUCT.NAME}\``,
+    `Display name: \`${PRODUCT.DISPLAY_NAME}\``,
+    `Result schema: \`${RESULT_SCHEMA.NAME}\` version \`${RESULT_SCHEMA.VERSION}\``,
+    "",
+    section("Tool Order", Object.fromEntries(TOOL_ORDER.map((tool) => [tool, tool]))),
+    section("Workspace Configuration File Names", Object.fromEntries(WORKSPACE_CONFIGURATION_FILE_NAMES.map((name) => [name, name]))),
+    section("Configuration Files", CONFIGURATION_FILE),
+    section("Workspace Root Marker File Names", Object.fromEntries(WORKSPACE_ROOT_MARKER_FILE_NAMES.map((name) => [name, name]))),
+    section("Source File Globs", Object.fromEntries(SOURCE_FILE_GLOBS.map((glob) => [glob, glob]))),
+    section("Excluded Source Globs", Object.fromEntries(SOURCE_EXCLUDED_GLOBS.map((glob) => [glob, glob]))),
+    section("Source Extensions", SOURCE_EXTENSION),
+    section("Language IDs", LANGUAGE_ID),
+    section("Vue Script Languages", VUE_SCRIPT_LANGUAGE),
+    section("Collection Status", COLLECTION_STATUS),
+    section("Presentation Mode", PRESENTATION_MODE),
+    section("Limit Mode", LIMIT_MODE),
+    section("Accounting Status", ACCOUNTING_STATUS),
+    section("Definition Match", DEFINITION_MATCH),
+    section("Signature Source", SIGNATURE_SOURCE),
+    section("Diagnostic Freshness", DIAGNOSTIC_FRESHNESS),
+    section("Diagnostic Severity", DIAGNOSTIC_SEVERITY),
+    section("Diagnostic Evidence Reason", DIAGNOSTIC_EVIDENCE_REASON),
+    section("Evidence Status", EVIDENCE_STATUS),
+    section("Reference Content Freshness", CONTENT_FRESHNESS),
+    section("Error Code", ERROR_CODE),
+    section("Evidence Type", EVIDENCE_TYPE),
+    section("Fingerprint Algorithm", FINGERPRINT_ALGORITHM),
+    section("Reference Discovery Method", REFERENCE_DISCOVERY_METHOD),
+    section("Reference Set Change Type", REFERENCE_SET_CHANGE_TYPE),
+    section("Definition Resolution Method", DEFINITION_RESOLUTION_METHOD),
+    section("Unresolved Reference Reason", UNRESOLVED_REFERENCE_REASON),
+    section("TypeScript Project Kind", TYPESCRIPT_PROJECT_KIND),
+    section("CI Status", CI_STATUS),
+    namedSection("CI Exit Codes", CI_EXIT_CODE),
+    section("CI Reason", CI_REASON),
+    section("CLI Commands", CLI_COMMAND),
+    section("CLI Arguments", CLI_ARGUMENT),
+    section("CLI Messages", CLI_MESSAGE),
+    section("Doctor Checks", DOCTOR_CHECK),
+    section("Doctor Reasons", DOCTOR_REASON),
+    section(
+      "Doctor Distribution Accepted Status",
+      Object.fromEntries(DOCTOR_DISTRIBUTION_ACCEPTED_STATUS.map((status) => [status, status])),
+    ),
+    namedSection("Doctor Status Priority", DOCTOR_STATUS_PRIORITY),
+    namedSection("Required Runtime Components", REQUIRED_RUNTIME_COMPONENT),
+    section("Runtime Commands", RUNTIME_COMMAND),
+    namedSection("Runtime Requirements", RUNTIME_REQUIREMENT),
+    section("Runtime Requirement Kinds", RUNTIME_REQUIREMENT_KIND),
+    section("Package Paths", PACKAGE_PATH),
+    section("Runtime Status", RUNTIME_STATUS),
+    section("Node Event", NODE_EVENT),
+    namedSection("Process Exit Codes", PROCESS_EXIT_CODE),
+    section("Internal Resolution Source", INTERNAL_RESOLUTION_SOURCE),
+    section("Forbidden Ambiguous Public Fields", Object.fromEntries(FORBIDDEN_PUBLIC_FIELD.map((field) => [field, field]))),
+    namedSection("Default Configuration Values", DEFAULT),
+    namedSection("Environment Variables", ENVIRONMENT_VARIABLE),
+  ]
+    .join("\n")
+    .trimEnd() + "\n";
+
+if (process.argv.includes("--check")) {
+  const current = await readFile(outputFile, "utf8").catch(() => "");
+  if (current !== content) {
+    process.stderr.write("Generated protocol reference is out of date. Run: node scripts/generate-protocol-reference.mjs\n");
+    process.exitCode = 1;
+  }
+} else {
+  await writeFile(outputFile, content);
+}

package/scripts/semantic-js-mcp-ci.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+import {readFile} from "node:fs/promises";
+import {parse as parseYaml, stringify as stringifyYaml} from "yaml";
+import {
+  CI_EXIT_CODE,
+  CI_REASON,
+  CI_STATUS,
+  COLLECTION_STATUS,
+  DIAGNOSTIC_SEVERITY,
+  EVIDENCE_STATUS,
+  PRESENTATION_MODE,
+  PRODUCT,
+  RESULT_SCHEMA,
+  TOOL,
+  TOOL_ORDER,
+} from "../protocol.mjs";
+
+const STANDARD_INPUT_PATH = "-";
+const YAML_OUTPUT_ARGUMENT = "--yaml";
+const COLLECTION_STATUSES = new Set(Object.values(COLLECTION_STATUS));
+const PRESENTATION_MODES = new Set(Object.values(PRESENTATION_MODE));
+const PUBLIC_TOOL_NAMES = new Set(TOOL_ORDER);
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isCanonicalResult(result) {
+  const continuationsAreCanonical =
+    Array.isArray(result?.continueWith) &&
+    result.continueWith.every((continuation) => isObject(continuation) && PUBLIC_TOOL_NAMES.has(continuation.tool));
+  return (
+    result?.server?.name === PRODUCT.NAME &&
+    typeof result.server.version === "string" &&
+    result.server.version.length > 0 &&
+    result?.resultSchema?.name === RESULT_SCHEMA.NAME &&
+    result.resultSchema.version === RESULT_SCHEMA.VERSION &&
+    PUBLIC_TOOL_NAMES.has(result.tool) &&
+    isObject(result.request) &&
+    isObject(result.result) &&
+    isObject(result.collection) &&
+    isObject(result.presentation) &&
+    PRESENTATION_MODES.has(result.presentation.mode) &&
+    continuationsAreCanonical &&
+    COLLECTION_STATUSES.has(result.collection.status)
+  );
+}
+
+async function readInput(inputPath) {
+  return inputPath && inputPath !== STANDARD_INPUT_PATH
+    ? readFile(inputPath, "utf8")
+    : new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => chunks.push(chunk));
+        process.stdin.on("end", () => resolve(chunks.join("")));
+        process.stdin.on("error", reject);
+      });
+}
+
+function parseInput(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return parseYaml(text);
+  }
+}
+
+function decision(status, reason) {
+  return {status, exitCode: CI_EXIT_CODE[status.toUpperCase()], reason};
+}
+
+function evaluate(data) {
+  const result = data?.structuredContent || data;
+  if (!isCanonicalResult(result)) {
+    return {...decision(CI_STATUS.BLOCKED, CI_REASON.INVALID_INPUT), source: {}};
+  }
+  const source = {tool: result.tool, collectionStatus: result.collection.status};
+  if (result.collection.status === COLLECTION_STATUS.FAILED || result.error) {
+    return {...decision(CI_STATUS.BLOCKED, CI_REASON.TOOL_EXECUTION_FAILED), source};
+  }
+  if (
+    result.tool === TOOL.DIAGNOSTICS &&
+    (result.result?.evidence?.status !== EVIDENCE_STATUS.VERIFIED || !result.result?.diagnosticsForCurrentDocument)
+  ) {
+    return {...decision(CI_STATUS.UNTRUSTED, CI_REASON.UNTRUSTED_DIAGNOSTICS), source};
+  }
+  if (result.collection.status === COLLECTION_STATUS.LIMITED || result.collection.status === COLLECTION_STATUS.PARTIAL) {
+    return {
+      ...decision(CI_STATUS.UNTRUSTED, CI_REASON.INCOMPLETE_EVIDENCE),
+      source,
+    };
+  }
+  if (result.tool === TOOL.DIAGNOSTICS) {
+    const diagnostics = result.result?.diagnosticsForCurrentDocument?.items || [];
+    if (diagnostics.some((item) => item.severity === DIAGNOSTIC_SEVERITY.ERROR)) {
+      return {...decision(CI_STATUS.FAIL, CI_REASON.VERIFIED_DIAGNOSTIC_ERRORS), source};
+    }
+  }
+  return {...decision(CI_STATUS.PASS, CI_REASON.COMPLETE_EVIDENCE), source};
+}
+
+let output;
+try {
+  const input = parseInput(await readInput(process.argv[2]));
+  output = {
+    protocol: {name: RESULT_SCHEMA.NAME, resultSchemaVersion: RESULT_SCHEMA.VERSION},
+    ...evaluate(input),
+  };
+} catch (error) {
+  output = {
+    protocol: {name: RESULT_SCHEMA.NAME, resultSchemaVersion: RESULT_SCHEMA.VERSION},
+    ...decision(CI_STATUS.BLOCKED, CI_REASON.INVALID_INPUT),
+    source: {},
+    message: error instanceof Error ? error.message : String(error),
+  };
+}
+
+const useYaml = process.argv.includes(YAML_OUTPUT_ARGUMENT);
+process.stdout.write(useYaml ? stringifyYaml(output, {lineWidth: 0}) : `${JSON.stringify(output, null, 2)}\n`);
+process.exitCode = output.exitCode;