pi-improve-interation 0.0.1

package/node_modules/pi-subagents/src/slash/prompt-workflows.ts

@@ -0,0 +1,287 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { parseFrontmatter } from "../agents/frontmatter.ts";
+import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
+import { getPromptDirectories } from "../shared/prompt-resources.ts";
+
+interface PromptWorkflow {
+	name: string;
+	description: string;
+	body: string;
+	filePath: string;
+	agent: string;
+	context?: "fresh" | "fork";
+	model?: string;
+	skill?: string | string[] | false;
+	cwd?: string;
+	chain?: string;
+}
+
+type PromptWorkflowRunner = (params: SubagentParamsLike, ctx: ExtensionContext) => Promise<void>;
+
+const RESERVED_COMMAND_NAMES = new Set([
+	"chain-prompts",
+	"prompt-workflow",
+	"run",
+	"chain",
+	"parallel",
+	"run-chain",
+	"subagents-doctor",
+	"subagents-models",
+]);
+
+function readPromptFiles(cwd: string): string[] {
+	const files: string[] = [];
+	for (const dir of Object.values(getPromptDirectories(cwd))) {
+		let entries: fs.Dirent[];
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (entry.isFile() && entry.name.endsWith(".md")) files.push(path.join(dir, entry.name));
+		}
+	}
+	return files;
+}
+
+function firstNonEmptyLine(value: string): string {
+	return value.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "Prompt workflow";
+}
+
+function stringField(frontmatter: Record<string, string>, key: string): string | undefined {
+	const value = frontmatter[key]?.trim();
+	return value ? value : undefined;
+}
+
+function booleanField(frontmatter: Record<string, string>, key: string): boolean | undefined {
+	const value = frontmatter[key]?.trim().toLowerCase();
+	if (value === "true" || value === "yes" || value === "1") return true;
+	if (value === "false" || value === "no" || value === "0") return false;
+	return undefined;
+}
+
+function parseSkill(value: string | undefined): string | string[] | false | undefined {
+	if (!value) return undefined;
+	if (value === "false") return false;
+	const parts = value.split(",").map((part) => part.trim()).filter(Boolean);
+	return parts.length > 1 ? parts : parts[0];
+}
+
+function parseAgent(frontmatter: Record<string, string>): string {
+	const subagent = stringField(frontmatter, "subagent");
+	if (!subagent || subagent === "true") return "delegate";
+	return subagent;
+}
+
+function loadPromptWorkflow(filePath: string): PromptWorkflow | undefined {
+	const content = fs.readFileSync(filePath, "utf-8");
+	const { frontmatter, body } = parseFrontmatter(content);
+	const name = path.basename(filePath, ".md");
+	if (!name || RESERVED_COMMAND_NAMES.has(name)) return undefined;
+	const model = stringField(frontmatter, "model");
+	const skill = parseSkill(stringField(frontmatter, "skill"));
+	const cwd = stringField(frontmatter, "cwd");
+	const chain = stringField(frontmatter, "chain");
+	return {
+		name,
+		description: stringField(frontmatter, "description") ?? firstNonEmptyLine(body),
+		body,
+		filePath,
+		agent: parseAgent(frontmatter),
+		...(booleanField(frontmatter, "inheritContext") === true || booleanField(frontmatter, "fork") === true ? { context: "fork" as const } : {}),
+		...(booleanField(frontmatter, "fresh") === true ? { context: "fresh" as const } : {}),
+		...(model ? { model } : {}),
+		...(skill !== undefined ? { skill } : {}),
+		...(cwd ? { cwd } : {}),
+		...(chain ? { chain } : {}),
+	};
+}
+
+export function discoverPromptWorkflows(cwd: string): PromptWorkflow[] {
+	const workflows = new Map<string, PromptWorkflow>();
+	for (const file of readPromptFiles(cwd)) {
+		const workflow = loadPromptWorkflow(file);
+		if (workflow) workflows.set(workflow.name, workflow);
+	}
+	return [...workflows.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function shellWords(input: string): string[] {
+	const words: string[] = [];
+	let current = "";
+	let quote: "'" | '"' | undefined;
+	let escaped = false;
+	for (const ch of input) {
+		if (escaped) {
+			current += ch;
+			escaped = false;
+			continue;
+		}
+		if (ch === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			if (ch === quote) quote = undefined;
+			else current += ch;
+			continue;
+		}
+		if (ch === "'" || ch === '"') {
+			quote = ch;
+			continue;
+		}
+		if (/\s/.test(ch)) {
+			if (current) {
+				words.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += ch;
+	}
+	if (current) words.push(current);
+	return words;
+}
+
+function substituteArgs(template: string, args: string[]): string {
+	const all = args.join(" ");
+	return template
+		.replace(/\$ARGUMENTS/g, all)
+		.replace(/\$@/g, all)
+		.replace(/\$\{(\d+):-([^}]*)\}/g, (_match, index: string, fallback: string) => args[Number(index) - 1] || fallback)
+		.replace(/\$(\d+)/g, (_match, index: string) => args[Number(index) - 1] ?? "");
+}
+
+function parseRuntimeOptions(words: string[]): { args: string[]; agentOverride?: string; fork?: boolean; fresh?: boolean; bg?: boolean } {
+	const args: string[] = [];
+	let agentOverride: string | undefined;
+	let fork = false;
+	let fresh = false;
+	let bg = false;
+	for (let i = 0; i < words.length; i++) {
+		const word = words[i]!;
+		if (word === "--fork") {
+			fork = true;
+			continue;
+		}
+		if (word === "--fresh") {
+			fresh = true;
+			continue;
+		}
+		if (word === "--bg" || word === "--async") {
+			bg = true;
+			continue;
+		}
+		if (word === "--subagent") {
+			agentOverride = words[++i];
+			continue;
+		}
+		const eq = word.match(/^--subagent(?:=|:)(.+)$/);
+		if (eq) {
+			agentOverride = eq[1];
+			continue;
+		}
+		args.push(word);
+	}
+	return { args, agentOverride, fork, fresh, bg };
+}
+
+
+function splitPromptChain(input: string): string[] {
+	return input.split(" -> ").map((part) => part.trim()).filter(Boolean);
+}
+
+function workflowParams(workflow: PromptWorkflow, args: string[], runtime: ReturnType<typeof parseRuntimeOptions>): SubagentParamsLike {
+	const task = substituteArgs(workflow.body, args).trim();
+	const context = runtime.fork ? "fork" : runtime.fresh ? "fresh" : workflow.context;
+	return {
+		agent: runtime.agentOverride ?? workflow.agent,
+		task,
+		agentScope: "both",
+		...(context ? { context } : {}),
+		...(workflow.model ? { model: workflow.model } : {}),
+		...(workflow.skill !== undefined ? { skill: workflow.skill } : {}),
+		...(workflow.cwd ? { cwd: workflow.cwd } : {}),
+	};
+}
+
+function promptWorkflowExecutionParams(workflows: PromptWorkflow[], args: string[], runtime: ReturnType<typeof parseRuntimeOptions>): SubagentParamsLike {
+	return {
+		workflowScript: promptWorkflowScript(workflows, args, runtime),
+		agentScope: "both",
+		async: runtime.bg ? true : false,
+	};
+}
+
+function promptWorkflowScript(workflows: PromptWorkflow[], args: string[], runtime: ReturnType<typeof parseRuntimeOptions>): string {
+	const launches = workflows.map((workflow, index) => {
+		const params = workflowParams(workflow, args, runtime);
+		const task = params.task ?? "";
+		const child = {
+			agent: params.agent ?? "delegate",
+			task,
+			...(params.model ? { model: params.model } : {}),
+			...(params.skill !== undefined ? { skill: params.skill } : {}),
+			...(params.cwd ? { cwd: params.cwd } : {}),
+			...(params.context ? { context: params.context } : {}),
+		};
+		return `const step${index} = await runs.run(${JSON.stringify(`prompt-${index + 1}-${workflow.name}`)}, { ...${JSON.stringify(child)}, task: ${JSON.stringify(task)}.replaceAll("{previous}", previous) });\nprevious = step${index}.output;`;
+	});
+	return `let previous = "";\n${launches.join("\n")}\nreturn previous;`;
+}
+
+function findWorkflow(workflows: PromptWorkflow[], name: string): PromptWorkflow | undefined {
+	return workflows.find((workflow) => workflow.name === name);
+}
+
+function formatWorkflowList(workflows: PromptWorkflow[]): string {
+	if (workflows.length === 0) return "No prompt workflows found in package, user, or project prompts.";
+	return [
+		"Prompt workflows:",
+		...workflows.map((workflow) => `- ${workflow.name}: ${workflow.description} (${workflow.filePath})`),
+	].join("\n");
+}
+
+export function registerPromptWorkflowCommands(input: {
+	pi: ExtensionAPI;
+	run: PromptWorkflowRunner;
+}): void {
+	const { pi, run } = input;
+
+	pi.registerCommand("prompt-workflow", {
+		description: "Run a prompt template through native pi-subagents: /prompt-workflow <name> [args]",
+		handler: async (rawArgs, ctx) => {
+			const words = shellWords(rawArgs);
+			const name = words.shift();
+			const workflows = discoverPromptWorkflows(ctx.cwd);
+			if (!name || name === "list") {
+				pi.sendMessage({ content: formatWorkflowList(workflows), display: true } as Parameters<typeof pi.sendMessage>[0]);
+				return;
+			}
+			const workflow = findWorkflow(workflows, name);
+			if (!workflow) {
+				ctx.ui.notify(`Unknown prompt workflow: ${name}`, "error");
+				return;
+			}
+			const runtime = parseRuntimeOptions(words);
+			try {
+				if (workflow.chain) {
+					const chain = splitPromptChain(workflow.chain).map((stepName) => {
+						const step = findWorkflow(workflows, stepName);
+						if (!step) throw new Error(`Unknown prompt workflow in chain '${workflow.name}': ${stepName}`);
+						return step;
+					});
+					await run(promptWorkflowExecutionParams(chain, runtime.args, runtime), ctx);
+					return;
+				}
+				await run(promptWorkflowExecutionParams([workflow], runtime.args, runtime), ctx);
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
+}

package/node_modules/pi-subagents/src/slash/selector.ts

@@ -0,0 +1,147 @@
+import { DynamicBorder, keyHint, rawKeyHint, type Theme } from "@earendil-works/pi-coding-agent";
+import { Container, fuzzyFilter, Input, type KeybindingsManager, Spacer, Text, type TUI } from "@earendil-works/pi-tui";
+
+/** A single selectable row. `value` is returned on confirm; `label` is the primary text. */
+export interface SelectorItem {
+	value: string;
+	label: string;
+	/** Optional dimmed badge shown after the label (e.g. a provider name). */
+	badge?: string;
+	/** Marks the current selection (rendered with a ✓ checkmark). */
+	current?: boolean;
+}
+
+export interface SelectorResult {
+	confirmed: boolean;
+	value?: string;
+}
+
+export interface SelectorOptions {
+	title: string;
+	/** Optional dimmed hint line under the title (e.g. the current value). */
+	subtitle?: string;
+	items: SelectorItem[];
+	done: (result: SelectorResult) => void;
+}
+
+const MAX_VISIBLE = 10;
+
+/**
+ * A single-select list with a search field and a bounded scroll window that keeps the
+ * highlighted row on screen with an `(n/total)` indicator, so the selection never scrolls
+ * out of view when the option list is long. Composed from pi's own TUI primitives so it
+ * matches the built-in `/model` picker.
+ *
+ * Colors come from the `theme` passed to the factory: the module-level `theme` singleton
+ * is undefined under the extension's jiti module cache.
+ */
+export class SelectorComponent extends Container {
+	private readonly tui: TUI;
+	private readonly theme: Theme;
+	private readonly keybindings: KeybindingsManager;
+	private readonly items: SelectorItem[];
+	private readonly done: (result: SelectorResult) => void;
+
+	private readonly searchInput: Input;
+	private readonly listContainer: Container;
+	private filtered: SelectorItem[];
+	private selectedIndex = 0;
+
+	constructor(tui: TUI, theme: Theme, keybindings: KeybindingsManager, options: SelectorOptions) {
+		super();
+		this.tui = tui;
+		this.theme = theme;
+		this.keybindings = keybindings;
+		this.items = options.items;
+		this.done = options.done;
+		this.filtered = [...this.items];
+
+		const border = () => new DynamicBorder((str) => theme.fg("border", str));
+		this.addChild(border());
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("accent", theme.bold(options.title)), 0, 0));
+		if (options.subtitle) this.addChild(new Text(theme.fg("muted", options.subtitle), 0, 0));
+		this.addChild(new Spacer(1));
+
+		this.searchInput = new Input();
+		this.searchInput.focused = true;
+		this.searchInput.onSubmit = () => this.confirmSelection();
+		this.addChild(this.searchInput);
+		this.addChild(new Spacer(1));
+
+		this.listContainer = new Container();
+		this.addChild(this.listContainer);
+		this.addChild(new Spacer(1));
+
+		this.addChild(new Text(rawKeyHint("↑↓", "navigate") + "  " + keyHint("tui.select.confirm", "select") + "  " + keyHint("tui.select.cancel", "cancel"), 0, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(border());
+
+		const currentIndex = this.filtered.findIndex((item) => item.current);
+		if (currentIndex >= 0) this.selectedIndex = currentIndex;
+		this.updateList();
+	}
+
+	private applyFilter(query: string): void {
+		const previous = this.filtered[this.selectedIndex]?.value;
+		this.filtered = query
+			? fuzzyFilter(this.items, query, (item) => `${item.label} ${item.value} ${item.badge ?? ""}`)
+			: [...this.items];
+		const keepIndex = this.filtered.findIndex((item) => item.value === previous);
+		this.selectedIndex = keepIndex >= 0 ? keepIndex : Math.min(this.selectedIndex, Math.max(0, this.filtered.length - 1));
+		this.updateList();
+	}
+
+	private updateList(): void {
+		const th = this.theme;
+		this.listContainer.clear();
+		const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(MAX_VISIBLE / 2), this.filtered.length - MAX_VISIBLE));
+		const endIndex = Math.min(startIndex + MAX_VISIBLE, this.filtered.length);
+
+		for (let i = startIndex; i < endIndex; i++) {
+			const item = this.filtered[i]!;
+			const isSelected = i === this.selectedIndex;
+			const badge = item.badge ? ` ${th.fg("muted", `[${item.badge}]`)}` : "";
+			const checkmark = item.current ? th.fg("success", " ✓") : "";
+			const line = isSelected
+				? `${th.fg("accent", "→ ")}${th.fg("accent", item.label)}${badge}${checkmark}`
+				: `  ${item.label}${badge}${checkmark}`;
+			this.listContainer.addChild(new Text(line, 0, 0));
+		}
+
+		if (startIndex > 0 || endIndex < this.filtered.length) {
+			this.listContainer.addChild(new Text(th.fg("muted", `  (${this.selectedIndex + 1}/${this.filtered.length})`), 0, 0));
+		}
+		if (this.filtered.length === 0) {
+			this.listContainer.addChild(new Text(th.fg("muted", "  No matching entries"), 0, 0));
+		}
+	}
+
+	private confirmSelection(): void {
+		const selected = this.filtered[this.selectedIndex];
+		this.done(selected ? { confirmed: true, value: selected.value } : { confirmed: false });
+	}
+
+	handleInput(keyData: string): void {
+		const kb = this.keybindings;
+		if (kb.matches(keyData, "tui.select.up")) {
+			if (this.filtered.length === 0) return;
+			this.selectedIndex = this.selectedIndex === 0 ? this.filtered.length - 1 : this.selectedIndex - 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "tui.select.down")) {
+			if (this.filtered.length === 0) return;
+			this.selectedIndex = this.selectedIndex === this.filtered.length - 1 ? 0 : this.selectedIndex + 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "tui.select.confirm")) {
+			this.confirmSelection();
+		} else if (kb.matches(keyData, "tui.select.cancel")) {
+			this.done({ confirmed: false });
+		} else {
+			this.searchInput.handleInput(keyData);
+			this.applyFilter(this.searchInput.getValue());
+			this.tui.requestRender();
+		}
+	}
+}

package/node_modules/pi-subagents/src/slash/slash-bridge.ts

@@ -0,0 +1,192 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { normalizePublicSubagentExecution } from "../extension/public-execution.ts";
+import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
+import {
+	SLASH_SUBAGENT_CANCEL_EVENT,
+	SLASH_SUBAGENT_REQUEST_EVENT,
+	SLASH_SUBAGENT_RESPONSE_EVENT,
+	SLASH_SUBAGENT_STARTED_EVENT,
+	SLASH_SUBAGENT_UPDATE_EVENT,
+	type Details,
+} from "../shared/types.ts";
+
+interface SlashSubagentRequest {
+	requestId: string;
+	params: SubagentParamsLike;
+	/** Optional requester context for in-process extension bridge calls. */
+	ctx?: ExtensionContext;
+}
+
+export interface SlashSubagentResponse {
+	requestId: string;
+	result: AgentToolResult<Details>;
+	isError: boolean;
+	errorText?: string;
+}
+
+export interface SlashSubagentUpdate {
+	requestId: string;
+	progress?: Details["progress"];
+	currentTool?: string;
+	toolCount?: number;
+}
+
+interface EventBus {
+	on(event: string, handler: (data: unknown) => void): (() => void) | void;
+	emit(event: string, data: unknown): void;
+}
+
+interface SlashBridgeOptions {
+	events: EventBus;
+	getContext: () => ExtensionContext | null;
+	execute: (
+		id: string,
+		params: SubagentParamsLike,
+		signal: AbortSignal,
+		onUpdate: ((r: AgentToolResult<Details>) => void) | undefined,
+		ctx: ExtensionContext,
+	) => Promise<AgentToolResult<Details>>;
+}
+
+export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
+	cancelAll: () => void;
+	dispose: () => void;
+} {
+	const controllers = new Map<string, AbortController>();
+	const pendingCancels = new Set<string>();
+	const subscriptions: Array<() => void> = [];
+
+	const subscribe = (event: string, handler: (data: unknown) => void): void => {
+		const unsubscribe = options.events.on(event, handler);
+		if (typeof unsubscribe === "function") subscriptions.push(unsubscribe);
+	};
+
+	subscribe(SLASH_SUBAGENT_CANCEL_EVENT, (data) => {
+		if (!data || typeof data !== "object") return;
+		const requestId = (data as { requestId?: unknown }).requestId;
+		if (typeof requestId !== "string") return;
+		const controller = controllers.get(requestId);
+		if (controller) {
+			controller.abort();
+			return;
+		}
+		pendingCancels.add(requestId);
+	});
+
+	subscribe(SLASH_SUBAGENT_REQUEST_EVENT, async (data) => {
+		if (!data || typeof data !== "object") return;
+		const request = data as Partial<SlashSubagentRequest>;
+		if (typeof request.requestId !== "string" || !request.params) return;
+		const { requestId } = request as SlashSubagentRequest;
+		const normalized = normalizePublicSubagentExecution((request as SlashSubagentRequest).params);
+		if (!normalized.ok) {
+			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
+				requestId,
+				result: {
+					content: [{ type: "text", text: normalized.error }],
+					isError: true,
+					details: { mode: normalized.mode, results: [] },
+				},
+				isError: true,
+				errorText: normalized.error,
+			} satisfies SlashSubagentResponse);
+			return;
+		}
+		const params = normalized.params;
+
+		const ctx = request.ctx ?? options.getContext();
+		if (!ctx) {
+			const response: SlashSubagentResponse = {
+				requestId,
+				result: {
+					content: [{ type: "text", text: "No active extension context for slash subagent execution." }],
+					details: { mode: "single" as const, results: [] },
+				},
+				isError: true,
+				errorText: "No active extension context.",
+			};
+			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			return;
+		}
+
+		const controller = new AbortController();
+		controllers.set(requestId, controller);
+
+		if (pendingCancels.delete(requestId)) {
+			controller.abort();
+			const response: SlashSubagentResponse = {
+				requestId,
+				result: {
+					content: [{ type: "text", text: "Cancelled." }],
+					details: { mode: "single" as const, results: [] },
+				},
+				isError: true,
+				errorText: "Cancelled before start.",
+			};
+			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			controllers.delete(requestId);
+			return;
+		}
+
+		options.events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId });
+
+		try {
+			const result = await options.execute(
+				requestId,
+				params,
+				controller.signal,
+				(update) => {
+					const progress = update.details?.progress;
+					const first = progress?.[0];
+					const payload: SlashSubagentUpdate = {
+						requestId,
+						progress,
+						currentTool: first?.currentTool,
+						toolCount: first?.toolCount,
+					};
+					options.events.emit(SLASH_SUBAGENT_UPDATE_EVENT, payload);
+				},
+				ctx,
+			);
+
+			const response: SlashSubagentResponse = {
+				requestId,
+				result,
+				isError: (result as { isError?: boolean }).isError === true,
+				errorText: (result as { isError?: boolean }).isError
+					? result.content.find((c) => c.type === "text")?.text
+					: undefined,
+			};
+			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+		} catch (error) {
+			const response: SlashSubagentResponse = {
+				requestId,
+				result: {
+					content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+					details: { mode: "single" as const, results: [] },
+				},
+				isError: true,
+				errorText: error instanceof Error ? error.message : String(error),
+			};
+			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+		} finally {
+			controllers.delete(requestId);
+		}
+	});
+
+	return {
+		cancelAll: () => {
+			for (const controller of controllers.values()) {
+				controller.abort();
+			}
+			controllers.clear();
+			pendingCancels.clear();
+		},
+		dispose: () => {
+			for (const unsubscribe of subscriptions) unsubscribe();
+			subscriptions.length = 0;
+			pendingCancels.clear();
+		},
+	};
+}