pi-agent-toolkit 0.1.0

package/dist/dotfiles/extensions/question-mode.ts

@@ -0,0 +1,242 @@
+import type { ExtensionAPI, ExtensionContext, ToolCallEventResult } from "@mariozechner/pi-coding-agent";
+import { Key } from "@mariozechner/pi-tui";
+
+const QUESTION_MODE_TOOLS = ["read", "grep", "find", "ls", "mcp", "exa_search"] as const;
+const FALLBACK_TOOLS = ["read", "bash", "edit", "write"] as const;
+
+interface QuestionModeState {
+	enabled: boolean;
+	restoreTools: string[];
+}
+
+function normalizeTools(input: unknown): string[] {
+	if (!Array.isArray(input)) return [];
+	return input.filter((value): value is string => typeof value === "string" && value.trim().length > 0);
+}
+
+export default function questionModeExtension(pi: ExtensionAPI): void {
+	let enabled = false;
+	let restoreTools: string[] = [];
+
+	function getAvailableToolNames(): Set<string> {
+		return new Set(pi.getAllTools().map((tool) => tool.name));
+	}
+
+	function filterAvailableTools(tools: readonly string[]): string[] {
+		const available = getAvailableToolNames();
+		return tools.filter((tool) => available.has(tool));
+	}
+
+	function getQuestionModeTools(): string[] {
+		const preferred = filterAvailableTools(QUESTION_MODE_TOOLS);
+		if (preferred.length > 0) return preferred;
+
+		const current = pi.getActiveTools();
+		if (current.length > 0) return current;
+
+		return filterAvailableTools(FALLBACK_TOOLS);
+	}
+
+	function getRestoreTools(): string[] {
+		const candidate = restoreTools.length > 0 ? restoreTools : Array.from(FALLBACK_TOOLS);
+		const filtered = filterAvailableTools(candidate);
+
+		if (filtered.length > 0) return filtered;
+
+		const current = pi.getActiveTools();
+		return current.length > 0 ? current : ["read"];
+	}
+
+	function applyQuestionModeTools(): string[] {
+		const tools = getQuestionModeTools();
+		if (tools.length > 0) {
+			pi.setActiveTools(tools);
+		}
+		return tools;
+	}
+
+	function applyRestoreTools(): string[] {
+		const tools = getRestoreTools();
+		if (tools.length > 0) {
+			pi.setActiveTools(tools);
+		}
+		return tools;
+	}
+
+	function updateStatus(ctx: ExtensionContext): void {
+		if (enabled) {
+			ctx.ui.setStatus("question-mode", "question-mode:on");
+		} else {
+			ctx.ui.setStatus("question-mode", undefined);
+		}
+	}
+
+	function persistState(): void {
+		pi.appendEntry<QuestionModeState>("question-mode-state", {
+			enabled,
+			restoreTools,
+		});
+	}
+
+	function restoreFromBranch(ctx: ExtensionContext): void {
+		const branchEntries = ctx.sessionManager.getBranch();
+		let state: QuestionModeState | undefined;
+
+		for (const entry of branchEntries) {
+			if (entry.type === "custom" && entry.customType === "question-mode-state") {
+				const data = entry.data as QuestionModeState | undefined;
+				if (data) {
+					state = {
+						enabled: Boolean(data.enabled),
+						restoreTools: normalizeTools(data.restoreTools),
+					};
+				}
+			}
+		}
+
+		if (!state) {
+			enabled = false;
+			restoreTools = [];
+			updateStatus(ctx);
+			return;
+		}
+
+		enabled = state.enabled;
+		restoreTools = state.restoreTools;
+
+		if (enabled) {
+			applyQuestionModeTools();
+		}
+
+		updateStatus(ctx);
+	}
+
+	function getStatusSummary(): string {
+		const mode = enabled ? "on" : "off";
+		const tools = pi.getActiveTools();
+		return `question-mode:${mode} | active tools: ${tools.join(", ")}`;
+	}
+
+	function enableQuestionMode(ctx: ExtensionContext): void {
+		if (enabled) {
+			ctx.ui.notify("Question mode is already enabled.", "info");
+			return;
+		}
+
+		restoreTools = pi.getActiveTools();
+		enabled = true;
+		const tools = applyQuestionModeTools();
+		persistState();
+		updateStatus(ctx);
+		ctx.ui.notify(`Question mode enabled. Tools: ${tools.join(", ")}`, "info");
+	}
+
+	function disableQuestionMode(ctx: ExtensionContext): void {
+		if (!enabled) {
+			ctx.ui.notify("Question mode is already disabled.", "info");
+			return;
+		}
+
+		enabled = false;
+		const restored = applyRestoreTools();
+		persistState();
+		updateStatus(ctx);
+		ctx.ui.notify(`Question mode disabled. Restored tools: ${restored.join(", ")}`, "info");
+	}
+
+	pi.registerShortcut(Key.ctrl("q"), {
+		description: "Toggle question mode",
+		handler: (ctx) => {
+			if (enabled) {
+				disableQuestionMode(ctx);
+			} else {
+				enableQuestionMode(ctx);
+			}
+		},
+	});
+
+	pi.registerCommand("question-mode", {
+		description: "Toggle strict read-only Q&A mode (no edits, no bash)",
+		handler: async (args, ctx) => {
+			const action = args.trim().toLowerCase();
+
+			if (action === "status") {
+				ctx.ui.notify(getStatusSummary(), "info");
+				return;
+			}
+
+			if (action === "on" || action === "enable") {
+				enableQuestionMode(ctx);
+				return;
+			}
+
+			if (action === "off" || action === "disable") {
+				disableQuestionMode(ctx);
+				return;
+			}
+
+			if (action === "" || action === "toggle") {
+				if (enabled) {
+					disableQuestionMode(ctx);
+				} else {
+					enableQuestionMode(ctx);
+				}
+				return;
+			}
+
+			ctx.ui.notify("Usage: /question-mode [on|off|toggle|status]", "warning");
+		},
+	});
+
+	pi.on("tool_call", async (event): Promise<ToolCallEventResult | undefined> => {
+		if (!enabled) return undefined;
+
+		if (event.toolName === "edit" || event.toolName === "write") {
+			return {
+				block: true,
+				reason: "Question mode blocks file modifications. Disable with /question-mode off to make changes.",
+			};
+		}
+
+		if (event.toolName === "bash") {
+			return {
+				block: true,
+				reason: "Question mode blocks bash to keep exploration read-only.",
+			};
+		}
+
+		return undefined;
+	});
+
+	pi.on("before_agent_start", async () => {
+		if (!enabled) return undefined;
+
+		return {
+			message: {
+				customType: "question-mode-context",
+				content: `[QUESTION MODE ACTIVE]\nYou are answering a user question in strict read-only mode.\n\nRules:\n- Focus on explanation and analysis.\n- Do not edit or create files.\n- Do not run shell commands that modify files, install dependencies, or change git state.\n- Use only available read-only tools to gather evidence.\n- For codebase discovery, audits, and cross-referencing, prefer augment_context_engine over exhaustive ls/Read traversals.\n- If code changes would help, describe them as a follow-up and ask for confirmation first.`,
+				display: false,
+			},
+		};
+	});
+
+	pi.on("turn_start", async (_event, ctx) => {
+		if (!enabled) return;
+
+		applyQuestionModeTools();
+		updateStatus(ctx);
+		persistState();
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		restoreFromBranch(ctx);
+	});
+
+	pi.on("session_tree", async (_event, ctx) => {
+		restoreFromBranch(ctx);
+	});
+
+	pi.on("session_fork", async (_event, ctx) => {
+		restoreFromBranch(ctx);
+	});
+}

package/dist/dotfiles/extensions/require-session-name-on-exit.ts

@@ -0,0 +1,141 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+function normalizeName(name: string | undefined | null): string {
+  return (name ?? "").trim();
+}
+
+function getDefaultNameFromFirstUserMessage(ctx: any): string {
+  const branch = ctx.sessionManager.getBranch();
+
+  for (const entry of branch) {
+    if (entry?.type !== "message") continue;
+    if (entry?.message?.role !== "user") continue;
+
+    const content = entry.message.content;
+    if (typeof content === "string") {
+      const value = content.replace(/\s+/g, " ").trim();
+      if (value) return value;
+      continue;
+    }
+
+    if (Array.isArray(content)) {
+      const textPart = content.find((part: any) => part?.type === "text" && typeof part?.text === "string");
+      const value = (textPart?.text ?? "").replace(/\s+/g, " ").trim();
+      if (value) return value;
+    }
+  }
+
+  return "work session";
+}
+
+function getEasternTimestamp(): string {
+  const now = new Date();
+  const date = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "America/New_York",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(now);
+  const y = date.find(p => p.type === "year")!.value;
+  const m = date.find(p => p.type === "month")!.value;
+  const d = date.find(p => p.type === "day")!.value;
+
+  const time = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/New_York",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+  }).format(now);
+  const compact = time.replace(/\s/g, "");
+
+  return `${y}-${m}-${d} ${compact}`;
+}
+
+function isShutdownFromReload(): boolean {
+  const stack = new Error().stack ?? "";
+  return stack.includes("AgentSession.reload") || stack.includes("handleReloadCommand");
+}
+
+async function ensureSessionNameAndConfirmExit(pi: ExtensionAPI, ctx: any): Promise<boolean> {
+  if (!ctx.hasUI) return false;
+
+  const current = normalizeName(pi.getSessionName());
+  if (current) {
+    const confirmed = await ctx.ui.confirm("Exit session?", `Session: ${current}\n\nDo you want to exit pi now?`);
+    if (!confirmed) {
+      ctx.ui.notify("Exit canceled", "info");
+      return false;
+    }
+    return true;
+  }
+
+  const suggested = getDefaultNameFromFirstUserMessage(ctx);
+  const input = await ctx.ui.input("Session name required before exit", suggested);
+  const name = normalizeName(input);
+
+  if (!name) {
+    const fallback = `${getEasternTimestamp()} ${suggested}`;
+    pi.setSessionName(fallback);
+    ctx.ui.notify(`Auto-named: ${fallback}`, "info");
+    return true;
+  }
+
+  pi.setSessionName(name);
+  ctx.ui.notify(`Session named: ${name}`, "info");
+  return true;
+}
+
+export default function (pi: ExtensionAPI) {
+  const guardedExit = async (ctx: any) => {
+    const ok = await ensureSessionNameAndConfirmExit(pi, ctx);
+    if (!ok) return;
+    ctx.shutdown();
+  };
+
+  // Built-in /quit and /exit cannot be overridden by extensions.
+  // Provide guarded alternatives.
+  pi.registerCommand("safe-quit", {
+    description: "Exit pi with guardrails (requires session name, confirms if already named)",
+    handler: async (_args, ctx) => {
+      await guardedExit(ctx);
+    },
+  });
+
+  pi.registerCommand("q", {
+    description: "Alias for /safe-quit",
+    handler: async (_args, ctx) => {
+      await guardedExit(ctx);
+    },
+  });
+
+  pi.registerShortcut("ctrl+shift+q", {
+    description: "Safe exit with session-name enforcement",
+    handler: async (ctx) => {
+      await guardedExit(ctx);
+    },
+  });
+
+  // Catch built-in /quit (which cannot be overridden by extension commands).
+  // Note: session_shutdown also fires on /reload, so we skip prompts in that path.
+  pi.on("session_shutdown", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+    if (isShutdownFromReload()) return;
+
+    const current = normalizeName(pi.getSessionName());
+    if (current) return;
+
+    const suggested = getDefaultNameFromFirstUserMessage(ctx);
+    const input = await ctx.ui.input("Session is closing. Enter a name to save it", suggested);
+    const name = normalizeName(input);
+
+    if (!name) {
+      const fallback = `${getEasternTimestamp()} ${suggested}`;
+      pi.setSessionName(fallback);
+      ctx.ui.notify(`Auto-named: ${fallback}`, "info");
+      return;
+    }
+
+    pi.setSessionName(name);
+    ctx.ui.notify(`Session named: ${name}`, "info");
+  });
+}