pi-lens 3.8.21 → 3.8.23

package/clients/dispatch/runners/tree-sitter.ts

@@ -8,7 +8,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { RuleCache } from "../../cache/rule-cache.js";
+import { getSourceFiles } from "../../scan-utils.js";
 import { TreeSitterClient } from "../../tree-sitter-client.js";
+import { logTreeSitter } from "../../tree-sitter-logger.js";
 import { classifyDefect } from "../diagnostic-taxonomy.js";
 import {
 	queryLoader,
@@ -20,11 +22,300 @@ import type {
 	RunnerDefinition,
 	RunnerResult,
 } from "../types.js";
+import { PRIORITY } from "../priorities.js";
 
 // Module-level singleton: web-tree-sitter WASM must only be initialized once per process.
 // Creating a new TreeSitterClient() on every write resets TRANSFER_BUFFER (a module-level
 // WASM pointer) — concurrent writes race on _ts_init() and corrupt shared WASM state → crash.
 let _sharedClient: TreeSitterClient | null = null;
+const entitySnapshotByFile = new Map<string, Map<string, string>>();
+const blastFileCache = new Map<string, { expiresAt: number; files: string[] }>();
+const blastCooldownByFile = new Map<string, number>();
+const BLAST_CACHE_TTL_MS = 30_000;
+const MAX_BLAST_FILES = 300;
+const MAX_BLAST_ENTITIES = 8;
+const BLAST_MAX_FILE_BYTES = 128 * 1024;
+const BLAST_MAX_TOTAL_BYTES = 2 * 1024 * 1024;
+const BLAST_MAX_ELAPSED_MS = 120;
+const BLAST_COOLDOWN_MS = 5_000;
+
+interface EntityQueryDef {
+	id: string;
+	kind: string;
+	query: string;
+}
+
+const ENTITY_QUERIES: Partial<Record<string, EntityQueryDef[]>> = {
+	typescript: [
+		{
+			id: "entity-ts-function",
+			kind: "function",
+			query: "(function_declaration name: (identifier) @NAME)",
+		},
+		{
+			id: "entity-ts-class",
+			kind: "class",
+			query: "(class_declaration name: (type_identifier) @NAME)",
+		},
+		{
+			id: "entity-ts-method",
+			kind: "method",
+			query: "(method_definition name: (property_identifier) @NAME)",
+		},
+	],
+	javascript: [
+		{
+			id: "entity-js-function",
+			kind: "function",
+			query: "(function_declaration name: (identifier) @NAME)",
+		},
+		{
+			id: "entity-js-class",
+			kind: "class",
+			query: "(class_declaration name: (identifier) @NAME)",
+		},
+		{
+			id: "entity-js-method",
+			kind: "method",
+			query: "(method_definition name: (property_identifier) @NAME)",
+		},
+	],
+	python: [
+		{
+			id: "entity-py-function",
+			kind: "function",
+			query: "(function_definition name: (identifier) @NAME)",
+		},
+		{
+			id: "entity-py-class",
+			kind: "class",
+			query: "(class_definition name: (identifier) @NAME)",
+		},
+	],
+	go: [
+		{
+			id: "entity-go-function",
+			kind: "function",
+			query: "(function_declaration name: (identifier) @NAME)",
+		},
+		{
+			id: "entity-go-method",
+			kind: "method",
+			query: "(method_declaration name: (field_identifier) @NAME)",
+		},
+		{
+			id: "entity-go-type",
+			kind: "type",
+			query: "(type_spec name: (type_identifier) @NAME)",
+		},
+	],
+	rust: [
+		{
+			id: "entity-rs-function",
+			kind: "function",
+			query: "(function_item name: (identifier) @NAME)",
+		},
+		{
+			id: "entity-rs-struct",
+			kind: "struct",
+			query: "(struct_item name: (type_identifier) @NAME)",
+		},
+		{
+			id: "entity-rs-enum",
+			kind: "enum",
+			query: "(enum_item name: (type_identifier) @NAME)",
+		},
+	],
+	ruby: [
+		{
+			id: "entity-rb-method",
+			kind: "method",
+			query: "(method name: (identifier) @NAME)",
+		},
+		{
+			id: "entity-rb-class",
+			kind: "class",
+			query: "(class name: (constant) @NAME)",
+		},
+		{
+			id: "entity-rb-module",
+			kind: "module",
+			query: "(module name: (constant) @NAME)",
+		},
+	],
+};
+
+function escapeRegex(name: string): string {
+	return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+async function extractEntitySnapshot(
+	client: TreeSitterClient,
+	filePath: string,
+	languageId: string,
+): Promise<Map<string, string>> {
+	const defs = ENTITY_QUERIES[languageId] ?? [];
+	const snapshot = new Map<string, string>();
+
+	for (const def of defs) {
+		const matches = await client.runQueryOnFile(
+			{
+				id: def.id,
+				name: def.id,
+				severity: "info",
+				category: "entity",
+				language: languageId,
+				message: "",
+				query: def.query,
+				metavars: ["NAME"],
+				has_fix: false,
+				filePath: "",
+			},
+			filePath,
+			languageId,
+			{ maxResults: 200 },
+		);
+
+		for (const match of matches) {
+			const name = match.captures.NAME?.trim();
+			if (!name) continue;
+			const key = `${def.kind}:${name}`;
+			snapshot.set(key, `${match.line}:${match.matchedText.slice(0, 400)}`);
+		}
+	}
+
+	return snapshot;
+}
+
+function diffEntitySnapshot(
+	prev: Map<string, string> | undefined,
+	next: Map<string, string>,
+): { added: string[]; removed: string[]; modified: string[] } {
+	if (!prev) {
+		return { added: [...next.keys()], removed: [], modified: [] };
+	}
+
+	const added: string[] = [];
+	const removed: string[] = [];
+	const modified: string[] = [];
+
+	for (const [key, value] of next.entries()) {
+		if (!prev.has(key)) {
+			added.push(key);
+			continue;
+		}
+		if (prev.get(key) !== value) {
+			modified.push(key);
+		}
+	}
+
+	for (const key of prev.keys()) {
+		if (!next.has(key)) {
+			removed.push(key);
+		}
+	}
+
+	return { added, removed, modified };
+}
+
+function getBlastFiles(cwd: string): string[] {
+	const now = Date.now();
+	const cached = blastFileCache.get(cwd);
+	if (cached && cached.expiresAt > now) return cached.files;
+
+	const files = getSourceFiles(cwd).slice(0, MAX_BLAST_FILES);
+	blastFileCache.set(cwd, { files, expiresAt: now + BLAST_CACHE_TTL_MS });
+	return files;
+}
+
+function computeBlastRadius(
+	entityNames: string[],
+	filePath: string,
+	cwd: string,
+): {
+	entities: Array<{ entity: string; dependentFiles: number; references: number }>;
+	scannedFiles: number;
+	scannedBytes: number;
+	totalCandidates: number;
+	truncated: boolean;
+	elapsedMs: number;
+} {
+	const startedAt = Date.now();
+	const limited = entityNames.slice(0, MAX_BLAST_ENTITIES);
+	if (limited.length === 0) {
+		return {
+			entities: [],
+			scannedFiles: 0,
+			scannedBytes: 0,
+			totalCandidates: 0,
+			truncated: false,
+			elapsedMs: 0,
+		};
+	}
+
+	const regexByEntity = new Map(
+		limited.map((name) => [name, new RegExp(`\\b${escapeRegex(name)}\\b`, "g")]),
+	);
+	const files = getBlastFiles(cwd);
+	const stats = new Map(
+		limited.map((name) => [name, { dependentFiles: 0, references: 0 }]),
+	);
+	let scannedFiles = 0;
+	let scannedBytes = 0;
+	let truncated = false;
+
+	for (const candidate of files) {
+		if (Date.now() - startedAt > BLAST_MAX_ELAPSED_MS) {
+			truncated = true;
+			break;
+		}
+
+		if (path.resolve(candidate) === path.resolve(filePath)) continue;
+		let size = 0;
+		try {
+			size = fs.statSync(candidate).size;
+		} catch {
+			continue;
+		}
+		if (size > BLAST_MAX_FILE_BYTES) continue;
+		if (scannedBytes + size > BLAST_MAX_TOTAL_BYTES) {
+			truncated = true;
+			break;
+		}
+
+		let content = "";
+		try {
+			content = fs.readFileSync(candidate, "utf-8");
+		} catch {
+			continue;
+		}
+		scannedFiles += 1;
+		scannedBytes += size;
+
+		for (const [name, regex] of regexByEntity.entries()) {
+			const matches = content.match(regex);
+			if (!matches || matches.length === 0) continue;
+			const current = stats.get(name);
+			if (!current) continue;
+			current.dependentFiles += 1;
+			current.references += matches.length;
+		}
+	}
+
+	const entities = limited
+		.map((name) => ({ entity: name, ...stats.get(name)! }))
+		.sort((a, b) => b.dependentFiles - a.dependentFiles)
+		.slice(0, 5);
+
+	return {
+		entities,
+		scannedFiles,
+		scannedBytes,
+		totalCandidates: files.length,
+		truncated,
+		elapsedMs: Date.now() - startedAt,
+	};
+}
 
 const SILENT_ERROR_QUERY_IDS = new Set([
 	"empty-catch",
@@ -71,19 +362,32 @@ function getSharedClient(): TreeSitterClient {
 const treeSitterRunner: RunnerDefinition = {
 	id: "tree-sitter",
 	appliesTo: ["jsts", "python", "go", "rust", "ruby"],
-	priority: 14, // Between oxlint (12) and ast-grep-napi (15)
+	priority: PRIORITY.STRUCTURAL_ANALYSIS,
 	enabledByDefault: true,
 	skipTestFiles: false, // Run on test files too (structural issues matter there)
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		// Use singleton client — WASM must never be re-initialized after first call
 		const client = getSharedClient();
+		logTreeSitter({ phase: "runner_start", filePath: ctx.filePath });
 		if (!client.isAvailable()) {
+			logTreeSitter({
+				phase: "runner_skip",
+				filePath: ctx.filePath,
+				reason: "client_unavailable",
+				status: "skipped",
+			});
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
 		const initialized = await client.init();
 		if (!initialized) {
+			logTreeSitter({
+				phase: "runner_skip",
+				filePath: ctx.filePath,
+				reason: "client_init_failed",
+				status: "skipped",
+			});
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
@@ -106,6 +410,12 @@ const treeSitterRunner: RunnerDefinition = {
 		};
 		const languageId = EXT_TO_LANG[ext];
 		if (!languageId) {
+			logTreeSitter({
+				phase: "runner_skip",
+				filePath: ctx.filePath,
+				reason: `unsupported_extension:${ext}`,
+				status: "skipped",
+			});
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
@@ -132,8 +442,10 @@ const treeSitterRunner: RunnerDefinition = {
 
 		// Try cache
 		const cached = cache.get(ruleFiles);
+		let cacheHit = false;
 		if (cached) {
 			// Use cached queries
+			cacheHit = true;
 			languageQueries = cached.queries.map(
 				(q) =>
 					({
@@ -173,6 +485,16 @@ const treeSitterRunner: RunnerDefinition = {
 		}
 
 		if (languageQueries.length === 0) {
+			logTreeSitter({
+				phase: "runner_complete",
+				filePath,
+				languageId,
+				status: "succeeded",
+				diagnostics: 0,
+				blocking: 0,
+				queryCount: 0,
+				effectiveQueryCount: 0,
+			});
 			return { status: "succeeded", diagnostics: [], semantic: "none" };
 		}
 
@@ -186,6 +508,16 @@ const treeSitterRunner: RunnerDefinition = {
 				)
 			: languageQueries;
 
+		logTreeSitter({
+			phase: "queries_loaded",
+			filePath,
+			languageId,
+			queryCount: languageQueries.length,
+			effectiveQueryCount: effectiveQueries.length,
+			cacheHit,
+			metadata: { blockingOnly: !!ctx.blockingOnly },
+		});
+
 		const diagnostics: Diagnostic[] = [];
 
 		// Run each query against the file
@@ -244,15 +576,151 @@ const treeSitterRunner: RunnerDefinition = {
 			} catch (err) {
 				// Individual query failure shouldn't stop other queries
 				console.error(`[tree-sitter] Query ${query.id} failed:`, err);
+				logTreeSitter({
+					phase: "query_error",
+					filePath,
+					languageId,
+					queryId: query.id,
+					error: err instanceof Error ? err.message : String(err),
+				});
 			}
 		}
 
 		if (diagnostics.length === 0) {
+			try {
+				const snapshot = await extractEntitySnapshot(client, filePath, languageId);
+				const prev = entitySnapshotByFile.get(filePath);
+				const diff = diffEntitySnapshot(prev, snapshot);
+				entitySnapshotByFile.set(filePath, snapshot);
+				const changedEntityKeys = [...diff.added, ...diff.modified, ...diff.removed];
+				const changedNames = [...new Set(changedEntityKeys.map((k) => k.split(":")[1]).filter(Boolean))];
+
+				if (changedEntityKeys.length > 0) {
+					logTreeSitter({
+						phase: "entity_diff",
+						filePath,
+						languageId,
+						metadata: {
+							added: diff.added,
+							modified: diff.modified,
+							removed: diff.removed,
+							totalChanged: changedEntityKeys.length,
+						},
+					});
+
+					const lastBlast = blastCooldownByFile.get(filePath) ?? 0;
+					if (Date.now() - lastBlast < BLAST_COOLDOWN_MS) {
+						logTreeSitter({
+							phase: "blast_radius",
+							filePath,
+							languageId,
+							metadata: { skipped: "cooldown", cooldownMs: BLAST_COOLDOWN_MS },
+						});
+					} else {
+						blastCooldownByFile.set(filePath, Date.now());
+						const blastRadius = computeBlastRadius(changedNames, filePath, ctx.cwd);
+						logTreeSitter({
+							phase: "blast_radius",
+							filePath,
+							languageId,
+							metadata: {
+								entities: blastRadius.entities,
+								scannedFiles: blastRadius.scannedFiles,
+								scannedBytes: blastRadius.scannedBytes,
+								totalCandidates: blastRadius.totalCandidates,
+								truncated: blastRadius.truncated,
+								elapsedMs: blastRadius.elapsedMs,
+							},
+						});
+					}
+				}
+			} catch {}
+
+			logTreeSitter({
+				phase: "runner_complete",
+				filePath,
+				languageId,
+				status: "succeeded",
+				diagnostics: 0,
+				blocking: 0,
+				queryCount: languageQueries.length,
+				effectiveQueryCount: effectiveQueries.length,
+			});
 			return { status: "succeeded", diagnostics: [], semantic: "none" };
 		}
 
 		// Check if any blocking issues
 		const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+		const blockingCount = diagnostics.filter(
+			(d) => d.semantic === "blocking",
+		).length;
+		try {
+			const snapshot = await extractEntitySnapshot(client, filePath, languageId);
+			const prev = entitySnapshotByFile.get(filePath);
+			const diff = diffEntitySnapshot(prev, snapshot);
+			entitySnapshotByFile.set(filePath, snapshot);
+			const changedEntityKeys = [
+				...diff.added,
+				...diff.modified,
+				...diff.removed,
+			];
+			const changedNames = [
+				...new Set(changedEntityKeys.map((k) => k.split(":")[1]).filter(Boolean)),
+			];
+
+			if (changedEntityKeys.length > 0) {
+				logTreeSitter({
+					phase: "entity_diff",
+					filePath,
+					languageId,
+					metadata: {
+						added: diff.added,
+						modified: diff.modified,
+						removed: diff.removed,
+						totalChanged: changedEntityKeys.length,
+					},
+				});
+
+				const lastBlast = blastCooldownByFile.get(filePath) ?? 0;
+				if (Date.now() - lastBlast < BLAST_COOLDOWN_MS) {
+					logTreeSitter({
+						phase: "blast_radius",
+						filePath,
+						languageId,
+						metadata: { skipped: "cooldown", cooldownMs: BLAST_COOLDOWN_MS },
+					});
+				} else {
+					blastCooldownByFile.set(filePath, Date.now());
+					const blastRadius = computeBlastRadius(changedNames, filePath, ctx.cwd);
+					logTreeSitter({
+						phase: "blast_radius",
+						filePath,
+						languageId,
+						metadata: {
+							entities: blastRadius.entities,
+							scannedFiles: blastRadius.scannedFiles,
+							scannedBytes: blastRadius.scannedBytes,
+							totalCandidates: blastRadius.totalCandidates,
+							truncated: blastRadius.truncated,
+							elapsedMs: blastRadius.elapsedMs,
+						},
+					});
+				}
+			}
+		} catch {
+			// best-effort experimental telemetry only
+		}
+
+		logTreeSitter({
+			phase: "runner_complete",
+			filePath,
+			languageId,
+			status: hasBlocking ? "failed" : "succeeded",
+			diagnostics: diagnostics.length,
+			blocking: blockingCount,
+			queryCount: languageQueries.length,
+			effectiveQueryCount: effectiveQueries.length,
+		});
 
 		return {
 			status: hasBlocking ? "failed" : "succeeded",

package/clients/dispatch/runners/ts-lsp.ts

@@ -16,12 +16,13 @@ import type {
 	RunnerDefinition,
 	RunnerResult,
 } from "../types.js";
+import { PRIORITY } from "../priorities.js";
 import { readFileContent } from "./utils.js";
 
 const tsLspRunner: RunnerDefinition = {
 	id: "ts-lsp",
 	appliesTo: ["jsts"],
-	priority: 5,
+	priority: PRIORITY.LSP_FALLBACK,
 	enabledByDefault: true,
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {

package/clients/dispatch/runners/type-safety.ts

@@ -13,12 +13,13 @@ import type {
 	RunnerDefinition,
 	RunnerResult,
 } from "../types.js";
+import { PRIORITY } from "../priorities.js";
 import { readFileContent } from "./utils.js";
 
 const typeSafetyRunner: RunnerDefinition = {
 	id: "type-safety",
 	appliesTo: ["jsts"],
-	priority: 20,
+	priority: PRIORITY.GENERAL_ANALYSIS,
 	enabledByDefault: true,
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {

package/clients/dispatch/runners/yamllint.ts

@@ -9,6 +9,7 @@ import type {
 	RunnerDefinition,
 	RunnerResult,
 } from "../types.js";
+import { PRIORITY } from "../priorities.js";
 
 const yamllint = createAvailabilityChecker("yamllint", ".exe");
 
@@ -83,7 +84,7 @@ function parseYamllintParsable(raw: string, filePath: string): Diagnostic[] {
 const yamllintRunner: RunnerDefinition = {
 	id: "yamllint",
 	appliesTo: ["yaml"],
-	priority: 22,
+	priority: PRIORITY.YAML_LINT,
 	enabledByDefault: true,
 	skipTestFiles: false,
 

package/clients/dispatch/tool-profile.ts

@@ -0,0 +1,40 @@
+export interface ToolProfile {
+	dedupPriority: number;
+	lintLike: boolean;
+}
+
+const DEFAULT_TOOL_PROFILE: ToolProfile = {
+	dedupPriority: 50,
+	lintLike: false,
+};
+
+const TOOL_PROFILE_MAP: Record<string, ToolProfile> = {
+	"tree-sitter:silent-error": { dedupPriority: 200, lintLike: false },
+	lsp: { dedupPriority: 120, lintLike: false },
+	"ts-lsp": { dedupPriority: 120, lintLike: false },
+	eslint: { dedupPriority: 110, lintLike: true },
+	biome: { dedupPriority: 100, lintLike: true },
+	"biome-check-json": { dedupPriority: 100, lintLike: true },
+	"tree-sitter": { dedupPriority: 90, lintLike: false },
+	"ast-grep-napi": { dedupPriority: 80, lintLike: false },
+	"ast-grep": { dedupPriority: 80, lintLike: false },
+	"ruff-lint": { dedupPriority: 95, lintLike: true },
+	oxlint: { dedupPriority: 95, lintLike: true },
+	rubocop: { dedupPriority: 95, lintLike: true },
+	"go-vet": { dedupPriority: 95, lintLike: true },
+	"golangci-lint": { dedupPriority: 95, lintLike: true },
+	"rust-clippy": { dedupPriority: 95, lintLike: true },
+	shellcheck: { dedupPriority: 95, lintLike: true },
+	"type-safety": { dedupPriority: 95, lintLike: true },
+};
+
+export function getToolProfile(
+	tool: string,
+	defectClass?: string,
+): ToolProfile {
+	const t = tool.toLowerCase();
+	if (defectClass === "silent-error" && t === "tree-sitter") {
+		return TOOL_PROFILE_MAP["tree-sitter:silent-error"];
+	}
+	return TOOL_PROFILE_MAP[t] ?? DEFAULT_TOOL_PROFILE;
+}

package/clients/dispatch/types.ts

@@ -88,17 +88,6 @@ export interface DispatchResult {
 	hasBlockers: boolean;
 }
 
-// --- Baseline Management ---
-
-export interface BaselineStore {
-	/** Get baseline for a file */
-	get(filePath: string): unknown[] | undefined;
-	/** Set baseline for a file */
-	set(filePath: string, diagnostics: unknown[]): void;
-	/** Clear all baselines */
-	clear(): void;
-}
-
 // --- Runner Definition ---
 
 export type RunnerMode = "all" | "fallback" | "first-success";
@@ -135,7 +124,7 @@ export interface DispatchContext {
 	readonly pi: PiAgentAPI;
 	readonly autofix: boolean;
 	readonly deltaMode: boolean;
-	readonly baselines: BaselineStore;
+	readonly facts: import("./fact-store.js").FactStore;
 	/** Only run blocking rules (severity: error) - used for fast feedback on file write */
 	readonly blockingOnly?: boolean;
 	readonly modifiedRanges?: ModifiedRange[];
@@ -164,6 +153,7 @@ export interface RunnerGroup {
 export interface RunnerRegistry {
 	register(runner: RunnerDefinition): void;
 	get(id: string): RunnerDefinition | undefined;
-	getForKind(kind: FileKind): RunnerDefinition[];
+	getForKind(kind: FileKind, filePath?: string): RunnerDefinition[];
 	list(): RunnerDefinition[];
+	clear(): void;
 }