@tea-agent/loop-agent 0.1.0 → 0.2.1

package/dist/adapters/loop-agent.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { readFileSync } from 'node:fs';
 import { buildStepContextFiles } from './context.js';
 import { loadHarnessManifest } from '../governance/harness.js';
 function getKeyRepoPaths(repoRoot, manifest) {
@@ -58,6 +59,10 @@ async function getContextFilesForStep(repoRoot, manifest, taskId, step, taskConf
     });
 }
 function getVerifyCommands(repoRoot, options) {
+    const manifestCommands = getManifestVerifyCommands(repoRoot, options.preset);
+    if (manifestCommands) {
+        return applyQuota(manifestCommands, options);
+    }
     const quickCommands = [
         {
             args: ['bash', 'scripts/check-repo.sh'],
@@ -84,11 +89,48 @@ function getVerifyCommands(repoRoot, options) {
         : options.preset === 'standard'
             ? [...quickCommands, ...standardCommands]
             : [...quickCommands, ...standardCommands, ...fullCommands];
+    return applyQuota(selectedCommands, options);
+}
+function applyQuota(commands, options) {
     if (options.phase === 'final' || !options.quota || options.quota === 'full') {
-        return selectedCommands;
+        return commands;
     }
     const maxCommands = options.quota === '1' ? 1 : 3;
-    return selectedCommands.slice(0, maxCommands);
+    return commands.slice(0, maxCommands);
+}
+function commandFromScript(repoRoot, label, command) {
+    return {
+        args: ['bash', '-lc', command],
+        cwd: repoRoot,
+        label,
+    };
+}
+function getManifestVerifyCommands(repoRoot, preset) {
+    try {
+        const manifest = JSON.parse(readFileSync(path.join(repoRoot, 'harness.json'), 'utf-8'));
+        const quick = typeof manifest.scripts?.quickVerify === 'string'
+            ? manifest.scripts.quickVerify
+            : undefined;
+        const standard = typeof manifest.scripts?.standardVerify === 'string'
+            ? manifest.scripts.standardVerify
+            : undefined;
+        const full = typeof manifest.scripts?.fullVerify === 'string'
+            ? manifest.scripts.fullVerify
+            : undefined;
+        if (!quick && !standard && !full)
+            return undefined;
+        const quickCommands = quick ? [commandFromScript(repoRoot, 'repo quick verification', quick)] : [];
+        const standardCommands = standard ? [commandFromScript(repoRoot, 'repo standard verification', standard)] : [];
+        const fullCommands = full ? [commandFromScript(repoRoot, 'repo full verification', full)] : [];
+        if (preset === 'quick')
+            return quickCommands;
+        if (preset === 'standard')
+            return [...quickCommands, ...standardCommands];
+        return [...quickCommands, ...standardCommands, ...fullCommands];
+    }
+    catch {
+        return undefined;
+    }
 }
 export const loopAgentAdapter = {
     name: 'loop-agent',

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,
+    };
+}