@bridge_gpt/mcp-server 0.2.53 → 0.2.54

package/build/conductor/test-run-branch-vectors.js

@@ -0,0 +1,165 @@
+/**
+ * BAPI-1127 — TypeScript-side loader for the SHARED cross-runtime vector table.
+ *
+ * `tests/pytest/fixtures/run_branch_vectors.json` lives at the repository root,
+ * outside this package, because it is not this package's fixture: it is the
+ * contract between this package and the Python server, and both sides read the
+ * same bytes. Python reaches it from `tests/pytest/models/`; this module is how
+ * the compiled `node:test` suites reach it.
+ *
+ * **Why `readFileSync` and not a JSON import.** Importing the JSON would require
+ * `resolveJsonModule` plus a widened `include` in `tsconfig.json`, which would
+ * inline a test fixture into the PUBLISHED bundle. `build/**\/*.test.js` is
+ * excluded from the package `files` list, so a compiled test reading a
+ * repository-root path ships nothing; a JSON module baked into the emitted
+ * source would.
+ *
+ * **Why the path is searched rather than computed.** The compiled test executes
+ * from `mcp_server/build/conductor/`, not `mcp_server/src/conductor/`, so a
+ * hard-coded `../../../` is correct for exactly one of the two and silently
+ * wrong for the other. Walking up until the fixture is found is correct from
+ * either, and from any CI checkout depth.
+ *
+ * Nothing here is reachable from the MCP server runtime — it is imported only by
+ * `*.test.ts` — so it adds no startup cost and touches no stdio.
+ */
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Repository-root-relative location of the shared table. */
+const FIXTURE_RELATIVE_PATH = path.join("tests", "pytest", "fixtures", "run_branch_vectors.json");
+function repositoryRoot() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    // 8 levels is far more than the 3 either real layout needs; the loop exists to
+    // be layout-independent, not to search the whole filesystem.
+    for (let i = 0; i < 8; i++) {
+        try {
+            readFileSync(path.join(dir, FIXTURE_RELATIVE_PATH));
+            return dir;
+        }
+        catch {
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    throw new Error(`run_branch_vectors.json not found above ${fileURLToPath(import.meta.url)}. ` +
+        "The shared cross-runtime vector table is required; this suite must not " +
+        "pass without it.");
+}
+function readDocument() {
+    const fixturePath = path.join(repositoryRoot(), FIXTURE_RELATIVE_PATH);
+    let raw;
+    try {
+        raw = readFileSync(fixturePath, "utf8");
+    }
+    catch (err) {
+        throw new Error(`shared vector fixture is unreadable at ${fixturePath}: ${String(err)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`shared vector fixture is not valid JSON (${fixturePath}): ${String(err)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`shared vector fixture is not a JSON object (${fixturePath}).`);
+    }
+    return parsed;
+}
+/** JSON `null` means "no declaration"; TypeScript spells that `undefined`. */
+function nullToUndefined(value) {
+    return value === null ? undefined : value;
+}
+/**
+ * Load the shared resolution vectors, THROWING on every vacuous state.
+ *
+ * A missing, unreadable, malformed, or empty table is a failure and never a
+ * skip: a parity suite that quietly parametrizes zero cases reports green while
+ * proving nothing, which is the exact outcome these vectors exist to prevent.
+ */
+export function loadResolutionVectors() {
+    const raw = readDocument()["resolution_vectors"];
+    if (!Array.isArray(raw)) {
+        throw new Error("shared vector fixture has no 'resolution_vectors' array.");
+    }
+    if (raw.length === 0) {
+        throw new Error("shared vector fixture declares zero resolution vectors; every parity " +
+            "assertion below would be vacuous.");
+    }
+    return raw.map((entry, index) => {
+        if (!entry || typeof entry !== "object") {
+            throw new Error(`resolution vector #${index} is not an object.`);
+        }
+        const e = entry;
+        if (typeof e["id"] !== "string" || e["id"].length === 0) {
+            throw new Error(`resolution vector #${index} has no id.`);
+        }
+        if (typeof e["policy_present"] !== "boolean") {
+            throw new Error(`resolution vector ${e["id"]} has no boolean policy_present.`);
+        }
+        if (!("expected_declared_branch" in e)) {
+            throw new Error(`resolution vector ${e["id"]} has no expected_declared_branch.`);
+        }
+        return {
+            id: e["id"],
+            note: typeof e["note"] === "string" ? e["note"] : "",
+            policyPresent: e["policy_present"],
+            policyJson: e["policy_present"] ? e["policy_json"] : undefined,
+            expectedDeclaredBranch: nullToUndefined(e["expected_declared_branch"]),
+            typescriptEffectiveBase: nullToUndefined(e["typescript_effective_base"]),
+            typescriptEffectiveErrorType: nullToUndefined(e["typescript_effective_error_type"]),
+        };
+    });
+}
+/** Load the shared branch-name validity vectors, with the same loud failures. */
+export function loadBranchNameVectors() {
+    const raw = readDocument()["branch_name_validation"];
+    if (!Array.isArray(raw)) {
+        throw new Error("shared vector fixture has no 'branch_name_validation' array.");
+    }
+    if (raw.length === 0) {
+        throw new Error("shared vector fixture declares zero branch-name vectors; every validator " +
+            "assertion below would be vacuous.");
+    }
+    return raw.map((entry, index) => {
+        if (!entry || typeof entry !== "object") {
+            throw new Error(`branch-name vector #${index} is not an object.`);
+        }
+        const e = entry;
+        if (typeof e["id"] !== "string" || e["id"].length === 0) {
+            throw new Error(`branch-name vector #${index} has no id.`);
+        }
+        if (typeof e["input"] !== "string") {
+            throw new Error(`branch-name vector ${e["id"]} has a non-string input.`);
+        }
+        if (typeof e["valid"] !== "boolean") {
+            throw new Error(`branch-name vector ${e["id"]} has no boolean 'valid'.`);
+        }
+        return {
+            id: e["id"],
+            note: typeof e["note"] === "string" ? e["note"] : "",
+            input: e["input"],
+            valid: e["valid"],
+            errorType: nullToUndefined(e["error_type"]),
+        };
+    });
+}
+/**
+ * The substring each `error_type` must appear as in a validator diagnostic.
+ *
+ * The adapters assert the ACTUAL message, not merely that some error occurred,
+ * so a validator that started reporting the wrong rule would fail rather than
+ * pass on a coincidentally-truthy result. Kept here, beside the loader, because
+ * both the TypeScript validator suite and the effective-base suite need it.
+ */
+export const ERROR_TYPE_MESSAGE_FRAGMENTS = {
+    empty: "must not be empty",
+    too_long: "255 characters or fewer",
+    leading_hyphen: "must not start with '-'",
+    double_dot: "must not contain '..'",
+    lock_suffix: "must not end with '.lock'",
+    control_character: "must not contain control characters",
+};