semantic-js-mcp 0.9.0 → 0.10.0

package/scripts/check-protocol-literals.mjs

@@ -36,8 +36,10 @@ import {
   FINGERPRINT_FORMAT,
   INTERNAL_RESOLUTION_SOURCE,
   LIMIT_MODE,
+  LSP_COMMAND,
   LSP_METHOD,
   NODE_EVENT,
+  OPERATING_SYSTEM,
   PRESENTATION_MODE,
   PACKAGE_PATH,
   PRODUCT,
@@ -50,8 +52,11 @@ import {
   RUNTIME_REQUIREMENT_KIND,
   RESULT_SCHEMA,
   SEARCH_SCOPE,
+  SEMANTIC_EVIDENCE_FOLLOW_UP_REASON,
+  SEMANTIC_EVIDENCE_STATUS,
   TOOL,
   TOOL_DESCRIPTION,
+  TYPESCRIPT_SERVER_COMMAND,
   TYPESCRIPT_PROJECT_KIND,
   SOURCE_EXCLUDED_GLOBS,
   SOURCE_FILE_GLOBS,
@@ -89,6 +94,8 @@ const groups = [
   ACCOUNTING_STATUS,
   DEFINITION_MATCH,
   DEFINITION_SELECTION_STATUS,
+  SEMANTIC_EVIDENCE_STATUS,
+  SEMANTIC_EVIDENCE_FOLLOW_UP_REASON,
   DIAGNOSTIC_FRESHNESS,
   DIAGNOSTIC_PROVIDER,
   DIAGNOSTIC_REGION,
@@ -106,6 +113,8 @@ const groups = [
   DEFINITION_RESOLUTION_METHOD,
   INTERNAL_RESOLUTION_SOURCE,
   LSP_METHOD,
+  LSP_COMMAND,
+  TYPESCRIPT_SERVER_COMMAND,
   UNRESOLVED_REFERENCE_REASON,
   TYPESCRIPT_PROJECT_KIND,
   CI_STATUS,
@@ -124,6 +133,7 @@ const groups = [
   PACKAGE_PATH,
   RUNTIME_STATUS,
   NODE_EVENT,
+  OPERATING_SYSTEM,
   PRODUCT,
   ENVIRONMENT_VARIABLE,
   RESULT_SCHEMA,

package/scripts/ci-smoke.mjs

@@ -8,13 +8,17 @@ import path from "node:path";
 import {fileURLToPath} from "node:url";
 import {
   CI_EXIT_CODE,
+  CI_REASON,
   CI_STATUS,
   COLLECTION_STATUS,
+  DEFINITION_SELECTION_STATUS,
   DIAGNOSTIC_SEVERITY,
   EVIDENCE_STATUS,
   PRESENTATION_MODE,
   PRODUCT,
   RESULT_SCHEMA,
+  SEMANTIC_EVIDENCE_FOLLOW_UP_REASON,
+  SEMANTIC_EVIDENCE_STATUS,
   SERVER_VERSION,
   TOOL,
 } from "../protocol.mjs";
@@ -39,7 +43,7 @@ function runEvaluator(inputFile) {
   });
 }
 
-async function evaluate(name, input, expectedStatus, expectedExitCode) {
+async function evaluate(name, input, expectedStatus, expectedExitCode, expectedReason) {
   const file = path.join(workspace, `${name}.json`);
   await writeFile(file, JSON.stringify(input));
   const execution = await runEvaluator(file);
@@ -47,6 +51,7 @@ async function evaluate(name, input, expectedStatus, expectedExitCode) {
   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});
+  if (expectedReason) strictEqual(result.reason, expectedReason, `${name} returned the wrong reason`);
 }
 
 function canonicalResult(tool, collectionStatus, result, extra = {}) {
@@ -64,6 +69,44 @@ function canonicalResult(tool, collectionStatus, result, extra = {}) {
 
 try {
   await evaluate("pass", canonicalResult(TOOL.COUNT_REFERENCES, COLLECTION_STATUS.COMPLETE, {}), CI_STATUS.PASS, CI_EXIT_CODE.PASS);
+  await evaluate(
+    "named-semantic-evidence-usable",
+    canonicalResult(TOOL.COUNT_NAMED_SYMBOL, COLLECTION_STATUS.COMPLETE, {
+      definitionSelectionStatus: DEFINITION_SELECTION_STATUS.ONE,
+      semanticEvidence: {status: SEMANTIC_EVIDENCE_STATUS.USABLE, followUpReasons: []},
+    }),
+    CI_STATUS.PASS,
+    CI_EXIT_CODE.PASS,
+  );
+  await evaluate(
+    "named-semantic-follow-up-required",
+    canonicalResult(TOOL.AUDIT_NAMED_SYMBOL, COLLECTION_STATUS.COMPLETE, {
+      definitionSelectionStatus: DEFINITION_SELECTION_STATUS.MULTIPLE,
+      semanticEvidence: {
+        status: SEMANTIC_EVIDENCE_STATUS.FOLLOW_UP_REQUIRED,
+        followUpReasons: [SEMANTIC_EVIDENCE_FOLLOW_UP_REASON.MULTIPLE_DEFINITIONS_SELECTED],
+      },
+    }),
+    CI_STATUS.UNTRUSTED,
+    CI_EXIT_CODE.UNTRUSTED,
+  );
+  await evaluate(
+    "named-semantic-evidence-conflicts-with-source-fields",
+    canonicalResult(TOOL.COUNT_NAMED_SYMBOL, COLLECTION_STATUS.PARTIAL, {
+      definitionSelectionStatus: DEFINITION_SELECTION_STATUS.ONE,
+      semanticEvidence: {status: SEMANTIC_EVIDENCE_STATUS.USABLE, followUpReasons: []},
+    }),
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+  );
+  await evaluate(
+    "named-semantic-evidence-requires-definition-selection",
+    canonicalResult(TOOL.COUNT_NAMED_SYMBOL, COLLECTION_STATUS.COMPLETE, {
+      semanticEvidence: {status: SEMANTIC_EVIDENCE_STATUS.USABLE, followUpReasons: []},
+    }),
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+  );
   await evaluate(
     "fail",
     canonicalResult(TOOL.DIAGNOSTICS, COLLECTION_STATUS.COMPLETE, {
@@ -94,6 +137,20 @@ try {
     CI_STATUS.BLOCKED,
     CI_EXIT_CODE.BLOCKED,
   );
+  await evaluate(
+    "named-tool-execution-failed",
+    canonicalResult(TOOL.COUNT_NAMED_SYMBOL, COLLECTION_STATUS.FAILED, {}, {error: {code: "fixture"}}),
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+    CI_REASON.TOOL_EXECUTION_FAILED,
+  );
+  await evaluate(
+    "named-tool-invalid-error-shape",
+    canonicalResult(TOOL.COUNT_NAMED_SYMBOL, COLLECTION_STATUS.FAILED, {}, {error: "fixture"}),
+    CI_STATUS.BLOCKED,
+    CI_EXIT_CODE.BLOCKED,
+    CI_REASON.INVALID_INPUT,
+  );
   await evaluate(
     "missing-canonical-identity",
     {

package/scripts/distribution-policy.mjs

@@ -47,15 +47,8 @@ export const NPM_DISTRIBUTION = Object.freeze({
   CACHE_ENVIRONMENT_VARIABLE: "npm_config_cache",
 });
 
-const WINDOWS_PLATFORM = "win32";
-const WINDOWS_COMMAND_SUFFIX = ".cmd";
 const DEPENDENCY_DIRECTORY_PREFIX = "node_modules/";
 
-export function npmExecutableName(name, platform = process.platform) {
-  if (platform === WINDOWS_PLATFORM) return `${name}${WINDOWS_COMMAND_SUFFIX}`;
-  return name;
-}
-
 export function allProductionDependenciesAreBundled(manifest) {
   const dependencies = Object.keys(manifest.dependencies || {}).sort();
   const bundledDependencies = [...(manifest.bundleDependencies || [])].sort();

package/scripts/distribution-smoke.mjs

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 
 import {spawn} from "node:child_process";
-import {mkdtemp, mkdir, readFile, realpath, rm, writeFile} from "node:fs/promises";
+import {mkdtemp, mkdir, readFile, realpath, writeFile} from "node:fs/promises";
 import {tmpdir} from "node:os";
 import path from "node:path";
 import {fileURLToPath} from "node:url";
+import {removeTemporaryDirectory} from "../lib/temporary-directory.mjs";
 import {
   CLI_ARGUMENT,
   CLI_MESSAGE,
@@ -18,7 +19,6 @@ import {
   REQUIRED_PACKAGE_FILE,
   NPM_DISTRIBUTION,
   allProductionDependenciesAreBundled,
-  npmExecutableName,
   packagePathIsAllowed,
 } from "./distribution-policy.mjs";
 
@@ -46,9 +46,13 @@ function run(command, args, options = {}) {
   });
 }
 
-function runNpm(args, cwd) {
-  if (npmCli) return run(process.execPath, [npmCli, ...args], {cwd, env: npmEnvironment});
-  return run("npm", args, {cwd, env: npmEnvironment});
+function runNpm(args, cwd, environment = npmEnvironment) {
+  if (npmCli) return run(process.execPath, [npmCli, ...args], {cwd, env: environment});
+  return run("npm", args, {cwd, env: environment});
+}
+
+function runInstalledExecutable(executable, args, cwd, environment) {
+  return run(process.execPath, [executable, ...args], {cwd, env: environment});
 }
 
 function assert(condition, message) {
@@ -81,21 +85,22 @@ try {
   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 installedManifest = JSON.parse(await readFile(path.join(installedRoot, "package.json"), "utf8"));
+  const installedExecutable = path.join(installedRoot, installedManifest.bin[PRODUCT.NAME]);
   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}});
+  const installedEnvironment = {...npmEnvironment, PATH: isolatedPath};
+  const doctor = await runInstalledExecutable(installedExecutable, ["doctor"], consumer, installedEnvironment);
+  const version = await runInstalledExecutable(installedExecutable, [CLI_ARGUMENT.VERSION], consumer, installedEnvironment);
   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}});
+  const help = await runInstalledExecutable(installedExecutable, [CLI_ARGUMENT.HELP], consumer, installedEnvironment);
   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}});
+  const invalid = await runInstalledExecutable(installedExecutable, ["unknown-command"], consumer, installedEnvironment);
   assert(
     invalid.exitCode === PROCESS_EXIT_CODE.FAILURE && invalid.stderr.includes(CLI_MESSAGE.UNKNOWN_COMMAND),
     "Installed executable accepted an unknown command",
@@ -117,7 +122,6 @@ try {
   }
   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(
       {
@@ -136,5 +140,5 @@ try {
     )}\n`,
   );
 } finally {
-  await rm(workspace, {recursive: true, force: true});
+  await removeTemporaryDirectory(workspace);
 }

package/scripts/doctor-smoke.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+import {spawn} from "node:child_process";
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+import {DOCTOR_DISTRIBUTION_ACCEPTED_STATUS, NODE_EVENT, PRODUCT} from "../protocol.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+const execution = await new Promise((resolve, reject) => {
+  const child = spawn(process.execPath, [path.join(root, "cli.mjs"), "doctor"], {
+    cwd: root,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  const stdout = [];
+  const stderr = [];
+  child.stdout.on("data", (chunk) => stdout.push(chunk));
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+  child.on(NODE_EVENT.ERROR, reject);
+  child.on(NODE_EVENT.CLOSE, (exitCode) =>
+    resolve({exitCode, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8")}),
+  );
+});
+
+let report;
+try {
+  report = JSON.parse(execution.stdout);
+} catch {
+  throw new Error(`Doctor did not return JSON: ${execution.stderr || execution.stdout}`);
+}
+if (!DOCTOR_DISTRIBUTION_ACCEPTED_STATUS.includes(report.status)) {
+  throw new Error(`Doctor returned ${report.status}: ${JSON.stringify(report, null, 2)}\n${execution.stderr}`);
+}
+if (report.exitCode !== execution.exitCode) {
+  throw new Error(`Doctor process exit ${execution.exitCode} differs from reported exit ${report.exitCode}`);
+}
+
+process.stdout.write(
+  `${JSON.stringify({product: PRODUCT.NAME, status: report.status, exitCode: execution.exitCode, checks: report.checks.length}, null, 2)}\n`,
+);

package/scripts/documentation-contract.mjs

@@ -0,0 +1,39 @@
+import {DOCTOR_REASON, SEMANTIC_EVIDENCE_FOLLOW_UP_REASON} from "../protocol.mjs";
+
+export const DOCUMENTATION_FILE = Object.freeze({
+  README: "README.md",
+  GETTING_STARTED: "docs/getting-started.md",
+  CONTRIBUTING: "CONTRIBUTING.md",
+  SECURITY: "SECURITY.md",
+});
+
+export const PUBLIC_ROOT_DOCUMENT = Object.freeze(["CHANGELOG.md", "CONTRIBUTING.md", "README.md", "ROADMAP.md", "SECURITY.md"]);
+
+export const PUBLIC_DOCUMENT_DIRECTORY = Object.freeze(["docs", "skills"]);
+
+export const DOCUMENTATION_REQUIREMENT = Object.freeze({
+  README_HEADINGS: Object.freeze(["Installation", "Runtime", "Verification", "Current Limitations", "Reporting Problems"]),
+  GETTING_STARTED_HEADINGS: Object.freeze([
+    "Trace A Symbol",
+    "Review A Security-Sensitive Change",
+    "Check Current Diagnostics",
+    "Complete Evidence",
+    "Partial Evidence",
+    "Untrusted Diagnostics",
+    "Startup Failure",
+  ]),
+  README_LINKS: Object.freeze(["docs/getting-started.md", "CONTRIBUTING.md", "SECURITY.md"]),
+  GETTING_STARTED_LITERALS: Object.freeze([SEMANTIC_EVIDENCE_FOLLOW_UP_REASON.COLLECTION_PARTIAL, DOCTOR_REASON.RUNTIME_COMPONENT_MISSING]),
+});
+
+export const DOCUMENTATION_REASON = Object.freeze({
+  FILE_MISSING: "required-document-missing",
+  HEADING_MISSING: "required-heading-missing",
+  LINK_MISSING: "required-link-missing",
+  LITERAL_MISSING: "required-literal-missing",
+  PRIVATE_COORDINATION: "private-coordination-language-found",
+  LOCAL_PATH: "local-absolute-path-found",
+});
+
+export const PRIVATE_COORDINATION_PATTERN = /\b(?:private (?:ticket|handoff)|internal (?:id|priority|status)|workstream|depends on)\b/i;
+export const LOCAL_ABSOLUTE_PATH_PATTERN = /\/(?:Users|home)\/[^/\s]+\//;

package/scripts/documentation-gate-smoke.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import {strictEqual} from "node:assert";
+import {DOCUMENTATION_FILE, DOCUMENTATION_REASON, DOCUMENTATION_REQUIREMENT} from "./documentation-contract.mjs";
+import {evaluateDocumentation} from "./documentation-gate.mjs";
+
+const headingText = (headings) => headings.map((heading) => `## ${heading}`).join("\n");
+const valid = {
+  [DOCUMENTATION_FILE.README]: `${headingText(DOCUMENTATION_REQUIREMENT.README_HEADINGS)}\n${DOCUMENTATION_REQUIREMENT.README_LINKS.map((link) => `[doc](${link})`).join("\n")}`,
+  [DOCUMENTATION_FILE.GETTING_STARTED]: `${headingText(DOCUMENTATION_REQUIREMENT.GETTING_STARTED_HEADINGS)}\n${DOCUMENTATION_REQUIREMENT.GETTING_STARTED_LITERALS.join("\n")}`,
+  [DOCUMENTATION_FILE.CONTRIBUTING]: "# Contributing",
+  [DOCUMENTATION_FILE.SECURITY]: "# Security",
+};
+
+strictEqual(evaluateDocumentation(valid).length, 0, "Valid public documentation failed the gate");
+
+const missingHeading = {...valid, [DOCUMENTATION_FILE.README]: valid[DOCUMENTATION_FILE.README].replace("## Verification", "")};
+strictEqual(
+  evaluateDocumentation(missingHeading).some((finding) => finding.reason === DOCUMENTATION_REASON.HEADING_MISSING),
+  true,
+  "Missing README heading was accepted",
+);
+
+const coordinationCode = ["WORK", "123"].join("-");
+const coordinationPhrase = ["private", "handoff"].join(" ");
+const internalLanguage = {
+  ...valid,
+  [DOCUMENTATION_FILE.CONTRIBUTING]: `Complete ${coordinationCode} from the ${coordinationPhrase}`,
+};
+strictEqual(
+  evaluateDocumentation(internalLanguage).some((finding) => finding.reason === DOCUMENTATION_REASON.PRIVATE_COORDINATION),
+  true,
+  "Private coordination language was accepted",
+);
+
+const missingLiteral = {
+  ...valid,
+  [DOCUMENTATION_FILE.GETTING_STARTED]: valid[DOCUMENTATION_FILE.GETTING_STARTED].replace(
+    DOCUMENTATION_REQUIREMENT.GETTING_STARTED_LITERALS[0],
+    "",
+  ),
+};
+strictEqual(
+  evaluateDocumentation(missingLiteral).some((finding) => finding.reason === DOCUMENTATION_REASON.LITERAL_MISSING),
+  true,
+  "Missing canonical example literal was accepted",
+);
+
+process.stdout.write(
+  `${JSON.stringify(
+    {validDocumentation: "pass", missingHeading: "rejected", missingLiteral: "rejected", privateCoordination: "rejected"},
+    null,
+    2,
+  )}\n`,
+);

package/scripts/documentation-gate.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+import {readdir, readFile} from "node:fs/promises";
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+import {
+  DOCUMENTATION_FILE,
+  DOCUMENTATION_REASON,
+  DOCUMENTATION_REQUIREMENT,
+  LOCAL_ABSOLUTE_PATH_PATTERN,
+  PRIVATE_COORDINATION_PATTERN,
+  PUBLIC_DOCUMENT_DIRECTORY,
+  PUBLIC_ROOT_DOCUMENT,
+} from "./documentation-contract.mjs";
+
+function markdownHeadings(source) {
+  return new Set(
+    source
+      .split("\n")
+      .map((line) => /^#{1,6}\s+(.+?)\s*$/.exec(line)?.[1])
+      .filter(Boolean),
+  );
+}
+
+function repositoryPath(root, absolute) {
+  return path.relative(root, absolute).split(path.sep).join("/");
+}
+
+export function evaluateDocumentation(documents) {
+  const findings = [];
+  for (const file of Object.values(DOCUMENTATION_FILE)) {
+    if (documents[file] !== undefined) continue;
+    findings.push({file, reason: DOCUMENTATION_REASON.FILE_MISSING});
+  }
+
+  const headingRequirements = [
+    [DOCUMENTATION_FILE.README, DOCUMENTATION_REQUIREMENT.README_HEADINGS],
+    [DOCUMENTATION_FILE.GETTING_STARTED, DOCUMENTATION_REQUIREMENT.GETTING_STARTED_HEADINGS],
+  ];
+  for (const [file, requiredHeadings] of headingRequirements) {
+    if (documents[file] === undefined) continue;
+    const headings = markdownHeadings(documents[file]);
+    for (const heading of requiredHeadings) {
+      if (headings.has(heading)) continue;
+      findings.push({file, reason: DOCUMENTATION_REASON.HEADING_MISSING, heading});
+    }
+  }
+
+  const readme = documents[DOCUMENTATION_FILE.README];
+  if (readme !== undefined) {
+    for (const link of DOCUMENTATION_REQUIREMENT.README_LINKS) {
+      if (readme.includes(`](${link})`)) continue;
+      findings.push({file: DOCUMENTATION_FILE.README, reason: DOCUMENTATION_REASON.LINK_MISSING, link});
+    }
+  }
+
+  const gettingStarted = documents[DOCUMENTATION_FILE.GETTING_STARTED];
+  if (gettingStarted !== undefined) {
+    for (const literal of DOCUMENTATION_REQUIREMENT.GETTING_STARTED_LITERALS) {
+      if (gettingStarted.includes(literal)) continue;
+      findings.push({file: DOCUMENTATION_FILE.GETTING_STARTED, reason: DOCUMENTATION_REASON.LITERAL_MISSING, literal});
+    }
+  }
+
+  for (const [file, source] of Object.entries(documents)) {
+    if (PRIVATE_COORDINATION_PATTERN.test(source)) {
+      findings.push({file, reason: DOCUMENTATION_REASON.PRIVATE_COORDINATION});
+    }
+    if (LOCAL_ABSOLUTE_PATH_PATTERN.test(source)) {
+      findings.push({file, reason: DOCUMENTATION_REASON.LOCAL_PATH});
+    }
+  }
+  return findings;
+}
+
+async function markdownFiles(directory, root) {
+  const entries = await readdir(directory, {withFileTypes: true});
+  const files = [];
+  for (const entry of entries) {
+    const absolute = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await markdownFiles(absolute, root)));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".md")) files.push(repositoryPath(root, absolute));
+  }
+  return files;
+}
+
+async function publicDocumentationFiles(root) {
+  const nested = await Promise.all(PUBLIC_DOCUMENT_DIRECTORY.map((directory) => markdownFiles(path.join(root, directory), root)));
+  return [...new Set([...PUBLIC_ROOT_DOCUMENT, ...nested.flat()])].sort();
+}
+
+async function main() {
+  const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+  const documents = {};
+  for (const file of await publicDocumentationFiles(root)) {
+    try {
+      documents[file] = await readFile(path.join(root, file), "utf8");
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+  }
+  const findings = evaluateDocumentation(documents);
+  process.stdout.write(`${JSON.stringify({status: findings.length === 0 ? "pass" : "fail", findings}, null, 2)}\n`);
+  if (findings.length > 0) process.exitCode = 1;
+}
+
+if (path.resolve(process.argv[1] || "") === fileURLToPath(import.meta.url)) await main();

package/scripts/generate-protocol-reference.mjs

@@ -39,8 +39,10 @@ import {
   INTERNAL_RESOLUTION_SOURCE,
   LANGUAGE_ID,
   LIMIT_MODE,
+  LSP_COMMAND,
   LSP_METHOD,
   NODE_EVENT,
+  OPERATING_SYSTEM,
   PRESENTATION_MODE,
   PACKAGE_PATH,
   PRODUCT,
@@ -54,11 +56,14 @@ import {
   RESULT_SCHEMA,
   SERVER_VERSION,
   SEARCH_SCOPE,
+  SEMANTIC_EVIDENCE_FOLLOW_UP_REASON,
+  SEMANTIC_EVIDENCE_STATUS,
   SIGNATURE_SOURCE,
   PROCESS_EXIT_CODE,
   RUNTIME_STATUS,
   TOOL_ORDER,
   TOOL_DESCRIPTION,
+  TYPESCRIPT_SERVER_COMMAND,
   TYPESCRIPT_PROJECT_KIND,
   SOURCE_EXCLUDED_GLOBS,
   SOURCE_EXTENSION,
@@ -112,9 +117,13 @@ const content =
     section("Presentation Mode", PRESENTATION_MODE),
     section("Limit Mode", LIMIT_MODE),
     section("LSP Methods", LSP_METHOD),
+    section("LSP Commands", LSP_COMMAND),
+    section("TypeScript Server Commands", TYPESCRIPT_SERVER_COMMAND),
     section("Accounting Status", ACCOUNTING_STATUS),
     section("Definition Match", DEFINITION_MATCH),
     section("Definition Selection Status", DEFINITION_SELECTION_STATUS),
+    section("Semantic Evidence Status", SEMANTIC_EVIDENCE_STATUS),
+    section("Semantic Evidence Follow-up Reason", SEMANTIC_EVIDENCE_FOLLOW_UP_REASON),
     section("Signature Source", SIGNATURE_SOURCE),
     section("Diagnostic Freshness", DIAGNOSTIC_FRESHNESS),
     section("Diagnostic Provider", DIAGNOSTIC_PROVIDER),
@@ -153,6 +162,7 @@ const content =
     section("Package Paths", PACKAGE_PATH),
     section("Runtime Status", RUNTIME_STATUS),
     section("Node Event", NODE_EVENT),
+    section("Operating System", OPERATING_SYSTEM),
     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]))),