@oh-my-pi/pi-coding-agent 15.5.15 → 15.7.0

package/src/tools/hindsight-recall.ts

@@ -1,69 +0,0 @@
-import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
-import { formatCurrentTime, formatMemories } from "../hindsight/content";
-import recallDescription from "../prompts/tools/recall.md" with { type: "text" };
-import type { ToolSession } from ".";
-
-const hindsightRecallSchema = z.object({
-	query: z.string().describe("natural language search query"),
-});
-
-export type HindsightRecallParams = z.infer<typeof hindsightRecallSchema>;
-
-export class HindsightRecallTool implements AgentTool<typeof hindsightRecallSchema> {
-	readonly name = "recall";
-	readonly approval = "read" as const;
-	readonly label = "Recall";
-	readonly description = recallDescription;
-	readonly parameters = hindsightRecallSchema;
-	readonly strict = true;
-	readonly loadMode = "discoverable";
-	readonly summary = "Search hindsight memory for relevant prior context";
-
-	constructor(private readonly session: ToolSession) {}
-
-	static createIf(session: ToolSession): HindsightRecallTool | null {
-		if (session.settings.get("memory.backend") !== "hindsight") return null;
-		return new HindsightRecallTool(session);
-	}
-
-	async execute(_id: string, params: HindsightRecallParams, signal?: AbortSignal): Promise<AgentToolResult> {
-		return untilAborted(signal, async () => {
-			const state = this.session.getHindsightSessionState?.();
-			if (!state) {
-				throw new Error("Hindsight backend is not initialised for this session.");
-			}
-
-			try {
-				const response = await state.client.recall(state.bankId, params.query, {
-					budget: state.config.recallBudget,
-					maxTokens: state.config.recallMaxTokens,
-					types: state.config.recallTypes.length > 0 ? state.config.recallTypes : undefined,
-					tags: state.recallTags,
-					tagsMatch: state.recallTagsMatch,
-				});
-				const results = response.results ?? [];
-				if (results.length === 0) {
-					return {
-						content: [{ type: "text", text: "No relevant memories found." }],
-						details: {},
-					};
-				}
-				const formatted = formatMemories(results);
-				return {
-					content: [
-						{
-							type: "text",
-							text: `Found ${results.length} relevant memories (as of ${formatCurrentTime()} UTC):\n\n${formatted}`,
-						},
-					],
-					details: {},
-				};
-			} catch (err) {
-				logger.warn("recall failed", { bankId: state.bankId, error: String(err) });
-				throw err instanceof Error ? err : new Error(String(err));
-			}
-		});
-	}
-}

package/src/tools/hindsight-reflect.ts

@@ -1,58 +0,0 @@
-import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
-import { ensureBankMission } from "../hindsight/bank";
-import reflectDescription from "../prompts/tools/reflect.md" with { type: "text" };
-import type { ToolSession } from ".";
-
-const hindsightReflectSchema = z.object({
-	query: z.string().describe("question to answer"),
-	context: z.string().describe("optional context").optional(),
-});
-
-export type HindsightReflectParams = z.infer<typeof hindsightReflectSchema>;
-
-export class HindsightReflectTool implements AgentTool<typeof hindsightReflectSchema> {
-	readonly name = "reflect";
-	readonly approval = "read" as const;
-	readonly label = "Reflect";
-	readonly description = reflectDescription;
-	readonly parameters = hindsightReflectSchema;
-	readonly strict = true;
-	readonly loadMode = "discoverable";
-	readonly summary = "Reflect on recent work and write hindsight memory";
-
-	constructor(private readonly session: ToolSession) {}
-
-	static createIf(session: ToolSession): HindsightReflectTool | null {
-		if (session.settings.get("memory.backend") !== "hindsight") return null;
-		return new HindsightReflectTool(session);
-	}
-
-	async execute(_id: string, params: HindsightReflectParams, signal?: AbortSignal): Promise<AgentToolResult> {
-		return untilAborted(signal, async () => {
-			const state = this.session.getHindsightSessionState?.();
-			if (!state) {
-				throw new Error("Hindsight backend is not initialised for this session.");
-			}
-
-			try {
-				await ensureBankMission(state.client, state.bankId, state.config, state.missionsSet);
-				const response = await state.client.reflect(state.bankId, params.query, {
-					context: params.context,
-					budget: state.config.recallBudget,
-					tags: state.recallTags,
-					tagsMatch: state.recallTagsMatch,
-				});
-				const text = response.text?.trim() || "No relevant information found to reflect on.";
-				return {
-					content: [{ type: "text", text }],
-					details: {},
-				};
-			} catch (err) {
-				logger.warn("reflect failed", { bankId: state.bankId, error: String(err) });
-				throw err instanceof Error ? err : new Error(String(err));
-			}
-		});
-	}
-}

package/src/tools/hindsight-retain.ts

@@ -1,57 +0,0 @@
-import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import * as z from "zod/v4";
-import retainDescription from "../prompts/tools/retain.md" with { type: "text" };
-import type { ToolSession } from ".";
-
-const hindsightRetainSchema = z.object({
-	items: z
-		.array(
-			z.object({
-				content: z.string().describe("information to remember"),
-				context: z.string().describe("source context").optional(),
-			}),
-		)
-		.min(1)
-		.describe("memories to retain"),
-});
-
-export type HindsightRetainParams = z.infer<typeof hindsightRetainSchema>;
-export class HindsightRetainTool implements AgentTool<typeof hindsightRetainSchema> {
-	readonly name = "retain";
-	readonly approval = "read" as const;
-	readonly label = "Retain";
-	readonly description = retainDescription;
-	readonly parameters = hindsightRetainSchema;
-	readonly strict = true;
-	readonly loadMode = "discoverable";
-	readonly summary = "Store important facts in hindsight memory";
-
-	constructor(private readonly session: ToolSession) {}
-
-	static createIf(session: ToolSession): HindsightRetainTool | null {
-		if (session.settings.get("memory.backend") !== "hindsight") return null;
-		return new HindsightRetainTool(session);
-	}
-
-	async execute(_id: string, params: HindsightRetainParams): Promise<AgentToolResult> {
-		const state = this.session.getHindsightSessionState?.();
-		if (!state) {
-			throw new Error("Hindsight backend is not initialised for this session.");
-		}
-
-		// Push every item onto the session-owned queue and return immediately.
-		// The queue flushes either when it reaches its batch threshold or when
-		// its debounce timer fires. If the eventual batch fails, the queue
-		// surfaces a UI-only warning notice — the LLM is not informed.
-		for (const item of params.items) {
-			state.enqueueRetain(item.content, item.context);
-		}
-
-		const count = params.items.length;
-		const noun = count === 1 ? "memory" : "memories";
-		return {
-			content: [{ type: "text", text: `${count} ${noun} queued.` }],
-			details: { count },
-		};
-	}
-}

package/src/tools/recipe/index.ts

@@ -1,81 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { prompt } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
-import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import type { Theme } from "../../modes/theme/theme";
-import recipeDescription from "../../prompts/tools/recipe.md" with { type: "text" };
-import type { ToolSession } from "..";
-import { type BashRenderContext, BashTool, type BashToolDetails } from "../bash";
-import { createRecipeToolRenderer, type RecipeRenderArgs } from "./render";
-import { buildPromptModel, type DetectedRunner, resolveCommand } from "./runner";
-import { RUNNERS } from "./runners";
-
-const recipeSchema = z
-	.object({
-		op: z.string().describe('task name and args, e.g. "test" or "build --release"'),
-	})
-	.strict();
-type RecipeParams = z.infer<typeof recipeSchema>;
-
-type RecipeRenderResult = {
-	content: Array<{ type: string; text?: string }>;
-	details?: BashToolDetails;
-	isError?: boolean;
-};
-
-export class RecipeTool implements AgentTool<typeof recipeSchema, BashToolDetails, Theme> {
-	readonly name = "recipe";
-	readonly label = "Run";
-	readonly approval = "exec" as const;
-	readonly description: string;
-	readonly parameters = recipeSchema;
-	readonly strict = true;
-	readonly concurrency = "exclusive";
-	readonly loadMode = "discoverable";
-	readonly summary = "Execute a saved bash recipe (multi-step shell command preset)";
-	readonly mergeCallAndResult = true;
-	readonly inline = true;
-	readonly renderCall: (args: RecipeRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;
-	readonly renderResult: (
-		result: RecipeRenderResult,
-		options: RenderResultOptions & { renderContext?: BashRenderContext },
-		uiTheme: Theme,
-		args?: RecipeRenderArgs,
-	) => Component;
-
-	readonly #bash: BashTool;
-	readonly #runners: DetectedRunner[];
-
-	constructor(session: ToolSession, runners: DetectedRunner[]) {
-		this.#runners = runners;
-		this.#bash = new BashTool(session);
-		this.description = prompt.render(recipeDescription, buildPromptModel(runners));
-		const renderer = createRecipeToolRenderer(runners);
-		this.renderCall = renderer.renderCall;
-		this.renderResult = renderer.renderResult;
-	}
-
-	static async createIf(session: ToolSession): Promise<RecipeTool | null> {
-		if (!session.settings.get("recipe.enabled")) return null;
-		const detected = (await Promise.all(RUNNERS.map(runner => runner.detect(session.cwd)))).filter(
-			(runner): runner is DetectedRunner => runner !== null && runner.tasks.length > 0,
-		);
-		if (detected.length === 0) return null;
-		return new RecipeTool(session, detected);
-	}
-
-	async execute(
-		toolCallId: string,
-		{ op }: RecipeParams,
-		signal?: AbortSignal,
-		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
-		ctx?: AgentToolContext,
-	): Promise<AgentToolResult<BashToolDetails>> {
-		const { command, cwd } = resolveCommand(op, this.#runners);
-		return await this.#bash.execute(toolCallId, { command, cwd }, signal, onUpdate, ctx);
-	}
-}
-
-export * from "./runner";
-export { tasksFromCargoMetadata } from "./runners/cargo";

package/src/tools/recipe/render.ts

@@ -1,19 +0,0 @@
-import { createShellRenderer } from "../bash";
-import type { DetectedRunner } from "./runner";
-import { commandFromOp, cwdFromOp, titleFromOp } from "./runner";
-
-export interface RecipeRenderArgs {
-	op?: string;
-	__partialJson?: string;
-	[key: string]: unknown;
-}
-
-export function createRecipeToolRenderer(runners: DetectedRunner[]) {
-	return createShellRenderer<RecipeRenderArgs>({
-		resolveTitle: args => titleFromOp(args?.op, runners),
-		resolveCommand: args => commandFromOp(args?.op, runners),
-		resolveCwd: args => cwdFromOp(args?.op, runners),
-	});
-}
-
-export const recipeToolRenderer = createRecipeToolRenderer([]);

package/src/tools/recipe/runner.ts

@@ -1,219 +0,0 @@
-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;
-	/** Working directory for the task, relative to the session cwd; absent means the runner's root cwd. */
-	cwd?: 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;
-	cwd?: string;
-}
-
-const PROMPT_TASK_LIMIT = 20;
-
-interface PromptRunnerModel {
-	id: string;
-	label: string;
-	commandPrefix: string;
-	tasks: PromptTaskModel[];
-	hiddenTaskCount?: number;
-}
-
-export interface RecipePromptModel {
-	[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(`recipe 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 interface ResolvedTask {
-	command: string;
-	cwd?: string;
-}
-
-export function resolveCommand(op: string, runners: DetectedRunner[]): ResolvedTask {
-	const { runner, task, tail } = resolveRunnerAndTask(op, runners);
-	const command = buildCommand(task.commandPrefix ?? runner.commandPrefix, task.commandName ?? task.name, tail);
-	return task.cwd ? { command, cwd: task.cwd } : { command };
-}
-
-export function resolveTaskFromOp(op: string | undefined, runners: DetectedRunner[]): ResolvedTask | undefined {
-	if (!op) return undefined;
-	try {
-		return resolveCommand(op, runners);
-	} catch {
-		return undefined;
-	}
-}
-
-export function commandFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined {
-	return resolveTaskFromOp(op, runners)?.command;
-}
-
-export function cwdFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined {
-	return resolveTaskFromOp(op, runners)?.cwd;
-}
-
-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[]): RecipePromptModel {
-	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.slice(0, PROMPT_TASK_LIMIT).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,
-				cwd: task.cwd,
-			})),
-		})),
-	};
-}

package/src/tools/recipe/runners/cargo.ts

@@ -1,131 +0,0 @@
-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/recipe/runners/index.ts

@@ -1,8 +0,0 @@
-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];