@dyyz1993/pi-coding-agent 0.74.47 → 0.74.48

package/dist/extensions/lsp/lsp/utils/project-scanner.ts

@@ -5,8 +5,50 @@ import type { ResolvedLspServerConfig } from "../config/resolver.js";
 
 export interface ProjectScanResult {
 	discoveredExtensions: Set<string>;
+	fileCount?: number;
 }
 
+// Common source code file extensions to scan for
+// This prevents scanning unnecessary files like .bak, .log, .bin, etc.
+const COMMON_SOURCE_EXTENSIONS = new Set([
+	".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+	".vue", ".svelte", ".jsx",
+	".py", ".pyi",
+	".rs",
+	".go",
+	".java", ".kt", ".kts",
+	".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".hxx",
+	".cs", ".vb",
+	".php",
+	".rb",
+	".swift", ".m", ".mm",
+	".dart",
+	".lua",
+	".sh", ".bash", ".zsh",
+	".sql",
+	".graphql", ".gql",
+	".yaml", ".yml",
+	".toml",
+	".json",
+	".md",
+	".xml", ".html", ".htm", ".css", ".scss", ".less", ".sass",
+	".txt",
+]);
+
+// Directories to exclude from scanning (in addition to .git, node_modules)
+const EXCLUDED_DIRS = [
+	"node_modules", ".git", "target", "dist", "build", ".pi",
+	".next", ".nuxt", ".output", ".vercel",
+	"venv", "env", ".venv", "envs", ".envs", "__pycache__",
+	".vscode", ".idea",
+	"coverage", ".nyc_output",
+	".cache", "tmp", "temp",
+	".DS_Store", "Thumbs.db",
+];
+
+// Maximum files to scan before stopping
+const MAX_FILES_TO_SCAN = 5000;
+
 /**
  * Scan the project for file types present on disk.
  * Uses `git ls-files` when available (fast, respects .gitignore),
@@ -14,38 +56,76 @@ export interface ProjectScanResult {
  */
 export function scanProjectFileTypes(cwd: string): ProjectScanResult {
 	const extensions = new Set<string>();
+	let fileCount = 0;
 
 	// Strategy 1: git ls-files (fast, respects gitignore)
 	const gitFiles = tryGitLsFiles(cwd);
 	if (gitFiles.length > 0) {
 		for (const file of gitFiles) {
+			fileCount++;
+			if (fileCount > MAX_FILES_TO_SCAN) {
+				console.warn(`[lsp] Stopped scan after ${MAX_FILES_TO_SCAN} files (too many files)`);
+				break;
+			}
+
 			const ext = extname(file).toLowerCase();
-			if (ext) {
+			// Only collect common source code extensions
+			if (ext && COMMON_SOURCE_EXTENSIONS.has(ext)) {
 				extensions.add(ext);
 			}
 		}
-		return { discoveredExtensions: extensions };
+		console.log(`[lsp] Project scan found ${extensions.size} file types from ${fileCount} files (git mode)`);
+		return { discoveredExtensions: extensions, fileCount };
 	}
 
-	// Strategy 2: shallow find (maxdepth 3, skip node_modules etc.)
+	// Strategy 2: shallow find (maxdepth 3, skip many common dirs)
 	try {
-		const output = execSync(
-			'find . -maxdepth 3 -type f -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/target/*" -not -path "*/dist/*" -not -path "*/.pi/*" 2>/dev/null | head -2000',
-			{ cwd, timeout: 3000, encoding: "utf8" },
-		);
-		for (const line of output.split("\n")) {
+		const excludeArgs = EXCLUDED_DIRS.map((dir) => `-not -path "*/${dir}/*"`).join(" ");
+		const command = `find . -maxdepth 3 -type f ${excludeArgs} 2>/dev/null | head -${MAX_FILES_TO_SCAN}`;
+		const output = execSync(command, {
+			cwd,
+			timeout: 3000,
+			encoding: "utf8",
+		});
+
+		const lines = output.split("\n").filter(Boolean);
+		fileCount = 0;
+
+		for (const line of lines) {
 			const trimmed = line.trim();
 			if (!trimmed) continue;
+
+			fileCount++;
+
+			// Check memory usage periodically
+			if (fileCount % 1000 === 0) {
+				const memUsage = process.memoryUsage();
+				const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
+				const heapTotalMB = Math.round(memUsage.heapTotal / 1024 / 1024);
+
+				// If we're using >3GB of heap, stop scanning
+				if (heapUsedMB > 3000) {
+					console.warn(`[lsp] Stopping scan due to high memory usage (${heapUsedMB}MB heap used)`);
+					break;
+				}
+			}
+
 			const ext = extname(trimmed).toLowerCase();
-			if (ext) {
+			// Only collect common source code extensions
+			if (ext && COMMON_SOURCE_EXTENSIONS.has(ext)) {
 				extensions.add(ext);
 			}
 		}
-	} catch {
+
+		console.log(`[lsp] Project scan found ${extensions.size} file types from ${fileCount} files (find mode)`);
+	} catch (error) {
+		if (error instanceof Error) {
+			console.warn(`[lsp] Project scan failed: ${error.message}`);
+		}
 		// If scan fails, return empty — will fall back to starting all servers
 	}
 
-	return { discoveredExtensions: extensions };
+	return { discoveredExtensions: extensions, fileCount };
 }
 
 function tryGitLsFiles(cwd: string): string[] {
@@ -76,10 +156,17 @@ export function filterServersByProject(
 	servers: ResolvedLspServerConfig[],
 	scanResult: ProjectScanResult,
 ): ResolvedLspServerConfig[] {
-	const { discoveredExtensions } = scanResult;
+	const { discoveredExtensions, fileCount } = scanResult;
 
 	// Safe fallback: if scan found nothing, start everything
 	if (discoveredExtensions.size === 0) {
+		console.log(`[lsp] No file types discovered, starting all ${servers.length} servers`);
+		return servers;
+	}
+
+	// If we scanned very few files (<10), might be an empty project - start all servers
+	if (fileCount !== undefined && fileCount < 10) {
+		console.log(`[lsp] Only ${fileCount} files scanned, starting all ${servers.length} servers`);
 		return servers;
 	}
 
@@ -98,5 +185,7 @@ export function filterServersByProject(
 		}
 	}
 
+	console.log(`[lsp] Filtered to ${filtered.length}/${servers.length} servers based on project files`);
+
 	return filtered;
 }

package/dist/extensions/output-guard/index.ts

@@ -217,6 +217,9 @@ function saveFullOutput(content: string, ctx: ExtensionContext): string | undefi
 // ============================================================================
 
 export default function outputGuard(pi: ExtensionAPI) {
+	pi.setName("output-guard");
+	let truncatedCount = 0;
+	let limitAdjustedCount = 0;
 	// ------------------------------------------------------------------
 	// 1. Global truncation fallback via tool_result hook
 	//
@@ -255,6 +258,7 @@ export default function outputGuard(pi: ExtensionAPI) {
 
 		// Truncate
 		const result = truncateOutput(fullText, config, ctx);
+		truncatedCount++;
 
 		let finalContent = result.content;
 		if (result.truncated) {
@@ -262,6 +266,21 @@ export default function outputGuard(pi: ExtensionAPI) {
 			finalContent = finalContent + "\n\n" + notice;
 		}
 
+		console.debug(
+			`[output-guard] truncated tool "${event.toolName}": ${result.totalLines} lines / ${result.totalBytes} bytes → ${result.outputLines} lines / ${result.outputBytes} bytes (truncatedBy: ${result.truncatedBy ?? "none"}, path: ${result.fullOutputPath ?? "N/A"})`,
+		);
+		pi.appendEntry("output_guard_truncate", {
+			toolName: event.toolName,
+			totalLines: result.totalLines,
+			totalBytes: result.totalBytes,
+			outputLines: result.outputLines,
+			outputBytes: result.outputBytes,
+			truncated: result.truncated,
+			truncatedBy: result.truncatedBy,
+			fullOutputPath: result.fullOutputPath,
+			truncatedCount,
+		});
+
 		return {
 			content: [{ type: "text" as const, text: finalContent }],
 		};
@@ -281,7 +300,9 @@ export default function outputGuard(pi: ExtensionAPI) {
 		if (event.toolName === "find") {
 			const input = event.input as { limit?: number };
 			if (input.limit === undefined || input.limit > config.findLimit) {
+				console.debug(`[output-guard] capped find limit: ${input.limit ?? "unlimited"} → ${config.findLimit}`);
 				input.limit = config.findLimit;
+				limitAdjustedCount++;
 			}
 		}
 
@@ -289,7 +310,9 @@ export default function outputGuard(pi: ExtensionAPI) {
 		if (event.toolName === "ls") {
 			const input = event.input as { limit?: number };
 			if (input.limit === undefined || input.limit > config.lsLimit) {
+				console.debug(`[output-guard] capped ls limit: ${input.limit ?? "unlimited"} → ${config.lsLimit}`);
 				input.limit = config.lsLimit;
+				limitAdjustedCount++;
 			}
 		}
 	});
@@ -335,11 +358,18 @@ export default function outputGuard(pi: ExtensionAPI) {
 			try {
 				const buffer = await fs.readFile(absolutePath);
 
+				console.debug(`[output-guard] pdf_read: ${args.path} (${buffer.length} bytes, pages: ${args.maxPages ?? "all"})`);
+
 				// Dynamic import of pdf-parse (optional dependency)
 				let pdfParse: typeof import("pdf-parse") | undefined;
 				try {
 					pdfParse = (await import("pdf-parse")).default;
 				} catch {
+					console.debug("[output-guard] pdf_read failed: pdf-parse not installed");
+					pi.appendEntry("output_guard_pdf_error", {
+						path: args.path,
+						error: "pdf-parse not installed",
+					});
 					return {
 						content: [
 							{
@@ -354,6 +384,15 @@ export default function outputGuard(pi: ExtensionAPI) {
 				const data = await pdfParse(buffer);
 				let text = data.text;
 
+				console.debug(`[output-guard] pdf_read success: ${args.path} (${data.numpages} pages, ${text.length} chars extracted)`);
+				pi.appendEntry("output_guard_pdf_read", {
+					path: args.path,
+					pages: data.numpages,
+					chars: text.length,
+					title: data.info?.Title ?? null,
+					author: data.info?.Author ?? null,
+				});
+
 				// Add metadata header
 				const header = [
 					`PDF: ${args.path}`,

package/dist/extensions/preview/index.ts

@@ -101,6 +101,8 @@ const PreviewParams = Type.Object({
 	title: Type.Optional(Type.String({ description: "Optional display title for the card" })),
 });
 
+let previewId = 0;
+
 export default function (pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "preview",
@@ -118,8 +120,11 @@ export default function (pi: ExtensionAPI) {
 			ctx?: ExtensionContext,
 		): Promise<AgentToolResult<PreviewDetails>> {
 			const cwd = ctx?.cwd ?? process.cwd();
+			previewId++;
 
 			if (!params.source?.trim()) {
+				console.debug(`[preview] #${previewId} error: source is required`);
+				pi.appendEntry("preview", { id: previewId, status: "error", error: "source required" });
 				return {
 					content: [{ type: "text", text: "Error: source is required" }],
 					details: { source: "", resourceType: "text", status: "error", error: "source required" },
@@ -138,6 +143,8 @@ export default function (pi: ExtensionAPI) {
 							const reachable = await checkReachable(parsed.hostname, port);
 							if (!reachable) {
 								const msg = `Preview 失败：${parsed.host} 未在局域网开放，服务可能只监听 127.0.0.1。请将服务绑定到 0.0.0.0 后重试。`;
+								console.debug(`[preview] #${previewId} error: local address "${parsed.host}:${parsed.port || 80}" not reachable`);
+								pi.appendEntry("preview", { id: previewId, source: params.source, status: "error", error: "local address not reachable", host: parsed.host, port: parseInt(parsed.port || "80", 10) });
 								return {
 									content: [{ type: "text", text: msg }],
 									details: {
@@ -156,6 +163,8 @@ export default function (pi: ExtensionAPI) {
 					}
 				}
 
+				console.debug(`[preview] #${previewId} url: ${params.source}`);
+				pi.appendEntry("preview", { id: previewId, source: params.source, type: "url", status: "ok", title: params.title });
 				return {
 					content: [{ type: "text", text: `Preview: ${params.source} (url)` }],
 					details: {
@@ -169,6 +178,8 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			if (!absolutePath || !existsSync(absolutePath)) {
+				console.debug(`[preview] #${previewId} not_found: ${params.source}`);
+				pi.appendEntry("preview", { id: previewId, source: params.source, type: resourceType, status: "not_found" });
 				return {
 					content: [{ type: "text", text: `Preview: ${params.source} not found` }],
 					details: {
@@ -184,6 +195,8 @@ export default function (pi: ExtensionAPI) {
 
 			const stat = statSync(absolutePath);
 			if (stat.isDirectory()) {
+				console.debug(`[preview] #${previewId} error: ${params.source} is a directory`);
+				pi.appendEntry("preview", { id: previewId, source: params.source, type: resourceType, status: "error", error: "is a directory" });
 				return {
 					content: [{ type: "text", text: `Preview: ${params.source} is a directory` }],
 					details: {
@@ -204,6 +217,16 @@ export default function (pi: ExtensionAPI) {
 						? `${(stat.size / 1024).toFixed(1)}KB`
 						: `${stat.size}B`;
 
+			console.debug(`[preview] #${previewId} ok: ${params.source} (${resourceType}, ${sizeStr})`);
+			pi.appendEntry("preview", {
+				id: previewId,
+				source: params.source,
+				type: resourceType,
+				mimeType,
+				size: stat.size,
+				status: "ok",
+				title: params.title,
+			});
 			return {
 				content: [
 					{

package/dist/extensions/subagent-v2/extract-parent-todos.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Tests for extractParentTodos — extracts parent session's todo list
+ * from session history entries for read-only reference in sub-agents.
+ */
+import { describe, expect, it } from "vitest";
+import { extractParentTodos } from "./index.js";
+
+interface CustomEntry {
+	type: "custom";
+	customType: string;
+	data?: { todos: unknown[]; nextId?: number };
+}
+
+interface MessageEntry {
+	type: "message";
+	message: {
+		role: string;
+		toolName?: string;
+		details?: { todos: unknown[]; nextId?: number };
+	};
+}
+
+type Entry = CustomEntry | MessageEntry;
+
+function customEntry(customType: string, todos: unknown[], nextId = 1): CustomEntry {
+	return { type: "custom", customType, data: { todos, nextId } };
+}
+
+function toolResultEntry(details: { todos: unknown[]; nextId?: number }): MessageEntry {
+	return {
+		type: "message",
+		message: { role: "toolResult", toolName: "todo", details },
+	};
+}
+
+function userMessageEntry(): MessageEntry {
+	return { type: "message", message: { role: "user" } };
+}
+
+function assistantMessageEntry(): MessageEntry {
+	return { type: "message", message: { role: "assistant" } };
+}
+
+describe("extractParentTodos", () => {
+	it("returns empty array when branch is empty", () => {
+		expect(extractParentTodos([])).toEqual([]);
+	});
+
+	it("returns empty array when branch has no todo entries", () => {
+		const branch: Entry[] = [userMessageEntry(), assistantMessageEntry()];
+		expect(extractParentTodos(branch)).toEqual([]);
+	});
+
+	it("returns active todos from custom entry", () => {
+		const todos = [
+			{ id: 1, text: "Fix login", done: false },
+			{ id: 2, text: "Add tests", done: false },
+		];
+		const branch: Entry[] = [customEntry("todo", todos)];
+		const result = extractParentTodos(branch);
+		expect(result).toHaveLength(2);
+		expect(result[0]).toEqual({ id: 1, text: "Fix login", priority: undefined, done: false });
+		expect(result[1]).toEqual({ id: 2, text: "Add tests", priority: undefined, done: false });
+	});
+
+	it("filters out done todos", () => {
+		const todos = [
+			{ id: 1, text: "Done task", done: true },
+			{ id: 2, text: "Active task", done: false },
+		];
+		const branch: Entry[] = [customEntry("todo", todos)];
+		const result = extractParentTodos(branch);
+		expect(result).toHaveLength(1);
+		expect(result[0].id).toBe(2);
+	});
+
+	it("filters out deleted todos", () => {
+		const todos = [
+			{ id: 1, text: "Deleted task", done: false, deleted: true },
+			{ id: 2, text: "Active task", done: false },
+		];
+		const branch: Entry[] = [customEntry("todo", todos)];
+		const result = extractParentTodos(branch);
+		expect(result).toHaveLength(1);
+		expect(result[0].id).toBe(2);
+	});
+
+	it("returns the latest todo list from toolResult messages (overwrites previous)", () => {
+		const earlyTodos = [{ id: 1, text: "Old task", done: false }];
+		const latestTodos = [
+			{ id: 1, text: "Old task", done: true },
+			{ id: 2, text: "New task", done: false },
+		];
+		const branch: Entry[] = [customEntry("todo", earlyTodos), toolResultEntry({ todos: latestTodos, nextId: 3 })];
+		const result = extractParentTodos(branch);
+		expect(result).toHaveLength(1);
+		expect(result[0].id).toBe(2);
+		expect(result[0].text).toBe("New task");
+	});
+
+	it("preserves priority field", () => {
+		const todos = [
+			{ id: 1, text: "High priority", done: false, priority: "high" },
+			{ id: 2, text: "Low priority", done: false, priority: "low" },
+			{ id: 3, text: "Medium priority", done: false },
+		];
+		const branch: Entry[] = [customEntry("todo", todos)];
+		const result = extractParentTodos(branch);
+		expect(result[0].priority).toBe("high");
+		expect(result[1].priority).toBe("low");
+		expect(result[2].priority).toBeUndefined();
+	});
+
+	it("ignores non-todo entries interspersed", () => {
+		const todos = [{ id: 1, text: "The only task", done: false }];
+		const branch: Entry[] = [
+			userMessageEntry(),
+			assistantMessageEntry(),
+			customEntry("some_other_thing", [{ unrelated: true }]),
+			customEntry("todo", todos),
+			userMessageEntry(),
+		];
+		const result = extractParentTodos(branch);
+		expect(result).toHaveLength(1);
+		expect(result[0].text).toBe("The only task");
+	});
+
+	it("handles toolResult with no matching details gracefully", () => {
+		const branch: Entry[] = [
+			{
+				type: "message",
+				message: { role: "toolResult", toolName: "bash", details: { exitCode: 0 } },
+			},
+		];
+		expect(extractParentTodos(branch)).toEqual([]);
+	});
+
+	it("returns empty array when all todos are done", () => {
+		const todos = [
+			{ id: 1, text: "Done A", done: true },
+			{ id: 2, text: "Done B", done: true, deleted: true },
+		];
+		const branch: Entry[] = [customEntry("todo", todos)];
+		expect(extractParentTodos(branch)).toEqual([]);
+	});
+});