builder-assistant-engineer 0.2.0

package/dist/gates/protected-files.js

@@ -0,0 +1,311 @@
+import { parseLine, program } from "../tasks/shell-words.js";
+export const TASKS_DIR = "docs/plan/tasks";
+export const WATCHED_DIRS = [
+    ".bae",
+    ".claude/agents",
+    ".claude/commands",
+    ".claude/skills",
+    ".claude/hooks",
+    ".opencode",
+    ".gemini",
+    ".codex",
+    TASKS_DIR,
+];
+export const AGENT_FILES = [".claude/settings.json", "opencode.json", "opencode.jsonc"];
+export const BAE_SCRATCH = [".bae/tmp/"];
+export const GIT_FILES = ["config", "info/attributes"];
+const MEMORY_FILES = new Set([
+    "AGENTS.md",
+    "AGENTS.override.md",
+    "CLAUDE.md",
+    "CLAUDE.local.md",
+    "GEMINI.md",
+]);
+const TOOLCHAIN_NAMES = new Set([
+    ".npmrc",
+    ".yarnrc",
+    ".yarnrc.yml",
+    ".pnpmfile.cjs",
+    "bunfig.toml",
+    ".envrc",
+]);
+const TOOLCHAIN_DIRS = [".yarn/releases/", ".yarn/plugins/"];
+const RUNNER_FILES = [
+    /^vitest\.(config|workspace)\.[cm]?[jt]s$/,
+    /^vite\.config\.[cm]?[jt]s$/,
+    /^jest\.config\.([cm]?[jt]s|json)$/,
+    /^playwright\.config\.[cm]?[jt]s$/,
+    /^cypress\.config\.[cm]?[jt]s$/,
+    /^karma\.conf\.[cm]?[jt]s$/,
+    /^\.mocharc(\.(c?js|jsonc?|ya?ml))?$/,
+    /^pytest\.ini$/,
+    /^conftest\.py$/,
+    /^phpunit\.xml(\.dist)?$/,
+    /^\.rspec$/,
+    /^tsconfig(\.[\w-]+)?\.json$/,
+    /^jsconfig\.json$/,
+    /^eslint\.config\.[cm]?[jt]s$/,
+    /^\.eslintrc(\.(c?js|json|ya?ml))?$/,
+    /^\.eslintignore$/,
+    /^biome\.jsonc?$/,
+    /^\.?ruff\.toml$/,
+    /^\.flake8$/,
+    /^\.?mypy\.ini$/,
+    /^\.?pylintrc$/,
+    /^\.golangci\.(ya?ml|toml|json)$/,
+    /^\.?clippy\.toml$/,
+    /^\.stylelintrc(\.\w+)?$/,
+    /^phpstan\.neon(\.dist)?$/,
+    /^psalm\.xml$/,
+    /^\.rubocop\.yml$/,
+    /^turbo\.json$/,
+    /^nx\.json$/,
+    /^project\.json$/,
+    /^angular\.json$/,
+    /^deno\.jsonc?$/,
+    /^\.babelrc(\.\w+)?$/,
+    /^babel\.config\.\w+$/,
+    /^\.prettierrc(\.\w+)?$/,
+    /^prettier\.config\.\w+$/,
+    /^\.coveragerc$/,
+    /^\.nycrc(\.\w+)?$/,
+    /^\.c8rc(\.\w+)?$/,
+    /^jest\.setup\.[cm]?[jt]s$/,
+];
+const SECTIONS = {
+    "pyproject.toml": [
+        "tool.pytest",
+        "tool.ruff",
+        "tool.mypy",
+        "tool.coverage",
+        "tool.poe",
+        "tool.hatch.envs",
+        "tool.pdm.scripts",
+    ],
+    "setup.cfg": ["tool:pytest", "flake8", "mypy", "coverage"],
+    "tox.ini": ["pytest", "flake8", "testenv", "tox"],
+    "Cargo.toml": ["lints", "workspace.lints"],
+};
+const RUNNER_CONFIGS = /^(vitest|vite|jest|playwright|cypress)\.config\.([cm]?[jt]s|json)$|^\.mocharc|^package\.json$|^\.rspec$/;
+const SETUP_KEYS = /["']?\b(setupFiles|setupFilesAfterEach|setupFilesAfterEnv|globalSetup|globalTeardown|require|setupFilesAfterFramework)\b["']?\s*[:=]\s*(\[[^\]]*\]|["'][^"']+["'])|(--require)\s+()(\S+)/g;
+const INTERPRETERS = new Set([
+    "node",
+    "tsx",
+    "ts-node",
+    "python",
+    "python3",
+    "py",
+    "bash",
+    "sh",
+    "ruby",
+    "perl",
+    "php",
+    "deno",
+    "bun",
+]);
+const PYTHONS = new Set(["python", "python3", "py"]);
+const PACKAGE_MANAGERS = new Set(["npm", "pnpm", "yarn", "bun"]);
+const EXEC_WRAPPERS = new Set(["npx", "pnpx", "bunx"]);
+const VALUE_FLAGS = new Set([
+    "--prefix",
+    "-C",
+    "--dir",
+    "-w",
+    "--workspace",
+    "--filter",
+    "-F",
+    "--cwd",
+]);
+const MAKEFILES = ["GNUmakefile", "makefile", "Makefile"];
+const ACCEPTABLE = new Set([
+    "memory",
+    "gitignore",
+    "git",
+    "scripts",
+    "runner",
+    "toolchain",
+]);
+export function isAcceptableKind(kind) {
+    return ACCEPTABLE.has(kind);
+}
+export function kindOf(path, taskPath) {
+    if (path === taskPath)
+        return "task";
+    if (path.startsWith(`${TASKS_DIR}/`))
+        return "tasks";
+    if (path.startsWith(".bae/"))
+        return "bae";
+    if (path.startsWith(".git/"))
+        return "gitdir";
+    if ([".claude/", ".opencode/", ".gemini/", ".codex/"].some((dir) => path.startsWith(dir)) ||
+        AGENT_FILES.includes(path)) {
+        return "agents";
+    }
+    if (MEMORY_FILES.has(baseName(path)))
+        return "memory";
+    const name = baseName(path);
+    if (name === ".gitignore")
+        return "gitignore";
+    if (["turbo.json", "nx.json", "project.json", "angular.json", "deno.json", "deno.jsonc"].includes(name)) {
+        return "runner";
+    }
+    if (name === ".gitattributes")
+        return "git";
+    if (name === "package.json")
+        return "scripts";
+    if (isToolchain(path))
+        return "toolchain";
+    return "runner";
+}
+export function repoProtected(path) {
+    if (path.split("/").includes("node_modules"))
+        return false;
+    const name = baseName(path);
+    return (MEMORY_FILES.has(baseName(path)) ||
+        name === ".gitignore" ||
+        name === ".gitattributes" ||
+        name === "package.json" ||
+        isToolchain(path) ||
+        Object.hasOwn(SECTIONS, name) ||
+        RUNNER_FILES.some((pattern) => pattern.test(name)));
+}
+export function createdIsViolation(path) {
+    if (path.split("/").includes("node_modules"))
+        return false;
+    return (MEMORY_FILES.has(baseName(path)) || baseName(path) === ".gitattributes" || isToolchain(path));
+}
+export function sectionsOf(path) {
+    return SECTIONS[baseName(path)];
+}
+export function isRunnerConfig(path) {
+    return RUNNER_CONFIGS.test(baseName(path));
+}
+export function setupReferences(configPath, text) {
+    const dir = configPath.split("/").slice(0, -1).join("/");
+    const found = [];
+    for (const match of text.matchAll(SETUP_KEYS)) {
+        const values = match[2] ?? (match[5] ? `"${match[5]}"` : "");
+        for (const quoted of values.matchAll(/["']([^"']+)["']/g)) {
+            let raw = (quoted[1] ?? "").replace(/^<rootDir>\//, "").replace(/^\.\//, "");
+            if (configPath.endsWith(".rspec") && !raw.includes("."))
+                raw = `spec/${raw}.rb`;
+            if (!looksLikePath(raw))
+                continue;
+            found.push(dir ? `${dir}/${raw}` : raw);
+        }
+    }
+    return found;
+}
+export function executedBy(commands, scripts) {
+    const files = new Set();
+    const modules = new Set();
+    let make = false;
+    const seen = new Set();
+    const pending = [...commands];
+    const visit = (name, args) => {
+        const wrapped = execTarget(name, args);
+        if (wrapped) {
+            visit(wrapped[0] ?? "", wrapped.slice(1));
+            return;
+        }
+        for (const script of scriptsInvoked(name, args, scripts)) {
+            if (typeof scripts[script] === "string")
+                pending.push(scripts[script]);
+        }
+        if (name === "make") {
+            make = true;
+            for (const file of MAKEFILES)
+                files.add(file);
+            const flag = args.indexOf("-f");
+            if (flag !== -1 && args[flag + 1])
+                files.add(clean(args[flag + 1] ?? ""));
+        }
+        if (looksLikePath(name) || /^\.\/(gradlew|mvnw)$/.test(name))
+            files.add(clean(name));
+        if (!INTERPRETERS.has(baseName(name)))
+            return;
+        const moduleIndex = args.indexOf("-m");
+        if (PYTHONS.has(baseName(name)) && moduleIndex !== -1) {
+            const module = (args[moduleIndex + 1] ?? "").split(".")[0];
+            if (module)
+                modules.add(module);
+            return;
+        }
+        const target = args.filter((arg) => !arg.startsWith("-") && arg !== "run")[0];
+        if (target && looksLikePath(target))
+            files.add(clean(target));
+    };
+    while (pending.length > 0) {
+        const command = pending.shift() ?? "";
+        if (seen.has(command))
+            continue;
+        seen.add(command);
+        for (const simple of parseLine(command).commands) {
+            const { name, args } = program(simple);
+            visit(name, args);
+        }
+    }
+    return { files: [...files], modules: [...modules], make };
+}
+export function shadowCandidates(executed) {
+    return [
+        ...(executed.make ? MAKEFILES : []),
+        ...executed.modules.flatMap((module) => [`${module}.py`, `${module}/`]),
+    ];
+}
+export function looksLikePath(word) {
+    if (word.includes("..") || word.startsWith("/") || /^[a-z]+:/i.test(word))
+        return false;
+    if (/^(\.\/)?[\w@.-]+(\/[\w@.-]+)*\.(c?js|mjs|ts|mts|cts|tsx|jsx|py|sh|bash|rb|php|pl|ps1|cmd|bat)$/.test(word)) {
+        return true;
+    }
+    return /^(\.\/[\w@.-]+|[\w@.-]+(\/[\w@.-]+)+)$/.test(word);
+}
+export function baseName(path) {
+    return path.split("/").at(-1) ?? path;
+}
+function isToolchain(path) {
+    return TOOLCHAIN_NAMES.has(baseName(path)) || TOOLCHAIN_DIRS.some((dir) => path.startsWith(dir));
+}
+export function mainScript(name, args, scripts) {
+    return scriptsInvoked(name, args, scripts).find((script) => !/^(pre|post)/.test(script));
+}
+function scriptsInvoked(name, args, scripts) {
+    if (!PACKAGE_MANAGERS.has(name))
+        return [];
+    const rest = positional(args);
+    let script;
+    if (rest[0] === "run" || rest[0] === "run-script" || rest[0] === "run-s")
+        script = rest[1];
+    else if (rest[0] === "test" || rest[0] === "t" || rest[0] === "tst")
+        script = "test";
+    else if (name !== "npm" && rest[0] && typeof scripts[rest[0]] === "string")
+        script = rest[0];
+    return script ? [`pre${script}`, script, `post${script}`] : [];
+}
+export function execTarget(name, args) {
+    if (EXEC_WRAPPERS.has(name))
+        return positional(args, false);
+    if (!PACKAGE_MANAGERS.has(name))
+        return undefined;
+    const rest = positional(args, false);
+    return rest[0] === "exec" || rest[0] === "dlx" ? rest.slice(1) : undefined;
+}
+export function positional(args, dropValues = true) {
+    const rest = [];
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index] ?? "";
+        if (!arg.startsWith("-")) {
+            rest.push(...(dropValues ? [arg] : args.slice(index)));
+            if (!dropValues)
+                break;
+            continue;
+        }
+        if (VALUE_FLAGS.has(arg))
+            index++;
+    }
+    return rest;
+}
+function clean(path) {
+    return path.replace(/^\.\//, "");
+}

package/dist/gates/regression.js

@@ -0,0 +1,219 @@
+import { z } from "zod";
+import { bashPath, runScript } from "../core/bash.js";
+import { goText, probeFor, REPORT_SOURCES } from "./reports.js";
+import { cargoUnits, countsSchema, errorLines, parseFailing, parseSummary, runnerHint, } from "./results.js";
+import { expandCommand, readSources, testRunners } from "./runners.js";
+export const SUITE_KEYS = ["lint", "typecheck", "build", "test"];
+export const commandBaselineSchema = z.object({
+    exitCode: z.number(),
+    counts: countsSchema.optional(),
+    failing: z.array(z.string()).optional(),
+    source: z.string().optional(),
+    units: z.array(z.string()).optional(),
+    errors: z.array(z.string()).optional(),
+    absent: z.boolean().optional(),
+});
+export const suiteBaselineSchema = z.object({
+    skipped: z.boolean().default(false),
+    commands: z.record(z.string(), commandBaselineSchema).default({}),
+    excluded: z.array(z.string()).default([]),
+});
+const OUTPUT_TAIL = 3_000;
+const BLOCKING = new Set([
+    "regression",
+    "unfinished",
+    "noBaseline",
+    "uncomparable",
+    "mustPass",
+    "unknown",
+]);
+const VERDICTS = {
+    passed: "passed",
+    preexisting: "preexisting: it already failed before the task and the task did not make it worse",
+    regression: "regression: it passed before the task, or more checks fail than before",
+    unfinished: "regression: it did not finish (timeout or could not start)",
+    noBaseline: "regression: there is no passing baseline for it",
+    uncomparable: "blocks: it already failed before the task and its output has no counts to compare, so only green passes",
+    mustPass: "blocks: the task is tests: fix, so the test suite must end green",
+    unknown: "blocks: bae could not read how many tests ran, so it cannot tell whether they passed",
+};
+export function suiteCommands(config) {
+    if (config.gates.regression === "off")
+        return [];
+    return SUITE_KEYS.flatMap((key) => {
+        const command = config.commands[key];
+        return command ? [{ key, command }] : [];
+    });
+}
+export async function runSuite(cwd, suite, onOutput, timeoutMs) {
+    const results = [];
+    const bash = await bashPath();
+    const sources = await readSources(cwd);
+    for (const item of suite) {
+        onOutput?.(`$ ${item.command}\n`);
+        results.push(bash
+            ? await runOne(bash, { cwd, item, sources, timeoutMs }, onOutput)
+            : { ...item, exitCode: -1, output: "bash was not found" });
+    }
+    return results;
+}
+async function runOne(bash, run, onOutput) {
+    const { cwd, item, sources } = run;
+    const test = item.key === "test";
+    const hint = test
+        ? testRunners(item.command, sources)
+        : runnerHint(expandCommand(item.command, sources));
+    const probe = test && hint.length > 0 ? await probeFor(cwd, item.command, sources) : undefined;
+    try {
+        const view = probe?.view?.();
+        const shown = onOutput && view
+            ? (chunk) => {
+                const text = view.push(chunk);
+                if (text)
+                    onOutput(text);
+            }
+            : onOutput;
+        const result = await runScript(bash, `set -o pipefail\nexport CI=true\n${probe?.command ?? item.command}\n`, {
+            cwd,
+            ...(shown ? { onOutput: shown } : {}),
+            ...(probe ? { env: probe.env } : {}),
+            ...(run.timeoutMs ? { timeoutMs: run.timeoutMs } : {}),
+        });
+        const rest = view?.end();
+        if (rest)
+            onOutput?.(rest);
+        const output = view ? goText(result.output) : result.output;
+        const read = (await probe?.collect(result.stdout)) ?? textRead(output, hint, test);
+        const errors = !test && result.exitCode !== 0 ? errorLines(output) : [];
+        return {
+            ...item,
+            exitCode: result.exitCode,
+            output,
+            ...read,
+            ...(errors.length > 0 ? { errors } : {}),
+            ...(test && hint.length === 0 ? { unrecognized: true } : {}),
+        };
+    }
+    finally {
+        await probe?.dispose();
+    }
+}
+function textRead(output, hint, test) {
+    if (test && hint.length === 0)
+        return {};
+    const summary = parseSummary(output, hint);
+    const failing = parseFailing(output, hint);
+    const units = hint.includes("cargo") ? cargoUnits(output) : [];
+    return {
+        ...(summary ? { counts: summary.counts, source: summary.source } : {}),
+        ...(failing ? { failing } : {}),
+        ...(units.length > 0 ? { units } : {}),
+    };
+}
+export function baselineFrom(results, excluded = [], absent = []) {
+    return {
+        skipped: false,
+        excluded,
+        commands: Object.fromEntries(results.map((result) => [
+            result.command,
+            {
+                exitCode: result.exitCode,
+                ...(result.counts ? { counts: result.counts } : {}),
+                ...(result.failing ? { failing: result.failing } : {}),
+                ...(result.source ? { source: result.source } : {}),
+                ...(result.units ? { units: result.units } : {}),
+                ...(result.errors ? { errors: result.errors } : {}),
+                ...(absent.includes(result.command) ? { absent: true } : {}),
+            },
+        ])),
+    };
+}
+export function unusableBaseline(results, fix) {
+    return results.filter((result) => {
+        if (result.exitCode === -1 || (result.key === "test" && result.unrecognized))
+            return true;
+        if (result.counts)
+            return false;
+        if (result.key === "test")
+            return !(fix && result.exitCode !== 0);
+        return result.exitCode !== 0 && !result.errors;
+    });
+}
+export function verdictOf(result, before, fix) {
+    if (result.exitCode === -1)
+        return "unfinished";
+    const red = result.exitCode !== 0 || (result.counts?.failed ?? 0) > 0;
+    if (result.key === "test" && !red && unread(result, before))
+        return "unknown";
+    if (fix && result.key === "test")
+        return red ? "mustPass" : "passed";
+    if (!before)
+        return red ? "noBaseline" : "passed";
+    const wasRed = before.exitCode !== 0 || (before.counts?.failed ?? 0) > 0;
+    if (!wasRed)
+        return red ? "regression" : "passed";
+    if (!red)
+        return "passed";
+    if (before.failing && result.failing) {
+        const known = new Set(before.failing);
+        if (result.failing.some((name) => !known.has(name)))
+            return "regression";
+    }
+    if (before.units && result.units && before.units.some((unit) => !result.units?.includes(unit))) {
+        return "regression";
+    }
+    if (!before.counts && before.errors && result.errors && result.key !== "test") {
+        const known = new Set(before.errors);
+        return result.errors.some((line) => !known.has(line)) ? "regression" : "preexisting";
+    }
+    if (!before.counts || !result.counts || before.source !== result.source)
+        return "uncomparable";
+    const worse = result.counts.failed > before.counts.failed || result.counts.passed < before.counts.passed;
+    return worse ? "regression" : "preexisting";
+}
+export function checkRegressions(results, baseline, fix, allowUnread = false) {
+    const checks = results.map((result) => {
+        const before = baseline?.commands[result.command];
+        return { ...result, verdict: verdictOf(result, before, fix), ...(before ? { before } : {}) };
+    });
+    const unread = checks.filter((check) => check.verdict === "unknown");
+    const regressions = checks.filter((check) => BLOCKING.has(check.verdict) && !(allowUnread && check.verdict === "unknown"));
+    return {
+        passed: regressions.length === 0,
+        checks,
+        regressions,
+        preexisting: checks.filter((check) => check.verdict === "preexisting"),
+        unread,
+        report: ["## Regression check", ...checks.map(describe)].join("\n\n"),
+    };
+}
+function unread(result, before) {
+    if (!result.counts)
+        return true;
+    if (!before?.counts || before.source === result.source)
+        return false;
+    return !(isReport(before.source) && isReport(result.source));
+}
+function isReport(source) {
+    return REPORT_SOURCES.includes(source);
+}
+export function blocking(verdict) {
+    return BLOCKING.has(verdict);
+}
+function describe(check) {
+    const head = `$ ${check.command} (${check.key}, exit ${check.exitCode}${countsText(check)})`;
+    if (check.verdict === "passed")
+        return head;
+    const output = check.output.slice(-OUTPUT_TAIL).trim();
+    return `${head} ${VERDICTS[check.verdict]}\n\n\`\`\`text\n${output}\n\`\`\``;
+}
+function countsText(check) {
+    const now = check.counts ? formatCounts(check.counts) : "";
+    const then = check.before?.counts ? formatCounts(check.before.counts) : "";
+    if (!now)
+        return "";
+    return then ? `; ${now}, before: ${then}` : `; ${now}`;
+}
+export function formatCounts(counts) {
+    return `${counts.passed} passed, ${counts.failed} failed, ${counts.skipped} skipped`;
+}