@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/workflows/dag/backend-test-contract-envelope.js

@@ -0,0 +1,205 @@
+/**
+ * Deterministic, fail-closed unique JSON object extraction for backend-test pipelines.
+ *
+ * Accepts pure JSON object, unique fenced json, prose+unique fence, or prose+unique
+ * bracket-balanced bare object. Contracts envelope adds analysis/execution validation.
+ * Semantic review / classification materializers reuse the same scanner.
+ */
+const JSON_FENCE_RE = /```json\s*\r?\n([\s\S]*?)\r?\n```/gi;
+/**
+ * Mask complete Markdown inline-code spans without changing source offsets.
+ * Object-shaped examples inside backticks are prose, not JSON candidates.
+ * Unclosed delimiters stay visible so malformed output cannot hide conflicts.
+ */
+function maskMarkdownInlineCode(text) {
+    const chars = text.split("");
+    for (let index = 0; index < text.length;) {
+        if (text[index] !== "`") {
+            index += 1;
+            continue;
+        }
+        let delimiterLength = 1;
+        while (text[index + delimiterLength] === "`")
+            delimiterLength += 1;
+        if (delimiterLength >= 3) {
+            index += delimiterLength;
+            continue;
+        }
+        const delimiter = "`".repeat(delimiterLength);
+        let close = text.indexOf(delimiter, index + delimiterLength);
+        while (close >= 0 &&
+            (text[close - 1] === "`" || text[close + delimiterLength] === "`")) {
+            close = text.indexOf(delimiter, close + delimiterLength);
+        }
+        if (close < 0) {
+            index += delimiterLength;
+            continue;
+        }
+        const end = close + delimiterLength;
+        for (let cursor = index; cursor < end; cursor += 1) {
+            if (chars[cursor] !== "\n" && chars[cursor] !== "\r")
+                chars[cursor] = " ";
+        }
+        index = end;
+    }
+    return chars.join("");
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Collect balanced top-level `{...}` object spans with string/escape awareness.
+ * Does not use greedy regex to guess JSON.
+ */
+export function findBalancedObjectSpans(text) {
+    return scanBalancedObjectSpans(text).spans;
+}
+function scanBalancedObjectSpans(text) {
+    const spans = [];
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text[i];
+        if (inString) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escape = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === "{") {
+            if (depth === 0)
+                start = i;
+            depth += 1;
+            continue;
+        }
+        if (ch === "}") {
+            if (depth === 0)
+                continue;
+            depth -= 1;
+            if (depth === 0 && start >= 0) {
+                spans.push({ start, end: i + 1 });
+                start = -1;
+            }
+        }
+    }
+    return { spans, unclosedObject: depth !== 0 };
+}
+function collectFencedJsonBlocks(text) {
+    const blocks = [];
+    JSON_FENCE_RE.lastIndex = 0;
+    for (const match of text.matchAll(JSON_FENCE_RE)) {
+        const start = match.index;
+        if (start === undefined)
+            continue;
+        blocks.push({
+            body: match[1] ?? "",
+            start,
+            end: start + match[0].length,
+        });
+    }
+    return blocks;
+}
+function parseObjectJson(candidate, label) {
+    let parsed;
+    try {
+        parsed = JSON.parse(candidate);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`backend-test unique JSON object ${label}: invalid JSON (${detail})`);
+    }
+    if (!isPlainObject(parsed)) {
+        throw new Error(`backend-test unique JSON object ${label}: JSON root must be an object`);
+    }
+    return parsed;
+}
+function countJsonFenceOpenings(text) {
+    return [...text.matchAll(/```json\b/gi)].length;
+}
+function findUniqueJsonObjectText(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        throw new Error("backend-test unique JSON object: empty input; expected one unique JSON object");
+    }
+    // Pure object fast path must run before Markdown recognition so fence-like
+    // tokens inside JSON strings remain ordinary string content.
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (isPlainObject(parsed)) {
+                return trimmed;
+            }
+        }
+        catch {
+            // Fall through to fenced / balanced candidate discovery.
+        }
+    }
+    const fenceOpenings = countJsonFenceOpenings(trimmed);
+    const fences = collectFencedJsonBlocks(trimmed);
+    if (fenceOpenings > fences.length) {
+        throw new Error("backend-test unique JSON object: unclosed fenced json block; expected one unique fenced json block");
+    }
+    if (fences.length > 1) {
+        throw new Error(`backend-test unique JSON object: expected exactly one fenced json block, found ${fences.length}`);
+    }
+    if (fences.length === 1) {
+        const fence = fences[0];
+        const outsideScans = [trimmed.slice(0, fence.start), trimmed.slice(fence.end)]
+            .map((fragment) => scanBalancedObjectSpans(maskMarkdownInlineCode(fragment)));
+        if (outsideScans.some((scan) => scan.unclosedObject)) {
+            throw new Error("backend-test unique JSON object: unclosed JSON object outside fenced json block");
+        }
+        const outsideSpans = outsideScans.flatMap((scan) => scan.spans);
+        if (outsideSpans.length > 0) {
+            throw new Error(`backend-test unique JSON object: expected one unique JSON object, found fenced json plus ${outsideSpans.length} bare object candidate(s)`);
+        }
+        return fence.body;
+    }
+    const scan = scanBalancedObjectSpans(maskMarkdownInlineCode(trimmed));
+    if (scan.unclosedObject) {
+        throw new Error("backend-test unique JSON object: unclosed JSON object; expected one unique balanced object");
+    }
+    if (scan.spans.length === 0) {
+        throw new Error("backend-test unique JSON object: no unique JSON object found (no fenced json and no balanced bare object)");
+    }
+    if (scan.spans.length > 1) {
+        throw new Error(`backend-test unique JSON object: expected exactly one top-level JSON object, found ${scan.spans.length}`);
+    }
+    const span = scan.spans[0];
+    return trimmed.slice(span.start, span.end);
+}
+/**
+ * Extract exactly one plain JSON object from model text.
+ * Does not require analysis/execution fields.
+ */
+export function extractUniqueJsonObject(text) {
+    const jsonText = findUniqueJsonObjectText(text);
+    return parseObjectJson(jsonText, "extract");
+}
+/**
+ * Extract the unique backend-test contract envelope `{ analysis, execution }` from model text.
+ */
+export function extractBackendTestContractEnvelope(text) {
+    const envelope = extractUniqueJsonObject(text);
+    if (!envelope.analysis || !envelope.execution) {
+        throw new Error("backend-test contract envelope requires analysis and execution");
+    }
+    return {
+        analysis: envelope.analysis,
+        execution: envelope.execution,
+    };
+}

package/dist/workflows/dag/backend-test-coverage-contract.js

@@ -0,0 +1,202 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+export const CODE_COVERAGE_SCHEMA_ID = "code-coverage-v1";
+const relativePath = z.string().min(1).refine((value) => !path.posix.isAbsolute(value) &&
+    !value.includes("\\") &&
+    !value.split("/").some((part) => part === "" || part === "." || part === ".."), "path must be a relative POSIX path");
+export const coverageMetricSchema = z.object({
+    status: z.enum(["available", "unavailable"]),
+    covered: z.number().int().min(0).nullable(),
+    total: z.number().int().min(0).nullable(),
+    ratio: z.number().min(0).max(1).nullable(),
+    reason: z.string().min(1).nullable(),
+}).strict();
+export const codeCoverageContractSchema = z.object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(CODE_COVERAGE_SCHEMA_ID),
+    language: z.enum(["python", "java"]),
+    format: z.enum(["coverage.py-json", "jacoco-xml"]),
+    tool: z.string().min(1),
+    toolVersion: z.string().min(1).nullable(),
+    sourceScope: z.object({
+        requirementIds: z.array(z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/)),
+        paths: z.array(relativePath),
+    }).strict(),
+    commitSha: z.string().regex(/^[a-f0-9]{7,64}$/).nullable(),
+    metrics: z.object({
+        line: coverageMetricSchema,
+        branch: coverageMetricSchema,
+        function: coverageMetricSchema,
+    }).strict(),
+    artifact: z.object({
+        path: relativePath,
+        sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    }).strict(),
+    missingData: z.array(z.string().min(1)),
+}).strict();
+function metric(covered, total, reason) {
+    if (covered === null || total === null || total === 0) {
+        return { status: "unavailable", covered, total, ratio: null, reason: reason ?? (total === 0 ? "denominator-is-zero" : "metric-missing") };
+    }
+    return { status: "available", covered, total, ratio: covered / total, reason: null };
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+function safeArtifactPath(value) {
+    const normalized = value.replaceAll(path.sep, "/");
+    if (path.posix.isAbsolute(normalized) || normalized.split("/").some((part) => part === "" || part === "." || part === "..")) {
+        throw new Error("artifact path must be a safe relative POSIX path");
+    }
+    return normalized;
+}
+function scopeMissing(scope) {
+    return scope.requirementIds.length === 0 ? ["source-scope-requirement-id-missing"] : [];
+}
+function baseContract(options, common) {
+    return {
+        schemaVersion: 1,
+        schemaId: CODE_COVERAGE_SCHEMA_ID,
+        ...common,
+        sourceScope: {
+            requirementIds: [...options.sourceScope.requirementIds],
+            paths: [...options.sourceScope.paths],
+        },
+        commitSha: options.commitSha,
+        artifact: { path: safeArtifactPath(options.artifactPath), sha256: options.artifactSha256 },
+    };
+}
+function parsePythonTotals(input, sourceScope) {
+    if (!input || typeof input !== "object")
+        throw new Error("coverage.py JSON must be an object");
+    const root = input;
+    const totals = root.totals;
+    if (!totals || typeof totals !== "object")
+        throw new Error("coverage.py JSON missing totals");
+    const files = root.files;
+    const scopedFiles = sourceScope.paths.length > 0 && files
+        ? Object.entries(files).filter(([file]) => sourceScope.paths.includes(file.replaceAll("\\", "/")))
+        : [];
+    const usesScopedFiles = sourceScope.paths.length > 0;
+    const values = usesScopedFiles ? scopedFiles.map(([, value]) => value) : null;
+    const get = (key) => {
+        if (values) {
+            let sum = 0;
+            for (const file of values) {
+                const data = file && typeof file === "object" ? file : {};
+                const value = numberValue(data[key]);
+                if (value !== null)
+                    sum += value;
+            }
+            return sum;
+        }
+        if (usesScopedFiles)
+            return null;
+        return numberValue(totals[key]);
+    };
+    return {
+        line: metric(get("covered_lines"), get("num_statements"), null),
+        branch: metric(get("covered_branches"), get("num_branches"), "coverage.py branch data missing"),
+        function: { status: "unavailable", covered: null, total: null, ratio: null, reason: "coverage.py JSON has no function coverage" },
+    };
+}
+function parseJacocoCounters(xml) {
+    const report = xml.match(/<report\b[^>]*>([\s\S]*?)<\/report>/i)?.[1];
+    if (report === undefined)
+        throw new Error("JaCoCo XML missing report root");
+    const reportLevel = report.split(/<(?:group|package)\b/i)[0] ?? "";
+    const counters = new Map();
+    for (const match of reportLevel.matchAll(/<counter\s+[^>]*type="([A-Z]+)"[^>]*missed="(\d+)"[^>]*covered="(\d+)"[^>]*\/>/gi)) {
+        const missed = Number(match[2]);
+        const covered = Number(match[3]);
+        counters.set(match[1].toUpperCase(), { covered, total: covered + missed });
+    }
+    return counters;
+}
+export function parseCoveragePyJson(input, options) {
+    const root = input;
+    const totals = parsePythonTotals(input, options.sourceScope);
+    const missingData = [...scopeMissing(options.sourceScope)];
+    const files = input && typeof input === "object" ? input.files : undefined;
+    if (options.sourceScope.paths.length > 0 && (!files || !options.sourceScope.paths.some((file) => Object.hasOwn(files, file))))
+        missingData.push("source-scope-not-found-in-artifact");
+    if (totals.branch.status === "unavailable")
+        missingData.push("branch-coverage-unavailable");
+    missingData.push("function-coverage-unavailable");
+    return codeCoverageContractSchema.parse({
+        ...baseContract(options, {
+            language: "python",
+            format: "coverage.py-json",
+            tool: "coverage.py",
+            toolVersion: typeof root?.meta?.version === "string" ? root.meta.version : options.toolVersion ?? null,
+        }),
+        metrics: totals,
+        missingData,
+    });
+}
+export function parseJacocoXml(xml, options) {
+    if (!/<report\b/i.test(xml))
+        throw new Error("JaCoCo XML missing report root");
+    const counters = parseJacocoCounters(xml);
+    const line = counters.get("LINE");
+    const branch = counters.get("BRANCH");
+    const method = counters.get("METHOD");
+    const missingData = [...scopeMissing(options.sourceScope)];
+    if (!line)
+        missingData.push("line-coverage-unavailable");
+    if (!branch)
+        missingData.push("branch-coverage-unavailable");
+    if (!method)
+        missingData.push("method-coverage-unavailable");
+    return codeCoverageContractSchema.parse({
+        ...baseContract(options, {
+            language: "java",
+            format: "jacoco-xml",
+            tool: "JaCoCo",
+            toolVersion: options.toolVersion ?? null,
+        }),
+        metrics: {
+            line: line ? metric(line.covered, line.total, null) : metric(null, null, "JaCoCo LINE counter missing"),
+            branch: branch ? metric(branch.covered, branch.total, null) : metric(null, null, "JaCoCo BRANCH counter missing"),
+            function: method ? metric(method.covered, method.total, null) : metric(null, null, "JaCoCo METHOD counter missing"),
+        },
+        missingData,
+    });
+}
+export async function readCoverageArtifact(inputPath, options) {
+    const raw = await readFile(inputPath, "utf8");
+    const artifactSha256 = createHash("sha256").update(raw).digest("hex");
+    const artifactPath = options.artifactPath ?? path.basename(inputPath);
+    const parseOptions = { ...options, artifactPath, artifactSha256 };
+    if (options.sourceScope.paths.some((value) => value.includes("..")))
+        throw new Error("unsafe source scope path");
+    if (inputPath.toLowerCase().endsWith(".xml"))
+        return parseJacocoXml(raw, parseOptions);
+    return parseCoveragePyJson(JSON.parse(raw), parseOptions);
+}
+export function formatCoverageMarkdown(contract) {
+    const row = (name, value) => `| ${name} | ${value.covered ?? "—"} | ${value.total ?? "—"} | ${value.ratio === null ? "unavailable" : `${(value.ratio * 100).toFixed(2)}%`} | ${value.status} | ${value.reason ?? "—"} |`;
+    return [
+        "# Code Coverage Report",
+        "",
+        `- Schema: ${contract.schemaId} v${contract.schemaVersion}`,
+        `- Language: ${contract.language}`,
+        `- Tool: ${contract.tool}${contract.toolVersion ? ` ${contract.toolVersion}` : ""}`,
+        `- Commit: ${contract.commitSha ?? "unavailable"}`,
+        `- Requirement IDs: ${contract.sourceScope.requirementIds.join(", ") || "unavailable"}`,
+        `- Source scope: ${contract.sourceScope.paths.join(", ") || "unavailable"}`,
+        `- Artifact: ${contract.artifact.path}`,
+        `- Artifact SHA-256: ${contract.artifact.sha256}`,
+        "",
+        "| Metric | Covered | Total | Ratio | Status | Reason |",
+        "|---|---:|---:|---:|---|---|",
+        row("Line", contract.metrics.line),
+        row("Branch", contract.metrics.branch),
+        row("Function/Method", contract.metrics.function),
+        "",
+        `Missing data: ${contract.missingData.length ? contract.missingData.join(", ") : "none"}`,
+        "",
+    ].join("\n");
+}