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

package/dist/workflows/dag/frontend-lint-baseline.js

@@ -0,0 +1,474 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+export const FRONTEND_LINT_BASELINE_SCHEMA_ID = "frontend-lint-baseline-v1";
+export const FRONTEND_LINT_ASSESSMENT_SCHEMA_ID = "frontend-lint-assessment-v1";
+const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
+const relativePathSchema = z
+    .string()
+    .min(1)
+    .refine((value) => !value.includes("\\") &&
+    !path.posix.isAbsolute(value) &&
+    !value.split("/").includes(".."), "expected a contained repo-relative path");
+export const frontendLintDiagnosticSchema = z
+    .object({
+    file: relativePathSchema,
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    severity: z.enum(["error", "warning"]),
+    message: z.string().min(1),
+    ruleId: z.string().min(1).nullable(),
+})
+    .strict();
+export const frontendLintCommandIdentitySchema = z
+    .object({
+    commands: z.array(z.string().min(1)).min(1),
+    sha256: sha256Schema,
+})
+    .strict();
+const rawEvidenceRefSchema = z
+    .object({
+    path: relativePathSchema,
+    sha256: sha256Schema,
+    stream: z.enum(["stdout", "stderr"]),
+    commandIndex: z.number().int().nonnegative(),
+})
+    .strict();
+const lintCommandResultSchema = z
+    .object({
+    command: z.string().min(1),
+    exitCode: z.number().int().nullable(),
+    timedOut: z.boolean(),
+    failureCategory: z.string().min(1),
+})
+    .strict();
+export const frontendLintBaselineArtifactSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_LINT_BASELINE_SCHEMA_ID),
+    status: z.enum(["available", "unavailable"]),
+    reason: z.string().min(1).optional(),
+    commandIdentity: frontendLintCommandIdentitySchema,
+    diagnostics: z.array(frontendLintDiagnosticSchema),
+    commandResults: z.array(lintCommandResultSchema),
+    rawEvidenceRefs: z.array(rawEvidenceRefSchema),
+})
+    .strict();
+export const frontendLintAssessmentArtifactSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_LINT_ASSESSMENT_SCHEMA_ID),
+    status: z.enum(["passed", "baseline-debt", "failed", "unavailable"]),
+    commandIdentity: frontendLintCommandIdentitySchema,
+    baselineRef: z
+        .object({
+        path: relativePathSchema,
+        sha256: sha256Schema,
+        nodeId: z.string().min(1),
+    })
+        .strict()
+        .optional(),
+    currentExitCode: z.number().int().nullable(),
+    writerChangedFiles: z.array(relativePathSchema),
+    currentDiagnostics: z.array(frontendLintDiagnosticSchema),
+    toleratedDiagnosticCount: z.number().int().nonnegative(),
+    blockingDiagnostics: z.array(frontendLintDiagnosticSchema),
+    blockingReasons: z.array(z.string().min(1)),
+    rawEvidenceRefs: z.array(rawEvidenceRefSchema),
+})
+    .strict();
+const ANSI_PATTERN = 
+// eslint-disable-next-line no-control-regex
+/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+function stripAnsi(value) {
+    return value.replace(ANSI_PATTERN, "");
+}
+function normalizeRepoPath(workspaceRoot, candidate) {
+    const clean = stripAnsi(candidate).trim().replace(/^file:\/\//, "");
+    const windowsAbsolute = /^[A-Za-z]:[\\/]/.test(clean);
+    const posixAbsolute = path.posix.isAbsolute(clean);
+    let relative;
+    if (windowsAbsolute) {
+        if (!/^[A-Za-z]:[\\/]/.test(workspaceRoot))
+            return null;
+        relative = path.win32.relative(workspaceRoot, clean);
+    }
+    else if (posixAbsolute) {
+        relative = path.posix.relative(workspaceRoot.replaceAll("\\", "/"), clean.replaceAll("\\", "/"));
+    }
+    else {
+        relative = clean;
+    }
+    const normalized = relative.replaceAll("\\", "/").replace(/^\.\//, "");
+    if (normalized.length === 0 ||
+        path.posix.isAbsolute(normalized) ||
+        normalized === ".." ||
+        normalized.startsWith("../")) {
+        return null;
+    }
+    return normalized;
+}
+const IGNORED_ESLINT_LINES = [
+    /^$/,
+    /^>\s/,
+    /^npm (?:warn|notice)\b/i,
+    /^eslint\b/i,
+    /^✖\s+\d+\s+problems?/i,
+    /^\d+\s+problems?\s+\(/i,
+    /^\d+\s+errors?\s+and\s+\d+\s+warnings?/i,
+    /^--$/,
+];
+function isIgnoredEslintLine(line) {
+    return IGNORED_ESLINT_LINES.some((pattern) => pattern.test(line.trim()));
+}
+export function parseEslintDiagnostics(input) {
+    const diagnostics = [];
+    const unparsedLines = [];
+    let currentFile = null;
+    for (const rawLine of stripAnsi(input.output).split(/\r?\n/)) {
+        const line = rawLine.trimEnd();
+        if (isIgnoredEslintLine(line))
+            continue;
+        const stylish = line.match(/^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)(?:\s{2,}([@a-zA-Z0-9_./-]+))?\s*$/);
+        if (stylish && currentFile) {
+            diagnostics.push({
+                file: currentFile,
+                line: Number(stylish[1]),
+                column: Number(stylish[2]),
+                severity: stylish[3],
+                message: stylish[4].trim(),
+                ruleId: stylish[5]?.trim() || null,
+            });
+            continue;
+        }
+        const compact = line.match(/^(.+?):\s*line\s+(\d+),\s*col\s+(\d+),\s*(Error|Warning)\s*-\s*(.+?)(?:\s+\(([^)]+)\))?$/i);
+        if (compact) {
+            const file = normalizeRepoPath(input.workspaceRoot, compact[1]);
+            if (!file) {
+                unparsedLines.push(line.trim());
+                continue;
+            }
+            diagnostics.push({
+                file,
+                line: Number(compact[2]),
+                column: Number(compact[3]),
+                severity: compact[4].toLowerCase(),
+                message: compact[5].trim(),
+                ruleId: compact[6]?.trim() || null,
+            });
+            continue;
+        }
+        const candidateFile = normalizeRepoPath(input.workspaceRoot, line.trim());
+        if (candidateFile &&
+            /\.[a-z0-9]+$/i.test(candidateFile) &&
+            !/\s{2,}/.test(line.trim())) {
+            currentFile = candidateFile;
+            continue;
+        }
+        unparsedLines.push(line.trim());
+    }
+    return { diagnostics, unparsedLines };
+}
+export function createFrontendLintCommandIdentity(commands) {
+    const normalized = commands.map((command) => command.trim());
+    return {
+        commands: normalized,
+        sha256: createHash("sha256")
+            .update(JSON.stringify(normalized))
+            .digest("hex"),
+    };
+}
+function diagnosticKey(value) {
+    return JSON.stringify([
+        value.file,
+        value.line,
+        value.column,
+        value.severity,
+        value.message,
+        value.ruleId,
+    ]);
+}
+export function assessFrontendLint(input) {
+    const writerChangedFiles = [
+        ...new Set(input.writerChangedFiles.map((value) => value.replaceAll("\\", "/"))),
+    ].sort();
+    const base = {
+        schemaVersion: 1,
+        schemaId: FRONTEND_LINT_ASSESSMENT_SCHEMA_ID,
+        commandIdentity: input.commandIdentity,
+        ...(input.baselineRef ? { baselineRef: input.baselineRef } : {}),
+        currentExitCode: input.currentExitCode,
+        writerChangedFiles,
+        currentDiagnostics: input.currentDiagnostics,
+        rawEvidenceRefs: input.rawEvidenceRefs,
+    };
+    if (input.currentExitCode === 0) {
+        return {
+            ...base,
+            status: "passed",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: [],
+            blockingReasons: [],
+        };
+    }
+    if (!input.baseline || input.baseline.status !== "available") {
+        return {
+            ...base,
+            status: "unavailable",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: input.currentDiagnostics,
+            blockingReasons: [
+                input.baseline?.reason ?? "lint baseline is missing or unavailable",
+            ],
+        };
+    }
+    if (input.currentUnavailableReason) {
+        return {
+            ...base,
+            status: "unavailable",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: input.currentDiagnostics,
+            blockingReasons: [input.currentUnavailableReason],
+        };
+    }
+    if (input.baseline.commandIdentity.sha256 !== input.commandIdentity.sha256) {
+        return {
+            ...base,
+            status: "unavailable",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: input.currentDiagnostics,
+            blockingReasons: ["lint command identity drifted from baseline"],
+        };
+    }
+    if (input.currentUnparsedLines.length > 0 || input.currentDiagnostics.length === 0) {
+        return {
+            ...base,
+            status: "unavailable",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: input.currentDiagnostics,
+            blockingReasons: ["current lint output cannot be parsed reliably"],
+        };
+    }
+    const changed = new Set(writerChangedFiles);
+    const changedDiagnostics = input.currentDiagnostics.filter((item) => changed.has(item.file));
+    const baselineCounts = new Map();
+    for (const item of input.baseline.diagnostics) {
+        const key = diagnosticKey(item);
+        baselineCounts.set(key, (baselineCounts.get(key) ?? 0) + 1);
+    }
+    const newDiagnostics = [];
+    let toleratedDiagnosticCount = 0;
+    for (const item of input.currentDiagnostics) {
+        if (changed.has(item.file))
+            continue;
+        const key = diagnosticKey(item);
+        const count = baselineCounts.get(key) ?? 0;
+        if (count === 0) {
+            newDiagnostics.push(item);
+        }
+        else {
+            baselineCounts.set(key, count - 1);
+            toleratedDiagnosticCount += 1;
+        }
+    }
+    const blockingReasons = [];
+    if (changedDiagnostics.length > 0) {
+        blockingReasons.push("writer-changed files contain lint diagnostics");
+    }
+    if (newDiagnostics.length > 0) {
+        blockingReasons.push("current lint contains diagnostics absent from baseline");
+    }
+    const blockingDiagnostics = [...changedDiagnostics, ...newDiagnostics];
+    return {
+        ...base,
+        status: blockingReasons.length > 0 ? "failed" : "baseline-debt",
+        toleratedDiagnosticCount,
+        blockingDiagnostics,
+        blockingReasons,
+    };
+}
+const writerChangeManifestSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    writerNodeId: z.string().min(1),
+    effectiveWriteSet: z.array(z.string()).optional(),
+    approvalSourceNodeId: z.string().min(1).optional(),
+    approvalDigest: z.string().min(1).optional(),
+    changedFiles: z.array(relativePathSchema),
+    beforeStatusSha256: sha256Schema,
+    afterStatusSha256: sha256Schema,
+})
+    .strict();
+export async function readWriterChangedFiles(runDir, writerNodeIds) {
+    const changed = new Set();
+    for (const writerNodeId of writerNodeIds) {
+        const raw = JSON.parse(await readFile(path.join(runDir, writerNodeId, "change-manifest.json"), "utf8"));
+        const parsed = writerChangeManifestSchema.parse(raw);
+        if (parsed.writerNodeId !== writerNodeId) {
+            throw new Error(`lint assessment writer manifest ownership mismatch for ${writerNodeId}`);
+        }
+        for (const file of parsed.changedFiles)
+            changed.add(file);
+    }
+    return [...changed].sort();
+}
+async function writeContract(runDir, name, value) {
+    const relative = `contracts/${name}`;
+    const raw = `${JSON.stringify(value, null, 2)}\n`;
+    await mkdir(path.join(runDir, "contracts"), { recursive: true });
+    await writeFile(path.join(runDir, relative), raw, "utf8");
+    return {
+        path: relative,
+        sha256: createHash("sha256").update(raw).digest("hex"),
+    };
+}
+async function materializeRawEvidence(input) {
+    const refs = [];
+    const evidenceDir = path.join(input.runDir, "contracts", "lint-evidence");
+    await mkdir(evidenceDir, { recursive: true });
+    for (const [commandIndex, result] of input.results.entries()) {
+        for (const stream of ["stdout", "stderr"]) {
+            const raw = await readResultStream(input.runDir, result, stream);
+            const relative = `contracts/lint-evidence/${input.phase}-${commandIndex}.${stream}.txt`;
+            await writeFile(path.join(input.runDir, relative), raw, "utf8");
+            refs.push({
+                path: relative,
+                sha256: createHash("sha256").update(raw).digest("hex"),
+                stream,
+                commandIndex,
+            });
+        }
+    }
+    return refs;
+}
+async function readResultStream(runDir, result, stream) {
+    const artifactPath = stream === "stdout"
+        ? result.stdoutArtifactPath
+        : result.stderrArtifactPath;
+    if (artifactPath) {
+        const resolved = path.resolve(artifactPath);
+        const relative = path.relative(path.resolve(runDir), resolved);
+        if (relative !== "" &&
+            !relative.startsWith("..") &&
+            !path.isAbsolute(relative)) {
+            try {
+                return await readFile(resolved, "utf8");
+            }
+            catch {
+                // Fall through to the bounded executor value.
+            }
+        }
+    }
+    return result[stream];
+}
+async function parseCommandResults(input) {
+    const diagnostics = [];
+    const unparsedLines = [];
+    for (const result of input.results) {
+        const parsed = parseEslintDiagnostics({
+            workspaceRoot: input.workspaceRoot,
+            output: `${await readResultStream(input.runDir, result, "stdout")}\n${await readResultStream(input.runDir, result, "stderr")}`,
+        });
+        diagnostics.push(...parsed.diagnostics);
+        unparsedLines.push(...parsed.unparsedLines);
+    }
+    return { diagnostics, unparsedLines };
+}
+export async function materializeFrontendLintBaseline(input) {
+    const commandIdentity = createFrontendLintCommandIdentity(input.commands);
+    const parsed = await parseCommandResults(input);
+    const unusableResult = input.results.find((result) => result.timedOut ||
+        result.exitCode === null ||
+        result.failureCategory === "spawn-error");
+    let reason;
+    if (input.worktreeChanged)
+        reason = "lint baseline command modified the worktree";
+    else if (unusableResult)
+        reason = "lint baseline command timed out or could not execute";
+    else if (input.results.some((result) => result.exitCode !== 0) &&
+        (parsed.unparsedLines.length > 0 || parsed.diagnostics.length === 0)) {
+        reason = "lint baseline output cannot be parsed reliably";
+    }
+    const rawEvidenceRefs = await materializeRawEvidence({
+        runDir: input.runDir,
+        phase: "baseline",
+        results: input.results,
+    });
+    const artifact = frontendLintBaselineArtifactSchema.parse({
+        schemaVersion: 1,
+        schemaId: FRONTEND_LINT_BASELINE_SCHEMA_ID,
+        status: reason ? "unavailable" : "available",
+        ...(reason ? { reason } : {}),
+        commandIdentity,
+        diagnostics: parsed.diagnostics,
+        commandResults: input.results.map((result) => ({
+            command: result.command,
+            exitCode: result.exitCode,
+            timedOut: result.timedOut,
+            failureCategory: result.failureCategory,
+        })),
+        rawEvidenceRefs,
+    });
+    const ref = await writeContract(input.runDir, "frontend-lint-baseline.json", artifact);
+    return { artifact, ref };
+}
+export async function materializeFrontendLintAssessment(input) {
+    const baselinePath = path.join(input.runDir, "contracts", "frontend-lint-baseline.json");
+    let baseline;
+    let baselineRef;
+    try {
+        const raw = await readFile(baselinePath, "utf8");
+        baseline = frontendLintBaselineArtifactSchema.parse(JSON.parse(raw));
+        baselineRef = {
+            path: "contracts/frontend-lint-baseline.json",
+            sha256: createHash("sha256").update(raw).digest("hex"),
+            nodeId: input.baselineNodeId,
+        };
+    }
+    catch {
+        baseline = undefined;
+    }
+    let writerChangedFiles = [];
+    let manifestError;
+    try {
+        writerChangedFiles = await readWriterChangedFiles(input.runDir, input.writerNodeIds);
+    }
+    catch (error) {
+        manifestError = error instanceof Error ? error.message : String(error);
+    }
+    const parsed = await parseCommandResults(input);
+    const rawEvidenceRefs = await materializeRawEvidence({
+        runDir: input.runDir,
+        phase: "current",
+        results: input.results,
+    });
+    const commandIdentity = createFrontendLintCommandIdentity(input.commands);
+    const nonzero = input.results.find((result) => result.exitCode !== 0);
+    const unusableResult = input.results.find((result) => result.timedOut ||
+        result.exitCode === null ||
+        result.failureCategory === "spawn-error");
+    let assessment = assessFrontendLint({
+        baseline,
+        baselineRef,
+        commandIdentity,
+        currentExitCode: unusableResult ? null : (nonzero?.exitCode ?? 0),
+        currentDiagnostics: parsed.diagnostics,
+        currentUnparsedLines: parsed.unparsedLines,
+        currentUnavailableReason: unusableResult
+            ? "current lint command timed out or could not execute"
+            : undefined,
+        writerChangedFiles,
+        rawEvidenceRefs,
+    });
+    if (manifestError && assessment.status !== "passed") {
+        assessment = {
+            ...assessment,
+            status: "unavailable",
+            blockingReasons: [manifestError],
+        };
+    }
+    assessment = frontendLintAssessmentArtifactSchema.parse(assessment);
+    await writeContract(input.runDir, "frontend-lint-assessment.json", assessment);
+    return assessment;
+}

package/dist/workflows/dag/frontend-plan-render.js

@@ -0,0 +1,90 @@
+/**
+ * Deterministic Markdown renderer for a canonical frontend implementation
+ * contract. The prewrite gate materializes this as `contracts/frontend-plan.md`
+ * next to the contract JSON, so plan prose is never produced by the model — it
+ * is derived from the single machine contract at materialization time.
+ *
+ * The function is pure: the same contract always renders byte-identical
+ * Markdown, and absent optional fields render as placeholders without throwing.
+ */
+function bulletList(items) {
+    if (!items || items.length === 0)
+        return "";
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function requirementsCoverage(contract) {
+    const lines = contract.requirements.map((requirement) => `- ${requirement.id}: ${requirement.expectedOutcome}`);
+    return lines.length > 0 ? lines.join("\n") : "_(no requirements)_";
+}
+function uiStateHandling(contract) {
+    const lines = contract.uiStates.map((state) => {
+        if (state.applicable) {
+            return `- ${state.name}: ${state.expectedBehavior ?? ""}`;
+        }
+        return `- ${state.name}: not applicable — ${state.notApplicableReason ?? ""}`;
+    });
+    return lines.length > 0 ? lines.join("\n") : "_(none)_";
+}
+function interactionNotes(contract) {
+    const lines = contract.interactions.map((interaction) => `- ${interaction.name}: ${interaction.trigger} → ${interaction.expectedBehavior}`);
+    return lines.length > 0 ? lines.join("\n") : "_(none)_";
+}
+function verificationPlan(contract) {
+    const lines = contract.verificationTargets.map((target) => `- ${target.id}: ${target.commandLabel} (${target.file})`);
+    return lines.length > 0 ? lines.join("\n") : "_(none)_";
+}
+function componentSelection(contract) {
+    const choices = contract.uiComponentChoices ?? [];
+    if (choices.length === 0)
+        return "_(not specified)_";
+    return choices
+        .map((choice) => {
+        const specReference = choice.specReference;
+        const refText = specReference
+            ? ` ${specReference.path}${specReference.section ? `#${specReference.section}` : ""}${specReference.line != null ? `:${specReference.line}` : ""}`
+            : "";
+        return `- ${choice.purpose} → ${choice.component} (${choice.decision})${refText ? `:${refText}` : ""} — ${choice.rationale}`;
+    })
+        .join("\n");
+}
+export function renderFrontendPlanMarkdown(contract) {
+    return [
+        "# Frontend Implementation Plan",
+        "",
+        "## Requirement Coverage",
+        requirementsCoverage(contract),
+        "",
+        "## Implementation Steps",
+        bulletList(contract.implementationSteps) || "_(not specified)_",
+        "",
+        "## Target Files",
+        bulletList(contract.targets.files) || "_(none)_",
+        "",
+        "## UI State Handling",
+        uiStateHandling(contract),
+        "",
+        "## Styling & Component Strategy",
+        contract.stylingStrategy || "_(not specified)_",
+        "",
+        "## Component Selection (spec conformance)",
+        componentSelection(contract),
+        "",
+        "## Interaction Notes",
+        interactionNotes(contract),
+        "",
+        "## Mock & API Strategy",
+        contract.mockApi.strategy,
+        "",
+        "## Dependency Policy",
+        contract.dependencyPolicy || "_(not specified)_",
+        "",
+        "## Verification Plan",
+        verificationPlan(contract),
+        "",
+        "## Real Integration Gap",
+        contract.realIntegrationGap || "_(not specified)_",
+        "",
+        "## Residual Risks",
+        bulletList(contract.residualRisks) || "_(none)_",
+    ].join("\n") + "\n";
+}