@oh-my-pi/pi-coding-agent 15.7.1 → 15.7.3

package/src/auto-thinking/classifier.ts

@@ -0,0 +1,180 @@
+/**
+ * Per-prompt difficulty classifier for the `auto` thinking level.
+ *
+ * Picks a coding-difficulty bucket for a user prompt and maps it to a concrete
+ * {@link Effort}, clamped into the active model's supported range (never below
+ * {@link Effort.Low}). Two backends, selected by `providers.autoThinkingModel`:
+ *
+ * - `online` (default): a smol model classifies into `low|medium|high|xhigh`.
+ * - a local key: an on-device memory model classifies into the coarser
+ *   `trivial|moderate|hard` scheme (3-class is more reliable than 4-way ordinal
+ *   on sub-2B models), mapped to `low|high|xhigh`.
+ *
+ * Throws on any failure (no model, no key, unparseable output, abort/timeout);
+ * the caller falls back to a concrete level and continues the turn.
+ */
+import { type AssistantMessage, completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
+import { prompt } from "@oh-my-pi/pi-utils";
+import type { ModelRegistry } from "../config/model-registry";
+import { resolveRoleSelection } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+import difficultySystemPrompt from "../prompts/system/auto-thinking-difficulty.md" with { type: "text" };
+import difficultyLocalPrompt from "../prompts/system/auto-thinking-difficulty-local.md" with { type: "text" };
+import { clampAutoThinkingEffort } from "../thinking";
+import { isTinyMemoryLocalModelKey, ONLINE_AUTO_THINKING_MODEL_KEY } from "../tiny/models";
+import { tinyModelClient } from "../tiny/title-client";
+
+const DIFFICULTY_SYSTEM_PROMPT = prompt.render(difficultySystemPrompt);
+
+/** Upper bound on prompt characters fed to the classifier. */
+const MAX_INPUT_CHARS = 6000;
+const HEAD_CHARS = 4000;
+const TAIL_CHARS = 2000;
+/** The answer is a single word; keep budgets tiny for non-reasoning backends. */
+const ANSWER_MAX_TOKENS = 8;
+/**
+ * Reasoning backends ignore `disableReasoning` on some providers, so reserve
+ * enough output room for the keyword to still land after unavoidable thinking.
+ */
+const REASONING_SAFE_MAX_TOKENS = 1024;
+
+export interface ClassifyDifficultyDeps {
+	settings: Settings;
+	registry: ModelRegistry;
+	model: Model;
+	sessionId?: string;
+	signal?: AbortSignal;
+	metadataResolver?: (provider: string) => Record<string, unknown> | undefined;
+}
+
+/**
+ * Classify `promptText` and return a concrete effort clamped to `deps.model`.
+ * @throws when the backend cannot produce a usable classification.
+ */
+export async function classifyDifficulty(promptText: string, deps: ClassifyDifficultyDeps): Promise<Effort> {
+	const backend = deps.settings.get("providers.autoThinkingModel");
+	const input = prepareClassifierInput(promptText);
+	const effort =
+		backend === ONLINE_AUTO_THINKING_MODEL_KEY
+			? await classifyOnline(input, deps)
+			: await classifyLocal(input, backend, deps);
+	return clampAutoThinkingEffort(deps.model, effort);
+}
+
+async function classifyOnline(input: string, deps: ClassifyDifficultyDeps): Promise<Effort> {
+	const resolved = resolveRoleSelection(["smol"], deps.settings, deps.registry.getAvailable(), deps.registry);
+	const model = resolved?.model;
+	if (!model) {
+		throw new Error("auto-thinking: no smol model available for classification");
+	}
+	const apiKey = await deps.registry.getApiKey(model, deps.sessionId);
+	if (!apiKey) {
+		throw new Error(`auto-thinking: no API key for ${model.provider}/${model.id}`);
+	}
+	// Resolve metadata after getApiKey so the session-sticky credential is recorded first.
+	const metadata = deps.metadataResolver?.(model.provider);
+	const maxTokens = model.reasoning ? Math.max(ANSWER_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS) : ANSWER_MAX_TOKENS;
+
+	const response = await completeSimple(
+		model,
+		{
+			systemPrompt: [DIFFICULTY_SYSTEM_PROMPT],
+			messages: [{ role: "user", content: input, timestamp: Date.now() }],
+		},
+		{
+			apiKey,
+			maxTokens,
+			disableReasoning: true,
+			metadata,
+			signal: deps.signal,
+		},
+	);
+
+	if (response.stopReason === "error") {
+		throw new Error(`auto-thinking: online classification failed: ${response.errorMessage ?? "unknown error"}`);
+	}
+
+	const text = extractText(response.content);
+	const effort = parseDifficultyLevel(text);
+	if (!effort) {
+		throw new Error(`auto-thinking: unparseable online classification: ${JSON.stringify(text)}`);
+	}
+	return effort;
+}
+
+async function classifyLocal(input: string, modelKey: string, deps: ClassifyDifficultyDeps): Promise<Effort> {
+	if (!isTinyMemoryLocalModelKey(modelKey)) {
+		throw new Error(`auto-thinking: unsupported local classifier model: ${modelKey}`);
+	}
+	const builtPrompt = prompt.render(difficultyLocalPrompt, { prompt: input });
+	const text = await tinyModelClient.complete(modelKey, builtPrompt, {
+		maxTokens: ANSWER_MAX_TOKENS,
+		signal: deps.signal,
+	});
+	if (!text) {
+		throw new Error("auto-thinking: local classification returned no output");
+	}
+	const effort = parseDifficultyBucket(text);
+	if (!effort) {
+		throw new Error(`auto-thinking: unparseable local classification: ${JSON.stringify(text)}`);
+	}
+	return effort;
+}
+
+/** Map the online 4-way level keyword to an {@link Effort}; earliest match wins. */
+export function parseDifficultyLevel(text: string): Effort | undefined {
+	const lower = text.toLowerCase();
+	const candidates: Array<[number, Effort]> = [];
+	// `xhigh` must be probed as its own token: `\bhigh\b` cannot match the "high"
+	// inside "xhigh" (no word boundary between `x` and `h`), so the two never collide.
+	const xhigh = lower.search(/x[\s_-]?high/);
+	if (xhigh >= 0) candidates.push([xhigh, Effort.XHigh]);
+	const high = lower.search(/\bhigh\b/);
+	if (high >= 0) candidates.push([high, Effort.High]);
+	const medium = lower.search(/\bmed(?:ium)?\b/);
+	if (medium >= 0) candidates.push([medium, Effort.Medium]);
+	const low = lower.search(/\blow\b/);
+	if (low >= 0) candidates.push([low, Effort.Low]);
+	return earliest(candidates);
+}
+
+/** Map the local 3-way bucket keyword to an {@link Effort}; earliest match wins. */
+export function parseDifficultyBucket(text: string): Effort | undefined {
+	const lower = text.toLowerCase();
+	const candidates: Array<[number, Effort]> = [];
+	const trivial = lower.search(/\btrivial\b/);
+	if (trivial >= 0) candidates.push([trivial, Effort.Low]);
+	const moderate = lower.search(/\bmoderate\b/);
+	if (moderate >= 0) candidates.push([moderate, Effort.High]);
+	const hard = lower.search(/\bhard\b/);
+	if (hard >= 0) candidates.push([hard, Effort.XHigh]);
+	return earliest(candidates);
+}
+
+function earliest(candidates: Array<[number, Effort]>): Effort | undefined {
+	if (candidates.length === 0) return undefined;
+	let best = candidates[0];
+	for (const candidate of candidates) {
+		if (candidate[0] < best[0]) best = candidate;
+	}
+	return best[1];
+}
+
+function extractText(content: AssistantMessage["content"]): string {
+	return content
+		.filter((block): block is Extract<AssistantMessage["content"][number], { type: "text" }> => block.type === "text")
+		.map(block => block.text)
+		.join(" ")
+		.trim();
+}
+
+/**
+ * Bound the classifier input. Code blocks are kept (a large diff is signal), but
+ * very long prompts are head+tail trimmed so the intent (start) and any trailing
+ * error/stacktrace (end) both survive.
+ */
+function prepareClassifierInput(text: string): string {
+	const trimmed = text.trim();
+	if (trimmed.length <= MAX_INPUT_CHARS) return trimmed;
+	return `${trimmed.slice(0, HEAD_CHARS)}\n…\n${trimmed.slice(-TAIL_CHARS)}`;
+}

package/src/autoresearch/tools/run-experiment.ts

@@ -1,12 +1,12 @@
-import * as childProcess from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { Text } from "@oh-my-pi/pi-tui";
 import { formatBytes } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
+import { executeBash } from "../../exec/bash-executor";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { Theme } from "../../modes/theme/theme";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "../../session/streaming-output";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, TailBuffer, truncateTail } from "../../session/streaming-output";
 import { replaceTabs, shortenPath } from "../../tools/render-utils";
 import * as git from "../../utils/git";
 import { parseWorkDirDirtyPaths } from "../git";
@@ -15,7 +15,6 @@ import {
 	EXPERIMENT_MAX_LINES,
 	formatElapsed,
 	formatNum,
-	killTree,
 	parseAsiLines,
 	parseMetricLines,
 	tryGitPrefix,
@@ -117,7 +116,7 @@ export function createRunExperimentTool(
 			let execution: ProcessExecutionResult;
 			try {
 				execution = await executeProcess({
-					command: ["bash", "-lc", resolvedCommand],
+					command: resolvedCommand,
 					cwd: ctx.cwd,
 					logPath: benchmarkLogPath,
 					timeoutMs,
@@ -268,68 +267,18 @@ export function createRunExperimentTool(
 	};
 }
 async function executeProcess(opts: {
-	command: string[];
+	command: string;
 	cwd: string;
 	logPath: string;
 	timeoutMs: number;
 	signal?: AbortSignal;
 	onProgress?(details: ProgressSnapshot): void;
 }): Promise<ProcessExecutionResult> {
-	const { promise, resolve, reject } = Promise.withResolvers<ProcessExecutionResult>();
-	const child = childProcess.spawn(opts.command[0] ?? "bash", opts.command.slice(1), {
-		cwd: opts.cwd,
-		detached: true,
-		stdio: ["ignore", "pipe", "pipe"],
-	});
-
-	const tailChunks: Buffer[] = [];
-	let chunksBytes = 0;
-	let killedByTimeout = false;
-	let resolved = false;
-	let writeStream: fs.WriteStream | undefined = fs.createWriteStream(opts.logPath);
-	let forceKillTimeout: NodeJS.Timeout | undefined;
-
-	const closeWriteStream = (): Promise<void> => {
-		if (!writeStream) return Promise.resolve();
-		const stream = writeStream;
-		writeStream = undefined;
-		return new Promise<void>((resolveClose, rejectClose) => {
-			stream.end((error?: Error | null) => {
-				if (error) {
-					rejectClose(error);
-					return;
-				}
-				resolveClose();
-			});
-		});
-	};
-
-	const cleanup = (): void => {
-		if (progressTimer) clearInterval(progressTimer);
-		if (timeoutHandle) clearTimeout(timeoutHandle);
-		if (forceKillTimeout) clearTimeout(forceKillTimeout);
-		opts.signal?.removeEventListener("abort", abortHandler);
-	};
-
-	const finish = (callback: () => void): void => {
-		if (resolved) return;
-		resolved = true;
-		cleanup();
-		callback();
-	};
-
-	const appendChunk = (data: Buffer): void => {
-		writeStream?.write(data);
-		tailChunks.push(data);
-		chunksBytes += data.length;
-		while (chunksBytes > DEFAULT_MAX_BYTES * 2 && tailChunks.length > 1) {
-			const removed = tailChunks.shift();
-			if (removed) chunksBytes -= removed.length;
-		}
-	};
+	const tailBuffer = new TailBuffer(DEFAULT_MAX_BYTES * 2);
 
+	const startedAt = Date.now();
 	const snapshot = (): ProgressSnapshot => {
-		const tail = truncateTail(Buffer.concat(tailChunks).toString("utf8"), {
+		const tail = truncateTail(tailBuffer.text(), {
 			maxBytes: DEFAULT_MAX_BYTES,
 			maxLines: DEFAULT_MAX_LINES,
 		});
@@ -342,71 +291,54 @@ async function executeProcess(opts: {
 		};
 	};
 
-	const killTreeWithEscalation = (): void => {
-		if (!child.pid) return;
-		killTree(child.pid);
-		forceKillTimeout = setTimeout(() => {
-			if (child.pid) killTree(child.pid, "SIGKILL");
-		}, 1_000);
-		forceKillTimeout.unref?.();
-	};
-
-	const startedAt = Date.now();
 	const progressTimer = opts.onProgress
 		? setInterval(() => {
 				opts.onProgress?.(snapshot());
 			}, 1000)
 		: undefined;
-	const timeoutHandle =
-		opts.timeoutMs > 0
-			? setTimeout(() => {
-					killedByTimeout = true;
-					killTreeWithEscalation();
-				}, opts.timeoutMs)
-			: undefined;
 
-	const abortHandler = (): void => {
-		killTreeWithEscalation();
+	const logSink = Bun.file(opts.logPath).writer();
+	let logSinkClosed = false;
+	const closeLogSink = async (): Promise<void> => {
+		if (logSinkClosed) return;
+		logSinkClosed = true;
+		await logSink.end();
 	};
-	if (opts.signal?.aborted) {
-		abortHandler();
-	} else {
-		opts.signal?.addEventListener("abort", abortHandler, { once: true });
-	}
-
-	child.stdout?.on("data", data => {
-		appendChunk(data);
-	});
-	child.stderr?.on("data", data => {
-		appendChunk(data);
-	});
-	child.on("error", error => {
-		void closeWriteStream().finally(() => {
-			finish(() => reject(error));
+	try {
+		const result = await executeBash(opts.command, {
+			cwd: opts.cwd,
+			sessionKey: `autoresearch:${opts.cwd}`,
+			timeout: opts.timeoutMs > 0 ? opts.timeoutMs : 2_147_000_000,
+			signal: opts.signal,
+			chunkThrottleMs: 0,
+			onChunk: chunk => {
+				tailBuffer.append(chunk);
+				logSink.write(chunk);
+			},
 		});
-	});
-	child.on("close", async code => {
-		try {
-			await closeWriteStream();
-			if (opts.signal?.aborted) {
-				finish(() => reject(new Error("aborted")));
-				return;
-			}
-			const output = await fs.promises.readFile(opts.logPath, "utf8");
-			finish(() =>
-				resolve({
-					exitCode: code,
-					killed: killedByTimeout,
-					logPath: opts.logPath,
-					output,
-				}),
-			);
-		} catch (error) {
-			finish(() => reject(error));
+		await closeLogSink();
+		if (opts.signal?.aborted) {
+			throw new Error("aborted");
 		}
-	});
 
-	return promise;
+		const output = await fs.promises.readFile(opts.logPath, "utf8");
+
+		return {
+			exitCode: result.exitCode ?? null,
+			killed: result.cancelled,
+			logPath: opts.logPath,
+			output,
+		};
+	} finally {
+		if (progressTimer) clearInterval(progressTimer);
+		if (!logSinkClosed) {
+			try {
+				await closeLogSink();
+			} catch {
+				// Preserve the command failure when cleanup is best-effort.
+			}
+		}
+	}
 }
 
 function buildRunText(details: RunDetails, outputPreview: string, bestMetric: number | null): string {

package/src/cli/args.ts

@@ -54,7 +54,12 @@ export interface Args {
 	unknownFlags: Map<string, boolean | string>;
 }
 
-export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "boolean" | "string" }>): Args {
+export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { type: "boolean" | "string" }>): Args {
+	// Work on a copy: the `--option=value` handling below splices the value
+	// into the array, and callers reuse the same argv (the post-extension
+	// reparse in `runRootCommand` parses it a second time). Mutating the input
+	// would corrupt that later parse, so never touch the caller's array.
+	const args = [...inputArgs];
 	const result: Args = {
 		messages: [],
 		fileArgs: [],
@@ -63,17 +68,41 @@ export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "
 
 	for (let i = 0; i < args.length; i++) {
 		let arg = args[i];
+		const flagIndex = i;
 
-		// Support --flag=value syntax (e.g. --tools=ask,read)
+		// Support --flag=value syntax (e.g. --tools=ask,read). The value is
+		// spliced in as the next token so value-consuming flags pick it up via
+		// `args[++i]`; a non-consuming flag (e.g. a boolean) leaves it behind and
+		// the post-loop guard drops it so it is not mistaken for a message.
+		let equalsValueIndex = -1;
 		if (arg.startsWith("--") && arg.includes("=")) {
 			const eqIdx = arg.indexOf("=");
 			const value = arg.slice(eqIdx + 1);
 			arg = arg.slice(0, eqIdx);
-			// Insert the value so the existing "args[++i]" logic picks it up
 			args.splice(i + 1, 0, value);
+			equalsValueIndex = i + 1;
 		}
 
-		if (arg === "--help" || arg === "-h") {
+		// Extension-registered flags take precedence over built-ins: a flag an
+		// extension owns (e.g. plan-mode's boolean `--plan`) is parsed with the
+		// extension's semantics rather than falling into a built-in branch. For a
+		// value-taking built-in (`--plan`, `--model`, …) that branch would consume
+		// the following token — eating the user's message and setting the wrong
+		// built-in field — so registered flags shadow same-named built-ins here.
+		const extFlag = arg.startsWith("--") ? extensionFlags?.get(arg.slice(2)) : undefined;
+		if (extFlag) {
+			const flagName = arg.slice(2);
+			if (extFlag.type === "boolean") {
+				result.unknownFlags.set(flagName, true);
+			} else if (extFlag.type === "string" && i + 1 < args.length) {
+				// Consume the value in `--flag=value` form, or when the next token is
+				// not flag-looking. A `-`-prefixed token in space form is left to be
+				// its own flag; pass a flag-looking value as `--flag=value`.
+				if (equalsValueIndex !== -1 || !args[i + 1].startsWith("-")) {
+					result.unknownFlags.set(flagName, args[++i]);
+				}
+			}
+		} else if (arg === "--help" || arg === "-h") {
 			result.help = true;
 		} else if (arg === "--version" || arg === "-v") {
 			result.version = true;
@@ -198,21 +227,15 @@ export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "
 			}
 		} else if (arg.startsWith("@")) {
 			result.fileArgs.push(arg.slice(1)); // Remove @ prefix
-		} else if (arg.startsWith("--") && extensionFlags) {
-			// Check if it's an extension-registered flag
-			const flagName = arg.slice(2);
-			const extFlag = extensionFlags.get(flagName);
-			if (extFlag) {
-				if (extFlag.type === "boolean") {
-					result.unknownFlags.set(flagName, true);
-				} else if (extFlag.type === "string" && i + 1 < args.length) {
-					result.unknownFlags.set(flagName, args[++i]);
-				}
-			}
-			// Unknown flags without extensionFlags are silently ignored (first pass)
 		} else if (!arg.startsWith("-")) {
 			result.messages.push(arg);
 		}
+		// Drop an unconsumed `--flag=value` value (e.g. a boolean flag): when no
+		// branch advanced past the spliced token, remove it so it does not fall
+		// through to a later iteration and become a positional message.
+		if (equalsValueIndex !== -1 && i === flagIndex) {
+			args.splice(equalsValueIndex, 1);
+		}
 	}
 
 	return result;

package/src/cli/extension-flags.ts

@@ -0,0 +1,48 @@
+import { type Args, parseArgs } from "./args";
+
+/**
+ * Minimal extension-runner surface needed to resolve CLI flag values. The real
+ * `ExtensionRunner` satisfies this structurally; depending only on the surface
+ * keeps this module free of the heavier runner/session imports and unit-testable
+ * with a fake.
+ */
+export interface ExtensionFlagSink {
+	getFlags(): Map<string, { type: "boolean" | "string" }>;
+	setFlagValue(name: string, value: boolean | string): void;
+}
+
+/**
+ * Resolve extension-registered CLI flags from `rawArgs` once the flag set is
+ * known, push the resolved values onto the sink, and return the parsed
+ * {@link Args} (whose `messages` and `fileArgs` now reflect those flags).
+ *
+ * The startup parse runs before extensions load, so it cannot recognise their
+ * flags: a string flag's value (`--spawn-peer reviewer` or `--spawn-peer=reviewer`)
+ * is otherwise left in `messages` and leaks into the initial prompt. Re-parsing
+ * here — through the *same* {@link parseArgs} the startup pass uses, now seeded
+ * with the registered flags — consumes every flag form (`--flag`, `--flag value`,
+ * `--flag=value`).
+ *
+ * {@link parseArgs} lets a registered flag shadow a same-named built-in, so even
+ * a built-in-colliding flag (e.g. plan-mode's boolean `--plan`, which would
+ * otherwise hit the built-in plan-model branch) is parsed with the extension's
+ * semantics and surfaces in `unknownFlags` — without consuming the following
+ * message or overwriting the built-in field. No built-in name list to maintain.
+ *
+ * Returns `null` when there is no sink or no registered extension flags, in
+ * which case the caller keeps its original startup parse (an extension-aware
+ * re-parse would be identical anyway).
+ */
+export function applyExtensionFlags(runner: ExtensionFlagSink | undefined, rawArgs: string[]): Args | null {
+	const extensionFlags = runner?.getFlags();
+	if (!runner || !extensionFlags || extensionFlags.size === 0) {
+		return null;
+	}
+	const parsed = parseArgs(rawArgs, extensionFlags);
+	// `parseArgs` only records registered extension flags in `unknownFlags`, so
+	// every entry here is a flag this runner owns that was actually passed.
+	for (const [name, value] of parsed.unknownFlags) {
+		runner.setFlagValue(name, value);
+	}
+	return parsed;
+}

package/src/cli/plugin-cli.ts

@@ -348,10 +348,12 @@ async function handleInstall(
 	flags: { json?: boolean; force?: boolean; dryRun?: boolean; scope?: "user" | "project" },
 ): Promise<void> {
 	if (packages.length === 0) {
-		console.error(chalk.red(`Usage: ${APP_NAME} plugin install <package[@version]>[features] ...`));
+		console.error(chalk.red(`Usage: ${APP_NAME} plugin install <source>[features] ...`));
 		console.error(chalk.dim("Examples:"));
 		console.error(chalk.dim(`  ${APP_NAME} plugin install @oh-my-pi/exa`));
 		console.error(chalk.dim(`  ${APP_NAME} plugin install name@marketplace`));
+		console.error(chalk.dim(`  ${APP_NAME} plugin install github:user/repo`));
+		console.error(chalk.dim(`  ${APP_NAME} plugin install https://github.com/user/repo#v1.0`));
 		process.exit(1);
 	}
 
@@ -898,7 +900,7 @@ export function printPluginHelp(): void {
 	console.log(`${chalk.bold(`${APP_NAME} plugin`)} - Plugin lifecycle management
 
 ${chalk.bold("Commands:")}
-  install <pkg[@ver]>[features]  Install plugins from npm
+  install <source>[features]     Install plugins from npm, GitHub, or git URL
   uninstall <pkg>                Remove plugins
   list                           Show installed plugins
   link <path>                    Link local plugin for development
@@ -916,6 +918,12 @@ ${chalk.bold("Feature Syntax:")}
   pkg[*]             Install with all features
   pkg[]              Install with no optional features
 
+${chalk.bold("Sources:")}
+  pkg, pkg@1.2.3                  npm package (optionally pinned)
+  github:user/repo[#ref]          GitHub shorthand (also gitlab:, bitbucket:, codeberg:, sourcehut:)
+  https://github.com/user/repo    Full git URL (https, ssh, or git protocol)
+  name@marketplace                Marketplace plugin (see marketplace command)
+
 ${chalk.bold("Config Subcommands:")}
   config list <pkg>              List all settings
   config get <pkg> <key>         Get a setting value
@@ -938,5 +946,6 @@ ${chalk.bold("Examples:")}
   ${APP_NAME} plugin config set my-plugin apiKey sk-xxx
   ${APP_NAME} plugin doctor --fix
   ${APP_NAME} plugin install --scope project name@marketplace
+  ${APP_NAME} plugin install github:user/repo#v1.0
 `);
 }