@dyyz1993/pi-coding-agent 0.74.46 → 0.74.48

package/dist/extensions/coordinator/types.ts

@@ -5,68 +5,76 @@ export const COORDINATOR_CHANNEL_NAME = "coordinator";
 export type SessionStatus = "idle" | "streaming" | "stopped" | "completed";
 
 export interface DelegatedTask {
-	sessionId: string;
-	title: string;
-	task: string;
-	projectPath: string;
-	dispatchedAt: number;
-	status: SessionStatus;
-	completedAt?: number;
-	result?: string;
+  sessionId: string;
+  title: string;
+  task: string;
+  projectPath: string;
+  dispatchedAt: number;
+  status: SessionStatus;
+  completedAt?: number;
+  result?: string;
 }
 
 export interface DelegateCreateResult {
-	sessionId: string;
-	status: "started" | "already_running";
+  sessionId: string;
+  status: "started" | "already_running";
 }
 
 export interface DelegateSendResult {
-	delivered: boolean;
-	targetStatus: "active" | "started" | "not_found";
+  delivered: boolean;
+  targetStatus: "active" | "started" | "not_found";
 }
 
 export interface DelegateListResult {
-	tasks: DelegatedTask[];
+  tasks: DelegatedTask[];
 }
 
 export interface DelegateStatusExt {
-	task: DelegatedTask | null;
-	isCompacting?: boolean;
-	contextUsage?: { tokens: number | null; contextWindow: number; percent: number | null };
+  task: DelegatedTask | null;
+  isCompacting?: boolean;
+  contextUsage?: { tokens: number | null; contextWindow: number; percent: number | null };
 }
 
 export interface CoordinatorChannelContract extends ChannelContract {
-	methods: {
-		session_delegate: {
-			params: { task: string; title?: string };
-			return: DelegateCreateResult;
-		};
-		session_delegate_send: {
-			params: { targetSessionId: string; message: string };
-			return: DelegateSendResult;
-		};
-		session_delegate_status: {
-			params: { sessionId: string };
-			return: DelegateStatusExt;
-		};
-		session_delegate_list: {
-			params: Record<string, never>;
-			return: DelegateListResult;
-		};
-		session_delegate_stop: {
-			params: { sessionId: string };
-			return: { ok: boolean };
-		};
-		session_delegate_fork: {
-			params: { sessionId: string; task: string; title?: string };
-			return: DelegateCreateResult;
-		};
-	};
-	events: {
-		message_received: { fromSessionId: string; message: string };
-		task_started: { sessionId: string; title: string; task: string };
-		task_stopped: { sessionId: string };
-		task_completed: { sessionId: string; result?: string };
-		task_error: { sessionId: string; error: string };
-	};
+  methods: {
+    session_delegate: {
+      params: { task: string; title?: string; projectPath?: string };
+      return: DelegateCreateResult;
+    };
+    session_delegate_send: {
+      params: { targetSessionId: string; message: string };
+      return: DelegateSendResult;
+    };
+    session_delegate_status: {
+      params: { sessionId: string };
+      return: DelegateStatusExt;
+    };
+    session_delegate_list: {
+      params: Record<string, never>;
+      return: DelegateListResult;
+    };
+    session_delegate_stop: {
+      params: { sessionId: string };
+      return: { ok: boolean };
+    };
+    session_delegate_remove: {
+      params: { sessionId: string };
+      return: { ok: boolean };
+    };
+    session_delegate_clear_stopped: {
+      params: Record<string, never>;
+      return: { removed: number };
+    };
+    session_delegate_fork: {
+      params: { sessionId: string; task: string; title?: string; projectPath?: string };
+      return: DelegateCreateResult;
+    };
+  };
+  events: {
+    message_received: { fromSessionId: string; message: string };
+    task_started: { sessionId: string; title: string; task: string };
+    task_stopped: { sessionId: string };
+    task_completed: { sessionId: string; result?: string };
+    task_error: { sessionId: string; error: string };
+  };
 }

package/dist/extensions/hooks-engine/index.ts

@@ -193,6 +193,9 @@ export default function hooksEngine(pi: ExtensionAPI): void {
 
 			if (promptResults.length > 0) {
 				console.log("[hook] Prompts to inject:", promptResults);
+				for (const prompt of promptResults) {
+					pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				}
 			}
 
 			return undefined;

package/dist/extensions/lsp/lsp/client/smart-file-tracker.ts

@@ -0,0 +1,302 @@
+import { extname } from "node:path";
+
+export interface SmartFileTrackerOptions {
+	maxOpenFiles?: number;
+	now?: () => number;
+	priorityMap?: Record<string, number>;
+	excludedExtensions?: Set<string>;
+}
+
+export interface MemoryUsage {
+	heapUsed: number;
+	heapTotal: number;
+}
+
+export interface TrackerStatistics {
+	totalOpens: number;
+	totalEvictions: number;
+	evictionReasons: Array<"window_full" | "memory_pressure" | "excluded_type">;
+	accessCounts: Map<string, number>;
+	openFileCount: number;
+}
+
+interface TrackedFile {
+	filePath: string;
+	lastAccess: number;
+	modifiedTime: number;
+	accessCount: number;
+	priority: number;
+}
+
+// Default priority map for common file types (higher = more important)
+const DEFAULT_PRIORITY_MAP: Record<string, number> = {
+	// TypeScript/JavaScript (highest)
+	".ts": 100,
+	".tsx": 100,
+	".js": 90,
+	".jsx": 90,
+	".mjs": 90,
+	".cjs": 90,
+
+	// Framework files
+	".vue": 95,
+	".svelte": 95,
+
+	// Other languages
+	".py": 80,
+	".rs": 80,
+	".go": 80,
+	".java": 75,
+	".kt": 75,
+	".c": 70,
+	".cpp": 70,
+	".h": 70,
+	".hpp": 70,
+	".cs": 70,
+
+	// Config files
+	".json": 30,
+	".yaml": 30,
+	".yml": 30,
+	".toml": 30,
+
+	// Documentation
+	".md": 20,
+
+	// Text files
+	".txt": 10,
+};
+
+	// Default excluded file types (never tracked)
+const DEFAULT_EXCLUDED_EXTENSIONS: Set<string> = new Set([
+	".log",
+	".bak",
+	".tmp",
+	".temp",
+	".swp",
+	".cache",
+	".DS_Store",
+	".map",
+	".lock",
+	".pid",
+	// Special files without extension
+	".gitignore",
+	".gitattributes",
+	".gitmodules",
+	".editorconfig",
+	".eslintrc",
+	".prettierrc",
+]);
+
+// Memory thresholds (in bytes)
+const HIGH_MEMORY_THRESHOLD = 3_000_000_000; // 3GB
+const CRITICAL_MEMORY_THRESHOLD = 3_500_000_000; // 3.5GB
+const BASE_MAX_FILES = 30;
+const HIGH_MEMORY_MAX_FILES = 10;
+const CRITICAL_MEMORY_MAX_FILES = 5;
+
+export interface SmartFileTracker {
+	open(filePath: string, onClose: (file: string) => void, mtime?: number): void;
+	getOpenFiles(): string[];
+	closeAll(onClose: (file: string) => void): void;
+	updateMemoryUsage(usage: MemoryUsage): void;
+	getStatistics(): TrackerStatistics;
+}
+
+export function createSmartFileTracker(options: SmartFileTrackerOptions = {}): SmartFileTracker {
+	const baseMaxOpenFiles = options.maxOpenFiles ?? BASE_MAX_FILES;
+	const now = options.now ?? (() => Date.now());
+	const priorityMap = options.priorityMap ?? DEFAULT_PRIORITY_MAP;
+	const excludedExtensions = options.excludedExtensions ?? DEFAULT_EXCLUDED_EXTENSIONS;
+
+	const files = new Map<string, TrackedFile>();
+	const stats: TrackerStatistics = {
+		totalOpens: 0,
+		totalEvictions: 0,
+		evictionReasons: [],
+		accessCounts: new Map(),
+		openFileCount: 0,
+	};
+
+	let memoryUsage: MemoryUsage = {
+		heapUsed: 0,
+		heapTotal: 0,
+	};
+
+	// Calculate current max files based on memory pressure
+	function getCurrentMaxFiles(): number {
+		if (!memoryUsage.heapUsed || !memoryUsage.heapTotal) {
+			return baseMaxOpenFiles;
+		}
+
+		const memoryRatio = memoryUsage.heapUsed / memoryUsage.heapTotal;
+
+		if (memoryRatio > CRITICAL_MEMORY_THRESHOLD / memoryUsage.heapTotal) {
+			return Math.min(CRITICAL_MEMORY_MAX_FILES, baseMaxOpenFiles);
+		}
+
+		if (memoryRatio > HIGH_MEMORY_THRESHOLD / memoryUsage.heapTotal) {
+			return Math.min(HIGH_MEMORY_MAX_FILES, baseMaxOpenFiles);
+		}
+
+		return baseMaxOpenFiles;
+	}
+
+	// Get file priority based on extension
+	function getFilePriority(filePath: string): number {
+		const ext = extname(filePath).toLowerCase();
+		return priorityMap[ext] ?? 50; // Default priority for unknown types
+	}
+
+	// Check if file should be excluded
+	function isExcluded(filePath: string): boolean {
+		const ext = extname(filePath).toLowerCase();
+		if (excludedExtensions.has(ext)) {
+			return true;
+		}
+
+		// Check excluded file names (files without extension like .gitignore)
+		const basename = filePath.split("/").pop() ?? filePath;
+		if (excludedExtensions.has(basename)) {
+			return true;
+		}
+
+		return false;
+	}
+
+	// Sort files by priority (higher first), then by modified time (newer first), then by last access
+	function getSortedFiles(): TrackedFile[] {
+		return Array.from(files.values()).sort((a, b) => {
+			// Higher priority first
+			if (b.priority !== a.priority) {
+				return b.priority - a.priority;
+			}
+			// Newer modified time first
+			if (b.modifiedTime !== a.modifiedTime) {
+				return b.modifiedTime - a.modifiedTime;
+			}
+			// More recently accessed first
+			if (b.lastAccess !== a.lastAccess) {
+				return b.lastAccess - a.lastAccess;
+			}
+			// Higher access count first
+			return b.accessCount - a.accessCount;
+		});
+	}
+
+	// Evict lowest priority file(s) to fit new file
+	function evictIfNeeded(onClose: (file: string) => void): void {
+		const currentMax = getCurrentMaxFiles();
+		// Evict if we're at or over the limit (before adding new file)
+		while (files.size >= currentMax) {
+			const sorted = getSortedFiles();
+			const lowest = sorted[sorted.length - 1]; // Last element has lowest priority
+
+			if (!lowest) {
+				break;
+			}
+
+			files.delete(lowest.filePath);
+			onClose(lowest.filePath);
+
+			stats.totalEvictions++;
+			stats.evictionReasons.push("window_full");
+			stats.openFileCount = files.size;
+
+			// If memory is high, evict multiple files
+			const memoryRatio = memoryUsage.heapUsed / memoryUsage.heapTotal;
+			if (memoryRatio > HIGH_MEMORY_THRESHOLD / memoryUsage.heapTotal && files.size > currentMax / 2) {
+				continue; // Keep evicting
+			}
+
+			break;
+		}
+	}
+
+	// Evict files to fit within memory constraints
+	function evictForMemory(onClose?: (file: string) => void): void {
+		const currentMax = getCurrentMaxFiles();
+		while (files.size > currentMax) {
+			const sorted = getSortedFiles();
+			const lowest = sorted[sorted.length - 1];
+
+			if (!lowest) {
+				break;
+			}
+
+			files.delete(lowest.filePath);
+			if (onClose) {
+				onClose(lowest.filePath);
+			}
+
+			stats.totalEvictions++;
+			stats.evictionReasons.push("memory_pressure");
+			stats.openFileCount = files.size;
+		}
+	}
+
+	return {
+		open(filePath: string, onClose: (file: string) => void, mtime?: number): void {
+			// Check if file is excluded
+			if (isExcluded(filePath)) {
+				onClose(filePath);
+				stats.totalEvictions++;
+				stats.evictionReasons.push("excluded_type");
+				return;
+			}
+
+			stats.totalOpens++;
+
+			// Update access count
+			const currentCount = stats.accessCounts.get(filePath) ?? 0;
+			stats.accessCounts.set(filePath, currentCount + 1);
+
+			// If file already exists, update its metadata
+			if (files.has(filePath)) {
+				const entry = files.get(filePath)!;
+				entry.lastAccess = now();
+				entry.modifiedTime = mtime ?? entry.modifiedTime;
+				entry.accessCount++;
+				return;
+			}
+
+			// Evict files if needed (before adding new file)
+			evictIfNeeded(onClose);
+
+			// Add new file
+			const newFile: TrackedFile = {
+				filePath,
+				lastAccess: now(),
+				modifiedTime: mtime ?? now(),
+				accessCount: 1,
+				priority: getFilePriority(filePath),
+			};
+
+			files.set(filePath, newFile);
+			stats.openFileCount = files.size;
+		},
+
+		getOpenFiles(): string[] {
+			const sorted = getSortedFiles();
+			return sorted.map((f) => f.filePath);
+		},
+
+		closeAll(onClose: (file: string) => void): void {
+			for (const filePath of files.keys()) {
+				onClose(filePath);
+			}
+			files.clear();
+			stats.openFileCount = 0;
+		},
+
+		updateMemoryUsage(usage: MemoryUsage): void {
+			memoryUsage = usage;
+			// Evict files if memory pressure increased window size
+			evictForMemory();
+		},
+
+		getStatistics(): TrackerStatistics {
+			return { ...stats, accessCounts: new Map(stats.accessCounts) };
+		},
+	};
+}

package/dist/extensions/lsp/lsp/index.ts

@@ -71,15 +71,21 @@ export default function lspExtension(pi: ExtensionAPI): void {
 			})),
 		}));
 
-		pi.sendMessage(
-			{
-				customType: "lsp_diagnostics",
-				content: `[LSP] Post-edit diagnostics found issues in ${results.length} file(s): ${summary}.\nPlease review and fix the issues listed below.`,
-				display: true,
-				details: { files: fileSummaries },
-			},
-			{ triggerTurn: true },
-		);
+		try {
+			pi.sendMessage(
+				{
+					customType: "lsp_diagnostics",
+					content: `[LSP] Post-edit diagnostics found issues in ${results.length} file(s): ${summary}.\nPlease review and fix the issues listed below.`,
+					display: true,
+					details: { files: fileSummaries },
+				},
+				{ triggerTurn: true },
+			);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			if (msg.includes("stale")) return;
+			throw err;
+		}
 	});
 
 	let idleCleanupTimer: ReturnType<typeof setTimeout> | undefined;

package/dist/extensions/lsp/lsp/lsp-clangd-e2e.test.ts

@@ -0,0 +1,229 @@
+import { tmpdir } from "node:os";
+import { mkdir, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it, vi, beforeAll, afterAll } from "vitest";
+import type { ExtensionAPI } from "@dyyz1993/pi-coding-agent";
+import lspExtensionDefault from "./index.js";
+
+const TEST_DIR = "/tmp/lsp-clangd-test";
+const TEST_FILE = "test.c";
+
+function createMockPi() {
+	const handlers: Record<string, Array<(event: any, ctx: any) => any>> = {};
+	const registeredTools = new Map<string, any>();
+	const channelSendFn = vi.fn();
+	const registerCommandFn = vi.fn();
+	let channelOnReceiveHandler: ((data: unknown) => void) | null = null;
+	let currentChannel: {
+		name: string;
+		send: (data: unknown) => void;
+		onReceive: (handler: (data: unknown) => void) => () => void;
+		invoke: (data: unknown, timeoutMs?: number) => Promise<unknown>;
+		call: (method: string, params: Record<string, unknown>, timeoutMs?: number) => Promise<unknown>;
+	} | null = null;
+
+	const pi = {
+		on: vi.fn((event: string, handler: any) => {
+			if (!handlers[event]) handlers[event] = [];
+			handlers[event].push(handler);
+		}),
+		callLLM: vi.fn(async () => "{}"),
+		callLLMStructured: vi.fn(async () => ({})),
+		forkAgent: vi.fn(async () => ({ text: "", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 } })),
+		once: vi.fn(),
+		emit: vi.fn(),
+		setStatus: vi.fn(),
+		registerProvider: vi.fn(),
+		unregisterProvider: vi.fn(),
+		events: { on: vi.fn(), off: vi.fn(), emit: vi.fn(), once: vi.fn() },
+		registerChannel: vi.fn(() => {
+			currentChannel = {
+				name: "lsp",
+				send: channelSendFn,
+				onReceive: vi.fn((handler: (data: unknown) => void) => {
+					channelOnReceiveHandler = handler;
+					return () => { channelOnReceiveHandler = null; };
+				}),
+				invoke: vi.fn(async (data: unknown) => {
+					if (!channelOnReceiveHandler) return {};
+					const msg = data as Record<string, unknown>;
+					const invokeId = msg.__invokeId as string;
+					return new Promise((resolve) => {
+						const orig = channelSendFn.getMockImplementation() ?? channelSendFn;
+						channelSendFn.mockImplementation((response: unknown) => {
+							const resp = response as Record<string, unknown>;
+							if (resp?.invokeId === invokeId) {
+								channelSendFn.mockImplementation(orig as any);
+								resolve(response);
+							}
+						});
+						channelOnReceiveHandler!(data);
+					});
+				}),
+				call: vi.fn(async (method: string, params: Record<string, unknown>, _timeoutMs?: number) => {
+					if (!channelOnReceiveHandler) return {};
+					const invokeId = `invoke_${method}_${Date.now()}`;
+					return new Promise((resolve) => {
+						const orig = channelSendFn.getMockImplementation() ?? channelSendFn;
+						channelSendFn.mockImplementation((response: unknown) => {
+							const resp = response as Record<string, unknown>;
+							if (resp?.invokeId === invokeId) {
+								channelSendFn.mockImplementation(orig as any);
+								resolve(response);
+							}
+						});
+						channelOnReceiveHandler!({ __call: method, invokeId, ...params });
+					});
+				}),
+			};
+			return currentChannel;
+		}),
+		registerTool: vi.fn((tool: any) => {
+			registeredTools.set(tool.name, tool);
+		}),
+		registerCommand: registerCommandFn,
+		appendEntry: vi.fn(),
+		sendMessage: vi.fn(),
+		off: vi.fn(),
+	} as unknown as ExtensionAPI;
+
+	return {
+		pi,
+		handlers,
+		registeredTools,
+		channelSend: channelSendFn,
+		registerCommandFn,
+		getCurrentChannel: () => currentChannel,
+	};
+}
+
+async function fireSessionStart(
+	mock: ReturnType<typeof createMockPi>,
+	cwd: string,
+): Promise<void> {
+	for (const h of mock.handlers.session_start ?? []) {
+		await h(
+			{},
+			{
+				sessionManager: { getBranch: () => [] },
+				hasUI: false,
+				ui: { notify: vi.fn() },
+				cwd,
+				isIdle: () => true,
+				signal: undefined,
+				abort: () => {},
+				hasPendingMessages: () => false,
+				shutdown: () => {},
+				getContextUsage: () => undefined,
+				compact: () => {},
+				getSystemPrompt: () => "",
+				model: undefined,
+			},
+		);
+	}
+}
+
+async function fireSessionShutdown(mock: ReturnType<typeof createMockPi>): Promise<void> {
+	for (const h of mock.handlers.session_shutdown ?? []) {
+		await h({}, {});
+	}
+}
+
+async function fireToolResult(
+	mock: ReturnType<typeof createMockPi>,
+	filePath: string,
+	toolName: "write" | "edit" = "write",
+): Promise<any> {
+	const results: any[] = [];
+	for (const h of mock.handlers.tool_result ?? []) {
+		const result = await h(
+			{
+				type: "tool_result",
+				toolCallId: "tc_e2e_1",
+				toolName,
+				input: { path: filePath },
+				content: [{ type: "text", text: `File written: ${filePath}` }],
+				isError: false,
+				details: undefined,
+			},
+			{
+				cwd: TEST_DIR,
+				ui: { notify: vi.fn() },
+			},
+		);
+		if (result) results.push(result);
+	}
+	return results;
+}
+
+describe("clangd E2E integration", () => {
+	const originalCwd = process.cwd();
+
+	beforeAll(async () => {
+		await mkdir(join(TEST_DIR, ".pi"), { recursive: true });
+		await writeFile(join(TEST_DIR, ".pi", "lsp.json"), JSON.stringify({
+			servers: [
+				{
+					name: "clangd",
+					command: ["clangd"],
+					fileTypes: [".c", ".h", ".cpp", ".hpp", ".cc", ".cxx"],
+				},
+			],
+		}));
+		await writeFile(join(TEST_DIR, TEST_FILE), `#include <stdio.h>\n\nint main() {\n    int x = "hello";\n    printf("%d\\n", x);\n    return 0;\n}\n`);
+		process.chdir(TEST_DIR);
+	});
+
+	afterAll(async () => {
+		process.chdir(originalCwd);
+	});
+
+	it(
+		"starts clangd, detects type error in test.c via diagnostics",
+		async () => {
+			const mock = createMockPi();
+			lspExtensionDefault(mock.pi);
+
+			await fireSessionStart(mock, TEST_DIR);
+
+			const channel = mock.getCurrentChannel();
+			expect(channel).not.toBeNull();
+
+			const statusResult = await channel!.call("getStatus", {});
+			console.log("[e2e] Status after session_start:", JSON.stringify(statusResult, null, 2));
+
+			const status = statusResult as any;
+			expect(status.state).toBeDefined();
+
+			const readyServers = (status.servers as any[])?.filter((s: any) => s.state === "ready") ?? [];
+			console.log(`[e2e] Ready servers: ${readyServers.length}`);
+			for (const s of readyServers) {
+				console.log(`[e2e]   - ${s.name} [${(s.fileTypes ?? []).join(",")}] state=${s.state}`);
+			}
+
+			if (readyServers.length === 0) {
+				console.log("[e2e] No clangd server became ready — skipping diagnostics check");
+				console.log("[e2e] All servers:", JSON.stringify(status.servers, null, 2));
+			}
+
+			expect(readyServers.length).toBeGreaterThanOrEqual(1);
+
+			const toolResults = await fireToolResult(mock, TEST_FILE);
+			console.log("[e2e] tool_result handler results:", JSON.stringify(toolResults, null, 2));
+
+			const diagnosticsContent = toolResults.find(
+				(r: any) => r?.content?.some?.((c: any) => c.text?.includes("[LSP]")),
+			);
+			if (diagnosticsContent) {
+				console.log("[e2e] Diagnostics found in tool_result response:");
+				for (const c of diagnosticsContent.content) {
+					console.log(c.text);
+				}
+			}
+
+			await fireSessionShutdown(mock);
+			console.log("[e2e] Session shutdown complete");
+		},
+		30_000,
+	);
+});