@bridge_gpt/mcp-server 0.2.59 → 0.2.60

package/build/conductor-bundle-cli.js

@@ -1,256 +0,0 @@
-/**
- * BAPI-634: thin CLI handler exposing the deterministic conductor-bundle helpers
- * to `emit-conductor-bundle.md`.
- *
- * Why this exists: the instruction ships **compiled** to consuming repositories
- * inside `build/pipelines.generated.js`. `mcp_server/src/` does not exist there,
- * so an instruction that told the agent to "call `validateConductorBundleInputs`"
- * would be referencing a path only this repository has. This subcommand is the
- * reachable surface, mirroring how `store-and-approve-epic-plan.md` invokes
- * `setup-epic` rather than hand-rolling HTTP calls.
- *
- * It holds no policy of its own: it parses argv, delegates to
- * `conductor-bundle-artifacts.ts`, and prints a JSON envelope. All I/O is behind
- * an injectable seam so tests never touch a real disk or construct a server.
- */
-import path from "node:path";
-import { finalizeEpicPlanSidecar, serializeSiblingTicketManifest, validateConductorBundleInputs, writeJsonAtomically, } from "./conductor-bundle-artifacts.js";
-const USAGE = [
-    "Usage: emit-conductor-bundle <validate|finalize> --input <file> [--docs-dir <dir>] [--json]",
-    "",
-    "  validate   Validate identities, the node->ticket mapping, manifest agreement,",
-    "             and path containment. Writes nothing.",
-    "  finalize   Validate, then finalize epic-plan.dag.json with real keys and",
-    "             per-node touched_files, and write the sibling-ticket manifest.",
-    "",
-    "Options:",
-    "  --input <file>     JSON document with epic_key, epic_slug, mappings,",
-    "                     decomposition_fingerprint, and (for finalize)",
-    "                     touched_files_by_key.",
-    "  --docs-dir <dir>   Docs directory (default: $BAPI_DOCS_DIR, else docs/tmp).",
-    "  --json             Emit a machine-readable result on stdout.",
-    "  -h, --help         Show this help.",
-].join("\n");
-/** Read a flag's value, rejecting a missing or flag-shaped value. */
-function takeValue(argv, index, flag) {
-    const value = argv[index + 1];
-    if (value === undefined || value.startsWith("-")) {
-        throw new Error(`Flag "${flag}" requires a value.`);
-    }
-    return value;
-}
-/** Parse argv into options, or throw with an actionable message. */
-export function parseConductorBundleArgs(argv) {
-    const mode = argv[0];
-    if (mode === "-h" || mode === "--help" || mode === undefined) {
-        return { mode: "validate", inputFile: "", json: false, help: true };
-    }
-    if (mode !== "validate" && mode !== "finalize") {
-        throw new Error(`Unknown subcommand "${mode}". Expected "validate" or "finalize".`);
-    }
-    let inputFile;
-    let docsDir;
-    let json = false;
-    let help = false;
-    for (let i = 1; i < argv.length; i++) {
-        const arg = argv[i];
-        switch (arg) {
-            case "--input":
-                inputFile = takeValue(argv, i, "--input");
-                i++;
-                break;
-            case "--docs-dir":
-                docsDir = takeValue(argv, i, "--docs-dir");
-                i++;
-                break;
-            case "--json":
-                json = true;
-                break;
-            case "-h":
-            case "--help":
-                help = true;
-                break;
-            default:
-                throw new Error(`Unknown argument "${arg}".`);
-        }
-    }
-    if (help)
-        return { mode, inputFile: inputFile ?? "", docsDir, json, help: true };
-    if (!inputFile)
-        throw new Error('Flag "--input" is required.');
-    return { mode, inputFile, docsDir, json, help: false };
-}
-/** Parse JSON, converting a syntax error into an actionable message. */
-async function readJson(filePath, fs, label) {
-    let raw;
-    try {
-        raw = await fs.readFile(filePath);
-    }
-    catch (err) {
-        throw new Error(`Could not read ${label} at ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch (err) {
-        throw new Error(`${label} at ${filePath} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-/** Read an optional JSON file, returning null when it does not exist. */
-async function readOptionalJson(filePath, fs, label) {
-    try {
-        await fs.readFile(filePath);
-    }
-    catch {
-        return null;
-    }
-    return readJson(filePath, fs, label);
-}
-/**
- * Run the `emit-conductor-bundle` subcommand. Returns a process exit code; never
- * throws for an expected validation failure.
- */
-export async function runConductorBundleCli(argv, overrides = {}) {
-    const deps = {
-        env: process.env,
-        cwd: process.cwd(),
-        fs: createDefaultBundleFs(),
-        log: (m) => console.log(m),
-        // Diagnostics go to stderr so `--json` keeps stdout a single result object.
-        errorLog: (m) => console.error(m),
-        ...overrides,
-    };
-    let opts;
-    try {
-        opts = parseConductorBundleArgs(argv);
-    }
-    catch (err) {
-        deps.errorLog(err instanceof Error ? err.message : String(err));
-        deps.errorLog(USAGE);
-        return 1;
-    }
-    if (opts.help) {
-        deps.log(USAGE);
-        return 0;
-    }
-    const emitFailure = (error) => {
-        if (opts.json)
-            deps.log(JSON.stringify({ ok: false, error }));
-        else
-            deps.errorLog(`Error: ${error}`);
-        return 1;
-    };
-    const docsDir = path.resolve(deps.cwd, opts.docsDir ?? deps.env.BAPI_DOCS_DIR ?? path.join("docs", "tmp"));
-    let input;
-    try {
-        input = (await readJson(path.resolve(deps.cwd, opts.inputFile), deps.fs, "--input document"));
-    }
-    catch (err) {
-        return emitFailure(err instanceof Error ? err.message : String(err));
-    }
-    if (!input || typeof input !== "object") {
-        return emitFailure("--input document must be a JSON object.");
-    }
-    const epicDir = path.resolve(docsDir, "epic-plans", String(input.epic_slug));
-    const sidecarPath = path.join(epicDir, "epic-plan.dag.json");
-    const manifestPath = path.join(epicDir, "sibling-ticket-manifest.json");
-    let sidecar;
-    let existingManifest;
-    try {
-        sidecar = await readJson(sidecarPath, deps.fs, "epic-plan.dag.json");
-        existingManifest = await readOptionalJson(manifestPath, deps.fs, "sibling-ticket-manifest.json");
-    }
-    catch (err) {
-        return emitFailure(err instanceof Error ? err.message : String(err));
-    }
-    const validation = await validateConductorBundleInputs({
-        epic_key: input.epic_key,
-        epic_slug: input.epic_slug,
-        docs_dir: docsDir,
-        mappings: input.mappings,
-        sidecar,
-        existing_manifest: existingManifest ?? undefined,
-        decomposition_fingerprint: input.decomposition_fingerprint,
-    }, deps.fs);
-    if (!validation.ok)
-        return emitFailure(validation.error);
-    if (opts.mode === "validate") {
-        const result = {
-            ok: true,
-            mode: "validate",
-            epic_key: validation.value.epic_key,
-            plan_version: validation.value.plan_version,
-            mapped_nodes: validation.value.mappings.length,
-            sidecar_path: validation.value.sidecar_path,
-        };
-        if (opts.json)
-            deps.log(JSON.stringify(result));
-        else {
-            deps.log(`Validated ${result.mapped_nodes} node mapping(s) for ${result.epic_key} ` +
-                `(plan v${result.plan_version}). Nothing was written.`);
-        }
-        return 0;
-    }
-    // ---- finalize ----------------------------------------------------------
-    const nodeKeyMap = {};
-    for (const m of validation.value.mappings) {
-        nodeKeyMap[m.plan_node_id] = m.ticket_key;
-    }
-    const finalized = finalizeEpicPlanSidecar({
-        sidecar,
-        node_key_map: nodeKeyMap,
-        touched_files_by_key: input.touched_files_by_key ?? {},
-        plan_version_already_stored: input.plan_version_already_stored === true,
-    });
-    if (!finalized.ok)
-        return emitFailure(finalized.error);
-    const sidecarWrite = await writeJsonAtomically(validation.value.sidecar_path, finalized.value, deps.fs);
-    if (!sidecarWrite.ok)
-        return emitFailure(sidecarWrite.error);
-    const manifest = serializeSiblingTicketManifest({
-        schema_version: 1,
-        epic_key: validation.value.epic_key,
-        epic_slug: validation.value.epic_slug,
-        plan_version: validation.value.plan_version,
-        decomposition_fingerprint: input.decomposition_fingerprint,
-        finalized_fingerprint: null,
-        run_phase: input.run_phase ?? "staged",
-        mappings: validation.value.mappings.map((m) => ({
-            plan_node_id: m.plan_node_id,
-            ticket_key: m.ticket_key,
-            exploration_path: m.exploration_path,
-            draft_path: m.draft_path,
-        })),
-        decisions: [],
-        completed_mutations: [],
-    });
-    const manifestWrite = await writeJsonAtomically(validation.value.manifest_path, manifest, deps.fs);
-    if (!manifestWrite.ok)
-        return emitFailure(manifestWrite.error);
-    const result = {
-        ok: true,
-        mode: "finalize",
-        epic_key: validation.value.epic_key,
-        plan_version: validation.value.plan_version,
-        sidecar_path: validation.value.sidecar_path,
-        manifest_path: validation.value.manifest_path,
-        ticket_keys: validation.value.mappings.map((m) => m.ticket_key),
-    };
-    if (opts.json)
-        deps.log(JSON.stringify(result));
-    else {
-        deps.log(`Finalized ${result.sidecar_path} with ${result.ticket_keys.length} real key(s) ` +
-            `and per-node touched_files. Manifest: ${result.manifest_path}`);
-    }
-    return 0;
-}
-/** Real filesystem seam, loaded lazily so importing this module stays cheap. */
-function createDefaultBundleFs() {
-    return {
-        readFile: async (p) => (await import("node:fs/promises")).readFile(p, "utf-8"),
-        writeFile: async (p, data) => (await import("node:fs/promises")).writeFile(p, data, "utf-8"),
-        rename: async (from, to) => (await import("node:fs/promises")).rename(from, to),
-        unlink: async (p) => (await import("node:fs/promises")).unlink(p),
-        realpath: async (p) => (await import("node:fs/promises")).realpath(p),
-    };
-}

package/build/direct-ticket-tools.js

@@ -1,70 +0,0 @@
-/**
- * direct-ticket-tools — agent-facing entry points for the ticket updater and the
- * single-ticket estimator (BAPI-711).
- *
- * Both flows were previously reachable only through a Jira-shaped webhook. In
- * Jira mode Jira is the driver; in local mode the driver is the agent, which
- * already talks to Bridge directly — so the fix is not a local event emitter, it
- * is a direct entry point. These tools are that entry point.
- *
- * Two properties are load-bearing:
- *
- *   - The repository is INJECTED from `BAPI_REPO_NAME`, never accepted from the
- *     agent. An agent-supplied repo would let a tool call address a repository
- *     the session was not configured for; the backend re-authorizes it anyway,
- *     but the schema should not invite the attempt.
- *   - Every outcome — success, duplicate-active, and backend error — resolves to
- *     a normal text content envelope. Throwing through the MCP transport turns a
- *     recoverable 429 into a dead session.
- */
-function text(value) {
-    return { content: [{ type: "text", text: value }] };
-}
-/**
- * POST a direct-invocation request and render its outcome as normal content.
- *
- * A connection failure is reported as text rather than rethrown: the submission
- * outcome is genuinely unknown at that point, and the recoverable action (poll
- * `get_ticket_state`) is the same either way.
- */
-async function postDirectInvocation(deps, path, body, ticketNumber) {
-    let resp;
-    try {
-        resp = await (deps.fetchImpl ?? fetch)(deps.buildUrl(path), {
-            method: "POST",
-            headers: await deps.getPostHeaders(),
-            body: JSON.stringify({ ...body, repo_name: deps.repoName }),
-        });
-    }
-    catch {
-        return text(`The request could not be delivered, so it is unknown whether it was accepted. ` +
-            `Call get_ticket_state for ${ticketNumber} to check before retrying.`);
-    }
-    if (!resp.ok) {
-        return text(await deps.handleResponse(resp));
-    }
-    return text(await resp.text());
-}
-export async function runRequestTicketUpdate(args, deps) {
-    return postDirectInvocation(deps, `/ticket/${encodeURIComponent(args.ticket_number)}/generate-ticket-update`, {}, args.ticket_number);
-}
-export async function runRequestEstimate(args, deps) {
-    return postDirectInvocation(deps, `/ticket/${encodeURIComponent(args.ticket_number)}/generate-estimate`, 
-    // Sent explicitly rather than omitted so the backend default and the tool
-    // default can never drift apart silently.
-    { recreate: args.recreate === true }, args.ticket_number);
-}
-export async function runGetTicketUpdateReview(args, deps) {
-    const url = deps.buildGetUrl(`/ticket/${encodeURIComponent(args.ticket_number)}/ticket-update-review`, { repo_name: deps.repoName });
-    let resp;
-    try {
-        resp = await (deps.fetchImpl ?? fetch)(url, { headers: await deps.getHeaders() });
-    }
-    catch {
-        return text(`The held-for-review proposal for ${args.ticket_number} could not be fetched. Retry shortly.`);
-    }
-    if (!resp.ok) {
-        return text(await deps.handleResponse(resp));
-    }
-    return text(await resp.text());
-}

package/build/executor/reconcile-overlap-governance.js

@@ -1,129 +0,0 @@
-/**
- * Governance-region comparison for `reconcile_overlap` (BAPI-1152).
- *
- * Before the wrapper pushes, the candidate tree is compared against the
- * governance-guarded regions the SERVER found in the INPUT epic head
- * (`required_epic_sha`). A candidate that changes any protected region — its
- * content OR either marker line — is never pushed: the job reports the
- * `governance_guard_change_required` fact and the reconciler parks naming the tag.
- *
- * This module deliberately does NOT parse the marker grammar. The server owns it
- * (`api/library/epic_conductor/governance_markers.py`) and ships each region as
- * its exact BEGIN and END marker lines plus the SHA-256 of the region's content,
- * markers included. Here a region is located by those exact lines and compared by
- * hash — never by line number, which an edit above the region would shift without
- * touching anything it protects. A second grammar implementation would be a
- * second place for the two to disagree about what is protected.
- *
- * Fail-closed everywhere the comparison cannot be proven:
- *   - the region's file is gone from the candidate (deleted or renamed), binary,
- *     or unreadable;
- *   - a marker line is missing, duplicated, or out of order;
- *   - the server reported the file's marker structure unprovable (unbalanced,
- *     nested, mismatched, or over the scan bound) and the candidate changes it;
- *   - the candidate changes a file the server did NOT scan and either side of that
- *     change contains a marker token — the server made no statement about it.
- * The last two carry the synthetic tag {@link UNPROVABLE_GOVERNANCE_TAG}, which is
- * itself valid marker grammar, so the park still names something greppable.
- */
-import { createHash } from "node:crypto";
-/** The synthetic tag for protection the comparison could not prove. */
-export const UNPROVABLE_GOVERNANCE_TAG = "GOVERNANCE_MARKERS_UNPROVABLE";
-/** The token every governance marker line contains. */
-export const GOVERNANCE_MARKER_TOKEN = "BRIDGE-GOVERNANCE-GUARD-";
-/** Bounds on the reported fact (mirrors the server's result-model bounds). */
-export const GOVERNANCE_FACT_MAX_FINDINGS = 8;
-export const GOVERNANCE_FACT_MAX_PATHS = 8;
-/**
- * Split text into lines exactly the way Python's `str.splitlines()` does, so the
- * region hash computed here matches the one the server computed.
- */
-export function splitLinesLikePython(text) {
-    const lines = text.split(/\r\n|[\n\r\v\f\x1c\x1d\x1e\x85\u2028\u2029]/);
-    // `splitlines()` yields no trailing empty entry for a terminal line break.
-    if (lines.length > 0 && lines[lines.length - 1] === "")
-        lines.pop();
-    return lines;
-}
-function sha256(text) {
-    return createHash("sha256").update(text, "utf8").digest("hex");
-}
-function indicesOf(lines, needle) {
-    const out = [];
-    lines.forEach((line, index) => {
-        if (line === needle)
-            out.push(index);
-    });
-    return out;
-}
-/** True when a region is intact in `text`: both markers once, in order, same hash. */
-function regionIntact(text, region) {
-    const lines = splitLinesLikePython(text);
-    const begins = indicesOf(lines, region.beginMarker);
-    const ends = indicesOf(lines, region.endMarker);
-    if (begins.length !== 1 || ends.length !== 1)
-        return false;
-    const [begin] = begins;
-    const [end] = ends;
-    if (end < begin)
-        return false;
-    return sha256(lines.slice(begin, end + 1).join("\n")) === region.contentSha256;
-}
-function containsMarkerToken(read) {
-    // An unreadable or binary side cannot be proven marker-free.
-    if (read.kind === "unreadable" || read.kind === "binary")
-        return true;
-    return read.kind === "text" && read.text.includes(GOVERNANCE_MARKER_TOKEN);
-}
-/**
- * Compare the candidate against the input epic head's governance regions.
- * Returns the structured fact, or `null` when nothing protected is touched.
- */
-export async function scanGovernanceRegions(input) {
-    const hits = new Map();
-    const hit = (tag, path) => {
-        let paths = hits.get(tag);
-        if (!paths) {
-            paths = new Set();
-            hits.set(tag, paths);
-        }
-        paths.add(path);
-    };
-    const changed = new Set(input.changedPaths);
-    for (const region of input.snapshot.regions) {
-        const candidate = await input.readCandidate(region.path);
-        if (candidate.kind !== "text" || !regionIntact(candidate.text, region)) {
-            hit(region.tag, region.path);
-        }
-    }
-    for (const finding of input.snapshot.findings) {
-        if (changed.has(finding.path))
-            hit(UNPROVABLE_GOVERNANCE_TAG, finding.path);
-    }
-    const scanned = new Set(input.snapshot.scannedPaths);
-    for (const path of input.changedPaths) {
-        if (scanned.has(path))
-            continue;
-        const [candidate, original] = await Promise.all([
-            input.readCandidate(path),
-            input.readInput(path),
-        ]);
-        if (containsMarkerToken(candidate) || containsMarkerToken(original)) {
-            hit(UNPROVABLE_GOVERNANCE_TAG, path);
-        }
-    }
-    if (hits.size === 0)
-        return null;
-    const findings = Array.from(hits.entries())
-        .map(([tag, paths]) => ({ tag, paths: Array.from(paths).sort().slice(0, GOVERNANCE_FACT_MAX_PATHS) }))
-        .sort((a, b) => a.tag !== b.tag ? (a.tag < b.tag ? -1 : 1) : (a.paths[0] ?? "") < (b.paths[0] ?? "") ? -1 : 1);
-    const bounded = findings.slice(0, GOVERNANCE_FACT_MAX_FINDINGS);
-    const primary = bounded[0];
-    return {
-        tag: primary.tag,
-        paths: primary.paths,
-        findings: bounded,
-        truncated: findings.length > GOVERNANCE_FACT_MAX_FINDINGS ||
-            Array.from(hits.values()).some((paths) => paths.size > GOVERNANCE_FACT_MAX_PATHS),
-    };
-}