@diegopetrucci/pi-extensions 0.1.74 → 0.1.78

package/extensions/git-footer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-git-footer",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "A TLH-style git status add-on for pi's built-in footer.",
   "keywords": [
     "pi-package",
@@ -29,8 +29,7 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-coding-agent": "*"
   },
   "type": "module",
   "engines": {

package/extensions/gnosis/index.ts

@@ -1,159 +1,209 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import {
-	DEFAULT_MAX_BYTES,
-	DEFAULT_MAX_LINES,
-	formatSize,
-	truncateTail,
-	type ExtensionAPI,
-	type ToolExecutionMode,
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  formatSize,
+  truncateTail,
+  type ExtensionAPI,
+  type ToolExecutionMode,
 } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 
 const GNOSIS_TIMEOUT_MS = 30_000;
 
 const GnosisParams = Type.Object({
-	action: StringEnum(["plan", "review", "search", "latest", "show", "topics", "write", "reindex"] as const, {
-		description: "The gnosis operation to run.",
-	}),
-	query: Type.Optional(Type.String({ minLength: 1, description: "Search query for action=search. Use uppercase OR/NOT for FTS operators." })),
-	target: Type.Optional(Type.String({ minLength: 1, description: "Entry ID prefix or topic for action=show." })),
-	topics: Type.Optional(
-		Type.Array(Type.String({ minLength: 1 }), {
-			minItems: 1,
-			description: "Topics for action=write. Each normalized topic must be at least 7 chars.",
-		}),
-	),
-	text: Type.Optional(Type.String({ minLength: 1, description: "Knowledge text for action=write." })),
-	related: Type.Optional(
-		Type.Array(Type.String({ minLength: 1 }), { description: "Related entry IDs or unique prefixes for action=write." }),
-	),
-	limit: Type.Optional(Type.Integer({ minimum: 1, description: "Positive result limit for action=search or action=latest." })),
+  action: StringEnum(
+    ["plan", "review", "search", "latest", "show", "topics", "write", "reindex"] as const,
+    {
+      description: "The gnosis operation to run.",
+    },
+  ),
+  query: Type.Optional(
+    Type.String({
+      minLength: 1,
+      description: "Search query for action=search. Use uppercase OR/NOT for FTS operators.",
+    }),
+  ),
+  target: Type.Optional(
+    Type.String({ minLength: 1, description: "Entry ID prefix or topic for action=show." }),
+  ),
+  topics: Type.Optional(
+    Type.Array(Type.String({ minLength: 1 }), {
+      minItems: 1,
+      description: "Topics for action=write. Each normalized topic must be at least 7 chars.",
+    }),
+  ),
+  text: Type.Optional(
+    Type.String({ minLength: 1, description: "Knowledge text for action=write." }),
+  ),
+  related: Type.Optional(
+    Type.Array(Type.String({ minLength: 1 }), {
+      description: "Related entry IDs or unique prefixes for action=write.",
+    }),
+  ),
+  limit: Type.Optional(
+    Type.Integer({
+      minimum: 1,
+      description: "Positive result limit for action=search or action=latest.",
+    }),
+  ),
 });
 
 type GnosisParams = Static<typeof GnosisParams>;
 
 function positiveInteger(value: number | undefined, name: string): string | undefined {
-	if (value === undefined) return undefined;
-	if (!Number.isInteger(value) || value <= 0) throw new Error(`${name} must be a positive integer.`);
-	return String(value);
+  if (value === undefined) return undefined;
+  if (!Number.isInteger(value) || value <= 0)
+    throw new Error(`${name} must be a positive integer.`);
+  return String(value);
 }
 
 function requireString(value: string | undefined, name: string): string {
-	const trimmed = value?.trim();
-	if (!trimmed) throw new Error(`${name} is required.`);
-	return trimmed;
+  const trimmed = value?.trim();
+  if (!trimmed) throw new Error(`${name} is required.`);
+  return trimmed;
 }
 
 function buildGnosisArgs(params: GnosisParams): string[] {
-	switch (params.action) {
-		case "plan":
-			return ["help", "plan"];
-		case "review":
-			return ["help", "review"];
-		case "search": {
-			const args = ["search", requireString(params.query, "query")];
-			const limit = positiveInteger(params.limit, "limit");
-			if (limit) args.push("--limit", limit);
-			return args;
-		}
-		case "latest": {
-			const args = ["latest"];
-			const limit = positiveInteger(params.limit, "limit");
-			if (limit) args.push("--limit", limit);
-			return args;
-		}
-		case "show":
-			return ["show", requireString(params.target, "target")];
-		case "topics":
-			return ["topics"];
-		case "write": {
-			const topics = params.topics?.map((topic) => topic.trim()).filter(Boolean) ?? [];
-			if (topics.length === 0) throw new Error("topics is required for action=write.");
-			const args = ["write", topics.join(","), requireString(params.text, "text")];
-			const related = params.related?.map((id) => id.trim()).filter(Boolean) ?? [];
-			if (related.length > 0) args.push("--related", related.join(","));
-			return args;
-		}
-		case "reindex":
-			return ["reindex"];
-		default: {
-			const exhaustive: never = params.action;
-			throw new Error(`Unsupported gnosis action: ${exhaustive}`);
-		}
-	}
+  switch (params.action) {
+    case "plan":
+      return ["help", "plan"];
+    case "review":
+      return ["help", "review"];
+    case "search": {
+      const args = ["search", requireString(params.query, "query")];
+      const limit = positiveInteger(params.limit, "limit");
+      if (limit) args.push("--limit", limit);
+      return args;
+    }
+    case "latest": {
+      const args = ["latest"];
+      const limit = positiveInteger(params.limit, "limit");
+      if (limit) args.push("--limit", limit);
+      return args;
+    }
+    case "show":
+      return ["show", requireString(params.target, "target")];
+    case "topics":
+      return ["topics"];
+    case "write": {
+      const topics = params.topics?.map((topic) => topic.trim()).filter(Boolean) ?? [];
+      if (topics.length === 0) throw new Error("topics is required for action=write.");
+      const args = ["write", topics.join(","), requireString(params.text, "text")];
+      const related = params.related?.map((id) => id.trim()).filter(Boolean) ?? [];
+      if (related.length > 0) args.push("--related", related.join(","));
+      return args;
+    }
+    case "reindex":
+      return ["reindex"];
+    default: {
+      const exhaustive: never = params.action;
+      throw new Error(`Unsupported gnosis action: ${exhaustive}`);
+    }
+  }
 }
 
 function installHint(): string {
-	return [
-		"The `gn` CLI is required for the gnosis extension.",
-		"Install it with one of:",
-		"  brew install --cask skorokithakis/tap/gnosis",
-		"  go install github.com/skorokithakis/gnosis/cmd/gn@latest",
-	].join("\n");
+  return [
+    "The `gn` CLI is required for the gnosis extension.",
+    "Install it with one of:",
+    "  brew install --cask skorokithakis/tap/gnosis",
+    "  go install github.com/skorokithakis/gnosis/cmd/gn@latest",
+  ].join("\n");
+}
+
+function isEnoent(error: unknown): boolean {
+  return !!error && typeof error === "object" && (error as { code?: unknown }).code === "ENOENT";
+}
+
+function isMissingBinaryFailure(
+  error: unknown,
+  outputText = "",
+  exitCode?: number | null,
+): boolean {
+  if (exitCode === 127 || isEnoent(error)) return true;
+  const message = error instanceof Error ? error.message : error == null ? "" : String(error);
+  const text = `${message}\n${outputText}`;
+  return (
+    /\bENOENT\b/.test(text) ||
+    /command not found/i.test(text) ||
+    /not recognized as an internal or external command/i.test(text) ||
+    /(?:^|[\s:`])gn(?:\.exe)?:\s*not found\b/im.test(text)
+  );
 }
 
 function formatOutput(stdout: string, stderr: string): { text: string; truncated: boolean } {
-	const raw = [stdout, stderr].filter(Boolean).join(stderr && stdout ? "\n" : "").trimEnd();
-	if (!raw) return { text: "(no output)", truncated: false };
-
-	const truncation = truncateTail(raw, {
-		maxBytes: DEFAULT_MAX_BYTES,
-		maxLines: DEFAULT_MAX_LINES,
-	});
-
-	let text = truncation.content;
-	if (truncation.truncated) {
-		text += `\n\n[Output truncated: ${truncation.outputLines} of ${truncation.totalLines} lines`;
-		text += ` (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}).]`;
-	}
-	return { text, truncated: truncation.truncated };
+  const raw = [stdout, stderr]
+    .filter(Boolean)
+    .join(stderr && stdout ? "\n" : "")
+    .trimEnd();
+  if (!raw) return { text: "(no output)", truncated: false };
+
+  const truncation = truncateTail(raw, {
+    maxBytes: DEFAULT_MAX_BYTES,
+    maxLines: DEFAULT_MAX_LINES,
+  });
+
+  let text = truncation.content;
+  if (truncation.truncated) {
+    text += `\n\n[Output truncated: ${truncation.outputLines} of ${truncation.totalLines} lines`;
+    text += ` (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}).]`;
+  }
+  return { text, truncated: truncation.truncated };
 }
 
 export default function gnosisExtension(pi: ExtensionAPI) {
-	pi.registerTool({
-		name: "gnosis",
-		label: "Gnosis",
-		description:
-			"Search and record repo-local project knowledge using the `gn` CLI. Supports plan/review doctrine, search, latest, show, topics, write, and reindex. Does not support edit/rm; use shell only with explicit user intent for destructive gnosis maintenance.",
-		executionMode: "sequential" as ToolExecutionMode,
-		promptSnippet: "Search and record repo-local project knowledge through gnosis (`gn`).",
-		promptGuidelines: [
-			"Use the gnosis tool before implementing changes that may touch prior architecture, project decisions, rejected alternatives, or human constraints.",
-			"Use gnosis with action=\"search\" and uppercase OR between likely topic keywords, for example `auth OR token OR session`.",
-			"Use gnosis with action=\"write\" only for durable, non-obvious project knowledge that is not already captured in code, comments, docs, or the commit message.",
-			"Prefer code comments over gnosis with action=\"write\" when the knowledge has an obvious specific code anchor.",
-		],
-		parameters: GnosisParams,
-
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			const args = buildGnosisArgs(params);
-
-			let result: Awaited<ReturnType<typeof pi.exec>>;
-			try {
-				result = await pi.exec("gn", args, {
-					cwd: ctx.cwd,
-					signal,
-					timeout: GNOSIS_TIMEOUT_MS,
-				});
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				throw new Error(`${installHint()}\n\nExecution error: ${message}`);
-			}
-
-			const output = formatOutput(result.stdout ?? "", result.stderr ?? "");
-			if (result.killed) throw new Error(`gnosis ${params.action} timed out or was cancelled.\n\n${output.text}`);
-			if (result.code !== 0) {
-				throw new Error(`gnosis ${params.action} failed with exit code ${result.code}.\n\n${output.text}\n\n${installHint()}`);
-			}
-
-			return {
-				content: [{ type: "text", text: output.text }],
-				details: {
-					action: params.action,
-					args,
-					truncated: output.truncated,
-				},
-			};
-		},
-	});
+  pi.registerTool({
+    name: "gnosis",
+    label: "Gnosis",
+    description:
+      "Search and record repo-local project knowledge using the `gn` CLI. Supports plan/review doctrine, search, latest, show, topics, write, and reindex. Does not support edit/rm; use shell only with explicit user intent for destructive gnosis maintenance.",
+    executionMode: "sequential" as ToolExecutionMode,
+    promptSnippet: "Search and record repo-local project knowledge through gnosis (`gn`).",
+    promptGuidelines: [
+      "Use the gnosis tool before implementing changes that may touch prior architecture, project decisions, rejected alternatives, or human constraints.",
+      'Use gnosis with action="search" and uppercase OR between likely topic keywords, for example `auth OR token OR session`.',
+      'Use gnosis with action="write" only for durable, non-obvious project knowledge that is not already captured in code, comments, docs, or the commit message.',
+      'Prefer code comments over gnosis with action="write" when the knowledge has an obvious specific code anchor.',
+    ],
+    parameters: GnosisParams,
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const args = buildGnosisArgs(params);
+
+      let result: Awaited<ReturnType<typeof pi.exec>>;
+      try {
+        result = await pi.exec("gn", args, {
+          cwd: ctx.cwd,
+          signal,
+          timeout: GNOSIS_TIMEOUT_MS,
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const hint = isMissingBinaryFailure(error) ? `${installHint()}\n\n` : "";
+        throw new Error(`${hint}Execution error: ${message}`);
+      }
+
+      const output = formatOutput(result.stdout ?? "", result.stderr ?? "");
+      if (result.killed)
+        throw new Error(`gnosis ${params.action} timed out or was cancelled.\n\n${output.text}`);
+      if (result.code !== 0) {
+        const hint = isMissingBinaryFailure(undefined, output.text, result.code)
+          ? `\n\n${installHint()}`
+          : "";
+        throw new Error(
+          `gnosis ${params.action} failed with exit code ${result.code}.\n\n${output.text}${hint}`,
+        );
+      }
+
+      return {
+        content: [{ type: "text", text: output.text }],
+        details: {
+          action: params.action,
+          args,
+          truncated: output.truncated,
+        },
+      };
+    },
+  });
 }

package/extensions/gnosis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-gnosis",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "A pi extension that exposes the gnosis repo-local knowledge base CLI as an agent tool.",
   "keywords": [
     "pi-package",

package/extensions/inline-bash/index.ts

@@ -1,107 +1,91 @@
-/**
- * Inline Bash Extension - expands inline bash commands in user prompts.
- *
- * Start pi with this extension:
- *   pi -e ./examples/extensions/inline-bash.ts
- *
- * Then type prompts with inline bash:
- *   What's in !{pwd}?
- *   The current branch is !{git branch --show-current} and status: !{git status --short}
- *   My node version is !{node --version}
- *
- * The !{command} patterns are executed and replaced with their trimmed output
- * before the prompt is sent to the agent. Very large expansions are truncated.
- *
- * Note: Regular !command syntax (whole-line bash) is preserved and works as before.
- */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 export default function (pi: ExtensionAPI) {
-	const PATTERN = /!\{([^}]+)\}/g;
-	const TIMEOUT_MS = 30000;
-	const MAX_OUTPUT_CHARS = 50000;
-
-	const trimAndLimit = (output: string) => {
-		const trimmed = output.trim();
-		if (trimmed.length <= MAX_OUTPUT_CHARS) return trimmed;
-		return `${trimmed.slice(0, MAX_OUTPUT_CHARS)}\n[inline-bash output truncated after ${MAX_OUTPUT_CHARS} characters]`;
-	};
-
-	pi.on("input", async (event, ctx) => {
-		const text = event.text;
-
-		// Only expand prompts supplied by the user/client. Extension-injected follow-ups
-		// should not get an implicit path to local shell execution.
-		if (event.source === "extension") {
-			return { action: "continue" };
-		}
-
-		// Don't process if it's a whole-line bash command (starts with !)
-		// This preserves the existing !command behavior
-		if (text.trimStart().startsWith("!") && !text.trimStart().startsWith("!{")) {
-			return { action: "continue" };
-		}
-
-		// Check if there are any inline bash patterns
-		if (!PATTERN.test(text)) {
-			return { action: "continue" };
-		}
-
-		// Reset regex state after test()
-		PATTERN.lastIndex = 0;
-
-		let result = text;
-		const expansions: Array<{ command: string; output: string; error?: string }> = [];
-
-		// Find all matches first (to avoid issues with replacing while iterating)
-		const matches: Array<{ full: string; command: string }> = [];
-		let match = PATTERN.exec(text);
-		while (match) {
-			matches.push({ full: match[0], command: match[1] });
-			match = PATTERN.exec(text);
-		}
-
-		// Execute each command and collect results
-		for (const { full, command } of matches) {
-			try {
-				const bashResult = await pi.exec("bash", ["-c", command], {
-					timeout: TIMEOUT_MS,
-				});
-
-				const output = bashResult.stdout || bashResult.stderr || "";
-				const trimmed = trimAndLimit(output);
-
-				if (bashResult.code !== 0 && bashResult.stderr) {
-					expansions.push({
-						command,
-						output: trimmed,
-						error: `exit code ${bashResult.code}`,
-					});
-				} else {
-					expansions.push({ command, output: trimmed });
-				}
-
-				result = result.replace(full, trimmed);
-			} catch (err) {
-				const errorMsg = err instanceof Error ? err.message : String(err);
-				expansions.push({ command, output: "", error: errorMsg });
-				result = result.replace(full, `[error: ${errorMsg}]`);
-			}
-		}
-
-		// Show what was expanded (if UI available)
-		if (ctx.hasUI && expansions.length > 0) {
-			const summary = expansions
-				.map((e) => {
-					const status = e.error ? ` (${e.error})` : "";
-					const preview = e.output.length > 50 ? `${e.output.slice(0, 50)}...` : e.output;
-					return `!{${e.command}}${status} -> "${preview}"`;
-				})
-				.join("\n");
-
-			ctx.ui.notify(`Expanded ${expansions.length} inline command(s):\n${summary}`, "info");
-		}
-
-		return { action: "transform", text: result, images: event.images };
-	});
+  const PATTERN = /!\{([^}]+)\}/g;
+  const TIMEOUT_MS = 30000;
+  const MAX_OUTPUT_CHARS = 50000;
+
+  const trimAndLimit = (output: string) => {
+    const trimmed = output.trim();
+    if (trimmed.length <= MAX_OUTPUT_CHARS) return trimmed;
+    return `${trimmed.slice(0, MAX_OUTPUT_CHARS)}\n[inline-bash output truncated after ${MAX_OUTPUT_CHARS} characters]`;
+  };
+
+  pi.on("input", async (event, ctx) => {
+    const text = event.text;
+
+    // Only expand prompts supplied by the user/client. Extension-injected follow-ups
+    // should not get an implicit path to local shell execution.
+    if (event.source === "extension") {
+      return { action: "continue" };
+    }
+
+    if (text.trimStart().startsWith("!") && !text.trimStart().startsWith("!{")) {
+      return { action: "continue" };
+    }
+
+    PATTERN.lastIndex = 0;
+    const matches: Array<{ start: number; end: number; command: string }> = [];
+    let match = PATTERN.exec(text);
+    while (match) {
+      matches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        command: match[1],
+      });
+      match = PATTERN.exec(text);
+    }
+    if (matches.length === 0) {
+      return { action: "continue" };
+    }
+
+    const parts: string[] = [];
+    let cursor = 0;
+    const expansions: Array<{ command: string; output: string; error?: string }> = [];
+
+    for (const { start, end, command } of matches) {
+      parts.push(text.slice(cursor, start));
+      cursor = end;
+      try {
+        const bashResult = await pi.exec("bash", ["-c", command], {
+          timeout: TIMEOUT_MS,
+        });
+
+        const output = bashResult.stdout || bashResult.stderr || "";
+        const trimmed = trimAndLimit(output);
+
+        if (bashResult.code !== 0 && bashResult.stderr) {
+          expansions.push({
+            command,
+            output: trimmed,
+            error: `exit code ${bashResult.code}`,
+          });
+        } else {
+          expansions.push({ command, output: trimmed });
+        }
+
+        parts.push(trimmed);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        expansions.push({ command, output: "", error: errorMsg });
+        parts.push(`[error: ${errorMsg}]`);
+      }
+    }
+    parts.push(text.slice(cursor));
+    const result = parts.join("");
+
+    if (ctx.hasUI && expansions.length > 0) {
+      const summary = expansions
+        .map((e) => {
+          const status = e.error ? ` (${e.error})` : "";
+          const preview = e.output.length > 50 ? `${e.output.slice(0, 50)}...` : e.output;
+          return `!{${e.command}}${status} -> "${preview}"`;
+        })
+        .join("\n");
+
+      ctx.ui.notify(`Expanded ${expansions.length} inline command(s):\n${summary}`, "info");
+    }
+
+    return { action: "transform", text: result, images: event.images };
+  });
 }

package/extensions/inline-bash/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-inline-bash",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "A pi extension that expands inline bash commands in user prompts.",
   "keywords": [
     "pi-package",

package/extensions/librarian/README.md

@@ -35,7 +35,7 @@ Then reload pi:
 ## Behavior
 
 - Tool name: `librarian`
-- Uses a restricted subagent with `bash` and `read`
+- Uses a restricted subagent with `bash`, `read`, and any configured MCP tools (MCP tools run without confirmation; may have side effects; use for evidence gathering only; requires host Pi >=1.0.4; older hosts degrade to no MCP, no error); the global `mcp.json` always applies; a project `.pi/mcp.json` is never loaded (the librarian subagent runs in a separate temp workspace)
 - Uses `gh` for GitHub search/API access
 - Uses cached local checkouts only when enabled
 - Toggle cache behavior for future calls with `/librarian-cache on | off | toggle | status`