@tea-agent/loop-agent 0.26.0 → 0.26.1

package/dist/commands/task-source-prepare.js

@@ -0,0 +1,468 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { stdin as stdinStream } from "node:process";
+import { parseAcceptanceFlag, parseVerifyFlag, parseVerifyTimeoutFlag, prepareTaskSource, PREPARE_MAX_FILE_BYTES, } from "../task/source-prepare/index.js";
+import { parseTaskContractDraft } from "../task/contract/schema.js";
+import { buildOperatorResult, operatorFailed, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
+const COMMAND = "task source prepare";
+const USAGE = `usage:
+  task source prepare <task-id>
+    [--from-text <string>]
+    [--from-file <path>]
+    [--from-stdin]
+    [--from-draft <path-to-TaskContractDraftV1.json>]
+    [--use-imported-prd]
+    [--title <string>]
+    [--objective <text>]
+    [--scope <text>]...
+    [--task-kind <TaskKind>]
+    [--feature-id <string>]
+    [--allowed-path <glob>]...
+    [--forbidden-path <glob>]...
+    [--no-default-forbidden-paths]
+    [--invariant <text>]...
+    [--ac <id:text> | --acceptance <id:text>]...
+    [--non-goal <text>]...
+    [--assumption <text>]...
+    [--open-question <text>]...
+    [--verify <label:command>]...
+    [--verify-timeout <label:timeoutMs>]...
+    [--request-id <id>]
+    [--dry-run | --apply]
+    [--force-overwrite-source]
+    [--json]`;
+function pushList(target, value) {
+    const list = target ?? [];
+    list.push(value);
+    return list;
+}
+export function parseTaskSourcePrepareArgs(args) {
+    const options = {};
+    const positional = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const token = args[i];
+        const next = () => {
+            const value = args[i + 1];
+            if (value === undefined || value.startsWith("-")) {
+                throw new Error(`missing value for ${token}\n${USAGE}`);
+            }
+            i += 1;
+            return value;
+        };
+        if (token === "--json") {
+            options.json = true;
+            continue;
+        }
+        if (token === "--dry-run") {
+            options.dryRun = true;
+            continue;
+        }
+        if (token === "--apply") {
+            options.apply = true;
+            continue;
+        }
+        if (token === "--force-overwrite-source") {
+            options.forceOverwriteSource = true;
+            continue;
+        }
+        if (token === "--use-imported-prd") {
+            options.useImportedPrd = true;
+            continue;
+        }
+        if (token === "--from-stdin") {
+            options.fromStdin = true;
+            continue;
+        }
+        if (token === "--no-default-forbidden-paths") {
+            options.noDefaultForbiddenPaths = true;
+            continue;
+        }
+        if (token === "--from-text") {
+            options.fromText = next();
+            continue;
+        }
+        if (token === "--from-file") {
+            options.fromFile = next();
+            continue;
+        }
+        if (token === "--from-draft") {
+            options.fromDraft = next();
+            continue;
+        }
+        if (token === "--title") {
+            options.title = next();
+            continue;
+        }
+        if (token === "--objective") {
+            options.objective = next();
+            continue;
+        }
+        if (token === "--scope") {
+            options.scope = pushList(options.scope, next());
+            continue;
+        }
+        if (token === "--task-kind") {
+            options.taskKind = next();
+            continue;
+        }
+        if (token === "--feature-id") {
+            options.featureId = next();
+            continue;
+        }
+        if (token === "--allowed-path") {
+            options.allowedPaths = pushList(options.allowedPaths, next());
+            continue;
+        }
+        if (token === "--forbidden-path") {
+            options.forbiddenPaths = pushList(options.forbiddenPaths, next());
+            continue;
+        }
+        if (token === "--invariant") {
+            options.invariants = pushList(options.invariants, next());
+            continue;
+        }
+        if (token === "--ac" || token === "--acceptance") {
+            const parsed = parseAcceptanceFlag(next());
+            options.acceptanceCriteria = [
+                ...(options.acceptanceCriteria ?? []),
+                parsed,
+            ];
+            continue;
+        }
+        if (token === "--non-goal") {
+            options.nonGoals = pushList(options.nonGoals, next());
+            continue;
+        }
+        if (token === "--assumption") {
+            options.assumptions = pushList(options.assumptions, next());
+            continue;
+        }
+        if (token === "--open-question") {
+            options.openQuestions = pushList(options.openQuestions, next());
+            continue;
+        }
+        if (token === "--verify") {
+            options.verify = pushList(options.verify, next());
+            continue;
+        }
+        if (token === "--verify-timeout") {
+            options.verifyTimeout = pushList(options.verifyTimeout, next());
+            continue;
+        }
+        if (token === "--request-id") {
+            options.requestId = next();
+            continue;
+        }
+        if (token.startsWith("-")) {
+            throw new Error(`unknown flag ${token}\n${USAGE}`);
+        }
+        positional.push(token);
+    }
+    const taskId = positional[0];
+    if (!taskId) {
+        throw new Error(USAGE);
+    }
+    if (positional.length > 1) {
+        throw new Error(`unexpected arguments: ${positional.slice(1).join(" ")}\n${USAGE}`);
+    }
+    return { taskId, options };
+}
+function validateOptionCombinations(options) {
+    if (options.dryRun && options.apply) {
+        throw new Error(`--dry-run and --apply are mutually exclusive\n${USAGE}`);
+    }
+    const textSources = [
+        options.fromText !== undefined,
+        options.fromFile !== undefined,
+        Boolean(options.fromStdin),
+    ].filter(Boolean).length;
+    if (textSources > 1) {
+        throw new Error(`--from-text / --from-file / --from-stdin are mutually exclusive\n${USAGE}`);
+    }
+    if (options.fromDraft) {
+        if (options.useImportedPrd ||
+            options.fromText !== undefined ||
+            options.fromFile !== undefined ||
+            options.fromStdin) {
+            throw new Error(`--from-draft is mutually exclusive with --use-imported-prd / --from-text / --from-file / --from-stdin\n${USAGE}`);
+        }
+    }
+    const hasIntentSource = Boolean(options.fromDraft) ||
+        Boolean(options.useImportedPrd) ||
+        options.fromText !== undefined ||
+        options.fromFile !== undefined ||
+        Boolean(options.fromStdin) ||
+        Boolean(options.title) ||
+        Boolean(options.objective) ||
+        Boolean(options.acceptanceCriteria?.length) ||
+        Boolean(options.allowedPaths?.length);
+    if (!hasIntentSource) {
+        throw new Error(`need at least one intent source: --use-imported-prd, --from-text/--from-file/--from-stdin, --from-draft, or sufficient flags (title/objective + --ac + --allowed-path)\n${USAGE}`);
+    }
+}
+async function readStdinText() {
+    if (stdinStream.isTTY) {
+        throw new Error("--from-stdin refused on TTY; pipe input or use --from-file/--from-text");
+    }
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of stdinStream) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        total += buf.byteLength;
+        if (total > PREPARE_MAX_FILE_BYTES) {
+            throw new Error(`stdin input exceeds ${PREPARE_MAX_FILE_BYTES} bytes (INPUT_TOO_LARGE)`);
+        }
+        chunks.push(buf);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+async function loadTextInput(repoRoot, options) {
+    if (options.fromText !== undefined) {
+        if (Buffer.byteLength(options.fromText, "utf-8") > PREPARE_MAX_FILE_BYTES) {
+            throw new Error(`--from-text exceeds ${PREPARE_MAX_FILE_BYTES} bytes (INPUT_TOO_LARGE)`);
+        }
+        return { text: options.fromText, label: "from-text" };
+    }
+    if (options.fromFile) {
+        const absolute = path.isAbsolute(options.fromFile)
+            ? options.fromFile
+            : path.resolve(repoRoot, options.fromFile);
+        const raw = await readFile(absolute);
+        if (raw.byteLength > PREPARE_MAX_FILE_BYTES) {
+            throw new Error(`--from-file exceeds ${PREPARE_MAX_FILE_BYTES} bytes (INPUT_TOO_LARGE)`);
+        }
+        return { text: raw.toString("utf-8"), label: options.fromFile };
+    }
+    if (options.fromStdin) {
+        const text = await readStdinText();
+        return { text, label: "stdin" };
+    }
+    return {};
+}
+async function loadDraftInput(repoRoot, draftPath) {
+    const absolute = path.isAbsolute(draftPath)
+        ? draftPath
+        : path.resolve(repoRoot, draftPath);
+    const raw = await readFile(absolute);
+    if (raw.byteLength > PREPARE_MAX_FILE_BYTES) {
+        throw new Error(`--from-draft exceeds ${PREPARE_MAX_FILE_BYTES} bytes (INPUT_TOO_LARGE)`);
+    }
+    let json;
+    try {
+        json = JSON.parse(raw.toString("utf-8"));
+    }
+    catch (error) {
+        throw new Error(`--from-draft is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return parseTaskContractDraft(json);
+}
+function buildFlags(options) {
+    const flags = {
+        title: options.title,
+        objective: options.objective,
+        scope: options.scope,
+        taskKind: options.taskKind,
+        featureId: options.featureId,
+        allowedPaths: options.allowedPaths,
+        forbiddenPaths: options.forbiddenPaths,
+        noDefaultForbiddenPaths: options.noDefaultForbiddenPaths,
+        invariants: options.invariants,
+        acceptanceCriteria: options.acceptanceCriteria,
+        nonGoals: options.nonGoals,
+        assumptions: options.assumptions,
+        openQuestions: options.openQuestions,
+    };
+    if (options.verify || options.verifyTimeout) {
+        const timeouts = new Map();
+        for (const raw of options.verifyTimeout ?? []) {
+            const parsed = parseVerifyTimeoutFlag(raw);
+            timeouts.set(parsed.label, parsed.timeoutMs);
+        }
+        const commands = (options.verify ?? []).map((raw) => {
+            const parsed = parseVerifyFlag(raw);
+            const timeoutMs = timeouts.get(parsed.label);
+            return {
+                label: parsed.label,
+                command: parsed.command,
+                ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+            };
+        });
+        // If only timeouts provided without verify, treat as empty explicit list? No — only set when --verify appears.
+        if (options.verify) {
+            flags.verifyCommands = commands;
+        }
+    }
+    return flags;
+}
+function toOperatorEnvelope(result) {
+    const payload = {
+        taskId: result.taskId,
+        mode: result.mode,
+        taskKind: result.taskKind,
+        title: result.title,
+        draft: result.draft,
+        gaps: result.gaps,
+        risks: result.risks,
+        projected: result.projected,
+        apply: result.apply ?? null,
+        next: result.next,
+        contractStatus: result.contractStatus,
+    };
+    if (result.ok) {
+        return buildOperatorResult({
+            command: COMMAND,
+            ok: true,
+            outcome: result.outcome,
+            result: payload,
+            warnings: result.warnings ?? [],
+        });
+    }
+    return buildOperatorResult({
+        command: COMMAND,
+        ok: false,
+        outcome: result.outcome,
+        result: payload,
+        warnings: result.warnings ?? [],
+        error: result.error ?? {
+            code: "INVALID_INPUT",
+            message: "task source prepare failed",
+        },
+    });
+}
+function printHuman(result) {
+    const lines = [
+        `task source prepare: ${result.taskId}`,
+        `  mode: ${result.mode}`,
+        `  outcome: ${result.outcome}`,
+        `  ok: ${result.ok}`,
+    ];
+    if (result.title)
+        lines.push(`  title: ${result.title}`);
+    if (result.taskKind)
+        lines.push(`  taskKind: ${result.taskKind}`);
+    if (result.contractStatus) {
+        lines.push(`  contractStatus: ${result.contractStatus}`);
+    }
+    if (result.gaps.length > 0) {
+        lines.push("  gaps:");
+        for (const gap of result.gaps) {
+            lines.push(`    - [${gap.level}] ${gap.code}: ${gap.message}`);
+        }
+    }
+    if (result.risks.length > 0) {
+        lines.push("  risks:");
+        for (const risk of result.risks) {
+            lines.push(`    - [${risk.level}] ${risk.code}: ${risk.message}`);
+        }
+    }
+    if (result.projected) {
+        lines.push(`  projected: ${result.projected.requirementPath}, ${result.projected.constraintsPath}`);
+        if (result.draft) {
+            lines.push(`  allowedPaths: ${result.draft.constraints.allowedPaths.join(", ") || "(none)"}`);
+            lines.push(`  forbiddenPaths: ${result.draft.constraints.forbiddenPaths.join(", ") || "(none)"}`);
+            lines.push(`  verifyCommands: ${result.draft.verification.commands
+                .map((c) => c.label)
+                .join(", ") || "(none)"}`);
+        }
+    }
+    if (result.apply) {
+        lines.push(`  apply: revision=${result.apply.ref.revision} txId=${result.apply.txId}`);
+    }
+    if (result.error) {
+        lines.push(`  error: ${result.error.code}: ${result.error.message}`);
+    }
+    if (result.next.length > 0) {
+        lines.push("  next:");
+        for (const step of result.next) {
+            lines.push(`    - ${step}`);
+        }
+    }
+    console.log(lines.join("\n"));
+}
+export async function runTaskSourcePrepare(repoRoot, args) {
+    let taskId;
+    let options = {};
+    try {
+        ({ taskId, options } = parseTaskSourcePrepareArgs(args));
+        validateOptionCombinations(options);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const envelope = operatorFailed({
+            command: COMMAND,
+            outcome: "invalid",
+            code: "INVALID_INPUT",
+            message,
+        });
+        if (options.json || args.includes("--json")) {
+            writeOperatorJson(envelope);
+        }
+        else {
+            console.error(message);
+        }
+        process.exitCode = processExitCodeForOutcome(envelope.outcome);
+        return;
+    }
+    try {
+        const flags = buildFlags(options);
+        const mode = options.apply ? "apply" : "dry-run";
+        let prepareInput;
+        if (options.fromDraft) {
+            const draft = await loadDraftInput(repoRoot, options.fromDraft);
+            prepareInput = {
+                repoRoot,
+                taskId,
+                mode,
+                intent: { kind: "draft", draft, sourcePath: options.fromDraft },
+                flags,
+                requestId: options.requestId,
+                forceOverwriteSource: options.forceOverwriteSource,
+            };
+        }
+        else {
+            const textInput = await loadTextInput(repoRoot, options);
+            prepareInput = {
+                repoRoot,
+                taskId,
+                mode,
+                intent: {
+                    kind: "facts",
+                    useImportedPrd: Boolean(options.useImportedPrd),
+                    text: textInput.text,
+                    textLabel: textInput.label,
+                },
+                flags,
+                requestId: options.requestId,
+                forceOverwriteSource: options.forceOverwriteSource,
+            };
+        }
+        const result = await prepareTaskSource(prepareInput);
+        const envelope = toOperatorEnvelope(result);
+        if (options.json) {
+            writeOperatorJson(envelope);
+        }
+        else {
+            printHuman(result);
+        }
+        process.exitCode = processExitCodeForOutcome(result.outcome);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code = message.includes("INPUT_TOO_LARGE")
+            ? "INPUT_TOO_LARGE"
+            : "INVALID_INPUT";
+        const envelope = operatorFailed({
+            command: COMMAND,
+            outcome: "invalid",
+            code,
+            message,
+        });
+        if (options.json) {
+            writeOperatorJson(envelope);
+        }
+        else {
+            console.error(message);
+        }
+        process.exitCode = processExitCodeForOutcome(envelope.outcome);
+    }
+}

package/dist/executors/dag-pi-executor.js

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { writeDagNodeJsonArtifact, writeTextArtifactFile, } from "../infrastructure/harness/artifact-store.js";
 import { executePiStep, } from "./pi-executor.js";
 import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
-import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
 export const DAG_PI_WRITE_TOOLS = [
@@ -257,7 +257,10 @@ export async function writePiExecutorArtifacts(artifactsDir, input) {
     await writeTextArtifactFile(summaryPath, buildPiResultSummaryMarkdown(input));
     return { promptPath, summaryPath };
 }
-export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
+const DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES = {
+    readGitStatusPorcelain,
+};
+export async function executeDagPiNode(input, meta, piStepFn = executePiStep, writeGuardDependencies = DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES) {
     const started = Date.now();
     const persona = resolveDagPiPersona(input.task);
     const step = resolveDagPiStepName(input.task);
@@ -276,10 +279,19 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
     let beforePathFingerprints;
     if (isWriteTask) {
         try {
-            beforeStatus = await readGitStatusPorcelain(input.cwd);
-            beforePathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, snapshotGitStatusPorcelain(beforeStatus));
+            beforeStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-before" });
+            const beforeSnapshot = snapshotGitStatusPorcelain(beforeStatus);
+            beforePathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, beforeSnapshot);
+            await persistWriterGitBaseline({
+                runDir: meta.runDir,
+                nodeId: input.task.id,
+                beforeStatus,
+                beforeSnapshot,
+                beforePathFingerprints,
+            });
         }
         catch (error) {
+            await persistGitWriteGuardDiagnostics(meta.runDir, input.task.id, error);
             return {
                 ok: false,
                 stdout: "",
@@ -349,7 +361,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
     let changeManifestChangedFiles;
     if (beforeStatus !== undefined) {
         try {
-            const afterStatus = await readGitStatusPorcelain(input.cwd);
+            const afterStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-after" });
             const afterSnapshot = snapshotGitStatusPorcelain(afterStatus);
             const afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, afterSnapshot);
             const changedFiles = pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), afterSnapshot, beforePathFingerprints, afterPathFingerprints);
@@ -364,6 +376,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
             writeGuardViolations = guard.violations;
         }
         catch (error) {
+            await persistGitWriteGuardDiagnostics(meta.runDir, input.task.id, error);
             writeGuardOk = false;
             writeGuardViolations = [
                 `git status unavailable: ${error instanceof Error ? error.message : String(error)}`,
@@ -604,6 +617,28 @@ function stripMarkdownLineDecorations(line) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+async function persistWriterGitBaseline(input) {
+    const fingerprintEntries = [...input.beforePathFingerprints.entries()].sort(([left], [right]) => left.localeCompare(right));
+    const baseline = {
+        schemaVersion: 1,
+        nodeId: input.nodeId,
+        phase: "pi-writer-before",
+        capturedAt: new Date().toISOString(),
+        statusSha256: createHash("sha256")
+            .update(input.beforeStatus)
+            .digest("hex"),
+        dirtyPaths: [...input.beforeSnapshot.keys()].sort(),
+        pathFingerprintsSha256: createHash("sha256")
+            .update(JSON.stringify(fingerprintEntries))
+            .digest("hex"),
+    };
+    await writeDagNodeJsonArtifact(input.runDir, input.nodeId, "write-guard-baseline.json", baseline);
+}
+async function persistGitWriteGuardDiagnostics(runDir, nodeId, error) {
+    if (!(error instanceof GitStatusUnavailableError))
+        return;
+    await writeDagNodeJsonArtifact(runDir, nodeId, "git-write-guard-diagnostics.json", error.diagnostics);
+}
 /**
  * Validate the writer's observed diff against its declared write boundary.
  * Inlined mirror of runPostRunWriteGuard that reuses the already-computed diff