@loucompanion/forge-bridge 0.1.3-dev.b6be5e7f9668 → 0.1.3-dev.ba7d36726eda

package/dist/session/phase-completion.helpers.js

@@ -0,0 +1,665 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { debugCompletionPhaseOrder, debugGateToolNames, decomposeCompletionGateOrder, decomposeGateToolNames, draftCompletionGateOrder, draftGateToolNames, qaCompletionGateOrder, qaGateToolNames, resolvedFindingStatuses } from "./phase-completion.js";
+export function normalizeArtifactPayload(payload, defaults) {
+    const normalized = stripUndefined({ ...payload });
+    delete normalized.report_markdown;
+    delete normalized.content_hash;
+    delete normalized.contentHash;
+    normalized.schema_version = numberOrDefault(normalized.schema_version, 1);
+    normalized.phase = defaults.phase;
+    normalized.work_item_id = defaults.workItemId;
+    const ownerFields = artifactOwnerFields(defaults);
+    Object.assign(normalized, ownerFields);
+    normalized.status = defaults.status;
+    normalized.produced_by = defaults.producedBy;
+    return normalized;
+}
+export function normalizeQaGateArtifactPayload(payload, defaults) {
+    const normalized = stripUndefined({ ...payload });
+    delete normalized.report_markdown;
+    delete normalized.content_hash;
+    delete normalized.contentHash;
+    normalized.schema_version = numberOrDefault(normalized.schema_version, 1);
+    normalized.phase = "qa";
+    normalized.gate = defaults.gate;
+    normalized.work_item_id = defaults.workItemId;
+    const ownerFields = artifactOwnerFields(defaults);
+    Object.assign(normalized, ownerFields);
+    normalized.status = defaults.status;
+    normalized.produced_by = defaults.producedBy;
+    if (defaults.gate === "qa_plan") {
+        const checklist = qaStringArray(normalized, "checklist");
+        normalized.checklist = checklist.length > 0 ? checklist : defaultQaChecklist(defaults.status);
+        normalized.acceptance_criteria = qaStringArray(normalized, "acceptance_criteria");
+    }
+    if (defaults.gate === "qa_findings") {
+        normalized.findings = qaObjectArray(normalized, "findings");
+        normalized.candidate_bugs = qaObjectArray(normalized, "candidate_bugs");
+    }
+    return normalized;
+}
+export function reportMarkdown(payload, phase, status, producedBy, contentHash) {
+    const explicit = optionalString(payload, "report_markdown");
+    if (explicit) {
+        return explicit.endsWith("\n") ? explicit : `${explicit}\n`;
+    }
+    const summary = optionalString(payload, "summary") ?? "No summary provided.";
+    return `# Forge ${phase.replace(/_/g, " ")} completion
+
+Status: ${status}
+Produced by: ${producedBy}
+Content hash: ${contentHash}
+
+## Summary
+
+${summary}
+`;
+}
+export function parseStrictCompletionPhase(value) {
+    const normalized = (value ?? "").trim().toLowerCase().replace(/-/g, "_");
+    const debugPhase = normalizeDebugCompletionPhase(normalized);
+    if (debugPhase) {
+        return debugPhase;
+    }
+    if (normalized === "implementation" || normalized === "implement" || normalized === "develop") {
+        return "implementation";
+    }
+    if (normalized === "self_review" || normalized === "selfreview" || normalized === "review") {
+        return "self_review";
+    }
+    if (normalized === "validate" || normalized === "validation") {
+        return "validation";
+    }
+    if (normalized === "qa" || normalized === "quality_assurance" || normalized === "qualityassurance") {
+        return "qa";
+    }
+    if (normalized === "architect" || normalized === "architect_plan" || normalized === "planning" || normalized === "plan") {
+        return "architect";
+    }
+    if (normalized === "draft" || normalized === "drafting" || normalized === "draft_work_order") {
+        return "draft";
+    }
+    if (normalized === "decompose" || normalized === "decomposition" || normalized === "work_order_decomposition" || normalized === "feature_decomposition") {
+        return "decompose";
+    }
+    return null;
+}
+export function normalizeDebugCompletionPhase(value) {
+    const normalized = (value ?? "").trim().toLowerCase().replace(/-/g, "_");
+    switch (normalized) {
+        case "debug_repro":
+        case "debugrepro":
+        case "repro":
+        case "reproduce":
+            return "debug_repro";
+        case "debug_root_cause":
+        case "debugrootcause":
+        case "root_cause":
+        case "rootcause":
+            return "debug_root_cause";
+        case "debug_fix":
+        case "debugfix":
+        case "fix":
+            return "debug_fix";
+        case "debug_regression":
+        case "debugregression":
+        case "regression":
+            return "debug_regression";
+        default:
+            return null;
+    }
+}
+export function isDevelopCompletionPhase(phase) {
+    return phase === "implementation" || phase === "self_review" || phase === "validation";
+}
+export function isDebugCompletionPhase(phase) {
+    return debugCompletionPhaseOrder.includes(phase);
+}
+export function asDebugCompletionPhase(phase) {
+    if (isDebugCompletionPhase(phase)) {
+        return phase;
+    }
+    throw new Error(`Expected Debug completion phase, got ${phase}.`);
+}
+export function parseCompletionRedactionSecrets(raw) {
+    if (!raw?.trim()) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.filter((value) => typeof value === "string" && value.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+export function phaseFromToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    if (normalized === "forge.complete_implementation" || normalized === "complete_implementation") {
+        return "implementation";
+    }
+    if (normalized === "forge.complete_self_review" || normalized === "complete_self_review") {
+        return "self_review";
+    }
+    if (normalized === "forge.complete_validation" || normalized === "complete_validation") {
+        return "validation";
+    }
+    if (normalized === "forge.complete_qa" || normalized === "complete_qa") {
+        return "qa";
+    }
+    if (normalized === "forge.complete_architect_plan" || normalized === "complete_architect_plan") {
+        return "architect";
+    }
+    if (draftGateFromToolName(toolName)) {
+        return "draft";
+    }
+    if (decomposeGateFromToolName(toolName)) {
+        return "decompose";
+    }
+    const debugGate = debugGateFromToolName(toolName);
+    if (debugGate) {
+        return debugGate;
+    }
+    if (qaGateFromToolName(toolName)) {
+        return "qa";
+    }
+    throw new Error(`Unknown Forge completion tool: ${toolName}`);
+}
+export function draftGateFromToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    for (const gate of draftCompletionGateOrder) {
+        const base = draftGateToolNames[gate];
+        if (normalized === `forge.${base}` || normalized === base) {
+            return gate;
+        }
+    }
+    return null;
+}
+export function decomposeGateFromToolName(toolName) {
+    for (const gate of decomposeCompletionGateOrder) {
+        const base = decomposeGateToolNames[gate];
+        if (toolName === base || toolName === `forge.${base}`) {
+            return gate;
+        }
+    }
+    return null;
+}
+export function isDecomposeDispatch(dispatch) {
+    const draftKind = dispatch.draft?.kind?.trim().toLowerCase();
+    return dispatch.execution.lane.trim().toLowerCase() === "decompose"
+        || dispatch.session.lane.trim().toLowerCase() === "decompose"
+        || draftKind === "work_order_decomposition"
+        || draftKind === "feature_decomposition";
+}
+export function debugGateFromToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    for (const gate of debugCompletionPhaseOrder) {
+        const base = debugGateToolNames[gate];
+        if (normalized === `forge.${base}` || normalized === base) {
+            return gate;
+        }
+    }
+    return null;
+}
+export function qaGateFromToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    for (const gate of qaCompletionGateOrder) {
+        const base = qaGateToolNames[gate];
+        if (normalized === `forge.${base}` || normalized === base) {
+            return gate;
+        }
+    }
+    return null;
+}
+export function requireField(payload, key) {
+    if (payload[key] === undefined || payload[key] === null || (typeof payload[key] === "string" && payload[key].trim().length === 0)) {
+        throw new Error(`${key} is required.`);
+    }
+}
+export function requireNonPassEvidence(payload) {
+    const evidenceKeys = ["blockers", "known_gaps", "findings", "remaining_risks", "commands", "failures"];
+    const hasEvidence = evidenceKeys.some((key) => {
+        const value = payload[key];
+        if (typeof value === "string") {
+            return value.trim().length > 0;
+        }
+        if (Array.isArray(value)) {
+            return value.length > 0;
+        }
+        return Boolean(value && typeof value === "object");
+    });
+    if (!hasEvidence) {
+        throw new Error("non-pass completion requires explicit blockers, findings, failures, or known gaps.");
+    }
+}
+export function requireImplementationEvidence(payload) {
+    const knownGaps = payload.known_gaps;
+    const hasKnownGap = Array.isArray(knownGaps) && knownGaps.length > 0;
+    for (const key of ["changed_files", "tests_added_or_updated", "docs_added_or_updated"]) {
+        const value = payload[key];
+        if (Array.isArray(value) && value.length === 0 && !hasKnownGap) {
+            throw new Error(`${key} is empty; known_gaps must explain why.`);
+        }
+    }
+}
+export function requirePassingCommands(payload) {
+    const commands = payload.commands;
+    if (!Array.isArray(commands)) {
+        return;
+    }
+    if (commands.length === 0) {
+        throw new Error("commands must include at least one deterministic validation command.");
+    }
+    for (const [index, command] of commands.entries()) {
+        if (!command || typeof command !== "object" || Array.isArray(command)) {
+            throw new Error(`commands[${index}] must be an object.`);
+        }
+        const record = command;
+        if (typeof record.command !== "string" || record.command.trim().length === 0) {
+            throw new Error(`commands[${index}].command must be a non-empty string.`);
+        }
+        if (typeof record.summary !== "string" || record.summary.trim().length === 0) {
+            throw new Error(`commands[${index}].summary must be a non-empty string.`);
+        }
+        if (typeof record.exit_code !== "number" || !Number.isFinite(record.exit_code)) {
+            throw new Error(`commands[${index}].exit_code must be a finite number.`);
+        }
+        if (record.exit_code !== 0) {
+            throw new Error(`commands[${index}].exit_code must be 0 when status is pass.`);
+        }
+        const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
+        if (status !== "pass") {
+            throw new Error(`commands[${index}].status must be pass.`);
+        }
+    }
+}
+export function requireArray(payload, key) {
+    if (!Array.isArray(payload[key])) {
+        throw new Error(`${key} must be an array.`);
+    }
+}
+export function requireNonEmptyArray(payload, key) {
+    requireArray(payload, key);
+    if (arrayLength(payload, key) === 0) {
+        throw new Error(`${key} must include at least one value.`);
+    }
+}
+export function arrayLength(payload, key) {
+    const value = payload[key];
+    return Array.isArray(value) ? value.length : 0;
+}
+export function requireAllowedStatus(payload, key, allowed) {
+    const value = normalizedString(optionalString(payload, key));
+    if (!allowed.includes(value)) {
+        throw new Error(`${key} must be one of ${allowed.join(", ")}.`);
+    }
+}
+export function requireObject(payload, key) {
+    const value = payload[key];
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${key} must be an object.`);
+    }
+}
+export function requiredRecord(payload, key) {
+    requireObject(payload, key);
+    return payload[key];
+}
+export function requireBoolean(payload, key) {
+    if (typeof payload[key] !== "boolean") {
+        throw new Error(`${key} must be a boolean.`);
+    }
+}
+export function requireNumericOne(payload, key, pathLabel) {
+    if (payload[key] !== 1) {
+        throw new Error(`${pathLabel}: expected numeric 1; correction: set ${pathLabel} to 1.`);
+    }
+}
+export function requireSatisfiedAcceptanceCriteria(payload) {
+    const criteria = payload.acceptance_criteria;
+    if (!Array.isArray(criteria)) {
+        return;
+    }
+    for (const [index, criterion] of criteria.entries()) {
+        if (!criterion || typeof criterion !== "object" || Array.isArray(criterion)) {
+            throw new Error(`acceptance_criteria[${index}] must be an object.`);
+        }
+        const record = criterion;
+        const status = optionalString(record, "status")?.toLowerCase();
+        const evidence = optionalString(record, "evidence");
+        if (status !== "satisfied" || !evidence) {
+            throw new Error(`acceptance_criteria[${index}] must be satisfied with evidence for status pass.`);
+        }
+    }
+}
+export function validateResolvedFindings(payload) {
+    const resolvedFindings = payload.resolved_findings;
+    if (resolvedFindings === undefined || resolvedFindings === null) {
+        return;
+    }
+    if (!Array.isArray(resolvedFindings)) {
+        throw new Error("resolved_findings must be an array.");
+    }
+    for (const [index, finding] of resolvedFindings.entries()) {
+        const prefix = `resolved_findings[${index}].`;
+        if (!finding || typeof finding !== "object" || Array.isArray(finding)) {
+            throw new Error(`resolved_findings[${index}] must be an object.`);
+        }
+        const record = finding;
+        requireNonEmptyStringRecord(record, "qa_id", prefix);
+        requireKnownStringRecord(record, "status", resolvedFindingStatuses, prefix);
+        requireNonEmptyStringRecord(record, "summary", prefix);
+        requireSubstantiveValueRecord(record, "evidence", prefix);
+        requireArrayRecord(record, "changed_files", prefix);
+        requireArrayRecord(record, "tests_added_or_updated", prefix);
+        requireSubstantiveValueRecord(record, "regression_evidence", prefix);
+        if (normalizedString(record.status) === "resolved") {
+            if (record.changed_files.length === 0) {
+                throw new Error(`${prefix}changed_files must include at least one changed file for resolved QA findings.`);
+            }
+            if (record.tests_added_or_updated.length === 0) {
+                throw new Error(`${prefix}tests_added_or_updated must include at least one regression test for resolved QA findings.`);
+            }
+        }
+    }
+}
+export function qaEvidenceSource(payload) {
+    const evidence = payload.evidence;
+    return evidence && typeof evidence === "object" && !Array.isArray(evidence)
+        ? evidence
+        : {};
+}
+export function qaArray(payload, key, fallback = {}) {
+    const value = payload[key] ?? fallback[key];
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${key} must be an array.`);
+    }
+    return value;
+}
+export function qaObjectArray(payload, key) {
+    return qaArray(payload, key).map((entry, index) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new Error(`${key}[${index}] must be an object.`);
+        }
+        return entry;
+    });
+}
+export function qaPolicyWarnings(payload) {
+    return qaArray(payload, "policy_warnings").map((entry, index) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new Error(`policy_warnings[${index}] must be an object.`);
+        }
+        const warning = entry;
+        const prefix = `policy_warnings[${index}].`;
+        requireNonEmptyStringRecord(warning, "code", prefix);
+        requireNonEmptyStringRecord(warning, "message", prefix);
+        const normalized = {
+            ...warning,
+            code: optionalString(warning, "code"),
+            message: optionalString(warning, "message")
+        };
+        if (warning.severity !== undefined && warning.severity !== null) {
+            requireNonEmptyStringRecord(warning, "severity", prefix);
+            normalized.severity = optionalString(warning, "severity");
+        }
+        return normalized;
+    });
+}
+export function qaStringArray(payload, key) {
+    const value = payload[key];
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${key} must be an array.`);
+    }
+    return value.map((entry, index) => {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+            throw new Error(`${key}[${index}] must be a non-empty string.`);
+        }
+        return entry;
+    });
+}
+export function requireEvidenceRecord(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+}
+export function requireNonEmptyStringRecord(source, key, prefix = "") {
+    if (!optionalString(source, key)) {
+        throw new Error(`${prefix}${key} is required.`);
+    }
+}
+export function requireArrayRecord(source, key, prefix = "") {
+    if (!Array.isArray(source[key])) {
+        throw new Error(`${prefix}${key} must be an array.`);
+    }
+}
+export function requireKnownStringRecord(source, key, allowed, prefix = "") {
+    const value = normalizedString(optionalString(source, key));
+    if (!allowed.has(value)) {
+        throw new Error(`${prefix}${key} must be one of ${[...allowed].sort().join(", ")}.`);
+    }
+}
+export function requireNonEmptyStringArrayRecord(source, key, prefix = "") {
+    const value = source[key];
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`${prefix}${key} must include at least one value.`);
+    }
+    for (const [index, entry] of value.entries()) {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+            throw new Error(`${prefix}${key}[${index}] must be a non-empty string.`);
+        }
+    }
+}
+export function requireSubstantiveValueRecord(source, key, prefix = "") {
+    if (!hasSubstantiveJsonValue(source[key])) {
+        throw new Error(`${prefix}${key} must include at least one concrete evidence reference or summary.`);
+    }
+}
+export function requireSubstantiveEvidenceRecord(source, prefix = "") {
+    const evidence = source.evidence;
+    if (!evidence || typeof evidence !== "object" || Array.isArray(evidence)) {
+        throw new Error(`${prefix}evidence must be an object.`);
+    }
+    if (!Object.values(evidence).some(hasSubstantiveJsonValue)) {
+        throw new Error(`${prefix}evidence must include at least one concrete evidence reference or summary.`);
+    }
+}
+export function hasSubstantiveJsonValue(value) {
+    if (typeof value === "string") {
+        return value.trim().length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    if (value && typeof value === "object") {
+        return Object.keys(value).length > 0;
+    }
+    return false;
+}
+export function normalizedString(value) {
+    return typeof value === "string" ? value.trim().toLowerCase().replace(/-/g, "_") : "";
+}
+export function normalizedOwnerType(value) {
+    const normalized = normalizedString(value);
+    return normalized === "work_item" || normalized === "story" ? normalized : undefined;
+}
+export function artifactOwnerFields(config) {
+    const ownerType = normalizedOwnerType(config.ownerType);
+    const ownerId = config.ownerId?.trim();
+    if (!ownerType && !ownerId) {
+        return {};
+    }
+    return {
+        owner_type: ownerType ?? "work_item",
+        owner_id: ownerId || config.workItemId
+    };
+}
+export function artifactReferenceOwnerFields(config) {
+    const owner = artifactOwnerFields(config);
+    return owner.owner_type && owner.owner_id
+        ? { ownerType: owner.owner_type, ownerId: owner.owner_id }
+        : {};
+}
+export function artifactOwnerDirectory(ownerType) {
+    return normalizedOwnerType(ownerType) === "story" ? "stories" : "work-items";
+}
+export function artifactOwnerRelativeRoot(ownerType, ownerId, workItemId) {
+    const owner = artifactOwnerFields({ workItemId, ownerType, ownerId });
+    return owner.owner_type && owner.owner_id
+        ? [".forge", artifactOwnerDirectory(owner.owner_type), owner.owner_id, "artifacts"].join("/")
+        : [".forge", "work-items", workItemId, "artifacts"].join("/");
+}
+export function defaultQaChecklist(status) {
+    return [
+        "Review the validated work item against acceptance criteria.",
+        "Inspect implementation, self-review, and validation evidence when available.",
+        status === "blocked" ? "Record the blocker reason preventing a conclusive QA verdict." : "Record concrete QA evidence and findings."
+    ];
+}
+export function qaArtifactRelativePath(workItemId, fileName) {
+    return [".forge", "work-items", workItemId, "artifacts", fileName].join("/");
+}
+export function qaArtifactRelativePathForOwner(ownerType, ownerId, fileName) {
+    return [".forge", artifactOwnerDirectory(ownerType), ownerId, "artifacts", fileName].join("/");
+}
+export function jsonText(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+export function fallbackReport(parsed, phase, artifactPath) {
+    return `# Forge ${phase.replace(/_/g, " ")} completion
+
+Artifact: ${artifactPath}
+Status: ${optionalString(parsed, "status") ?? "unknown"}
+`;
+}
+export function parseJsonObject(content, label) {
+    try {
+        return asRecord(JSON.parse(content), label);
+    }
+    catch (error) {
+        throw new Error(`${label} is not valid JSON: ${errorMessage(error)}`, { cause: error });
+    }
+}
+export function parseOptionalJsonObject(content, label) {
+    if (!content.trim()) {
+        return {};
+    }
+    return parseJsonObject(content, label);
+}
+export function asRecord(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    return value;
+}
+export function asMutableRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? { ...value }
+        : {};
+}
+export function requiredString(source, key) {
+    const value = source[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${key} must be a non-empty string.`);
+    }
+    return value;
+}
+export function optionalString(source, key) {
+    const value = source[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+export function numberOrDefault(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+export function stripUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+export function safePathSegment(value, label) {
+    if (!value.trim() || value.includes("/") || value.includes("\\") || value === "." || value === "..") {
+        throw new Error(`${label} is not a safe path segment.`);
+    }
+    return value;
+}
+export async function readOptionalFile(filePath) {
+    return await fs.readFile(filePath, "utf8").catch((error) => {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    });
+}
+export async function writeFileAtomic(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+    await fs.writeFile(tempPath, content, "utf8");
+    await fs.rename(tempPath, filePath);
+}
+export function stableStringify(value) {
+    return JSON.stringify(sortJson(value));
+}
+export function sortJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortJson);
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, sortJson(entry)]));
+    }
+    return value;
+}
+export function sha256(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+}
+export function forgeBridgeCliBinPath() {
+    return fileURLToPath(new URL("../cli/bin.js", import.meta.url));
+}
+export function tomlString(value) {
+    if (value.includes("'''")) {
+        throw new Error("Codex MCP configuration values cannot contain three consecutive apostrophes.");
+    }
+    // Codex config overrides pass through npm's PowerShell shim on Windows.
+    // Literal TOML strings survive that boundary; basic-string double quotes do not.
+    return `'''${value}'''`;
+}
+export function tomlStringArray(values) {
+    return `[${values.map(tomlString).join(", ")}]`;
+}
+export function writeJsonRpc(message) {
+    process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+export function rpcError(code, message) {
+    return { code, message };
+}
+export function asJsonRpcMessage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const message = value;
+    if (message.jsonrpc !== "2.0" || typeof message.method !== "string") {
+        return null;
+    }
+    const id = message.id;
+    return {
+        id: typeof id === "string" || typeof id === "number" || id === null ? id : undefined,
+        method: message.method,
+        params: message.params
+    };
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}