@dungle-scrubs/tallow 0.8.26 → 0.8.28

package/extensions/loop/index.ts

@@ -10,7 +10,7 @@
  *   - `until "<condition>"` — the model evaluates the condition each
  *     iteration and calls the `loop_stop` tool when it's met
  *
- * Usage:
+ * Usage (strict syntax):
  *   /loop 5m check the deploy status
  *   /loop 1m x10 run the test suite
  *   /loop 2m until "build is done" check fuse index progress
@@ -18,6 +18,11 @@
  *   /loop 30s /stats
  *   /loop stop
  *   /loop status
+ *
+ * Natural language (auto-parsed → prefilled for confirmation):
+ *   /loop check ci every 2 minutes until it passes
+ *   /loop run tests every 30 seconds, stop when they pass
+ *   /loop monitor deploy health every minute, max 20 tries
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
@@ -277,6 +282,201 @@ export function parseLoopArgs(args: string): LoopArgs | { action: "error"; messa
 	};
 }
 
+// ── Natural Language Parsing ──────────────────────────────────────────────────
+
+/** Map from human-readable unit names to short suffixes. */
+const UNIT_ALIASES: Readonly<Record<string, string>> = {
+	s: "s",
+	sec: "s",
+	secs: "s",
+	second: "s",
+	seconds: "s",
+	m: "m",
+	min: "m",
+	mins: "m",
+	minute: "m",
+	minutes: "m",
+	h: "h",
+	hr: "h",
+	hrs: "h",
+	hour: "h",
+	hours: "h",
+};
+
+/**
+ * Attempt to parse a natural-language loop description into structured params.
+ *
+ * Extracts interval, condition, max iterations, and prompt from free-form
+ * text using regex heuristics. Returns null if no interval can be identified.
+ *
+ * This is a best-effort parser — the result is prefilled in the editor for
+ * the user to review, not executed directly.
+ *
+ * @param text - Free-form loop description
+ * @returns Parsed start params, or null if no interval was found
+ */
+export function parseNaturalLanguageLoop(
+	text: string
+): Extract<LoopArgs, { action: "start" }> | null {
+	let work = text;
+
+	// ── Interval extraction ──────────────────────────────────────────
+
+	let intervalMs: number | null = null;
+	let intervalLabel: string | null = null;
+
+	// "every <N> <unit-word>" — e.g. "every 2 minutes", "every 30 seconds"
+	const everyLong = work.match(
+		/\bevery\s+(\d+)\s+(seconds?|secs?|sec|minutes?|mins?|min|hours?|hrs?|hr)\b/i
+	);
+	if (everyLong) {
+		const val = parseInt(everyLong[1], 10);
+		const unit = UNIT_ALIASES[everyLong[2].toLowerCase()];
+		if (unit && val > 0) {
+			intervalMs = val * UNIT_MS[unit];
+			intervalLabel = `${val}${unit}`;
+			work = work.replace(everyLong[0], " ");
+		}
+	}
+
+	// "every <unit-word>" without number → 1 unit. e.g. "every minute"
+	if (!intervalMs) {
+		const everyBare = work.match(/\bevery\s+(second|minute|hour)\b/i);
+		if (everyBare) {
+			const unit = UNIT_ALIASES[everyBare[1].toLowerCase()];
+			if (unit) {
+				intervalMs = UNIT_MS[unit];
+				intervalLabel = `1${unit}`;
+				work = work.replace(everyBare[0], " ");
+			}
+		}
+	}
+
+	// "every <N><short-unit>" — e.g. "every 2m"
+	if (!intervalMs) {
+		const everyShort = work.match(/\bevery\s+(\d+)(s|m|h)\b/i);
+		if (everyShort) {
+			const val = parseInt(everyShort[1], 10);
+			const unit = everyShort[2].toLowerCase();
+			if (val > 0) {
+				intervalMs = val * UNIT_MS[unit];
+				intervalLabel = `${val}${unit}`;
+				work = work.replace(everyShort[0], " ");
+			}
+		}
+	}
+
+	// Bare "<N><short-unit>" without "every" — e.g. "2m"
+	if (!intervalMs) {
+		const bare = work.match(/\b(\d+)(s|m|h)\b/);
+		if (bare) {
+			const val = parseInt(bare[1], 10);
+			const unit = bare[2].toLowerCase();
+			if (val > 0) {
+				intervalMs = val * UNIT_MS[unit];
+				intervalLabel = `${val}${unit}`;
+				work = work.replace(bare[0], " ");
+			}
+		}
+	}
+
+	if (!intervalMs || !intervalLabel) return null;
+
+	// ── Max iterations extraction ────────────────────────────────────
+
+	let maxIterations: number | null = null;
+
+	// "x<N>"
+	const xN = work.match(/\bx(\d+)\b/);
+	if (xN) {
+		const n = parseInt(xN[1], 10);
+		if (n > 0) {
+			maxIterations = n;
+			work = work.replace(xN[0], " ");
+		}
+	}
+
+	// "<N> times" / "max <N> [times|tries|iterations]" / "at most <N> [...]"
+	if (maxIterations === null) {
+		const alt = work.match(
+			/\b(?:(\d+)\s+times|max\s+(\d+)(?:\s+(?:times|tries|iterations))?|at\s+most\s+(\d+)(?:\s+(?:times|tries|iterations))?)\b/i
+		);
+		if (alt) {
+			const n = parseInt(alt[1] || alt[2] || alt[3], 10);
+			if (n > 0) {
+				maxIterations = n;
+				work = work.replace(alt[0], " ");
+			}
+		}
+	}
+
+	// ── Condition extraction ─────────────────────────────────────────
+	// Uses greedy match for the prompt prefix so multi-"until" text picks
+	// the last occurrence (the actual condition marker).
+
+	let untilCondition: string | null = null;
+	let promptText: string;
+
+	// Case 1: condition at end (most common) — "check ci until it passes"
+	const endMatch = work.match(/^(.*)\s*[,;]?\s*\b(until|stop\s+when)\s+(.+?)[\s,;.!]*$/i);
+
+	if (endMatch?.[1].trim()) {
+		promptText = endMatch[1];
+		untilCondition = endMatch[3].replace(/^["']|["']$/g, "");
+	} else {
+		// Case 2: condition at start with comma — "until it passes, check ci"
+		const startMatch = work.match(/^\s*\b(until|stop\s+when)\s+(.+?)\s*[,;]\s+(.+?)[\s,;.!]*$/i);
+
+		if (startMatch) {
+			untilCondition = startMatch[2].replace(/^["']|["']$/g, "");
+			promptText = startMatch[3];
+		} else {
+			// No condition marker, or condition-only with no prompt
+			promptText = work;
+		}
+	}
+
+	// ── Clean up ─────────────────────────────────────────────────────
+
+	const prompt = promptText.replace(/[,;]+/g, " ").replace(/\s+/g, " ").trim();
+
+	if (!prompt) return null;
+
+	if (untilCondition) {
+		untilCondition = untilCondition.replace(/\s+/g, " ").trim();
+		if (!untilCondition) untilCondition = null;
+	}
+
+	return {
+		action: "start",
+		intervalMs,
+		intervalLabel,
+		prompt,
+		maxIterations,
+		untilCondition,
+	};
+}
+
+/**
+ * Build a `/loop` command string from structured params.
+ *
+ * Produces valid strict syntax that `parseLoopArgs` can parse.
+ *
+ * @param params - Parsed loop start parameters
+ * @returns Command string like `/loop 2m until "it passes" check ci`
+ */
+export function buildLoopCommand(params: Extract<LoopArgs, { action: "start" }>): string {
+	let cmd = `/loop ${params.intervalLabel}`;
+	if (params.maxIterations !== null) {
+		cmd += ` x${params.maxIterations}`;
+	}
+	if (params.untilCondition) {
+		cmd += ` until "${params.untilCondition}"`;
+	}
+	cmd += ` ${params.prompt}`;
+	return cmd;
+}
+
 // ── Loop Lifecycle ───────────────────────────────────────────────────────────
 
 /**
@@ -469,14 +669,24 @@ export default function loopExtension(pi: ExtensionAPI): void {
 	pi.registerCommand("loop", {
 		description:
 			"Run a prompt on a recurring interval. " +
-			'Syntax: /loop <interval> [x<N>] [until "<condition>"] <prompt>',
+			'Syntax: /loop <interval> [x<N>] [until "<condition>"] <prompt> — ' +
+			"or describe in natural language: /loop check ci every 2m until it passes",
 		handler: async (args, ctx) => {
 			const parsed = parseLoopArgs(args);
 
 			switch (parsed.action) {
-				case "error":
+				case "error": {
+					// Try natural-language fallback before showing the error
+					const nlResult = parseNaturalLanguageLoop(args);
+					if (nlResult) {
+						const command = buildLoopCommand(nlResult);
+						ctx.ui.setEditorText(command);
+						ctx.ui.notify("Loop command generated — review and press Enter to start", "info");
+						return;
+					}
 					ctx.ui.notify(parsed.message, "error");
 					return;
+				}
 
 				case "stop":
 					if (!activeLoop) {

package/extensions/mcp-adapter-tool/index.ts

@@ -1752,7 +1752,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
 		return { systemPrompt: event.systemPrompt + lines.join("\n") };
 	});
 
-	pi.on("session_shutdown" as never, async () => {
+	pi.on("session_shutdown", async () => {
 		resetRuntimeState();
 	});
 

package/extensions/minimal-skill-display/__tests__/minimal-skill-display.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import minimalSkillDisplay from "../index.js";
+
+describe("minimal-skill-display extension", () => {
+	test("registers session_start and input handlers", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+			registerCommand: () => {},
+			registerMessageRenderer: () => {},
+		} as unknown as ExtensionAPI;
+
+		minimalSkillDisplay(pi);
+		expect(events).toContain("session_start");
+		expect(events).toContain("input");
+	});
+});

package/extensions/permissions/__tests__/permissions.test.ts

@@ -0,0 +1,213 @@
+/**
+ * Tests for the permissions extension registration and wiring.
+ *
+ * Uses the ExtensionHarness to avoid mock.module() — which contaminates
+ * other test files in the same Bun worker. Tests cover command/handler
+ * registration and event handler presence without mocking the _shared modules.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
+import registerPermissions from "../index.js";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+type EventName = "session_start" | "tool_call";
+type EventHandler = (event: unknown, ctx: ExtensionContext) => Promise<unknown>;
+type CommandHandler = (args: string | undefined, ctx: unknown) => Promise<void>;
+
+interface CapturedPi {
+	handlers: Partial<Record<EventName, EventHandler>>;
+	commands: Record<string, { description: string; handler: CommandHandler }>;
+}
+
+/**
+ * Run the extension against a spy pi to capture what it registers.
+ *
+ * @returns Captured event handlers and commands
+ */
+function captureRegistrations(): CapturedPi {
+	const handlers: Partial<Record<EventName, EventHandler>> = {};
+	const commands: Record<string, { description: string; handler: CommandHandler }> = {};
+	const pi = {
+		on: (event: string, handler: EventHandler) => {
+			handlers[event as EventName] = handler;
+		},
+		registerCommand: (name: string, opts: { description: string; handler: CommandHandler }) => {
+			commands[name] = opts;
+		},
+	} as unknown as ExtensionAPI;
+
+	registerPermissions(pi);
+	return { handlers, commands };
+}
+
+// ════════════════════════════════════════════════════════════════
+// Registration
+// ════════════════════════════════════════════════════════════════
+
+describe("permissions extension registration", () => {
+	test("registers session_start handler", () => {
+		const { handlers } = captureRegistrations();
+		expect(handlers.session_start).toBeDefined();
+	});
+
+	test("registers tool_call handler", () => {
+		const { handlers } = captureRegistrations();
+		expect(handlers.tool_call).toBeDefined();
+	});
+
+	test("registers /permissions command", () => {
+		const { commands } = captureRegistrations();
+		expect(commands.permissions).toBeDefined();
+		expect(commands.permissions.description).toBeTruthy();
+	});
+});
+
+// ════════════════════════════════════════════════════════════════
+// tool_call handler wiring
+// ════════════════════════════════════════════════════════════════
+
+describe("tool_call handler", () => {
+	test("skips bash tool (handled by shell-policy)", async () => {
+		const { handlers } = captureRegistrations();
+		const result = await handlers.tool_call!(
+			{ type: "tool_call", toolName: "bash", toolCallId: "t1", input: { command: "ls" } },
+			{ cwd: "/tmp", hasUI: false, ui: {} } as unknown as ExtensionContext
+		);
+		// No block/error — should be undefined (pass-through)
+		expect(result).toBeUndefined();
+	});
+
+	test("skips bg_bash tool (handled by shell-policy)", async () => {
+		const { handlers } = captureRegistrations();
+		const result = await handlers.tool_call!(
+			{ type: "tool_call", toolName: "bg_bash", toolCallId: "t2", input: { command: "ls" } },
+			{ cwd: "/tmp", hasUI: false, ui: {} } as unknown as ExtensionContext
+		);
+		expect(result).toBeUndefined();
+	});
+
+	test("skips when no rules configured", async () => {
+		const { handlers } = captureRegistrations();
+		// Session-start hasn't been called yet, so currentCwd is "", and
+		// getPermissions("") returns empty rules → skip
+		const result = await handlers.tool_call!(
+			{
+				type: "tool_call",
+				toolName: "read",
+				toolCallId: "t3",
+				input: { path: "/etc/passwd" },
+			},
+			{ cwd: "/tmp", hasUI: false, ui: {} } as unknown as ExtensionContext
+		);
+		expect(result).toBeUndefined();
+	});
+});
+
+// ════════════════════════════════════════════════════════════════
+// /permissions command wiring
+// ════════════════════════════════════════════════════════════════
+
+describe("/permissions command", () => {
+	test("reload subcommand calls reloadPermissions", async () => {
+		const { commands } = captureRegistrations();
+		const notifications: Array<{ msg: string; type: string }> = [];
+		const ctx = {
+			cwd: "/tmp",
+			ui: {
+				notify: (msg: string, type: string) => {
+					notifications.push({ msg, type });
+				},
+			},
+		};
+
+		await commands.permissions.handler("reload", ctx);
+		// Should have notified about reload
+		expect(notifications.length).toBeGreaterThan(0);
+		expect(notifications[0].msg).toContain("Reloaded");
+	});
+
+	test("no args shows rules (or 'no rules' when none configured)", async () => {
+		const { commands } = captureRegistrations();
+		const notifications: Array<{ msg: string; type: string }> = [];
+		const ctx = {
+			cwd: "/tmp",
+			ui: {
+				notify: (msg: string, type: string) => {
+					notifications.push({ msg, type });
+				},
+			},
+		};
+
+		await commands.permissions.handler("", ctx);
+		expect(notifications.length).toBeGreaterThan(0);
+		// Should show either "No permission rules" or "Active Permission Rules"
+		const msg = notifications[0].msg;
+		expect(msg.includes("No permission rules") || msg.includes("Permission Rules")).toBe(true);
+	});
+
+	test("test subcommand evaluates Tool(specifier) format", async () => {
+		const { commands } = captureRegistrations();
+		const notifications: Array<{ msg: string; type: string }> = [];
+		const ctx = {
+			cwd: "/tmp",
+			ui: {
+				notify: (msg: string, type: string) => {
+					notifications.push({ msg, type });
+				},
+			},
+		};
+
+		await commands.permissions.handler("test Bash(ls)", ctx);
+		expect(notifications.length).toBeGreaterThan(0);
+		// Should contain action verdict info
+		expect(notifications[0].msg).toContain("Action:");
+	});
+
+	test("test subcommand handles bare tool name", async () => {
+		const { commands } = captureRegistrations();
+		const notifications: Array<{ msg: string; type: string }> = [];
+		const ctx = {
+			cwd: "/tmp",
+			ui: {
+				notify: (msg: string, type: string) => {
+					notifications.push({ msg, type });
+				},
+			},
+		};
+
+		await commands.permissions.handler("test read", ctx);
+		expect(notifications.length).toBeGreaterThan(0);
+		expect(notifications[0].msg).toContain("Action:");
+	});
+});
+
+// ════════════════════════════════════════════════════════════════
+// ExtensionHarness integration
+// ════════════════════════════════════════════════════════════════
+
+describe("permissions via ExtensionHarness", () => {
+	test("tool_call event handler is registered", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(registerPermissions);
+		// Verify the extension registered a tool_call handler by firing one
+		const results = await harness.fireEvent("tool_call", {
+			type: "tool_call",
+			toolName: "read",
+			toolCallId: "h-1",
+			input: { path: "foo.txt" },
+		});
+		// No rules configured → should not block
+		const blocked = results.some(
+			(r) => r && typeof r === "object" && (r as { block?: boolean }).block
+		);
+		expect(blocked).toBe(false);
+	});
+
+	test("/permissions command is registered", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(registerPermissions);
+		expect(harness.commands.has("permissions")).toBe(true);
+	});
+});

package/extensions/progress-indicator/__tests__/progress-indicator.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import progressIndicator from "../index.js";
+
+describe("progress-indicator extension", () => {
+	let originalIsTTY: boolean;
+	let written: string[];
+	let originalWrite: typeof process.stdout.write;
+
+	beforeEach(() => {
+		originalIsTTY = process.stdout.isTTY;
+		originalWrite = process.stdout.write;
+		written = [];
+		Object.defineProperty(process.stdout, "isTTY", { value: true, configurable: true });
+		process.stdout.write = ((chunk: string) => {
+			written.push(chunk);
+			return true;
+		}) as typeof process.stdout.write;
+	});
+
+	afterEach(() => {
+		Object.defineProperty(process.stdout, "isTTY", {
+			value: originalIsTTY,
+			configurable: true,
+		});
+		process.stdout.write = originalWrite;
+	});
+
+	test("registers turn_start, turn_end, agent_end, session_shutdown handlers", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		expect(events).toContain("turn_start");
+		expect(events).toContain("turn_end");
+		expect(events).toContain("agent_end");
+		expect(events).toContain("session_shutdown");
+	});
+
+	test("turn_start writes indeterminate OSC sequence", () => {
+		const handlers: Record<string, () => void> = {};
+		const pi = {
+			on: (event: string, handler: () => void) => {
+				handlers[event] = handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		handlers.turn_start();
+
+		expect(written).toHaveLength(1);
+		expect(written[0]).toContain("9;4;3");
+	});
+
+	test("turn_end writes clear OSC sequence", () => {
+		const handlers: Record<string, () => void> = {};
+		const pi = {
+			on: (event: string, handler: () => void) => {
+				handlers[event] = handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		handlers.turn_end();
+
+		expect(written).toHaveLength(1);
+		expect(written[0]).toContain("9;4;0");
+	});
+
+	test("agent_end writes clear OSC sequence", () => {
+		const handlers: Record<string, () => void> = {};
+		const pi = {
+			on: (event: string, handler: () => void) => {
+				handlers[event] = handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		handlers.agent_end();
+
+		expect(written).toHaveLength(1);
+		expect(written[0]).toContain("9;4;0");
+	});
+
+	test("skips write when stdout is not a TTY", () => {
+		Object.defineProperty(process.stdout, "isTTY", { value: false, configurable: true });
+
+		const handlers: Record<string, () => void> = {};
+		const pi = {
+			on: (event: string, handler: () => void) => {
+				handlers[event] = handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		handlers.turn_start();
+
+		expect(written).toHaveLength(0);
+	});
+});