peer-ai 1.0.0-next.0

package/dist/check.js

@@ -0,0 +1,253 @@
+// peer-ai check: the gate CI runs. It fails when the setup is broken, or when a work item claims
+// more than its record shows: an item at ship or done without a passing verify or reviews, or a
+// gap marked done that a fresh assessment still finds. Gaps on the map never fail it; they are
+// reported, so they become work items instead of blockers. The project's stage sets how strict
+// it is.
+import { renderedName } from "peer-ai-skills";
+import { MAP_ITEM_IDS } from "peer-ai-workflow";
+import { MAP_FILE, assess, gaps, loadConfig } from "./assess.js";
+import { count, fail, formatChecks, ok, plural, warn } from "./checks.js";
+import { CONFIG_FILE } from "./detect.js";
+import { checkTracks, checkWorkItems, diagnose } from "./doctor.js";
+import { mapChanges, readMap, readWorkItems } from "./state.js";
+/** Doctor's checks that check already makes itself. */
+const CHECKED_HERE = new Set(["config", "tracks", "map", "work-items"]);
+/**
+ * The setup checks doctor makes: every failure, and one line counting the warnings. The skills
+ * are left out, since CI never has them.
+ */
+export function setupChecks(root, nodeVersion, today) {
+    const diagnosis = diagnose(root, nodeVersion, today, { skills: false });
+    const others = diagnosis.checks.filter((check) => !CHECKED_HERE.has(check.id));
+    const warnings = count(others, "warn");
+    return [
+        ...others.filter((check) => check.status === "fail"),
+        ...(warnings === 0
+            ? []
+            : [warn("setup", `${plural(warnings, "setup warning")}.`, "Run npx peer-ai doctor for the details.")]),
+    ];
+}
+/** Work at these stages says it has been verified and reviewed. */
+const CLAIMS_VERIFIED = ["ship", "done"];
+const OPEN = ["prepare", "build", "verify", "ship"];
+const COMMIT_MAP = `Run peer-ai assess, and commit ${MAP_FILE}.`;
+const isKnownItem = (id) => MAP_ITEM_IDS.includes(id);
+/** The most recent review from each skill: a later pass supersedes an earlier failure. */
+function latestReviews(item) {
+    const latest = new Map();
+    for (const review of item.reviews ?? []) {
+        const seen = latest.get(review.skill);
+        if (seen === undefined || Date.parse(review.at) >= Date.parse(seen.at))
+            latest.set(review.skill, review);
+    }
+    return [...latest.values()];
+}
+/**
+ * Whether a work item may be at ship or done. `items` are the project's other work items, for its
+ * dependencies (RFC 0005): an item can't ship before the items it depends on have.
+ */
+export function gateWorkItem(item, config, stage, assessment, items = []) {
+    const checks = [];
+    const claim = `${item.id} is at ${item.stage}`;
+    const backToBuild = "or move the item back to build.";
+    const verifyCommand = config.commands?.verify ?? undefined;
+    for (const id of item.dependsOn ?? []) {
+        const dependency = items.find((other) => other.id === id);
+        if (dependency !== undefined && CLAIMS_VERIFIED.includes(dependency.stage))
+            continue;
+        checks.push(fail("gates", dependency === undefined
+            ? `${claim}, but it depends on ${id}, which isn't a work item.`
+            : dependency.stage === "cancelled"
+                ? `${claim}, but it depends on ${id}, which was cancelled.`
+                : `${claim}, but it depends on ${id}, which is only at ${dependency.stage}.`, dependency?.stage === "cancelled" || dependency === undefined
+            ? `Remove ${id} from its dependsOn, ${backToBuild}`
+            : `Ship ${id} first, ${backToBuild}`));
+    }
+    if (item.lastVerify?.result === "fail") {
+        checks.push(fail("gates", `${claim}, but its last verify failed.`, `Fix what failed and verify again, ${backToBuild}`));
+    }
+    else if (item.lastVerify === undefined && verifyCommand !== undefined) {
+        checks.push(fail("gates", `${claim}, but it has no recorded verify.`, `Run ${verifyCommand} and record the result on the work item, ${backToBuild}`));
+    }
+    // The reviews the change needs (RFC 0004): a warning for an MVP, a failure in production. A
+    // prototype is only told, by next_work.
+    const recorded = new Set((item.reviews ?? []).map((review) => review.skill));
+    for (const required of item.requiredReviews ?? []) {
+        if (recorded.has(required.skill) || stage === "prototype")
+            continue;
+        const message = `${claim}, but it has no ${required.skill}, which it needs because ${required.reason}.`;
+        const fix = `Use the ${renderedName(required.skill)} skill and record its review, ${backToBuild}`;
+        checks.push(stage === "production" ? fail("gates", message, fix) : warn("gates", message, fix));
+    }
+    for (const review of latestReviews(item)) {
+        // A prototype accepts a review that didn't cover every rule; a failed one still stops it.
+        const allowed = review.result === "pass" || (review.result === "incomplete" && stage === "prototype");
+        if (!allowed) {
+            checks.push(review.result === "fail"
+                ? fail("gates", `${claim}, but its latest ${review.skill} failed.`, `Fix the findings and review again, ${backToBuild}`)
+                : fail("gates", `${claim}, but its latest ${review.skill} is incomplete: it didn't check every rule.`, `Review again until every rule is checked, ${backToBuild}`));
+        }
+        else if (review.report === undefined && stage !== "prototype") {
+            // Without a report, the result is the agent's word (RFC 0002): a warning for an MVP, a
+            // failure in production.
+            const message = `${claim}, but its latest ${review.skill} has no report, so its result is unproven.`;
+            const fix = "Write the review's report, and record the review again with it.";
+            checks.push(stage === "production" ? fail("gates", message, fix) : warn("gates", message, fix));
+        }
+    }
+    if (item.kind === "gap" && item.stage === "done" && item.gap !== undefined && isKnownItem(item.gap)) {
+        const status = assessment.items[item.gap].status;
+        if (status !== "present" && status !== "not-applicable") {
+            checks.push(fail("gates", `${item.id} says the ${item.gap} gap is done, but a fresh assessment finds it ${status}.`, `Finish the work, ${backToBuild}`));
+        }
+    }
+    return checks;
+}
+function checkGates(items, config, stage, assessment) {
+    const claiming = items.filter((item) => CLAIMS_VERIFIED.includes(item.stage));
+    const results = claiming.flatMap((item) => gateWorkItem(item, config, stage, assessment, items));
+    const failures = results.filter((check) => check.status === "fail");
+    const warnings = results.filter((check) => check.status === "warn");
+    if (failures.length > 0)
+        return [...failures, ...warnings];
+    if (claiming.length === 0)
+        return [ok("gates", "No work items at ship or done yet")];
+    return [
+        ok("gates", `${plural(claiming.length, "work item")} at ship or done, each verified and reviewed`),
+        ...warnings,
+    ];
+}
+/** Every dependency names a work item that exists, and no items wait on each other in a loop (RFC 0005). */
+function checkDependencies(items) {
+    const ids = new Set(items.map((item) => item.id));
+    const problems = [];
+    for (const item of items) {
+        for (const id of item.dependsOn ?? []) {
+            if (!ids.has(id)) {
+                problems.push(fail("plans", `${item.id} depends on ${id}, which isn't a work item.`, `Remove ${id} from its dependsOn.`));
+            }
+        }
+    }
+    const byId = new Map(items.map((item) => [item.id, item]));
+    const reported = new Set();
+    for (const start of items) {
+        // Follow the dependencies depth first; meeting an item already on the path is a loop.
+        const path = [];
+        const visit = (id) => {
+            if (path.includes(id))
+                return [...path.slice(path.indexOf(id)), id];
+            if (reported.has(id))
+                return undefined;
+            path.push(id);
+            for (const next of byId.get(id)?.dependsOn ?? []) {
+                const loop = visit(next);
+                if (loop !== undefined)
+                    return loop;
+            }
+            path.pop();
+            return undefined;
+        };
+        const loop = visit(start.id);
+        if (loop !== undefined && !loop.some((id) => reported.has(id))) {
+            for (const id of loop)
+                reported.add(id);
+            problems.push(fail("plans", `Work items wait on each other in a loop: ${loop.join(" → ")}.`, "Remove one of the dependencies."));
+        }
+    }
+    if (problems.length > 0)
+        return problems;
+    const planned = items.filter((item) => (item.dependsOn ?? []).length > 0).length;
+    return planned === 0 ? [] : [ok("plans", `${plural(planned, "work item")} with dependencies, each on a real item`)];
+}
+function checkVerifyCommand(config, stage) {
+    if (stage === "prototype" || (config.commands?.verify ?? undefined) !== undefined)
+        return [];
+    return [
+        warn("verify", "No verify command is set, so nothing is verified before work is called done.", `Set commands.verify in ${CONFIG_FILE}, for example "npm test" or "make check".`),
+    ];
+}
+function checkMap(root, assessment) {
+    const read = readMap(root);
+    if (read === undefined)
+        return warn("map", "There is no project map yet.", COMMIT_MAP);
+    if (!read.ok)
+        return fail("map", `${MAP_FILE} ${read.error}`, COMMIT_MAP);
+    const changed = mapChanges(read.value, assessment);
+    if (changed.length > 0)
+        return warn("map", `The project map is out of date: ${changed.join(", ")}.`, COMMIT_MAP);
+    return ok("map", "The project map is up to date");
+}
+/** What the stage needs and is missing should each have an open gap work item. */
+function checkGapsTracked(assessment, stage, items) {
+    if (stage === "prototype")
+        return ok("gaps", "Nothing on the map is required at the prototype stage");
+    const needed = gaps(assessment, stage);
+    if (needed.length === 0)
+        return ok("gaps", `Everything the ${stage} stage needs is in place`);
+    const tracked = new Set(items.filter((item) => item.kind === "gap" && OPEN.includes(item.stage)).map((i) => i.gap));
+    const untracked = needed.filter((id) => !tracked.has(id));
+    if (untracked.length === 0)
+        return ok("gaps", `${plural(needed.length, "gap")} for ${stage}, each with a work item`);
+    return warn("gaps", `${plural(untracked.length, "gap")} for ${stage} with no work item: ${untracked.join(", ")}.`, "Add a gap work item for each, so they are planned rather than forgotten.");
+}
+export function evaluate(root, config) {
+    const stage = config.project.stage ?? "mvp";
+    const assessment = assess(root, config, stage);
+    const trackFailures = checkTracks(root, config).filter((check) => check.status === "fail");
+    const items = readWorkItems(root).flatMap(({ item }) => (item.ok ? [item.value] : []));
+    const checks = [
+        ok("config", `${CONFIG_FILE} is valid`),
+        ...(trackFailures.length > 0 ? trackFailures : [ok("tracks", "Every track's folder exists")]),
+        checkMap(root, assessment),
+        ...checkWorkItems(root, config),
+        ...checkDependencies(items),
+        ...checkGates(items, config, stage, assessment),
+        ...checkVerifyCommand(config, stage),
+        checkGapsTracked(assessment, stage, items),
+    ];
+    const setup = setupChecks(root);
+    return {
+        name: config.project.name,
+        stage,
+        ok: count(checks, "fail") + count(setup, "fail") === 0,
+        checks,
+        setup,
+    };
+}
+export function formatVerdict(verdict) {
+    const all = [...verdict.checks, ...verdict.setup];
+    const failures = count(all, "fail");
+    const warnings = count(all, "warn");
+    const andWarnings = warnings === 0 ? "" : `, and ${plural(warnings, "warning")}`;
+    return [
+        `Peer AI check: ${verdict.name} (stage: ${verdict.stage})`,
+        "",
+        ...formatChecks(verdict.checks),
+        ...(verdict.setup.length === 0 ? [] : ["", "Setup, as peer-ai doctor checks it:", ...formatChecks(verdict.setup)]),
+        "",
+        failures > 0
+            ? `Failed: ${plural(failures, "problem")}${andWarnings}.`
+            : `Passed${warnings === 0 ? "" : `, with ${plural(warnings, "warning")}`}.`,
+    ];
+}
+/** Exit code 0 when it passes, even with warnings; 1 when it fails; 2 without a valid config. */
+export function runCheck(options, out) {
+    const { config, errors } = loadConfig(options.cwd);
+    if (config === undefined) {
+        if (errors === undefined)
+            out.error(`There is no ${CONFIG_FILE}. Run peer-ai init first.`);
+        else {
+            out.error(`${CONFIG_FILE} is not valid:`);
+            for (const error of errors)
+                out.error(`  ${error}`);
+        }
+        return 2;
+    }
+    const verdict = evaluate(options.cwd, config);
+    if (options.json)
+        out.log(JSON.stringify(verdict, null, 2));
+    else
+        for (const line of formatVerdict(verdict))
+            out.log(line);
+    return verdict.ok ? 0 : 1;
+}

package/dist/checks.d.ts

@@ -0,0 +1,15 @@
+export type CheckStatus = "ok" | "warn" | "fail" | "skip";
+export interface Check {
+    id: string;
+    status: CheckStatus;
+    message: string;
+    fix?: string;
+}
+export declare const ok: (id: string, message: string) => Check;
+export declare const skip: (id: string, message: string) => Check;
+export declare const warn: (id: string, message: string, fix: string) => Check;
+export declare const fail: (id: string, message: string, fix: string) => Check;
+export declare const plural: (count: number, word: string) => string;
+export declare const count: (checks: Check[], status: CheckStatus) => number;
+/** One line per check, with its fix indented beneath it. */
+export declare function formatChecks(checks: Check[]): string[];

package/dist/checks.js

@@ -0,0 +1,15 @@
+// The results `peer-ai doctor` and `peer-ai check` report, and how they are printed.
+export const ok = (id, message) => ({ id, status: "ok", message });
+export const skip = (id, message) => ({ id, status: "skip", message });
+export const warn = (id, message, fix) => ({ id, status: "warn", message, fix });
+export const fail = (id, message, fix) => ({ id, status: "fail", message, fix });
+export const plural = (count, word) => `${String(count)} ${word}${count === 1 ? "" : "s"}`;
+export const count = (checks, status) => checks.filter((check) => check.status === status).length;
+const SYMBOL = { ok: "✓", warn: "!", fail: "✗", skip: "–" };
+/** One line per check, with its fix indented beneath it. */
+export function formatChecks(checks) {
+    return checks.flatMap((check) => [
+        `  ${SYMBOL[check.status]} ${check.message}`,
+        ...(check.fix === undefined ? [] : [`      ${check.fix}`]),
+    ]);
+}

package/dist/cli.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { type Output } from "./init.ts";
+import { type Prompter } from "./prompter.ts";
+export interface Io {
+    cwd: string;
+    out: Output;
+    /** Present when questions can be asked, which means a terminal is attached. */
+    prompter?: Prompter;
+}
+export declare function main(argv: string[], io: Io): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+// The peer-ai command. Exit codes: 0 success, 1 refused, cancelled or problems found, 2 usage or
+// config error.
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { CLI_COMMAND_IDS, TOOL_IDS } from "peer-ai-workflow";
+import { runAssess } from "./assess.js";
+import { runCheck } from "./check.js";
+import { runCheckDocument } from "./document.js";
+import { runDoctor } from "./doctor.js";
+import { runFeedback } from "./feedback.js";
+import { serveStdio } from "./mcp.js";
+import { runInit } from "./init.js";
+import { VERSION } from "./package-info.js";
+import { createTerminalPrompter } from "./prompter.js";
+import { formatReport } from "./report.js";
+import { runRender } from "./render.js";
+import { runCheckReport } from "./work.js";
+const STAGES = ["prototype", "mvp", "production"];
+const HELP = `peer-ai: from a brief to a shipped product, with any AI tool
+
+Usage:
+  peer-ai init [options]      Set up Peer AI in this repository
+  peer-ai assess [options]    Map what the project has and what its stage still needs
+  peer-ai render [options]    Set up each AI tool in the config: instructions and the MCP server
+  peer-ai doctor [options]    Check that Peer AI is set up correctly, and how to fix it
+  peer-ai check [options]     The CI gate: fail when work claims more than its record shows
+  peer-ai check-report <file> Check a review's report, as the record_review tool does
+  peer-ai check-document <file> --skill <skill>
+                              Check a document against its skill's template, as the
+                              check_document tool does
+  peer-ai feedback            List the feedback drafts your AI tool wrote about Peer AI
+  peer-ai feedback send <draft>
+                              Send a draft as an issue on Peer AI's repository
+  peer-ai feedback drop <draft>
+                              Delete a draft
+  peer-ai mcp                 Start the MCP server that AI tools connect to, over stdio
+
+Options for init:
+  -y, --yes                   Accept what init detects instead of asking
+      --dry-run               Print the config instead of writing it
+      --name <name>           The project's name
+      --stage <stage>         prototype, mvp or production
+      --team <team>           solo or team
+      --tool <tool>           An AI tool you use; repeat for several
+                              (${TOOL_IDS.join(", ")})
+
+Options for assess:
+      --target <stage>        Assess against a stage other than the project's own,
+                              for example production before a launch
+      --json                  Print the project map as JSON instead of the report
+      --dry-run               Don't write .peer-ai/map.json
+
+Options for render:
+      --check                 Change nothing; fail when a file is out of date (for CI)
+      --skills                Write only the skills (what each tool's setup step runs)
+      --quiet                 Print nothing unless something fails
+
+Options for check-report:
+      --skill <skill>         The skill the report is for (default: the one it names)
+      --work-item <id>        The work item it's for, when there is one
+      --json                  Print the result as JSON
+
+Options for check-document:
+      --skill <skill>         The document skill that wrote it, such as requirements-analysis
+      --template <name>       Which of the skill's templates it follows (default: the main one)
+      --json                  Print the result as JSON
+
+Options for doctor and check:
+      --json                  Print the checks as JSON
+
+Other:
+  -h, --help                  Show this help
+  -v, --version               Show the version`;
+function oneOf(value, allowed, flag) {
+    if (allowed.includes(value))
+        return value;
+    throw new Error(`${flag} must be one of: ${allowed.join(", ")}`);
+}
+async function init(args, io) {
+    const { values } = parseArgs({
+        args,
+        strict: true,
+        options: {
+            yes: { type: "boolean", short: "y" },
+            "dry-run": { type: "boolean" },
+            name: { type: "string" },
+            stage: { type: "string" },
+            team: { type: "string" },
+            tool: { type: "string", multiple: true },
+        },
+    });
+    const stage = values.stage === undefined ? undefined : oneOf(values.stage, STAGES, "--stage");
+    const team = values.team === undefined ? undefined : oneOf(values.team, ["solo", "team"], "--team");
+    const tools = values.tool?.map((tool) => oneOf(tool, TOOL_IDS, "--tool"));
+    return runInit({
+        cwd: io.cwd,
+        yes: values.yes === true,
+        dryRun: values["dry-run"] === true,
+        ...(values.name === undefined ? {} : { name: values.name }),
+        ...(stage === undefined ? {} : { stage }),
+        ...(team === undefined ? {} : { team }),
+        ...(tools === undefined ? {} : { tools }),
+    }, io.prompter, io.out);
+}
+function assess(args, io) {
+    const { values } = parseArgs({
+        args,
+        strict: true,
+        options: {
+            target: { type: "string" },
+            json: { type: "boolean" },
+            "dry-run": { type: "boolean" },
+        },
+    });
+    const target = values.target === undefined ? undefined : oneOf(values.target, STAGES, "--target");
+    return runAssess({
+        cwd: io.cwd,
+        json: values.json === true,
+        dryRun: values["dry-run"] === true,
+        ...(target === undefined ? {} : { target }),
+    }, io.out, formatReport);
+}
+function doctor(args, io) {
+    const { values } = parseArgs({ args, strict: true, options: { json: { type: "boolean" } } });
+    return runDoctor({ cwd: io.cwd, json: values.json === true }, io.out);
+}
+function check(args, io) {
+    const { values } = parseArgs({ args, strict: true, options: { json: { type: "boolean" } } });
+    return runCheck({ cwd: io.cwd, json: values.json === true }, io.out);
+}
+function checkReportCommand(args, io) {
+    const { values, positionals } = parseArgs({
+        args,
+        strict: true,
+        allowPositionals: true,
+        options: { skill: { type: "string" }, "work-item": { type: "string" }, json: { type: "boolean" } },
+    });
+    const [report] = positionals;
+    if (report === undefined)
+        throw new TypeError("Give the report's path, such as peer-ai check-report .peer-ai/reports/project/security-review.json");
+    return runCheckReport({ cwd: io.cwd, report, skill: values.skill, workItem: values["work-item"], json: values.json === true }, io.out);
+}
+function checkDocumentCommand(args, io) {
+    const { values, positionals } = parseArgs({
+        args,
+        strict: true,
+        allowPositionals: true,
+        options: { skill: { type: "string" }, template: { type: "string" }, json: { type: "boolean" } },
+    });
+    const [path] = positionals;
+    if (path === undefined || values.skill === undefined)
+        throw new TypeError("Give the document's path and its skill, such as peer-ai check-document docs/requirements.md --skill requirements-analysis");
+    return runCheckDocument({ cwd: io.cwd, path, skill: values.skill, template: values.template, json: values.json === true }, io.out);
+}
+function render(args, io) {
+    const { values } = parseArgs({
+        args,
+        strict: true,
+        options: { check: { type: "boolean" }, skills: { type: "boolean" }, quiet: { type: "boolean" } },
+    });
+    return runRender({ cwd: io.cwd, check: values.check === true, skills: values.skills === true, quiet: values.quiet === true }, io.out);
+}
+function feedback(args, io) {
+    const { positionals } = parseArgs({ args, strict: true, allowPositionals: true, options: {} });
+    const [action, draft] = positionals;
+    return runFeedback({ cwd: io.cwd, action, draft }, io.out);
+}
+async function mcp(args, io) {
+    parseArgs({ args, strict: true, options: {} });
+    await serveStdio(io.cwd);
+    return 0;
+}
+const COMMANDS = {
+    init,
+    assess,
+    render,
+    doctor,
+    check,
+    "check-report": checkReportCommand,
+    "check-document": checkDocumentCommand,
+    feedback,
+    mcp,
+};
+const isCommand = (value) => CLI_COMMAND_IDS.includes(value);
+export async function main(argv, io) {
+    const [command, ...rest] = argv;
+    if (command === undefined || command === "-h" || command === "--help" || command === "help") {
+        io.out.log(HELP);
+        return 0;
+    }
+    if (command === "-v" || command === "--version") {
+        io.out.log(VERSION);
+        return 0;
+    }
+    const run = isCommand(command) ? COMMANDS[command] : undefined;
+    if (run === undefined) {
+        io.out.error(`Unknown command "${command}". Run peer-ai --help to see the commands.`);
+        return 2;
+    }
+    try {
+        return await run(rest, io);
+    }
+    catch (error) {
+        if (error instanceof TypeError || (error instanceof Error && error.message.startsWith("--"))) {
+            io.out.error(`${error.message}. Run peer-ai --help for usage.`);
+            return 2;
+        }
+        throw error;
+    }
+}
+// An installed peer-ai runs through a link in node_modules/.bin, so compare the file the link points to.
+const invokedDirectly = process.argv[1] !== undefined &&
+    realpathSync(resolve(process.argv[1])) === realpathSync(fileURLToPath(import.meta.url));
+if (invokedDirectly) {
+    const interactive = process.stdin.isTTY && process.stdout.isTTY;
+    process.exitCode = await main(process.argv.slice(2), {
+        cwd: process.cwd(),
+        out: {
+            log: (line) => {
+                console.log(line);
+            },
+            error: (line) => {
+                console.error(line);
+            },
+        },
+        ...(interactive ? { prompter: createTerminalPrompter() } : {}),
+    });
+}

package/dist/detect.d.ts

@@ -0,0 +1,42 @@
+import type { ToolId } from "peer-ai-workflow";
+import { CONFIG_FILE } from "peer-ai-workflow";
+export { CONFIG_FILE };
+export type TrackKind = "web" | "mobile" | "desktop" | "backend" | "infrastructure" | "library" | "cli" | "other";
+export type RepoHost = "github" | "gitlab" | "bitbucket" | "azure-devops" | "other";
+export interface DetectedTrack {
+    id: string;
+    kind: TrackKind;
+    path?: string;
+    stack: string[];
+    /** Where it deploys, when a platform's config file says so. */
+    deploy?: string;
+}
+export interface Detected {
+    name: string;
+    description?: string;
+    origin: "new" | "existing";
+    tools: ToolId[];
+    repo: {
+        host?: RepoHost;
+        remote: string | null;
+    };
+    /** Present when a CI pipeline already exists, so Peer AI extends it instead of adding another. */
+    delivery?: {
+        ci: "existing";
+        pipeline: string;
+    };
+    tracks: DetectedTrack[];
+    hasConfig: boolean;
+}
+export declare function slugify(text: string): string;
+export declare function detectDeploy(dir: string): string | undefined;
+/** The project's name from its own project file, in whichever language it's written. */
+export declare function detectName(root: string): string;
+export declare function detectTracks(root: string, projectName: string): DetectedTrack[];
+export declare function detectDelivery(root: string): Detected["delivery"];
+export declare function detectTools(root: string): ToolId[];
+/** The host name of a git remote, from an https, ssh:// or scp-style (git@host:path) URL. */
+export declare function remoteHostname(url: string): string | undefined;
+export declare function classifyHost(hostname: string | undefined): RepoHost;
+export declare function detectRepo(root: string): Detected["repo"];
+export declare function detect(root: string): Detected;