@leing2021/super-pi 0.20.0 → 0.22.0

package/extensions/subagent/agent-manager-list.ts

@@ -0,0 +1,278 @@
+// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
+// MIT License
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import type { AgentSource } from "./agents.ts";
+import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { pad, row, renderHeader, renderFooter, fuzzyFilter, formatScrollInfo } from "./render-helpers.ts";
+
+export interface ListAgent {
+	id: string;
+	name: string;
+	description: string;
+	model?: string;
+	source: AgentSource;
+	overrideScope?: "user" | "project";
+	disabled?: boolean;
+	kind: "agent" | "chain";
+	stepCount?: number;
+}
+
+export interface ListState {
+	cursor: number;
+	scrollOffset: number;
+	filterQuery: string;
+	selected: string[];
+}
+
+export type ListAction =
+	| { type: "open-detail"; id: string }
+	| { type: "clone"; id: string }
+	| { type: "new" }
+	| { type: "delete"; id: string }
+	| { type: "run-chain"; ids: string[] }
+	| { type: "run-parallel"; ids: string[] }
+	| { type: "close" };
+
+const LIST_VIEWPORT_HEIGHT = 8;
+
+function selectionCount(selected: string[], id: string): number {
+	let count = 0;
+	for (const s of selected) if (s === id) count++;
+	return count;
+}
+
+function clampCursor(state: ListState, filtered: ListAgent[]): void {
+	if (filtered.length === 0) {
+		state.cursor = 0;
+		state.scrollOffset = 0;
+		return;
+	}
+
+	state.cursor = Math.max(0, Math.min(state.cursor, filtered.length - 1));
+	const maxOffset = Math.max(0, filtered.length - LIST_VIEWPORT_HEIGHT);
+	state.scrollOffset = Math.max(0, Math.min(state.scrollOffset, maxOffset));
+
+	if (state.cursor < state.scrollOffset) {
+		state.scrollOffset = state.cursor;
+	} else if (state.cursor >= state.scrollOffset + LIST_VIEWPORT_HEIGHT) {
+		state.scrollOffset = state.cursor - LIST_VIEWPORT_HEIGHT + 1;
+	}
+}
+
+export function handleListInput(state: ListState, agents: ListAgent[], data: string): ListAction | undefined {
+	const filtered = fuzzyFilter(agents, state.filterQuery);
+
+	if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+		if (state.filterQuery.length > 0) {
+			state.filterQuery = "";
+			state.cursor = 0;
+			state.scrollOffset = 0;
+			return;
+		}
+		if (state.selected.length > 0) {
+			state.selected.length = 0;
+			return;
+		}
+		return { type: "close" };
+	}
+
+	if (matchesKey(data, "return")) {
+		if (filtered.length > 0) {
+			const agent = filtered[state.cursor];
+			if (agent) return { type: "open-detail", id: agent.id };
+		}
+		return;
+	}
+
+	if (matchesKey(data, "up") || matchesKey(data, "down")) {
+		if (matchesKey(data, "up")) state.cursor -= 1;
+		if (matchesKey(data, "down")) state.cursor += 1;
+		clampCursor(state, filtered);
+		return;
+	}
+
+	if (matchesKey(data, "backspace")) {
+		if (state.filterQuery.length > 0) {
+			state.filterQuery = state.filterQuery.slice(0, -1);
+			state.cursor = 0;
+			state.scrollOffset = 0;
+		}
+		return;
+	}
+
+	if (matchesKey(data, "alt+n")) {
+		return { type: "new" };
+	}
+
+	if (matchesKey(data, "ctrl+k")) {
+		const agent = filtered[state.cursor];
+		if (agent) return { type: "clone", id: agent.id };
+		return;
+	}
+
+	if (matchesKey(data, "ctrl+d") || matchesKey(data, "delete")) {
+		const agent = filtered[state.cursor];
+		if (agent) return { type: "delete", id: agent.id };
+		return;
+	}
+
+	if (matchesKey(data, "tab")) {
+		const agent = filtered[state.cursor];
+		if (!agent) return;
+		if (agent.kind !== "agent") return;
+		state.selected.push(agent.id);
+		return;
+	}
+
+	if (matchesKey(data, "shift+tab")) {
+		const agent = filtered[state.cursor];
+		if (!agent) return;
+		const lastIdx = state.selected.lastIndexOf(agent.id);
+		if (lastIdx >= 0) state.selected.splice(lastIdx, 1);
+		return;
+	}
+
+	if (matchesKey(data, "ctrl+r")) {
+		if (state.selected.length > 0) return { type: "run-chain", ids: [...state.selected] };
+		const agent = filtered[state.cursor];
+		if (agent && agent.kind === "agent") return { type: "run-chain", ids: [agent.id] };
+		return;
+	}
+
+	if (matchesKey(data, "ctrl+p")) {
+		if (state.selected.length > 0) return { type: "run-parallel", ids: [...state.selected] };
+		const agent = filtered[state.cursor];
+		if (agent && agent.kind === "agent") return { type: "run-parallel", ids: [agent.id] };
+		return;
+	}
+
+	if (data.length === 1 && data.charCodeAt(0) >= 32) {
+		state.filterQuery += data;
+		state.cursor = 0;
+		state.scrollOffset = 0;
+		return;
+	}
+
+	return;
+}
+
+export function renderList(
+	state: ListState,
+	agents: ListAgent[],
+	width: number,
+	theme: Theme,
+	statusMessage?: { text: string; type: "error" | "info" },
+): string[] {
+	const lines: string[] = [];
+	const filtered = fuzzyFilter(agents, state.filterQuery);
+	clampCursor(state, filtered);
+
+	const agentCount = agents.filter((a) => a.kind === "agent").length;
+	const chainCount = agents.filter((a) => a.kind === "chain").length;
+	const headerText = chainCount
+		? ` Subagents [${agentCount} agents  ${chainCount} chains] `
+		: ` Subagents [${agentCount}] `;
+	lines.push(renderHeader(headerText, width, theme));
+	lines.push(row("", width, theme));
+
+	const cursor = theme.fg("accent", "│");
+	const searchIcon = theme.fg("dim", "◎");
+	const placeholder = theme.fg("dim", "\x1b[3mtype to filter...\x1b[23m");
+	const queryDisplay = state.filterQuery ? `${state.filterQuery}${cursor}` : `${cursor}${placeholder}`;
+	lines.push(row(` ${searchIcon}  ${queryDisplay}`, width, theme));
+	lines.push(row("", width, theme));
+
+	const userNames = new Set(agents.filter((a) => a.source === "user" && a.kind === "agent").map((a) => a.name));
+	const startIdx = state.scrollOffset;
+	const endIdx = Math.min(filtered.length, startIdx + LIST_VIEWPORT_HEIGHT);
+	const visible = filtered.slice(startIdx, endIdx);
+
+	if (filtered.length === 0) {
+		lines.push(row(` ${theme.fg("dim", "No matching agents")}`, width, theme));
+		for (let i = 1; i < LIST_VIEWPORT_HEIGHT; i++) lines.push(row("", width, theme));
+	} else {
+		const innerW = width - 2;
+		const nameWidth = 16;
+		const modelWidth = 12;
+		const scopeWidth = 21;
+
+		for (let i = 0; i < visible.length; i++) {
+			const agent = visible[i]!;
+			const index = startIdx + i;
+			const isCursor = index === state.cursor;
+			const count = selectionCount(state.selected, agent.id);
+			const isShadowed = agent.kind === "agent" && agent.source === "project" && userNames.has(agent.name);
+
+			const cursorChar = isCursor ? theme.fg("accent", ">") : " ";
+			const selectBadge = count > 0 ? theme.fg("accent", String(count).padStart(2)) : "  ";
+			const shadowMarker = isShadowed ? theme.fg("warning", "!") : " ";
+			const prefix = `${cursorChar}${selectBadge}${shadowMarker} `;
+
+			const modelRaw = agent.kind === "chain" ? `${agent.stepCount ?? 0} steps` : (agent.model ?? "default");
+			const modelDisplay = modelRaw.includes("/") ? modelRaw.split("/").pop() ?? modelRaw : modelRaw;
+			const nameText = isCursor ? theme.fg("accent", agent.name) : agent.name;
+			const modelText = theme.fg("dim", modelDisplay);
+			const scopeLabel = agent.kind === "chain"
+				? "[chain]"
+				: agent.source === "builtin"
+					? (agent.disabled
+						? (agent.overrideScope ? `[builtin off+${agent.overrideScope}]` : "[builtin off]")
+						: (agent.overrideScope ? `[builtin+${agent.overrideScope}]` : "[builtin]"))
+					: agent.source === "project"
+						? "[proj]"
+						: "[user]";
+			const scopeBadge = theme.fg("dim", scopeLabel);
+			const descText = theme.fg("dim", agent.description);
+
+			const descWidth = Math.max(0, innerW - 1 - visibleWidth(prefix) - nameWidth - modelWidth - scopeWidth - 3);
+			const line =
+				prefix +
+				pad(truncateToWidth(nameText, nameWidth), nameWidth) +
+				" " +
+				pad(truncateToWidth(modelText, modelWidth), modelWidth) +
+				" " +
+				pad(scopeBadge, scopeWidth) +
+				" " +
+				truncateToWidth(descText, descWidth);
+
+			lines.push(row(` ${line}`, width, theme));
+		}
+
+		for (let i = visible.length; i < LIST_VIEWPORT_HEIGHT; i++) {
+			lines.push(row("", width, theme));
+		}
+	}
+
+	const scrollInfo = formatScrollInfo(state.scrollOffset, Math.max(0, filtered.length - (state.scrollOffset + LIST_VIEWPORT_HEIGHT)));
+	const selectedNames = state.selected
+		.map((id) => agents.find((a) => a.id === id))
+		.filter((a): a is ListAgent => Boolean(a))
+		.map((a) => a.name);
+	const preview = selectedNames.length > 0 ? truncateToWidth(selectedNames.join(" → "), width - 4) : "";
+
+	lines.push(row("", width, theme));
+
+	if (statusMessage) {
+		const color = statusMessage.type === "error" ? "error" : "success";
+		lines.push(row(` ${theme.fg(color, truncateToWidth(statusMessage.text, width - 4))}`, width, theme));
+	} else if (preview) {
+		lines.push(row(` ${theme.fg("dim", preview)}`, width, theme));
+	} else {
+		const cursorAgent = filtered[state.cursor];
+		const desc = cursorAgent ? truncateToWidth(cursorAgent.description, width - 4) : "";
+		const content = desc || scrollInfo;
+		lines.push(row(content ? ` ${theme.fg("dim", content)}` : "", width, theme));
+	}
+
+	lines.push(row("", width, theme));
+
+	const selCount = state.selected.length;
+	const footerText = selCount > 1
+		? ` [ctrl+r] chain  [ctrl+p] parallel  [tab] add  [shift+tab] remove  [esc] clear (${selCount}) `
+		: selCount === 1
+			? " [ctrl+r] run  [ctrl+p] parallel  [tab] add more  [shift+tab] remove  [esc] clear "
+			: " [enter] view  [ctrl+r] run  [tab] select  [alt+n] new  [esc] close ";
+	lines.push(renderFooter(footerText, width, theme));
+
+	return lines;
+}

package/extensions/subagent/agent-manager-parallel.ts

@@ -0,0 +1,304 @@
+// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
+// MIT License
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { TextEditorState } from "./text-editor.ts";
+import { createEditorState, handleEditorInput, renderEditor, wrapText, getCursorDisplayPos, ensureCursorVisible } from "./text-editor.ts";
+import { pad, row, renderHeader, renderFooter, fuzzyFilter } from "./render-helpers.ts";
+
+export interface ParallelSlot {
+	agentName: string;
+	customTask: string;
+}
+
+export interface ParallelState {
+	slots: ParallelSlot[];
+	cursor: number;
+	scrollOffset: number;
+	mode: "browse" | "add" | "edit-task";
+	addQuery: string;
+	addCursor: number;
+	editIndex: number;
+	editEditor: TextEditorState | null;
+}
+
+export type ParallelAction =
+	| { type: "proceed" }
+	| { type: "back" };
+
+export interface AgentOption {
+	name: string;
+	description: string;
+	model?: string;
+}
+
+const CONTENT_HEIGHT = 14;
+const SLOT_VIEWPORT_BROWSE = 12;
+const SLOT_VIEWPORT_COMPACT = 5;
+const ADD_RESULTS_MAX = 5;
+
+export function createParallelState(agentNames: string[]): ParallelState {
+	return {
+		slots: agentNames.map((name) => ({ agentName: name, customTask: "" })),
+		cursor: 0,
+		scrollOffset: 0,
+		mode: "browse",
+		addQuery: "",
+		addCursor: 0,
+		editIndex: -1,
+		editEditor: null,
+	};
+}
+
+function clampSlotScroll(state: ParallelState, viewport: number): void {
+	if (state.slots.length === 0) { state.cursor = 0; state.scrollOffset = 0; return; }
+	state.cursor = Math.max(0, Math.min(state.cursor, state.slots.length - 1));
+	const maxOffset = Math.max(0, state.slots.length - viewport);
+	state.scrollOffset = Math.max(0, Math.min(state.scrollOffset, maxOffset));
+	if (state.cursor < state.scrollOffset) state.scrollOffset = state.cursor;
+	else if (state.cursor >= state.scrollOffset + viewport) state.scrollOffset = state.cursor - viewport + 1;
+}
+
+export function handleParallelInput(
+	state: ParallelState,
+	agents: AgentOption[],
+	data: string,
+	width: number,
+): ParallelAction | undefined {
+	switch (state.mode) {
+		case "browse": return handleBrowse(state, data);
+		case "add": return handleAdd(state, agents, data);
+		case "edit-task": return handleEditTask(state, data, width);
+	}
+}
+
+function handleBrowse(state: ParallelState, data: string): ParallelAction | undefined {
+	if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) return { type: "back" };
+	if (matchesKey(data, "up")) { state.cursor = Math.max(0, state.cursor - 1); clampSlotScroll(state, SLOT_VIEWPORT_BROWSE); return; }
+	if (matchesKey(data, "down")) { state.cursor = Math.min(state.slots.length - 1, state.cursor + 1); clampSlotScroll(state, SLOT_VIEWPORT_BROWSE); return; }
+
+	if (matchesKey(data, "ctrl+a")) {
+		state.mode = "add";
+		state.addQuery = "";
+		state.addCursor = 0;
+		return;
+	}
+
+	if (matchesKey(data, "delete") || matchesKey(data, "ctrl+d")) {
+		if (state.slots.length > 1) {
+			state.slots.splice(state.cursor, 1);
+			state.cursor = Math.min(state.cursor, state.slots.length - 1);
+			clampSlotScroll(state, SLOT_VIEWPORT_BROWSE);
+		}
+		return;
+	}
+
+	if (matchesKey(data, "return")) {
+		if (state.slots.length === 0) return;
+		state.mode = "edit-task";
+		state.editIndex = state.cursor;
+		state.editEditor = createEditorState(state.slots[state.cursor]!.customTask);
+		return;
+	}
+
+	if (matchesKey(data, "ctrl+r")) {
+		if (state.slots.length >= 2) return { type: "proceed" };
+		return;
+	}
+
+	return;
+}
+
+function handleAdd(state: ParallelState, agents: AgentOption[], data: string): ParallelAction | undefined {
+	if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { state.mode = "browse"; return; }
+
+	const filtered = fuzzyFilter(agents, state.addQuery);
+
+	if (matchesKey(data, "up")) { state.addCursor = Math.max(0, state.addCursor - 1); return; }
+	if (matchesKey(data, "down")) { state.addCursor = Math.min(Math.max(0, filtered.length - 1), state.addCursor + 1); return; }
+
+	if (matchesKey(data, "return")) {
+		const selected = filtered[state.addCursor];
+		if (selected) {
+			state.slots.push({ agentName: selected.name, customTask: "" });
+			state.cursor = state.slots.length - 1;
+			clampSlotScroll(state, SLOT_VIEWPORT_BROWSE);
+		}
+		state.mode = "browse";
+		return;
+	}
+
+	if (matchesKey(data, "backspace")) {
+		state.addQuery = state.addQuery.slice(0, -1);
+		state.addCursor = 0;
+		return;
+	}
+
+	if (data.length === 1 && data.charCodeAt(0) >= 32) {
+		state.addQuery += data;
+		state.addCursor = 0;
+		return;
+	}
+
+	return;
+}
+
+function handleEditTask(state: ParallelState, data: string, width: number): ParallelAction | undefined {
+	if (!state.editEditor) { state.mode = "browse"; return; }
+
+	if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+		state.editEditor = null;
+		state.mode = "browse";
+		return;
+	}
+
+	if (matchesKey(data, "return")) {
+		const slot = state.slots[state.editIndex];
+		if (slot) slot.customTask = state.editEditor.buffer.trim();
+		state.editEditor = null;
+		state.mode = "browse";
+		return;
+	}
+
+	if (matchesKey(data, "tab")) return;
+
+	const innerW = width - 2;
+	const boxInnerWidth = Math.max(10, innerW - 4);
+	const nextState = handleEditorInput(state.editEditor, data, boxInnerWidth);
+	if (nextState) state.editEditor = nextState;
+	return;
+}
+
+function renderSlotLine(
+	slot: ParallelSlot,
+	slotNumber: number,
+	isCursor: boolean,
+	width: number,
+	theme: Theme,
+): string {
+	const cursor = isCursor ? theme.fg("accent", "▸") : " ";
+	const num = theme.fg("accent", slotNumber.toString().padStart(2));
+	const name = isCursor ? theme.fg("accent", slot.agentName) : slot.agentName;
+	const nameWidth = 16;
+	const prefix = `${cursor} ${num}  `;
+	const prefixVis = visibleWidth(prefix);
+	const nameStr = pad(truncateToWidth(name, nameWidth), nameWidth);
+
+	if (slot.customTask) {
+		const taskWidth = Math.max(0, width - 2 - prefixVis - nameWidth - 3);
+		const taskPreview = theme.fg("dim", `"${truncateToWidth(slot.customTask, Math.max(0, taskWidth - 2))}"`);
+		return ` ${prefix}${nameStr}  ${taskPreview}`;
+	}
+	return ` ${prefix}${nameStr}`;
+}
+
+export function renderParallel(
+	state: ParallelState,
+	agents: AgentOption[],
+	width: number,
+	theme: Theme,
+): string[] {
+	const lines: string[] = [];
+	lines.push(renderHeader(" Parallel Builder ", width, theme));
+	lines.push(row("", width, theme));
+
+	const contentLines: string[] = [];
+
+	if (state.mode === "browse") {
+		clampSlotScroll(state, SLOT_VIEWPORT_BROWSE);
+		const start = state.scrollOffset;
+		const end = Math.min(state.slots.length, start + SLOT_VIEWPORT_BROWSE);
+		for (let i = start; i < end; i++) {
+			contentLines.push(renderSlotLine(state.slots[i]!, i + 1, i === state.cursor, width, theme));
+		}
+	} else if (state.mode === "add") {
+		const slotLines = Math.min(state.slots.length, SLOT_VIEWPORT_COMPACT);
+		const slotStart = Math.max(0, state.slots.length - slotLines);
+		for (let i = slotStart; i < state.slots.length; i++) {
+			contentLines.push(renderSlotLine(state.slots[i]!, i + 1, false, width, theme));
+		}
+		contentLines.push("");
+
+		const searchIcon = theme.fg("dim", "◎");
+		const cursor = theme.fg("accent", "│");
+		const placeholder = theme.fg("dim", "\x1b[3msearch agents...\x1b[23m");
+		const queryDisplay = state.addQuery ? `${state.addQuery}${cursor}` : `${cursor}${placeholder}`;
+		contentLines.push(` ${searchIcon}  ${queryDisplay}`);
+
+		const filtered = fuzzyFilter(agents, state.addQuery);
+		const addStart = Math.max(0, Math.min(state.addCursor - ADD_RESULTS_MAX + 1, filtered.length - ADD_RESULTS_MAX));
+		const addEnd = Math.min(filtered.length, addStart + ADD_RESULTS_MAX);
+		for (let i = addStart; i < addEnd; i++) {
+			const a = filtered[i]!;
+			const isCursor = i === state.addCursor;
+			const cur = isCursor ? theme.fg("accent", "▸") : " ";
+			const nameStr = isCursor ? theme.fg("accent", a.name) : a.name;
+			const descWidth = Math.max(0, width - 2 - 1 - 1 - 16 - 2);
+			contentLines.push(` ${cur} ${pad(truncateToWidth(nameStr, 16), 16)}  ${theme.fg("dim", truncateToWidth(a.description, descWidth))}`);
+		}
+	} else if (state.mode === "edit-task") {
+		const slotLines = Math.min(state.slots.length, SLOT_VIEWPORT_COMPACT);
+		const slotStart = Math.max(0, Math.min(state.editIndex - Math.floor(slotLines / 2), state.slots.length - slotLines));
+		for (let i = slotStart; i < slotStart + slotLines; i++) {
+			contentLines.push(renderSlotLine(state.slots[i]!, i + 1, i === state.editIndex, width, theme));
+		}
+		contentLines.push("");
+
+		const slot = state.slots[state.editIndex];
+		const label = slot ? `Task for ${slot.agentName} (slot ${state.editIndex + 1}):` : "Task:";
+		contentLines.push(` ${theme.fg("dim", label)}`);
+
+		const innerW = width - 2;
+		const boxInnerWidth = Math.max(10, innerW - 4);
+		contentLines.push(` \u250C${"\u2500".repeat(boxInnerWidth)}\u2510`);
+
+		if (state.editEditor) {
+			const editorState = { ...state.editEditor };
+			const wrapped = wrapText(editorState.buffer, boxInnerWidth);
+			const cursorPos = getCursorDisplayPos(editorState.cursor, wrapped.starts);
+			editorState.viewportOffset = ensureCursorVisible(cursorPos.line, 1, editorState.viewportOffset);
+			const editorLine = renderEditor(editorState, boxInnerWidth, 1)[0] ?? "";
+			contentLines.push(` \u2502${pad(editorLine, boxInnerWidth)}\u2502`);
+		} else {
+			contentLines.push(` \u2502${pad("", boxInnerWidth)}\u2502`);
+		}
+
+		contentLines.push(` \u2514${"\u2500".repeat(boxInnerWidth)}\u2518`);
+		contentLines.push(` ${theme.fg("dim", "Empty = use shared task")}`);
+	}
+
+	for (const line of contentLines) lines.push(row(line, width, theme));
+	for (let i = contentLines.length; i < CONTENT_HEIGHT; i++) lines.push(row("", width, theme));
+
+	let statusText = "";
+	if (state.mode === "browse") {
+		if (state.slots.length < 2) {
+			statusText = theme.fg("dim", `${state.slots.length} agent — add at least 2 for parallel`);
+		} else {
+			statusText = theme.fg("dim", formatSlotSummary(state.slots));
+		}
+	}
+	lines.push(row(statusText ? ` ${statusText}` : "", width, theme));
+
+	let footerText: string;
+	if (state.mode === "add") {
+		footerText = " [enter] add  [esc] cancel ";
+	} else if (state.mode === "edit-task") {
+		footerText = " [enter] save  [esc] cancel ";
+	} else {
+		footerText = " [ctrl+a] add  [del] remove  [enter] edit task  [ctrl+r] continue  [esc] back ";
+	}
+	lines.push(renderFooter(footerText, width, theme));
+
+	return lines;
+}
+
+function formatSlotSummary(slots: ParallelSlot[]): string {
+	const counts = new Map<string, number>();
+	for (const s of slots) counts.set(s.agentName, (counts.get(s.agentName) ?? 0) + 1);
+	return [...counts.entries()].map(([name, count]) => count > 1 ? `${count}\u00D7 ${name}` : name).join(" + ");
+}
+
+export function formatParallelTitle(slots: ParallelSlot[]): string {
+	return `Parallel: ${formatSlotSummary(slots)}`;
+}