@tea-agent/loop-agent 0.1.0 → 0.2.1

package/dist/commands/dag-validate.js

@@ -1,186 +1,14 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { loadDagSpecFromFile } from "../workflows/dag/runner.js";
-import { assertValidDagSpec, collectExecutorModelWarnings, collectForbiddenExecutorIssues, collectGovernanceWarnings, validateDagSpec, } from "../workflows/dag/validate.js";
-import { inferGovernanceProfile } from "../workflows/dag/governance-profile.js";
-import { topoSortToRanks } from "../workflows/dag/topo.js";
-import { runSpineAudit } from "../governance/spine-audit.js";
-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,
-    };
-}
-function formatModelMatrixWarnings(warnings) {
-    return warnings.map((warning) => ({
-        executor: warning.executor,
-        complexity: warning.complexity,
-        expected: warning.expected,
-        actual: warning.actual,
-    }));
-}
-function formatGovernanceWarnings(warnings) {
-    return warnings.map((warning) => ({
-        type: warning.type,
-        message: warning.message,
-    }));
-}
-function ensureStrictModelMatrix(warnings) {
-    if (warnings.length === 0) {
-        return;
-    }
-    const details = warnings
-        .map((entry) => `executor=${entry.executor}, complexity=${entry.complexity}, expected=${entry.expected}, actual=${entry.actual}`)
-        .join("; ");
-    throw new Error(`non-canonical executorModels overrides are blocked by --strict-models: ${details}`);
-}
-async function loadRawTaskExecutorMap(dagPath) {
-    const raw = JSON.parse(await readFile(dagPath, "utf-8"));
-    const map = new Map();
-    for (const task of raw.tasks ?? []) {
-        if (typeof task.id === "string")
-            map.set(task.id, task.executor);
-    }
-    return map;
-}
-function ensureNoForbiddenExecutors(spec, forbidExecutors, rawTaskExecutors) {
-    const supported = new Set(["cursor", "pi", "shell", "static"]);
-    const normalized = forbidExecutors.map((executor) => {
-        if (!supported.has(executor)) {
-            throw new Error(`unsupported executor for --forbid-executor: ${executor}`);
-        }
-        return executor;
-    });
-    const issues = collectForbiddenExecutorIssues(spec, normalized);
-    if (issues.length === 0)
-        return;
-    const details = issues
-        .map((issue) => {
-        const implicitDefault = rawTaskExecutors.get(issue.taskId) === undefined;
-        return `task=${issue.taskId}, executor=${issue.executor}${implicitDefault ? " (implicit default)" : ""}`;
-    })
-        .join("; ");
-    throw new Error(`forbidden executor present: ${details}`);
-}
+import { parseDagValidateArgs, } from "../application/dag/args.js";
+import { validateDagUseCase } from "../application/dag/validate-dag.js";
+export { parseDagValidateArgs };
 export async function runDagValidate(repoRoot, rawArgs) {
     const parsed = parseDagValidateArgs(rawArgs);
-    const spec = await loadDagSpecFromFile(parsed.dagPath);
-    const rawTaskExecutors = await loadRawTaskExecutorMap(parsed.dagPath);
-    ensureNoForbiddenExecutors(spec, parsed.forbidExecutors, rawTaskExecutors);
-    const validationIssues = validateDagSpec(spec);
-    const warnings = collectExecutorModelWarnings(spec);
-    const governanceWarnings = collectGovernanceWarnings(validationIssues);
-    if (parsed.strictModelMatrix) {
-        ensureStrictModelMatrix(warnings);
-    }
-    const spineAudit = parsed.spineTaskId
-        ? await runSpineAudit(repoRoot, parsed.spineTaskId)
-        : undefined;
-    if (parsed.strictGovernance && spineAudit && !spineAudit.ok) {
-        throw new Error(`minimal spec spine audit failed for ${parsed.spineTaskId}: ${spineAudit.findings
-            .filter((finding) => finding.severity === "error")
-            .map((finding) => `${finding.type}: ${finding.message}`)
-            .join("; ")}`);
-    }
-    assertValidDagSpec(spec, {
-        issues: validationIssues,
-        strictGovernance: parsed.strictGovernance,
+    const result = await validateDagUseCase({
+        repoRoot,
+        ...parsed,
     });
-    const { ranks } = topoSortToRanks(spec);
-    const governanceProfile = inferGovernanceProfile(spec);
     console.log(JSON.stringify({
         mode: "validate",
-        title: spec.title,
-        taskCount: spec.tasks.length,
-        ranks,
-        governanceProfile,
-        spineAudit: spineAudit
-            ? {
-                ok: spineAudit.ok,
-                taskId: spineAudit.taskId,
-                findings: spineAudit.findings,
-                verifyCommandLabels: spineAudit.verifyCommandLabels,
-            }
-            : undefined,
-        warnings: [
-            ...formatModelMatrixWarnings(warnings),
-            ...formatGovernanceWarnings(governanceWarnings),
-        ],
+        ...result,
     }, null, 2));
 }

package/dist/commands/examples.js

@@ -0,0 +1,90 @@
+import { copyFile, mkdir, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+async function exists(filePath) {
+    try {
+        await readFile(filePath, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findPackageRoot() {
+    let current = path.dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        if (await exists(path.join(current, "package.json")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return path.resolve(".");
+        current = parent;
+    }
+}
+async function examplesRoot() {
+    return path.join(await findPackageRoot(), "examples");
+}
+function assertSafeExampleName(name) {
+    if (!name || name.includes("/") || name.includes("\\") || name.includes("..")) {
+        throw new Error(`invalid example name: ${name}`);
+    }
+}
+export async function listBundledExamples() {
+    const root = await examplesRoot();
+    const entries = await readdir(root, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .sort();
+}
+export async function readBundledExample(name) {
+    assertSafeExampleName(name);
+    return readFile(path.join(await examplesRoot(), name), "utf-8");
+}
+export async function copyBundledExample(input) {
+    assertSafeExampleName(input.name);
+    const targetRelative = input.output ?? path.join("examples", input.name);
+    const target = path.join(input.repoRoot, targetRelative);
+    await mkdir(path.dirname(target), { recursive: true });
+    await copyFile(path.join(await examplesRoot(), input.name), target);
+    return target;
+}
+function parseExamplesArgs(args) {
+    const [subcommand, name, ...rest] = args;
+    if (!subcommand || !["list", "show", "copy"].includes(subcommand)) {
+        throw new Error("usage: examples <list|show|copy> [name] [--output <path>]");
+    }
+    let output;
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === "--output" || arg === "-o") {
+            output = rest[++i];
+            continue;
+        }
+        if (arg.startsWith("--output=")) {
+            output = arg.slice("--output=".length);
+            continue;
+        }
+        throw new Error(`unknown examples flag: ${arg}`);
+    }
+    return { subcommand, name, output };
+}
+export async function runExamples(repoRoot, rawArgs) {
+    const parsed = parseExamplesArgs(rawArgs);
+    if (parsed.subcommand === "list") {
+        console.log((await listBundledExamples()).join("\n"));
+        return;
+    }
+    if (!parsed.name)
+        throw new Error(`examples ${parsed.subcommand} requires <name>`);
+    if (parsed.subcommand === "show") {
+        console.log(await readBundledExample(parsed.name));
+        return;
+    }
+    const target = await copyBundledExample({
+        name: parsed.name,
+        repoRoot,
+        output: parsed.output,
+    });
+    console.log(target);
+}