@tea-agent/loop-agent 0.23.1 → 0.24.1

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -7,6 +7,7 @@ import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { findPackageRoot } from "../../shared/package-metadata.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
 export const FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID = "frontend-implementation-contract-v1";
 /**
  * Load the canonical frontend-implementation-contract-v1 JSON Schema from the
@@ -133,7 +134,7 @@ export const frontendImplementationContractSchema = z
         verificationTargetIds: z.array(z.string().min(1)).optional(),
         notApplicableReason: z.string().min(1).optional(),
     })
-        .strict()).min(1),
+        .strict()),
     interactions: z.array(z
         .object({
         name: z.string().min(1),
@@ -300,17 +301,11 @@ export const frontendImplementationContractSchema = z
 });
 export async function assertFrontendSourceBindingFresh(input) {
     for (const source of input.binding.sources) {
-        // DAG source bindings are task-relative (for example source/需求.md),
-        // while older bindings may already contain the repository-relative
-        // .harness/tasks/<taskId>/ prefix. Resolve both forms before hashing.
-        const taskDir = path.resolve(input.workspaceRoot, ".harness", "tasks", input.binding.taskId);
-        const absolute = source.path.startsWith(".harness/")
-            ? path.resolve(input.workspaceRoot, source.path)
-            : path.resolve(taskDir, source.path);
-        const relative = path.relative(input.workspaceRoot, absolute);
-        if (relative.startsWith("..") || path.isAbsolute(relative)) {
-            throw new Error(`frontend source binding escapes workspace: ${source.path}`);
-        }
+        const absolute = resolveDagTaskSourcePath({
+            workspaceRoot: input.workspaceRoot,
+            taskId: input.binding.taskId,
+            sourcePath: source.path,
+        });
         let content;
         try {
             content = await readFile(absolute);
@@ -425,12 +420,23 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
             uiStates: Array.isArray(rawRecord.uiStates)
                 ? rawRecord.uiStates.map((item) => {
                     const state = asRecord(item);
-                    if (!state ||
-                        state.applicable === false ||
-                        (state.notApplicableReason !== "" && state.notApplicableReason !== null))
+                    if (!state)
                         return item;
-                    const { notApplicableReason: _emptyReason, ...withoutEmptyReason } = state;
-                    return withoutEmptyReason;
+                    if (state.applicable === true &&
+                        (state.notApplicableReason === null ||
+                            (typeof state.notApplicableReason === "string" &&
+                                state.notApplicableReason.trim() === ""))) {
+                        const { notApplicableReason: _emptyReason, ...withoutEmptyReason } = state;
+                        return withoutEmptyReason;
+                    }
+                    if (state.applicable === false &&
+                        (state.expectedBehavior === null ||
+                            (typeof state.expectedBehavior === "string" &&
+                                state.expectedBehavior.trim() === ""))) {
+                        const { expectedBehavior: _emptyBehavior, ...withoutEmptyBehavior } = state;
+                        return withoutEmptyBehavior;
+                    }
+                    return item;
                 })
                 : rawRecord.uiStates,
         }

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

@@ -87,14 +87,14 @@ function stripAnsi(value) {
 function normalizeRepoPath(workspaceRoot, candidate) {
     const clean = stripAnsi(candidate).trim().replace(/^file:\/\//, "");
     const windowsAbsolute = /^[A-Za-z]:[\\/]/.test(clean);
-    const windowsRoot = /^[A-Za-z]:[\\/]/.test(workspaceRoot);
+    const posixAbsolute = path.posix.isAbsolute(clean);
     let relative;
-    if (windowsAbsolute || windowsRoot) {
-        if (!windowsAbsolute || !windowsRoot)
+    if (windowsAbsolute) {
+        if (!/^[A-Za-z]:[\\/]/.test(workspaceRoot))
             return null;
         relative = path.win32.relative(workspaceRoot, clean);
     }
-    else if (path.posix.isAbsolute(clean)) {
+    else if (posixAbsolute) {
         relative = path.posix.relative(workspaceRoot.replaceAll("\\", "/"), clean.replaceAll("\\", "/"));
     }
     else {

package/dist/workflows/dag/frontend-project-capability.js

@@ -1,316 +1 @@
-/**
- * Generation-time frontend project capability discovery (M5/M6).
- * Strong evidence only: package.json deps, config files, source imports.
- * Lockfile-only or directory-name-only must NOT activate adapters.
- */
-import { readFile, readdir, stat } from "node:fs/promises";
-import path from "node:path";
-import { OPENSPEC_SPEC_DIRS, OPENSPEC_SPEC_EXT_RE } from "../../shared/openspec-spec.js";
-async function exists(filePath) {
-    try {
-        await stat(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function readJson(filePath) {
-    try {
-        return JSON.parse(await readFile(filePath, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-function allDeps(pkg) {
-    return {
-        ...(pkg.dependencies ?? {}),
-        ...(pkg.devDependencies ?? {}),
-        ...(pkg.peerDependencies ?? {}),
-    };
-}
-function hasDep(deps, name) {
-    return Object.hasOwn(deps, name);
-}
-async function listOpenspec(repoRoot) {
-    const out = [];
-    for (const specDir of OPENSPEC_SPEC_DIRS) {
-        const root = path.join(repoRoot, specDir);
-        if (!(await exists(root)))
-            continue;
-        await walk(root, 0);
-    }
-    return out.slice(0, 40);
-    async function walk(dir, depth) {
-        if (depth > 4)
-            return;
-        let entries = [];
-        try {
-            entries = await readdir(dir);
-        }
-        catch {
-            return;
-        }
-        for (const name of entries) {
-            const full = path.join(dir, name);
-            try {
-                const info = await stat(full);
-                if (info.isDirectory())
-                    await walk(full, depth + 1);
-                else if (OPENSPEC_SPEC_EXT_RE.test(name)) {
-                    out.push(path.relative(repoRoot, full).replace(/\\/g, "/"));
-                }
-            }
-            catch {
-                // skip
-            }
-        }
-    }
-}
-export function buildAdapterGuidance(capability) {
-    const lines = [
-        "## Frontend project capability (generation-time)",
-        `Framework: ${capability.framework}${capability.frameworkVersion ? `@${capability.frameworkVersion}` : ""}`,
-        `Evidence: ${capability.evidencePaths.join(", ") || "(none)"}`,
-        "Rules: openspec specs and task sources outrank adapter tips; do not invent APIs for unknown versions; lockfile-only is not enough.",
-    ];
-    if (capability.framework === "react") {
-        lines.push("React adapter: prefer function components + hooks; reuse existing Testing Library / Vitest patterns; do not introduce new state libs without authorization.");
-    }
-    else if (capability.framework === "next") {
-        lines.push("Next.js adapter: respect App vs Pages router from evidence; keep server/client boundaries explicit; avoid guessing cache/navigation APIs across major versions.");
-    }
-    else if (capability.framework === "vue") {
-        lines.push("Vue adapter: prefer Composition API if project already uses it; reuse Pinia/Vue Router/Vue Query only when evidenced; Vitest + Vue Test Utils when present.");
-    }
-    else {
-        lines.push("Unknown framework: use generic frontend-implementation skill only; do not assume React/Vue/Next APIs.");
-    }
-    if (capability.a11y.status === "present") {
-        lines.push(`A11y tools present: ${capability.a11y.tools.join(", ")}. Report static/component-level evidence only; Browser a11y remains not-run.`);
-    }
-    else {
-        lines.push("A11y tools: absent/unknown — mark a11y checks unavailable/not-run; do not install tools.");
-    }
-    if (capability.designEvidence.normativePaths.length) {
-        lines.push(`Normative design paths: ${capability.designEvidence.normativePaths.slice(0, 8).join(", ")}`);
-    }
-    return lines.join("\n");
-}
-/**
- * Discover frontend project capability from repo root.
- * Strong evidence: package.json direct deps + config/bootstrap files.
- */
-export async function discoverFrontendProjectCapability(repoRoot) {
-    const evidencePaths = [];
-    const reasons = [];
-    const pkgPath = path.join(repoRoot, "package.json");
-    const pkgRaw = await readJson(pkgPath);
-    if (!pkgRaw || typeof pkgRaw !== "object") {
-        const openspec = await listOpenspec(repoRoot);
-        const base = {
-            schemaVersion: 1,
-            framework: "unknown",
-            state: [],
-            dataFetching: [],
-            componentLibrary: [],
-            style: [],
-            testRunner: [],
-            mock: [],
-            a11y: { status: "unknown", tools: [], evidencePaths: [] },
-            evidencePaths: openspec.slice(0, 5),
-            reasons: ["package.json missing or unreadable"],
-            designEvidence: {
-                normativePaths: openspec,
-                advisoryPaths: [],
-                conflicts: [],
-            },
-        };
-        if (openspec.length) {
-            base.reasons.push(`openspec spec files discovered: ${openspec.slice(0, 5).join(", ")}`);
-        }
-        return { ...base, adapterGuidance: buildAdapterGuidance(base) };
-    }
-    evidencePaths.push("package.json");
-    const deps = allDeps(pkgRaw);
-    // Lockfile alone does not activate
-    for (const lock of ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]) {
-        if (await exists(path.join(repoRoot, lock))) {
-            reasons.push(`${lock} present but not used as sole activation evidence`);
-        }
-    }
-    let framework = "unknown";
-    let frameworkVersion;
-    const configHits = [];
-    const nextConfig = ["next.config.js", "next.config.mjs", "next.config.ts"];
-    for (const name of nextConfig) {
-        if (await exists(path.join(repoRoot, name))) {
-            configHits.push(name);
-            evidencePaths.push(name);
-        }
-    }
-    if (hasDep(deps, "next") && configHits.some((c) => c.startsWith("next"))) {
-        framework = "next";
-        frameworkVersion = deps.next?.replace(/^[^\d]*/, "");
-        reasons.push("next dependency + next.config*");
-    }
-    else if (hasDep(deps, "next") && configHits.length === 0) {
-        // dep without config: still weak if only transitive — require direct dep
-        framework = "next";
-        frameworkVersion = deps.next?.replace(/^[^\d]*/, "");
-        reasons.push("next direct dependency (config not found)");
-        evidencePaths.push("package.json#dependencies.next");
-    }
-    if (framework === "unknown") {
-        const vueConfig = ["vite.config.ts", "vite.config.js", "vue.config.js"];
-        let vueCfg = false;
-        for (const name of vueConfig) {
-            if (await exists(path.join(repoRoot, name))) {
-                vueCfg = true;
-                evidencePaths.push(name);
-            }
-        }
-        if (hasDep(deps, "vue") && (vueCfg || hasDep(deps, "nuxt"))) {
-            framework = "vue";
-            frameworkVersion = deps.vue?.replace(/^[^\d]*/, "");
-            reasons.push("vue direct dependency + config/tooling");
-        }
-    }
-    if (framework === "unknown" && hasDep(deps, "react")) {
-        // Need config or jsx tooling — not lockfile-only
-        const reactCfg = (await exists(path.join(repoRoot, "vite.config.ts"))) ||
-            (await exists(path.join(repoRoot, "vite.config.js"))) ||
-            (await exists(path.join(repoRoot, "webpack.config.js"))) ||
-            hasDep(deps, "react-scripts") ||
-            hasDep(deps, "vite");
-        if (reactCfg) {
-            framework = "react";
-            frameworkVersion = deps.react?.replace(/^[^\d]*/, "");
-            reasons.push("react direct dependency + bundler/tooling evidence");
-            evidencePaths.push("package.json#dependencies.react");
-        }
-        else {
-            reasons.push("react listed but no strong config/bundler evidence — framework=unknown");
-        }
-    }
-    const state = [];
-    for (const lib of [
-        "redux",
-        "@reduxjs/toolkit",
-        "zustand",
-        "jotai",
-        "recoil",
-        "pinia",
-        "vuex",
-    ]) {
-        if (hasDep(deps, lib))
-            state.push(lib);
-    }
-    const dataFetching = [];
-    for (const lib of [
-        "@tanstack/react-query",
-        "swr",
-        "axios",
-        "@tanstack/vue-query",
-        "ofetch",
-    ]) {
-        if (hasDep(deps, lib))
-            dataFetching.push(lib);
-    }
-    const componentLibrary = [];
-    for (const lib of [
-        "antd",
-        "@mui/material",
-        "element-plus",
-        "vuetify",
-        "@chakra-ui/react",
-    ]) {
-        if (hasDep(deps, lib))
-            componentLibrary.push(lib);
-    }
-    const style = [];
-    for (const lib of [
-        "tailwindcss",
-        "sass",
-        "less",
-        "styled-components",
-        "@emotion/react",
-    ]) {
-        if (hasDep(deps, lib))
-            style.push(lib);
-    }
-    const testRunner = [];
-    for (const lib of [
-        "vitest",
-        "jest",
-        "@testing-library/react",
-        "@testing-library/vue",
-        "@playwright/test",
-    ]) {
-        if (hasDep(deps, lib))
-            testRunner.push(lib);
-    }
-    const mock = [];
-    for (const lib of ["msw", "nock", "miragejs"]) {
-        if (hasDep(deps, lib))
-            mock.push(lib);
-    }
-    const a11yTools = [];
-    const a11yEvidence = [];
-    for (const lib of [
-        "eslint-plugin-jsx-a11y",
-        "@axe-core/react",
-        "jest-axe",
-        "vitest-axe",
-        "axe-core",
-    ]) {
-        if (hasDep(deps, lib)) {
-            a11yTools.push(lib);
-            a11yEvidence.push(`package.json#${lib}`);
-        }
-    }
-    const a11y = {
-        status: (a11yTools.length > 0 ? "present" : "absent"),
-        tools: a11yTools,
-        evidencePaths: a11yEvidence,
-    };
-    let router;
-    if (hasDep(deps, "react-router-dom") || hasDep(deps, "react-router")) {
-        router = "react-router";
-    }
-    if (framework === "next")
-        router = router ?? "next-router";
-    if (hasDep(deps, "vue-router"))
-        router = "vue-router";
-    const openspec = await listOpenspec(repoRoot);
-    const designEvidence = {
-        normativePaths: openspec,
-        advisoryPaths: [],
-        conflicts: [],
-    };
-    if (openspec.length)
-        evidencePaths.push(...openspec.slice(0, 5));
-    const base = {
-        schemaVersion: 1,
-        framework,
-        frameworkVersion,
-        router,
-        state,
-        dataFetching,
-        componentLibrary,
-        style,
-        testRunner,
-        mock,
-        a11y,
-        packageManager: (await exists(path.join(repoRoot, "pnpm-lock.yaml")))
-            ? "pnpm"
-            : (await exists(path.join(repoRoot, "yarn.lock")))
-                ? "yarn"
-                : "npm",
-        evidencePaths: [...new Set(evidencePaths)],
-        reasons,
-        designEvidence,
-    };
-    return { ...base, adapterGuidance: buildAdapterGuidance(base) };
-}
+export * from "../../task/frontend-project-capability.js";

package/dist/workflows/dag/frontend-worktree-diff.js

@@ -33,7 +33,10 @@ function splitLines(text) {
         .filter(Boolean);
 }
 function statusPaths(status) {
-    return splitLines(status)
+    return status
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length >= 4)
         .map((line) => line.slice(3).split(" -> ").at(-1) ?? "")
         .filter(Boolean)
         .sort();