@dungle-scrubs/tallow 0.8.13 → 0.8.15

package/extensions/ask-user-question-tool/__tests__/render-regression.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Regression tests for ask_user_question custom UI rendering.
+ *
+ * Validates multiline option content never leaks embedded newlines into
+ * render rows and that repeated arrow navigation rerenders remain stable.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
+import askUserQuestion from "../index.js";
+
+/** Shape of the custom component returned by `ctx.ui.custom(...)`. */
+interface RenderComponentLike {
+	handleInput: (data: string) => void;
+	invalidate: () => void;
+	render: (width: number) => string[];
+}
+
+/** Driver returned by {@link createInteractiveContextHarness}. */
+interface InteractiveContextHarness {
+	ctx: ExtensionContext;
+	getComponent: () => RenderComponentLike;
+	getRenderRequestCount: () => number;
+}
+
+/** Raw terminal sequence for the Down arrow key. */
+const KEY_DOWN = "\u001b[B";
+/** Raw terminal sequence for Escape key. */
+const KEY_ESCAPE = "\u001b";
+
+/**
+ * Builds an interactive context stub and captures the custom UI component.
+ *
+ * The returned context implements `ctx.ui.custom(...)` by instantiating the
+ * component immediately and resolving when the component calls `done(...)`.
+ *
+ * @returns Harness with context and captured component accessors
+ */
+function createInteractiveContextHarness(): InteractiveContextHarness {
+	let component: RenderComponentLike | null = null;
+	let renderRequestCount = 0;
+
+	const ctx = {
+		hasUI: true,
+		cwd: process.cwd(),
+		ui: {
+			setWorkingMessage() {},
+			async custom(factory: unknown) {
+				const createComponent = factory as (
+					tui: unknown,
+					theme: unknown,
+					keybindings: unknown,
+					done: (value: unknown) => void
+				) => RenderComponentLike;
+
+				return await new Promise((resolve) => {
+					component = createComponent(
+						{
+							requestRender() {
+								renderRequestCount += 1;
+							},
+						},
+						{
+							bold: (value: string) => value,
+							fg: (_color: string, value: string) => value,
+						},
+						{},
+						(value: unknown) => {
+							resolve(value);
+						}
+					);
+				});
+			},
+		} as unknown as ExtensionContext["ui"],
+	} as ExtensionContext;
+
+	return {
+		ctx,
+		getComponent() {
+			if (!component) {
+				throw new Error("Custom component was not created yet");
+			}
+			return component;
+		},
+		getRenderRequestCount() {
+			return renderRequestCount;
+		},
+	};
+}
+
+/**
+ * Ensures the current microtask queue has drained.
+ * @returns Promise resolved on the next microtask tick
+ */
+async function nextTick(): Promise<void> {
+	await Promise.resolve();
+}
+
+describe("ask_user_question render regression", () => {
+	test("renders newline-safe rows for multiline labels and descriptions", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(askUserQuestion);
+
+		const tool = harness.tools.get("ask_user_question");
+		expect(tool).toBeDefined();
+		if (!tool) {
+			throw new Error("ask_user_question tool is not registered");
+		}
+
+		const interactive = createInteractiveContextHarness();
+		const runPromise = tool.execute(
+			"test-id",
+			{
+				question: "Pick one option",
+				options: [
+					{
+						description: "first description line\nsecond description line",
+						label: "Option A\nExtra Label",
+					},
+					{
+						description: "single line",
+						label: "Option B",
+					},
+				],
+			},
+			new AbortController().signal,
+			() => {},
+			interactive.ctx
+		);
+
+		await nextTick();
+		const component = interactive.getComponent();
+
+		const firstRender = component.render(44);
+		component.handleInput(KEY_DOWN);
+		const secondRender = component.render(44);
+
+		component.handleInput(KEY_ESCAPE);
+		const result = await runPromise;
+
+		expect(firstRender.every((line) => !line.includes("\n"))).toBe(true);
+		expect(secondRender.every((line) => !line.includes("\n"))).toBe(true);
+		expect(result.content[0]?.text).toBe("User cancelled the selection");
+	});
+
+	test("keeps line count stable during repeated down-arrow rerenders", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(askUserQuestion);
+
+		const tool = harness.tools.get("ask_user_question");
+		expect(tool).toBeDefined();
+		if (!tool) {
+			throw new Error("ask_user_question tool is not registered");
+		}
+
+		const interactive = createInteractiveContextHarness();
+		const runPromise = tool.execute(
+			"test-id",
+			{
+				question: "Navigate options",
+				options: [
+					{
+						description: "Line 1\nLine 2\nLine 3",
+						label: "Alpha",
+					},
+					{
+						description: "Desc B",
+						label: "Bravo",
+					},
+					{
+						description: "Desc C",
+						label: "Charlie",
+					},
+				],
+			},
+			new AbortController().signal,
+			() => {},
+			interactive.ctx
+		);
+
+		await nextTick();
+		const component = interactive.getComponent();
+
+		const width = 46;
+		const lineCounts: number[] = [component.render(width).length];
+		const renderSnapshots: string[][] = [component.render(width)];
+
+		for (let i = 0; i < 8; i++) {
+			component.handleInput(KEY_DOWN);
+			const snapshot = component.render(width);
+			lineCounts.push(snapshot.length);
+			renderSnapshots.push(snapshot);
+		}
+
+		component.handleInput(KEY_ESCAPE);
+		await runPromise;
+
+		expect(new Set(lineCounts).size).toBe(1);
+		expect(renderSnapshots.flat().every((line) => !line.includes("\n"))).toBe(true);
+		expect(interactive.getRenderRequestCount()).toBeGreaterThan(0);
+	});
+});

package/extensions/ask-user-question-tool/index.ts

@@ -13,6 +13,7 @@ import {
 	matchesKey,
 	Text,
 	truncateToWidth,
+	visibleWidth,
 	wrapTextWithAnsi,
 } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -48,6 +49,50 @@ const QuestionParams = Type.Object({
 	options: Type.Array(OptionSchema, { description: "Options for the user to choose from" }),
 });
 
+/**
+ * Splits text into visual lines while normalizing LF/CRLF line endings.
+ * @param text - Source text that may contain LF or CRLF newlines
+ * @returns Normalized visual lines without embedded newline characters
+ */
+function splitVisualLines(text: string): string[] {
+	return text.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+}
+
+/**
+ * Appends wrapped, newline-safe lines with first-line and continuation prefixes.
+ * @param lines - Output line buffer
+ * @param width - Total render width
+ * @param text - Raw text that may include LF/CRLF newlines
+ * @param firstPrefix - Prefix applied to the first rendered line
+ * @param continuationPrefix - Prefix applied to wrapped/continued lines
+ * @param style - Style function applied to each visual line before wrapping
+ * @returns Nothing
+ */
+function pushWrappedPrefixedLines(
+	lines: string[],
+	width: number,
+	text: string,
+	firstPrefix: string,
+	continuationPrefix: string,
+	style: (line: string) => string
+): void {
+	const safeWidth = Math.max(1, width);
+	let currentPrefix = firstPrefix;
+
+	for (const visualLine of splitVisualLines(text)) {
+		const prefixWidth = Math.max(visibleWidth(currentPrefix), visibleWidth(continuationPrefix));
+		const contentWidth = Math.max(1, safeWidth - prefixWidth);
+		const wrapped = wrapTextWithAnsi(style(visualLine), contentWidth);
+
+		for (let i = 0; i < wrapped.length; i++) {
+			const prefix = i === 0 ? currentPrefix : continuationPrefix;
+			lines.push(truncateToWidth(prefix + wrapped[i], safeWidth));
+		}
+
+		currentPrefix = continuationPrefix;
+	}
+}
+
 /**
  * Registers the ask_user_question tool with Pi.
  * Provides an interactive UI for asking users questions with selectable options.
@@ -118,6 +163,7 @@ WHEN NOT TO USE:
 				let optionIndex = 0;
 				let editMode = false;
 				let cachedLines: string[] | undefined;
+				let cachedWidth: number | undefined;
 
 				const editorTheme: EditorTheme = {
 					borderColor: (s) => theme.fg("accent", s),
@@ -147,6 +193,7 @@ WHEN NOT TO USE:
 				 */
 				function refresh() {
 					cachedLines = undefined;
+					cachedWidth = undefined;
 					tui.requestRender();
 				}
 
@@ -200,7 +247,7 @@ WHEN NOT TO USE:
 				 * @returns Array of rendered lines
 				 */
 				function render(width: number): string[] {
-					if (cachedLines) return cachedLines;
+					if (cachedLines && cachedWidth === width) return cachedLines;
 
 					const lines: string[] = [];
 					const add = (s: string) => lines.push(truncateToWidth(s, width));
@@ -216,19 +263,31 @@ WHEN NOT TO USE:
 						const opt = allOptions[i];
 						const selected = i === optionIndex;
 						const isOther = opt.isOther === true;
-						const prefix = selected ? theme.fg("accent", "> ") : "  ";
-
-						if (isOther && editMode) {
-							add(prefix + theme.fg("accent", `${i + 1}. ${opt.label} ✎`));
-						} else if (selected) {
-							add(prefix + theme.fg("accent", `${i + 1}. ${opt.label}`));
+						const numberPrefix = `${i + 1}. `;
+						const continuationPrefix = `  ${" ".repeat(numberPrefix.length)}`;
+						const hasEditMarker = isOther && editMode;
+						const labelText = `${numberPrefix}${opt.label}${hasEditMarker ? " ✎" : ""}`;
+
+						if (hasEditMarker || selected) {
+							pushWrappedPrefixedLines(
+								lines,
+								width,
+								labelText,
+								selected ? theme.fg("accent", "> ") : "  ",
+								continuationPrefix,
+								(value) => theme.fg("accent", value)
+							);
 						} else {
-							add(`  ${theme.fg("text", `${i + 1}. ${opt.label}`)}`);
+							pushWrappedPrefixedLines(lines, width, labelText, "  ", continuationPrefix, (value) =>
+								theme.fg("text", value)
+							);
 						}
 
 						// Show description if present
 						if (opt.description) {
-							add(`     ${theme.fg("muted", opt.description)}`);
+							pushWrappedPrefixedLines(lines, width, opt.description, "     ", "     ", (value) =>
+								theme.fg("muted", value)
+							);
 						}
 					}
 
@@ -248,6 +307,7 @@ WHEN NOT TO USE:
 					}
 					add(theme.fg("accent", "─".repeat(width)));
 
+					cachedWidth = width;
 					cachedLines = lines;
 					return lines;
 				}
@@ -256,6 +316,7 @@ WHEN NOT TO USE:
 					render,
 					invalidate: () => {
 						cachedLines = undefined;
+						cachedWidth = undefined;
 					},
 					handleInput,
 				};

package/extensions/background-task-tool/index.ts

@@ -45,7 +45,7 @@ import {
 	onInteropEvent,
 } from "../_shared/interop-events.js";
 import { registerPid, unregisterPid } from "../_shared/pid-registry.js";
-import { enforceExplicitPolicy, recordAudit } from "../_shared/shell-policy.js";
+import { enforceExplicitPolicy, evaluateCommand, recordAudit } from "../_shared/shell-policy.js";
 import { getTallowSettingsPath } from "../_shared/tallow-paths.js";
 import {
 	appendSection,
@@ -1666,9 +1666,17 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
 		const command = (event.input as Record<string, unknown>).command as string | undefined;
 		if (!command) return;
 
-		return enforceExplicitPolicy(command, "bg_bash", ctx.cwd, ctx.hasUI, (msg) =>
+		const verdict = evaluateCommand(command, "bg_bash", ctx.cwd);
+		const blocked = await enforceExplicitPolicy(command, "bg_bash", ctx.cwd, ctx.hasUI, (msg) =>
 			ctx.ui.confirm("Shell Policy", msg)
 		);
+		if (blocked) {
+			return blocked;
+		}
+
+		if (ctx.hasUI && verdict.allowed && verdict.requiresConfirmation) {
+			ctx.ui.notify("✅ Shell action approved — starting background task", "info");
+		}
 	});
 
 	pi.on("tool_result", async (event, ctx) => {

package/extensions/bash-tool-enhanced/index.ts

@@ -27,7 +27,7 @@ import {
 import { Text } from "@mariozechner/pi-tui";
 import { getIcon } from "../_icons/index.js";
 import { INTEROP_API_CHANNELS } from "../_shared/interop-events.js";
-import { enforceExplicitPolicy, recordAudit } from "../_shared/shell-policy.js";
+import { enforceExplicitPolicy, evaluateCommand, recordAudit } from "../_shared/shell-policy.js";
 import { getTallowSettingsPath } from "../_shared/tallow-paths.js";
 import type { PromotedTaskHandle } from "../background-task-tool/index.js";
 import {
@@ -653,9 +653,17 @@ export default function bashLive(pi: ExtensionAPI): void {
 		const command = (event.input as { command?: string }).command;
 		if (!command) return;
 
-		return enforceExplicitPolicy(command, "bash", ctx.cwd, ctx.hasUI, (msg) =>
+		const verdict = evaluateCommand(command, "bash", ctx.cwd);
+		const blocked = await enforceExplicitPolicy(command, "bash", ctx.cwd, ctx.hasUI, (msg) =>
 			ctx.ui.confirm("Shell Policy", msg)
 		);
+		if (blocked) {
+			return blocked;
+		}
+
+		if (ctx.hasUI && verdict.allowed && verdict.requiresConfirmation) {
+			ctx.ui.notify("✅ Shell action approved — running command", "info");
+		}
 	});
 
 	pi.on("tool_result", async (event, ctx) => {

package/extensions/plan-mode-tool/__tests__/utils.test.ts

@@ -1,12 +1,14 @@
 import { describe, expect, test } from "bun:test";
 import {
 	cleanStepText,
+	detectPlanIntent,
 	extractDoneSteps,
 	extractTodoItems,
 	isPlanModeToolAllowed,
 	isSafeCommand,
 	markCompletedSteps,
 	PLAN_MODE_ALLOWED_TOOLS,
+	stripPlanIntent,
 	type TodoItem,
 } from "../utils.js";
 
@@ -256,3 +258,181 @@ describe("markCompletedSteps", () => {
 		expect(items[0].completed).toBe(true);
 	});
 });
+
+describe("detectPlanIntent", () => {
+	// ── True positives ──────────────────────────────────────────────
+	test("detects 'plan only'", () => {
+		expect(detectPlanIntent("plan only")).toBe(true);
+	});
+
+	test("detects 'plan-only' (hyphenated)", () => {
+		expect(detectPlanIntent("this is plan-only")).toBe(true);
+	});
+
+	test("detects 'just plan'", () => {
+		expect(detectPlanIntent("just plan for now")).toBe(true);
+	});
+
+	test("detects 'only plan'", () => {
+		expect(detectPlanIntent("only plan, don't execute")).toBe(true);
+	});
+
+	test("detects 'plan mode' as directive", () => {
+		expect(detectPlanIntent("plan mode please")).toBe(true);
+	});
+
+	test("detects 'planning mode'", () => {
+		expect(detectPlanIntent("planning mode please")).toBe(true);
+	});
+
+	test("detects 'don't implement'", () => {
+		expect(detectPlanIntent("don't implement yet")).toBe(true);
+	});
+
+	test("detects curly apostrophe 'don\u2019t implement'", () => {
+		expect(detectPlanIntent("don\u2019t implement yet")).toBe(true);
+	});
+
+	test("detects 'do not implement'", () => {
+		expect(detectPlanIntent("do not implement")).toBe(true);
+	});
+
+	test("detects 'don't code yet'", () => {
+		expect(detectPlanIntent("don't code yet")).toBe(true);
+	});
+
+	test("detects 'don't make changes'", () => {
+		expect(detectPlanIntent("don't make changes")).toBe(true);
+	});
+
+	test("detects 'do not make changes'", () => {
+		expect(detectPlanIntent("do not make changes")).toBe(true);
+	});
+
+	test("detects 'no implementation yet'", () => {
+		expect(detectPlanIntent("no implementation yet")).toBe(true);
+	});
+
+	test("detects 'no changes first'", () => {
+		expect(detectPlanIntent("no changes first")).toBe(true);
+	});
+
+	test("detects 'read-only mode'", () => {
+		expect(detectPlanIntent("read-only mode")).toBe(true);
+	});
+
+	test("detects 'read only mode' (no hyphen)", () => {
+		expect(detectPlanIntent("read only mode")).toBe(true);
+	});
+
+	test("detects 'this is plan'", () => {
+		expect(detectPlanIntent("this is plan")).toBe(true);
+	});
+
+	test("detects 'this is planning'", () => {
+		expect(detectPlanIntent("this is planning")).toBe(true);
+	});
+
+	test("detects 'plan first'", () => {
+		expect(detectPlanIntent("plan first")).toBe(true);
+	});
+
+	test("detects 'plan before'", () => {
+		expect(detectPlanIntent("plan before implementing")).toBe(true);
+	});
+
+	test("detects the exact user complaint: 'not yet, this is plan only'", () => {
+		expect(detectPlanIntent("not yet, this is plan only")).toBe(true);
+	});
+
+	test("is case-insensitive", () => {
+		expect(detectPlanIntent("Plan Only")).toBe(true);
+		expect(detectPlanIntent("PLAN MODE")).toBe(true);
+		expect(detectPlanIntent("DON'T IMPLEMENT")).toBe(true);
+	});
+
+	test("detects intent mixed with a request", () => {
+		expect(detectPlanIntent("don't implement, just review the auth flow")).toBe(true);
+		expect(detectPlanIntent("analyze the database schema, plan only")).toBe(true);
+	});
+
+	// ── True negatives ──────────────────────────────────────────────
+	test("does NOT match 'make a plan for the API' (noun usage)", () => {
+		expect(detectPlanIntent("make a plan for the API")).toBe(false);
+	});
+
+	test("does NOT match 'what does plan mode do?' (question about plan mode)", () => {
+		expect(detectPlanIntent("what does plan mode do?")).toBe(false);
+	});
+
+	test("does NOT match 'how does plan mode work?' (question)", () => {
+		expect(detectPlanIntent("how does plan mode work?")).toBe(false);
+	});
+
+	test("does NOT match 'execute the plan' (opposite intent)", () => {
+		expect(detectPlanIntent("execute the plan")).toBe(false);
+	});
+
+	test("does NOT match 'the implementation plan looks good' (plan as noun)", () => {
+		expect(detectPlanIntent("the implementation plan looks good")).toBe(false);
+	});
+
+	test("does NOT match 'plan' alone (too ambiguous)", () => {
+		expect(detectPlanIntent("plan")).toBe(false);
+	});
+
+	test("does NOT match empty string", () => {
+		expect(detectPlanIntent("")).toBe(false);
+	});
+
+	test("does NOT match 'the plan is to refactor auth' (noun usage)", () => {
+		expect(detectPlanIntent("the plan is to refactor auth")).toBe(false);
+	});
+
+	test("does NOT match 'I planned the migration' (past tense)", () => {
+		expect(detectPlanIntent("I planned the migration")).toBe(false);
+	});
+});
+
+describe("stripPlanIntent", () => {
+	test("strips 'don't implement' and keeps the request", () => {
+		expect(stripPlanIntent("don't implement, just review the auth flow")).toBe(
+			"just review the auth flow"
+		);
+	});
+
+	test("returns original when stripping leaves empty string", () => {
+		expect(stripPlanIntent("plan only")).toBe("plan only");
+	});
+
+	test("strips 'this is plan only' prefix from mixed input", () => {
+		expect(stripPlanIntent("this is plan only, analyze the database schema")).toBe(
+			"analyze the database schema"
+		);
+	});
+
+	test("strips 'plan mode' from mixed input", () => {
+		expect(stripPlanIntent("plan mode — review the auth module")).toBe("review the auth module");
+	});
+
+	test("strips 'do not make changes' and cleans punctuation", () => {
+		expect(stripPlanIntent("do not make changes, review the config")).toBe("review the config");
+	});
+
+	test("cleans up double spaces after stripping", () => {
+		expect(stripPlanIntent("please plan only review auth")).toBe("please review auth");
+	});
+
+	test("handles multiple intent phrases in one message", () => {
+		const result = stripPlanIntent("plan only, don't implement, analyze the code");
+		expect(result).toBe("analyze the code");
+	});
+
+	test("returns original when entire message is intent", () => {
+		expect(stripPlanIntent("just plan")).toBe("just plan");
+	});
+
+	test("returns original for empty string", () => {
+		expect(stripPlanIntent("")).toBe("");
+	});
+});

package/extensions/plan-mode-tool/extension.json

@@ -10,6 +10,7 @@
 			"agent_end",
 			"before_agent_start",
 			"context",
+			"input",
 			"session_start",
 			"tool_call",
 			"tool_result",

package/extensions/plan-mode-tool/index.ts

@@ -31,11 +31,13 @@ import {
 import { Type } from "@sinclair/typebox";
 import { getIcon } from "../_icons/index.js";
 import {
+	detectPlanIntent,
 	extractTodoItems,
 	isPlanModeToolAllowed,
 	isSafeCommand,
 	markCompletedSteps,
 	PLAN_MODE_ALLOWED_TOOLS,
+	stripPlanIntent,
 	type TodoItem,
 } from "./utils.js";
 
@@ -443,6 +445,37 @@ Use action "enable" to enter plan mode, "disable" to exit, or "status" to check
 		}
 	});
 
+	// Auto-enable plan mode when user expresses planning intent in natural language
+	pi.on("input", async (event, ctx) => {
+		// No-op if already in plan mode or execution mode
+		if (planModeEnabled || executionMode) {
+			return { action: "continue" as const };
+		}
+
+		if (!detectPlanIntent(event.text)) {
+			return { action: "continue" as const };
+		}
+
+		// Auto-enable plan mode
+		planModeEnabled = true;
+		captureNormalModeTools();
+		applyPlanModeTools();
+		updateStatus(ctx);
+		persistState();
+
+		ctx.ui?.notify(
+			"Plan mode auto-enabled (detected planning intent). Use /plan-mode or Ctrl+Alt+P to disable.",
+			"info"
+		);
+
+		// Strip the plan-intent phrase, keep the actual request
+		const stripped = stripPlanIntent(event.text);
+		if (stripped !== event.text) {
+			return { action: "transform" as const, text: stripped };
+		}
+		return { action: "continue" as const };
+	});
+
 	// Filter out stale plan mode context when not in plan mode
 	pi.on("context", async (event) => {
 		if (planModeEnabled) return;