@gavin-hu/my-pi-agent 0.14.0 → 0.15.0

package/extensions/check/detect.ts

@@ -0,0 +1,269 @@
+/**
+ * Cross-stack command detection for the check extension.
+ *
+ * A detector is one pure function over a directory: it reads the manifests it
+ * understands and returns the same `DetectedCommands` shape. The registry is
+ * ordered, and detection stops at the first family that yields a command, so a
+ * Node project with a Makefile does not silently become a `make` project.
+ *
+ * `check.command` bypasses this module entirely. That is the deliberate escape
+ * hatch for stacks without a detector, not a failure of the design.
+ */
+
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import type { CheckTarget, CommandSpec, DetectedCommands } from "./types.ts";
+
+/** One family of manifests and the commands it declares. */
+export interface Detector {
+	/** Stable name for tests and documentation. */
+	name: string;
+	/** Commands this directory declares, or undefined when it is not this family. */
+	detect(cwd: string): DetectedCommands | undefined;
+}
+
+/** One resolved command list, or the corrective reason there is none. */
+export type PlannedCommands = { ok: true; commands: CommandSpec[] } | { ok: false; error: string };
+
+/** A command whose label is its own text. */
+function spec(command: string): CommandSpec {
+	return { command, label: command };
+}
+
+/** Read a UTF-8 file, or undefined when it is missing or unreadable. */
+function read(cwd: string, name: string): string | undefined {
+	try {
+		return readFileSync(join(cwd, name), "utf-8");
+	} catch {
+		return undefined;
+	}
+}
+
+/** Whether a directory entry is a file or a directory. */
+function has(cwd: string, name: string, kind: "file" | "dir" = "file"): boolean {
+	try {
+		const path = join(cwd, name);
+		return kind === "dir" ? statSync(path).isDirectory() : statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+
+/** A plain object, for untrusted JSON. */
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** The package manager whose lockfile is present, defaulting to npm. */
+export function packageManager(cwd: string): "bun" | "pnpm" | "yarn" | "npm" {
+	if (existsSync(join(cwd, "bun.lock")) || existsSync(join(cwd, "bun.lockb"))) return "bun";
+	if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+	return "npm";
+}
+
+/** The declared scripts in package.json, or undefined outside a Node project. */
+function packageScripts(cwd: string): Record<string, string> | undefined {
+	const text = read(cwd, "package.json");
+	if (text === undefined) return undefined;
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return undefined;
+	}
+	if (!isRecord(parsed) || !isRecord(parsed.scripts)) return undefined;
+	const scripts: Record<string, string> = {};
+	for (const [name, value] of Object.entries(parsed.scripts)) {
+		if (typeof value === "string") scripts[name] = value;
+	}
+	return scripts;
+}
+
+const packageDetector: Detector = {
+	name: "package.json",
+	detect(cwd) {
+		const scripts = packageScripts(cwd);
+		if (!scripts) return undefined;
+		const pm = packageManager(cwd);
+		const run = (name: string): CommandSpec | undefined =>
+			scripts[name] !== undefined ? spec(`${pm} run ${name}`) : undefined;
+		const commands: DetectedCommands = {};
+		const test = run("test");
+		const lint = run("lint");
+		const typecheck = run("typecheck");
+		const all = run("check");
+		if (test) commands.test = test;
+		if (lint) commands.lint = lint;
+		if (typecheck) commands.typecheck = typecheck;
+		if (all) commands.all = all;
+		return Object.keys(commands).length > 0 ? commands : undefined;
+	},
+};
+
+const cargoDetector: Detector = {
+	name: "Cargo.toml",
+	detect(cwd) {
+		if (!has(cwd, "Cargo.toml")) return undefined;
+		return {
+			test: spec("cargo test"),
+			lint: spec("cargo clippy -- -D warnings"),
+			typecheck: spec("cargo check"),
+		};
+	},
+};
+
+const goDetector: Detector = {
+	name: "go.mod",
+	detect(cwd) {
+		if (!has(cwd, "go.mod")) return undefined;
+		return {
+			test: spec("go test ./..."),
+			lint: spec("go vet ./..."),
+			typecheck: spec("go build ./..."),
+		};
+	},
+};
+
+const pythonDetector: Detector = {
+	name: "python",
+	detect(cwd) {
+		const pyproject = read(cwd, "pyproject.toml") ?? "";
+		const pytest = has(cwd, "pytest.ini") || pyproject.includes("[tool.pytest") || has(cwd, "tests", "dir");
+		const commands: DetectedCommands = {};
+		if (pytest) commands.test = spec("pytest");
+		if (pyproject.includes("[tool.ruff")) commands.lint = spec("ruff check .");
+		if (pyproject.includes("[tool.mypy")) commands.typecheck = spec("mypy .");
+		return Object.keys(commands).length > 0 ? commands : undefined;
+	},
+};
+
+/** Declared recipe names in a justfile. */
+function justTargets(text: string): Set<string> {
+	const targets = new Set<string>();
+	for (const line of text.split("\n")) {
+		const match = /^([A-Za-z_][A-Za-z0-9_-]*)\s*:/.exec(line);
+		if (match) targets.add(match[1] ?? "");
+	}
+	return targets;
+}
+
+/** The recipe name each target runs, for a recipe runner's declared targets. */
+const RECIPE_TARGETS: ReadonlyArray<readonly [CheckTarget, string]> = [
+	["test", "test"],
+	["lint", "lint"],
+	["typecheck", "typecheck"],
+	["all", "check"],
+];
+
+/**
+ * A detector for a recipe runner: a manifest of `name:` targets, of which the
+ * declared `test`/`lint`/`typecheck`/`check` become the commands. `targets` is
+ * the family's own target parser, because a Makefile and a justfile do not agree
+ * on what a legal target name is.
+ */
+function recipeDetector(options: {
+	name: string;
+	/** Manifest names to look for, in the family's own preference order. */
+	files: readonly string[];
+	/** The runner binary, e.g. `just`. */
+	command: string;
+	targets(text: string): Set<string>;
+}): Detector {
+	return {
+		name: options.name,
+		detect(cwd) {
+			const file = options.files.find((name) => has(cwd, name));
+			if (!file) return undefined;
+			const declared = options.targets(read(cwd, file) ?? "");
+			const commands: DetectedCommands = {};
+			for (const [target, recipe] of RECIPE_TARGETS) {
+				if (declared.has(recipe)) commands[target] = spec(`${options.command} ${recipe}`);
+			}
+			return Object.keys(commands).length > 0 ? commands : undefined;
+		},
+	};
+}
+
+const justDetector = recipeDetector({
+	name: "justfile",
+	files: ["justfile", "Justfile", ".justfile"],
+	command: "just",
+	targets: justTargets,
+});
+
+/** Declared target names in a Makefile. */
+function makeTargets(text: string): Set<string> {
+	const targets = new Set<string>();
+	for (const line of text.split("\n")) {
+		const match = /^([A-Za-z0-9_.-]+)\s*:/.exec(line);
+		if (match?.[1] && !match[1].startsWith(".")) targets.add(match[1]);
+	}
+	return targets;
+}
+
+const makeDetector = recipeDetector({
+	name: "Makefile",
+	files: ["Makefile", "makefile"],
+	command: "make",
+	targets: makeTargets,
+});
+
+/** Detectors in priority order; the first family with a command wins. */
+export const DETECTORS: readonly Detector[] = [
+	packageDetector,
+	cargoDetector,
+	goDetector,
+	pythonDetector,
+	justDetector,
+	makeDetector,
+];
+
+/** The commands the first matching manifest family declares. */
+export function detectCommands(cwd: string): DetectedCommands | undefined {
+	for (const detector of DETECTORS) {
+		const commands = detector.detect(cwd);
+		if (commands) return commands;
+	}
+	return undefined;
+}
+
+/** The ordered targets `all` runs when no all-command exists. */
+const ALL_ORDER: ReadonlyArray<Exclude<CheckTarget, "all">> = ["test", "lint", "typecheck"];
+
+/**
+ * Resolve the commands for one target.
+ *
+ * `override` is the user's `check.command`; when set it is the only command, for
+ * every target. Otherwise detection supplies the target, and `all` prefers a
+ * declared all-command before expanding to the detected targets in order.
+ */
+export function planCommands(cwd: string, target: CheckTarget, override = ""): PlannedCommands {
+	const custom = override.trim();
+	if (custom) return { ok: true, commands: [spec(custom)] };
+
+	const detected = detectCommands(cwd);
+	if (!detected) {
+		return {
+			ok: false,
+			error: "No check command detected. Set `check.command` in bytefly.json to the command this project uses.",
+		};
+	}
+
+	if (target !== "all") {
+		const command = detected[target];
+		if (command) return { ok: true, commands: [command] };
+		return {
+			ok: false,
+			error: `No ${target} command detected. Set \`check.command\` in bytefly.json to the command this project uses.`,
+		};
+	}
+
+	if (detected.all) return { ok: true, commands: [detected.all] };
+	const commands = ALL_ORDER.flatMap((name) => (detected[name] ? [detected[name]] : []));
+	if (commands.length > 0) return { ok: true, commands };
+	return {
+		ok: false,
+		error: "No check command detected. Set `check.command` in bytefly.json to the command this project uses.",
+	};
+}

package/extensions/check/failures.ts

@@ -0,0 +1,230 @@
+/**
+ * Best-effort failure extraction from a check command's output.
+ *
+ * Known runner lines (pytest, Go, Cargo, Vitest/Jest) are recognized first; the
+ * generic `path:line(:col): message` parser is the fallback, so any compiler or
+ * linter with a conventional location works without a runner-specific parser.
+ * A miss is never guessed at: the caller falls back to a bounded tail with the
+ * command's exit status.
+ */
+
+import { stripControlChars } from "../../lib/format.ts";
+import type { Failure } from "./types.ts";
+
+/** Failures retained from one command; the model list is capped lower. */
+const MAX_FAILURES = 200;
+
+/** One clean line, without control characters or a trailing CR. */
+function cleanLine(text: string): string {
+	return stripControlChars(text.replace(/\r/g, "")).trim();
+}
+
+/** Whether a candidate looks like a path rather than prose or a URL. */
+function looksLikePath(path: string): boolean {
+	if (path === "" || path.startsWith("http://") || path.startsWith("https://")) return false;
+	return path.includes("/") || path.includes("\\") || path.includes(".");
+}
+
+/** A number from a regex group, or undefined when the group did not match. */
+function numberFrom(group: string | undefined): number | undefined {
+	return group === undefined ? undefined : Number.parseInt(group, 10);
+}
+
+/**
+ * A failure at a parsed location, or undefined when the path is not a path the
+ * extension is willing to point at. A column is kept only when it parsed, so a
+ * two-part location never carries a `NaN`.
+ */
+function locatedFailure(
+	path: string,
+	line: number | undefined,
+	column: number | undefined,
+	rest: Pick<Failure, "message" | "command"> & { test?: string },
+): Failure | undefined {
+	if (!looksLikePath(path) || line === undefined || !Number.isFinite(line)) return undefined;
+	const known = column !== undefined && Number.isFinite(column) ? column : undefined;
+	return { path, line, ...(known === undefined ? {} : { column: known }), ...rest };
+}
+
+/** The generic compiler/linter location: `path:line(:col): message`. */
+function genericFailure(line: string, command: string): Failure | undefined {
+	const match = /^(.*?):(\d+)(?::(\d+))?:\s*(.+)$/.exec(line);
+	if (!match) return undefined;
+	const path = match[1]?.trim() ?? "";
+	const message = match[4]?.trim() ?? "";
+	if (message === "") return undefined;
+	if (path.startsWith("at ") || path.startsWith("thread ")) return undefined;
+	return locatedFailure(path, numberFrom(match[2]), numberFrom(match[3]), { message, command });
+}
+
+/** Pytest's `FAILED path::test - message` line. */
+function pytestFailure(line: string, command: string): Failure | undefined {
+	const match = /^FAILED\s+(.+?)::(\S+)(?:\s+-\s+(.*))?$/.exec(line);
+	if (!match) return undefined;
+	const path = match[1]?.trim() ?? "";
+	const test = match[2]?.trim() ?? "";
+	const message = match[3]?.trim() || "Test failed";
+	if (!path || !test) return undefined;
+	return { path, test, message, command };
+}
+
+/** Vitest/Jest's `FAIL path > suite > test` line. */
+function failLine(rest: string, command: string): Failure | undefined {
+	const match = /^\s*FAIL\s+(.+?)(?:\s+>\s+.*)?$/.exec(rest);
+	if (!match) return undefined;
+	const path = match[1]?.trim() ?? "";
+	if (!looksLikePath(path)) return undefined;
+	return { path, message: "Test failed", command };
+}
+
+/** Jest/Vitest's `● suite > test` name; the next located frame attaches it. */
+function testName(line: string): string | undefined {
+	const match = /^●\s+(.+)$/.exec(line);
+	return match?.[1]?.trim() || undefined;
+}
+
+/** A stack frame with a real location: `at … (path:line:col)` or `at path:line:col`. */
+function stackFailure(line: string, command: string, pendingTest: string | undefined): Failure | undefined {
+	const parenthesized = /^\s*at\s+.*?\((.+?):(\d+)(?::(\d+))?\)\s*$/.exec(line);
+	const bare = parenthesized ? undefined : /^\s*at\s+(.+?):(\d+)(?::(\d+))?\s*$/.exec(line);
+	const match = parenthesized ?? bare;
+	if (!match) return undefined;
+	const path = match[1]?.trim() ?? "";
+	return locatedFailure(path, numberFrom(match[2]), numberFrom(match[3]), {
+		...(pendingTest ? { test: pendingTest } : {}),
+		message: pendingTest ? "Test failed" : "Stack frame",
+		command,
+	});
+}
+
+/** Python's `File "path", line N, in test` traceback line. */
+function pythonTraceback(line: string, command: string, pendingTest: string | undefined): Failure | undefined {
+	const match = /^File "(.+)", line (\d+)/.exec(line);
+	if (!match) return undefined;
+	const path = match[1]?.trim() ?? "";
+	return locatedFailure(path, numberFrom(match[2]), undefined, {
+		...(pendingTest ? { test: pendingTest } : {}),
+		message: pendingTest ? "Test failed" : "Traceback",
+		command,
+	});
+}
+
+/** Go's `--- FAIL: TestName` line; the next location attaches to it. */
+function goFailure(line: string, command: string): Failure | undefined {
+	const match = /^--- FAIL:\s+(\S+)/.exec(line);
+	if (!match) return undefined;
+	return { test: match[1] ?? "test", message: "Test failed", command };
+}
+
+/** Cargo's `thread 'test' panicked at path:line:col:` line. */
+function cargoFailure(line: string, command: string): Failure | undefined {
+	const match = /^thread '(.+)' panicked at (.+?):(\d+)(?::(\d+))?:$/.exec(line);
+	if (!match) return undefined;
+	const path = match[2]?.trim() ?? "";
+	return locatedFailure(path, numberFrom(match[3]), numberFrom(match[4]), {
+		test: match[1],
+		message: "Panicked",
+		command,
+	});
+}
+
+/**
+ * Stable identity for dedupe. The command joins the key only when two commands'
+ * failures must not merge, which is the cross-command pass in `runtime.ts`.
+ */
+export function failureKey(failure: Failure, options: { command?: boolean } = {}): string {
+	const fields: Array<string | number | undefined> = [failure.path, failure.line, failure.column, failure.test];
+	if (options.command) fields.push(failure.command);
+	fields.push(failure.message);
+	return fields.map((field) => field ?? "").join("\u0000");
+}
+
+/**
+ * Parse the failures in one command's bounded output.
+ *
+ * A passing command has no failures even if a warning matched; parsing is only
+ * used after a non-zero exit. A failed command with no recognizable failure
+ * gets one honest fallback instead of an invented location.
+ */
+export function parseFailures(output: string, command: string, exitCode: number | null): Failure[] {
+	if (exitCode === 0) return [];
+	const failures: Failure[] = [];
+	const seen = new Set<string>();
+	let pendingTest: string | undefined;
+
+	const add = (failure: Failure | undefined): void => {
+		if (!failure) return;
+		const normalized: Failure = {
+			...failure,
+			message: cleanLine(failure.message),
+			...(failure.test ? { test: cleanLine(failure.test) } : {}),
+			...(failure.path ? { path: cleanLine(failure.path) } : {}),
+		};
+		if (!normalized.message) return;
+		const key = failureKey(normalized);
+		if (seen.has(key)) return;
+		seen.add(key);
+		if (failures.length < MAX_FAILURES) failures.push(normalized);
+	};
+
+	for (const raw of output.split("\n")) {
+		const line = cleanLine(raw);
+		if (!line) continue;
+
+		const test = testName(line);
+		if (test) {
+			pendingTest = test;
+			continue;
+		}
+
+		const go = goFailure(line, command);
+		if (go) {
+			pendingTest = go.test;
+			add(go);
+			continue;
+		}
+
+		const stack = stackFailure(line, command, pendingTest);
+		if (stack) {
+			add(stack);
+			pendingTest = undefined;
+			continue;
+		}
+
+		const python = pythonTraceback(line, command, pendingTest);
+		if (python) {
+			add(python);
+			pendingTest = undefined;
+			continue;
+		}
+
+		const cargo = cargoFailure(line, command);
+		if (cargo) {
+			add(cargo);
+			continue;
+		}
+
+		const pytest = pytestFailure(line, command);
+		if (pytest) {
+			add(pytest);
+			continue;
+		}
+
+		const failed = failLine(line, command);
+		if (failed) {
+			add(failed);
+			continue;
+		}
+
+		const generic = genericFailure(line, command);
+		if (generic) {
+			add(pendingTest ? { ...generic, test: pendingTest } : generic);
+			pendingTest = undefined;
+		}
+	}
+
+	if (failures.length > 0) return failures;
+	return [
+		{ message: exitCode === null ? "Command did not exit cleanly" : `Command exited with status ${exitCode}`, command },
+	];
+}

package/extensions/check/format.ts

@@ -0,0 +1,135 @@
+/**
+ * Pure text for the check extension: the one-line summary, failure rows, the
+ * detail body, and the model-facing report. No terminal access and no git.
+ */
+
+import { formatDuration, sanitizeLine, stripControlChars } from "../../lib/format.ts";
+import { SEPARATORS } from "../../lib/tui/glyphs.ts";
+import type { CheckResult, CheckStatus, Failure } from "./types.ts";
+import type { SourceResult } from "./source.ts";
+
+/** Failures shown in a model-facing report and in an expanded transcript result. */
+export const MODEL_FAILURES = 20;
+
+/**
+ * What the summary helpers read: a final result, or the run details a partial
+ * transcript result carries with `status: "running"`.
+ */
+export interface CheckSummary {
+	status: CheckStatus | "running";
+	commands: readonly string[];
+	durationMs: number;
+	failures: readonly Failure[];
+	error?: string;
+}
+
+/** Command labels are script names and config text, so they are untrusted too. */
+function formatCommands(commands: readonly string[]): string {
+	return commands.length > 0 ? commands.map((command) => sanitizeLine(command)).join(", ") : "no command";
+}
+
+/** Whether a failure named a file, a test, or both. */
+export function hasFailureLocation(failure: Failure): boolean {
+	return failure.path !== undefined || failure.test !== undefined;
+}
+
+/** `path:line:col`, a test name, or a neutral label. */
+export function formatFailureLocation(failure: Failure): string {
+	if (failure.path) {
+		const line = failure.line === undefined ? "" : `:${failure.line}`;
+		const column = failure.column === undefined ? "" : `:${failure.column}`;
+		return sanitizeLine(`${failure.path}${line}${column}`);
+	}
+	return sanitizeLine(failure.test ?? "check");
+}
+
+/** `path:line:col — message`, one line. */
+export function formatFailureLine(failure: Failure): string {
+	return `${formatFailureLocation(failure)}${SEPARATORS.item}${sanitizeLine(failure.message)}`;
+}
+
+/** The one-line result a passing run posts, and the headline of a failed one. */
+export function formatCheckSummary(result: CheckResult): string {
+	const commands = formatCommands(result.commands);
+	const duration = formatDuration(result.durationMs);
+	if (result.status === "passed") return `Check passed: ${commands}${SEPARATORS.item}${duration}`;
+	if (result.status === "failed") {
+		const count = result.failures.length;
+		return `Check failed: ${count} failure${count === 1 ? "" : "s"}${SEPARATORS.item}${commands}${SEPARATORS.item}${duration}`;
+	}
+	if (result.status === "timeout") return `Check timed out: ${commands}${SEPARATORS.item}${duration}`;
+	if (result.status === "cancelled") return `Check cancelled: ${commands}`;
+	return `Check failed to run: ${sanitizeLine(result.error ?? "unknown error")}`;
+}
+
+/** The compact summary under the Check title and on a transcript result. */
+export function formatResultSummary(result: CheckSummary): string {
+	const commands = formatCommands(result.commands);
+	const duration = formatDuration(result.durationMs);
+	if (result.status === "running") return `running${SEPARATORS.item}${commands}${SEPARATORS.item}${duration}`;
+	if (result.status === "passed") return `passed${SEPARATORS.item}${commands}${SEPARATORS.item}${duration}`;
+	if (result.status === "failed") {
+		const count = result.failures.length;
+		// A fallback entry is the exit status, not a counted failure; the summary
+		// says "failed" and the tail carries the reason.
+		if (count > 0 && result.failures.every((failure) => !hasFailureLocation(failure))) {
+			return `failed${SEPARATORS.item}${commands}${SEPARATORS.item}${duration}`;
+		}
+		return `${count} failure${count === 1 ? "" : "s"}${SEPARATORS.item}${commands}${SEPARATORS.item}${duration}`;
+	}
+	if (result.status === "timeout") return `timed out${SEPARATORS.item}${commands}${SEPARATORS.item}${duration}`;
+	if (result.status === "cancelled") return `cancelled${SEPARATORS.item}${commands}`;
+	return `error${SEPARATORS.item}${sanitizeLine(result.error ?? "unknown error")}`;
+}
+
+/** The source excerpt rows with a target marker and aligned line numbers. */
+export function formatSourceExcerpt(excerpt: {
+	startLine: number;
+	endLine: number;
+	targetLine: number;
+	lines: readonly string[];
+}): string[] {
+	const width = String(excerpt.endLine).length;
+	return excerpt.lines.map((text, index) => {
+		const number = excerpt.startLine + index;
+		const marker = number === excerpt.targetLine ? ">" : " ";
+		const clean = stripControlChars(text).replaceAll("\t", "    ").slice(0, 2_000).trimEnd();
+		return `${marker} ${String(number).padStart(width)} │ ${clean}`;
+	});
+}
+
+/** The lines a failure detail pane shows: location, reason, source or tail. */
+export function formatFailureDetail(failure: Failure, tail: string, source?: SourceResult): string[] {
+	const lines = [
+		`${formatFailureLocation(failure)}${SEPARATORS.item}${sanitizeLine(failure.command)}`,
+		"",
+		...sanitizeLine(failure.message).split("\n"),
+	];
+	if (source?.ok) {
+		lines.push("", "Source:", ...formatSourceExcerpt(source.excerpt));
+		return lines;
+	}
+	if (source && failure.path) lines.push("", `(source unavailable: ${sanitizeLine(source.reason)})`);
+	const tailLines = tail
+		.split("\n")
+		.map((line) => sanitizeLine(line))
+		.filter((line, index, all) => line !== "" || index === all.length - 1);
+	if (tailLines.length > 0) lines.push("", "…", ...tailLines);
+	return lines;
+}
+
+/** The model-facing report: summary, up to 20 failures, then the fallback tail. */
+export function formatCheckReport(result: CheckResult): string {
+	const lines = [formatCheckSummary(result)];
+	for (const failure of result.failures.slice(0, MODEL_FAILURES)) {
+		lines.push(`- ${formatFailureLine(failure)}${SEPARATORS.item}${sanitizeLine(failure.command)}`);
+	}
+	if (result.failures.length > MODEL_FAILURES) {
+		lines.push(`… ${result.failures.length - MODEL_FAILURES} more failures in details`);
+	}
+	const fallbackOnly = result.failures.length > 0 && result.failures.every((failure) => !hasFailureLocation(failure));
+	if ((result.failures.length === 0 || fallbackOnly) && result.status !== "passed" && result.tail.trim() !== "") {
+		lines.push("", "Tail:", result.tail);
+	}
+	return lines.join("\n");
+}

package/extensions/check/index.ts

@@ -0,0 +1,26 @@
+/**
+ * check — cross-stack verification runs.
+ *
+ * Registers `/check` and the `run_check` tool. Detection and parsing know about
+ * project manifests and runner output; the runtime, screens, and tool speak in
+ * commands and failures, never in a language or package manager.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isExtensionEnabled } from "../../lib/env.ts";
+import { registerCheckCommand } from "./commands.ts";
+import { createCheckRuntime } from "./runtime.ts";
+import { registerCheckTool } from "./tools.ts";
+
+export function registerCheck(pi: ExtensionAPI): void {
+	const runtime = createCheckRuntime();
+	registerCheckTool(pi, runtime);
+	registerCheckCommand(pi, runtime);
+	pi.on("session_shutdown", () => runtime.shutdown());
+}
+
+/** Pi extension entrypoint. */
+export default function checkExtension(pi: ExtensionAPI): void {
+	if (!isExtensionEnabled("check")) return;
+	registerCheck(pi);
+}