pi-usereq 0.7.0 → 0.11.0

package/pi.dev-src/pi-mono/coding-agent/test/truncate-to-width.test.ts

@@ -0,0 +1,81 @@
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Tests for truncateToWidth behavior with Unicode characters.
+ *
+ * These tests verify that truncateToWidth properly handles text with
+ * Unicode characters that have different byte vs display widths.
+ */
+describe("truncateToWidth", () => {
+	it("should truncate messages with Unicode characters correctly", () => {
+		// This message contains a checkmark (✔) which may have display width > 1 byte
+		const message = '✔ script to run › dev $ concurrently "vite" "node --import tsx ./';
+		const width = 67;
+		const maxMsgWidth = width - 2; // Account for cursor
+
+		const truncated = truncateToWidth(message, maxMsgWidth);
+		const truncatedWidth = visibleWidth(truncated);
+
+		expect(truncatedWidth).toBeLessThanOrEqual(maxMsgWidth);
+	});
+
+	it("should handle emoji characters", () => {
+		const message = "🎉 Celebration! 🚀 Launch 📦 Package ready for deployment now";
+		const width = 40;
+		const maxMsgWidth = width - 2;
+
+		const truncated = truncateToWidth(message, maxMsgWidth);
+		const truncatedWidth = visibleWidth(truncated);
+
+		expect(truncatedWidth).toBeLessThanOrEqual(maxMsgWidth);
+	});
+
+	it("should handle mixed ASCII and wide characters", () => {
+		const message = "Hello 世界 Test 你好 More text here that is long";
+		const width = 30;
+		const maxMsgWidth = width - 2;
+
+		const truncated = truncateToWidth(message, maxMsgWidth);
+		const truncatedWidth = visibleWidth(truncated);
+
+		expect(truncatedWidth).toBeLessThanOrEqual(maxMsgWidth);
+	});
+
+	it("should not truncate messages that fit", () => {
+		const message = "Short message";
+		const width = 50;
+		const maxMsgWidth = width - 2;
+
+		const truncated = truncateToWidth(message, maxMsgWidth);
+
+		expect(truncated).toBe(message);
+		expect(visibleWidth(truncated)).toBeLessThanOrEqual(maxMsgWidth);
+	});
+
+	it("should add ellipsis when truncating", () => {
+		const message = "This is a very long message that needs to be truncated";
+		const width = 30;
+		const maxMsgWidth = width - 2;
+
+		const truncated = truncateToWidth(message, maxMsgWidth);
+
+		expect(truncated).toContain("...");
+		expect(visibleWidth(truncated)).toBeLessThanOrEqual(maxMsgWidth);
+	});
+
+	it("should handle the exact crash case from issue report", () => {
+		// Terminal width was 67, line had visible width 68
+		// The problematic text contained "✔" and "›" characters
+		const message = '✔ script to run › dev $ concurrently "vite" "node --import tsx ./server.ts"';
+		const terminalWidth = 67;
+		const cursorWidth = 2; // "› " or "  "
+		const maxMsgWidth = terminalWidth - cursorWidth;
+
+		const truncated = truncateToWidth(message, maxMsgWidth);
+		const finalWidth = visibleWidth(truncated);
+
+		// The final line (cursor + message) must not exceed terminal width
+		expect(finalWidth + cursorWidth).toBeLessThanOrEqual(terminalWidth);
+	});
+});

package/pi.dev-src/pi-mono/coding-agent/test/user-message.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "vitest";
+import { UserMessageComponent } from "../src/modes/interactive/components/user-message.js";
+import { initTheme } from "../src/modes/interactive/theme/theme.js";
+
+const OSC133_ZONE_START = "\x1b]133;A\x07";
+const OSC133_ZONE_END = "\x1b]133;B\x07";
+const OSC133_ZONE_FINAL = "\x1b]133;C\x07";
+const BG_RESET = "\x1b[49m";
+
+describe("UserMessageComponent", () => {
+	test("keeps user message height stable while moving closing OSC markers off line end", () => {
+		initTheme("dark");
+
+		const component = new UserMessageComponent("hello");
+		const lines = component.render(20);
+
+		expect(lines).toHaveLength(3);
+		expect(lines[0]).toContain(OSC133_ZONE_START);
+		expect(lines[0].endsWith(BG_RESET)).toBe(true);
+		expect(lines[0]).not.toContain(OSC133_ZONE_END);
+		expect(lines[1]).toContain("hello");
+		expect(lines[2].startsWith(OSC133_ZONE_END + OSC133_ZONE_FINAL)).toBe(true);
+		expect(lines[2].endsWith(BG_RESET)).toBe(true);
+	});
+});

package/pi.dev-src/pi-mono/coding-agent/test/utilities.ts

@@ -0,0 +1,316 @@
+/**
+ * Shared test utilities for coding-agent tests.
+ */
+
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { Agent } from "@mariozechner/pi-agent-core";
+import { getModel, type OAuthCredentials, type OAuthProvider } from "@mariozechner/pi-ai";
+import { getOAuthApiKey } from "@mariozechner/pi-ai/oauth";
+import { AgentSession } from "../src/core/agent-session.js";
+import { AuthStorage } from "../src/core/auth-storage.js";
+import { createEventBus } from "../src/core/event-bus.js";
+import type { Extension, ExtensionFactory, LoadExtensionsResult } from "../src/core/extensions/index.js";
+import { createExtensionRuntime, loadExtensionFromFactory } from "../src/core/extensions/loader.js";
+import { ModelRegistry } from "../src/core/model-registry.js";
+import type { ResourceLoader } from "../src/core/resource-loader.js";
+import { SessionManager } from "../src/core/session-manager.js";
+import { SettingsManager } from "../src/core/settings-manager.js";
+import { createCodingTools } from "../src/index.js";
+
+/**
+ * API key for authenticated tests. Tests using this should be wrapped in
+ * describe.skipIf(!API_KEY)
+ */
+export const API_KEY = process.env.ANTHROPIC_OAUTH_TOKEN || process.env.ANTHROPIC_API_KEY;
+
+// ============================================================================
+// OAuth API key resolution from ~/.pi/agent/auth.json
+// ============================================================================
+
+const AUTH_PATH = join(homedir(), ".pi", "agent", "auth.json");
+
+type ApiKeyCredential = {
+	type: "api_key";
+	key: string;
+};
+
+type OAuthCredentialEntry = {
+	type: "oauth";
+} & OAuthCredentials;
+
+type AuthCredential = ApiKeyCredential | OAuthCredentialEntry;
+
+type AuthStorageData = Record<string, AuthCredential>;
+
+function loadAuthStorage(): AuthStorageData {
+	if (!existsSync(AUTH_PATH)) {
+		return {};
+	}
+	try {
+		const content = readFileSync(AUTH_PATH, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+
+function saveAuthStorage(storage: AuthStorageData): void {
+	const configDir = dirname(AUTH_PATH);
+	if (!existsSync(configDir)) {
+		mkdirSync(configDir, { recursive: true, mode: 0o700 });
+	}
+	writeFileSync(AUTH_PATH, JSON.stringify(storage, null, 2), "utf-8");
+	chmodSync(AUTH_PATH, 0o600);
+}
+
+/**
+ * Resolve API key for a provider from ~/.pi/agent/auth.json
+ *
+ * For API key credentials, returns the key directly.
+ * For OAuth credentials, returns the access token (refreshing if expired and saving back).
+ *
+ * For google-gemini-cli and google-antigravity, returns JSON-encoded { token, projectId }
+ */
+export async function resolveApiKey(provider: string): Promise<string | undefined> {
+	const storage = loadAuthStorage();
+	const entry = storage[provider];
+
+	if (!entry) return undefined;
+
+	if (entry.type === "api_key") {
+		return entry.key;
+	}
+
+	if (entry.type === "oauth") {
+		// Build OAuthCredentials record for getOAuthApiKey
+		const oauthCredentials: Record<string, OAuthCredentials> = {};
+		for (const [key, value] of Object.entries(storage)) {
+			if (value.type === "oauth") {
+				const { type: _, ...creds } = value;
+				oauthCredentials[key] = creds;
+			}
+		}
+
+		const result = await getOAuthApiKey(provider as OAuthProvider, oauthCredentials);
+		if (!result) return undefined;
+
+		// Save refreshed credentials back to auth.json
+		storage[provider] = { type: "oauth", ...result.newCredentials };
+		saveAuthStorage(storage);
+
+		return result.apiKey;
+	}
+
+	return undefined;
+}
+
+/**
+ * Check if a provider has credentials in ~/.pi/agent/auth.json
+ */
+export function hasAuthForProvider(provider: string): boolean {
+	const storage = loadAuthStorage();
+	return provider in storage;
+}
+
+/** Path to the real pi agent config directory */
+export const PI_AGENT_DIR = join(homedir(), ".pi", "agent");
+
+/**
+ * Get an AuthStorage instance backed by ~/.pi/agent/auth.json
+ * Use this for tests that need real OAuth credentials.
+ */
+export function getRealAuthStorage(): AuthStorage {
+	return AuthStorage.create(AUTH_PATH);
+}
+
+/**
+ * Create a minimal user message for testing.
+ */
+export function userMsg(text: string) {
+	return { role: "user" as const, content: text, timestamp: Date.now() };
+}
+
+/**
+ * Create a minimal assistant message for testing.
+ */
+export function assistantMsg(text: string) {
+	return {
+		role: "assistant" as const,
+		content: [{ type: "text" as const, text }],
+		api: "anthropic-messages" as const,
+		provider: "anthropic",
+		model: "test",
+		usage: {
+			input: 1,
+			output: 1,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 2,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop" as const,
+		timestamp: Date.now(),
+	};
+}
+
+/**
+ * Options for creating a test session.
+ */
+export interface TestSessionOptions {
+	/** Use in-memory session (no file persistence) */
+	inMemory?: boolean;
+	/** Custom system prompt */
+	systemPrompt?: string;
+	/** Custom settings overrides */
+	settingsOverrides?: Record<string, unknown>;
+}
+
+/**
+ * Resources returned by createTestSession that need cleanup.
+ */
+export interface TestSessionContext {
+	session: AgentSession;
+	sessionManager: SessionManager;
+	tempDir: string;
+	cleanup: () => void;
+}
+
+export interface CreateTestExtensionsResultInput {
+	factory: ExtensionFactory;
+	path?: string;
+}
+
+export async function createTestExtensionsResult(
+	inputs: Array<ExtensionFactory | CreateTestExtensionsResultInput>,
+	cwd = process.cwd(),
+): Promise<LoadExtensionsResult> {
+	const runtime = createExtensionRuntime();
+	const eventBus = createEventBus();
+	const extensions: Extension[] = [];
+
+	for (const [index, input] of inputs.entries()) {
+		const factory = typeof input === "function" ? input : input.factory;
+		const extensionPath =
+			typeof input === "function" ? `<inline:${index + 1}>` : (input.path ?? `<inline:${index + 1}>`);
+		extensions.push(await loadExtensionFromFactory(factory, cwd, eventBus, runtime, extensionPath));
+	}
+
+	return {
+		extensions,
+		errors: [],
+		runtime,
+	};
+}
+
+export interface CreateTestResourceLoaderOptions {
+	extensionsResult?: LoadExtensionsResult;
+}
+
+export function createTestResourceLoader(options: CreateTestResourceLoaderOptions = {}): ResourceLoader {
+	const extensionsResult = options.extensionsResult ?? {
+		extensions: [],
+		errors: [],
+		runtime: createExtensionRuntime(),
+	};
+
+	return {
+		getExtensions: () => extensionsResult,
+		getSkills: () => ({ skills: [], diagnostics: [] }),
+		getPrompts: () => ({ prompts: [], diagnostics: [] }),
+		getThemes: () => ({ themes: [], diagnostics: [] }),
+		getAgentsFiles: () => ({ agentsFiles: [] }),
+		getSystemPrompt: () => undefined,
+		getAppendSystemPrompt: () => [],
+		extendResources: () => {},
+		reload: async () => {},
+	};
+}
+
+/**
+ * Create an AgentSession for testing with proper setup and cleanup.
+ * Use this for e2e tests that need real LLM calls.
+ */
+export function createTestSession(options: TestSessionOptions = {}): TestSessionContext {
+	const tempDir = join(tmpdir(), `pi-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	mkdirSync(tempDir, { recursive: true });
+
+	const model = getModel("anthropic", "claude-sonnet-4-5")!;
+	const agent = new Agent({
+		getApiKey: () => API_KEY,
+		initialState: {
+			model,
+			systemPrompt: options.systemPrompt ?? "You are a helpful assistant. Be extremely concise.",
+			tools: createCodingTools(process.cwd()),
+		},
+	});
+
+	const sessionManager = options.inMemory ? SessionManager.inMemory() : SessionManager.create(tempDir);
+	const settingsManager = SettingsManager.create(tempDir, tempDir);
+
+	if (options.settingsOverrides) {
+		settingsManager.applyOverrides(options.settingsOverrides);
+	}
+
+	const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
+	const modelRegistry = ModelRegistry.create(authStorage, tempDir);
+
+	const session = new AgentSession({
+		agent,
+		sessionManager,
+		settingsManager,
+		cwd: tempDir,
+		modelRegistry,
+		resourceLoader: createTestResourceLoader(),
+	});
+
+	// Must subscribe to enable session persistence
+	session.subscribe(() => {});
+
+	const cleanup = () => {
+		session.dispose();
+		if (tempDir && existsSync(tempDir)) {
+			rmSync(tempDir, { recursive: true });
+		}
+	};
+
+	return { session, sessionManager, tempDir, cleanup };
+}
+
+/**
+ * Build a session tree for testing using SessionManager.
+ * Returns the IDs of all created entries.
+ *
+ * Example tree structure:
+ * ```
+ * u1 -> a1 -> u2 -> a2
+ *          -> u3 -> a3  (branch from a1)
+ * u4 -> a4              (another root)
+ * ```
+ */
+export function buildTestTree(
+	session: SessionManager,
+	structure: {
+		messages: Array<{ role: "user" | "assistant"; text: string; branchFrom?: string }>;
+	},
+): Map<string, string> {
+	const ids = new Map<string, string>();
+
+	for (const msg of structure.messages) {
+		if (msg.branchFrom) {
+			const branchFromId = ids.get(msg.branchFrom);
+			if (!branchFromId) {
+				throw new Error(`Cannot branch from unknown entry: ${msg.branchFrom}`);
+			}
+			session.branch(branchFromId);
+		}
+
+		const id =
+			msg.role === "user" ? session.appendMessage(userMsg(msg.text)) : session.appendMessage(assistantMsg(msg.text));
+
+		ids.set(msg.text, id);
+	}
+
+	return ids;
+}

package/pi.dev-src/pi-mono/coding-agent/tsconfig.examples.json

@@ -0,0 +1,16 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"noEmit": true,
+		"paths": {
+			"@mariozechner/pi-coding-agent": ["./src/index.ts"],
+			"@mariozechner/pi-coding-agent/hooks": ["./src/core/hooks/index.ts"],
+			"@mariozechner/pi-tui": ["../tui/src/index.ts"],
+			"@mariozechner/pi-ai": ["../ai/src/index.ts"],
+			"typebox": ["../../node_modules/typebox"]
+		},
+		"skipLibCheck": true
+	},
+	"include": ["examples/**/*.ts"],
+	"exclude": ["node_modules", "dist"]
+}

package/pi.dev-src/pi-mono/coding-agent/vitest.config.ts

@@ -0,0 +1,26 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vitest/config";
+
+const aiSrcIndex = fileURLToPath(new URL("../ai/src/index.ts", import.meta.url));
+const aiSrcOAuth = fileURLToPath(new URL("../ai/src/oauth.ts", import.meta.url));
+const agentSrcIndex = fileURLToPath(new URL("../agent/src/index.ts", import.meta.url));
+
+export default defineConfig({
+	test: {
+		globals: true,
+		environment: "node",
+		testTimeout: 30000,
+		server: {
+			deps: {
+				external: [/@silvia-odwyer\/photon-node/],
+			},
+		},
+	},
+	resolve: {
+		alias: [
+			{ find: /^@mariozechner\/pi-ai$/, replacement: aiSrcIndex },
+			{ find: /^@mariozechner\/pi-ai\/oauth$/, replacement: aiSrcOAuth },
+			{ find: /^@mariozechner\/pi-agent-core$/, replacement: agentSrcIndex },
+		],
+	},
+});

package/pi.dev-src/pi-mono/mom/dev.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -e
+
+CONTAINER_NAME="mom-sandbox"
+DATA_DIR="$(pwd)/data"
+
+# Create data directory if it doesn't exist
+mkdir -p "$DATA_DIR"
+
+# Check if container exists
+if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+    # Check if it's running
+    if ! docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+        echo "Starting existing container: $CONTAINER_NAME"
+        docker start "$CONTAINER_NAME"
+    else
+        echo "Container $CONTAINER_NAME already running"
+    fi
+else
+    echo "Creating container: $CONTAINER_NAME"
+    docker run -d \
+        --name "$CONTAINER_NAME" \
+        -v "$DATA_DIR:/workspace" \
+        alpine:latest \
+        tail -f /dev/null
+fi
+
+# Run mom with tsx watch mode
+echo "Starting mom in dev mode..."
+npx tsx --watch-path src --watch src/main.ts --sandbox=docker:$CONTAINER_NAME ./data

package/pi.dev-src/pi-mono/mom/docker.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+
+# Mom Docker Sandbox Management Script
+# Usage:
+#   ./docker.sh create <data-dir>   - Create and start the container
+#   ./docker.sh start               - Start the container
+#   ./docker.sh stop                - Stop the container
+#   ./docker.sh remove              - Remove the container
+#   ./docker.sh status              - Check container status
+#   ./docker.sh shell               - Open a shell in the container
+
+CONTAINER_NAME="mom-sandbox"
+IMAGE="alpine:latest"
+
+case "$1" in
+  create)
+    if [ -z "$2" ]; then
+      echo "Usage: $0 create <data-dir>"
+      echo "Example: $0 create ./data"
+      exit 1
+    fi
+    
+    DATA_DIR=$(cd "$2" && pwd)
+    
+    if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+      echo "Container '${CONTAINER_NAME}' already exists. Remove it first with: $0 remove"
+      exit 1
+    fi
+    
+    echo "Creating container '${CONTAINER_NAME}'..."
+    echo "  Data dir: ${DATA_DIR} -> /workspace"
+    
+    docker run -d \
+      --name "$CONTAINER_NAME" \
+      -v "${DATA_DIR}:/workspace" \
+      "$IMAGE" \
+      tail -f /dev/null
+    
+    if [ $? -eq 0 ]; then
+      echo "Container created and running."
+      echo ""
+      echo "Run mom with: mom --sandbox=docker:${CONTAINER_NAME} $2"
+    else
+      echo "Failed to create container."
+      exit 1
+    fi
+    ;;
+    
+  start)
+    echo "Starting container '${CONTAINER_NAME}'..."
+    docker start "$CONTAINER_NAME"
+    ;;
+    
+  stop)
+    echo "Stopping container '${CONTAINER_NAME}'..."
+    docker stop "$CONTAINER_NAME"
+    ;;
+    
+  remove)
+    echo "Removing container '${CONTAINER_NAME}'..."
+    docker rm -f "$CONTAINER_NAME"
+    ;;
+    
+  status)
+    if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+      echo "Container '${CONTAINER_NAME}' is running."
+      docker ps --filter "name=${CONTAINER_NAME}" --format "table {{.ID}}\t{{.Image}}\t{{.Status}}"
+    elif docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+      echo "Container '${CONTAINER_NAME}' exists but is not running."
+      echo "Start it with: $0 start"
+    else
+      echo "Container '${CONTAINER_NAME}' does not exist."
+      echo "Create it with: $0 create <data-dir>"
+    fi
+    ;;
+    
+  shell)
+    echo "Opening shell in '${CONTAINER_NAME}'..."
+    docker exec -it "$CONTAINER_NAME" /bin/sh
+    ;;
+    
+  *)
+    echo "Mom Docker Sandbox Management"
+    echo ""
+    echo "Usage: $0 <command> [args]"
+    echo ""
+    echo "Commands:"
+    echo "  create <data-dir>  - Create and start the container"
+    echo "  start              - Start the container"
+    echo "  stop               - Stop the container"  
+    echo "  remove             - Remove the container"
+    echo "  status             - Check container status"
+    echo "  shell              - Open a shell in the container"
+    ;;
+esac