@oh-my-pi/pi-coding-agent 14.5.6 → 14.5.8

package/src/tools/run-command/runner.ts

@@ -0,0 +1,198 @@
+import { ToolError } from "../tool-errors";
+
+export interface RunnerTask {
+	name: string;
+	doc?: string;
+	/** Parameter names only; used for the `name foo bar` signature line in the description. */
+	parameters: string[];
+	/** Override for this specific task, e.g. `cargo run --package crate --bin`. */
+	commandPrefix?: string;
+	/** Token passed to the runner command; defaults to `name`. Used when display names are namespaced. */
+	commandName?: string;
+}
+
+export interface DetectedRunner {
+	id: string;
+	label: string;
+	/** Resolved shell prefix, e.g. "just" or "bun run" or "make". */
+	commandPrefix: string;
+	tasks: RunnerTask[];
+}
+
+export interface TaskRunner {
+	id: string;
+	label: string;
+	/**
+	 * Probe `cwd` for the manifest, the binary, and the task list.
+	 * Returns null when this runner does not apply.
+	 */
+	detect(cwd: string): Promise<DetectedRunner | null>;
+}
+
+interface ParsedOp {
+	head: string;
+	tail: string;
+}
+
+interface PromptTaskModel {
+	name: string;
+	paramSig?: string;
+	command?: string;
+	doc?: string;
+}
+
+interface PromptRunnerModel {
+	id: string;
+	label: string;
+	commandPrefix: string;
+	tasks: PromptTaskModel[];
+}
+
+export interface RunCommandPromptModel {
+	[key: string]: unknown;
+	hasMultipleRunners: boolean;
+	ambiguityExampleRunner?: string;
+	ambiguityExampleTask?: string;
+	runners: PromptRunnerModel[];
+}
+
+function parseOp(op: string): ParsedOp {
+	const trimmedStart = op.trimStart();
+	if (trimmedStart.length === 0) return { head: "", tail: "" };
+	const match = /^(\S+)(?:\s+([\s\S]*))?$/u.exec(trimmedStart);
+	return { head: match?.[1] ?? "", tail: match?.[2] ?? "" };
+}
+
+function findRunnerById(id: string, runners: DetectedRunner[]): DetectedRunner | undefined {
+	return runners.find(runner => runner.id === id);
+}
+
+function hasTask(runner: DetectedRunner, taskName: string): boolean {
+	return runner.tasks.some(task => task.name === taskName);
+}
+
+function findMatchingRunners(taskName: string, runners: DetectedRunner[]): DetectedRunner[] {
+	return runners.filter(runner => hasTask(runner, taskName));
+}
+
+function formatAvailableTasks(runners: DetectedRunner[]): string {
+	return runners
+		.map(runner => {
+			const names = runner.tasks.map(task => task.name).join(", ");
+			return `- ${runner.id}: ${names || "(no tasks)"}`;
+		})
+		.join("\n");
+}
+
+function formatRunnerIds(runners: DetectedRunner[]): string {
+	return runners.map(runner => runner.id).join(", ");
+}
+
+function buildCommand(commandPrefix: string, taskName: string, tail: string): string {
+	return [commandPrefix, taskName, tail]
+		.filter(part => part.trim().length > 0)
+		.join(" ")
+		.trim();
+}
+
+function resolveRunnerAndTask(
+	op: string,
+	runners: DetectedRunner[],
+): { runner: DetectedRunner; task: RunnerTask; tail: string } {
+	const { head, tail } = parseOp(op);
+	if (!head) {
+		throw new ToolError(`run_command op is empty. Available tasks:\n${formatAvailableTasks(runners)}`);
+	}
+
+	const colonIndex = head.indexOf(":");
+	if (colonIndex > 0) {
+		const maybeRunnerId = head.slice(0, colonIndex);
+		const explicitRunner = findRunnerById(maybeRunnerId, runners);
+		if (explicitRunner) {
+			const taskName = head.slice(colonIndex + 1);
+			const explicitTask = explicitRunner.tasks.find(task => task.name === taskName);
+			if (!taskName || !explicitTask) {
+				throw new ToolError(
+					`Task \`${taskName || "(empty)"}\` not found in runner \`${explicitRunner.id}\`. Available tasks:\n${formatAvailableTasks(runners)}`,
+				);
+			}
+			return { runner: explicitRunner, task: explicitTask, tail };
+		}
+	}
+
+	const matches = findMatchingRunners(head, runners);
+	if (matches.length === 1) {
+		return { runner: matches[0]!, task: matches[0]!.tasks.find(task => task.name === head)!, tail };
+	}
+	if (matches.length > 1) {
+		const ids = matches.map(runner => runner.id).join(", ");
+		throw new ToolError(
+			`Task \`${head}\` exists in multiple runners (${ids}). Use \`<runner-id>:<task>\`, for example \`${matches[0]!.id}:${head}\`. Available tasks:\n${formatAvailableTasks(runners)}`,
+		);
+	}
+
+	throw new ToolError(
+		`No runner task named \`${head}\`. Use one of the available runner ids (${formatRunnerIds(runners)}) as a prefix when needed, e.g. \`pkg:${head}\`. Available tasks:\n${formatAvailableTasks(runners)}`,
+	);
+}
+
+export function resolveCommand(op: string, runners: DetectedRunner[]): string {
+	const { runner, task, tail } = resolveRunnerAndTask(op, runners);
+	return buildCommand(task.commandPrefix ?? runner.commandPrefix, task.commandName ?? task.name, tail);
+}
+
+export function commandFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined {
+	if (!op) return undefined;
+	try {
+		return resolveCommand(op, runners);
+	} catch {
+		return undefined;
+	}
+}
+
+export function titleFromOp(op: string | undefined, runners: DetectedRunner[]): string {
+	if (!op) return "Run";
+	const { head } = parseOp(op);
+	if (!head) return "Run";
+	const colonIndex = head.indexOf(":");
+	if (colonIndex > 0) {
+		const runner = findRunnerById(head.slice(0, colonIndex), runners);
+		return runner?.label ?? "Run";
+	}
+	const matches = findMatchingRunners(head, runners);
+	return matches.length === 1 ? matches[0]!.label : "Run";
+}
+
+function findAmbiguityExample(runners: DetectedRunner[]): { runner: string; task: string } | undefined {
+	const seen = new Map<string, string>();
+	for (const runner of runners) {
+		for (const task of runner.tasks) {
+			const previousRunner = seen.get(task.name);
+			if (previousRunner) return { runner: previousRunner, task: task.name };
+			seen.set(task.name, runner.id);
+		}
+	}
+	const firstRunner = runners[0];
+	const firstTask = firstRunner?.tasks[0];
+	return firstRunner && firstTask ? { runner: firstRunner.id, task: firstTask.name } : undefined;
+}
+
+export function buildPromptModel(runners: DetectedRunner[]): RunCommandPromptModel {
+	const ambiguityExample = findAmbiguityExample(runners);
+	return {
+		hasMultipleRunners: runners.length > 1,
+		ambiguityExampleRunner: ambiguityExample?.runner,
+		ambiguityExampleTask: ambiguityExample?.task,
+		runners: runners.map(runner => ({
+			id: runner.id,
+			label: runner.label,
+			commandPrefix: runner.commandPrefix,
+			tasks: runner.tasks.map(task => ({
+				name: task.name,
+				paramSig: task.parameters.length > 0 ? task.parameters.join(" ") : undefined,
+				command: buildCommand(task.commandPrefix ?? runner.commandPrefix, task.commandName ?? task.name, ""),
+				doc: task.doc,
+			})),
+		})),
+	};
+}

package/src/tools/run-command/runners/cargo.ts

@@ -0,0 +1,131 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { $which, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import type { DetectedRunner, RunnerTask, TaskRunner } from "../runner";
+
+export interface CargoMetadataTarget {
+	kind?: string[];
+	name?: string;
+}
+
+export interface CargoMetadataPackage {
+	id?: string;
+	name?: string;
+	targets?: CargoMetadataTarget[];
+}
+
+export interface CargoMetadata {
+	packages?: CargoMetadataPackage[];
+	workspace_members?: string[];
+}
+
+type CargoTargetKind = "bin" | "example" | "test";
+
+async function hasCargoManifest(cwd: string): Promise<boolean> {
+	try {
+		const stat = await fs.stat(path.join(cwd, "Cargo.toml"));
+		return stat.isFile();
+	} catch (err) {
+		if (isEnoent(err)) return false;
+		throw err;
+	}
+}
+
+function shellQuote(value: string): string {
+	return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+function cargoTargetKind(target: CargoMetadataTarget): CargoTargetKind | undefined {
+	if (target.kind?.includes("bin")) return "bin";
+	if (target.kind?.includes("example")) return "example";
+	if (target.kind?.includes("test")) return "test";
+	return undefined;
+}
+
+function commandPrefixForTarget(packageName: string, kind: CargoTargetKind): string {
+	const packageFlag = `--package ${shellQuote(packageName)}`;
+	switch (kind) {
+		case "bin":
+			return `cargo run ${packageFlag} --bin`;
+		case "example":
+			return `cargo run ${packageFlag} --example`;
+		case "test":
+			return `cargo test ${packageFlag} --test`;
+	}
+}
+
+function taskNameForTarget(
+	packageName: string,
+	kind: CargoTargetKind,
+	targetName: string,
+	isWorkspace: boolean,
+): string {
+	const category = kind === "bin" ? "bin" : kind;
+	return isWorkspace ? `${packageName}/${category}/${targetName}` : `${category}/${targetName}`;
+}
+
+export function tasksFromCargoMetadata(metadata: CargoMetadata): RunnerTask[] {
+	const workspaceMembers = new Set(metadata.workspace_members ?? []);
+	const workspacePackages = (metadata.packages ?? []).filter(pkg => pkg.id && workspaceMembers.has(pkg.id));
+	const packages = workspacePackages.length > 0 ? workspacePackages : (metadata.packages ?? []);
+	const isWorkspace = packages.length > 1;
+	const tasks: RunnerTask[] = [];
+	const seen = new Set<string>();
+
+	for (const pkg of packages) {
+		if (!pkg.name) continue;
+		for (const target of pkg.targets ?? []) {
+			if (!target.name) continue;
+			const kind = cargoTargetKind(target);
+			if (!kind) continue;
+			const name = taskNameForTarget(pkg.name, kind, target.name, isWorkspace);
+			if (seen.has(name)) continue;
+			seen.add(name);
+			tasks.push({
+				name,
+				doc: `${pkg.name} ${kind} target ${target.name}`,
+				parameters: [],
+				commandPrefix: commandPrefixForTarget(pkg.name, kind),
+				commandName: shellQuote(target.name),
+			});
+		}
+	}
+
+	return tasks;
+}
+
+async function readCargoMetadata(cwd: string): Promise<CargoMetadata | null> {
+	try {
+		const proc = Bun.spawn(["cargo", "metadata", "--no-deps", "--format-version=1"], {
+			cwd,
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const [stdout, exit] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+		if (exit !== 0) return null;
+		return JSON.parse(stdout) as CargoMetadata;
+	} catch (err) {
+		logger.debug("cargo metadata failed", { error: err instanceof Error ? err.message : String(err) });
+		return null;
+	}
+}
+
+export const cargoRunner: TaskRunner = {
+	id: "cargo",
+	label: "Cargo",
+	async detect(cwd: string): Promise<DetectedRunner | null> {
+		try {
+			if (!$which("cargo")) return null;
+			if (!(await hasCargoManifest(cwd))) return null;
+			const metadata = await readCargoMetadata(cwd);
+			if (!metadata) return null;
+			const tasks = tasksFromCargoMetadata(metadata);
+			if (tasks.length === 0) return null;
+			return { id: "cargo", label: "Cargo", commandPrefix: "cargo", tasks };
+		} catch (err) {
+			logger.debug("cargo runner probe failed", { error: err instanceof Error ? err.message : String(err) });
+			return null;
+		}
+	},
+};

package/src/tools/run-command/runners/index.ts

@@ -0,0 +1,8 @@
+import type { TaskRunner } from "../runner";
+import { cargoRunner } from "./cargo";
+import { justRunner } from "./just";
+import { makeRunner } from "./make";
+import { pkgRunner } from "./pkg";
+import { taskRunner } from "./task";
+
+export const RUNNERS: TaskRunner[] = [justRunner, pkgRunner, cargoRunner, makeRunner, taskRunner];

package/src/tools/run-command/runners/just.ts

@@ -0,0 +1,73 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { $which, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import type { DetectedRunner, RunnerTask, TaskRunner } from "../runner";
+
+interface JustDumpRecipeRaw {
+	name?: string;
+	doc?: string | null;
+	private?: boolean;
+	parameters?: Array<{ name?: string }>;
+}
+
+interface JustDump {
+	recipes?: Record<string, JustDumpRecipeRaw>;
+}
+
+const JUSTFILE_NAMES = ["justfile", "Justfile", ".justfile"] as const;
+
+async function hasJustfile(cwd: string): Promise<boolean> {
+	for (const name of JUSTFILE_NAMES) {
+		try {
+			const stat = await fs.stat(path.join(cwd, name));
+			if (stat.isFile()) return true;
+		} catch (err) {
+			if (!isEnoent(err)) throw err;
+		}
+	}
+	return false;
+}
+
+async function dumpJustTasks(cwd: string): Promise<RunnerTask[] | null> {
+	try {
+		const proc = Bun.spawn(["just", "--dump", "--dump-format=json"], {
+			cwd,
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const [stdout, exit] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+		if (exit !== 0) return null;
+		const dump = JSON.parse(stdout) as JustDump;
+		const tasks: RunnerTask[] = [];
+		for (const recipe of Object.values(dump.recipes ?? {})) {
+			if (!recipe.name || recipe.private) continue;
+			const parameters = (recipe.parameters ?? [])
+				.map(parameter => parameter.name)
+				.filter((name): name is string => typeof name === "string" && name.length > 0);
+			const doc = typeof recipe.doc === "string" && recipe.doc.length > 0 ? recipe.doc : undefined;
+			tasks.push({ name: recipe.name, doc, parameters });
+		}
+		return tasks;
+	} catch (err) {
+		logger.debug("just task detection failed", { error: err instanceof Error ? err.message : String(err) });
+		return null;
+	}
+}
+
+export const justRunner: TaskRunner = {
+	id: "just",
+	label: "Just",
+	async detect(cwd: string): Promise<DetectedRunner | null> {
+		try {
+			if (!$which("just")) return null;
+			if (!(await hasJustfile(cwd))) return null;
+			const tasks = await dumpJustTasks(cwd);
+			if (!tasks || tasks.length === 0) return null;
+			return { id: "just", label: "Just", commandPrefix: "just", tasks };
+		} catch (err) {
+			logger.debug("just runner probe failed", { error: err instanceof Error ? err.message : String(err) });
+			return null;
+		}
+	},
+};

package/src/tools/run-command/runners/make.ts

@@ -0,0 +1,101 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { $which, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import type { DetectedRunner, RunnerTask, TaskRunner } from "../runner";
+
+const MAKEFILE_NAMES = ["Makefile", "makefile", "GNUmakefile"] as const;
+const TARGET_PATTERN = /^(?<name>[A-Za-z_][A-Za-z0-9_-]*)\s*:(?!=).*?(?:##\s*(?<doc>.+))?$/u;
+const PHONY_PATTERN = /^\.PHONY\s*:\s*(?<targets>.*)$/u;
+
+interface MakeTargetInfo {
+	name: string;
+	doc?: string;
+	order: number;
+	phony: boolean;
+}
+
+async function findMakefile(cwd: string): Promise<string | null> {
+	for (const name of MAKEFILE_NAMES) {
+		const candidate = path.join(cwd, name);
+		try {
+			const stat = await fs.stat(candidate);
+			if (stat.isFile()) return candidate;
+		} catch (err) {
+			if (!isEnoent(err)) throw err;
+		}
+	}
+	return null;
+}
+
+function isVariableAssignment(line: string, name: string): boolean {
+	return new RegExp(`^\\s*${name}\\s*[:?+]?=`, "u").test(line);
+}
+
+function parsePhonyTargets(line: string): string[] {
+	const match = PHONY_PATTERN.exec(line);
+	if (!match?.groups?.targets) return [];
+	return match.groups.targets
+		.split(/\s+/u)
+		.map(target => target.trim())
+		.filter(target => /^[A-Za-z_][A-Za-z0-9_-]*$/u.test(target));
+}
+
+function parseMakeTargets(text: string): RunnerTask[] {
+	const targets = new Map<string, MakeTargetInfo>();
+	const phonyTargets: string[] = [];
+	let order = 0;
+
+	for (const line of text.split("\n")) {
+		for (const target of parsePhonyTargets(line)) {
+			if (!phonyTargets.includes(target)) phonyTargets.push(target);
+		}
+
+		const match = TARGET_PATTERN.exec(line);
+		const name = match?.groups?.name;
+		if (!name || name === ".PHONY" || isVariableAssignment(line, name)) continue;
+		if (targets.has(name)) continue;
+		const rawDoc = match?.groups?.doc?.trim();
+		const doc = rawDoc && rawDoc.length > 0 ? rawDoc : undefined;
+		targets.set(name, { name, doc, order, phony: false });
+		order += 1;
+	}
+
+	for (const phony of phonyTargets) {
+		const existing = targets.get(phony);
+		if (existing) {
+			existing.phony = true;
+			continue;
+		}
+		targets.set(phony, { name: phony, order, phony: true });
+		order += 1;
+	}
+
+	const hasPhonyTargets = phonyTargets.length > 0;
+	return [...targets.values()]
+		.sort((left, right) => left.order - right.order)
+		.flatMap(target => {
+			if (!hasPhonyTargets || target.phony) {
+				return [{ name: target.name, doc: target.doc, parameters: [] }];
+			}
+			if (!target.doc) return [];
+			return [{ name: target.name, doc: `${target.doc} (file target)`, parameters: [] }];
+		});
+}
+
+export const makeRunner: TaskRunner = {
+	id: "make",
+	label: "Make",
+	async detect(cwd: string): Promise<DetectedRunner | null> {
+		try {
+			if (!$which("make")) return null;
+			const makefile = await findMakefile(cwd);
+			if (!makefile) return null;
+			const tasks = parseMakeTargets(await Bun.file(makefile).text());
+			if (tasks.length === 0) return null;
+			return { id: "make", label: "Make", commandPrefix: "make", tasks };
+		} catch (err) {
+			logger.debug("make runner probe failed", { error: err instanceof Error ? err.message : String(err) });
+			return null;
+		}
+	},
+};