peer-ai 1.0.0-next.0

package/dist/enforcers.js

@@ -0,0 +1,307 @@
+// Whether the stack profiles a project lists exist, and whether the tools that enforce their
+// automatic rules are set up (RFC 0006): ESLint using Peer AI's settings, and each TypeScript
+// part's tsconfig saying what the compiler rules need. An automatic rule nothing enforces is a
+// warning, and a failure at production.
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, normalize, posix } from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+import { parse as parseToml } from "smol-toml";
+import { parse as parseYaml } from "yaml";
+import { profile, profileRulesFor } from "peer-ai-standards";
+import { fail, ok, plural, warn } from "./checks.js";
+import { WORKFLOW_FILE, environmentAddresses, pipelineRules, sameFile, unchangedSinceRender, workflowFile, workflowJobs, writtenByRender, } from "./pipeline.js";
+import { RUFF_FILE, ruffFile } from "./ruff.js";
+const ESLINT_CONFIGS = ["js", "mjs", "cjs", "ts", "mts", "cts"].map((extension) => `eslint.config.${extension}`);
+const ESLINT_PACKAGE = "peer-ai-eslint-config";
+const list = (ids) => ids.join(", ");
+/** The profiles the config lists that Peer AI has no rules for yet. */
+export function checkProfiles(config) {
+    const listed = config.standards?.profiles ?? [];
+    if (listed.length === 0)
+        return [];
+    const unknown = listed.filter((id) => profile(id) === undefined);
+    if (unknown.length === 0)
+        return [ok("profiles", `Stack profiles: ${list(listed)}`)];
+    return [
+        warn("profiles", `Peer AI has no rules yet for ${list(unknown)}, so ${unknown.length === 1 ? "that profile adds" : "those profiles add"} nothing for now.`, "Keep it listed and its rules arrive with the profile, or check the id against the profiles in peer-ai-standards."),
+    ];
+}
+/** The automatic profile rules each part of the project gets, leaving out the ones it set aside. */
+function automaticRules(config) {
+    const setAside = new Set((config.standards?.exceptions ?? []).map((exception) => exception.rule));
+    return config.tracks
+        .filter((track) => track.status !== "external")
+        .map((track) => ({
+        track,
+        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 }),
+        }).filter((rule) => rule.check === "auto" && !setAside.has(rule.id)),
+    }));
+}
+/** The nearest ESLint config for a part, from its folder up to the root: ESLint looks for it the same way. */
+function eslintConfigFor(root, path) {
+    for (const folder of upFrom(path)) {
+        const found = ESLINT_CONFIGS.find((name) => existsSync(join(root, folder, name)));
+        if (found !== undefined)
+            return folder === "." ? found : join(folder, found);
+    }
+    return undefined;
+}
+/** The folders from a part's folder up to the root, nearest first. */
+function upFrom(path) {
+    const folders = [];
+    for (let folder = path === undefined ? "." : normalize(path);; folder = dirname(folder)) {
+        folders.push(folder);
+        if (folder === "." || dirname(folder) === folder)
+            break;
+    }
+    return folders;
+}
+const table = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+const strings = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+/** The Ruff settings in a file, or undefined when it isn't valid TOML or holds none. */
+function readRuff(root, file) {
+    let data;
+    try {
+        data = parseToml(readFileSync(join(root, file), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    const ruff = file.endsWith("pyproject.toml") ? table(table(data.tool)?.ruff) : data;
+    if (ruff === undefined)
+        return undefined;
+    const lint = table(ruff.lint) ?? {};
+    const extend = ruff.extend;
+    return {
+        ...(typeof extend === "string" ? { extend: posix.normalize(posix.join(posix.dirname(file), extend)) } : {}),
+        select: "select" in lint || "select" in ruff,
+        ignored: [lint.ignore, lint["extend-ignore"], ruff.ignore, ruff["extend-ignore"]].flatMap(strings),
+    };
+}
+/**
+ * The Ruff settings nearest a part, found as Ruff finds them: in each folder from the part's up,
+ * .ruff.toml, then ruff.toml, then a pyproject.toml with a tool.ruff table, such as [tool.ruff.lint].
+ */
+function ruffConfigFor(root, path) {
+    for (const folder of upFrom(path)) {
+        for (const name of [".ruff.toml", "ruff.toml", "pyproject.toml"]) {
+            const file = folder === "." ? name : posix.join(folder, name);
+            if (!existsSync(join(root, file)))
+                continue;
+            if (name !== "pyproject.toml" || readRuff(root, file) !== undefined)
+                return file;
+        }
+    }
+    return undefined;
+}
+/**
+ * The files a Ruff config reads, following each extend in turn: Ruff allows one per file, and the
+ * file it names can extend another. Stops at Peer AI's file, at a file it can't read, or at a loop.
+ */
+function ruffChain(root, file) {
+    const files = [];
+    const settings = [];
+    for (let current = file; current !== undefined && !files.includes(current);) {
+        files.push(current);
+        if (current === RUFF_FILE || !existsSync(join(root, current)))
+            break;
+        const read = readRuff(root, current);
+        settings.push(read);
+        current = read?.extend;
+    }
+    return { files, settings };
+}
+/** The jobs a workflow file defines, or none when it isn't valid YAML. */
+function jobsIn(content) {
+    try {
+        const parsed = parseYaml(content);
+        return Object.keys(table(table(parsed)?.jobs) ?? {});
+    }
+    catch {
+        return [];
+    }
+}
+/** A tsconfig's compiler options, read as TypeScript reads it: comments and trailing commas allowed. */
+function readTsconfig(root, path) {
+    const parsed = parseJsonc(readFileSync(join(root, path), "utf8"), [], { allowTrailingComma: true });
+    const config = (typeof parsed === "object" && parsed !== null ? parsed : {});
+    const references = (config.references ?? [])
+        .map((reference) => reference.path)
+        .filter((reference) => typeof reference === "string")
+        .map((reference) => {
+        const target = join(dirname(path), reference);
+        return target.endsWith(".json") ? target : join(target, "tsconfig.json");
+    })
+        .filter((target) => existsSync(join(root, target)));
+    return { options: config.compilerOptions ?? {}, references };
+}
+/**
+ * The tsconfig files that set a part's compiler options: its own, or, when it only points to
+ * others, as a solution file does, the ones it references.
+ */
+function tsconfigsFor(root, path, option) {
+    const { options, references } = readTsconfig(root, path);
+    return option in options || references.length === 0 ? [path] : references;
+}
+/** Each enforcing tool is set up to use Peer AI's settings. */
+export function checkEnforcers(root, config) {
+    const production = config.project.stage === "production";
+    const missing = (message, fix) => production ? fail("enforcers", message, fix) : warn("enforcers", message, fix);
+    const parts = automaticRules(config);
+    const checks = [];
+    // Each part is linted by its nearest ESLint config, so each config is checked for the rules of
+    // the parts it covers.
+    const byConfig = new Map();
+    for (const { track, rules } of parts) {
+        const linted = rules.filter((rule) => rule.enforcer?.tool === "eslint").map((rule) => rule.id);
+        if (linted.length === 0)
+            continue;
+        const file = eslintConfigFor(root, track.path);
+        byConfig.set(file, new Set([...(byConfig.get(file) ?? []), ...linted]));
+    }
+    const addIt = `import peerAi from "${ESLINT_PACKAGE}", and spread ...peerAi() into the settings it exports, before your own.`;
+    for (const [file, ids] of byConfig) {
+        const listed = list([...ids]);
+        if (file === undefined) {
+            checks.push(missing(`There's no ESLint config, so nothing enforces ${listed}.`, `Add eslint.config.js: ${addIt}`));
+        }
+        else if (!readFileSync(join(root, file), "utf8").includes(ESLINT_PACKAGE)) {
+            checks.push(missing(`${file} doesn't use Peer AI's settings, so nothing enforces ${listed}.`, `In ${file}, ${addIt}`));
+        }
+        else {
+            checks.push(ok("enforcers", `${file} uses Peer AI's settings for ${plural(ids.size, "rule")}`));
+        }
+    }
+    // Each Python part is linted by its nearest Ruff settings, which must reach the file render
+    // writes through extend, without a select that replaces its rules or an ignore that drops them.
+    const byRuffConfig = new Map();
+    for (const { track, rules } of parts) {
+        const ruffRules = rules.filter((rule) => rule.enforcer?.tool === "ruff");
+        if (ruffRules.length === 0)
+            continue;
+        const file = ruffConfigFor(root, track.path);
+        const folder = track.path ?? ".";
+        const key = file ?? `none:${folder}`;
+        const entry = byRuffConfig.get(key) ?? { ...(file === undefined ? {} : { file }), folder, rules: [] };
+        for (const rule of ruffRules)
+            if (!entry.rules.some((known) => known.id === rule.id))
+                entry.rules.push(rule);
+        byRuffConfig.set(key, entry);
+    }
+    if (byRuffConfig.size > 0) {
+        const current = existsSync(join(root, RUFF_FILE)) ? readFileSync(join(root, RUFF_FILE), "utf8") : undefined;
+        if (current === undefined) {
+            checks.push(missing(`${RUFF_FILE} isn't there, so Ruff has no Peer AI settings to extend.`, "Run peer-ai render."));
+        }
+        else if (current !== ruffFile(config)) {
+            checks.push(missing(`${RUFF_FILE} is out of date with the config.`, "Run peer-ai render."));
+        }
+    }
+    const extendLine = (from) => `extend = "${posix.relative(from, RUFF_FILE)}"`;
+    for (const { file, folder, rules } of byRuffConfig.values()) {
+        const listed = list(rules.map((rule) => rule.id));
+        if (file === undefined) {
+            checks.push(missing(`There are no Ruff settings for ${folder}, so nothing enforces ${listed}.`, `Add [tool.ruff] to ${posix.join(folder, "pyproject.toml")}, with ${extendLine(folder)}.`));
+            continue;
+        }
+        const chain = ruffChain(root, file);
+        const unreadable = chain.files.find((_, i) => i < chain.settings.length && chain.settings[i] === undefined);
+        if (unreadable !== undefined) {
+            checks.push(missing(`${unreadable} can't be read as Ruff settings, so Ruff won't run.`, `Fix the TOML in ${unreadable}.`));
+            continue;
+        }
+        if (!chain.files.includes(RUFF_FILE)) {
+            const last = chain.files.at(-1) ?? file;
+            const table = last.endsWith("pyproject.toml") ? ", under [tool.ruff]," : "";
+            const where = last === file
+                ? `In ${file}${table}`
+                : `${file} extends ${last}, which extends nothing further. In ${last}${table}`;
+            checks.push(missing(`${file} doesn't extend Peer AI's Ruff settings, so nothing enforces ${listed}.`, `${where} add ${extendLine(posix.dirname(last))}. Ruff allows one extend in each file.`));
+            continue;
+        }
+        const before = chain.settings.filter((read) => read !== undefined);
+        const selecting = chain.files.filter((_, i) => before[i]?.select === true);
+        if (selecting.length > 0) {
+            checks.push(missing(`${list(selecting)} ${selecting.length === 1 ? "sets" : "set"} select, which replaces Peer AI's Ruff rules instead of adding to them, so nothing enforces ${listed}.`, `In ${list(selecting)}, rename select to extend-select.`));
+            continue;
+        }
+        const ignored = before.flatMap((read) => read.ignored);
+        const dropped = rules.filter((rule) => {
+            const code = rule.enforcer?.tool === "ruff" ? rule.enforcer.rule : "";
+            return ignored.some((entry) => entry === "ALL" || code.startsWith(entry));
+        });
+        if (dropped.length > 0) {
+            checks.push(missing(`${file}'s Ruff settings ignore the codes of ${list(dropped.map((rule) => rule.id))}, which switches them off without a recorded reason.`, "Take those codes out of ignore, and set any rule that doesn't fit aside in standards.exceptions, with the reason."));
+            continue;
+        }
+        checks.push(ok("enforcers", `${file} extends Peer AI's Ruff settings for ${plural(rules.length, "rule")}`));
+    }
+    // The pipeline's checks run from the workflow render writes.
+    const pipeline = pipelineRules(config);
+    const existing = existsSync(join(root, WORKFLOW_FILE)) ? readFileSync(join(root, WORKFLOW_FILE), "utf8") : undefined;
+    const expected = workflowFile(config);
+    if (expected === undefined) {
+        if (existing !== undefined && writtenByRender(existing)) {
+            checks.push(warn("enforcers", `${WORKFLOW_FILE} is still there, but the config asks for none of its checks, so render no longer updates it.`, "Delete it, or list the github-actions profile in standards.profiles."));
+        }
+    }
+    else {
+        const ids = list(pipeline.filter((rule) => rule.check === "auto").map((rule) => rule.id));
+        if (existing === undefined) {
+            checks.push(missing(`${WORKFLOW_FILE} isn't there, so the pipeline doesn't run ${ids}.`, "Run peer-ai render."));
+        }
+        else if (unchangedSinceRender(existing)) {
+            if (sameFile(existing, expected))
+                checks.push(ok("enforcers", `${WORKFLOW_FILE} runs ${ids}`));
+            else
+                checks.push(missing(`${WORKFLOW_FILE} is out of date with the config.`, "Run peer-ai render."));
+        }
+        else {
+            // Changed by hand: the jobs Peer AI's would have must still be there, under their names.
+            const found = jobsIn(existing);
+            const gone = workflowJobs(config).filter((job) => !found.includes(job));
+            checks.push(gone.length === 0
+                ? warn("enforcers", `${WORKFLOW_FILE} was changed by hand. It still has every job, but doctor can't tell whether each still runs its check.`, "Keep it up to date with the config yourself, or delete it and run peer-ai render to go back to Peer AI's.")
+                : missing(`${WORKFLOW_FILE} was changed by hand, and no longer has the ${gone.join(", ")} ${gone.length === 1 ? "job" : "jobs"}.`, "Add them back, or delete the file and run peer-ai render to go back to Peer AI's."));
+        }
+        const unusable = environmentAddresses(config).unusable;
+        if (unusable.length > 0 && pipeline.some((rule) => rule.id === "GHA-06" || rule.id === "GHA-07")) {
+            checks.push(warn("enforcers", `The pipeline leaves out ${list(unusable.map((environment) => `${environment.id} (${environment.url})`))}: an address must be a full http or https URL, without a user name or password.`, "Correct the url in the environments of peer-ai.config.json."));
+        }
+    }
+    for (const { track, rules } of parts) {
+        const compiled = rules.filter((rule) => rule.enforcer?.tool === "typescript");
+        if (compiled.length === 0)
+            continue;
+        const path = [track.path, undefined]
+            .map((folder) => (folder === undefined ? "tsconfig.json" : join(folder, "tsconfig.json")))
+            .find((candidate) => existsSync(join(root, candidate)));
+        if (path === undefined) {
+            checks.push(missing(`${track.id} has no tsconfig.json, so the compiler doesn't enforce ${list(compiled.map((r) => r.id))}.`, `Add a tsconfig.json to ${track.path ?? "the repository"} that turns on what they need.`));
+            continue;
+        }
+        for (const rule of compiled) {
+            if (rule.enforcer?.tool !== "typescript")
+                continue;
+            const { option, value } = rule.enforcer;
+            for (const file of tsconfigsFor(root, path, option)) {
+                const set = readTsconfig(root, file).options[option];
+                const wanted = JSON.stringify(value);
+                if (set === value) {
+                    checks.push(ok("enforcers", `${file} sets ${option} to ${wanted} (${rule.id})`));
+                    continue;
+                }
+                checks.push(missing(set === undefined
+                    ? `${file} doesn't say "${option}": ${wanted}, which ${rule.id} needs.`
+                    : `${file} sets "${option}" to ${JSON.stringify(set)}, but ${rule.id} needs ${wanted}.`, `Set "${option}": ${wanted} in the compilerOptions of ${file}, in the file itself, so it holds whatever it extends.`));
+            }
+        }
+    }
+    return checks;
+}

package/dist/feedback.d.ts

@@ -0,0 +1,67 @@
+import type { PeerAiConfig } from "peer-ai-workflow";
+import type { Output } from "./init.ts";
+import type { Result } from "./work.ts";
+export declare const FEEDBACK_DIR = ".peer-ai/feedback";
+/** Where reports go. */
+export declare const FEEDBACK_REPO = "AbuMahir980/peer-ai";
+export interface FeedbackInput {
+    /** One line, such as "security-review flagged a test file as production code". */
+    title: string;
+    /** What happened, in plain words. */
+    what: string;
+    /** What should have happened. */
+    expected: string;
+    /** The skill involved, when there is one. */
+    skill?: string | undefined;
+    /** The command or tool involved, when there is one. */
+    command?: string | undefined;
+}
+/** What Peer AI knows itself, and adds to every report. */
+export interface FeedbackContext {
+    /** The AI tool, as it named itself when it connected. */
+    tool?: string;
+    node?: string;
+    os?: string;
+}
+/** Why a draft can't be written as it is: empty when it can. */
+export declare function draftProblems(input: FeedbackInput): string[];
+/** The report as a person reads it and as the issue shows it. */
+export declare function formatReport(input: FeedbackInput, config: PeerAiConfig | undefined, context: FeedbackContext): string;
+/** Writes a draft to .peer-ai/feedback/, or refuses it with what to take out. */
+export declare function draftFeedback(root: string, config: PeerAiConfig | undefined, input: FeedbackInput, context: FeedbackContext, now: Date): Result<{
+    draft: string;
+}>;
+export interface Draft {
+    file: string;
+    title: string;
+}
+/** The drafts waiting for a person's decision, oldest first. */
+export declare function listDrafts(root: string): Draft[];
+/** Runs a command and returns what it printed, or undefined when it failed. */
+export type Runner = (command: string, args: string[]) => string | undefined;
+export declare const runQuietly: Runner;
+/** A link that opens a new issue with the report filled in, for a person to submit. */
+export declare function issueLink(title: string, body: string): string;
+export type Sent = {
+    issue: string;
+} | {
+    link: string;
+};
+/**
+ * Opens a draft as an issue on Peer AI's repository, through the GitHub CLI when it's signed in,
+ * under the person's own account, then moves the draft to sent/. Without the CLI, returns a link
+ * for the person to open and submit, and keeps the draft.
+ */
+export declare function sendDraft(root: string, draft: string, run?: Runner): Result<Sent>;
+/** Deletes a draft the person decided not to send. */
+export declare function dropDraft(root: string, draft: string): Result<{
+    dropped: string;
+}>;
+export interface FeedbackOptions {
+    cwd: string;
+    action?: string | undefined;
+    draft?: string | undefined;
+    run?: Runner;
+}
+/** `peer-ai feedback [send|drop <draft>]`. Exit code 0 done, 1 refused, 2 a usage error. */
+export declare function runFeedback(options: FeedbackOptions, out: Output): number;

package/dist/feedback.js

@@ -0,0 +1,209 @@
+// The feedback route (RFC 0007). When Peer AI gets something wrong in a project, the AI tool drafts
+// a report with the draft_feedback tool, and a person decides whether it's sent: `peer-ai feedback`
+// lists the drafts, `send` opens one as an issue on Peer AI's repository, `drop` deletes it. A
+// report leaves the machine only when a person has read it and said yes.
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { arch, platform } from "node:os";
+import { basename, join } from "node:path";
+import { VERSION } from "./package-info.js";
+export const FEEDBACK_DIR = ".peer-ai/feedback";
+const SENT_DIR = join(FEEDBACK_DIR, "sent");
+/** Where reports go. */
+export const FEEDBACK_REPO = "AbuMahir980/peer-ai";
+/**
+ * What a report must never hold, with what to do instead. Project code, secrets and people's
+ * details stay out of a report that becomes a public issue.
+ */
+const NEVER = [
+    { pattern: /```|~~~/, problem: "It holds a block of code. Describe what the code does in words instead." },
+    {
+        pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk|pk|rk)_(?:live|test)_[A-Za-z0-9]{8,}|\bgh[pousr]_[A-Za-z0-9]{20,}|\bgithub_pat_[A-Za-z0-9_]{20,}|\bAKIA[0-9A-Z]{16}\b|\bxox[abprs]-[A-Za-z0-9-]{10,}|\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}|[A-Za-z0-9+/_=-]{40,}/,
+        problem: "It holds something that looks like a key or a token. Take it out.",
+    },
+    {
+        pattern: /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/,
+        problem: "It holds an email address. Take it out, and any other detail about a person.",
+    },
+];
+/** Why a draft can't be written as it is: empty when it can. */
+export function draftProblems(input) {
+    const text = [input.title, input.what, input.expected, input.skill ?? "", input.command ?? ""].join("\n");
+    const problems = NEVER.filter(({ pattern }) => pattern.test(text)).map(({ problem }) => problem);
+    if (input.title.includes("\n"))
+        problems.push("The title is more than one line.");
+    return problems;
+}
+const slug = (title) => title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 50)
+    .replace(/-$/, "") || "feedback";
+/** The report as a person reads it and as the issue shows it. */
+export function formatReport(input, config, context) {
+    const facts = [
+        ["Peer AI", VERSION],
+        ["AI tool", context.tool],
+        ["Skill", input.skill],
+        ["Command or tool", input.command],
+        ["Operating system", context.os ?? `${platform()} ${arch()}`],
+        ["Node", context.node ?? process.versions.node],
+        ["Stage", config?.project.stage],
+        ["Stack profiles", config?.standards?.profiles?.join(", ")],
+    ];
+    return [
+        `# ${input.title.trim()}`,
+        "",
+        "## What happened",
+        "",
+        input.what.trim(),
+        "",
+        "## What should have happened",
+        "",
+        input.expected.trim(),
+        "",
+        "## Where",
+        "",
+        "| | |",
+        "|-|-|",
+        ...facts.flatMap(([name, value]) => (value === undefined || value === "" ? [] : [`| ${name} | ${value} |`])),
+        "",
+        "Drafted by an AI tool with Peer AI's draft_feedback, and sent by a person who read it.",
+        "",
+    ].join("\n");
+}
+/** Writes a draft to .peer-ai/feedback/, or refuses it with what to take out. */
+export function draftFeedback(root, config, input, context, now) {
+    const problems = draftProblems(input);
+    if (problems.length > 0) {
+        return {
+            ok: false,
+            error: `Peer AI won't write this draft, since a report may become public. ${problems.join(" ")}`,
+        };
+    }
+    const dir = join(root, FEEDBACK_DIR);
+    mkdirSync(dir, { recursive: true });
+    const stem = `${now.toISOString().slice(0, 10)}-${slug(input.title)}`;
+    let name = `${stem}.md`;
+    for (let n = 2; existsSync(join(dir, name)); n++)
+        name = `${stem}-${String(n)}.md`;
+    writeFileSync(join(dir, name), formatReport(input, config, context));
+    return { ok: true, value: { draft: join(FEEDBACK_DIR, name) } };
+}
+/** The drafts waiting for a person's decision, oldest first. */
+export function listDrafts(root) {
+    const dir = join(root, FEEDBACK_DIR);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((file) => file.endsWith(".md"))
+        .sort()
+        .map((file) => ({
+        file,
+        title: /^# (.+)$/m.exec(readFileSync(join(dir, file), "utf8"))?.[1] ?? file,
+    }));
+}
+/** A draft by its file name or its path, never a file outside the drafts folder. */
+function findDraft(root, draft) {
+    const file = basename(draft);
+    const path = join(root, FEEDBACK_DIR, file);
+    if (!file.endsWith(".md") || !existsSync(path)) {
+        const waiting = listDrafts(root).map((d) => d.file);
+        return {
+            ok: false,
+            error: `There's no draft ${file}.${waiting.length === 0 ? " No drafts are waiting." : ` Waiting: ${waiting.join(", ")}.`}`,
+        };
+    }
+    return { ok: true, value: path };
+}
+export const runQuietly = (command, args) => {
+    try {
+        return execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    }
+    catch {
+        return undefined;
+    }
+};
+/** A link that opens a new issue with the report filled in, for a person to submit. */
+export function issueLink(title, body) {
+    const params = new URLSearchParams({ title, body, labels: "feedback" });
+    return `https://github.com/${FEEDBACK_REPO}/issues/new?${params.toString()}`;
+}
+/**
+ * Opens a draft as an issue on Peer AI's repository, through the GitHub CLI when it's signed in,
+ * under the person's own account, then moves the draft to sent/. Without the CLI, returns a link
+ * for the person to open and submit, and keeps the draft.
+ */
+export function sendDraft(root, draft, run = runQuietly) {
+    const found = findDraft(root, draft);
+    if (!found.ok)
+        return found;
+    const report = readFileSync(found.value, "utf8");
+    const title = /^# (.+)$/m.exec(report)?.[1] ?? basename(found.value, ".md");
+    const body = report.replace(/^# .+\n+/, "");
+    if (run("gh", ["auth", "status"]) !== undefined) {
+        const create = ["issue", "create", "--repo", FEEDBACK_REPO, "--title", title, "--body", body];
+        // The label helps the maintainer sort reports; an issue without it is still a report.
+        const printed = run("gh", [...create, "--label", "feedback"]) ?? run("gh", create);
+        const issue = printed?.trim().split("\n").at(-1);
+        if (issue?.startsWith("https://") === true) {
+            mkdirSync(join(root, SENT_DIR), { recursive: true });
+            writeFileSync(found.value, `${report.trimEnd()}\n\nSent as ${issue}\n`);
+            renameSync(found.value, join(root, SENT_DIR, basename(found.value)));
+            return { ok: true, value: { issue } };
+        }
+    }
+    return { ok: true, value: { link: issueLink(title, body) } };
+}
+/** Deletes a draft the person decided not to send. */
+export function dropDraft(root, draft) {
+    const found = findDraft(root, draft);
+    if (!found.ok)
+        return found;
+    rmSync(found.value);
+    return { ok: true, value: { dropped: basename(found.value) } };
+}
+/** `peer-ai feedback [send|drop <draft>]`. Exit code 0 done, 1 refused, 2 a usage error. */
+export function runFeedback(options, out) {
+    const { cwd, action, draft } = options;
+    if (action === undefined) {
+        const drafts = listDrafts(cwd);
+        if (drafts.length === 0) {
+            out.log("No feedback drafts are waiting.");
+            return 0;
+        }
+        out.log(`Feedback drafts waiting for your decision, in ${FEEDBACK_DIR}/:`);
+        for (const { file, title } of drafts)
+            out.log(`  ${file}: ${title}`);
+        out.log("");
+        out.log("Read one, then run peer-ai feedback send <draft> or peer-ai feedback drop <draft>.");
+        return 0;
+    }
+    if ((action !== "send" && action !== "drop") || draft === undefined) {
+        out.error("Use peer-ai feedback, peer-ai feedback send <draft> or peer-ai feedback drop <draft>.");
+        return 2;
+    }
+    if (action === "drop") {
+        const dropped = dropDraft(cwd, draft);
+        if (!dropped.ok) {
+            out.error(dropped.error);
+            return 1;
+        }
+        out.log(`Dropped ${dropped.value.dropped}.`);
+        return 0;
+    }
+    const sent = sendDraft(cwd, draft, options.run);
+    if (!sent.ok) {
+        out.error(sent.error);
+        return 1;
+    }
+    if ("issue" in sent.value)
+        out.log(`Sent: ${sent.value.issue}`);
+    else {
+        out.log("The GitHub CLI isn't signed in here, so open this link to submit the report yourself:");
+        out.log(sent.value.link);
+        out.log(`Once it's submitted, run peer-ai feedback drop ${basename(draft)}.`);
+    }
+    return 0;
+}

package/dist/files.d.ts

@@ -0,0 +1 @@
+export declare function listRepoFiles(root: string): string[];

package/dist/files.js

@@ -0,0 +1,72 @@
+// Lists a repository's files as forward-slash paths relative to its root. In a git repository
+// it asks git, so .gitignore is respected; otherwise it walks the folder. Dependency and build
+// folders are always skipped, as are Peer AI's own rendered skills, and symlinks are never followed.
+import { execFileSync } from "node:child_process";
+import { existsSync, lstatSync, readdirSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+const SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".nuxt",
+    ".turbo",
+    ".expo",
+    "coverage",
+    "vendor",
+    "Pods",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".dart_tool",
+    ".gradle",
+    "target",
+    "obj",
+    ".build",
+    "_build",
+]);
+const MAX_FILES = 50_000;
+/** Peer AI's own skills, wherever render wrote them. They describe Peer AI, not the project. */
+const PEER_AI_SKILL = /(^|\/)\.(claude|agents)\/skills\/peer-ai-[^/]+\//;
+const skipped = (path) => path.split("/").some((part) => SKIP_DIRS.has(part)) || PEER_AI_SKILL.test(path);
+export function listRepoFiles(root) {
+    if (existsSync(join(root, ".git"))) {
+        try {
+            const listed = execFileSync("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+                cwd: root,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "pipe"],
+                maxBuffer: 256 * 1024 * 1024,
+            });
+            return listed
+                .split("\0")
+                .filter((file) => file !== "" && !skipped(file))
+                .slice(0, MAX_FILES);
+        }
+        catch {
+            // Not usable as a git repository after all: fall back to walking the folder.
+        }
+    }
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir).sort()) {
+            if (files.length >= MAX_FILES)
+                return;
+            if (SKIP_DIRS.has(entry))
+                continue;
+            const full = join(dir, entry);
+            const stats = lstatSync(full);
+            if (stats.isDirectory())
+                walk(full);
+            else if (stats.isFile()) {
+                const path = relative(root, full).split(sep).join("/");
+                if (!skipped(path))
+                    files.push(path);
+            }
+        }
+    };
+    walk(root);
+    return files;
+}