@tea-agent/loop-agent 0.1.0 → 0.2.0

package/dist/application/dag/args.js

@@ -0,0 +1,420 @@
+import path from "node:path";
+import { DAG_PAUSED_LATEST_REPORT_PRESET, DAG_RECOVERY_ACTIONS, } from "../../workflows/dag/report.js";
+const RECOVERY_ACTIONS = new Set(DAG_RECOVERY_ACTIONS);
+const LIFECYCLE_FILTERS = new Set([
+    "active",
+    "paused",
+    "completed",
+    "all",
+]);
+export function parseDagRunTaskArgs(args, defaultCwd) {
+    if (args.length === 0) {
+        throw new Error("usage: dag run-task <task-id> [--output <path>] [--profile auto|minimal|standard|reviewed|supervised] [--strict-models] [--no-cursor] [--execute] [--init-only] [--dry-run] [--cwd <dir>] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]]");
+    }
+    let taskId;
+    let outputPath;
+    let strictModels = false;
+    let noCursor = false;
+    let execute = false;
+    let initOnly = false;
+    let dryRun = false;
+    let cwd;
+    let maxConcurrent;
+    let runId;
+    let canvasPath;
+    let canvasName;
+    let canvasesDir;
+    let profile = "standard";
+    let profileExplicit = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--output" || arg === "-o") {
+            outputPath = args[++i];
+            if (!outputPath) {
+                throw new Error("dag run-task --output requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--output=")) {
+            outputPath = arg.slice("--output=".length);
+            continue;
+        }
+        if (arg === "--strict-models") {
+            strictModels = true;
+            continue;
+        }
+        if (arg === "--no-cursor") {
+            noCursor = true;
+            continue;
+        }
+        if (arg === "--execute") {
+            execute = true;
+            continue;
+        }
+        if (arg === "--init-only") {
+            initOnly = true;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        if (arg === "--cwd" || arg === "-C") {
+            cwd = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--cwd=")) {
+            cwd = arg.slice(6);
+            continue;
+        }
+        if (arg === "--max-concurrent") {
+            maxConcurrent = Number(args[++i]);
+            continue;
+        }
+        if (arg === "--run-id") {
+            runId = args[++i];
+            continue;
+        }
+        if (arg === "--canvas-path") {
+            canvasPath = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--canvas-path=")) {
+            canvasPath = arg.slice(14);
+            continue;
+        }
+        if (arg === "--canvas") {
+            canvasName = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--canvas=")) {
+            canvasName = arg.slice(9);
+            continue;
+        }
+        if (arg === "--canvases-dir") {
+            canvasesDir = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--canvases-dir=")) {
+            canvasesDir = arg.slice(15);
+            continue;
+        }
+        if (arg === "--profile") {
+            const value = args[++i];
+            if (!value) {
+                throw new Error("dag run-task --profile requires a value");
+            }
+            profile = parseDagRunTaskProfile(value);
+            profileExplicit = true;
+            continue;
+        }
+        if (arg.startsWith("--profile=")) {
+            profile = parseDagRunTaskProfile(arg.slice("--profile=".length));
+            profileExplicit = true;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag run-task flag: ${arg}`);
+        }
+        if (taskId) {
+            throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        taskId = arg;
+    }
+    if (!taskId) {
+        throw new Error("dag run-task requires <task-id>");
+    }
+    return {
+        taskId,
+        outputPath: outputPath ? path.resolve(outputPath) : undefined,
+        strictModels,
+        noCursor,
+        execute,
+        initOnly,
+        dryRun,
+        cwd: path.resolve(cwd ?? defaultCwd ?? process.cwd()),
+        maxConcurrent,
+        runId,
+        canvasPath,
+        canvasName,
+        canvasesDir,
+        profile,
+        profileExplicit,
+    };
+}
+function parseDagRunTaskProfile(value) {
+    if (value === "auto" ||
+        value === "minimal" ||
+        value === "standard" ||
+        value === "reviewed" ||
+        value === "supervised") {
+        return value;
+    }
+    throw new Error(`dag run-task --profile must be one of: auto, minimal, standard, reviewed, supervised; got ${value}`);
+}
+export function parseDagValidateArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag validate --dag <path> [--strict-models] [--strict-governance]");
+    }
+    let dagPath;
+    let strictModelMatrix = false;
+    let strictGovernance = false;
+    const forbidExecutors = [];
+    let spineTaskId;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--dag") {
+            dagPath = args[++i];
+            if (!dagPath) {
+                throw new Error("dag validate --dag requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--dag=")) {
+            dagPath = arg.slice("--dag=".length);
+            if (!dagPath) {
+                throw new Error("dag validate --dag requires a path");
+            }
+            continue;
+        }
+        if (arg === "--strict-models") {
+            strictModelMatrix = true;
+            continue;
+        }
+        if (arg === "--strict-governance") {
+            strictGovernance = true;
+            continue;
+        }
+        if (arg === "--forbid-executor") {
+            const executor = args[++i];
+            if (!executor) {
+                throw new Error("dag validate --forbid-executor requires an executor");
+            }
+            forbidExecutors.push(executor);
+            continue;
+        }
+        if (arg === "--spine-task") {
+            spineTaskId = args[++i];
+            if (!spineTaskId) {
+                throw new Error("dag validate --spine-task requires a task id");
+            }
+            continue;
+        }
+        if (arg.startsWith("--spine-task=")) {
+            spineTaskId = arg.slice("--spine-task=".length);
+            if (!spineTaskId) {
+                throw new Error("dag validate --spine-task requires a task id");
+            }
+            continue;
+        }
+        if (arg.startsWith("--forbid-executor=")) {
+            const executor = arg.slice("--forbid-executor=".length);
+            if (!executor) {
+                throw new Error("dag validate --forbid-executor requires an executor");
+            }
+            forbidExecutors.push(executor);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag validate flag: ${arg}`);
+        }
+        if (dagPath) {
+            throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        dagPath = arg;
+    }
+    if (!dagPath) {
+        throw new Error("dag validate requires --dag <path>");
+    }
+    return {
+        dagPath: path.resolve(dagPath),
+        strictModelMatrix,
+        strictGovernance,
+        forbidExecutors,
+        spineTaskId,
+    };
+}
+export function parseRunDagArgs(args, defaultCwd) {
+    if (args.length === 0) {
+        throw new Error("usage: run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]]");
+    }
+    let dagPath;
+    let cwd;
+    let initOnly = false;
+    let dryRun = false;
+    let maxConcurrent;
+    let runId;
+    let noCursor = false;
+    let canvasPath;
+    let canvasName;
+    let canvasesDir;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--dag") {
+            dagPath = args[++i];
+        }
+        else if (arg.startsWith("--dag=")) {
+            dagPath = arg.slice(6);
+        }
+        else if (arg === "--cwd" || arg === "-C") {
+            cwd = args[++i];
+        }
+        else if (arg.startsWith("--cwd=")) {
+            cwd = arg.slice(6);
+        }
+        else if (arg === "--init-only") {
+            initOnly = true;
+        }
+        else if (arg === "--dry-run") {
+            dryRun = true;
+        }
+        else if (arg === "--max-concurrent") {
+            maxConcurrent = Number(args[++i]);
+        }
+        else if (arg === "--run-id") {
+            runId = args[++i];
+        }
+        else if (arg === "--no-cursor") {
+            noCursor = true;
+        }
+        else if (arg === "--canvas-path") {
+            canvasPath = args[++i];
+        }
+        else if (arg.startsWith("--canvas-path=")) {
+            canvasPath = arg.slice(14);
+        }
+        else if (arg === "--canvas") {
+            canvasName = args[++i];
+        }
+        else if (arg.startsWith("--canvas=")) {
+            canvasName = arg.slice(9);
+        }
+        else if (arg === "--canvases-dir") {
+            canvasesDir = args[++i];
+        }
+        else if (arg.startsWith("--canvases-dir=")) {
+            canvasesDir = arg.slice(15);
+        }
+        else if (!arg.startsWith("-")) {
+            if (!dagPath)
+                dagPath = arg;
+            else
+                throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        else {
+            throw new Error(`unknown run-dag flag: ${arg}`);
+        }
+    }
+    if (!dagPath) {
+        throw new Error("run-dag requires --dag <path>");
+    }
+    return {
+        dagPath: path.resolve(dagPath),
+        cwd: path.resolve(cwd ?? defaultCwd ?? process.cwd()),
+        initOnly,
+        dryRun,
+        maxConcurrent,
+        runId,
+        noCursor,
+        canvasPath,
+        canvasName,
+        canvasesDir,
+    };
+}
+export function parseDagReportArgs(args) {
+    let runId;
+    let lifecycle = "all";
+    let json = false;
+    let markdown = false;
+    let failedOnly = false;
+    let latest = false;
+    let pausedLatest = false;
+    let action;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--run-id") {
+            runId = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--run-id=")) {
+            runId = arg.slice("--run-id=".length);
+            continue;
+        }
+        if (arg === "--lifecycle") {
+            const value = args[++i];
+            if (!LIFECYCLE_FILTERS.has(value)) {
+                throw new Error(`invalid --lifecycle value: ${value} (expected active|paused|completed|all)`);
+            }
+            lifecycle = value;
+            continue;
+        }
+        if (arg.startsWith("--lifecycle=")) {
+            const value = arg.slice("--lifecycle=".length);
+            if (!LIFECYCLE_FILTERS.has(value)) {
+                throw new Error(`invalid --lifecycle value: ${value} (expected active|paused|completed|all)`);
+            }
+            lifecycle = value;
+            continue;
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--markdown") {
+            markdown = true;
+            continue;
+        }
+        if (arg === "--failed-only") {
+            failedOnly = true;
+            continue;
+        }
+        if (arg === "--latest") {
+            latest = true;
+            continue;
+        }
+        if (arg === "--paused-latest") {
+            pausedLatest = true;
+            continue;
+        }
+        if (arg === "--action") {
+            const value = args[++i];
+            if (!RECOVERY_ACTIONS.has(value)) {
+                throw new Error(`invalid --action value: ${value} (expected ${[...DAG_RECOVERY_ACTIONS].join("|")})`);
+            }
+            action = value;
+            continue;
+        }
+        if (arg.startsWith("--action=")) {
+            const value = arg.slice("--action=".length);
+            if (!RECOVERY_ACTIONS.has(value)) {
+                throw new Error(`invalid --action value: ${value} (expected ${[...DAG_RECOVERY_ACTIONS].join("|")})`);
+            }
+            action = value;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag report flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (json && markdown) {
+        throw new Error("cannot use --json and --markdown together");
+    }
+    if (pausedLatest) {
+        if (lifecycle !== "all") {
+            throw new Error("cannot combine --paused-latest with an explicit --lifecycle filter");
+        }
+        lifecycle = DAG_PAUSED_LATEST_REPORT_PRESET.lifecycle;
+        latest = DAG_PAUSED_LATEST_REPORT_PRESET.latest;
+    }
+    return {
+        runId,
+        lifecycle,
+        json,
+        markdown,
+        failedOnly,
+        latest,
+        pausedLatest,
+        action,
+    };
+}

package/dist/application/dag/generate-task-dag.js

@@ -0,0 +1,280 @@
+import { readFile } from "node:fs/promises";
+import { resolveAutoRoutingProfile, requiresSupervisedQualityGate, } from "../../workflows/dag/governance-profile.js";
+import { resolveShellCommands } from "../../executors/shell-executor.js";
+import { parseDagSpec } from "../../workflows/dag/types.js";
+import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { loadHarnessManifest } from "../../governance/harness.js";
+import { defaultHybridDagOutputPath, initHybridDagFromTask, } from "../../workflows/dag/init-hybrid.js";
+import { validateDagUseCase } from "./validate-dag.js";
+import { runDagUseCase } from "./run-dag.js";
+const PLACEHOLDER_WRITESET_MARKER = "REPLACE/WITH";
+function buildValidateInput(repoRoot, dagPath, parsed) {
+    return {
+        repoRoot,
+        dagPath,
+        strictModelMatrix: parsed.strictModels,
+        strictGovernance: false,
+        forbidExecutors: parsed.noCursor ? ["cursor"] : [],
+    };
+}
+function shouldRunExecution(parsed) {
+    return parsed.execute || parsed.initOnly || parsed.dryRun;
+}
+function resolveExecutionMode(parsed) {
+    if (parsed.dryRun)
+        return "dry-run";
+    if (parsed.initOnly)
+        return "init-only";
+    return "execute";
+}
+function isUnsafeWriteSetEntry(entry) {
+    const normalized = entry.trim();
+    if (!normalized || normalized === "." || normalized === "./")
+        return true;
+    if (normalized === "**")
+        return true;
+    return normalized.includes(PLACEHOLDER_WRITESET_MARKER);
+}
+export async function assertSafeForExecution(dagPath) {
+    const raw = JSON.parse(await readFile(dagPath, "utf-8"));
+    const unsafe = [];
+    for (const task of raw.tasks ?? []) {
+        if (task.writePolicy !== "exclusive")
+            continue;
+        const writeSet = Array.isArray(task.writeSet) ? task.writeSet : [];
+        for (const entry of writeSet) {
+            if (typeof entry !== "string")
+                continue;
+            if (isUnsafeWriteSetEntry(entry)) {
+                const taskId = typeof task.id === "string" ? task.id : "unknown";
+                unsafe.push(`task=${taskId}, writeSet=${entry}`);
+            }
+        }
+    }
+    if (unsafe.length === 0)
+        return;
+    throw new Error(`refusing execution: narrow implement writeSet before --execute/init-only/dry-run: ${unsafe.join("; ")}`);
+}
+function buildNextSteps(taskId, outputPath, cwd) {
+    return [
+        `Review ${outputPath}`,
+        `npm run dev -- dag validate --dag ${outputPath}`,
+        `npm run dev -- run-dag --dag ${outputPath} --cwd ${cwd}`,
+        `npm run dev -- dag run-task ${taskId} --execute --cwd ${cwd}`,
+    ];
+}
+function isBroadWriteSetEntryForPacket(entry) {
+    const normalized = entry.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+    if (!normalized || normalized === "." || normalized === "./")
+        return true;
+    if (normalized === "**")
+        return true;
+    return normalized.includes(PLACEHOLDER_WRITESET_MARKER);
+}
+function resolveWritePolicyForPacket(task, spec) {
+    return task.writePolicy ?? spec.defaults?.writePolicy ?? "none";
+}
+function collectWriterTasksForPacket(spec) {
+    return spec.tasks.filter((task) => {
+        const writePolicy = resolveWritePolicyForPacket(task, spec);
+        return writePolicy === "exclusive" && (task.writeSet?.length ?? 0) > 0;
+    });
+}
+function findForbiddenOverlapsForPacket(task) {
+    const overlaps = [];
+    for (const writeSetEntry of task.writeSet ?? []) {
+        for (const forbiddenPath of task.forbiddenPaths ?? []) {
+            if (pathMatchesPattern(writeSetEntry, forbiddenPath) ||
+                pathMatchesPattern(forbiddenPath, writeSetEntry)) {
+                overlaps.push({ writeSetEntry, forbiddenPath });
+            }
+        }
+    }
+    return overlaps;
+}
+function isVerificationShellTask(task) {
+    if (task.executor !== "shell" || !task.shell)
+        return false;
+    if (/verify|verification/i.test(task.id))
+        return true;
+    const commands = resolveShellCommands(task.shell);
+    return commands.some((command) => /(vitest|npm run (lint|typecheck|test)|check-repo\.sh|loop-agent-standard-verify)/.test(command));
+}
+async function buildReviewPacket(input) {
+    const spec = parseDagSpec(JSON.parse(await readFile(input.dagPath, "utf-8")));
+    const writers = collectWriterTasksForPacket(spec).map((task) => {
+        const writeSet = task.writeSet ?? [];
+        return {
+            nodeId: task.id,
+            role: task.role,
+            writePolicy: resolveWritePolicyForPacket(task, spec),
+            writeSet,
+            broadEntries: writeSet.filter(isBroadWriteSetEntryForPacket),
+            forbiddenOverlaps: findForbiddenOverlapsForPacket(task),
+        };
+    });
+    const shellTasks = spec.tasks.filter((task) => task.executor === "shell" && task.shell);
+    const shellVerification = shellTasks
+        .filter(isVerificationShellTask)
+        .map((task) => ({
+        nodeId: task.id,
+        commands: resolveShellCommands(task.shell),
+    }));
+    return {
+        profileRouting: {
+            requestedProfile: input.profileRouting.requestedProfile,
+            selectedByProfile: input.profileRouting.selectedByProfile,
+            selectedTemplate: input.profileRouting.selectedTemplate,
+            source: input.profileRouting.source,
+            ...(input.profileRouting.routingReasons
+                ? { routingReasons: input.profileRouting.routingReasons }
+                : {}),
+        },
+        governanceProfile: input.governanceProfile,
+        writers,
+        broadWriteSetRisk: writers.some((writer) => writer.broadEntries.length > 0),
+        forbiddenOverlapRisk: writers.some((writer) => writer.forbiddenOverlaps.length > 0),
+        shellGates: shellTasks
+            .filter((task) => task.shell?.verdictGate)
+            .map((task) => ({
+            nodeId: task.id,
+            fromNodeId: task.shell.verdictGate.fromNodeId,
+            accept: task.shell.verdictGate.accept,
+            lineMode: task.shell.verdictGate.lineMode ?? "first-non-empty",
+            label: task.shell.verdictGate.label,
+            commands: resolveShellCommands(task.shell),
+        })),
+        shellVerification,
+        decisionGates: spec.tasks.map((task) => ({
+            nodeId: task.id,
+            enabled: task.decisionGate?.enabled ?? false,
+            mode: task.decisionGate?.enabled
+                ? (task.decisionGate.mode ?? "record-only")
+                : "disabled",
+        })),
+        expectedVerification: shellVerification.flatMap((entry) => entry.commands),
+    };
+}
+function templateForProfile(policy, profile) {
+    return policy.dag.profileRouting[profile];
+}
+async function resolveProfileRouting(repoRoot, parsed, candidateProfile) {
+    if (!parsed.profileExplicit) {
+        return {
+            requestedProfile: parsed.profile,
+            selectedByProfile: "standard",
+            selectedTemplate: "standard-dag",
+            source: "default",
+            candidateProfile,
+        };
+    }
+    const manifest = await loadHarnessManifest(repoRoot);
+    if (parsed.profile === "auto") {
+        const supervisedGate = requiresSupervisedQualityGate(candidateProfile);
+        const selectedByProfile = resolveAutoRoutingProfile(candidateProfile);
+        const escalatedToSupervised = supervisedGate.required && selectedByProfile === "supervised";
+        return {
+            requestedProfile: "auto",
+            selectedByProfile,
+            selectedTemplate: templateForProfile(manifest.workflowPolicy, selectedByProfile),
+            source: escalatedToSupervised
+                ? "supervised-quality-gate"
+                : "workflowPolicy",
+            candidateProfile,
+            routingReasons: supervisedGate.required
+                ? supervisedGate.reasons
+                : undefined,
+        };
+    }
+    return {
+        requestedProfile: parsed.profile,
+        selectedByProfile: parsed.profile,
+        selectedTemplate: templateForProfile(manifest.workflowPolicy, parsed.profile),
+        source: "cli",
+        candidateProfile,
+    };
+}
+export async function generateTaskDagUseCase(input) {
+    const { repoRoot, ...parsed } = input;
+    const candidateResult = await initHybridDagFromTask(repoRoot, parsed.taskId, {
+        outputPath: parsed.outputPath,
+        template: "standard-dag",
+    });
+    const candidateValidateSummary = await validateDagUseCase(buildValidateInput(repoRoot, candidateResult.outputPath, parsed));
+    const profileRouting = await resolveProfileRouting(repoRoot, parsed, candidateValidateSummary.governanceProfile ?? {
+        profile: "standard",
+        process: [],
+        delivery: [],
+        codeChange: [],
+        reasons: ["dag run-task validate did not report governanceProfile"],
+    });
+    const initResult = profileRouting.selectedTemplate === "standard-dag"
+        ? candidateResult
+        : await initHybridDagFromTask(repoRoot, parsed.taskId, {
+            outputPath: parsed.outputPath,
+            template: profileRouting.selectedTemplate,
+        });
+    const outputPath = initResult.outputPath;
+    const validateSummary = profileRouting.selectedTemplate === "standard-dag"
+        ? candidateValidateSummary
+        : await validateDagUseCase(buildValidateInput(repoRoot, outputPath, parsed));
+    const governanceProfile = validateSummary.governanceProfile ?? {
+        profile: "standard",
+        process: [],
+        delivery: [],
+        codeChange: [],
+        reasons: ["dag run-task validate did not report governanceProfile"],
+    };
+    const reviewPacket = await buildReviewPacket({
+        dagPath: outputPath,
+        profileRouting,
+        governanceProfile,
+    });
+    if (!shouldRunExecution(parsed)) {
+        return {
+            mode: "generate+validate",
+            ok: true,
+            taskId: initResult.taskId,
+            outputPath,
+            defaultOutputPath: defaultHybridDagOutputPath(parsed.taskId),
+            taskCount: initResult.taskCount,
+            nodeIds: initResult.nodeIds,
+            title: validateSummary.title,
+            ranks: validateSummary.ranks,
+            governanceProfile,
+            profileRouting,
+            reviewPacket,
+            warnings: validateSummary.warnings,
+            next: buildNextSteps(parsed.taskId, outputPath, parsed.cwd),
+        };
+    }
+    await assertSafeForExecution(outputPath);
+    const runSummary = await runDagUseCase({
+        repoRoot,
+        dagPath: outputPath,
+        cwd: parsed.cwd,
+        initOnly: parsed.initOnly,
+        dryRun: parsed.dryRun,
+        maxConcurrent: parsed.maxConcurrent,
+        runId: parsed.runId,
+        noCursor: parsed.noCursor,
+        canvasPath: parsed.canvasPath,
+        canvasName: parsed.canvasName,
+        canvasesDir: parsed.canvasesDir,
+    });
+    return {
+        mode: resolveExecutionMode(parsed),
+        ok: true,
+        taskId: initResult.taskId,
+        outputPath,
+        taskCount: initResult.taskCount,
+        nodeIds: initResult.nodeIds,
+        title: validateSummary.title,
+        ranks: validateSummary.ranks,
+        governanceProfile,
+        profileRouting,
+        reviewPacket,
+        warnings: validateSummary.warnings,
+        run: runSummary,
+    };
+}