builder-assistant-engineer 0.2.0

package/dist/commands/init.js

@@ -0,0 +1,199 @@
+import { hasApiCredentials } from "../backends/api.js";
+import { DEFAULT_AGENT_TIMEOUT_MINUTES, DEFAULT_CHECK_TIMEOUT_MINUTES, DEFAULT_DIGEST_MAX_CHARS, MODES, TARGETS, } from "../config/schema.js";
+import { readConfig, readInterview, writeConfig, writeInterview } from "../config/store.js";
+import { UserError } from "../core/errors.js";
+import { ensureGitignore } from "../core/gitignore.js";
+import { AGENT_BACKENDS, detectInstalledAgents, pickDefaultBackend } from "../detect/agents.js";
+import { detectProjectMode } from "../detect/mode.js";
+import { buildDigest } from "../digest/index.js";
+import { getLang, setLang, t } from "../i18n/index.js";
+import { interviewPrompt, runAdaptiveRound } from "../interview/adaptive.js";
+import { loadBrief } from "../interview/brief.js";
+import { BASE_QUESTIONS, OBJECTIVE_LABELS, OBJECTIVES } from "../interview/questions.js";
+import { renderInterview } from "../interview/render.js";
+export const NEXT_COMMAND = "npx builder-assistant-engineer plan";
+const BACKEND_LABELS = {
+    claude: "Claude Code",
+    opencode: "opencode",
+    codex: "Codex CLI",
+    gemini: "Gemini CLI",
+};
+const TARGET_LABELS = {
+    "claude-code": "Claude Code",
+    opencode: "opencode",
+    codex: "Codex CLI",
+    gemini: "Gemini CLI",
+};
+const TARGET_FOR = {
+    claude: "claude-code",
+    opencode: "opencode",
+    codex: "codex",
+    gemini: "gemini",
+};
+export async function runInit(ctx, options) {
+    const existing = await readConfig(ctx.cwd);
+    ctx.prompter.intro(t("init.intro"));
+    const lang = await chooseLang(ctx, existing);
+    setLang(lang);
+    const mode = await chooseMode(ctx, await detectProjectMode(ctx.cwd));
+    const installed = await detectInstalledAgents(ctx.env);
+    const config = {
+        version: 1,
+        mode,
+        backend: await chooseBackend(ctx, installed, existing),
+        targets: await chooseTargets(ctx, installed, existing),
+        lang,
+        digest: existing?.digest ?? { maxChars: DEFAULT_DIGEST_MAX_CHARS },
+        commands: existing?.commands ?? {},
+        gates: existing?.gates ?? { regression: "full", timeoutMinutes: DEFAULT_CHECK_TIMEOUT_MINUTES },
+        verify: existing?.verify ?? { allow: [] },
+        secrets: existing?.secrets ?? { allow: [] },
+        agent: existing?.agent ?? { timeoutMinutes: DEFAULT_AGENT_TIMEOUT_MINUTES },
+    };
+    const interview = await interviewFor(ctx, config, options);
+    if (interview === undefined)
+        return;
+    await writeConfig(ctx.cwd, config);
+    await writeInterview(ctx.cwd, interview);
+    await ensureGitignore(ctx.cwd);
+    ctx.prompter.outro(t("init.done", { command: NEXT_COMMAND }));
+}
+async function chooseLang(ctx, existing) {
+    if (ctx.flags.lang)
+        return ctx.flags.lang;
+    const initial = existing?.lang ?? getLang();
+    if (ctx.flags.yes)
+        return initial;
+    const choices = [
+        { value: "en", label: "English" },
+        { value: "es", label: "Español" },
+    ];
+    return ctx.prompter.select(t("init.lang"), choices, initial);
+}
+async function chooseMode(ctx, detected) {
+    if (ctx.flags.yes)
+        return detected;
+    const choices = MODES.map((mode) => ({
+        value: mode,
+        label: t(`mode.${mode}`),
+        hint: mode === detected ? t("init.detected") : undefined,
+    }));
+    return ctx.prompter.select(t("init.mode"), choices, detected);
+}
+async function chooseBackend(ctx, installed, existing) {
+    if (ctx.flags.backend)
+        return ctx.flags.backend;
+    const initial = existing?.backend ?? pickDefaultBackend(installed, ctx.env);
+    if (ctx.flags.yes)
+        return initial;
+    const backend = await ctx.prompter.select(t("init.backend"), backendChoices(ctx, installed), initial);
+    if (isMissingAgent(backend, installed)) {
+        ctx.prompter.warn(t("init.backendMissing", { command: backend }));
+    }
+    return backend;
+}
+function backendChoices(ctx, installed) {
+    const agents = [...installed, ...AGENT_BACKENDS.filter((name) => !installed.includes(name))];
+    return [
+        ...agents.map((name) => ({
+            value: name,
+            label: BACKEND_LABELS[name],
+            hint: t(installed.includes(name) ? "backend.hint.installed" : "backend.hint.missing"),
+        })),
+        {
+            value: "api",
+            label: "API",
+            hint: t(hasApiCredentials(ctx.env) ? "backend.hint.apiReady" : "backend.hint.api"),
+        },
+        { value: "manual", label: t("backend.label.manual"), hint: t("backend.hint.manual") },
+    ];
+}
+function isMissingAgent(backend, installed) {
+    return AGENT_BACKENDS.some((name) => name === backend && !installed.includes(name));
+}
+async function chooseTargets(ctx, installed, existing) {
+    const detected = installed.map((name) => TARGET_FOR[name]);
+    const initial = existing?.targets ?? (detected.length > 0 ? detected : ["claude-code"]);
+    if (ctx.flags.yes)
+        return initial;
+    const choices = TARGETS.map((target) => ({ value: target, label: TARGET_LABELS[target] }));
+    return ctx.prompter.multiselect(t("init.targets"), choices, initial);
+}
+async function interviewFor(ctx, config, options) {
+    const current = await readInterview(ctx.cwd);
+    if (current && options.brief === undefined && !(await wantsRedo(ctx))) {
+        return ctx.flags.dryRun ? finishDryRun(ctx) : current;
+    }
+    const data = await collectInterview(ctx, config.mode, options.brief);
+    const adaptive = !ctx.flags.yes && config.backend !== "manual";
+    if (!adaptive && config.backend === "manual" && !ctx.flags.yes) {
+        ctx.prompter.info(t("interview.adaptiveManual"));
+    }
+    if (!adaptive)
+        return ctx.flags.dryRun ? finishDryRun(ctx) : renderInterview(data);
+    const digest = await ctx.prompter.spinner(t("digest.reading"), async () => {
+        return (await buildDigest(ctx.cwd, { maxChars: config.digest.maxChars })).text;
+    });
+    const base = {
+        cwd: ctx.cwd,
+        projectType: config.mode,
+        lang: config.lang,
+        targets: config.targets,
+        digest,
+        canExplore: AGENT_BACKENDS.some((name) => name === config.backend),
+    };
+    if (ctx.flags.dryRun) {
+        ctx.print(`${await interviewPrompt(base, data)}\n`);
+        ctx.prompter.outro(t("init.dryRunDone"));
+        return undefined;
+    }
+    const backend = ctx.createBackend(config.backend);
+    const result = await runAdaptiveRound({ ...base, backend, prompter: ctx.prompter }, data);
+    return renderInterview(result);
+}
+async function wantsRedo(ctx) {
+    if (ctx.flags.yes)
+        return false;
+    return ctx.prompter.confirm(t("init.redoInterview"), false);
+}
+function finishDryRun(ctx) {
+    ctx.prompter.info(t("init.dryRunNoAi"));
+    ctx.prompter.outro(t("init.dryRunDone"));
+    return undefined;
+}
+async function collectInterview(ctx, mode, briefOption) {
+    const interactive = !ctx.flags.yes;
+    if (interactive)
+        ctx.prompter.info(t("interview.intro"));
+    const brief = await collectBrief(ctx, briefOption);
+    const objective = interactive && mode === "brownfield" ? await askObjective(ctx) : undefined;
+    const answers = [];
+    if (interactive) {
+        for (const key of BASE_QUESTIONS) {
+            answers.push({ question: t(key), answer: await ctx.prompter.text(t(key)) });
+        }
+    }
+    return { mode, objective, brief: brief.text, answers, followUps: [] };
+}
+async function collectBrief(ctx, option) {
+    if (option !== undefined) {
+        const brief = await loadBrief(ctx.cwd, option);
+        if (brief.files.length === 0)
+            throw new UserError(t("init.briefMissing", { path: option }));
+        return brief;
+    }
+    if (ctx.flags.yes)
+        return { text: "", files: [] };
+    const raw = await ctx.prompter.text(t("interview.brief"), t("interview.briefPlaceholder"));
+    const brief = await loadBrief(ctx.cwd, raw);
+    if (brief.files.length > 0) {
+        const paths = brief.files.join(", ");
+        ctx.prompter.success(t("interview.briefLoaded", { count: brief.files.length, paths }));
+    }
+    return brief;
+}
+async function askObjective(ctx) {
+    const choices = OBJECTIVES.map((value) => ({ value, label: t(OBJECTIVE_LABELS[value]) }));
+    const objective = await ctx.prompter.select(t("interview.objective"), choices, "feature");
+    return objective === "skip" ? undefined : t(OBJECTIVE_LABELS[objective]);
+}

package/dist/commands/next.js

@@ -0,0 +1,103 @@
+import { ExitCode } from "../core/errors.js";
+import { loadPrompt, renderPrompt } from "../core/prompt-loader.js";
+import { newAcceptance } from "../gates/findings.js";
+import { suiteCommands } from "../gates/regression.js";
+import { t } from "../i18n/index.js";
+import { attemptOnce, headlessLoop } from "../next/attempts.js";
+import { checksFor, recoverInterrupted, start, withSuiteCommands } from "../next/start.js";
+import { capturedTask } from "../review/run.js";
+import { MAX_ATTEMPTS, readAttempts, sinceBlocked } from "../tasks/attempts.js";
+import { MAX_LOG_LINES, planContext } from "../tasks/handoff.js";
+import { completionTimes, readMetrics } from "../tasks/metrics.js";
+import { pickNext, waitingOn } from "../tasks/select.js";
+import { CLI, isAgentBackend, loadValidTasks, requireConfig } from "./shared.js";
+export async function runNext(ctx, options) {
+    const acceptance = newAcceptance(options.acceptFinding);
+    await recoverInterrupted(ctx, acceptance);
+    const stored = await requireConfig(ctx);
+    ctx.prompter.intro(t("next.intro"));
+    const tasks = await loadValidTasks(ctx);
+    const task = pickNext(tasks, await exhaustedTasks(ctx, tasks));
+    if (!task) {
+        reportNoTask(ctx, tasks);
+        return;
+    }
+    const config = task.meta.status === "pending" ? await withSuiteCommands(ctx, stored) : stored;
+    ctx.prompter.note(describeTask(task, checksFor(task, config)), `${task.meta.id} · ${task.meta.title}`);
+    if (ctx.flags.dryRun) {
+        ctx.print(`${task.text}\n`);
+        ctx.prompter.outro(t("next.dryRunDone"));
+        return;
+    }
+    const allowSkip = Boolean(options.allowSkip);
+    const headless = Boolean(options.headless) && isAgentBackend(config.backend);
+    const unattended = headless || Boolean(ctx.flags.yes);
+    const capture = await start(ctx, config, task, { allowSkip, unattended });
+    if (!capture)
+        throw new ExitCode(1);
+    const run = {
+        capture,
+        checks: checksFor(capturedTask(capture), capture.config),
+        approval: { granted: false },
+        acceptance,
+        allowSkip,
+        unattended,
+        tampered: [],
+    };
+    const prompt = await taskPrompt(ctx, capture, tasks);
+    if (options.headless && !headless)
+        ctx.prompter.warn(t("next.headlessNeedsAgent"));
+    const done = headless
+        ? await headlessLoop(ctx, run, prompt)
+        : await attemptOnce(ctx, run, prompt);
+    if (!done)
+        throw new ExitCode(1);
+}
+async function exhaustedTasks(ctx, tasks) {
+    const inProgress = tasks.filter((task) => task.meta.status === "in_progress");
+    const used = await Promise.all(inProgress.map(async (task) => [task.meta.id, sinceBlocked(await readAttempts(ctx.cwd, task.meta.id)).length]));
+    return new Set(used.filter(([, count]) => count >= MAX_ATTEMPTS).map(([id]) => id));
+}
+async function taskPrompt(ctx, capture, tasks) {
+    const task = capturedTask(capture);
+    const others = tasks.map((item) => (item.meta.id === task.meta.id ? task : item));
+    const metrics = await readMetrics(ctx.cwd, others.filter((item) => item.meta.status === "done").map((item) => item.meta.id));
+    return renderPrompt(await loadPrompt("task", ctx.cwd), {
+        context: planContext(capture.config, others, task, completionTimes(metrics)),
+        task: task.text.trim(),
+        task_path: task.path,
+        max_log_lines: String(MAX_LOG_LINES),
+        suite: suiteCommands(capture.config).length > 0
+            ? ", then the project's lint and test commands, which must not turn red"
+            : "",
+    });
+}
+function describeTask(task, checks) {
+    const { phase, size, risk, depends_on } = task.meta;
+    const deps = depends_on.length > 0 ? depends_on.join(", ") : "-";
+    const verify = checks.commands.map((command) => `  $ ${command}`).join("\n");
+    const lines = [t("next.meta", { phase, size, risk, deps }), `${t("verify.commands")}:`, verify];
+    if (checks.suite.length > 0) {
+        lines.push(`${t("regression.title")}:`, ...checks.suite.map((item) => `  $ ${item.command}`));
+    }
+    return lines.join("\n");
+}
+function reportNoTask(ctx, tasks) {
+    if (tasks.length === 0) {
+        ctx.prompter.outro(t("next.noPlan", { command: `${CLI} plan` }));
+        return;
+    }
+    if (tasks.every((task) => task.meta.status === "done")) {
+        ctx.prompter.outro(t("next.allDone"));
+        return;
+    }
+    const stuck = tasks
+        .filter((task) => task.meta.status !== "done")
+        .map((task) => {
+        const waiting = waitingOn(task, tasks);
+        const reason = task.meta.status === "blocked" ? "blocked" : `waiting on ${waiting.join(", ")}`;
+        return `${task.meta.id} ${task.meta.title} (${reason})`;
+    });
+    ctx.prompter.note(stuck.join("\n"), t("next.nothingReady"));
+    ctx.prompter.outro(t("next.unblock"));
+}

package/dist/commands/plan.js

@@ -0,0 +1,71 @@
+import { planChanges } from "../artifacts/merge.js";
+import { applyChanges, confirmChanges } from "../artifacts/write.js";
+import { ensureGitignore } from "../core/gitignore.js";
+import { t } from "../i18n/index.js";
+import { selectFiles } from "../plan/filter.js";
+import { closeQuestions } from "../plan/questions.js";
+import { generatePlan } from "../plan/run.js";
+import { loadTaskFiles } from "../tasks/load.js";
+import { CLI, requireConfig, saveCommands } from "./shared.js";
+export async function runPlan(ctx, options) {
+    const config = await requireConfig(ctx);
+    let confirmed = false;
+    while (await planOnce(ctx, config, options, confirmed))
+        confirmed = true;
+}
+async function planOnce(ctx, config, options, confirmed) {
+    ctx.prompter.intro(t("plan.intro"));
+    const existing = await loadTaskFiles(ctx.cwd);
+    if (existing.length > 0 && !confirmed && !ctx.flags.dryRun && !(await regenerate(ctx))) {
+        ctx.prompter.outro(t("plan.useReplan"));
+        return false;
+    }
+    const knownTaskIds = existing.map((task) => task.id);
+    const parsed = await generatePlan(ctx, config, { priorPlan: "", knownTaskIds });
+    if (!parsed) {
+        ctx.prompter.outro(t("plan.dryRunDone"));
+        return false;
+    }
+    const files = selectFiles(parsed.files, { only: options.only, targets: config.targets });
+    const replaced = options.only === undefined || options.only === "plan";
+    const obsolete = replaced ? obsoleteTasks(existing, parsed) : [];
+    const changes = [...(await planChanges(ctx.cwd, files)), ...obsolete];
+    const written = await writePlanFiles(ctx, changes);
+    await saveCommands(ctx, parsed.commands);
+    return reportPlan(ctx, parsed, written);
+}
+export function obsoleteTasks(tasks, parsed) {
+    const kept = new Set(parsed.tasks.map((task) => task.meta.id));
+    return tasks
+        .filter((task) => task.task?.meta.status === "pending" && !kept.has(task.id))
+        .map((task) => ({ path: task.path, before: task.text, after: "", kind: "delete" }));
+}
+export async function writePlanFiles(ctx, changes) {
+    const accepted = await confirmChanges(ctx, changes);
+    await applyChanges(ctx.cwd, accepted);
+    if (accepted.length > 0)
+        await ensureGitignore(ctx.cwd);
+    return accepted;
+}
+export async function reportPlan(ctx, parsed, written) {
+    ctx.prompter.note(parsed.summary, t("plan.summary"));
+    for (const warning of parsed.warnings)
+        ctx.prompter.warn(warning);
+    const closed = await closeQuestions(ctx, parsed.questions);
+    const answered = closed.some((question) => question.blocking && question.answer !== "");
+    if (answered && (await ctx.prompter.confirm(t("plan.rerun"), true))) {
+        ctx.prompter.outro(t("plan.rerunning"));
+        return true;
+    }
+    if (written.length === 0) {
+        ctx.prompter.outro(t("plan.nothingWritten"));
+        return false;
+    }
+    ctx.prompter.outro(t("plan.done", { count: written.length, next: `${CLI} next` }));
+    return false;
+}
+async function regenerate(ctx) {
+    if (ctx.flags.yes)
+        return true;
+    return ctx.prompter.confirm(t("plan.existingPlan"), false);
+}

package/dist/commands/replan.js

@@ -0,0 +1,37 @@
+import { planChanges } from "../artifacts/merge.js";
+import { t } from "../i18n/index.js";
+import { selectFiles } from "../plan/filter.js";
+import { buildPriorPlan } from "../plan/prior.js";
+import { generatePlan } from "../plan/run.js";
+import { loadTaskFiles } from "../tasks/load.js";
+import { obsoleteTasks, reportPlan, writePlanFiles } from "./plan.js";
+import { CLI, requireConfig, saveCommands } from "./shared.js";
+const CHANGELOG = "docs/plan/CHANGELOG.md";
+export async function runReplan(ctx) {
+    const config = await requireConfig(ctx);
+    while (await replanOnce(ctx, config)) { }
+}
+async function replanOnce(ctx, config) {
+    ctx.prompter.intro(t("replan.intro"));
+    const tasks = await loadTaskFiles(ctx.cwd);
+    if (tasks.length === 0) {
+        ctx.prompter.outro(t("replan.noPlan", { command: `${CLI} plan` }));
+        return false;
+    }
+    const priorPlan = await buildPriorPlan(ctx.cwd, tasks);
+    const parsed = await generatePlan(ctx, config, {
+        priorPlan,
+        knownTaskIds: tasks.map((task) => task.id),
+    });
+    if (!parsed) {
+        ctx.prompter.outro(t("plan.dryRunDone"));
+        return false;
+    }
+    if (!parsed.files.some((file) => file.path === CHANGELOG))
+        ctx.prompter.warn(t("replan.noChangelog"));
+    const files = selectFiles(parsed.files, { targets: config.targets });
+    const changes = [...(await planChanges(ctx.cwd, files)), ...obsoleteTasks(tasks, parsed)];
+    const written = await writePlanFiles(ctx, changes);
+    await saveCommands(ctx, parsed.commands);
+    return reportPlan(ctx, parsed, written);
+}

package/dist/commands/review.js

@@ -0,0 +1,37 @@
+import { ExitCode, UserError } from "../core/errors.js";
+import { prepareCapture, readCapture } from "../gates/capture.js";
+import { newAcceptance } from "../gates/findings.js";
+import { t } from "../i18n/index.js";
+import { formatFindings, reviewTask } from "../review/run.js";
+import { loadValidTasks, requireConfig } from "./shared.js";
+export async function runReview(ctx, taskId, options = {}) {
+    const config = await requireConfig(ctx);
+    ctx.prompter.intro(t("review.intro"));
+    const tasks = await loadValidTasks(ctx);
+    const wanted = taskId?.toUpperCase();
+    const task = wanted
+        ? tasks.find((candidate) => candidate.meta.id === wanted)
+        : tasks.find((candidate) => candidate.meta.status === "in_progress");
+    if (!task) {
+        throw new UserError(wanted ? t("review.unknownTask", { id: wanted }) : t("review.noTask"));
+    }
+    const stored = await readCapture(ctx.cwd, task.meta.id);
+    if (!stored)
+        ctx.prompter.warn(t("review.noCapture", { id: task.meta.id }));
+    const capture = stored ?? { ...(await prepareCapture(ctx.cwd, config, task)), snapshot: {} };
+    const result = await reviewTask(ctx, capture, [], newAcceptance(options.acceptFinding));
+    if (result.reason && result.status === "fail")
+        ctx.prompter.warn(result.reason);
+    if (result.findings.length > 0)
+        ctx.prompter.note(formatFindings(result.findings), t("review.findings"));
+    if (result.status === "skipped") {
+        ctx.prompter.outro(result.reason ?? "");
+        return;
+    }
+    if (result.status === "pass") {
+        ctx.prompter.outro(t("review.passed"));
+        return;
+    }
+    ctx.prompter.outro(t("review.failed", { id: task.meta.id }));
+    throw new ExitCode(1);
+}

package/dist/commands/shared.js

@@ -0,0 +1,40 @@
+import { fillCommands, proposeCommands } from "../config/commands.js";
+import { COMMAND_KEYS } from "../config/schema.js";
+import { readConfig, writeConfig } from "../config/store.js";
+import { UserError } from "../core/errors.js";
+import { t } from "../i18n/index.js";
+import { loadTaskFiles } from "../tasks/load.js";
+export const CLI = "npx builder-assistant-engineer";
+export async function requireConfig(ctx) {
+    const config = await readConfig(ctx.cwd);
+    if (!config)
+        throw new UserError(t("config.missing", { command: `${CLI} init` }));
+    return {
+        ...config,
+        backend: ctx.flags.backend ?? config.backend,
+        lang: ctx.flags.lang ?? config.lang,
+    };
+}
+export async function saveCommands(ctx, analyst = {}) {
+    const stored = await readConfig(ctx.cwd);
+    if (!stored)
+        return analyst;
+    const commands = fillCommands(stored.commands, analyst, await proposeCommands(ctx.cwd));
+    const added = COMMAND_KEYS.filter((key) => commands[key] && !stored.commands[key]);
+    if (added.length === 0 || ctx.flags.dryRun)
+        return commands;
+    await writeConfig(ctx.cwd, { ...stored, commands });
+    ctx.prompter.note(added.map((key) => `${key}: ${commands[key]}`).join("\n"), t("plan.commands"));
+    return commands;
+}
+export function isAgentBackend(backend) {
+    return backend !== "api" && backend !== "manual";
+}
+export async function loadValidTasks(ctx) {
+    const loaded = await loadTaskFiles(ctx.cwd);
+    for (const item of loaded) {
+        if (item.error)
+            ctx.prompter.warn(t("tasks.invalid", { error: item.error }));
+    }
+    return loaded.flatMap((item) => (item.task ? [item.task] : []));
+}

package/dist/commands/status.js

@@ -0,0 +1,95 @@
+import pc from "picocolors";
+import { t } from "../i18n/index.js";
+import { blockedReason } from "../tasks/attempts.js";
+import { loadTaskFiles } from "../tasks/load.js";
+import { formatDuration, readMetrics } from "../tasks/metrics.js";
+import { orderTasks, pickNext, waitingOn } from "../tasks/select.js";
+import { CLI } from "./shared.js";
+const BAR_WIDTH = 20;
+const TITLE_WIDTH = 56;
+const SYMBOLS = {
+    done: pc.green("✔"),
+    in_progress: pc.yellow("▶"),
+    pending: pc.dim("○"),
+    blocked: pc.red("✖"),
+};
+export async function runStatus(ctx) {
+    const loaded = await loadTaskFiles(ctx.cwd);
+    if (loaded.length === 0) {
+        ctx.print(`${t("status.empty", { command: `${CLI} plan` })}\n`);
+        return;
+    }
+    const metrics = await readMetrics(ctx.cwd, loaded.map((item) => item.id));
+    const blocked = loaded.filter((item) => item.task?.meta.status === "blocked");
+    const reasons = new Map(await Promise.all(blocked.map(async (item) => [item.id, (await blockedReason(ctx.cwd, item.id)) ?? ""])));
+    ctx.print(`${renderStatus(loaded, metrics, reasons)}\n`);
+}
+export function renderStatus(loaded, metrics, reasons = new Map()) {
+    const tasks = loaded.flatMap((item) => (item.task ? [item.task] : []));
+    const phases = [...new Set(orderTasks(tasks).map((task) => task.meta.phase))];
+    const blocks = phases.map((phase) => renderPhase(phase, orderTasks(tasks).filter((task) => task.meta.phase === phase), tasks, metrics));
+    const invalid = loaded.filter((item) => item.error).map((item) => `${pc.red("!")} ${item.error}`);
+    const why = [...reasons]
+        .filter(([, reason]) => reason !== "")
+        .map(([id, reason]) => `${SYMBOLS.blocked} ${t("status.blockedReason", { id, reason })}`);
+    return [
+        ...blocks,
+        ...(why.length > 0 ? [why.join("\n")] : []),
+        ...(invalid.length > 0 ? [invalid.join("\n")] : []),
+        summary(tasks),
+        ...(metrics && metrics.attempts > 0 ? [renderMetrics(metrics)] : []),
+    ].join("\n\n");
+}
+function renderPhase(phase, tasks, all, metrics) {
+    const done = tasks.filter((task) => task.meta.status === "done").length;
+    const header = `${pc.bold(t("status.phase", { phase }))}  ${bar(done, tasks.length)} ${done}/${tasks.length}`;
+    return [header, ...tasks.map((task) => renderTask(task, all, metrics))].join("\n");
+}
+function renderTask(task, all, metrics) {
+    const { id, size, risk, status, title } = task.meta;
+    const waiting = status === "pending" ? waitingOn(task, all) : [];
+    const note = waiting.length > 0 ? pc.dim(`  ${t("status.waiting", { ids: waiting.join(", ") })}`) : "";
+    const label = status === "done" ? "" : pc.dim(`  ${status}`);
+    const runs = metrics?.tasks.get(id);
+    const effort = runs
+        ? pc.dim(`  ${t("status.taskRuns", { attempts: runs.attempts, time: formatDuration(runs.durationMs) })}`)
+        : "";
+    return `  ${SYMBOLS[status]} ${id}  ${size}  ${risk.padEnd(6)}  ${truncate(title)}${label}${note}${effort}`;
+}
+function summary(tasks) {
+    const done = tasks.filter((task) => task.meta.status === "done").length;
+    const next = pickNext(tasks);
+    const nextText = next
+        ? t("status.next", { id: next.meta.id, title: next.meta.title })
+        : t("status.noNext");
+    return `${t("status.total", { done, total: tasks.length, percent: percent(done, tasks.length) })} · ${nextText}`;
+}
+function renderMetrics(metrics) {
+    const average = (metrics.attempts / Math.max(metrics.attempted, 1)).toFixed(1);
+    const lines = [
+        t("status.attempts", { attempts: metrics.attempts, tasks: metrics.attempted, average }),
+        t("status.firstAttempt", {
+            count: metrics.doneOnFirst,
+            tasks: metrics.attempted,
+            percent: percent(metrics.doneOnFirst, metrics.attempted),
+        }),
+        t("status.regressions", { count: metrics.regressionsCaught }),
+    ];
+    if (metrics.done > 0) {
+        lines.push(t("status.time", {
+            average: formatDuration(metrics.doneDurationMs / metrics.done),
+            total: formatDuration(metrics.doneDurationMs),
+        }));
+    }
+    return [pc.bold(t("status.metrics")), ...lines.map((line) => `  ${line}`)].join("\n");
+}
+function percent(part, total) {
+    return total > 0 ? Math.round((part / total) * 100) : 0;
+}
+function bar(done, total) {
+    const filled = total > 0 ? Math.round((done / total) * BAR_WIDTH) : 0;
+    return pc.green("█".repeat(filled)) + pc.dim("░".repeat(BAR_WIDTH - filled));
+}
+function truncate(text) {
+    return text.length > TITLE_WIDTH ? `${text.slice(0, TITLE_WIDTH - 1)}…` : text;
+}

package/dist/config/commands.js

@@ -0,0 +1,85 @@
+import { join } from "node:path";
+import { readTextIfExists } from "../core/fs.js";
+import { asRecord, parseObject } from "../core/json.js";
+import { COMMAND_KEYS } from "./schema.js";
+const NPM_SCRIPTS = {
+    test: ["test"],
+    lint: ["lint"],
+    typecheck: ["typecheck", "type-check", "check-types", "types"],
+    build: ["build"],
+};
+const PLACEHOLDER_TEST = /no test specified/;
+const LOCKFILES = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+];
+const DEFAULTS = [
+    ["go.mod", { test: "go test -v ./...", lint: "go vet ./...", build: "go build ./..." }],
+    [
+        "Cargo.toml",
+        { test: "cargo test", lint: "cargo clippy", typecheck: "cargo check", build: "cargo build" },
+    ],
+];
+const PYTHON_TOOLS = [
+    ["test", /\bpytest\b/, "pytest"],
+    ["lint", /\bruff\b/, "ruff check ."],
+    ["lint", /\bflake8\b/, "flake8"],
+    ["typecheck", /\bmypy\b/, "mypy ."],
+    ["typecheck", /\bpyright\b/, "pyright"],
+];
+export async function proposeCommands(cwd) {
+    const read = (name) => readTextIfExists(join(cwd, name));
+    const [pkg, makefile, ...python] = await Promise.all(["package.json", "Makefile", "pyproject.toml", "requirements.txt", "requirements-dev.txt"].map(read));
+    const inferred = await Promise.all(DEFAULTS.map(async ([file, commands]) => ((await read(file)) === undefined ? {} : commands)));
+    return fillCommands(pkg ? fromScripts(pkg, await detectRunner(cwd, pkg)) : {}, makefile ? fromMakefile(makefile) : {}, fromPython(python.join("\n")), ...inferred);
+}
+export function fillCommands(...sources) {
+    const commands = {};
+    for (const key of COMMAND_KEYS) {
+        const value = sources.map((source) => source?.[key]?.trim()).find(Boolean);
+        if (value)
+            commands[key] = value;
+    }
+    return commands;
+}
+function fromScripts(text, runner) {
+    const scripts = asRecord(parseObject(text)?.scripts);
+    const commands = {};
+    for (const key of COMMAND_KEYS) {
+        const name = NPM_SCRIPTS[key].find((candidate) => typeof scripts[candidate] === "string");
+        if (!name || (key === "test" && PLACEHOLDER_TEST.test(String(scripts[name]))))
+            continue;
+        commands[key] =
+            runner !== "bun" && name === "test" ? `${runner} test` : `${runner} run ${name}`;
+    }
+    return commands;
+}
+async function detectRunner(cwd, pkg) {
+    const declared = String(parseObject(pkg)?.packageManager ?? "").split("@")[0];
+    if (declared === "pnpm" || declared === "yarn" || declared === "bun")
+        return declared;
+    for (const [file, runner] of LOCKFILES) {
+        if ((await readTextIfExists(join(cwd, file))) !== undefined)
+            return runner;
+    }
+    return "npm";
+}
+function fromMakefile(text) {
+    const commands = {};
+    for (const key of COMMAND_KEYS) {
+        if (new RegExp(`^${key}\\s*:`, "m").test(text))
+            commands[key] = `make ${key}`;
+    }
+    return commands;
+}
+function fromPython(text) {
+    const lower = text.toLowerCase();
+    const commands = {};
+    for (const [key, pattern, command] of PYTHON_TOOLS) {
+        if (!commands[key] && pattern.test(lower))
+            commands[key] = command;
+    }
+    return commands;
+}