peer-ai 1.0.0-next.0

package/dist/routing.d.ts

@@ -0,0 +1,24 @@
+import { type KnownMapItemId, type PeerAiConfig, type SkillId, type WorkItem } from "peer-ai-workflow";
+import type { Stage } from "./init.ts";
+export interface RequiredReview {
+    skill: SkillId;
+    reason: string;
+}
+/** The installed name of each gap's skill, for the gaps whose skill exists. */
+export declare function gapSkills(gaps: KnownMapItemId[], available?: readonly SkillId[]): Partial<Record<KnownMapItemId, string>>;
+/**
+ * The reviews a change needs, from the files it touched. `read` gives a file's text, for the
+ * checks that look inside: personal fields in a schema, an AI library in code.
+ */
+export declare function reviewsFor(files: string[], config: PeerAiConfig, stage: Stage, read: (file: string) => string, available?: readonly SkillId[], item?: {
+    acceptance?: string[] | undefined;
+}): RequiredReview[];
+/** Every file the work has touched: committed since it left the base branch, and not yet committed. */
+export declare function changedFiles(root: string): string[];
+/** The required reviews still to do on a work item, by their installed names, for next_work. */
+export declare function reviewsToDo(item: WorkItem): {
+    skill: SkillId;
+    use: string;
+    reason: string;
+    done: boolean;
+}[];

package/dist/routing.js

@@ -0,0 +1,121 @@
+// Which skill comes next, so nobody has to remember 29 names (RFC 0004, section 8): the skill that
+// fills each gap on the map, and the reviews a change needs, worked out from the files it touched.
+// Only skills that exist are named or required; the rest follow as they're written.
+import { execFileSync } from "node:child_process";
+import { availableSkills, renderedName } from "peer-ai-skills";
+import { MAP_ITEM_SKILLS } from "peer-ai-workflow";
+import { INFRASTRUCTURE_AS_CODE, MANIFEST, PERSONAL_FIELD, SCHEMA_FILE, TEST_FILE, TRAIT_LIBRARIES, UI_KINDS, snakeCase, } from "./assess.js";
+/** The installed name of each gap's skill, for the gaps whose skill exists. */
+export function gapSkills(gaps, available = availableSkills()) {
+    const named = {};
+    for (const gap of gaps) {
+        const skill = (MAP_ITEM_SKILLS[gap] ?? []).find((candidate) => available.includes(candidate));
+        if (skill !== undefined)
+            named[gap] = renderedName(skill);
+    }
+    return named;
+}
+const CODE = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rb|php|cs|java|kt|kts|swift|dart|rs|ex|exs|vue|svelte|astro|scala|sql|c|cc|cpp|h|m|mm)$/;
+const SCREEN = /\.(tsx|jsx|vue|svelte|astro|html|css|scss|dart|swift)$|(^|\/)res\/layout\//;
+const MIGRATION = /(^|\/)(migrations?|migrate|alembic|drizzle)\/|schema\.prisma$|(^|\/)db\/schema\.(rb|sql)$/i;
+const LOCKFILE = /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|poetry\.lock|uv\.lock|Pipfile\.lock|Cargo\.lock|go\.sum|Gemfile\.lock|composer\.lock|Podfile\.lock|pubspec\.lock|packages\.lock\.json|gradle\.lockfile)$/;
+const DEPLOYMENT = /(^|\/)(Dockerfile|[^/]*\.Dockerfile|docker-compose[^/]*\.ya?ml|compose\.ya?ml|vercel\.json|netlify\.toml|fly\.toml|render\.yaml|app\.yaml|wrangler\.(toml|jsonc?)|serverless\.ya?ml|Procfile)$|(^|\/)\.github\/workflows\/|\.gitlab-ci\.yml$/;
+const DATA_INVENTORY = /data[-_ ]?inventory/i;
+const API_KINDS = ["http", "graphql", "rpc", "websocket", "events"];
+const aiLibraries = TRAIT_LIBRARIES.find(([trait]) => trait === "ai-features")?.[1];
+/** A pattern's test without the state a global pattern keeps between calls. */
+const matches = (pattern, text) => new RegExp(pattern.source, pattern.flags.replace("g", "")).test(text);
+const inTrack = (file, track) => track.path === undefined || file.startsWith(`${track.path}/`);
+/**
+ * The reviews a change needs, from the files it touched. `read` gives a file's text, for the
+ * checks that look inside: personal fields in a schema, an AI library in code.
+ */
+export function reviewsFor(files, config, stage, read, available = availableSkills(), item = {}) {
+    const tracks = config.tracks.filter((track) => track.status !== "external" && track.status !== "dormant");
+    const code = files.filter((file) => CODE.test(file));
+    const source = code.filter((file) => !TEST_FILE.test(file));
+    const found = [];
+    const need = (skill, reason, when) => {
+        if (when)
+            found.push({ skill, reason });
+    };
+    need("code-review", "it changes code", code.length > 0);
+    need("security-review", `it changes code, at the ${stage} stage`, source.length > 0 && stage !== "prototype");
+    const screens = files.filter((file) => SCREEN.test(file) && tracks.some((track) => UI_KINDS.includes(track.kind) && inTrack(file, track)));
+    need("accessibility-review", "it changes a screen", screens.length > 0);
+    need("design-review", "it changes a screen, and the project has a design", screens.length > 0 && config.design !== undefined);
+    const contracts = (config.apis ?? []).flatMap((api) => api.contract?.location ?? []);
+    const providers = (config.apis ?? [])
+        .filter((api) => API_KINDS.includes(api.kind) && api.providedBy !== undefined)
+        .map((api) => api.providedBy);
+    const providing = tracks.filter((track) => providers.includes(track.id));
+    need("contract-check", "it changes an API or its contract", files.some((file) => contracts.includes(file)) ||
+        source.some((file) => providing.some((track) => inTrack(file, track))));
+    need("data-migration-review", "it changes a migration", files.some((file) => MIGRATION.test(file)));
+    need("dependency-review", "it changes a dependency file or lockfile", files.some((file) => MANIFEST.test(file) || LOCKFILE.test(file)));
+    need("compliance-review", "it changes where personal data is kept", files.some((file) => DATA_INVENTORY.test(file) || (SCHEMA_FILE.test(file) && matches(PERSONAL_FIELD, snakeCase(read(file))))));
+    need("ai-feature-review", "it changes code that calls an AI model", (config.project.traits ?? []).includes("ai-features") &&
+        aiLibraries !== undefined &&
+        source.some((file) => matches(aiLibraries, read(file))));
+    need("infrastructure-review", "it changes infrastructure or deployment", files.some((file) => INFRASTRUCTURE_AS_CODE.test(file) || DEPLOYMENT.test(file)));
+    need("qa-acceptance", "its work item has acceptance criteria, which must all hold before it ships", (item.acceptance?.length ?? 0) > 0 && stage !== "prototype" && files.length > 0);
+    need("release-readiness", "it's about to ship, at the production stage", stage === "production" && files.length > 0);
+    const choices = config.activities?.verify?.reviews;
+    for (const skill of choices?.require ?? []) {
+        if (!found.some((review) => review.skill === skill))
+            found.push({ skill, reason: "the project's config requires it" });
+    }
+    const skipped = new Set((choices?.skip ?? []).map((choice) => choice.skill));
+    return found.filter((review) => available.includes(review.skill) && !skipped.has(review.skill));
+}
+const git = (root, args) => execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+/** The branch changes are measured against: origin's default branch, or main, or master. */
+function baseCommit(root) {
+    const candidates = [];
+    try {
+        candidates.push(git(root, ["symbolic-ref", "--short", "-q", "refs/remotes/origin/HEAD"]).trim());
+    }
+    catch {
+        // No remote default: fall back to the usual names.
+    }
+    candidates.push("main", "master");
+    for (const candidate of candidates.filter((name) => name !== "")) {
+        try {
+            return git(root, ["merge-base", "HEAD", candidate]).trim();
+        }
+        catch {
+            // Not a branch in this repository; try the next.
+        }
+    }
+    return undefined;
+}
+/** Every file the work has touched: committed since it left the base branch, and not yet committed. */
+export function changedFiles(root) {
+    const files = new Set();
+    try {
+        const base = baseCommit(root);
+        if (base !== undefined) {
+            for (const file of git(root, ["diff", "--name-only", `${base}...HEAD`]).split("\n"))
+                if (file !== "")
+                    files.add(file);
+        }
+        for (const line of git(root, ["status", "--porcelain", "--untracked-files=all"]).split("\n")) {
+            const path = line.slice(3).split(" -> ").at(-1);
+            if (path !== undefined && path !== "")
+                files.add(path.replace(/^"|"$/g, ""));
+        }
+    }
+    catch {
+        // Not a git repository: nothing to measure.
+    }
+    return [...files].sort();
+}
+/** The required reviews still to do on a work item, by their installed names, for next_work. */
+export function reviewsToDo(item) {
+    const done = new Set((item.reviews ?? []).map((review) => review.skill));
+    return (item.requiredReviews ?? []).map((review) => ({
+        ...review,
+        use: renderedName(review.skill),
+        done: done.has(review.skill),
+    }));
+}

package/dist/ruff.d.ts

@@ -0,0 +1,19 @@
+import { type AppliedRule } from "peer-ai-standards";
+import type { PeerAiConfig } from "peer-ai-workflow";
+export declare const RUFF_FILE = ".peer-ai/enforce/ruff.toml";
+type Table = Record<string, unknown>;
+/**
+ * Ruff's lint settings for these rules, with the settings they read merged in. The rules are added
+ * with extend-select, which keeps Ruff's defaults and the project's own choices: a select would
+ * replace them.
+ */
+export declare function ruffSettings(rules: readonly AppliedRule[]): {
+    lint: Table;
+};
+/** The automatic Ruff rules any part of the project gets, leaving out the ones it set aside. */
+export declare function ruffRules(config: PeerAiConfig): AppliedRule[];
+/** Settings as TOML. */
+export declare const toToml: (settings: Table) => string;
+/** The file render writes, or undefined when no part gets a Ruff rule. */
+export declare function ruffFile(config: PeerAiConfig): string | undefined;
+export {};

package/dist/ruff.js

@@ -0,0 +1,64 @@
+// Ruff's settings for a project's Python profiles (RFC 0006). Ruff reads settings from a file, not
+// a package, so render writes them to .peer-ai/enforce/ruff.toml and the project's own Ruff
+// settings extend it. Every automatic rule Ruff enforces is selected, with the project's values.
+import { profileRulesFor } from "peer-ai-standards";
+import { stringify } from "smol-toml";
+export const RUFF_FILE = ".peer-ai/enforce/ruff.toml";
+/**
+ * Ruff's lint settings for these rules, with the settings they read merged in. The rules are added
+ * with extend-select, which keeps Ruff's defaults and the project's own choices: a select would
+ * replace them.
+ */
+export function ruffSettings(rules) {
+    const codes = new Set();
+    const lint = {};
+    for (const rule of rules) {
+        if (rule.check !== "auto" || rule.enforcer?.tool !== "ruff")
+            continue;
+        codes.add(rule.enforcer.rule);
+        for (const [section, settings] of Object.entries(rule.enforcer.settings ?? {})) {
+            lint[section] = { ...lint[section], ...settings };
+        }
+    }
+    return { lint: { "extend-select": [...codes].sort(), ...lint } };
+}
+/** The automatic Ruff rules any part of the project gets, leaving out the ones it set aside. */
+export function ruffRules(config) {
+    const setAside = new Set((config.standards?.exceptions ?? []).map((exception) => exception.rule));
+    const seen = new Map();
+    for (const track of config.tracks) {
+        if (track.status === "external")
+            continue;
+        const rules = profileRulesFor({
+            listed: config.standards?.profiles ?? [],
+            stage: config.project.stage ?? "mvp",
+            traits: config.project.traits ?? [],
+            overrides: config.standards?.overrides ?? {},
+            ...(track.stack === undefined ? {} : { stack: track.stack }),
+            ...(track.architecture === undefined ? {} : { architecture: track.architecture }),
+        });
+        for (const rule of rules) {
+            if (rule.enforcer?.tool === "ruff" && rule.check === "auto" && !setAside.has(rule.id))
+                seen.set(rule.id, rule);
+        }
+    }
+    return [...seen.values()];
+}
+/** Settings as TOML. */
+export const toToml = (settings) => stringify(settings);
+/** The file render writes, or undefined when no part gets a Ruff rule. */
+export function ruffFile(config) {
+    const rules = ruffRules(config);
+    if (rules.length === 0)
+        return undefined;
+    const ids = rules.map((rule) => `${rule.id} ${rule.enforcer?.tool === "ruff" ? rule.enforcer.rule : ""}`);
+    return `${[
+        "# Generated by peer-ai render from peer-ai.config.json: the Ruff rules of the project's stack profiles.",
+        '# Extend it from your own Ruff settings, such as extend = ".peer-ai/enforce/ruff.toml", and add rules',
+        "# of your own with extend-select, not select, which would replace these. Change the config, not this",
+        "# file: render writes it again.",
+        `# ${ids.join(", ")}`,
+        "",
+        toToml(ruffSettings(rules)),
+    ].join("\n")}\n`;
+}

package/dist/standards.d.ts

@@ -0,0 +1,46 @@
+import { type Rule, type Value } from "peer-ai-standards";
+import { type PeerAiConfig } from "peer-ai-workflow";
+type ConfigTrack = PeerAiConfig["tracks"][number];
+/**
+ * A rule as an agent needs it while editing: what to do, and the question it will be reviewed by.
+ * A stack profile's rule also names the core rule it carries out, and its value for this project.
+ */
+export type RuleForFile = Pick<Rule, "id" | "title" | "rule" | "ask" | "check" | "severity"> & {
+    carries?: string;
+    value?: Value;
+};
+export interface StandardsForFile {
+    file: string;
+    stage: "prototype" | "mvp" | "production";
+    /** Peer AI's rules that apply to this file. */
+    peerAiRules: RuleForFile[];
+    /** Rules the project has set aside, with its reasons. */
+    setAside: {
+        rule: string;
+        reason: string;
+    }[];
+    track?: {
+        id: string;
+        kind: ConfigTrack["kind"];
+        path?: string;
+    };
+    /** Peer AI's core principles apply unless the config turns them off. */
+    core: boolean;
+    profiles: string[];
+    /** The project's own documents that govern this file, in the order the config lists them. */
+    documents: {
+        path: string;
+        role: "standard" | "addendum" | "checklist";
+    }[];
+    rules: {
+        path: string;
+        description?: string;
+    }[];
+    /** Which side wins a conflict between the project's documents and the core principles. */
+    precedence: "project" | "core";
+}
+/** The track whose folder holds the file most closely, or the track at the repository root. */
+export declare function trackFor(config: PeerAiConfig, file: string): ConfigTrack | undefined;
+/** Returns undefined for a file outside the project. */
+export declare function standardsFor(config: PeerAiConfig, root: string, file: string): StandardsForFile | undefined;
+export {};

package/dist/standards.js

@@ -0,0 +1,130 @@
+// Which standards govern a file: Peer AI's rules for the kind of part it belongs to, at the
+// project's stage and with its traits, and the project's own documents and rules. An agent asks
+// for these before editing a file, instead of loading every rule on every turn.
+import { isAbsolute, relative } from "node:path";
+import { PROFILES, profileRulesFor, rulesFor } from "peer-ai-standards";
+import { DOMAIN_IDS } from "peer-ai-workflow";
+const normalise = (path) => path.replace(/^\.\//, "").replace(/\/+$/, "");
+/** The track whose folder holds the file most closely, or the track at the repository root. */
+export function trackFor(config, file) {
+    let best;
+    let bestLength = -1;
+    for (const track of config.tracks) {
+        if (track.status === "external")
+            continue;
+        const path = track.path === undefined ? "" : normalise(track.path);
+        const holds = path === "" || file === path || file.startsWith(`${path}/`);
+        if (holds && path.length > bestLength) {
+            best = track;
+            bestLength = path.length;
+        }
+    }
+    return best;
+}
+// The domains that matter for every file, and those added by the kind of part it belongs to.
+// Money, safety-critical and AI rules are always considered, and apply only with their traits.
+const EVERY_FILE = [
+    "code-quality",
+    "architecture",
+    "security",
+    "privacy-compliance",
+    "testing",
+    "money",
+    "safety-critical",
+    "ai-features",
+];
+// Apps call other services and can hold the only copy of a person's data, so reliability counts
+// for them too; its offline and real-time rules apply only with those traits.
+const UI = ["frontend", "design-accessibility", "performance", "reliability"];
+const SERVER = [
+    "backend",
+    "api-design",
+    "data",
+    "system-design",
+    "performance",
+    "reliability",
+    "operations",
+];
+const BY_KIND = {
+    web: UI,
+    desktop: UI,
+    extension: UI,
+    mobile: [...UI, "mobile"],
+    backend: SERVER,
+    data: ["data", "performance", "reliability"],
+    infrastructure: ["delivery", "operations", "reliability"],
+    library: ["api-design"],
+    cli: ["api-design", "reliability"],
+};
+/** The domains for a file: every domain when it belongs to no track or to a kind not listed. */
+function domainsFor(track) {
+    const extra = track === undefined ? undefined : BY_KIND[track.kind];
+    return extra === undefined ? [...DOMAIN_IDS] : [...new Set([...EVERY_FILE, ...extra])];
+}
+const WHOLE_PROJECT = new Set(PROFILES.filter((profile) => profile.stacks.length === 0).map((profile) => profile.id));
+/** Returns undefined for a file outside the project. */
+export function standardsFor(config, root, file) {
+    const path = normalise(isAbsolute(file) ? relative(root, file) : file);
+    if (path === ".." || path.startsWith("../") || isAbsolute(path))
+        return undefined;
+    const track = trackFor(config, path);
+    const standards = config.standards;
+    const documents = (standards?.documents ?? [])
+        .filter((doc) => doc.scope === undefined || (track !== undefined && doc.scope.includes(track.id)))
+        .map((doc) => ({ path: doc.path, role: doc.role }));
+    const stage = config.project.stage ?? "mvp";
+    const exceptions = standards?.exceptions ?? [];
+    const setAside = new Set(exceptions.map((exception) => exception.rule));
+    const traits = config.project.traits ?? [];
+    const domains = domainsFor(track);
+    const core = rulesFor({ stage, traits, domains }).map(({ id, title, rule, ask, check, severity }) => ({
+        id,
+        title,
+        rule,
+        ask,
+        check,
+        severity,
+    }));
+    const profiled = profileRulesFor({
+        listed: standards?.profiles ?? [],
+        stage,
+        traits,
+        overrides: standards?.overrides ?? {},
+        ...(track?.stack === undefined ? {} : { stack: track.stack }),
+        ...(track?.architecture === undefined ? {} : { architecture: track.architecture }),
+    })
+        // A profile with no stacks, such as the pipeline's, is about the project as a whole: its rules
+        // go with the pipeline's files in .github/, whichever part holds them, and with files outside
+        // every part, not with each part's code.
+        .filter((rule) => WHOLE_PROJECT.has(rule.profile)
+        ? track === undefined || path.startsWith(".github/")
+        : domains.includes(rule.domain))
+        .map(({ id, title, rule, ask, check, severity, carries, value }) => ({
+        id,
+        title,
+        rule,
+        ask,
+        check,
+        severity,
+        carries,
+        ...(value === undefined ? {} : { value }),
+    }));
+    const peerAiRules = [...core, ...profiled].filter((rule) => !setAside.has(rule.id));
+    return {
+        file: path,
+        stage,
+        peerAiRules,
+        setAside: exceptions.map((exception) => ({ rule: exception.rule, reason: exception.reason })),
+        ...(track === undefined
+            ? {}
+            : { track: { id: track.id, kind: track.kind, ...(track.path === undefined ? {} : { path: track.path }) } }),
+        core: standards?.core ?? true,
+        profiles: standards?.profiles ?? [],
+        documents,
+        rules: (config.rules ?? []).map((rule) => ({
+            path: rule.path,
+            ...(rule.description === undefined ? {} : { description: rule.description }),
+        })),
+        precedence: standards?.precedence ?? "project",
+    };
+}

package/dist/state.d.ts

@@ -0,0 +1,22 @@
+import { type ProjectMap, type WorkItem } from "peer-ai-workflow";
+import { type Assessment } from "./assess.ts";
+export declare const WORK_DIR = ".peer-ai/work";
+/** On failure, `error` completes a sentence that starts with the file's path. */
+export type Read<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** The project map, or undefined when there is none yet. */
+export declare function readMap(root: string): Read<ProjectMap> | undefined;
+export interface WorkItemFile {
+    /** The path from the project root, such as .peer-ai/work/SHOP-1.json. */
+    path: string;
+    item: Read<WorkItem>;
+}
+/** Every work item, sorted by file name. A file whose id doesn't match its name is an error. */
+export declare function readWorkItems(root: string): WorkItemFile[];
+/** Items whose status on the map differs from a fresh assessment, as "tests (missing → present)". */
+export declare function mapChanges(map: ProjectMap, assessment: Assessment): string[];

package/dist/state.js

@@ -0,0 +1,56 @@
+// Reads Peer AI's state files: the project map, and one file per work item. Problems are
+// returned, never thrown, so each command decides how serious they are.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, join } from "node:path";
+import { MAP_ITEM_IDS, validateMap, validateWorkItem } from "peer-ai-workflow";
+import { MAP_FILE } from "./assess.js";
+export const WORK_DIR = ".peer-ai/work";
+function readJson(path) {
+    try {
+        return { ok: true, value: JSON.parse(readFileSync(path, "utf8")) };
+    }
+    catch (error) {
+        return { ok: false, error: `is not valid JSON: ${error.message}` };
+    }
+}
+/** The project map, or undefined when there is none yet. */
+export function readMap(root) {
+    const path = join(root, MAP_FILE);
+    if (!existsSync(path))
+        return undefined;
+    const json = readJson(path);
+    if (!json.ok)
+        return json;
+    const result = validateMap(json.value);
+    return result.ok ? result : { ok: false, error: `is not valid: ${result.errors.join("; ")}` };
+}
+/** Every work item, sorted by file name. A file whose id doesn't match its name is an error. */
+export function readWorkItems(root) {
+    const dir = join(root, WORK_DIR);
+    if (statSync(dir, { throwIfNoEntry: false })?.isDirectory() !== true)
+        return [];
+    return readdirSync(dir)
+        .filter((file) => file.endsWith(".json"))
+        .sort()
+        .map((file) => {
+        const path = `${WORK_DIR}/${file}`;
+        const json = readJson(join(dir, file));
+        if (!json.ok)
+            return { path, item: json };
+        const result = validateWorkItem(json.value);
+        if (!result.ok)
+            return { path, item: { ok: false, error: `is not valid: ${result.errors.join("; ")}` } };
+        const id = basename(file, ".json");
+        if (result.value.id !== id) {
+            return {
+                path,
+                item: { ok: false, error: `has the id "${result.value.id}", but a work item's file is named after its id` },
+            };
+        }
+        return { path, item: result };
+    });
+}
+/** Items whose status on the map differs from a fresh assessment, as "tests (missing → present)". */
+export function mapChanges(map, assessment) {
+    return MAP_ITEM_IDS.filter((id) => map.items[id]?.status !== assessment.items[id].status).map((id) => `${id} (${map.items[id]?.status ?? "not recorded"} → ${assessment.items[id].status})`);
+}

package/dist/test-helpers.d.ts

@@ -0,0 +1,16 @@
+import type { Output } from "./init.ts";
+import { type Prompter } from "./prompter.ts";
+/** Creates a temporary project from a map of file paths to contents. A trailing "/" makes a folder. */
+export declare function project(files?: Record<string, string>, options?: {
+    gitRemote?: string;
+    git?: boolean;
+}): string;
+export declare function cleanUp(): void;
+export declare function capture(): Output & {
+    lines: string[];
+    text: () => string;
+};
+/** A prompter that gives scripted answers in order, or cancels when it reaches "CANCEL". */
+export declare function scripted(answers: unknown[]): Prompter & {
+    asked: string[];
+};

package/dist/test-helpers.js

@@ -0,0 +1,62 @@
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { Cancelled } from "./prompter.js";
+const created = [];
+/** Creates a temporary project from a map of file paths to contents. A trailing "/" makes a folder. */
+export function project(files = {}, options = {}) {
+    const root = mkdtempSync(join(tmpdir(), "peer-ai-"));
+    created.push(root);
+    for (const [path, content] of Object.entries(files)) {
+        if (path.endsWith("/")) {
+            mkdirSync(join(root, path), { recursive: true });
+            continue;
+        }
+        mkdirSync(dirname(join(root, path)), { recursive: true });
+        writeFileSync(join(root, path), content);
+    }
+    if (options.gitRemote !== undefined || options.git === true) {
+        execFileSync("git", ["init", "-q"], { cwd: root });
+        if (options.gitRemote !== undefined)
+            execFileSync("git", ["remote", "add", "origin", options.gitRemote], { cwd: root });
+    }
+    return root;
+}
+export function cleanUp() {
+    for (const root of created.splice(0))
+        rmSync(root, { recursive: true, force: true });
+}
+export function capture() {
+    const lines = [];
+    return {
+        lines,
+        log: (line) => lines.push(line),
+        error: (line) => lines.push(line),
+        text: () => lines.join("\n"),
+    };
+}
+/** A prompter that gives scripted answers in order, or cancels when it reaches "CANCEL". */
+export function scripted(answers) {
+    const queue = [...answers];
+    const asked = [];
+    const next = (message) => {
+        asked.push(message);
+        if (queue.length === 0)
+            throw new Error(`no scripted answer for: ${message}`);
+        const value = queue.shift();
+        if (value === "CANCEL")
+            throw new Cancelled();
+        return value;
+    };
+    return {
+        asked,
+        intro: () => undefined,
+        note: () => undefined,
+        outro: () => undefined,
+        text: (message) => Promise.resolve(next(message)),
+        select: (message) => Promise.resolve(next(message)),
+        multiselect: (message) => Promise.resolve(next(message)),
+        confirm: (message) => Promise.resolve(next(message)),
+    };
+}