@bdsqqq/pi 0.0.1

package/dist/extensions/skill.js

@@ -0,0 +1,232 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { boxRendererWindowed, textSection } from "../core/box-format.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as os from "node:os";
+//#region packages/extensions/skill/index.ts
+/**
+* skill tool — load a skill by name, returning its content for
+* injection into the conversation context.
+*
+* replaces pi's default approach (model uses `read` on the SKILL.md
+* path) with a dedicated tool. the model
+* calls `skill(name: "git")` instead of `read(path: "/.../SKILL.md")`.
+*
+* discovery searches skill directories configured in pi's settings
+* (settings.json `skills` array), the default agentDir/skills/,
+* and project-local .pi/skills/. frontmatter is parsed for name
+* and description. files in the skill directory are listed in
+* <skill_files> for the model to read if needed.
+*
+* does NOT inject MCP or builtin tools from frontmatter — that
+* requires runtime tool registration which is out of scope for
+* this first pass.
+*/
+const COLLAPSED_EXCERPTS = [{
+	focus: "head",
+	context: 3
+}, {
+	focus: "tail",
+	context: 5
+}];
+function parseFrontmatter(content) {
+	const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+	if (!normalized.startsWith("---")) return {
+		frontmatter: {},
+		body: normalized
+	};
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) return {
+		frontmatter: {},
+		body: normalized
+	};
+	const yamlStr = normalized.slice(4, endIndex);
+	const body = normalized.slice(endIndex + 4).trim();
+	const frontmatter = {};
+	for (const line of yamlStr.split("\n")) {
+		const match = line.match(/^(\w[\w-]*):\s*"?(.+?)"?\s*$/);
+		if (match && match[1] && match[2]) frontmatter[match[1]] = match[2];
+	}
+	return {
+		frontmatter,
+		body
+	};
+}
+/**
+* resolve agentDir the same way pi does:
+* env PI_CODING_AGENT_DIR > ~/.pi/agent/
+*/
+function getAgentDir() {
+	const envDir = process.env.PI_CODING_AGENT_DIR;
+	if (envDir) {
+		if (envDir === "~") return os.homedir();
+		if (envDir.startsWith("~/")) return os.homedir() + envDir.slice(1);
+		return envDir;
+	}
+	return path.join(os.homedir(), ".pi", "agent");
+}
+/**
+* read pi's settings.json to get additional skill paths.
+* returns the `skills` array if present.
+*/
+function getSkillPathsFromSettings() {
+	const settingsPath = path.join(getAgentDir(), "settings.json");
+	if (!fs.existsSync(settingsPath)) return [];
+	try {
+		const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+		if (Array.isArray(settings.skills)) return settings.skills.map((p) => {
+			if (p === "~") return os.homedir();
+			if (p.startsWith("~/")) return os.homedir() + p.slice(1);
+			return p;
+		});
+	} catch {}
+	return [];
+}
+/**
+* search for a skill by name across all known directories.
+* checks: agentDir/skills/{name}/SKILL.md, settings skill paths,
+* and project-local .pi/skills/{name}/SKILL.md.
+*/
+function findSkill(name, cwd) {
+	const candidates = [];
+	candidates.push(path.join(getAgentDir(), "skills", name, "SKILL.md"));
+	for (const skillDir of getSkillPathsFromSettings()) candidates.push(path.join(skillDir, name, "SKILL.md"));
+	candidates.push(path.join(cwd, ".pi", "skills", name, "SKILL.md"));
+	for (const candidate of candidates) if (fs.existsSync(candidate)) return {
+		name,
+		filePath: candidate,
+		baseDir: path.dirname(candidate)
+	};
+	return null;
+}
+/**
+* list all known skill names for error messages.
+*/
+function listAvailableSkills(cwd) {
+	const names = /* @__PURE__ */ new Set();
+	const dirs = [
+		path.join(getAgentDir(), "skills"),
+		...getSkillPathsFromSettings(),
+		path.join(cwd, ".pi", "skills")
+	];
+	for (const dir of dirs) {
+		if (!fs.existsSync(dir)) continue;
+		try {
+			for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+				if (!entry.isDirectory()) continue;
+				const skillMd = path.join(dir, entry.name, "SKILL.md");
+				if (fs.existsSync(skillMd)) names.add(entry.name);
+			}
+		} catch {}
+	}
+	return Array.from(names).sort();
+}
+/**
+* collect file paths in the skill directory (excluding SKILL.md),
+* walking subdirectories. used for the <skill_files> block so the
+* model knows what reference files are available.
+*/
+function collectSkillFiles(baseDir) {
+	const files = [];
+	function walk(dir) {
+		let entries;
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (entry.name.startsWith(".")) continue;
+			if (entry.name === "node_modules") continue;
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) walk(full);
+			else if (entry.isFile() && entry.name !== "SKILL.md") files.push(full);
+		}
+	}
+	walk(baseDir);
+	return files;
+}
+function createSkillTool() {
+	return {
+		name: "skill",
+		label: "Load Skill",
+		description: "Load a specialized skill that provides domain-specific instructions and workflows.\n\nWhen you recognize that a task matches one of the available skills, use this tool to load the full skill instructions.\n\nThe skill will inject detailed instructions, workflows, and access to bundled resources (scripts, references, templates) into the conversation context.",
+		parameters: Type.Object({
+			name: Type.String({ description: "The name of the skill to load (must match one of the available skills)." }),
+			arguments: Type.Optional(Type.String({ description: "Optional arguments to pass to the skill." }))
+		}),
+		renderCall(args, theme) {
+			const name = args.name || "...";
+			return new Text(theme.fg("dim", "using ") + theme.fg("toolTitle", theme.bold(name)) + theme.fg("dim", " skill"), 0, 0);
+		},
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const p = params;
+			const skill = findSkill(p.name, ctx.cwd);
+			if (!skill) {
+				const available = listAvailableSkills(ctx.cwd);
+				const list = available.length > 0 ? `\n\navailable skills: ${available.join(", ")}` : "";
+				return {
+					content: [{
+						type: "text",
+						text: `skill "${p.name}" not found.${list}`
+					}],
+					isError: true
+				};
+			}
+			let rawContent;
+			try {
+				rawContent = fs.readFileSync(skill.filePath, "utf-8");
+			} catch (err) {
+				return {
+					content: [{
+						type: "text",
+						text: `failed to read skill file: ${err.message}`
+					}],
+					isError: true
+				};
+			}
+			const { body } = parseFrontmatter(rawContent);
+			const parts = [
+				`<loaded_skill name="${skill.name}">`,
+				body,
+				"",
+				`Base directory for this skill: file://${skill.baseDir}`,
+				"Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory."
+			];
+			const skillFiles = collectSkillFiles(skill.baseDir);
+			if (skillFiles.length > 0) {
+				parts.push("");
+				parts.push("<skill_files>");
+				for (const f of skillFiles) parts.push(`<file>${f}</file>`);
+				parts.push("</skill_files>");
+			}
+			parts.push("</loaded_skill>");
+			return {
+				content: [{
+					type: "text",
+					text: parts.join("\n")
+				}],
+				details: { header: skill.name }
+			};
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			if (content.text.startsWith("<loaded_skill")) return boxRendererWindowed(() => [textSection(void 0, "skill loaded", true)], {
+				collapsed: {},
+				expanded: {}
+			}, void 0, expanded);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		}
+	};
+}
+function skill_default(pi) {
+	pi.registerTool(withPromptPatch(createSkillTool()));
+}
+//#endregion
+export { createSkillTool, skill_default as default };

package/dist/extensions/system-prompt.d.ts

@@ -0,0 +1,6 @@
+import { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/system-prompt/index.d.ts
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { export_default as default };

package/dist/extensions/system-prompt.js

@@ -0,0 +1,31 @@
+import { getExtensionConfig } from "../core/config.js";
+import { interpolatePromptVars } from "../core/interpolate.js";
+import { resolvePrompt } from "../core/pi-spawn.js";
+//#region packages/extensions/system-prompt/index.ts
+const CONFIG_DEFAULTS = {
+	identity: "Amp",
+	harness: "pi",
+	promptFile: "",
+	promptString: "",
+	harnessDocsPromptFile: "",
+	harnessDocsPromptString: ""
+};
+function system_prompt_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/system-prompt", CONFIG_DEFAULTS);
+	const body = resolvePrompt(cfg.promptString, cfg.promptFile);
+	if (!body) return;
+	const harnessDocsFile = cfg.harnessDocsPromptFile || `prompt.harness-docs.${cfg.harness}.md`;
+	const harnessDocs = resolvePrompt(cfg.harnessDocsPromptString, harnessDocsFile);
+	pi.on("before_agent_start", async (event, ctx) => {
+		const interpolated = interpolatePromptVars(body, ctx.cwd, {
+			sessionId: ctx.sessionManager.getSessionId(),
+			identity: cfg.identity,
+			harness: cfg.harness,
+			harnessDocsSection: harnessDocs
+		});
+		if (!interpolated.trim()) return;
+		return { systemPrompt: event.systemPrompt + "\n\n" + interpolated };
+	});
+}
+//#endregion
+export { system_prompt_default as default };

package/dist/extensions/task.d.ts

@@ -0,0 +1,11 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/task/index.d.ts
+interface TaskConfig {
+  builtinTools?: string[];
+  extensionTools?: string[];
+}
+declare function createTaskTool(config?: TaskConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { TaskConfig, createTaskTool, export_default as default };

package/dist/extensions/task.js

@@ -0,0 +1,114 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { getExtensionConfig } from "../core/config.js";
+import { piSpawn, zeroUsage } from "../core/pi-spawn.js";
+import { getFinalOutput, renderAgentTree, subAgentResult } from "../core/sub-agent-render.js";
+import { Container, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+//#region packages/extensions/task/index.ts
+const CONFIG_DEFAULTS = {
+	builtinTools: [
+		"read",
+		"grep",
+		"find",
+		"ls",
+		"bash",
+		"edit",
+		"write"
+	],
+	extensionTools: [
+		"read",
+		"grep",
+		"find",
+		"ls",
+		"bash",
+		"edit",
+		"write",
+		"format_file",
+		"skill",
+		"finder"
+	]
+};
+function createTaskTool(config = {}) {
+	return {
+		name: "Task",
+		label: "Task",
+		description: "Perform a task (a sub-task of the user's overall task) using a sub-agent that has access to the following tools: Read, Grep, Find, ls, Bash, Edit, Write, format_file, skill, finder.\n\nWhen to use the Task tool:\n- When you need to perform complex multi-step tasks\n- When you need to run an operation that will produce a lot of output (tokens) that is not needed after the sub-agent's task completes\n- When you are making changes across many layers of an application, after you have first planned and spec'd out the changes so they can be implemented independently\n- When the user asks you to launch an \"agent\" or \"subagent\"\n\nWhen NOT to use the Task tool:\n- When you are performing a single logical task\n- When you're reading a single file (use Read), performing a text search (use Grep), editing a single file (use Edit)\n- When you're not sure what changes you want to make\n\nHow to use the Task tool:\n- Run multiple sub-agents concurrently if tasks are independent, by including multiple tool uses in a single assistant message.\n- Include all necessary context and a detailed plan in the task description.\n- Tell the sub-agent how to verify its work if possible.\n- When the agent is done, it will return a single message back to you.",
+		parameters: Type.Object({
+			prompt: Type.String({ description: "The task for the agent to perform. Be specific and include any relevant context." }),
+			description: Type.String({ description: "A very short description of the task that can be displayed to the user." })
+		}),
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const p = params;
+			let sessionId = "";
+			try {
+				sessionId = ctx.sessionManager?.getSessionId?.() ?? "";
+			} catch {}
+			const singleResult = {
+				agent: "Task",
+				task: p.description,
+				exitCode: -1,
+				messages: [],
+				usage: zeroUsage()
+			};
+			const result = await piSpawn({
+				cwd: ctx.cwd,
+				task: p.prompt,
+				builtinTools: config.builtinTools ?? CONFIG_DEFAULTS.builtinTools,
+				extensionTools: config.extensionTools ?? CONFIG_DEFAULTS.extensionTools,
+				signal,
+				sessionId,
+				onUpdate: (partial) => {
+					singleResult.messages = partial.messages;
+					singleResult.usage = partial.usage;
+					singleResult.model = partial.model;
+					singleResult.stopReason = partial.stopReason;
+					singleResult.errorMessage = partial.errorMessage;
+					if (onUpdate) onUpdate({
+						content: [{
+							type: "text",
+							text: getFinalOutput(partial.messages) || "(working...)"
+						}],
+						details: singleResult
+					});
+				}
+			});
+			singleResult.exitCode = result.exitCode;
+			singleResult.messages = result.messages;
+			singleResult.usage = result.usage;
+			singleResult.model = result.model;
+			singleResult.stopReason = result.stopReason;
+			singleResult.errorMessage = result.errorMessage;
+			const isError = result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
+			const output = getFinalOutput(result.messages) || "(no output)";
+			if (isError) return subAgentResult(result.errorMessage || result.stderr || output, singleResult, true);
+			return subAgentResult(output, singleResult);
+		},
+		renderCall(args, theme) {
+			const desc = args.description || "...";
+			const preview = desc.length > 80 ? `${desc.slice(0, 80)}...` : desc;
+			return new Text(theme.fg("toolTitle", theme.bold("Task ")) + theme.fg("dim", preview), 0, 0);
+		},
+		renderResult(result, { expanded }, theme) {
+			const details = result.details;
+			if (!details) {
+				const text = result.content[0];
+				return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+			}
+			const container = new Container();
+			renderAgentTree(details, container, expanded, theme, {
+				label: "Task",
+				header: "statusOnly"
+			});
+			return container;
+		}
+	};
+}
+function task_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/task", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createTaskTool({
+		builtinTools: cfg.builtinTools,
+		extensionTools: cfg.extensionTools
+	})));
+}
+//#endregion
+export { createTaskTool, task_default as default };

package/dist/extensions/tool-harness.d.ts

@@ -0,0 +1,6 @@
+import { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/tool-harness/index.d.ts
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { export_default as default };

package/dist/extensions/tool-harness.js

@@ -0,0 +1,37 @@
+//#region packages/extensions/tool-harness/index.ts
+/**
+* backward-compat alias map: old names -> registered names.
+*/
+const TOOL_ALIASES = {
+	glob: "find",
+	edit_file: "edit",
+	create_file: "write"
+};
+function resolveAliases(names) {
+	return names.map((name) => TOOL_ALIASES[name] ?? name);
+}
+function tool_harness_default(pi) {
+	const raw = process.env.PI_INCLUDE_TOOLS;
+	if (!raw) return;
+	if (raw === "NONE") {
+		const applyEmpty = () => pi.setActiveTools([]);
+		pi.on("session_start", async () => {
+			applyEmpty();
+		});
+		pi.on("before_agent_start", async () => {
+			applyEmpty();
+		});
+		return;
+	}
+	const allowed = resolveAliases(raw.split(",").map((t) => t.trim()).filter(Boolean));
+	if (allowed.length === 0) return;
+	const applyFilter = () => pi.setActiveTools(allowed);
+	pi.on("session_start", async () => {
+		applyFilter();
+	});
+	pi.on("before_agent_start", async () => {
+		applyFilter();
+	});
+}
+//#endregion
+export { tool_harness_default as default };

package/dist/extensions/undo-edit.d.ts

@@ -0,0 +1,7 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/undo-edit/index.d.ts
+declare function createUndoEditTool(): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { createUndoEditTool, export_default as default };

package/dist/extensions/undo-edit.js

@@ -0,0 +1,127 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { boxRendererWindowed, osc8Link, textSection } from "../core/box-format.js";
+import { withFileLock } from "../core/mutex.js";
+import { resolveWithVariants } from "./read.js";
+import { findLatestChange, revertChange, simpleDiff } from "../core/file-tracker.js";
+import * as path from "node:path";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as os from "node:os";
+//#region packages/extensions/undo-edit/index.ts
+/**
+* undo_edit tool — reverts the last edit made to a file.
+*
+* uses lib/file-tracker's disk-based change records to find and
+* revert the most recent non-reverted change for a given file.
+*
+* branch awareness: scans the current session branch (via
+* sessionManager.getBranch()) to extract tool call IDs, then
+* only considers changes from those IDs. this prevents undoing
+* edits from a different conversation branch.
+*
+* mutex-locked to prevent concurrent undo + edit on the same file.
+*/
+const COLLAPSED_EXCERPTS = [{
+	focus: "head",
+	context: 3
+}, {
+	focus: "tail",
+	context: 5
+}];
+/**
+* extract tool call IDs from the current session branch.
+* session entries with type "message" and role "assistant" contain
+* tool_calls arrays. we collect all tool call IDs so findLatestChange
+* can filter to only branch-visible changes.
+*
+* falls back to empty array if getBranch() isn't available (e.g.,
+* running in a context where session tree access is restricted).
+*/
+function getActiveToolCallIds(sessionManager) {
+	try {
+		const branch = sessionManager.getBranch?.();
+		if (!Array.isArray(branch)) return [];
+		const ids = [];
+		for (const entry of branch) {
+			if (entry.type !== "message") continue;
+			const msg = entry.message;
+			if (msg?.role !== "assistant") continue;
+			if (Array.isArray(msg.tool_calls)) {
+				for (const tc of msg.tool_calls) if (tc.id) ids.push(tc.id);
+			}
+			if (Array.isArray(msg.content)) {
+				for (const block of msg.content) if (block.type === "tool_use" && block.id) ids.push(block.id);
+			}
+		}
+		return ids;
+	} catch {
+		return [];
+	}
+}
+function createUndoEditTool() {
+	return {
+		name: "undo_edit",
+		label: "Undo Edit",
+		description: "Undo the last edit made to a file.\n\nThis command reverts the most recent edit made to the specified file.\nIt will restore the file to its state before the last edit was made.\n\nReturns a diff showing the changes that were undone.",
+		parameters: Type.Object({ path: Type.String({ description: "The absolute path to the file whose last edit should be undone (must be absolute, not relative)." }) }),
+		renderCall(args, theme) {
+			const filePath = args.path || "...";
+			const home = os.homedir();
+			const shortened = filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+			const linked = filePath.startsWith("/") ? osc8Link(`file://${filePath}`, shortened) : shortened;
+			return new Text(theme.fg("toolTitle", theme.bold("Undo ")) + theme.fg("dim", linked), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		},
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const resolved = resolveWithVariants(params.path, ctx.cwd);
+			return withFileLock(resolved, async () => {
+				const sessionId = ctx.sessionManager.getSessionId();
+				const activeIds = getActiveToolCallIds(ctx.sessionManager);
+				if (activeIds.length === 0) return {
+					content: [{
+						type: "text",
+						text: "no edits found to undo (no tool calls in current branch)."
+					}],
+					isError: true
+				};
+				const latest = findLatestChange(sessionId, resolved, activeIds);
+				if (!latest) return {
+					content: [{
+						type: "text",
+						text: `no edits found to undo for ${path.basename(resolved)}.`
+					}],
+					isError: true
+				};
+				const reverted = revertChange(sessionId, latest.toolCallId, latest.change.id);
+				if (!reverted) return {
+					content: [{
+						type: "text",
+						text: `failed to revert — change may have already been undone.`
+					}],
+					isError: true
+				};
+				let result = simpleDiff(path.basename(resolved), reverted.after, reverted.before);
+				if (reverted.isNewFile) result += `\n\n(file was created by the reverted edit — file restored to empty)`;
+				return {
+					content: [{
+						type: "text",
+						text: result
+					}],
+					details: { header: resolved }
+				};
+			});
+		}
+	};
+}
+function undo_edit_default(pi) {
+	pi.registerTool(withPromptPatch(createUndoEditTool()));
+}
+//#endregion
+export { createUndoEditTool, undo_edit_default as default };

package/dist/extensions/web-search.d.ts

@@ -0,0 +1,12 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/web-search/index.d.ts
+type WebSearchExtConfig = {
+  defaultMaxResults: number;
+  endpoint: string;
+  curlTimeoutSecs: number;
+};
+declare function createWebSearchTool(config?: WebSearchExtConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { createWebSearchTool, export_default as default };