peer-ai 1.0.0-next.0

package/dist/init.d.ts

@@ -0,0 +1,31 @@
+import { type ToolId } from "peer-ai-workflow";
+import { type Detected, type DetectedTrack } from "./detect.ts";
+import { type Prompter } from "./prompter.ts";
+export declare const SCHEMA_URL = "https://raw.githubusercontent.com/AbuMahir980/peer-ai/main/packages/workflow/schemas/config.schema.json";
+export type Stage = "prototype" | "mvp" | "production";
+export type Team = "solo" | "team";
+export interface InitOptions {
+    cwd: string;
+    yes: boolean;
+    dryRun: boolean;
+    name?: string;
+    stage?: Stage;
+    team?: Team;
+    tools?: ToolId[];
+}
+export interface Output {
+    log: (line: string) => void;
+    error: (line: string) => void;
+}
+interface Answers {
+    name: string;
+    description: string;
+    tracks: DetectedTrack[];
+    team: Team;
+    stage: Stage;
+    tools: ToolId[];
+}
+export declare function describeTrack(track: DetectedTrack): string;
+export declare function buildConfig(detected: Detected, answers: Answers): Record<string, unknown>;
+export declare function runInit(options: InitOptions, prompter: Prompter | undefined, out: Output): Promise<number>;
+export {};

package/dist/init.js

@@ -0,0 +1,158 @@
+// peer-ai init: works out what it can from the repository, asks about the rest, and writes
+// peer-ai.config.json. It never overwrites an existing config, and it never assumes a stack:
+// a project with nothing to detect gets a track of kind "other" until the user decides.
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { TOOL_IDS, validateConfig } from "peer-ai-workflow";
+import { CONFIG_FILE, detect } from "./detect.js";
+import { Cancelled } from "./prompter.js";
+export const SCHEMA_URL = "https://raw.githubusercontent.com/AbuMahir980/peer-ai/main/packages/workflow/schemas/config.schema.json";
+const UNDECIDED_TRACK = { id: "app", kind: "other", stack: [] };
+const KIND_CHOICES = [
+    { value: "web", label: "A web app" },
+    { value: "mobile", label: "A mobile app" },
+    { value: "backend", label: "A backend or API" },
+    { value: "desktop", label: "A desktop app" },
+    { value: "cli", label: "A command-line tool" },
+    { value: "library", label: "A library or SDK" },
+    { value: "other", label: "Not decided yet" },
+];
+const STAGE_CHOICES = [
+    { value: "prototype", label: "Prototype", hint: "trying an idea; only the essentials are checked" },
+    { value: "mvp", label: "MVP", hint: "real users soon; critical paths are tested" },
+    { value: "production", label: "Production", hint: "live; everything is checked" },
+];
+const TOOL_LABELS = {
+    "claude-code": "Claude Code",
+    codex: "Codex",
+    cursor: "Cursor",
+    copilot: "GitHub Copilot",
+    "gemini-cli": "Gemini CLI",
+    other: "Another tool",
+};
+export function describeTrack(track) {
+    const where = track.path ?? "repository root";
+    const stack = track.stack.length === 0 ? "" : `: ${track.stack.join(", ")}`;
+    const deploy = track.deploy === undefined ? "" : `, deploys to ${track.deploy}`;
+    return `${track.id} (${track.kind}, ${where}${stack}${deploy})`;
+}
+function parseStack(text) {
+    return text
+        .split(/[,\s]+/)
+        .map((part) => part.trim().toLowerCase())
+        .filter((part) => part !== "");
+}
+async function ask(detected, prompter) {
+    prompter.intro("peer-ai init");
+    if (detected.tracks.length > 0) {
+        prompter.note(detected.tracks.map(describeTrack).join("\n"), "Found in this repository");
+    }
+    const name = await prompter.text("What are you building? Give it a name.", {
+        initial: detected.name,
+        required: true,
+    });
+    const description = await prompter.text("Describe it in one line. Optional.", {
+        initial: detected.description ?? "",
+    });
+    let tracks = detected.tracks;
+    if (tracks.length > 0 && !(await prompter.confirm("Use the parts found above?", true)))
+        tracks = [];
+    if (tracks.length === 0) {
+        const kind = await prompter.select("What kind of thing is it?", KIND_CHOICES);
+        const stack = await prompter.text("Which stack? For example: typescript, react. Leave empty to decide later.", {
+            placeholder: "decide later",
+        });
+        tracks = [{ id: "app", kind, stack: parseStack(stack) }];
+    }
+    const team = await prompter.select("Who's working on it?", [
+        { value: "solo", label: "Just me" },
+        { value: "team", label: "A team" },
+    ], "solo");
+    const stage = await prompter.select("What stage is it at?", STAGE_CHOICES, "mvp");
+    let tools = detected.tools;
+    if (tools.length === 0) {
+        tools = await prompter.multiselect("Which AI tools do you use?", TOOL_IDS.map((id) => ({ value: id, label: TOOL_LABELS[id] })));
+    }
+    return { name, description, tracks, team, stage, tools };
+}
+function defaults(detected, options) {
+    return {
+        name: options.name ?? detected.name,
+        description: detected.description ?? "",
+        tracks: detected.tracks.length > 0 ? detected.tracks : [UNDECIDED_TRACK],
+        team: options.team ?? "solo",
+        stage: options.stage ?? "mvp",
+        tools: options.tools ?? detected.tools,
+    };
+}
+export function buildConfig(detected, answers) {
+    return {
+        $schema: SCHEMA_URL,
+        version: 1,
+        project: {
+            name: answers.name,
+            ...(answers.description === "" ? {} : { description: answers.description }),
+            stage: answers.stage,
+            origin: detected.origin,
+            team: answers.team,
+        },
+        ...(answers.tools.length === 0 ? {} : { tools: answers.tools }),
+        tracks: answers.tracks.map((track) => ({
+            id: track.id,
+            kind: track.kind,
+            ...(track.path === undefined ? {} : { path: track.path }),
+            ...(track.stack.length === 0 ? {} : { stack: track.stack }),
+            ...(track.deploy === undefined ? {} : { deploy: { target: track.deploy } }),
+            status: "active",
+            ...(track.kind === "other" && track.stack.length === 0
+                ? { note: "Set the kind and stack once they are decided." }
+                : {}),
+        })),
+        repo: { ...(detected.repo.host === undefined ? {} : { host: detected.repo.host }), remote: detected.repo.remote },
+        ...(detected.delivery === undefined ? {} : { delivery: detected.delivery }),
+    };
+}
+export async function runInit(options, prompter, out) {
+    const detected = detect(options.cwd);
+    if (detected.hasConfig) {
+        out.error(`${CONFIG_FILE} already exists. init never overwrites it: edit it, or delete it and run init again.`);
+        return 1;
+    }
+    if (!options.yes && prompter === undefined) {
+        out.error("init asks a few questions, so it needs a terminal. To accept what it detects instead, pass --yes.");
+        return 2;
+    }
+    let answers;
+    try {
+        answers = options.yes || prompter === undefined ? defaults(detected, options) : await ask(detected, prompter);
+    }
+    catch (error) {
+        if (error instanceof Cancelled) {
+            out.error("Cancelled. Nothing was written.");
+            return 1;
+        }
+        throw error;
+    }
+    const config = buildConfig(detected, answers);
+    const result = validateConfig(config);
+    if (!result.ok) {
+        out.error("The config init built is not valid. This is a bug in peer-ai; please report it with these details:");
+        for (const error of result.errors)
+            out.error(`  ${error}`);
+        return 2;
+    }
+    const json = `${JSON.stringify(config, null, 2)}\n`;
+    if (options.dryRun) {
+        out.log(json.trimEnd());
+        return 0;
+    }
+    writeFileSync(join(options.cwd, CONFIG_FILE), json, { flag: "wx" });
+    const summary = `Wrote ${CONFIG_FILE}: ${String(answers.tracks.length)} ${answers.tracks.length === 1 ? "part" : "parts"}, ${answers.stage} stage.`;
+    if (prompter !== undefined && !options.yes)
+        prompter.outro(summary);
+    else
+        out.log(summary);
+    out.log("Edit it any time. Your editor checks it against the schema as you type.");
+    out.log("Next: peer-ai assess to map the project, then peer-ai render to set up your AI tools.");
+    return 0;
+}

package/dist/mcp.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type CommandRunner } from "./work.ts";
+export interface ServerOptions {
+    /** Where the AI tool started the server: the project's folder or one inside it. */
+    cwd: string;
+    now?: () => Date;
+    run?: CommandRunner;
+}
+/** The nearest folder at or above `start` with a config, or `start` itself when there is none. */
+export declare function findRoot(start: string): string;
+export declare function createServer(options: ServerOptions): McpServer;
+/** Serves over stdio until the AI tool closes the connection. Nothing else may write to stdout. */
+export declare function serveStdio(cwd: string): Promise<void>;

package/dist/mcp.js

@@ -0,0 +1,247 @@
+// The Peer AI MCP server. Every AI tool that speaks the Model Context Protocol reaches the same
+// project map, work items and gates through it, so a project behaves the same whichever tool a
+// person uses. It runs over stdio from the project's folder: `peer-ai mcp`.
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ACTIVITY_IDS, MapItemIdSchema, SKILL_IDS, WorkItemSchema } from "peer-ai-workflow";
+import { z } from "zod";
+import { NEXT_STAGE, assess, gaps, loadConfig } from "./assess.js";
+import { CONFIG_FILE } from "./detect.js";
+import { checkDocumentFile } from "./document.js";
+import { draftFeedback } from "./feedback.js";
+import { VERSION } from "./package-info.js";
+import { standardsFor } from "./standards.js";
+import { mapChanges, readMap } from "./state.js";
+import { advanceWorkItem, checkReport, createWorkItem, nextWork, recordReview, runCommand, runVerify, updateWorkItem, } from "./work.js";
+const INSTRUCTIONS = `Peer AI keeps this project's map, its work items and the gates work must pass.
+Start a session with next_work: it returns the work item for the current git branch and where it stopped.
+Before editing a file, call standards_for_file and follow what it returns.
+Record progress with update_work_item. Run verification with run_verify rather than reporting a result yourself.
+Record each review with record_review, passing the path of its report, including failed and incomplete reviews.
+Check each document a Peer AI skill writes with check_document, and fix what it names.
+Move work with advance_work_item: build before changing code, verify once the change is complete, ship when it is verified, reviewed and ready to merge, done once merged or released.
+Moving to ship or done passes the same gates as CI; when it refuses, fix what it lists.
+When next_work reports setup problems, fix what you can, such as running npx peer-ai render, before other work, and tell the person in plain words about anything only they can decide.
+When Peer AI gets something wrong, call draft_feedback. At a natural stopping point, show the person each draft in a few words and ask whether to send it.`;
+/** The nearest folder at or above `start` with a config, or `start` itself when there is none. */
+export function findRoot(start) {
+    let dir = start;
+    for (;;) {
+        if (existsSync(join(dir, CONFIG_FILE)))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return start;
+        dir = parent;
+    }
+}
+const reply = (value) => ({
+    content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
+});
+const refuse = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+const fromResult = (result) => (result.ok ? reply(result.value) : refuse(result.error));
+const READ_ONLY = { readOnlyHint: true, openWorldHint: false };
+const WRITES = { readOnlyHint: false, destructiveHint: false, openWorldHint: false };
+const itemId = z.string().min(1).describe("The work item's id, such as ITEM-3 or PROJ-14.");
+export function createServer(options) {
+    const now = options.now ?? (() => new Date());
+    const run = options.run ?? runCommand;
+    const server = new McpServer({ name: "peer-ai", version: VERSION }, { instructions: INSTRUCTIONS });
+    /** Every tool works from the project's config; without one it says how to create it. */
+    const withProject = (handle) => (args) => {
+        const root = findRoot(options.cwd);
+        const { config, errors } = loadConfig(root);
+        if (config !== undefined)
+            return handle(root, config, args);
+        return refuse(errors === undefined
+            ? `There is no ${CONFIG_FILE} in ${root} or above it. Run npx peer-ai init in the project first.`
+            : `${CONFIG_FILE} is not valid:\n${errors.map((error) => `- ${error}`).join("\n")}`);
+    };
+    server.registerTool("project_map", {
+        title: "Project map",
+        description: "Where the project stands: each item on the map (requirements, architecture, API contract, tests, CI, infrastructure and more) as present, partial, missing or not applicable, with the files that prove it; what the project's stage still needs; and compliance signals such as personal data found in the schema.",
+        annotations: READ_ONLY,
+    }, withProject((root, config) => {
+        const stage = config.project.stage ?? "mvp";
+        const assessment = assess(root, config, stage);
+        const next = NEXT_STAGE[stage];
+        const needed = gaps(assessment, stage);
+        const stored = readMap(root);
+        return reply({
+            project: assessment.name,
+            stage,
+            items: assessment.items,
+            neededFor: { [stage]: needed },
+            ...(next === undefined
+                ? {}
+                : { laterFor: { [next]: gaps(assessment, next).filter((id) => !needed.includes(id)) } }),
+            signals: assessment.signals,
+            suggestedTraits: assessment.suggestedTraits,
+            suggestedProfiles: assessment.suggestedProfiles,
+            suggestedStacks: assessment.suggestedStacks,
+            storedMap: stored === undefined
+                ? "There is no .peer-ai/map.json yet. Run npx peer-ai assess to write it."
+                : stored.ok
+                    ? { assessedAt: stored.value.assessedAt, changedSince: mapChanges(stored.value, assessment) }
+                    : `.peer-ai/map.json ${stored.error}`,
+        });
+    }));
+    server.registerTool("next_work", {
+        title: "Next work",
+        description: "The work to continue: the open work item for the current git branch, with where it stopped, its next action and the reviews it needs, and every other open item, with the items each is waiting for before it can ship. When nothing is open, the gaps the project's stage needs, to start as work items, with the Peer AI skill to use for each (useSkill).",
+        annotations: READ_ONLY,
+    }, withProject((root, config) => reply(nextWork(root, config))));
+    server.registerTool("standards_for_file", {
+        title: "Standards for a file",
+        description: "The standards that govern a file: the track it belongs to, the stack profiles, and the project's own standards documents and rules for that track. Call it before editing a file, then read and follow the documents it lists.",
+        inputSchema: { file: z.string().min(1).describe("The file's path, relative to the project root.") },
+        annotations: READ_ONLY,
+    }, withProject((root, config, { file }) => {
+        const standards = standardsFor(config, root, file);
+        return standards === undefined ? refuse(`${file} is outside the project.`) : reply(standards);
+    }));
+    server.registerTool("create_work_item", {
+        title: "Create a work item",
+        description: "Start a piece of work: a feature, bug, refactor, migration, discovery, chore, or a gap on the project map. It starts at prepare. The id comes from the tracker's ticket prefix unless you give one, such as a tracker key. Give it a goal, acceptance criteria, the sources it implements and the items it depends on when you know them: it can't ship before those items have.",
+        inputSchema: {
+            title: z.string().min(1),
+            kind: WorkItemSchema.shape.kind,
+            track: z.string().min(1).optional().describe("The track it changes. Needed when the project has several."),
+            gap: MapItemIdSchema.optional().describe("For kind gap: the map item this work fills, such as threat-model."),
+            id: z.string().min(1).optional().describe("A tracker key such as PROJ-14, or GH-42 for a GitHub issue."),
+            branch: z.string().min(1).optional().describe("Its git branch. Filled from the repo's naming pattern if set."),
+            next: z.string().min(1).max(200).optional().describe("One line: the first action."),
+            goal: WorkItemSchema.shape.goal,
+            acceptance: WorkItemSchema.shape.acceptance,
+            sources: WorkItemSchema.shape.sources,
+            dependsOn: WorkItemSchema.shape.dependsOn,
+        },
+        annotations: WRITES,
+    }, withProject((root, config, input) => fromResult(createWorkItem(root, config, input, now()))));
+    server.registerTool("update_work_item", {
+        title: "Update a work item",
+        description: "Record where work stands, so the next session resumes exactly there: the next action, the activity and step it stopped at, its branch or its title. It also sets the item's goal, acceptance criteria, sources and dependencies, replacing any given before.",
+        inputSchema: {
+            id: itemId,
+            next: z.string().min(1).max(200).optional().describe("One line: the next action."),
+            position: z
+                .object({ activity: z.enum(ACTIVITY_IDS), step: z.number().int().positive() })
+                .optional()
+                .describe("The activity and step where work stopped."),
+            branch: z.string().min(1).optional(),
+            title: z.string().min(1).optional(),
+            goal: WorkItemSchema.shape.goal,
+            acceptance: WorkItemSchema.shape.acceptance,
+            sources: WorkItemSchema.shape.sources,
+            dependsOn: WorkItemSchema.shape.dependsOn,
+        },
+        annotations: { ...WRITES, idempotentHint: true },
+    }, withProject((root, config, { id, ...changes }) => fromResult(updateWorkItem(root, config, id, changes, now()))));
+    server.registerTool("run_verify", {
+        title: "Run verify",
+        description: "Run the project's verify command (commands.verify in peer-ai.config.json) and record the result on the work item, with the end of its output. A work item can't move to ship or done without a passing verify, and only this tool records one.",
+        inputSchema: { id: itemId },
+        annotations: { ...WRITES, openWorldHint: true },
+    }, withProject(async (root, config, { id }) => {
+        const outcome = await runVerify(root, config, id, now, run);
+        if (!outcome.ok)
+            return refuse(outcome.error);
+        const { command, result, output } = outcome.value;
+        return reply({ id, command, result, output });
+    }));
+    server.registerTool("record_review", {
+        title: "Record a review",
+        description: "Record a review of a work item. Write the review's report first (.peer-ai/reports/<work item>/<skill>-<time>.json, in the review-report format) and pass its path: Peer AI checks the report, including that every rule the skill answers for has a coverage line, and works out pass, fail or incomplete from it. If it refuses, fix what it names and call it again. A review recorded without a report is marked unproven. Record failed and incomplete reviews too. For a review of the whole project, which has no work item, leave out the id: Peer AI checks the report the same way and gives its result, without recording it anywhere.",
+        inputSchema: {
+            id: itemId.optional().describe("The work item reviewed. Leave it out for a review of the whole project."),
+            skill: z.enum(SKILL_IDS),
+            report: z.string().min(1).optional().describe("The review report's path, relative to the project root."),
+            result: z
+                .enum(["pass", "fail", "incomplete"])
+                .optional()
+                .describe("Needed only without a report. With one, it must match the result the report supports."),
+            summary: z.string().min(1).max(500).optional().describe("A short summary for people."),
+        },
+        annotations: WRITES,
+    }, withProject((root, config, { id, ...review }) => {
+        if (id !== undefined)
+            return fromResult(recordReview(root, config, id, review, now()));
+        if (review.report === undefined) {
+            return refuse("A review of the whole project needs its report: give the report's path.");
+        }
+        const checked = checkReport(root, config, { ...review, report: review.report });
+        return fromResult(checked.ok
+            ? {
+                ok: true,
+                value: {
+                    ...checked.value,
+                    recorded: false,
+                    note: "The report is valid. A review of the whole project has no work item, so it isn't recorded; tell the person its result.",
+                },
+            }
+            : checked);
+    }));
+    server.registerTool("check_document", {
+        title: "Check a document",
+        description: "Check a document a Peer AI document skill wrote, such as requirements or a threat model, against the skill's template: every required part present and filled in, no template text left in, and only rule ids that exist. Write the document first and pass its path. When it isn't ready, it lists what to change: fix it and call check_document again, until it's ready.",
+        inputSchema: {
+            skill: z.enum(SKILL_IDS).describe("The document skill that wrote it, such as requirements-analysis."),
+            path: z.string().min(1).describe("The document's path, relative to the project root."),
+            template: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Which of the skill's templates it follows, when it has several. Defaults to the main one."),
+        },
+        annotations: READ_ONLY,
+    }, withProject((root, _config, input) => {
+        const checked = checkDocumentFile(root, input);
+        if (!checked.ok)
+            return refuse(checked.error);
+        if (checked.value.ready)
+            return reply(checked.value);
+        return refuse(`${input.path} isn't ready yet. Fix these, then call check_document again:\n${checked.value.problems.map((problem) => `- ${problem}`).join("\n")}`);
+    }));
+    server.registerTool("advance_work_item", {
+        title: "Advance a work item",
+        description: "Move a work item to its next stage (prepare, build, verify, ship, done), to an earlier stage to reopen it, or to cancelled. Moving to verify works out the reviews the change needs from the files it touched. Moving to ship or done passes the same gates as CI: a passing verify, the required reviews passing, and for a gap, the gap filled. When it refuses, it lists what to fix.",
+        inputSchema: {
+            id: itemId,
+            to: WorkItemSchema.shape.stage.optional().describe("The stage to move to. Omit it for the next one."),
+        },
+        annotations: WRITES,
+    }, withProject((root, config, { id, to }) => fromResult(advanceWorkItem(root, config, id, to, now()))));
+    server.registerTool("draft_feedback", {
+        title: "Draft feedback",
+        description: "Draft a report for Peer AI's maintainers when Peer AI itself gets something wrong: a review misses a problem or reports one that isn't there, a check blocks work by mistake, a skill's step can't be followed, or a command fails or misleads. Not for problems in the project. The draft stays in .peer-ai/feedback/ until the person decides; never send it yourself. Describe everything in plain words: never include the project's code, file contents, names of people, companies or products, secrets, or URLs and hosts. Peer AI refuses a draft holding code, a key or token, or an email address.",
+        inputSchema: {
+            title: z
+                .string()
+                .min(1)
+                .max(120)
+                .describe('One line, such as "security-review flagged a test file as production code".'),
+            what: z.string().min(1).max(4000).describe("What happened, in plain words."),
+            expected: z.string().min(1).max(2000).describe("What should have happened."),
+            skill: z.enum(SKILL_IDS).optional().describe("The Peer AI skill involved, when there is one."),
+            command: z
+                .string()
+                .min(1)
+                .max(120)
+                .optional()
+                .describe("The peer-ai command or MCP tool involved, when there is one."),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
+    }, (input) => {
+        const root = findRoot(options.cwd);
+        const { config } = loadConfig(root);
+        const client = server.server.getClientVersion()?.name;
+        return fromResult(draftFeedback(root, config, input, client === undefined ? {} : { tool: client }, now()));
+    });
+    return server;
+}
+/** Serves over stdio until the AI tool closes the connection. Nothing else may write to stdout. */
+export async function serveStdio(cwd) {
+    await createServer({ cwd }).connect(new StdioServerTransport());
+}

package/dist/package-info.d.ts

@@ -0,0 +1,4 @@
+/** This package's version. */
+export declare const VERSION: string;
+/** The oldest Node.js major version this package runs on, from `engines.node` (">=24"). */
+export declare const MIN_NODE_MAJOR: number;

package/dist/package-info.js

@@ -0,0 +1,6 @@
+import { readFileSync } from "node:fs";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+/** This package's version. */
+export const VERSION = pkg.version;
+/** The oldest Node.js major version this package runs on, from `engines.node` (">=24"). */
+export const MIN_NODE_MAJOR = Number(/^>=(\d+)/.exec(pkg.engines.node)?.[1] ?? 0);

package/dist/pipeline.d.ts

@@ -0,0 +1,82 @@
+import { type PipelineJob } from "peer-ai-standards";
+import type { PeerAiConfig } from "peer-ai-workflow";
+export declare const WORKFLOW_FILE = ".github/workflows/peer-ai-security.yml";
+/** A container image, pinned to its digest: Docker uses the digest, and the tag says which release it is. */
+export interface Image {
+    name: string;
+    tag: string;
+    digest: string;
+}
+export declare const IMAGES: {
+    zizmor: {
+        name: string;
+        tag: string;
+        digest: string;
+    };
+    semgrep: {
+        name: string;
+        tag: string;
+        digest: string;
+    };
+    sslyze: {
+        name: string;
+        tag: string;
+        digest: string;
+    };
+    zap: {
+        name: string;
+        tag: string;
+        digest: string;
+    };
+};
+export declare const imageRef: (image: Image) => string;
+/** How a job installs its tool and runs it on the repository, as shell lines. */
+export interface JobScript {
+    /** The job's name, which a project makes a required check. It never changes. */
+    name: string;
+    /** The tool and its version, for the steps' names. */
+    tool: string;
+    /** Lines that install the tool into $RUNNER_TEMP/peer-ai-tools, which is on the PATH afterwards. */
+    install: string[];
+    /** Lines that run the tool on the repository at the current folder, failing the job on a finding. */
+    scan: string[];
+    /** The whole history, for a tool that reads it. */
+    history?: boolean;
+    /** Environment variables the scan reads, from GitHub's contexts: never pasted into the script. */
+    env?: Record<string, string>;
+}
+export declare const JOBS: Record<PipelineJob, JobScript>;
+/** An environment with an address the pipeline can check. */
+interface Address {
+    id: string;
+    url: string;
+    host: string;
+    production: boolean | undefined;
+}
+/**
+ * The environments' addresses, split into those the pipeline can use and those it can't: an
+ * address that isn't a full http or https URL, or that holds a user name or password, which would
+ * be written into the committed workflow.
+ */
+export declare function environmentAddresses(config: PeerAiConfig): {
+    usable: Address[];
+    unusable: {
+        id: string;
+        url: string;
+    }[];
+};
+/** The pipeline rules that apply at the project's stage, leaving out the ones it set aside. */
+export declare function pipelineRules(config: PeerAiConfig): import("peer-ai-standards").AppliedRule[];
+/** The workflow's body, below its header, or undefined when no job applies. */
+export declare function workflowBody(config: PeerAiConfig): string | undefined;
+/** The jobs the workflow render writes would run: the keys under jobs:. */
+export declare function workflowJobs(config: PeerAiConfig): string[];
+/** The whole file render writes: a header recording the body's hash, then the body. */
+export declare function workflowFile(config: PeerAiConfig): string | undefined;
+/** Whether a file was written by render: it records a hash in its header. */
+export declare const writtenByRender: (content: string) => boolean;
+/** Whether a file is as render wrote it: its body still has the hash its header records. */
+export declare function unchangedSinceRender(content: string): boolean;
+/** Whether two files are the same apart from their line endings. */
+export declare const sameFile: (a: string, b: string) => boolean;
+export {};