@tea-agent/loop-agent 0.24.11-beta.0 → 0.25.1

package/dist/task/runtime.js

@@ -68,6 +68,8 @@ export function getTaskPaths(repoRoot, taskId) {
         contractPath: path.join(taskDir, 'contract.json'),
         /** Journaled contract transactions directory. */
         transactionsDir: path.join(taskDir, '.transactions'),
+        /** Canonical current DAG draft input for validate / run-dag. */
+        dagDraftPath: path.join(taskDir, 'dag.json'),
     };
 }
 export async function createTask(repoRoot, taskId, title) {
@@ -177,8 +179,15 @@ export async function getTaskStatus(repoRoot, taskId) {
     return loadWorkflowState(getTaskPaths(repoRoot, taskId).statePath);
 }
 export async function loadTaskConfig(repoRoot, taskId) {
-    const raw = await readFile(getTaskPaths(repoRoot, taskId).taskConfigPath, 'utf-8');
-    return parseTaskConfigForRuntime(JSON.parse(raw));
+    const configPath = getTaskPaths(repoRoot, taskId).taskConfigPath;
+    const raw = await readFile(configPath, 'utf-8');
+    try {
+        return parseTaskConfigForRuntime(JSON.parse(raw));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid task config at ${configPath}: ${message}`);
+    }
 }
 export function parseTaskConfigForRuntime(rawConfig) {
     const parsed = taskConfigSchema.parse(rawConfig);
@@ -292,7 +301,7 @@ export function getSupportedNextCommand(step, taskId, status, options) {
         return `npm run dev -- loop status ${taskId}`;
     }
     if (step === 'analyze' || step === 'plan' || step === 'spec' || step === 'implement' || step === 'verify' || step === 'retrospective') {
-        return `npm run dev -- dag run-task ${taskId} --profile auto --strict-models --output /tmp/${taskId}-dag.json`;
+        return `npm run dev -- dag run-task ${taskId} --profile auto --strict-models`;
     }
     return `${step} step not yet implemented in this prototype; human intervention required`;
 }

package/dist/verification/maven/cache.js

@@ -0,0 +1,142 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { MAVEN_CACHE_SCHEMA_VERSION, MAVEN_PLANNER_VERSION, } from "./types.js";
+import { buildMavenWorkspaceGraph } from "./workspace-graph.js";
+const CACHE_FILE_NAME = "maven-workspace-graph.json";
+/** Directory names ignored during discovery and lightweight entry-list checks. */
+const SKIP_DIR_NAMES = new Set([
+    ".git",
+    ".harness",
+    "node_modules",
+    "target",
+    "dist",
+    "build",
+    ".idea",
+    ".vscode",
+    "coverage",
+    ".turbo",
+    ".next",
+]);
+export function defaultMavenCacheDir(repoRoot) {
+    return path.join(repoRoot, ".harness", "cache");
+}
+export function mavenGraphCachePath(cacheDir) {
+    return path.join(cacheDir, CACHE_FILE_NAME);
+}
+function isValidCachedGraph(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const graph = value;
+    return (graph.schemaVersion === MAVEN_CACHE_SCHEMA_VERSION &&
+        graph.plannerVersion === MAVEN_PLANNER_VERSION &&
+        typeof graph.fingerprint === "string" &&
+        Array.isArray(graph.pomPaths) &&
+        Array.isArray(graph.nodes));
+}
+/**
+ * Lightweight freshness probe: only stat previously recorded directories and
+ * file metadata. Does NOT re-walk the whole tree or re-parse POMs.
+ * Returns true when the cached graph can be reused as-is.
+ */
+export function isCachedGraphStillFresh(repoRoot, graph) {
+    if (graph.schemaVersion !== MAVEN_CACHE_SCHEMA_VERSION ||
+        graph.plannerVersion !== MAVEN_PLANNER_VERSION) {
+        return false;
+    }
+    const manifest = graph.manifest;
+    if (!manifest) {
+        // Old cache shape without manifest cannot prove lightweight freshness.
+        return false;
+    }
+    // Directory entry lists: any add/remove invalidates.
+    for (const dir of manifest.directories) {
+        const absDir = dir.path === "" ? repoRoot : path.join(repoRoot, ...dir.path.split("/"));
+        let entries;
+        try {
+            entries = readdirSync(absDir, { withFileTypes: true })
+                .filter((e) => {
+                if (SKIP_DIR_NAMES.has(e.name))
+                    return false;
+                try {
+                    return !e.isSymbolicLink();
+                }
+                catch {
+                    return true;
+                }
+            })
+                .map((e) => e.name)
+                .sort();
+        }
+        catch {
+            return false;
+        }
+        if (entries.length !== dir.entryNames.length)
+            return false;
+        for (let i = 0; i < entries.length; i += 1) {
+            if (entries[i] !== dir.entryNames[i])
+                return false;
+        }
+    }
+    // File metadata: size/mtime change triggers rebuild (content re-hash on rebuild).
+    for (const file of manifest.files) {
+        const abs = path.join(repoRoot, ...file.path.split("/"));
+        try {
+            const lst = lstatSync(abs);
+            if (lst.isSymbolicLink())
+                return false;
+            const st = statSync(abs);
+            if (st.size !== file.size)
+                return false;
+            if (st.mtimeMs !== file.mtimeMs)
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Load cached graph when schema/planner versions match and lightweight
+ * directory/file metadata is unchanged. Full parse only on miss/stale.
+ */
+export function loadOrBuildMavenWorkspaceGraph(input) {
+    const cacheDir = input.cacheDir ?? defaultMavenCacheDir(input.repoRoot);
+    const cachePath = mavenGraphCachePath(cacheDir);
+    if (existsSync(cachePath)) {
+        try {
+            const raw = JSON.parse(readFileSync(cachePath, "utf8"));
+            if (isValidCachedGraph(raw) && isCachedGraphStillFresh(input.repoRoot, raw)) {
+                return raw;
+            }
+        }
+        catch {
+            // Fall through to rebuild.
+        }
+    }
+    const graph = buildMavenWorkspaceGraph(input.repoRoot);
+    writeGraphCache(cacheDir, graph);
+    return graph;
+}
+export function writeGraphCache(cacheDir, graph) {
+    mkdirSync(cacheDir, { recursive: true });
+    const payload = `${JSON.stringify(graph, null, 2)}\n`;
+    // Guard: never persist absolute host paths.
+    if (/[A-Za-z]:[\\/]/.test(payload) || payload.includes("\\\\")) {
+        // Absolute Windows paths are forbidden; re-check using graph fields only.
+        const serialized = JSON.stringify({
+            schemaVersion: graph.schemaVersion,
+            plannerVersion: graph.plannerVersion,
+            fingerprint: graph.fingerprint,
+            pomPaths: graph.pomPaths,
+            wrapperPaths: graph.wrapperPaths,
+            nodes: graph.nodes,
+            reactors: graph.reactors,
+            reactorRootByPomPath: graph.reactorRootByPomPath,
+            manifest: graph.manifest,
+        });
+        writeFileSync(mavenGraphCachePath(cacheDir), `${serialized}\n`, "utf8");
+        return;
+    }
+    writeFileSync(mavenGraphCachePath(cacheDir), payload, "utf8");
+}

package/dist/verification/maven/index.js

@@ -0,0 +1,120 @@
+import path from "node:path";
+import { loadOrBuildMavenWorkspaceGraph } from "./cache.js";
+import { commandContainsMaven, extractExplicitMavenFile, parseMavenInvocation, planMavenCommands, } from "./plan-commands.js";
+import { resolveMavenTargets } from "./scope-resolve.js";
+import { assertMavenPlanFresh } from "./stale.js";
+import { MAVEN_CACHE_SCHEMA_VERSION, MAVEN_PLANNER_VERSION, MavenPlanError, MavenPlanStaleError, } from "./types.js";
+export { MAVEN_CACHE_SCHEMA_VERSION, MAVEN_PLANNER_VERSION, MavenPlanError, MavenPlanStaleError, assertMavenPlanFresh, };
+function toPosix(value) {
+    return value.replace(/\\/g, "/");
+}
+function allMavenCommandsHaveExplicitFile(commands) {
+    const mavenCommands = commands.filter(commandContainsMaven);
+    if (mavenCommands.length === 0)
+        return false;
+    return mavenCommands.every((command) => {
+        const parsed = parseMavenInvocation(command);
+        if (!parsed)
+            return false;
+        return extractExplicitMavenFile(parsed.mavenArgs) !== undefined;
+    });
+}
+function targetsFromExplicitFiles(input) {
+    const byPom = new Map();
+    for (const command of input.commands) {
+        const parsed = parseMavenInvocation(command);
+        if (!parsed)
+            continue;
+        const explicit = extractExplicitMavenFile(parsed.mavenArgs);
+        if (!explicit)
+            continue;
+        // Resolve relative -f against the original command cwd.
+        const baseCwd = command.cwd ?? input.repoRoot;
+        const absolute = path.isAbsolute(explicit)
+            ? path.normalize(explicit)
+            : path.resolve(baseCwd, explicit);
+        const rel = toPosix(path.relative(input.repoRoot, absolute));
+        if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+            // Keep unresolved path for planMavenCommands validation/fail-fast.
+            byPom.set(toPosix(explicit), {
+                pomPath: toPosix(explicit),
+                artifactId: path.posix.basename(toPosix(explicit).replace(/\/pom\.xml$/i, "")) || "unknown",
+            });
+            continue;
+        }
+        const node = input.graph.nodes.find((n) => n.pomPath === rel);
+        if (node) {
+            const reactorRoot = input.graph.reactorRootByPomPath[node.pomPath];
+            if (reactorRoot && reactorRoot !== node.pomPath) {
+                const reactor = input.graph.reactors.find((r) => r.rootPomPath === reactorRoot);
+                byPom.set(node.pomPath, {
+                    pomPath: node.pomPath,
+                    artifactId: node.artifactId,
+                    reactorRootPomPath: reactorRoot,
+                    moduleCoordinate: reactor?.modulePathByPomPath?.[node.pomPath] ??
+                        reactor?.artifactIdByPomPath[node.pomPath] ??
+                        node.artifactId,
+                });
+            }
+            else {
+                byPom.set(node.pomPath, {
+                    pomPath: node.pomPath,
+                    artifactId: node.artifactId,
+                    reactorRootPomPath: reactorRoot === node.pomPath ? reactorRoot : undefined,
+                });
+            }
+        }
+        else {
+            const base = rel.replace(/\/pom\.xml$/i, "");
+            const artifactId = base.split("/").filter(Boolean).pop() ?? rel;
+            byPom.set(rel, { pomPath: rel, artifactId });
+        }
+    }
+    return [...byPom.values()];
+}
+/**
+ * Plan Maven verification commands from task scope + static workspace graph.
+ * Non-Maven commands are returned unchanged. Returns plan=null when no Maven
+ * commands are present (REQ-MVN-007).
+ */
+export function planMavenVerification(input) {
+    const mavenCommands = input.commands.filter(commandContainsMaven);
+    if (mavenCommands.length === 0) {
+        return { commands: input.commands, plan: null };
+    }
+    const graph = loadOrBuildMavenWorkspaceGraph({
+        repoRoot: input.repoRoot,
+        cacheDir: input.cacheDir,
+    });
+    if (graph.pomPaths.length === 0) {
+        throw new MavenPlanError("Maven verification is requested but no pom.xml was found in the repository.", { code: "maven-no-pom" });
+    }
+    // When every Maven command already carries a resolvable -f, skip automatic
+    // scope target resolution (wide/empty scope must not block explicit targets).
+    const targets = allMavenCommandsHaveExplicitFile(input.commands)
+        ? targetsFromExplicitFiles({
+            repoRoot: input.repoRoot,
+            commands: input.commands,
+            graph,
+        })
+        : resolveMavenTargets({
+            graph,
+            scope: input.scope,
+        });
+    const planned = planMavenCommands({
+        repoRoot: input.repoRoot,
+        commands: input.commands,
+        targets,
+        graph,
+        scope: input.scope,
+    });
+    // Ensure planned commands keep original repoRoot cwd (explicit -f, not module cd).
+    const commands = planned.commands.map((command) => ({
+        ...command,
+        cwd: input.repoRoot,
+    }));
+    return {
+        commands,
+        plan: planned.plan,
+    };
+}