@tea-agent/loop-agent 0.3.0 → 0.4.0

package/dist/worker/pool/run-store.js

@@ -0,0 +1,117 @@
+import { appendFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+export function getTaskPoolRoot(repoRoot) {
+    return path.join(repoRoot, ".task-pool");
+}
+export function getRunsJsonlPath(repoRoot) {
+    return path.join(getTaskPoolRoot(repoRoot), "runs", "runs.jsonl");
+}
+export function getEventsJsonlPath(repoRoot) {
+    return path.join(getTaskPoolRoot(repoRoot), "events", "events.jsonl");
+}
+export function getTaskStatePath(repoRoot, taskId) {
+    return path.join(getTaskPoolRoot(repoRoot), "state", `${taskId}.json`);
+}
+export async function recordTaskPoolRun(input) {
+    await ensurePoolDirs(input.repoRoot);
+    await appendJsonlFile(getRunsJsonlPath(input.repoRoot), input.run);
+    await writeTaskPoolState(input.repoRoot, stateFromRun(input.run));
+    await appendJsonlFile(getEventsJsonlPath(input.repoRoot), eventFromRun(input.run));
+}
+export async function findRunByWorkerRunId(repoRoot, workerRunId) {
+    const runs = await readJsonlFile(getRunsJsonlPath(repoRoot));
+    return runs.find((run) => run.workerRunId === workerRunId);
+}
+export async function readTaskPoolState(repoRoot, taskId) {
+    const statePath = getTaskStatePath(repoRoot, taskId);
+    try {
+        return JSON.parse(await readFile(statePath, "utf-8"));
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return undefined;
+        throw error;
+    }
+}
+export async function readAllTaskPoolStates(repoRoot) {
+    const stateDir = path.join(getTaskPoolRoot(repoRoot), "state");
+    try {
+        const entries = await readdir(stateDir);
+        const states = {};
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            const raw = await readFile(path.join(stateDir, entry), "utf-8");
+            const state = JSON.parse(raw);
+            states[state.taskId] = state;
+        }
+        return states;
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return {};
+        throw error;
+    }
+}
+export async function writeTaskPoolState(repoRoot, state) {
+    const statePath = getTaskStatePath(repoRoot, state.taskId);
+    await mkdir(path.dirname(statePath), { recursive: true });
+    await writeFile(statePath, `${JSON.stringify({ schemaVersion: 1, ...state }, null, 2)}\n`, "utf-8");
+}
+export async function readJsonlFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        return raw
+            .split(/\r?\n/)
+            .filter((line) => line.trim().length > 0)
+            .map((line) => JSON.parse(line));
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return [];
+        throw error;
+    }
+}
+async function appendJsonlFile(filePath, value) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await appendFile(filePath, `${JSON.stringify(value)}\n`, "utf-8");
+}
+async function ensurePoolDirs(repoRoot) {
+    await mkdir(path.join(getTaskPoolRoot(repoRoot), "runs"), { recursive: true });
+    await mkdir(path.join(getTaskPoolRoot(repoRoot), "events"), { recursive: true });
+    await mkdir(path.join(getTaskPoolRoot(repoRoot), "state"), { recursive: true });
+}
+function stateFromRun(run) {
+    return {
+        taskId: run.taskId,
+        status: stateStatusFromRun(run),
+        updatedAt: run.recordedAt,
+        workerRunId: run.workerRunId,
+        ...(run.runRecordPath ? { lastRunRecordPath: run.runRecordPath } : {}),
+        ...(run.failure ? { failure: run.failure } : {}),
+    };
+}
+function stateStatusFromRun(run) {
+    if (run.status === "succeeded")
+        return "Done";
+    if (run.status === "run-error")
+        return "Blocked";
+    return "Failed";
+}
+function eventFromRun(run) {
+    return {
+        schemaVersion: 1,
+        at: run.recordedAt,
+        type: "task-run-recorded",
+        batchRunId: run.batchRunId,
+        workerRunId: run.workerRunId,
+        taskId: run.taskId,
+        status: run.status,
+    };
+}
+function isNotFound(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/worker/pool/types.js

@@ -0,0 +1 @@
+export {};

package/dist/worker/preflight.js

@@ -0,0 +1,108 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+export const DEFAULT_CHECK_REPO_TIMEOUT_MS = 300_000;
+export async function preflightTargetRepo(input) {
+    const commands = [];
+    if (!(await exists(path.join(input.repoRoot, "harness.json")))) {
+        return {
+            ok: false,
+            code: "target-not-initialized",
+            message: "target repo is missing harness.json",
+            commands,
+        };
+    }
+    if (!(await exists(path.join(input.repoRoot, ".harness")))) {
+        return {
+            ok: false,
+            code: "target-not-initialized",
+            message: "target repo is missing .harness",
+            commands,
+        };
+    }
+    const version = await input.client.run(["--version"], {
+        cwd: input.repoRoot,
+        artifactName: "loop-agent-version",
+    });
+    commands.push({ artifactName: "loop-agent-version", result: version });
+    if (!version.ok) {
+        return {
+            ok: false,
+            code: "version-failed",
+            message: "loop-agent --version failed",
+            commands,
+        };
+    }
+    const inspect = await input.client.run(["inspect"], {
+        cwd: input.repoRoot,
+        artifactName: "inspect",
+        expectJson: true,
+    });
+    commands.push({ artifactName: "inspect", result: inspect });
+    if (!inspect.ok || !inspect.json || typeof inspect.json !== "object") {
+        return {
+            ok: false,
+            code: "inspect-failed",
+            message: "loop-agent inspect failed or did not return JSON",
+            commands,
+        };
+    }
+    const docsAudit = await input.client.run(["docs", "audit"], {
+        cwd: input.repoRoot,
+        artifactName: "docs-audit",
+    });
+    commands.push({ artifactName: "docs-audit", result: docsAudit });
+    if (!docsAudit.ok) {
+        return {
+            ok: false,
+            code: "docs-audit-failed",
+            message: "loop-agent docs audit failed",
+            commands,
+        };
+    }
+    const gitStatus = await input.client.runExternal("git", ["status", "--short", "--branch"], {
+        cwd: input.repoRoot,
+        artifactName: "git-status",
+    });
+    commands.push({ artifactName: "git-status", result: gitStatus });
+    if (!gitStatus.ok) {
+        return {
+            ok: false,
+            code: "git-status-failed",
+            message: "git status --short --branch failed",
+            commands,
+        };
+    }
+    if (input.runCheckRepo) {
+        const [command, ...args] = input.checkRepoCommand ?? ["bash", "scripts/check-repo.sh"];
+        const checkRepo = await input.client.runExternal(command, args, {
+            cwd: input.repoRoot,
+            artifactName: "check-repo",
+            timeoutMs: DEFAULT_CHECK_REPO_TIMEOUT_MS,
+        });
+        commands.push({ artifactName: "check-repo", result: checkRepo });
+        if (!checkRepo.ok) {
+            return {
+                ok: false,
+                code: "check-repo-failed",
+                message: `${[command, ...args].join(" ")} failed`,
+                commands,
+            };
+        }
+    }
+    return {
+        ok: true,
+        version: version.stdout.trim(),
+        inspect: inspect.json,
+        gitStatus: gitStatus.stdout,
+        commands,
+    };
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/worker/profile-mapping.js

@@ -0,0 +1,76 @@
+const MINIMAL_TYPES = new Set([
+    "doc-update",
+    "qa-analysis",
+    "qa-casegen",
+    "qa-execute",
+]);
+const SENSITIVE_PATH_MARKERS = [
+    "auth",
+    "payment",
+    "database",
+    "migration",
+    "migrations",
+    "infra",
+    "secret",
+    "public-contract",
+    "public_contract",
+];
+export function resolveLoopAgentProfile(taskSpec) {
+    if (taskSpec.risk_level === "high") {
+        return mapping(taskSpec, "supervised", "risk-high", [
+            "risk_level=high requires supervised governance",
+        ]);
+    }
+    if (MINIMAL_TYPES.has(taskSpec.type)) {
+        return mapping(taskSpec, "minimal", `${taskSpec.type}-minimal`, [
+            `type=${taskSpec.type}`,
+        ]);
+    }
+    const sensitiveMarkers = collectSensitiveMarkers(taskSpec);
+    if (sensitiveMarkers.length > 0) {
+        return mapping(taskSpec, "reviewed", "sensitive-path", [
+            `sensitive path markers: ${sensitiveMarkers.join(", ")}`,
+        ]);
+    }
+    if (taskSpec.type === "backend-feature" ||
+        taskSpec.type === "frontend-feature") {
+        if (taskSpec.risk_level === "medium") {
+            return mapping(taskSpec, "reviewed", `${taskSpec.type}-medium`, [
+                `type=${taskSpec.type}`,
+                "risk_level=medium",
+            ]);
+        }
+        return mapping(taskSpec, "standard", `${taskSpec.type}-low`, [
+            `type=${taskSpec.type}`,
+            "risk_level=low",
+        ]);
+    }
+    if (taskSpec.type === "qa-testcode") {
+        return mapping(taskSpec, "standard", "qa-testcode-standard", [
+            "type=qa-testcode",
+        ]);
+    }
+    if (taskSpec.type === "ci-fix" || taskSpec.type === "reviewer-gate") {
+        return mapping(taskSpec, "reviewed", `${taskSpec.type}-reviewed`, [
+            `type=${taskSpec.type}`,
+        ]);
+    }
+    return mapping(taskSpec, "reviewed", "default-reviewed", [
+        `type=${taskSpec.type}`,
+        "default governance profile",
+    ]);
+}
+function mapping(taskSpec, loopAgentProfile, ruleId, reasons) {
+    return {
+        taskId: taskSpec.id,
+        businessProfile: taskSpec.type,
+        riskLevel: taskSpec.risk_level,
+        loopAgentProfile,
+        ruleId,
+        reasons,
+    };
+}
+function collectSensitiveMarkers(taskSpec) {
+    const haystack = taskSpec.constraints.allowed_paths.map((value) => value.toLowerCase());
+    return SENSITIVE_PATH_MARKERS.filter((marker) => haystack.some((value) => value.includes(marker)));
+}

package/dist/worker/progress-reporter.js

@@ -0,0 +1,81 @@
+/**
+ * Human-readable progress reporting for long-running worker commands.
+ *
+ * Why this exists: agent-worker batch runs can take many minutes per task with
+ * zero stdout/stderr feedback, which looks indistinguishable from a hang. The
+ * system writes rich state to disk (state.json, run.json, .task-pool artifacts)
+ * but never echoes it to the triggering terminal, so users assume it is dead.
+ *
+ * Design:
+ * - Progress goes to STDERR only. STDOUT stays reserved for the final
+ *   machine-readable JSON payload, so `... | jq` and pipes keep working.
+ * - Default ON. `--quiet` disables it. Non-interactive use that only wants JSON
+ *   can pass `--quiet` (or redirect stderr).
+ * - TTY-aware for ANSI only: if stderr is not a TTY, we still print the lines
+ *   (they are line-buffered text and flush fine) but skip ANSI decoration.
+ * - A `noop` reporter keeps library callers (and tests that don't care) quiet
+ *   with zero changes to their call sites beyond accepting the option.
+ */
+const ANSI = {
+    bold: "\x1b[1m",
+    green: "\x1b[32m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    cyan: "\x1b[36m",
+    dim: "\x1b[2m",
+    reset: "\x1b[0m",
+};
+function stamp(now) {
+    const iso = now.toISOString();
+    // YYYY-MM-DDTHH:MM:SS — drop millis and trailing Z noise for compact lines.
+    return `[${iso.slice(0, 19)}]`;
+}
+export function createProgressReporter(options = {}) {
+    if (options.quiet)
+        return noopProgressReporter;
+    const sink = options.sink ?? ((chunk) => process.stderr.write(chunk));
+    const isTty = options.isTty ?? process.stderr.isTTY === true;
+    const now = options.now ?? (() => new Date());
+    function decorate(prefix, message, color) {
+        return isTty ? `${color}${prefix}${ANSI.reset} ${message}` : `${prefix} ${message}`;
+    }
+    return {
+        batch(message) {
+            sink(`${stamp(now())} ${decorate("==", message, ANSI.bold + ANSI.cyan)}\n`);
+        },
+        task(message) {
+            sink(`${stamp(now())} ${decorate("▶", message, ANSI.bold)}\n`);
+        },
+        step(message) {
+            const body = isTty ? `${ANSI.dim}${message}${ANSI.reset}` : message;
+            sink(`${stamp(now())}   ${body}\n`);
+        },
+        note(message) {
+            sink(`${stamp(now())} ${decorate("•", message, ANSI.dim)}\n`);
+        },
+    };
+}
+export const noopProgressReporter = {
+    batch() { },
+    task() { },
+    step() { },
+    note() { },
+};
+/** Format a millisecond duration as a compact human string: "6m 35s", "1h 2m 3s", "450ms". */
+export function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return "?";
+    if (ms < 1000)
+        return `${Math.round(ms)}ms`;
+    const totalSeconds = Math.round(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0 || hours > 0)
+        parts.push(`${minutes}m`);
+    parts.push(`${seconds}s`);
+    return parts.join(" ");
+}

package/dist/worker/report/morning-report.js

@@ -0,0 +1,69 @@
+import { access, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { getRunsJsonlPath, readAllTaskPoolStates, readJsonlFile, } from "../pool/run-store.js";
+export async function renderMorningReport(options) {
+    const runs = (await readJsonlFile(getRunsJsonlPath(options.repoRoot))).filter((run) => !options.batchRunId || run.batchRunId === options.batchRunId);
+    const total = runs.length;
+    const succeeded = runs.filter((run) => run.status === "succeeded").length;
+    const failed = runs.filter((run) => run.status === "failed").length;
+    const followUps = runs.filter((run) => run.failure).length;
+    const states = await readAllTaskPoolStates(options.repoRoot);
+    const blocked = Object.values(states).filter((state) => state.status === "Blocked").length;
+    const lines = [
+        "# Nightly Worker Report",
+        "",
+        "## Summary",
+        "",
+        `- Total: ${total}`,
+        `- Succeeded: ${succeeded}`,
+        `- Failed: ${failed}`,
+        `- Blocked: ${blocked}`,
+        `- Follow-ups: ${followUps}`,
+        "",
+        "## Results",
+        "",
+        "| Task | Status | Run | Failure | Next | Artifacts |",
+        "|---|---|---|---|---|---|",
+    ];
+    for (const run of runs) {
+        lines.push(`| ${run.taskId} | ${run.status} | ${run.workerRunId} | ${run.failure?.category ?? "-"} | ${run.failure?.derivedFollowUpTaskId ?? "-"} | ${await artifactSummary(run)} |`);
+    }
+    if (followUps > 0) {
+        lines.push("", "## Human Actions", "");
+        for (const run of runs.filter((candidate) => candidate.failure)) {
+            lines.push(`- ${run.failure?.derivedFollowUpTaskId}: ${run.failure?.recommendedFollowUpKind} for ${run.taskId}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export async function writeMorningReport(input) {
+    const markdown = await renderMorningReport(input);
+    await mkdir(path.dirname(input.outputPath), { recursive: true });
+    await writeFile(input.outputPath, markdown, "utf-8");
+    return input.outputPath;
+}
+async function artifactSummary(run) {
+    const artifacts = [
+        ["dag", run.dagPath],
+        ["record", run.runRecordPath],
+        ["report", run.failureArtifacts?.reportMarkdownArtifactPath],
+        ["doctor", run.failureArtifacts?.doctorMarkdownArtifactPath],
+        ["closeout", run.failureArtifacts?.closeoutDraftPath],
+    ].filter((entry) => Boolean(entry[1]));
+    if (artifacts.length === 0)
+        return "-";
+    const parts = [];
+    for (const [label, artifactPath] of artifacts) {
+        parts.push(`${label}:${(await exists(artifactPath)) ? artifactPath : `missing artifact ${artifactPath}`}`);
+    }
+    return parts.join("<br>");
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/worker/repos/repo-resolver.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+export function resolveRepoPath(config, pathRef) {
+    const entry = config.repos?.[pathRef];
+    if (!entry) {
+        return {
+            ok: false,
+            code: "repo-path-ref-missing",
+            message: `repo path_ref is not configured: ${pathRef}`,
+        };
+    }
+    if (typeof entry.path !== "string" || entry.path.trim().length === 0) {
+        return {
+            ok: false,
+            code: "repo-path-invalid",
+            message: `repo path_ref has invalid path: ${pathRef}`,
+        };
+    }
+    return {
+        ok: true,
+        repoRoot: path.resolve(entry.path),
+        defaultBranch: typeof entry.default_branch === "string" ? entry.default_branch : undefined,
+    };
+}