builder-assistant-engineer 0.2.0

package/dist/config/schema.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { LANGS } from "../i18n/index.js";
+export const MODES = ["greenfield", "brownfield"];
+export const BACKENDS = ["claude", "opencode", "codex", "gemini", "api", "manual"];
+export const TARGETS = ["claude-code", "opencode", "codex", "gemini"];
+export const COMMAND_KEYS = ["test", "lint", "typecheck", "build"];
+export const REGRESSION_MODES = ["full", "task", "off"];
+export const DEFAULT_DIGEST_MAX_CHARS = 100_000;
+export const DEFAULT_AGENT_TIMEOUT_MINUTES = 45;
+export const DEFAULT_CHECK_TIMEOUT_MINUTES = 15;
+const command = z.string().trim().min(1).optional();
+export const commandsSchema = z.object({
+    test: command,
+    lint: command,
+    typecheck: command,
+    build: command,
+});
+export const configSchema = z.object({
+    version: z.literal(1),
+    mode: z.enum(MODES),
+    backend: z.enum(BACKENDS),
+    targets: z.array(z.enum(TARGETS)).min(1),
+    lang: z.enum(LANGS),
+    digest: z
+        .object({ maxChars: z.number().int().positive() })
+        .default({ maxChars: DEFAULT_DIGEST_MAX_CHARS }),
+    commands: commandsSchema.default({}),
+    gates: z
+        .object({
+        regression: z.enum(REGRESSION_MODES).default("full"),
+        timeoutMinutes: z.number().int().positive().default(DEFAULT_CHECK_TIMEOUT_MINUTES),
+    })
+        .default({ regression: "full", timeoutMinutes: DEFAULT_CHECK_TIMEOUT_MINUTES }),
+    verify: z.object({ allow: z.array(z.string().trim().min(1)).default([]) }).default({ allow: [] }),
+    secrets: z
+        .object({ allow: z.array(z.string().trim().min(1)).default([]) })
+        .default({ allow: [] }),
+    agent: z
+        .object({
+        timeoutMinutes: z.number().int().positive().default(DEFAULT_AGENT_TIMEOUT_MINUTES),
+    })
+        .default({ timeoutMinutes: DEFAULT_AGENT_TIMEOUT_MINUTES }),
+});

package/dist/config/settings.js

@@ -0,0 +1,8 @@
+export function resolveSettings(flags, config) {
+    return {
+        lang: flags.lang ?? config?.lang ?? "en",
+        backend: flags.backend ?? config?.backend,
+        dryRun: flags.dryRun ?? false,
+        yes: flags.yes ?? false,
+    };
+}

package/dist/config/store.js

@@ -0,0 +1,38 @@
+import { relative } from "node:path";
+import { z } from "zod";
+import { UserError } from "../core/errors.js";
+import { readTextIfExists, writeText } from "../core/fs.js";
+import { baePaths } from "../core/paths.js";
+import { t } from "../i18n/index.js";
+import { configSchema } from "./schema.js";
+export async function readConfig(cwd) {
+    const path = baePaths(cwd).config;
+    const text = await readTextIfExists(path);
+    if (text === undefined)
+        return undefined;
+    return parseConfig(text, relative(cwd, path));
+}
+export function parseConfig(text, displayPath) {
+    const result = configSchema.safeParse(parseJson(text, displayPath));
+    if (result.success)
+        return result.data;
+    throw new UserError(t("error.configInvalid", { path: displayPath, details: z.prettifyError(result.error) }));
+}
+export async function writeConfig(cwd, config) {
+    await writeText(baePaths(cwd).config, `${JSON.stringify(config, null, 2)}\n`);
+}
+export function readInterview(cwd) {
+    return readTextIfExists(baePaths(cwd).interview);
+}
+export async function writeInterview(cwd, text) {
+    await writeText(baePaths(cwd).interview, text.endsWith("\n") ? text : `${text}\n`);
+}
+function parseJson(text, displayPath) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        const details = error instanceof Error ? error.message : String(error);
+        throw new UserError(t("error.configJson", { path: displayPath, details }));
+    }
+}

package/dist/core/bash.js

@@ -0,0 +1,105 @@
+import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execa } from "execa";
+import { findExecutable } from "./which.js";
+const SCRIPT_TIMEOUT_MS = 15 * 60_000;
+const WSL_BASH = /[\\/](system32|sysnative|windowsapps)[\\/]/i;
+let cached;
+export function bashPath() {
+    cached ??= findBash();
+    return cached;
+}
+export async function findBash(env = process.env, platform = process.platform) {
+    if (platform !== "win32")
+        return findExecutable("bash", env, platform);
+    const roots = [env.ProgramFiles, env["ProgramFiles(x86)"], env.ProgramW6432].filter(Boolean);
+    const candidates = [
+        ...roots.map((root) => join(root ?? "", "Git", "bin", "bash.exe")),
+        ...(env.LOCALAPPDATA ? [join(env.LOCALAPPDATA, "Programs", "Git", "bin", "bash.exe")] : []),
+    ];
+    for (const candidate of candidates) {
+        if (await isFile(candidate))
+            return candidate;
+    }
+    const found = await findExecutable("bash", env, platform);
+    return found && !WSL_BASH.test(found) ? found : undefined;
+}
+export async function runScript(bash, script, options) {
+    const dir = await mkdtemp(join(tmpdir(), "bae-script-"));
+    const file = join(dir, "script.sh");
+    await writeFile(file, script, "utf8");
+    const group = process.platform !== "win32";
+    const limit = options.timeoutMs ?? SCRIPT_TIMEOUT_MS;
+    try {
+        const subprocess = execa(bash, ["--noprofile", "--norc", file], {
+            cwd: options.cwd,
+            all: true,
+            reject: false,
+            detached: group,
+            ...(group ? {} : { timeout: limit }),
+            env: { ...options.env, PWD: options.cwd },
+        });
+        const { onOutput } = options;
+        if (onOutput)
+            subprocess.all?.on("data", (chunk) => onOutput(chunk.toString()));
+        let timedOut = false;
+        const stop = (signal) => {
+            if (group && subprocess.pid)
+                killGroup(subprocess.pid, signal);
+        };
+        const timer = group
+            ? setTimeout(() => {
+                timedOut = true;
+                stop("SIGTERM");
+                setTimeout(() => stop("SIGKILL"), 3_000).unref();
+            }, limit)
+            : undefined;
+        subprocess.on("exit", () => stop("SIGKILL"));
+        const forward = (signal) => {
+            stop(signal);
+            release();
+            process.kill(process.pid, signal);
+        };
+        const release = () => {
+            process.off("SIGINT", forward);
+            process.off("SIGTERM", forward);
+        };
+        if (group) {
+            process.once("SIGINT", forward);
+            process.once("SIGTERM", forward);
+        }
+        const result = await subprocess.finally(release);
+        if (timer)
+            clearTimeout(timer);
+        if (timedOut) {
+            return {
+                exitCode: -1,
+                output: result.all ?? "",
+                stdout: typeof result.stdout === "string" ? result.stdout : "",
+            };
+        }
+        return {
+            exitCode: result.exitCode ?? -1,
+            output: result.all ?? result.message ?? "",
+            stdout: typeof result.stdout === "string" ? result.stdout : "",
+        };
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+function killGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch { }
+}
+async function isFile(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/errors.js

@@ -0,0 +1,14 @@
+export class UserError extends Error {
+    name = "UserError";
+}
+export class FormatError extends Error {
+    name = "FormatError";
+}
+export class ExitCode extends Error {
+    code;
+    name = "ExitCode";
+    constructor(code) {
+        super(`exit ${code}`);
+        this.code = code;
+    }
+}

package/dist/core/fs.js

@@ -0,0 +1,35 @@
+import { lstat, mkdir, open, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export async function readTextIfExists(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return undefined;
+        throw error;
+    }
+}
+export async function writeText(path, text) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, text, "utf8");
+}
+function isNotFound(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+export async function isSymlink(path) {
+    return (await lstat(path).catch(() => undefined))?.isSymbolicLink() ?? false;
+}
+export async function looksBinary(path) {
+    const handle = await open(path, "r").catch(() => undefined);
+    if (!handle)
+        return false;
+    try {
+        const buffer = Buffer.alloc(8192);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        return buffer.subarray(0, bytesRead).includes(0);
+    }
+    finally {
+        await handle.close();
+    }
+}

package/dist/core/git.js

@@ -0,0 +1,104 @@
+import { runCommand } from "./process.js";
+const GIT_TIMEOUT_MS = 30_000;
+export const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+const HARDENED = [
+    "--no-replace-objects",
+    "-c",
+    "core.quotePath=false",
+    "-c",
+    "core.fsmonitor=false",
+    "-c",
+    "core.untrackedCache=false",
+    "-c",
+    "diff.noprefix=false",
+    "-c",
+    "diff.mnemonicPrefix=false",
+    "-c",
+    "diff.relative=false",
+    "-c",
+    "diff.external=",
+    "-c",
+    "color.ui=never",
+];
+export const DIFF_FLAGS = [
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--text",
+    "--no-renames",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+];
+export async function git(cwd, args) {
+    const result = await runCommand("git", [...HARDENED, ...args], {
+        cwd,
+        timeoutMs: GIT_TIMEOUT_MS,
+    });
+    return result.exitCode === 0 ? result.stdout : undefined;
+}
+export async function gitPaths(cwd, args) {
+    const out = await git(cwd, [...args.slice(0, 1), "-z", ...args.slice(1)]);
+    return out === undefined ? undefined : out.split("\0").filter((path) => path !== "");
+}
+export async function flaggedFiles(cwd) {
+    const entries = await gitPaths(cwd, ["ls-files", "-v"]);
+    return entries
+        ?.filter((entry) => /^[a-zS] /.test(entry))
+        .map((entry) => entry.slice(2))
+        .sort();
+}
+export function unquotePath(raw) {
+    if (!raw.startsWith('"') || !raw.endsWith('"'))
+        return raw;
+    const bytes = [];
+    const body = raw.slice(1, -1);
+    const escapes = {
+        n: 10,
+        t: 9,
+        r: 13,
+        '"': 34,
+        "\\": 92,
+        a: 7,
+        b: 8,
+        f: 12,
+        v: 11,
+    };
+    for (let index = 0; index < body.length; index++) {
+        const char = body[index] ?? "";
+        if (char !== "\\") {
+            bytes.push(...Buffer.from(char, "utf8"));
+            continue;
+        }
+        const next = body[index + 1] ?? "";
+        if (/[0-7]/.test(next)) {
+            bytes.push(Number.parseInt(body.slice(index + 1, index + 4), 8));
+            index += 3;
+            continue;
+        }
+        bytes.push(escapes[next] ?? next.charCodeAt(0));
+        index += 1;
+    }
+    return Buffer.from(bytes).toString("utf8");
+}
+export async function isGitRepo(cwd) {
+    return (await git(cwd, ["rev-parse", "--is-inside-work-tree"]))?.trim() === "true";
+}
+export async function headCommit(cwd) {
+    return (await git(cwd, ["rev-parse", "--verify", "HEAD"]))?.trim() || undefined;
+}
+export async function verifyCommit(cwd, ref) {
+    return ((await git(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]))?.trim() || undefined);
+}
+export async function resolveBase(cwd, base) {
+    const verified = base && (await verifyCommit(cwd, base));
+    return verified || (await headCommit(cwd)) || EMPTY_TREE;
+}
+export function lines(text) {
+    return (text ?? "").split(/\r?\n/).filter((line) => line.trim() !== "");
+}
+export function literal(path) {
+    return `:(literal)${path}`;
+}
+export function excluded(path) {
+    return `:(exclude,literal)${path}`;
+}

package/dist/core/gitignore.js

@@ -0,0 +1,14 @@
+import { join } from "node:path";
+import { readTextIfExists, writeText } from "./fs.js";
+export const BAE_IGNORED = [".bae/tmp/"];
+export async function ensureGitignore(cwd) {
+    const path = join(cwd, ".gitignore");
+    const current = (await readTextIfExists(path)) ?? "";
+    const present = new Set(current.split(/\r?\n/).map((line) => line.trim()));
+    const missing = BAE_IGNORED.filter((entry) => !present.has(entry));
+    if (missing.length === 0)
+        return [];
+    const separator = current && !current.endsWith("\n") ? "\n" : "";
+    await writeText(path, `${current}${separator}${missing.join("\n")}\n`);
+    return missing;
+}

package/dist/core/json.js

@@ -0,0 +1,13 @@
+export function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function parseObject(text) {
+    try {
+        return asRecord(JSON.parse(text));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/core/paths.js

@@ -0,0 +1,14 @@
+import { join } from "node:path";
+export const BAE_DIR = ".bae";
+export function baePaths(cwd) {
+    const dir = join(cwd, BAE_DIR);
+    return {
+        dir,
+        config: join(dir, "config.json"),
+        interview: join(dir, "interview.md"),
+        prompts: join(dir, "prompts"),
+        runs: join(dir, "runs"),
+        tmp: join(dir, "tmp"),
+        ignore: join(cwd, ".baeignore"),
+    };
+}

package/dist/core/process.js

@@ -0,0 +1,56 @@
+import { execa } from "execa";
+import { findExecutable } from "./which.js";
+const SHELL_TIMEOUT_MS = 15 * 60_000;
+export async function runCommand(file, args, options) {
+    if (!(await findExecutable(file)))
+        return missing(file);
+    const subprocess = execa(file, args, {
+        cwd: options.cwd,
+        input: options.input,
+        timeout: options.timeoutMs,
+        reject: false,
+        env: { PWD: options.cwd },
+    });
+    const { onStdout } = options;
+    if (onStdout)
+        subprocess.stdout?.on("data", (chunk) => onStdout(chunk.toString()));
+    const result = await subprocess;
+    const notFound = "code" in result && result.code === "ENOENT";
+    return {
+        exitCode: result.exitCode ?? -1,
+        stdout: result.stdout ?? "",
+        stderr: result.exitCode === undefined ? (result.message ?? "") : (result.stderr ?? ""),
+        notFound,
+        ...(result.timedOut ? { timedOut: true } : {}),
+    };
+}
+export async function runInteractive(file, args, options) {
+    if (!(await findExecutable(file)))
+        return missing(file);
+    const result = await execa(file, args, {
+        cwd: options.cwd,
+        stdio: "inherit",
+        reject: false,
+        env: { PWD: options.cwd },
+    });
+    const notFound = "code" in result && result.code === "ENOENT";
+    return { exitCode: result.exitCode ?? -1, stdout: "", stderr: result.message ?? "", notFound };
+}
+function missing(file) {
+    return { exitCode: -1, stdout: "", stderr: `${file}: command not found`, notFound: true };
+}
+export async function runShell(command, options) {
+    const subprocess = execa(command, {
+        cwd: options.cwd,
+        shell: true,
+        all: true,
+        reject: false,
+        timeout: options.timeoutMs ?? SHELL_TIMEOUT_MS,
+        env: { PWD: options.cwd },
+    });
+    const { onOutput } = options;
+    if (onOutput)
+        subprocess.all?.on("data", (chunk) => onOutput(chunk.toString()));
+    const result = await subprocess;
+    return { exitCode: result.exitCode ?? -1, output: result.all ?? result.message ?? "" };
+}

package/dist/core/prompt-loader.js

@@ -0,0 +1,27 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { t } from "../i18n/index.js";
+import { UserError } from "./errors.js";
+import { readTextIfExists } from "./fs.js";
+import { baePaths } from "./paths.js";
+const BUILTIN_DIR = fileURLToPath(new URL("../prompts/", import.meta.url));
+const VARIABLE = /\{\{(\w+)\}\}/g;
+export async function loadPrompt(name, cwd) {
+    const overridePath = join(baePaths(cwd).prompts, `${name}.md`);
+    const override = await readTextIfExists(overridePath);
+    if (override !== undefined)
+        return { path: overridePath, text: override };
+    const path = join(BUILTIN_DIR, `${name}.md`);
+    return { path, text: await readFile(path, "utf8") };
+}
+export function renderPrompt(prompt, vars) {
+    const missing = findVariables(prompt.text).filter((name) => !Object.hasOwn(vars, name));
+    if (missing.length > 0) {
+        throw new UserError(t("error.promptMissingVars", { path: prompt.path, vars: missing.join(", ") }));
+    }
+    return prompt.text.replace(VARIABLE, (_, name) => vars[name] ?? "");
+}
+export function findVariables(text) {
+    return [...new Set(Array.from(text.matchAll(VARIABLE), (match) => match[1] ?? ""))];
+}

package/dist/core/state.js

@@ -0,0 +1,27 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const KEY_LENGTH = 16;
+export function stateHome() {
+    return process.env.BAE_HOME || join(homedir(), ".bae");
+}
+export function repoState(cwd) {
+    return join(stateHome(), repoKey(cwd));
+}
+export function repoKey(cwd) {
+    return createHash("sha256").update(realPath(cwd)).digest("hex").slice(0, KEY_LENGTH);
+}
+export function displayPath(path) {
+    const home = homedir();
+    const shown = path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+    return shown.split("\\").join("/");
+}
+function realPath(cwd) {
+    try {
+        return realpathSync.native(cwd);
+    }
+    catch {
+        return cwd;
+    }
+}

package/dist/core/which.js

@@ -0,0 +1,24 @@
+import { stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join } from "node:path";
+export async function findExecutable(name, env = process.env, platform = process.platform) {
+    if (isAbsolute(name) || /[\\/]/.test(name))
+        return (await isFile(name)) ? name : undefined;
+    const dirs = (env.PATH ?? env.Path ?? "").split(delimiter).filter(Boolean);
+    const extensions = platform === "win32" ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")] : [""];
+    for (const dir of dirs) {
+        for (const extension of extensions) {
+            const candidate = join(dir, `${name}${extension}`);
+            if (await isFile(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+async function isFile(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/detect/agents.js

@@ -0,0 +1,17 @@
+import { hasApiCredentials } from "../backends/api.js";
+import { findExecutable } from "../core/which.js";
+export { findExecutable };
+export const AGENT_BACKENDS = ["claude", "opencode", "codex", "gemini"];
+export async function detectInstalledAgents(env = process.env, platform = process.platform) {
+    const found = await Promise.all(AGENT_BACKENDS.map(async (name) => (await findExecutable(name, env, platform)) ? name : undefined));
+    return found.filter((name) => name !== undefined);
+}
+export async function suggestBackend(env = process.env, platform = process.platform) {
+    return pickDefaultBackend(await detectInstalledAgents(env, platform), env);
+}
+export function pickDefaultBackend(installed, env) {
+    const [first] = installed;
+    if (first)
+        return first;
+    return hasApiCredentials(env) ? "api" : "manual";
+}

package/dist/detect/mode.js

@@ -0,0 +1,11 @@
+import { languageOf } from "../digest/files.js";
+import { ecosystemOf } from "../digest/manifests.js";
+import { scanFiles } from "../digest/walk.js";
+export function detectMode(paths) {
+    const hasCode = paths.some((path) => ecosystemOf(path) !== undefined || languageOf(path) !== undefined);
+    return hasCode ? "brownfield" : "greenfield";
+}
+export async function detectProjectMode(root) {
+    const { files } = await scanFiles(root);
+    return detectMode(files.map((file) => file.path));
+}