builder-assistant-engineer 0.2.0

package/dist/tasks/load.js

@@ -0,0 +1,37 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { FormatError } from "../core/errors.js";
+import { readTextIfExists } from "../core/fs.js";
+import { parseTask, TASK_PATH, TASKS_DIR } from "./schema.js";
+export async function loadTaskFiles(cwd) {
+    const names = await listMarkdown(join(cwd, ...TASKS_DIR.split("/")));
+    const loaded = await Promise.all(names.map((name) => loadOne(cwd, `${TASKS_DIR}/${name}`)));
+    return loaded
+        .filter((task) => task !== undefined)
+        .sort((a, b) => compareIds(a.id, b.id));
+}
+export function compareIds(a, b) {
+    return Number(a.slice(2)) - Number(b.slice(2)) || (a < b ? -1 : a > b ? 1 : 0);
+}
+async function loadOne(cwd, path) {
+    const id = TASK_PATH.exec(path)?.[1];
+    const text = await readTextIfExists(join(cwd, ...path.split("/")));
+    if (!id || text === undefined)
+        return undefined;
+    try {
+        return { path, id, text, task: parseTask(path, text) };
+    }
+    catch (error) {
+        if (!(error instanceof FormatError))
+            throw error;
+        return { path, id, text, error: error.message };
+    }
+}
+async function listMarkdown(dir) {
+    try {
+        return (await readdir(dir)).filter((name) => name.endsWith(".md")).sort();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/tasks/metrics.js

@@ -0,0 +1,40 @@
+import { readAttempts } from "./attempts.js";
+export async function readMetrics(cwd, ids) {
+    const history = await Promise.all(ids.map(async (id) => [id, await readAttempts(cwd, id)]));
+    const tasks = new Map(history
+        .filter(([, attempts]) => attempts.length > 0)
+        .map(([id, attempts]) => [id, taskMetrics(id, attempts)]));
+    const all = history.flatMap(([, attempts]) => attempts);
+    const finished = [...tasks.values()].filter((task) => task.completedAt !== undefined);
+    return {
+        tasks,
+        attempts: all.length,
+        attempted: tasks.size,
+        doneOnFirst: [...tasks.values()].filter((task) => task.doneOnFirst).length,
+        regressionsCaught: all.filter((attempt) => attempt.stage === "regression").length,
+        done: finished.length,
+        doneDurationMs: finished.reduce((total, task) => total + task.durationMs, 0),
+    };
+}
+export function completionTimes(metrics) {
+    return new Map([...metrics.tasks.values()].flatMap((task) => task.completedAt === undefined ? [] : [[task.id, task.completedAt]]));
+}
+export function formatDuration(ms) {
+    const seconds = Math.round(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+function taskMetrics(id, attempts) {
+    const done = attempts.filter((attempt) => attempt.outcome === "done").at(-1);
+    return {
+        id,
+        attempts: attempts.length,
+        durationMs: attempts.reduce((total, attempt) => total + attempt.durationMs, 0),
+        doneOnFirst: attempts[0]?.outcome === "done",
+        ...(done ? { completedAt: Date.parse(done.startedAt) + done.durationMs } : {}),
+    };
+}

package/dist/tasks/runs.js

@@ -0,0 +1,12 @@
+import { join } from "node:path";
+import { writeText } from "../core/fs.js";
+import { repoState } from "../core/state.js";
+export function runDir(cwd, id) {
+    return join(repoState(cwd), "runs", id);
+}
+export async function writeRunLog(cwd, id, content) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const path = join(runDir(cwd, id), `${stamp}.md`);
+    await writeText(path, content);
+    return path;
+}

package/dist/tasks/schema.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { FormatError } from "../core/errors.js";
+import { trivialityProblems } from "./checks.js";
+import { splitFrontmatter } from "./frontmatter.js";
+import { logicalLines } from "./shell-words.js";
+export const TASK_STATUSES = ["pending", "in_progress", "done", "blocked"];
+export const TEST_POLICIES = ["required", "optional", "fix"];
+export const TASK_ID = /^T-\d{3,}$/;
+export const TASK_PATH = /^docs\/plan\/tasks\/(T-\d{3,})-[A-Za-z0-9._-]+\.md$/;
+export const TASKS_DIR = "docs/plan/tasks";
+const taskId = z.string().regex(TASK_ID, "must look like T-001");
+export const taskMetaSchema = z.object({
+    id: taskId,
+    title: z.string().min(1),
+    status: z.enum(TASK_STATUSES),
+    phase: z.union([z.number().int().nonnegative(), z.string().regex(/^\d+$/).transform(Number)]),
+    depends_on: z
+        .array(taskId)
+        .nullish()
+        .transform((value) => value ?? []),
+    size: z.enum(["S", "M", "L"]),
+    risk: z.enum(["low", "medium", "high"]),
+    tests: z.enum(TEST_POLICIES).default("optional"),
+});
+export const SECTIONS = {
+    goal: ["goal", "objetivo"],
+    context: ["context", "contexto"],
+    scope: ["scope", "alcance"],
+    steps: ["steps", "pasos"],
+    acceptance: ["acceptance criteria", "criterios de aceptación", "criterios de aceptacion"],
+    verification: ["verification", "verificación", "verificacion"],
+    risks: ["risks and notes", "riesgos y notas", "risks", "riesgos"],
+    log: ["log", "registro", "bitácora", "bitacora"],
+};
+const TRIVIALITY = {
+    masks: "hides failures (|| true, set +e); the block runs with set -euo pipefail and must fail when a check fails",
+    trivial: "runs nothing that checks the task; use the project's test runner, a linter or a check with an expected result (test -f, grep -q, curl -f)",
+};
+const COMMAND_BLOCK = /```(?:sh|bash|shell|console)[^\n]*\n([\s\S]*?)```/g;
+export function parseTask(path, text) {
+    const frontmatter = readFrontmatter(path, text);
+    const result = taskMetaSchema.safeParse(frontmatter.data);
+    if (!result.success) {
+        const details = result.error.issues
+            .map((issue) => `${issue.path.join(".") || "frontmatter"}: ${issue.message}`)
+            .join("; ");
+        throw new FormatError(`${path}: invalid frontmatter (${details})`);
+    }
+    return { path, meta: result.data, body: frontmatter.body, text };
+}
+export function taskProblems(task) {
+    const missing = Object.keys(SECTIONS).filter((key) => sectionText(task.body, key) === undefined);
+    const problems = missing.map((key) => `${task.path}: missing section "${SECTIONS[key][0]}"`);
+    if (!missing.includes("verification") && verificationCommands(task.body).length === 0) {
+        problems.push(`${task.path}: Verification needs at least one command in a \`\`\`sh block`);
+    }
+    for (const problem of trivialityProblems(verificationScript(task.body))) {
+        problems.push(`${task.path}: Verification ${TRIVIALITY[problem.reason]}: ${problem.command}`);
+    }
+    return problems;
+}
+export function sectionText(body, key) {
+    return sectionTexts(body, key)[0];
+}
+export function sectionTexts(body, key) {
+    const aliases = SECTIONS[key];
+    const parts = body.split(/^##[ \t]+(.+?)[ \t]*$/m);
+    const found = [];
+    for (let index = 1; index < parts.length; index += 2) {
+        const heading = (parts[index] ?? "").trim().toLowerCase();
+        if (aliases.includes(heading))
+            found.push((parts[index + 1] ?? "").trim());
+    }
+    return found;
+}
+export function verificationScript(body) {
+    const section = sectionText(body, "verification") ?? "";
+    return Array.from(section.matchAll(COMMAND_BLOCK), (match) => match[1] ?? "")
+        .flatMap((block) => block.replace(/\r?\n$/, "").split(/\r?\n/))
+        .map((line) => line.replace(/^(\s*)\$\s+/, "$1"));
+}
+export function verificationCommands(body) {
+    return logicalLines(verificationScript(body));
+}
+function readFrontmatter(path, text) {
+    try {
+        const frontmatter = splitFrontmatter(text);
+        if (frontmatter)
+            return frontmatter;
+    }
+    catch (error) {
+        const details = error instanceof Error ? error.message.split("\n")[0] : String(error);
+        throw new FormatError(`${path}: frontmatter is not valid YAML (${details})`);
+    }
+    throw new FormatError(`${path}: missing YAML frontmatter`);
+}

package/dist/tasks/select.js

@@ -0,0 +1,15 @@
+import { compareIds } from "./load.js";
+export function orderTasks(tasks) {
+    return [...tasks].sort((a, b) => a.meta.phase - b.meta.phase || compareIds(a.meta.id, b.meta.id));
+}
+export function pickNext(tasks, exhausted = new Set()) {
+    const ordered = orderTasks(tasks);
+    const inProgress = ordered.filter((task) => task.meta.status === "in_progress");
+    return (inProgress.find((task) => !exhausted.has(task.meta.id)) ??
+        ordered.find((task) => task.meta.status === "pending" && waitingOn(task, tasks).length === 0) ??
+        inProgress[0]);
+}
+export function waitingOn(task, tasks) {
+    const done = new Set(tasks.filter((other) => other.meta.status === "done").map((other) => other.meta.id));
+    return task.meta.depends_on.filter((id) => !done.has(id));
+}

package/dist/tasks/shell-words.js

@@ -0,0 +1,176 @@
+const OPERATORS = ["&&", "||", ";", "|", "&"];
+export function parseLine(line) {
+    const commands = [];
+    let words = [];
+    let word = "";
+    let text = "";
+    let quote;
+    let substitution = false;
+    let started = false;
+    const endWord = () => {
+        if (started)
+            words.push(word);
+        word = "";
+        started = false;
+    };
+    const endCommand = () => {
+        endWord();
+        if (words.length > 0)
+            commands.push({ words, text: text.trim() });
+        words = [];
+        text = "";
+    };
+    for (let index = 0; index < line.length; index++) {
+        const char = line[index] ?? "";
+        const rest = line.slice(index);
+        if (quote) {
+            if (char === quote)
+                quote = undefined;
+            else if (char === "\\" && quote === '"')
+                word += line[++index] ?? "";
+            else
+                word += char;
+            if (quote === '"' && (rest.startsWith("$(") || char === "`"))
+                substitution = true;
+            text += char;
+            continue;
+        }
+        if (char === "#" && !started)
+            break;
+        if (char === "'" || char === '"') {
+            quote = char;
+            started = true;
+            text += char;
+            continue;
+        }
+        if (char === "\\") {
+            word += line[++index] ?? "";
+            started = true;
+            text += char;
+            continue;
+        }
+        if (rest.startsWith("$(") || char === "`")
+            substitution = true;
+        const operator = OPERATORS.find((candidate) => rest.startsWith(candidate));
+        if (operator) {
+            endCommand();
+            index += operator.length - 1;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            endWord();
+            text += char;
+            continue;
+        }
+        word += char;
+        started = true;
+        text += char;
+    }
+    endCommand();
+    return { commands, substitution };
+}
+const KEYWORDS = new Set([
+    "if",
+    "then",
+    "else",
+    "elif",
+    "while",
+    "until",
+    "do",
+    "done",
+    "fi",
+    "esac",
+    "!",
+    "{",
+    "}",
+    "(",
+    ")",
+    ";;",
+    "time",
+]);
+const CASE_PATTERN = /^[^()=\s]*\)$/;
+const HEREDOC = /(?<!<)<<-?(?!<)\s*(['"]?)([A-Za-z_]\w*)\1/;
+export function program(command) {
+    let index = 0;
+    const words = command.words;
+    while (/^[A-Za-z_]\w*=/.test(words[index] ?? "") ||
+        KEYWORDS.has(words[index] ?? "") ||
+        (CASE_PATTERN.test(words[index] ?? "") && index < words.length - 1)) {
+        index++;
+    }
+    const [raw = "", ...args] = words.slice(index);
+    const first = raw.replace(/^\(+/, "");
+    if (first === "env")
+        return program({ words: args, text: command.text });
+    return { name: first, args };
+}
+export function heredocEnd(line) {
+    return HEREDOC.exec(unquoted(line))?.[2];
+}
+export function openQuote(text, start) {
+    let quote = start;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index] ?? "";
+        if (quote === "'") {
+            if (char === "'")
+                quote = undefined;
+            continue;
+        }
+        if (char === "\\") {
+            index++;
+            continue;
+        }
+        if (quote === '"') {
+            if (char === '"')
+                quote = undefined;
+            continue;
+        }
+        if (char === "#" && (index === 0 || /\s/.test(text[index - 1] ?? "")))
+            break;
+        if (char === "'" || char === '"')
+            quote = char;
+    }
+    return quote;
+}
+export function unquoted(line) {
+    return line.replace(/'[^']*'|"(?:[^"\\]|\\.)*"/g, "''").replace(/(^|\s)#.*$/, "$1");
+}
+export function logicalLines(lines) {
+    const joined = [];
+    let pending = "";
+    let quote;
+    let heredoc;
+    for (const raw of lines) {
+        if (heredoc !== undefined) {
+            if (raw.replace(/^\t+/, "").trimEnd() === heredoc)
+                heredoc = undefined;
+            continue;
+        }
+        const line = raw.replace(/\s+$/, "");
+        if (quote) {
+            pending += `\n${line}`;
+            quote = openQuote(line, quote);
+            if (quote)
+                continue;
+        }
+        else if (line.endsWith("\\") && !openQuote(line)) {
+            pending += `${line.slice(0, -1).trim()} `;
+            continue;
+        }
+        else {
+            pending = `${pending}${line.trim()}`;
+            quote = openQuote(line);
+            if (quote)
+                continue;
+        }
+        const done = pending.trim();
+        pending = "";
+        if (done !== "" && !done.startsWith("#")) {
+            joined.push(done);
+            heredoc = heredocEnd(done);
+        }
+    }
+    if (pending.trim())
+        joined.push(pending.trim());
+    return joined;
+}

package/dist/tasks/status.js

@@ -0,0 +1,13 @@
+import { join } from "node:path";
+import { readTextIfExists, writeText } from "../core/fs.js";
+import { setFrontmatterFields } from "./frontmatter.js";
+import { withLogSection } from "./handoff.js";
+export async function setTaskStatus(cwd, task, status) {
+    const path = join(cwd, ...task.path.split("/"));
+    const current = (await readTextIfExists(path)) ?? task.text;
+    const text = setFrontmatterFields(status === "in_progress" ? withLogSection(current) : current, {
+        status,
+    });
+    await writeText(path, text);
+    return { ...task, text, meta: { ...task.meta, status } };
+}

package/dist/tasks/verify.js

@@ -0,0 +1,181 @@
+import { runScript } from "../core/bash.js";
+import { t } from "../i18n/index.js";
+import { trivialityProblems } from "./checks.js";
+import { heredocEnd, logicalLines, openQuote, parseLine, program, unquoted, } from "./shell-words.js";
+const HEADER = [
+    "set -Eeuo pipefail",
+    "export CI=true",
+    `trap 'bae_status=$?; printf "\\nbae: failed with exit %s: %s\\n" "$bae_status" "$BASH_COMMAND" >&2' ERR`,
+    `bae_reuse() { printf '$ %s (%s)\\n' "$2" "$3"; return "$1"; }`,
+    `bae_ok() { [ "$1" -eq 0 ] || { printf '\\nbae: failed with exit %s: %s\\n' "$1" "$2" >&2; exit "$1"; }; }`,
+];
+const FAILED_LINE = /^bae: failed with exit \d+: (.*)$/gm;
+const OPENERS = /(^|[;&|]\s*)(if|while|until|for|case|select)\b/g;
+const CLOSERS = /(^|[;&|]\s*)(fi|done|esac)\b/g;
+const STATEFUL = new Set([
+    "cd",
+    "pushd",
+    "popd",
+    "export",
+    "unset",
+    "set",
+    "source",
+    ".",
+    "alias",
+    "shopt",
+    "umask",
+    "trap",
+    "declare",
+    "typeset",
+    "local",
+    "readonly",
+    "eval",
+    "exec",
+    "function",
+]);
+const RULES = [
+    ["sudo", (command) => /(^|[\s;&|(`$])(sudo|doas)(\s|$)/.test(command)],
+    ["rm -rf", hasRecursiveForceRm],
+    [
+        "curl | sh",
+        (command) => /\b(curl|wget|iwr|irm|invoke-webrequest|invoke-restmethod)\b[^\n]*\|\s*(sudo\s+)?(sh|bash|zsh|dash|ksh|fish|python[\d.]*|node|perl|ruby|iex|invoke-expression)\b/i.test(command),
+    ],
+    ["git reset --hard", (command) => /\bgit\s+reset\b[^;&|]*--hard/.test(command)],
+    ["git clean -f", (command) => /\bgit\s+clean\b[^;&|]*\s-[a-zA-Z]*f/.test(command)],
+    ["git push", (command) => /\bgit\s+push\b/.test(command)],
+    [
+        "publish",
+        (command) => /\b(npm|pnpm|yarn)\s+(npm\s+)?publish\b|\bdocker\s+push\b/.test(command),
+    ],
+    [
+        "disk tools",
+        (command) => /\b(mkfs(\.\w+)?|fdisk|diskpart)\b|\bdd\b[^;&|]*\bof=\/dev\//.test(command),
+    ],
+    ["shutdown", (command) => /\b(shutdown|reboot|halt|poweroff)\b/.test(command)],
+    ["fork bomb", (command) => /:\(\)\s*\{/.test(command)],
+    [
+        "recursive delete",
+        (command) => /\b(rd|rmdir)\s+\/s\b|\bdel\b[^;&|]*\/s\b|remove-item\b(?=[^;&|]*-recurse)(?=[^;&|]*-force)/i.test(command),
+    ],
+];
+export function findUnsafe(commands) {
+    return commands.flatMap((command) => {
+        const rule = RULES.find(([, matches]) => matches(command));
+        return rule ? [{ command, reason: rule[0] }] : [];
+    });
+}
+export async function runVerification(cwd, lines, options) {
+    const known = options.known ?? new Map();
+    const excused = options.excused ?? new Set();
+    const commands = logicalLines(lines);
+    const tolerated = commands.filter((command) => excused.has(command) && (known.get(command)?.exitCode ?? 0) !== 0);
+    const script = lines.join("\n");
+    const counted = commands.filter((command) => !(excused.has(command) && known.has(command)));
+    const onlyExcused = counted.length < commands.length &&
+        (counted.length === 0 || trivialityProblems(counted).some((item) => item.reason === "trivial"));
+    if (onlyExcused) {
+        return {
+            passed: false,
+            exitCode: 1,
+            output: t("verify.onlyExcused"),
+            script,
+            tolerated,
+            ...(commands[0] ? { failed: commands[0] } : {}),
+        };
+    }
+    const body = planLines(lines).flatMap((line) => {
+        const command = line.text.trim();
+        const result = line.reusable && line.check === command ? known.get(command) : undefined;
+        const check = line.check === undefined ? [] : [`bae_ok $? ${quote(line.check)}`];
+        if (!result)
+            return [line.text, ...check];
+        const allowed = excused.has(command);
+        const code = allowed ? 0 : result.exitCode;
+        const note = allowed
+            ? `exit ${result.exitCode}, preexisting: it already failed before the task and did not get worse`
+            : `exit ${result.exitCode}, from the regression check`;
+        return [`bae_reuse ${code} ${quote(command)} ${quote(note)}`, ...check];
+    });
+    options.onOutput?.(`${lines.map((line) => `$ ${line}`).join("\n")}\n`);
+    const result = await runScript(options.bash, [...HEADER, ...body, ""].join("\n"), {
+        cwd,
+        onOutput: options.onOutput,
+        ...(options.timeoutMs ? { timeoutMs: options.timeoutMs } : {}),
+    });
+    const failed = [...result.output.matchAll(FAILED_LINE)].at(-1)?.[1];
+    return {
+        passed: result.exitCode === 0,
+        exitCode: result.exitCode,
+        output: result.output,
+        script,
+        tolerated,
+        ...(failed ? { failed } : {}),
+    };
+}
+function planLines(lines) {
+    const planned = [];
+    let depth = 0;
+    let heredoc;
+    let quote;
+    let pending = "";
+    let stateful = false;
+    for (const line of lines) {
+        const entry = { text: line, reusable: false };
+        planned.push(entry);
+        if (heredoc !== undefined) {
+            if (line.replace(/^\t+/, "").trimEnd() === heredoc)
+                heredoc = undefined;
+            continue;
+        }
+        const trimmed = line.trim();
+        const inside = quote !== undefined;
+        if (!inside && pending === "" && (trimmed === "" || trimmed.startsWith("#")))
+            continue;
+        entry.reusable = !inside && pending === "" && depth === 0 && !stateful;
+        pending = pending ? `${pending}${inside ? "\n" : " "}${trimmed}` : trimmed;
+        quote = openQuote(line, quote);
+        if (quote)
+            continue;
+        if (!inside) {
+            depth += blockDelta(trimmed);
+            heredoc = heredocEnd(trimmed);
+            stateful ||= changesState(trimmed);
+        }
+        if (/(\\|&&|\|\||\|)$/.test(unquoted(trimmed).trimEnd()) || heredoc || depth > 0)
+            continue;
+        depth = Math.max(depth, 0);
+        entry.check = pending;
+        pending = "";
+    }
+    return planned;
+}
+function changesState(line) {
+    return parseLine(line).commands.some((command) => {
+        const { name } = program(command);
+        return (STATEFUL.has(name) ||
+            /^[A-Za-z_]\w*\s*\(\s*\)/.test(command.text) ||
+            (command.words.length > 0 && command.words.every((word) => /^[A-Za-z_]\w*=/.test(word))));
+    });
+}
+function blockDelta(line) {
+    const code = unquoted(line);
+    const opens = [...code.matchAll(OPENERS)].length + (/\{\s*$/.test(code) ? 1 : 0);
+    const closes = [...code.matchAll(CLOSERS)].length + (/^\s*\}/.test(code) ? 1 : 0);
+    return opens - closes;
+}
+function quote(text) {
+    return `'${text.replace(/'/g, "'\\''")}'`;
+}
+function hasRecursiveForceRm(command) {
+    return command.split(/[;&|]+/).some((segment) => {
+        const tokens = segment.trim().split(/\s+/);
+        const index = tokens.findIndex((token) => token === "rm" || token.endsWith("/rm"));
+        if (index === -1)
+            return false;
+        const flags = tokens.slice(index + 1).filter((token) => token.startsWith("-"));
+        const short = flags.filter((flag) => /^-[a-zA-Z]+$/.test(flag)).join("");
+        const recursive = /[rR]/.test(short) || flags.includes("--recursive");
+        const force = short.includes("f") || flags.includes("--force");
+        return recursive && force;
+    });
+}

package/dist/ui/clack.js

@@ -0,0 +1,46 @@
+import * as clack from "@clack/prompts";
+import { UserError } from "../core/errors.js";
+import { t } from "../i18n/index.js";
+export function createClackPrompter() {
+    return {
+        intro: (title) => clack.intro(title),
+        outro: (message) => clack.outro(message),
+        note: (message, title) => clack.note(message, title),
+        info: (message) => clack.log.info(message),
+        warn: (message) => clack.log.warn(message),
+        success: (message) => clack.log.success(message),
+        select: async (message, choices, initial) => unwrap(await clack.select({ message, options: choices, initialValue: initial })),
+        multiselect: async (message, choices, initial) => unwrap(await clack.multiselect({
+            message,
+            options: choices,
+            initialValues: initial,
+            required: true,
+        })),
+        text: async (message, placeholder) => unwrap(await clack.text({ message, placeholder })) ?? "",
+        confirm: async (message, initial) => unwrap(await clack.confirm({ message, initialValue: initial })),
+        spinner: async (message, task) => {
+            if (!process.stdout.isTTY)
+                return staticSpinner(message, task);
+            const spin = clack.spinner({ indicator: "timer" });
+            spin.start(message);
+            try {
+                const result = await task((update) => spin.message(update));
+                spin.stop(message);
+                return result;
+            }
+            catch (error) {
+                spin.error(message);
+                throw error;
+            }
+        },
+    };
+}
+function unwrap(value) {
+    if (clack.isCancel(value))
+        throw new UserError(t("ui.cancelled"));
+    return value;
+}
+async function staticSpinner(message, task) {
+    clack.log.step(message);
+    return task(() => { });
+}

package/dist/ui/prompter.js

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