xtrm-tools 0.5.10 → 0.5.13

package/config/pi/extensions/bg-process/package.json

@@ -1,16 +0,0 @@
-{
-  "name": "@xtrm/pi-bg-process",
-  "version": "1.0.0",
-  "description": "xtrm Pi extension: bg-process",
-  "type": "module",
-  "exports": {
-    ".": "./index.ts"
-  },
-  "keywords": [
-    "pi",
-    "extension",
-    "xtrm"
-  ],
-  "author": "xtrm",
-  "license": "MIT"
-}

package/config/pi/extensions/minimal-mode/index.ts

@@ -1,201 +0,0 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import {
-	createBashTool,
-	createEditTool,
-	createFindTool,
-	createGrepTool,
-	createLsTool,
-	createReadTool,
-	createWriteTool,
-} from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
-
-function getTextContent(result: any): string {
-	if (!result?.content || !Array.isArray(result.content)) return "";
-	return result.content
-		.filter((c: any) => c?.type === "text" && typeof c.text === "string")
-		.map((c: any) => c.text)
-		.join("\n")
-		.trim();
-}
-
-function oneLine(s: string): string {
-	return (s || "").replace(/\s+/g, " ").trim();
-}
-
-function summarize(result: any): { text: string; isError: boolean } {
-	const raw = getTextContent(result);
-	if (!raw) return { text: "done", isError: false };
-	const line = oneLine(raw.split("\n").find((l) => l.trim()) || "");
-	const lower = line.toLowerCase();
-	const isError = lower.includes("error") || lower.includes("failed") || lower.includes("exception");
-	return { text: line.slice(0, 140) || "done", isError };
-}
-
-const toolCache = new Map<string, ReturnType<typeof createBuiltInTools>>();
-function createBuiltInTools(cwd: string) {
-	return {
-		read: createReadTool(cwd),
-		bash: createBashTool(cwd),
-		edit: createEditTool(cwd),
-		write: createWriteTool(cwd),
-		find: createFindTool(cwd),
-		grep: createGrepTool(cwd),
-		ls: createLsTool(cwd),
-	};
-}
-function getBuiltInTools(cwd: string) {
-	let tools = toolCache.get(cwd);
-	if (!tools) {
-		tools = createBuiltInTools(cwd);
-		toolCache.set(cwd, tools);
-	}
-	return tools;
-}
-
-export default function (pi: ExtensionAPI) {
-	let minimalEnabled = true;
-	let thinkingStatusEnabled = true;
-	let spinnerTimer: NodeJS.Timeout | null = null;
-	let spinnerIndex = 0;
-	const frames = ["thinking   ", "thinking.  ", "thinking.. ", "thinking..."];
-
-	const clearSpinner = (ctx: any) => {
-		if (spinnerTimer) {
-			clearInterval(spinnerTimer);
-			spinnerTimer = null;
-		}
-		if (ctx?.hasUI) {
-			ctx.ui.setStatus("thinking", undefined);
-			ctx.ui.setHeader(undefined);
-		}
-	};
-
-	const mountThinkingHeader = (ctx: any) => {
-		if (!ctx?.hasUI) return;
-		ctx.ui.setHeader((_tui: any, theme: any) => ({
-			invalidate() {},
-			render(width: number): string[] {
-				const text = frames[spinnerIndex];
-				return [oneLine(theme.fg("accent", text)).slice(0, width)];
-			},
-		}));
-	};
-
-	const startSpinner = (ctx: any) => {
-		if (!thinkingStatusEnabled || !ctx?.hasUI) return;
-		clearSpinner(ctx);
-		spinnerIndex = 0;
-		ctx.ui.setStatus("thinking", frames[spinnerIndex]);
-		mountThinkingHeader(ctx);
-		spinnerTimer = setInterval(() => {
-			spinnerIndex = (spinnerIndex + 1) % frames.length;
-			ctx.ui.setStatus("thinking", frames[spinnerIndex]);
-			mountThinkingHeader(ctx);
-		}, 220);
-	};
-
-	const renderCollapsedResult = (result: any, theme: any) => {
-		const s = summarize(result);
-		const icon = s.isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
-		const text = s.isError ? theme.fg("error", s.text) : theme.fg("muted", s.text);
-		if (minimalEnabled) return new Text(` ${icon} ${text}`, 0, 0);
-		return new Text(theme.fg("muted", ` → ${s.text}`), 0, 0);
-	};
-
-	const renderExpandedResult = (result: any, theme: any) => {
-		const text = getTextContent(result);
-		if (!text) return new Text("", 0, 0);
-		const output = text.split("\n").map((line) => theme.fg("toolOutput", line)).join("\n");
-		return new Text(`\n${output}`, 0, 0);
-	};
-
-	pi.registerTool({
-		name: "bash",
-		label: "bash",
-		description: getBuiltInTools(process.cwd()).bash.description,
-		parameters: getBuiltInTools(process.cwd()).bash.parameters,
-		async execute(toolCallId, params, signal, onUpdate, ctx) {
-			return getBuiltInTools(ctx.cwd).bash.execute(toolCallId, params, signal, onUpdate);
-		},
-		renderCall(args, theme) {
-			const cmd = oneLine(args.command || "");
-			return new Text(`${theme.fg("toolTitle", theme.bold("bash"))}(${theme.fg("accent", cmd || "...")})`, 0, 0);
-		},
-		renderResult(result, { expanded }, theme) {
-			return expanded ? renderExpandedResult(result, theme) : renderCollapsedResult(result, theme);
-		},
-	});
-
-	for (const name of ["read", "write", "edit", "find", "grep", "ls"] as const) {
-		pi.registerTool({
-			name,
-			label: name,
-			description: (getBuiltInTools(process.cwd()) as any)[name].description,
-			parameters: (getBuiltInTools(process.cwd()) as any)[name].parameters,
-			async execute(toolCallId, params, signal, onUpdate, ctx) {
-				return (getBuiltInTools(ctx.cwd) as any)[name].execute(toolCallId, params, signal, onUpdate);
-			},
-			renderCall(args, theme) {
-				const suffix = oneLine(args.path || args.pattern || "");
-				return new Text(`${theme.fg("toolTitle", theme.bold(name))}${suffix ? `(${theme.fg("accent", suffix)})` : ""}`, 0, 0);
-			},
-			renderResult(result, { expanded }, theme) {
-				return expanded ? renderExpandedResult(result, theme) : renderCollapsedResult(result, theme);
-			},
-		});
-	}
-
-	pi.registerCommand("minimal-on", {
-		description: "Enable minimal collapsed tool output",
-		handler: async (_args, ctx) => {
-			minimalEnabled = true;
-			ctx.ui.notify("Minimal mode enabled", "info");
-		},
-	});
-
-	pi.registerCommand("minimal-off", {
-		description: "Disable minimal collapsed tool output",
-		handler: async (_args, ctx) => {
-			minimalEnabled = false;
-			ctx.ui.notify("Minimal mode disabled", "info");
-		},
-	});
-
-	pi.registerCommand("minimal-toggle", {
-		description: "Toggle minimal collapsed tool output",
-		handler: async (_args, ctx) => {
-			minimalEnabled = !minimalEnabled;
-			ctx.ui.notify(`Minimal mode ${minimalEnabled ? "enabled" : "disabled"}`, "info");
-		},
-	});
-
-	pi.registerCommand("thinking-status-toggle", {
-		description: "Toggle flashing thinking status indicator",
-		handler: async (_args, ctx) => {
-			thinkingStatusEnabled = !thinkingStatusEnabled;
-			if (!thinkingStatusEnabled) clearSpinner(ctx);
-			ctx.ui.notify(`Thinking status ${thinkingStatusEnabled ? "enabled" : "disabled"}`, "info");
-		},
-	});
-
-	pi.on("turn_start", async (_event, ctx) => {
-		startSpinner(ctx);
-		return undefined;
-	});
-
-	pi.on("turn_end", async (_event, ctx) => {
-		clearSpinner(ctx);
-		return undefined;
-	});
-
-	pi.on("agent_end", async (_event, ctx) => {
-		clearSpinner(ctx);
-		return undefined;
-	});
-
-	pi.on("session_shutdown", async (_event, ctx) => {
-		clearSpinner(ctx);
-		return undefined;
-	});
-}

package/config/pi/extensions/minimal-mode/package.json

@@ -1,16 +0,0 @@
-{
-  "name": "@xtrm/pi-minimal-mode",
-  "version": "1.0.0",
-  "description": "xtrm Pi extension: minimal-mode",
-  "type": "module",
-  "exports": {
-    ".": "./index.ts"
-  },
-  "keywords": [
-    "pi",
-    "extension",
-    "xtrm"
-  ],
-  "author": "xtrm",
-  "license": "MIT"
-}

package/config/pi/extensions/todo/index.ts

@@ -1,299 +0,0 @@
-/**
- * Todo Extension - Demonstrates state management via session entries
- *
- * This extension:
- * - Registers a `todo` tool for the LLM to manage todos
- * - Registers a `/todos` command for users to view the list
- *
- * State is stored in tool result details (not external files), which allows
- * proper branching - when you branch, the todo state is automatically
- * correct for that point in history.
- */
-
-import { StringEnum } from "@mariozechner/pi-ai";
-import type { ExtensionAPI, ExtensionContext, Theme } from "@mariozechner/pi-coding-agent";
-import { matchesKey, Text, truncateToWidth } from "@mariozechner/pi-tui";
-import { Type } from "@sinclair/typebox";
-
-interface Todo {
-	id: number;
-	text: string;
-	done: boolean;
-}
-
-interface TodoDetails {
-	action: "list" | "add" | "toggle" | "clear";
-	todos: Todo[];
-	nextId: number;
-	error?: string;
-}
-
-const TodoParams = Type.Object({
-	action: StringEnum(["list", "add", "toggle", "clear"] as const),
-	text: Type.Optional(Type.String({ description: "Todo text (for add)" })),
-	id: Type.Optional(Type.Number({ description: "Todo ID (for toggle)" })),
-});
-
-/**
- * UI component for the /todos command
- */
-class TodoListComponent {
-	private todos: Todo[];
-	private theme: Theme;
-	private onClose: () => void;
-	private cachedWidth?: number;
-	private cachedLines?: string[];
-
-	constructor(todos: Todo[], theme: Theme, onClose: () => void) {
-		this.todos = todos;
-		this.theme = theme;
-		this.onClose = onClose;
-	}
-
-	handleInput(data: string): void {
-		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
-			this.onClose();
-		}
-	}
-
-	render(width: number): string[] {
-		if (this.cachedLines && this.cachedWidth === width) {
-			return this.cachedLines;
-		}
-
-		const lines: string[] = [];
-		const th = this.theme;
-
-		lines.push("");
-		const title = th.fg("accent", " Todos ");
-		const headerLine =
-			th.fg("borderMuted", "─".repeat(3)) + title + th.fg("borderMuted", "─".repeat(Math.max(0, width - 10)));
-		lines.push(truncateToWidth(headerLine, width));
-		lines.push("");
-
-		if (this.todos.length === 0) {
-			lines.push(truncateToWidth(`  ${th.fg("dim", "No todos yet. Ask the agent to add some!")}`, width));
-		} else {
-			const done = this.todos.filter((t) => t.done).length;
-			const total = this.todos.length;
-			lines.push(truncateToWidth(`  ${th.fg("muted", `${done}/${total} completed`)}`, width));
-			lines.push("");
-
-			for (const todo of this.todos) {
-				const check = todo.done ? th.fg("success", "✓") : th.fg("dim", "○");
-				const id = th.fg("accent", `#${todo.id}`);
-				const text = todo.done ? th.fg("dim", todo.text) : th.fg("text", todo.text);
-				lines.push(truncateToWidth(`  ${check} ${id} ${text}`, width));
-			}
-		}
-
-		lines.push("");
-		lines.push(truncateToWidth(`  ${th.fg("dim", "Press Escape to close")}`, width));
-		lines.push("");
-
-		this.cachedWidth = width;
-		this.cachedLines = lines;
-		return lines;
-	}
-
-	invalidate(): void {
-		this.cachedWidth = undefined;
-		this.cachedLines = undefined;
-	}
-}
-
-export default function (pi: ExtensionAPI) {
-	// In-memory state (reconstructed from session on load)
-	let todos: Todo[] = [];
-	let nextId = 1;
-
-	/**
-	 * Reconstruct state from session entries.
-	 * Scans tool results for this tool and applies them in order.
-	 */
-	const reconstructState = (ctx: ExtensionContext) => {
-		todos = [];
-		nextId = 1;
-
-		for (const entry of ctx.sessionManager.getBranch()) {
-			if (entry.type !== "message") continue;
-			const msg = entry.message;
-			if (msg.role !== "toolResult" || msg.toolName !== "todo") continue;
-
-			const details = msg.details as TodoDetails | undefined;
-			if (details) {
-				todos = details.todos;
-				nextId = details.nextId;
-			}
-		}
-	};
-
-	// Reconstruct state on session events
-	pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
-	pi.on("session_switch", async (_event, ctx) => reconstructState(ctx));
-	pi.on("session_fork", async (_event, ctx) => reconstructState(ctx));
-	pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
-
-	// Register the todo tool for the LLM
-	pi.registerTool({
-		name: "todo",
-		label: "Todo",
-		description: "Manage a todo list. Actions: list, add (text), toggle (id), clear",
-		parameters: TodoParams,
-
-		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-			switch (params.action) {
-				case "list":
-					return {
-						content: [
-							{
-								type: "text",
-								text: todos.length
-									? todos.map((t) => `[${t.done ? "x" : " "}] #${t.id}: ${t.text}`).join("\n")
-									: "No todos",
-							},
-						],
-						details: { action: "list", todos: [...todos], nextId } as TodoDetails,
-					};
-
-				case "add": {
-					if (!params.text) {
-						return {
-							content: [{ type: "text", text: "Error: text required for add" }],
-							details: { action: "add", todos: [...todos], nextId, error: "text required" } as TodoDetails,
-						};
-					}
-					const newTodo: Todo = { id: nextId++, text: params.text, done: false };
-					todos.push(newTodo);
-					return {
-						content: [{ type: "text", text: `Added todo #${newTodo.id}: ${newTodo.text}` }],
-						details: { action: "add", todos: [...todos], nextId } as TodoDetails,
-					};
-				}
-
-				case "toggle": {
-					if (params.id === undefined) {
-						return {
-							content: [{ type: "text", text: "Error: id required for toggle" }],
-							details: { action: "toggle", todos: [...todos], nextId, error: "id required" } as TodoDetails,
-						};
-					}
-					const todo = todos.find((t) => t.id === params.id);
-					if (!todo) {
-						return {
-							content: [{ type: "text", text: `Todo #${params.id} not found` }],
-							details: {
-								action: "toggle",
-								todos: [...todos],
-								nextId,
-								error: `#${params.id} not found`,
-							} as TodoDetails,
-						};
-					}
-					todo.done = !todo.done;
-					return {
-						content: [{ type: "text", text: `Todo #${todo.id} ${todo.done ? "completed" : "uncompleted"}` }],
-						details: { action: "toggle", todos: [...todos], nextId } as TodoDetails,
-					};
-				}
-
-				case "clear": {
-					const count = todos.length;
-					todos = [];
-					nextId = 1;
-					return {
-						content: [{ type: "text", text: `Cleared ${count} todos` }],
-						details: { action: "clear", todos: [], nextId: 1 } as TodoDetails,
-					};
-				}
-
-				default:
-					return {
-						content: [{ type: "text", text: `Unknown action: ${params.action}` }],
-						details: {
-							action: "list",
-							todos: [...todos],
-							nextId,
-							error: `unknown action: ${params.action}`,
-						} as TodoDetails,
-					};
-			}
-		},
-
-		renderCall(args, theme) {
-			let text = theme.fg("toolTitle", theme.bold("todo ")) + theme.fg("muted", args.action);
-			if (args.text) text += ` ${theme.fg("dim", `"${args.text}"`)}`;
-			if (args.id !== undefined) text += ` ${theme.fg("accent", `#${args.id}`)}`;
-			return new Text(text, 0, 0);
-		},
-
-		renderResult(result, { expanded }, theme) {
-			const details = result.details as TodoDetails | undefined;
-			if (!details) {
-				const text = result.content[0];
-				return new Text(text?.type === "text" ? text.text : "", 0, 0);
-			}
-
-			if (details.error) {
-				return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
-			}
-
-			const todoList = details.todos;
-
-			switch (details.action) {
-				case "list": {
-					if (todoList.length === 0) {
-						return new Text(theme.fg("dim", "No todos"), 0, 0);
-					}
-					let listText = theme.fg("muted", `${todoList.length} todo(s):`);
-					const display = expanded ? todoList : todoList.slice(0, 5);
-					for (const t of display) {
-						const check = t.done ? theme.fg("success", "✓") : theme.fg("dim", "○");
-						const itemText = t.done ? theme.fg("dim", t.text) : theme.fg("muted", t.text);
-						listText += `\n${check} ${theme.fg("accent", `#${t.id}`)} ${itemText}`;
-					}
-					if (!expanded && todoList.length > 5) {
-						listText += `\n${theme.fg("dim", `... ${todoList.length - 5} more`)}`;
-					}
-					return new Text(listText, 0, 0);
-				}
-
-				case "add": {
-					const added = todoList[todoList.length - 1];
-					return new Text(
-						theme.fg("success", "✓ Added ") +
-							theme.fg("accent", `#${added.id}`) +
-							" " +
-							theme.fg("muted", added.text),
-						0,
-						0,
-					);
-				}
-
-				case "toggle": {
-					const text = result.content[0];
-					const msg = text?.type === "text" ? text.text : "";
-					return new Text(theme.fg("success", "✓ ") + theme.fg("muted", msg), 0, 0);
-				}
-
-				case "clear":
-					return new Text(theme.fg("success", "✓ ") + theme.fg("muted", "Cleared all todos"), 0, 0);
-			}
-		},
-	});
-
-	// Register the /todos command for users
-	pi.registerCommand("todos", {
-		description: "Show all todos on the current branch",
-		handler: async (_args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("/todos requires interactive mode", "error");
-				return;
-			}
-
-			await ctx.ui.custom<void>((_tui, theme, _kb, done) => {
-				return new TodoListComponent(todos, theme, () => done());
-			});
-		},
-	});
-}

package/config/pi/extensions/todo/package.json

@@ -1,16 +0,0 @@
-{
-  "name": "@xtrm/pi-todo",
-  "version": "1.0.0",
-  "description": "xtrm Pi extension: todo",
-  "type": "module",
-  "exports": {
-    ".": "./index.ts"
-  },
-  "keywords": [
-    "pi",
-    "extension",
-    "xtrm"
-  ],
-  "author": "xtrm",
-  "license": "MIT"
-}

package/hooks/agent_context.py

@@ -1,105 +0,0 @@
-#!/usr/bin/env python3
-import json
-import sys
-import os
-
-class AgentContext:
-    def __init__(self):
-        try:
-            # Read JSON from stdin once
-            self.data = json.load(sys.stdin)
-        except Exception:
-            self.data = {}
-            
-        self.tool_name = self.data.get('tool_name')
-        self.tool_input = self.data.get('tool_input', {})
-        self.event = self.data.get('hook_event_name')
-        self.prompt = self.data.get('prompt', '')
-        
-        # Determine Agent Type
-        if self.tool_name in ['run_shell_command', 'read_file', 'write_file', 'replace']:
-            self.agent_type = 'gemini'
-        elif self.tool_name in ['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep']:
-            self.agent_type = 'claude'
-        else:
-            # Fallback based on env vars
-            if os.environ.get('GEMINI_PROJECT_DIR'):
-                self.agent_type = 'gemini'
-            else:
-                self.agent_type = 'claude'
-
-    def is_shell_tool(self):
-        return self.tool_name in ['Bash', 'run_shell_command']
-
-    def is_write_tool(self):
-        return self.tool_name in ['Write', 'write_file']
-
-    def is_edit_tool(self):
-        return self.tool_name in ['Edit', 'replace']
-
-    def get_command(self):
-        return self.tool_input.get('command', '')
-
-    def get_file_path(self):
-        return self.tool_input.get('file_path', '')
-
-    def block(self, reason, system_message=None):
-        """Unified block response.
-
-        Only PreToolUse hooks support permissionDecision: deny.
-        For other hooks, use continue: false to block execution.
-        """
-        output = {}
-
-        if system_message:
-            output["systemMessage"] = system_message
-
-        # Only PreToolUse hooks support permissionDecision
-        if self.event == "PreToolUse":
-            output["hookSpecificOutput"] = {
-                "hookEventName": self.event,
-                "permissionDecision": "deny",
-                "permissionDecisionReason": reason
-            }
-        else:
-            # For non-PreToolUse hooks, use continue: false to block
-            output["continue"] = False
-            output["stopReason"] = reason
-
-        print(json.dumps(output))
-        sys.exit(0)
-
-    def allow(self, system_message=None, additional_context=None):
-        """Unified allow response.
-
-        For PreToolUse hooks: outputs permissionDecision in hookSpecificOutput
-        For other hooks (UserPromptSubmit, SessionStart, PostToolUse):
-          only systemMessage and/or additionalContext are valid
-        """
-        output = {}
-
-        if system_message:
-            output["systemMessage"] = system_message
-
-        # Build hookSpecificOutput if we have PreToolUse or additionalContext
-        if self.event == "PreToolUse" or additional_context:
-            hook_output = {"hookEventName": self.event}
-
-            # Only PreToolUse supports permissionDecision
-            if self.event == "PreToolUse":
-                hook_output["permissionDecision"] = "allow"
-
-            if additional_context:
-                hook_output["additionalContext"] = additional_context
-
-            output["hookSpecificOutput"] = hook_output
-
-        # Only print output if we have something to say
-        if output:
-            print(json.dumps(output))
-
-        sys.exit(0)
-
-    def fail_open(self):
-        """Standard fail-open behavior"""
-        sys.exit(0)

package/hooks/branch-state.mjs

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-// branch-state.mjs — UserPromptSubmit hook
-// Re-injects current git branch and active beads claim at each prompt.
-// Keeps the agent oriented after /compact or long sessions.
-// Output: { hookSpecificOutput: { additionalSystemPrompt } }
-
-import { execSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-
-function readInput() {
-  try { return JSON.parse(readFileSync(0, 'utf-8')); } catch { return null; }
-}
-
-function getBranch(cwd) {
-  try {
-    return execSync('git branch --show-current', {
-      encoding: 'utf8', cwd,
-      stdio: ['pipe', 'pipe', 'pipe'], timeout: 2000,
-    }).trim() || null;
-  } catch { return null; }
-}
-
-try {
-  const input = readInput();
-  if (!input) process.exit(0);
-
-  const cwd = input.cwd || process.cwd();
-  const branch = getBranch(cwd);
-
-  if (!branch) process.exit(0);
-
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: { additionalSystemPrompt: `[Context: branch=${branch}]` },
-  }));
-  process.stdout.write('\n');
-  process.exit(0);
-} catch {
-  process.exit(0);
-}