pi-lens 1.3.13 → 2.0.0

package/index.ts

@@ -217,12 +217,15 @@ export default function (pi: ExtensionAPI) {
 
 	pi.registerCommand("lens-booboo", {
 		description:
-			"Code review: design smells + complexity metrics. Usage: /lens-booboo [path]",
+			"Full codebase review: design smells, complexity, AI slop detection, TODOs, dead code, duplicates, type coverage. Results saved to .pi-lens/reviews/. Usage: /lens-booboo [path]",
 		handler: async (args, ctx) => {
 			const targetPath = args.trim() || ctx.cwd || process.cwd();
-			ctx.ui.notify("🔍 Running code review...", "info");
+			ctx.ui.notify("🔍 Running full codebase review...", "info");
 
 			const parts: string[] = [];
+			const fullReport: string[] = [];
+			const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+			const reviewDir = path.join(process.cwd(), ".pi-lens", "reviews");
 
 			// Part 1: Design smells via ast-grep
 			if (astGrepClient.isAvailable()) {
@@ -239,6 +242,10 @@ export default function (pi: ExtensionAPI) {
 						"scan",
 						"--config", configPath,
 						"--json",
+						"--globs", "!**/*.test.ts",
+						"--globs", "!**/*.spec.ts",
+						"--globs", "!**/test-utils.ts",
+						"--globs", "!**/.pi-lens/**",
 						targetPath,
 					], {
 						encoding: "utf-8",
@@ -271,6 +278,7 @@ export default function (pi: ExtensionAPI) {
 						}
 
 						if (issues.length > 0) {
+							// UI summary (truncated)
 							let report = `[Design Smells] ${issues.length} issue(s) found:\n`;
 							for (const issue of issues.slice(0, 20)) {
 								report += `  L${issue.line}: ${issue.rule} — ${issue.message}\n`;
@@ -279,6 +287,14 @@ export default function (pi: ExtensionAPI) {
 								report += `  ... and ${issues.length - 20} more\n`;
 							}
 							parts.push(report);
+
+							// Full report for file
+							let fullSection = `## Design Smells\n\n**${issues.length} issue(s) found**\n\n`;
+							fullSection += "| Line | Rule | Message |\n|------|------|--------|\n";
+							for (const issue of issues) {
+								fullSection += `| ${issue.line} | ${issue.rule} | ${issue.message} |\n`;
+							}
+							fullReport.push(fullSection);
 						}
 					}
 				} catch (err: any) {
@@ -290,6 +306,7 @@ export default function (pi: ExtensionAPI) {
 			if (astGrepClient.isAvailable()) {
 				const similarGroups = await astGrepClient.findSimilarFunctions(targetPath, "typescript");
 				if (similarGroups.length > 0) {
+					// UI summary (truncated)
 					let report = `[Similar Functions] ${similarGroups.length} group(s) of structurally similar functions:\n`;
 					for (const group of similarGroups.slice(0, 5)) {
 						report += `  Pattern: ${group.functions.map(f => f.name).join(", ")}\n`;
@@ -301,11 +318,24 @@ export default function (pi: ExtensionAPI) {
 						report += `  ... and ${similarGroups.length - 5} more groups\n`;
 					}
 					parts.push(report);
+
+					// Full report for file
+					let fullSection = `## Similar Functions\n\n**${similarGroups.length} group(s) of structurally similar functions**\n\n`;
+					for (const group of similarGroups) {
+						fullSection += `### Pattern: ${group.functions.map(f => f.name).join(", ")}\n\n`;
+						fullSection += "| Function | File | Line |\n|----------|------|------|\n";
+						for (const fn of group.functions) {
+							fullSection += `| ${fn.name} | ${fn.file} | ${fn.line} |\n`;
+						}
+						fullSection += "\n";
+					}
+					fullReport.push(fullSection);
 				}
 			}
 
-			// Part 3: Complexity metrics
+			// Part 3: Complexity metrics + AI slop detection
 			const results: import("./clients/complexity-client.js").FileComplexity[] = [];
+			const aiSlopIssues: string[] = [];
 
 			const scanDir = (dir: string) => {
 				if (!require("node:fs").existsSync(dir)) return;
@@ -320,6 +350,17 @@ export default function (pi: ExtensionAPI) {
 						const metrics = complexityClient.analyzeFile(fullPath);
 						if (metrics) {
 							results.push(metrics);
+
+							// Check AI slop indicators — skip test files (low MI is expected/structural)
+							if (!/\.(test|spec)\.[jt]sx?$/.test(entry.name)) {
+								const warnings = complexityClient.checkThresholds(metrics);
+								if (warnings.length > 0) {
+									aiSlopIssues.push(`  ${metrics.filePath}:`);
+									for (const w of warnings) {
+										aiSlopIssues.push(`    ⚠ ${w}`);
+									}
+								}
+							}
 						}
 					}
 				}
@@ -332,10 +373,13 @@ export default function (pi: ExtensionAPI) {
 				const avgCognitive = results.reduce((a, b) => a + b.cognitiveComplexity, 0) / results.length;
 				const avgCyclomatic = results.reduce((a, b) => a + b.cyclomaticComplexity, 0) / results.length;
 				const maxNesting = Math.max(...results.map(r => r.maxNestingDepth));
+				const maxCognitive = Math.max(...results.map(r => r.cognitiveComplexity));
+				const minMI = Math.min(...results.map(r => r.maintainabilityIndex));
 
 				const lowMI = results.filter(r => r.maintainabilityIndex < 60).sort((a, b) => a.maintainabilityIndex - b.maintainabilityIndex);
 				const highCognitive = results.filter(r => r.cognitiveComplexity > 20).sort((a, b) => b.cognitiveComplexity - a.cognitiveComplexity);
 
+				// UI summary (truncated)
 				let summary = `[Complexity] ${results.length} file(s) scanned\n`;
 				summary += `  Maintainability: ${avgMI.toFixed(1)} avg | Cognitive: ${avgCognitive.toFixed(1)} avg | Max Nesting: ${maxNesting} levels\n`;
 
@@ -355,17 +399,369 @@ export default function (pi: ExtensionAPI) {
 					if (highCognitive.length > 5) summary += `    ... and ${highCognitive.length - 5} more\n`;
 				}
 
+				// Add AI slop issues
+				if (aiSlopIssues.length > 0) {
+					summary += `\n[AI Slop Indicators]\n${aiSlopIssues.join("\n")}`;
+				}
+
 				parts.push(summary);
+
+				// Full report for file
+				let fullSection = `## Complexity Metrics\n\n**${results.length} file(s) scanned**\n\n`;
+				fullSection += `### Summary\n\n`;
+				fullSection += `| Metric | Value |\n|--------|-------|\n`;
+				fullSection += `| Avg Maintainability Index | ${avgMI.toFixed(1)} |\n`;
+				fullSection += `| Min Maintainability Index | ${minMI.toFixed(1)} |\n`;
+				fullSection += `| Avg Cognitive Complexity | ${avgCognitive.toFixed(1)} |\n`;
+				fullSection += `| Max Cognitive Complexity | ${maxCognitive} |\n`;
+				fullSection += `| Avg Cyclomatic Complexity | ${avgCyclomatic.toFixed(1)} |\n`;
+				fullSection += `| Max Nesting Depth | ${maxNesting} |\n`;
+				fullSection += `| Total Files | ${results.length} |\n\n`;
+
+				if (lowMI.length > 0) {
+					fullSection += `### Low Maintainability (MI < 60)\n\n`;
+					fullSection += `| File | MI | Cognitive | Cyclomatic | Nesting |\n`;
+					fullSection += `|------|-----|-----------|------------|--------|\n`;
+					for (const f of lowMI) {
+						fullSection += `| ${f.filePath} | ${f.maintainabilityIndex.toFixed(1)} | ${f.cognitiveComplexity} | ${f.cyclomaticComplexity} | ${f.maxNestingDepth} |\n`;
+					}
+					fullSection += "\n";
+				}
+
+				if (highCognitive.length > 0) {
+					fullSection += `### High Cognitive Complexity (> 20)\n\n`;
+					fullSection += `| File | Cognitive | MI | Cyclomatic | Nesting |\n`;
+					fullSection += `|------|-----------|-----|------------|--------|\n`;
+					for (const f of highCognitive) {
+						fullSection += `| ${f.filePath} | ${f.cognitiveComplexity} | ${f.maintainabilityIndex.toFixed(1)} | ${f.cyclomaticComplexity} | ${f.maxNestingDepth} |\n`;
+					}
+					fullSection += "\n";
+				}
+
+				// All files table
+				fullSection += `### All Files\n\n`;
+				fullSection += `| File | MI | Cognitive | Cyclomatic | Nesting | Entropy |\n`;
+				fullSection += `|------|-----|-----------|------------|---------|--------|\n`;
+				for (const f of results.sort((a, b) => a.maintainabilityIndex - b.maintainabilityIndex)) {
+					fullSection += `| ${f.filePath} | ${f.maintainabilityIndex.toFixed(1)} | ${f.cognitiveComplexity} | ${f.cyclomaticComplexity} | ${f.maxNestingDepth} | ${f.codeEntropy.toFixed(2)} |\n`;
+				}
+				fullSection += "\n";
+
+				// AI slop indicators
+				if (aiSlopIssues.length > 0) {
+					fullSection += `### AI Slop Indicators\n\n`;
+					for (const issue of aiSlopIssues) {
+						fullSection += `${issue}\n`;
+					}
+					fullSection += "\n";
+				}
+
+				fullReport.push(fullSection);
 			}
 
+			// Part 4: TODOs scan
+			const todoResult = todoScanner.scanDirectory(targetPath);
+			const todoReport = todoScanner.formatResult(todoResult);
+			if (todoReport) {
+				parts.push(todoReport);
+				// Full TODO report
+				let fullSection = `## TODOs / Annotations\n\n`;
+				if (todoResult.items.length > 0) {
+					fullSection += `**${todoResult.items.length} annotation(s) found**\n\n`;
+					fullSection += `| Type | File | Line | Text |\n`;
+					fullSection += `|------|------|------|------|\n`;
+					for (const item of todoResult.items) {
+						fullSection += `| ${item.type} | ${item.file} | ${item.line} | ${item.message} |\n`;
+					}
+				} else {
+					fullSection += `No annotations found.\n`;
+				}
+				fullSection += "\n";
+				fullReport.push(fullSection);
+			}
+
+			// Part 5: Dead code (knip)
+			if (knipClient.isAvailable()) {
+				const knipResult = knipClient.analyze(targetPath);
+				const knipReport = knipClient.formatResult(knipResult);
+				if (knipReport) {
+					parts.push(knipReport);
+					// Full knip report
+					let fullSection = `## Dead Code (Knip)\n\n`;
+					if (knipResult.issues.length > 0) {
+						fullSection += `**${knipResult.issues.length} issue(s) found**\n\n`;
+						fullSection += `| Type | Name | File |\n`;
+						fullSection += `|------|------|------|\n`;
+						for (const issue of knipResult.issues) {
+							fullSection += `| ${issue.type} | ${issue.name} | ${issue.file ?? ""} |\n`;
+						}
+					} else {
+						fullSection += `No dead code issues found.\n`;
+					}
+					fullSection += "\n";
+					fullReport.push(fullSection);
+				}
+			}
+
+			// Part 6: Code duplication
+			if (jscpdClient.isAvailable()) {
+				const jscpdResult = jscpdClient.scan(targetPath);
+				const jscpdReport = jscpdClient.formatResult(jscpdResult);
+				if (jscpdReport) {
+					parts.push(jscpdReport);
+					// Full jscpd report
+					let fullSection = `## Code Duplication (jscpd)\n\n`;
+					if (jscpdResult.clones.length > 0) {
+						fullSection += `**${jscpdResult.clones.length} duplicate block(s) found** (${jscpdResult.duplicatedLines}/${jscpdResult.totalLines} lines, ${jscpdResult.percentage.toFixed(1)}%)\n\n`;
+						fullSection += `| File A | Line A | File B | Line B | Lines | Tokens |\n`;
+						fullSection += `|--------|--------|--------|--------|-------|--------|\n`;
+						for (const dup of jscpdResult.clones) {
+							fullSection += `| ${dup.fileA} | ${dup.startA} | ${dup.fileB} | ${dup.startB} | ${dup.lines} | ${dup.tokens} |\n`;
+						}
+					} else {
+						fullSection += `No duplicate code found.\n`;
+					}
+					fullSection += "\n";
+					fullReport.push(fullSection);
+				}
+			}
+
+			// Part 7: Type coverage
+			if (typeCoverageClient.isAvailable()) {
+				const tcResult = typeCoverageClient.scan(targetPath);
+				const tcReport = typeCoverageClient.formatResult(tcResult);
+				if (tcReport) {
+					parts.push(tcReport);
+					// Full type coverage report
+					let fullSection = `## Type Coverage\n\n`;
+					fullSection += `**${tcResult.percentage.toFixed(1)}% typed** (${tcResult.typed}/${tcResult.total} identifiers)\n\n`;
+					if (tcResult.untypedLocations.length > 0) {
+						fullSection += `### Untyped Identifiers\n\n`;
+						fullSection += `| File | Line | Column | Name |\n`;
+						fullSection += `|------|------|--------|------|\n`;
+						for (const u of tcResult.untypedLocations) {
+							fullSection += `| ${u.file} | ${u.line} | ${u.column} | ${u.name} |\n`;
+						}
+					}
+					fullSection += "\n";
+					fullReport.push(fullSection);
+				}
+			}
+
+			// Build and save full markdown report
+			const fs = require("node:fs");
+			if (!fs.existsSync(reviewDir)) {
+				fs.mkdirSync(reviewDir, { recursive: true });
+			}
+
+			const projectName = path.basename(process.cwd());
+			let mdReport = `# Code Review: ${projectName}\n\n`;
+			mdReport += `**Scanned:** ${new Date().toISOString()}\n\n`;
+			mdReport += `**Path:** \`${targetPath}\`\n\n`;
+			mdReport += `---\n\n`;
+			mdReport += fullReport.join("\n");
+
+			const reportPath = path.join(reviewDir, `booboo-${timestamp}.md`);
+			fs.writeFileSync(reportPath, mdReport, "utf-8");
+
 			if (parts.length === 0) {
-				ctx.ui.notify("✓ Code review clean", "info");
+				ctx.ui.notify("✓ Code review clean — saved to .pi-lens/reviews/", "info");
 			} else {
-				ctx.ui.notify(parts.join("\n\n"), "info");
+				ctx.ui.notify(`${parts.join("\n\n")}\n\n📄 Full report: ${reportPath}`, "info");
 			}
 		},
 	});
 
+	pi.registerCommand("lens-metrics", {
+		description:
+			"Measure complexity metrics for all files and export to report.md. Usage: /lens-metrics [path]",
+		handler: async (args, ctx) => {
+			const targetPath = args.trim() || ctx.cwd || process.cwd();
+			ctx.ui.notify("📊 Measuring code metrics...", "info");
+
+			const fs = require("node:fs");
+			const reviewDir = path.join(process.cwd(), ".pi-lens", "reviews");
+			const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+			const projectName = path.basename(process.cwd());
+
+			const results: import("./clients/complexity-client.js").FileComplexity[] = [];
+
+			const scanDir = (dir: string) => {
+				if (!fs.existsSync(dir)) return;
+				const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+				for (const entry of entries) {
+					const fullPath = path.join(dir, entry.name);
+					if (entry.isDirectory()) {
+						if (["node_modules", ".git", "dist", "build", ".next", ".pi-lens"].includes(entry.name)) continue;
+						scanDir(fullPath);
+					} else if (complexityClient.isSupportedFile(fullPath)) {
+						const metrics = complexityClient.analyzeFile(fullPath);
+						if (metrics) {
+							results.push(metrics);
+						}
+					}
+				}
+			};
+
+			scanDir(targetPath);
+
+			if (results.length === 0) {
+				ctx.ui.notify("No supported files found to analyze", "warning");
+				return;
+			}
+
+			// Calculate aggregates
+			const avgMI = results.reduce((a, b) => a + b.maintainabilityIndex, 0) / results.length;
+			const avgCognitive = results.reduce((a, b) => a + b.cognitiveComplexity, 0) / results.length;
+			const avgCyclomatic = results.reduce((a, b) => a + b.cyclomaticComplexity, 0) / results.length;
+			const avgFunctionLength = results.reduce((a, b) => a + b.avgFunctionLength, 0) / results.length;
+			const maxNesting = Math.max(...results.map(r => r.maxNestingDepth));
+			const maxCognitive = Math.max(...results.map(r => r.cognitiveComplexity));
+			const minMI = Math.min(...results.map(r => r.maintainabilityIndex));
+			const totalFunctions = results.reduce((a, b) => a + b.functionCount, 0);
+			const totalLOC = results.reduce((a, b) => a + b.linesOfCode, 0);
+
+			// Grade distribution
+			const grades = results.map(r => {
+				const mi = r.maintainabilityIndex;
+				if (mi >= 80) return { letter: "A", color: "🟢" };
+				if (mi >= 60) return { letter: "B", color: "🟡" };
+				if (mi >= 40) return { letter: "C", color: "🟠" };
+				if (mi >= 20) return { letter: "D", color: "🔴" };
+				return { letter: "F", color: "⚫" };
+			});
+
+			const gradeCount = { A: 0, B: 0, C: 0, D: 0, F: 0 };
+			grades.forEach(g => gradeCount[g.letter as keyof typeof gradeCount]++);
+
+			// Build report
+			let report = `# Code Metrics Report: ${projectName}\n\n`;
+			report += `**Generated:** ${new Date().toISOString()}\n\n`;
+			report += `**Path:** \`${targetPath}\`\n\n`;
+			report += `---\n\n`;
+
+			// AI slop aggregates
+			const totalAISlopWarnings = results.reduce((a, b) => {
+				return a + complexityClient.checkThresholds(b).length;
+			}, 0);
+			const totalEmojiComments = results.reduce((a, b) => a + b.aiCommentPatterns, 0);
+			const totalTryCatch = results.reduce((a, b) => a + b.tryCatchCount, 0);
+			const totalSingleUse = results.reduce((a, b) => a + b.singleUseFunctions, 0);
+			const maxParams = Math.max(...results.map(r => r.maxParamsInFunction));
+
+			// Summary
+			report += `## Summary\n\n`;
+			report += `| Metric | Value |\n`;
+			report += `|--------|-------|\n`;
+			report += `| Files Analyzed | ${results.length} |\n`;
+			report += `| Total Functions | ${totalFunctions} |\n`;
+			report += `| Total Lines of Code | ${totalLOC.toLocaleString()} |\n`;
+			report += `| Avg Maintainability Index | ${avgMI.toFixed(1)} |\n`;
+			report += `| Min Maintainability Index | ${minMI.toFixed(1)} |\n`;
+			report += `| Avg Cognitive Complexity | ${avgCognitive.toFixed(1)} |\n`;
+			report += `| Max Cognitive Complexity | ${maxCognitive} |\n`;
+			report += `| Avg Cyclomatic Complexity | ${avgCyclomatic.toFixed(1)} |\n`;
+			report += `| Max Nesting Depth | ${maxNesting} |\n`;
+			report += `| Avg Function Length | ${avgFunctionLength.toFixed(1)} lines |\n\n`;
+
+			// AI Slop Summary
+			report += `## AI Slop Indicators (Aggregate)\n\n`;
+			report += `| Indicator | Count |\n`;
+			report += `|-----------|-------|\n`;
+			report += `| Total Warnings | ${totalAISlopWarnings} |\n`;
+			report += `| Emoji/Boilerplate Comments | ${totalEmojiComments} |\n`;
+			report += `| Try/Catch Blocks | ${totalTryCatch} |\n`;
+			report += `| Single-Use Helper Functions | ${totalSingleUse} |\n`;
+			report += `| Max Function Parameters | ${maxParams} |\n\n`;
+
+			// Grade distribution
+			report += `## Maintainability Grade Distribution\n\n`;
+			report += `| Grade | Count | Percentage |\n`;
+			report += `|-------|-------|------------|\n`;
+			for (const [grade, count] of Object.entries(gradeCount)) {
+				const pct = ((count / results.length) * 100).toFixed(1);
+				const icon = grade === "A" ? "🟢" : grade === "B" ? "🟡" : grade === "C" ? "🟠" : grade === "D" ? "🔴" : "⚫";
+				report += `| ${icon} ${grade} (MI ≥ ${grade === "A" ? 80 : grade === "B" ? 60 : grade === "C" ? 40 : grade === "D" ? 20 : 0}) | ${count} | ${pct}% |\n`;
+			}
+			report += `\n`;
+
+			// All files table (sorted by MI ascending)
+			report += `## All Files\n\n`;
+			report += `| Grade | File | MI | Cognitive | Cyclomatic | Nesting | Functions | LOC | Entropy |\n`;
+			report += `|-------|------|-----|-----------|------------|---------|-----------|-----|--------|\n`;
+
+			const sorted = [...results].sort((a, b) => a.maintainabilityIndex - b.maintainabilityIndex);
+			for (const f of sorted) {
+				const mi = f.maintainabilityIndex;
+				let grade: string;
+				if (mi >= 80) grade = "🟢 A";
+				else if (mi >= 60) grade = "🟡 B";
+				else if (mi >= 40) grade = "🟠 C";
+				else if (mi >= 20) grade = "🔴 D";
+				else grade = "⚫ F";
+
+				// Make path relative for readability
+				const relPath = path.relative(targetPath, f.filePath);
+
+				report += `| ${grade} | ${relPath} | ${mi.toFixed(1)} | ${f.cognitiveComplexity} | ${f.cyclomaticComplexity.toFixed(1)} | ${f.maxNestingDepth} | ${f.functionCount} | ${f.linesOfCode} | ${f.codeEntropy.toFixed(2)} |\n`;
+			}
+			report += `\n`;
+
+			// Top 10 worst files (actionable)
+			report += `## Top 10 Files Needing Attention\n\n`;
+			report += `These files have the lowest maintainability scores:\n\n`;
+			for (let i = 0; i < Math.min(10, sorted.length); i++) {
+				const f = sorted[i];
+				const relPath = path.relative(targetPath, f.filePath);
+				const warnings: string[] = [];
+
+				if (f.maintainabilityIndex < 20) warnings.push("🔴 Critical: MI < 20");
+				else if (f.maintainabilityIndex < 40) warnings.push("🟠 Low: MI < 40");
+				if (f.cognitiveComplexity > 50) warnings.push(`High cognitive (${f.cognitiveComplexity})`);
+				if (f.maxNestingDepth > 5) warnings.push(`Deep nesting (${f.maxNestingDepth})`);
+				if (f.maxFunctionLength > 50) warnings.push(`Long functions (max ${f.maxFunctionLength})`);
+
+				// AI slop indicators
+				const slopWarnings = complexityClient.checkThresholds(f);
+				for (const w of slopWarnings) {
+					if (w.includes("AI-style") || w.includes("try/catch") || w.includes("single-use") || w.includes("parameter list")) {
+						warnings.push(`🤖 ${w.split(" — ")[0]}`);
+					}
+				}
+
+				report += `${i + 1}. **${relPath}** — MI: ${f.maintainabilityIndex.toFixed(1)}\n`;
+				if (warnings.length > 0) {
+					report += `   - ${warnings.join(", ")}\n`;
+				}
+			}
+			report += `\n`;
+
+			// Save report
+			if (!fs.existsSync(reviewDir)) {
+				fs.mkdirSync(reviewDir, { recursive: true });
+			}
+
+			const reportPath = path.join(reviewDir, `metrics-${timestamp}.md`);
+			fs.writeFileSync(reportPath, report, "utf-8");
+
+			// Also save latest.md for easy access
+			const latestPath = path.join(reviewDir, "latest.md");
+			fs.writeFileSync(latestPath, report, "utf-8");
+
+			// Console summary
+			const summary = [
+				`📊 Metrics Report`,
+				`   ${results.length} files, ${totalLOC.toLocaleString()} LOC, ${totalFunctions} functions`,
+				`   MI: ${avgMI.toFixed(1)} avg (${gradeCount.A}A ${gradeCount.B}B ${gradeCount.C}C ${gradeCount.D}D ${gradeCount.F}F)`,
+				`   Cognitive: ${avgCognitive.toFixed(1)} avg, ${maxCognitive} max`,
+				`📄 Saved: ${reportPath}`,
+			].join("\n");
+
+			ctx.ui.notify(summary, "info");
+		},
+	});
+
 	pi.registerCommand("lens-format", {
 		description:
 			"Apply Biome formatting to files. Usage: /lens-format [file-path] or /lens-format --all",
@@ -508,6 +904,10 @@ export default function (pi: ExtensionAPI) {
 	let cachedExports = new Map<string, string>(); // function name -> file path
 	const complexityBaselines: Map<string, import("./clients/complexity-client.js").FileComplexity> = new Map();
 
+	// Delta baselines: store pre-write diagnostics to diff against post-write
+	const astGrepBaselines = new Map<string, import("./clients/ast-grep-client.js").AstGrepDiagnostic[]>();
+	const biomeBaselines = new Map<string, import("./clients/biome-client.js").BiomeDiagnostic[]>();
+
 	// --- Events ---
 
 	pi.on("session_start", async (_event, ctx) => {
@@ -644,26 +1044,13 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
-		if (
-			/\.(ts|tsx|js|jsx)$/.test(filePath) &&
-			!pi.getFlag("no-biome") &&
-			biomeClient.isAvailable()
-		) {
-			const diags = biomeClient.checkFile(filePath);
-			if (diags.length > 0) {
-				hints.push(
-					`⚠ Pre-write: file already has ${diags.length} Biome issue(s)`,
-				);
-			}
+		// Snapshot baselines for delta mode (no pre-write hints — delta handles it)
+		if (!pi.getFlag("no-ast-grep") && astGrepClient.isAvailable()) {
+			astGrepBaselines.set(filePath, astGrepClient.scanFile(filePath));
 		}
 
-		if (!pi.getFlag("no-ast-grep") && astGrepClient.isAvailable()) {
-			const diags = astGrepClient.scanFile(filePath);
-			if (diags.length > 0) {
-				hints.push(
-					`⚠ Pre-write: file already has ${diags.length} structural violations`,
-				);
-			}
+		if (!pi.getFlag("no-biome") && biomeClient.isAvailable() && biomeClient.isSupportedFile(filePath)) {
+			biomeBaselines.set(filePath, biomeClient.checkFile(filePath).filter(d => d.category === "lint" || d.severity === "error"));
 		}
 
 		dbg(`  pre-write hints: ${hints.length} — ${hints.join(" | ") || "none"}`);
@@ -778,50 +1165,105 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
-		// ast-grep structural analysis
-		const astAvailable = astGrepClient.isAvailable();
-		dbg(
-			`  ast-grep available: ${astAvailable}, no-ast-grep: ${pi.getFlag("no-ast-grep")}`,
-		);
-		if (!pi.getFlag("no-ast-grep") && astAvailable) {
-			const astDiags = astGrepClient.scanFile(filePath);
-			dbg(`  ast-grep diags: ${astDiags.length}`);
-			if (astDiags.length > 0) {
-				lspOutput += `\n\n${astGrepClient.formatDiagnostics(astDiags)}`;
+		// ast-grep structural analysis — delta mode (only show new violations)
+		if (!pi.getFlag("no-ast-grep") && astGrepClient.isAvailable()) {
+			const after = astGrepClient.scanFile(filePath);
+			const before = astGrepBaselines.get(filePath) ?? [];
+			astGrepBaselines.set(filePath, after);
+
+			// Count by rule before/after
+			const countBefore = new Map<string, number>();
+			const countAfter = new Map<string, number>();
+			for (const d of before) countBefore.set(d.rule, (countBefore.get(d.rule) ?? 0) + 1);
+			for (const d of after) countAfter.set(d.rule, (countAfter.get(d.rule) ?? 0) + 1);
+
+			// Find new/increased rules
+			const newViolations: typeof after = [];
+			for (const d of after) {
+				const ruleBefore = countBefore.get(d.rule) ?? 0;
+				const ruleAfter = countAfter.get(d.rule) ?? 0;
+				if (ruleAfter > ruleBefore && newViolations.filter(x => x.rule === d.rule).length < (ruleAfter - ruleBefore)) {
+					newViolations.push(d);
+				}
+			}
+
+			// Find fixed rules
+			const fixedRules: string[] = [];
+			for (const [rule, n] of countBefore) {
+				const after_n = countAfter.get(rule) ?? 0;
+				if (after_n < n) fixedRules.push(`${rule} (-${n - after_n})`);
+			}
+
+			if (newViolations.length > 0) {
+				lspOutput += `\n\n[ast-grep] +${newViolations.length} new issue(s) introduced:\n`;
+				lspOutput += astGrepClient.formatDiagnostics(newViolations);
+			}
+			if (fixedRules.length > 0) {
+				lspOutput += `\n\n[ast-grep] ✓ Fixed: ${fixedRules.join(", ")}`;
+			}
+			// Show total count quietly so context isn't lost
+			if (after.length > 0 && newViolations.length === 0 && fixedRules.length === 0) {
+				// no change — show nothing
+			} else if (after.length > 0) {
+				lspOutput += `\n  (${after.length} total)`;
 			}
 		}
 
-		// Biome: lint only (formatting noise filtered out, use /lens-format)
+		// Biome: lint only — delta mode
 		const biomeAvailable = biomeClient.isAvailable();
-		dbg(
-			`  biome available: ${biomeAvailable}, supported: ${biomeClient.isSupportedFile(filePath)}, no-biome: ${pi.getFlag("no-biome")}`,
-		);
-		if (!pi.getFlag("no-biome") && biomeClient.isSupportedFile(filePath)) {
-			const biomeDiags = biomeClient.checkFile(filePath);
-			// Filter out format-only issues (noise for agent, use /lens-format)
-			const lintDiags = biomeDiags.filter((d) => d.category === "lint" || d.severity === "error");
-			dbg(`  biome diags: ${biomeDiags.length} total, ${lintDiags.length} lint-only`);
-			if (pi.getFlag("autofix-biome") && lintDiags.length > 0) {
-				// Always attempt fix — let Biome decide what it can do
+		if (!pi.getFlag("no-biome") && biomeAvailable && biomeClient.isSupportedFile(filePath)) {
+			const allDiags = biomeClient.checkFile(filePath);
+			const after = allDiags.filter((d) => d.category === "lint" || d.severity === "error");
+			const before = biomeBaselines.get(filePath) ?? [];
+			biomeBaselines.set(filePath, after);
+
+			// Count by rule before/after
+			const countBefore = new Map<string, number>();
+			const countAfter = new Map<string, number>();
+			const ruleKey = (d: typeof after[0]) => d.rule ?? d.message;
+			for (const d of before) countBefore.set(ruleKey(d), (countBefore.get(ruleKey(d)) ?? 0) + 1);
+			for (const d of after) countAfter.set(ruleKey(d), (countAfter.get(ruleKey(d)) ?? 0) + 1);
+
+			const newDiags: typeof after = [];
+			for (const d of after) {
+				const key = ruleKey(d);
+				const n_before = countBefore.get(key) ?? 0;
+				const n_after = countAfter.get(key) ?? 0;
+				if (n_after > n_before && newDiags.filter(x => ruleKey(x) === key).length < (n_after - n_before)) {
+					newDiags.push(d);
+				}
+			}
+
+			const fixedRules: string[] = [];
+			for (const [rule, n] of countBefore) {
+				const after_n = countAfter.get(rule) ?? 0;
+				if (after_n < n) fixedRules.push(`${rule} (-${n - after_n})`);
+			}
+
+			if (pi.getFlag("autofix-biome") && after.length > 0) {
 				const fixResult = biomeClient.fixFile(filePath);
 				if (fixResult.success && fixResult.changed) {
 					lspOutput += `\n\n[Biome] Auto-fixed ${fixResult.fixed} issue(s) — file updated on disk`;
-					const remaining = biomeClient.checkFile(filePath);
-					const remainingLint = remaining.filter((d) => d.category === "lint" || d.severity === "error");
-					if (remainingLint.length > 0) {
-						lspOutput += `\n\n${biomeClient.formatDiagnostics(remainingLint, filePath)}`;
-					} else {
-						lspOutput += `\n\n[Biome] ✓ All issues resolved`;
-					}
-				} else {
-					// Nothing fixable — show diagnostics as-is
-					lspOutput += `\n\n${biomeClient.formatDiagnostics(lintDiags, filePath)}`;
+					const remaining = biomeClient.checkFile(filePath).filter((d) => d.category === "lint" || d.severity === "error");
+					if (remaining.length > 0) lspOutput += `\n\n${biomeClient.formatDiagnostics(remaining, filePath)}`;
+					else lspOutput += `\n\n[Biome] ✓ All issues resolved`;
+				} else if (after.length > 0) {
+					lspOutput += `\n\n${biomeClient.formatDiagnostics(after, filePath)}`;
 				}
-			} else if (lintDiags.length > 0) {
-				const fixable = lintDiags.filter((d) => d.fixable);
-				lspOutput += `\n\n${biomeClient.formatDiagnostics(lintDiags, filePath)}`;
-				if (fixable.length > 0) {
-					lspOutput += `\n\n[Biome] ${fixable.length} fixable — enable --autofix-biome flag or run /lens-format`;
+			} else {
+				if (newDiags.length > 0) {
+					const fixable = newDiags.filter((d) => d.fixable);
+					lspOutput += `\n\n[Biome] +${newDiags.length} new issue(s) introduced:\n`;
+					lspOutput += biomeClient.formatDiagnostics(newDiags, filePath);
+					if (fixable.length > 0) lspOutput += `\n\n[Biome] ${fixable.length} fixable — run /lens-format`;
+				}
+				if (fixedRules.length > 0) {
+					lspOutput += `\n\n[Biome] ✓ Fixed: ${fixedRules.join(", ")}`;
+				}
+				if (after.length > 0 && newDiags.length === 0 && fixedRules.length === 0) {
+					// no change — show nothing
+				} else if (after.length > 0) {
+					lspOutput += `\n  (${after.length} total)`;
 				}
 			}
 		}