pi-lens 1.3.4 → 1.3.6

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to pi-lens will be documented in this file.
 
+## [1.5.0] - 2026-03-23
+
+### Added
+- **Real-time jscpd duplicate detection**: Code duplication is now detected on every write. Duplicates involving the edited file are shown to the agent in real-time.
+- **`/lens-review` command**: Combined code review: design smells + complexity metrics in one command.
+
+### Changed
+- **Consistent command prefix**: All commands now start with `lens-`.
+  - `/find-todos` → `/lens-todos`
+  - `/dead-code` → `/lens-dead-code`
+  - `/check-deps` → `/lens-deps`
+  - `/format` → `/lens-format`
+  - `/design-review` + `/lens-metrics` → `/lens-review`
+
 ## [1.4.0] - 2026-03-23
 
 ### Added

package/README.md

@@ -12,10 +12,11 @@ Real-time code quality feedback for [pi](https://github.com/mariozechner/pi-codi
 |---|---|
 | **TypeScript LSP** | Type errors and warnings, using the project's `tsconfig.json` (walks up from the file to find it; falls back to `ES2020 + DOM` defaults) |
 | **ast-grep** | 60+ structural rules: `no-var`, `no-eval`, `no-debugger`, `no-as-any`, `prefer-template`, `no-throw-string`, `no-hardcoded-secrets`, `no-return-await`, nested ternaries, strict equality, and more |
-| **Biome** | Lint + format for JS/TS/JSX/TSX/CSS/JSON. Auto-fixes on every write by default |
+| **Biome** | Lint + format for JS/TS/JSX/TSX/CSS/JSON. Auto-fix disabled by default, use `/lens-format` to apply |
 | **Ruff** | Lint + format for Python. Auto-fixes on every write by default |
 | **Test Runner** | Runs corresponding test file when you edit source code (vitest, jest, pytest). Silent if no test file exists. |
 | **Complexity Metrics** | AST-based analysis: Maintainability Index, Cyclomatic/Cognitive Complexity, Halstead Volume, nesting depth, function length. |
+| **jscpd** | Code duplication detection. Warns when editing a file that has duplicates with other files in the project. |
 
 ### Pre-write hints
 
@@ -68,12 +69,11 @@ Example:
 
 | Command | Description |
 |---|---|
-| `/find-todos [path]` | Scan for TODO/FIXME/HACK annotations |
-| `/dead-code` | Find unused exports/files/dependencies (requires knip) |
-| `/check-deps` | Circular dependency scan (requires madge) |
-| `/format [file|--all]` | Apply Biome formatting |
-| `/design-review [path]` | Analyze files for design smells (long methods, large classes, etc.) |
-| `/lens-metrics [path]` | Full project complexity scan (Maintainability Index, Cognitive/Cyclomatic Complexity, Halstead Volume) |
+| `/lens-todos [path]` | Scan for TODO/FIXME/HACK annotations |
+| `/lens-dead-code` | Find unused exports/files/dependencies (requires knip) |
+| `/lens-deps` | Circular dependency scan (requires madge) |
+| `/lens-format [file\|--all]` | Apply Biome formatting |
+| `/lens-review [path]` | Code review: design smells + complexity metrics |
 
 ### On-demand tools
 

package/clients/ast-grep-client.ts

@@ -200,6 +200,78 @@ export class AstGrepClient {
     return { matches: result.matches, applied: apply, error: result.error };
   }
 
+  /**
+   * Scan for exported function names in a directory
+   */
+  async scanExports(dir: string, lang: string = "typescript"): Promise<Map<string, string>> {
+    console.log(`[scanExports] Starting scan of ${dir}`);
+    const exports = new Map<string, string>();
+
+    if (!this.isAvailable()) {
+      console.log(`[scanExports] ast-grep not available`);
+      return exports;
+    }
+
+    const tmpDir = require("node:os").tmpdir();
+    const ts = Date.now();
+    const ruleDir = require("node:path").join(tmpDir, `pi-lens-exports-${ts}`);
+    const rulesSubdir = require("node:path").join(ruleDir, "rules");
+    const ruleFile = require("node:path").join(rulesSubdir, "find-functions.yml");
+    const configFile = require("node:path").join(ruleDir, ".sgconfig.yml");
+
+    require("node:fs").mkdirSync(rulesSubdir, { recursive: true });
+
+    require("node:fs").writeFileSync(configFile, `ruleDirs:\n  - ./rules\n`);
+    require("node:fs").writeFileSync(ruleFile, `id: find-functions
+language: ${lang}
+rule:
+  kind: function_declaration
+severity: info
+message: found
+`);
+
+    try {
+      const result = spawnSync("npx", [
+        "sg", "scan",
+        "--config", configFile,
+        "--json",
+        dir,
+      ], {
+        encoding: "utf-8",
+        timeout: 15000,
+        shell: true,
+      });
+
+      console.log(`[scanExports] status: ${result.status}, stdout length: ${result.stdout?.length || 0}`);
+
+      const output = result.stdout || result.stderr || "";
+      this.log(`scanExports output length: ${output.length}`);
+      if (output.trim()) {
+        try {
+          const items = JSON.parse(output);
+          const matches = Array.isArray(items) ? items : [items];
+          console.log(`[scanExports] parsed ${matches.length} matches`);
+          for (const item of matches) {
+            const text = item.text || "";
+            const nameMatch = text.match(/function\s+(\w+)/);
+            if (nameMatch && nameMatch[1]) {
+              this.log(`scanExports found: ${nameMatch[1]} in ${item.file}`);
+              exports.set(nameMatch[1], item.file);
+            }
+          }
+        } catch (e) {
+          this.log(`scanExports parse error: ${e}`);
+        }
+      }
+    } catch (err: any) {
+      this.log(`scanExports error: ${err.message}`);
+    } finally {
+      try { require("node:fs").rmSync(ruleDir, { recursive: true, force: true }); } catch {}
+    }
+
+    return exports;
+  }
+
   private runSg(args: string[]): Promise<{ matches: AstGrepMatch[]; error?: string }> {
     return new Promise((resolve) => {
       const proc = spawn("npx", ["sg", ...args], { stdio: ["ignore", "pipe", "pipe"], shell: true });

package/index.ts

@@ -11,14 +11,14 @@
  * - Warns when target file already has existing violations
  *
 	 * Auto-fix on write (enable with --autofix-ruff flag, Biome auto-fix disabled by default):
-	 * - Biome: feedback only by default, use /format to apply fixes
+	 * - Biome: feedback only by default, use /lens-format to apply fixes
 	 * - Ruff: applies --fix + format (lint + format fixes)
  *
  * On-demand commands:
- * - /format - Apply Biome formatting
- * - /find-todos - Scan for TODO/FIXME/HACK annotations
- * - /dead-code - Find unused exports/dependencies (requires knip)
- * - /check-deps - Full circular dependency scan (requires madge)
+ * - /lens-format - Apply Biome formatting
+ * - /lens-todos - Scan for TODO/FIXME/HACK annotations
+ * - /lens-dead-code - Find unused exports/dependencies (requires knip)
+ * - /lens-deps - Full circular dependency scan (requires madge)
  *
  * External dependencies:
  * - npm: @biomejs/biome, @ast-grep/cli, knip, madge
@@ -154,9 +154,9 @@ export default function (pi: ExtensionAPI) {
 
 	// --- Commands ---
 
-	pi.registerCommand("find-todos", {
+	pi.registerCommand("lens-todos", {
 		description:
-			"Scan for TODO/FIXME/HACK annotations. Usage: /find-todos [path]",
+			"Scan for TODO/FIXME/HACK annotations. Usage: /lens-todos [path]",
 		handler: async (args, ctx) => {
 			const targetPath = args.trim() || ctx.cwd || process.cwd();
 			ctx.ui.notify("🔍 Scanning for TODOs...", "info");
@@ -172,8 +172,8 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerCommand("dead-code", {
-		description: "Check for unused exports, files, and dependencies",
+	pi.registerCommand("lens-dead-code", {
+		description: "Check for unused exports, files, and dependencies. Usage: /lens-dead-code [path]",
 		handler: async (args, ctx) => {
 			if (!knipClient.isAvailable()) {
 				ctx.ui.notify("Knip not installed. Run: npm install -D knip", "error");
@@ -192,8 +192,8 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerCommand("check-deps", {
-		description: "Check for circular dependencies in the project",
+	pi.registerCommand("lens-deps", {
+		description: "Check for circular dependencies. Usage: /lens-deps [path]",
 		handler: async (args, ctx) => {
 			if (!depChecker.isAvailable()) {
 				ctx.ui.notify(
@@ -215,95 +215,78 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerCommand("design-review", {
+	pi.registerCommand("lens-review", {
 		description:
-			"Analyze files for design smells (long methods, large classes, deep nesting). Usage: /design-review [path]",
+			"Code review: design smells + complexity metrics. Usage: /lens-review [path]",
 		handler: async (args, ctx) => {
-			if (!astGrepClient.isAvailable()) {
-				ctx.ui.notify(
-					"ast-grep not installed. Run: npm i -D @ast-grep/cli",
-					"error",
-				);
-				return;
-			}
-
 			const targetPath = args.trim() || ctx.cwd || process.cwd();
-			ctx.ui.notify("🔍 Analyzing design smells...", "info");
+			ctx.ui.notify("🔍 Running code review...", "info");
 
-			const configPath = path.join(
-				typeof __dirname !== "undefined" ? __dirname : ".",
-				"rules",
-				"ast-grep-rules",
-				".sgconfig.yml",
-			);
+			const parts: string[] = [];
 
-			try {
-				const result = require("node:child_process").spawnSync("npx", [
-					"sg",
-					"scan",
-					"--config", configPath,
-					"--json",
-					targetPath,
-				], {
-					encoding: "utf-8",
-					timeout: 30000,
-					shell: true,
-				});
-
-				const output = result.stdout || result.stderr || "";
-				if (!output.trim() || result.status !== 1) {
-					ctx.ui.notify("✓ No design smells found", "info");
-					return;
-				}
+			// Part 1: Design smells via ast-grep
+			if (astGrepClient.isAvailable()) {
+				const configPath = path.join(
+					typeof __dirname !== "undefined" ? __dirname : ".",
+					"rules",
+					"ast-grep-rules",
+					".sgconfig.yml",
+				);
 
-				let issues: Array<{line: number; rule: string; message: string}> = [];
-				const lines = output.split("\n").filter((l: string) => l.trim());
-
-				for (const line of lines) {
-					try {
-						const item = JSON.parse(line);
-						const ruleId = item.ruleId || item.name || "unknown";
-						const ruleDesc = astGrepClient.getRuleDescription?.(ruleId);
-						const message = ruleDesc?.message || item.message || ruleId;
-						const lineNum = item.labels?.[0]?.range?.start?.line || 
-							item.spans?.[0]?.range?.start?.line || 0;
-
-						issues.push({
-							line: lineNum + 1,
-							rule: ruleId,
-							message: message,
-						});
-					} catch {
-						// Skip unparseable lines
-					}
-				}
+				try {
+					const result = require("node:child_process").spawnSync("npx", [
+						"sg",
+						"scan",
+						"--config", configPath,
+						"--json",
+						targetPath,
+					], {
+						encoding: "utf-8",
+						timeout: 30000,
+						shell: true,
+					});
 
-				if (issues.length === 0) {
-					ctx.ui.notify("✓ No design smells found", "info");
-					return;
-				}
+					const output = result.stdout || result.stderr || "";
+					if (output.trim() && result.status === 1) {
+						let issues: Array<{line: number; rule: string; message: string}> = [];
+						const lines = output.split("\n").filter((l: string) => l.trim());
+
+						for (const line of lines) {
+							try {
+								const item = JSON.parse(line);
+								const ruleId = item.ruleId || item.name || "unknown";
+								const ruleDesc = astGrepClient.getRuleDescription?.(ruleId);
+								const message = ruleDesc?.message || item.message || ruleId;
+								const lineNum = item.labels?.[0]?.range?.start?.line ||
+									item.spans?.[0]?.range?.start?.line || 0;
+
+								issues.push({
+									line: lineNum + 1,
+									rule: ruleId,
+									message: message,
+								});
+							} catch {
+								// Skip unparseable lines
+							}
+						}
 
-				let report = `[Design Review] ${issues.length} design smell(s) found:\n`;
-				for (const issue of issues.slice(0, 20)) {
-					report += `  L${issue.line}: ${issue.rule} — ${issue.message}\n`;
-				}
-				if (issues.length > 20) {
-					report += `  ... and ${issues.length - 20} more\n`;
+						if (issues.length > 0) {
+							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`;
+							}
+							if (issues.length > 20) {
+								report += `  ... and ${issues.length - 20} more\n`;
+							}
+							parts.push(report);
+						}
+					}
+				} catch (err: any) {
+					// ast-grep scan failed, skip
 				}
-				ctx.ui.notify(report, "info");
-			} catch (err: any) {
-				ctx.ui.notify(`Design review failed: ${err.message}`, "error");
 			}
-		},
-	});
-
-	pi.registerCommand("lens-metrics", {
-		description: "Scan project for complexity metrics (maintainability, cognitive complexity, etc.). Usage: /lens-metrics [path]",
-		handler: async (args, ctx) => {
-			const targetPath = args.trim() || ctx.cwd || process.cwd();
-			ctx.ui.notify("🔍 Scanning project metrics...", "info");
 
-			const startTime = Date.now();
+			// Part 2: Complexity metrics
 			const results: import("./clients/complexity-client.js").FileComplexity[] = [];
 
 			const scanDir = (dir: string) => {
@@ -325,127 +308,49 @@ export default function (pi: ExtensionAPI) {
 			};
 
 			scanDir(targetPath);
-			const duration = Date.now() - startTime;
 
-			if (results.length === 0) {
-				ctx.ui.notify("✓ No TS/JS files found", "info");
-				return;
-			}
+			if (results.length > 0) {
+				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 maxNesting = Math.max(...results.map(r => r.maxNestingDepth));
 
-			// 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 maxNesting = Math.max(...results.map(r => r.maxNestingDepth));
-			const avgHalstead = results.reduce((a, b) => a + b.halsteadVolume, 0) / results.length;
-
-			// Find problem files
-			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);
-			const highNesting = results.filter(r => r.maxNestingDepth > 5).sort((a, b) => b.maxNestingDepth - a.maxNestingDepth);
-
-			// Build markdown report
-			const now = new Date();
-			const timestamp = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
-			const dateStr = now.toISOString().slice(0, 10);
-			const timeStr = now.toISOString().slice(11, 19);
-
-			let report = `# Lens Metrics Report\n\n`;
-			report += `**Date:** ${dateStr} ${timeStr}\n`;
-			report += `**Files scanned:** ${results.length}\n`;
-			report += `**Scan time:** ${duration}ms\n\n`;
-			report += `## Aggregate\n\n`;
-			report += `| Metric | Value |\n`;
-			report += `|--------|-------|\n`;
-			report += `| Maintainability Index | ${avgMI.toFixed(1)} (avg) |\n`;
-			report += `| Cognitive Complexity | ${avgCognitive.toFixed(1)} (avg) |\n`;
-			report += `| Cyclomatic Complexity | ${avgCyclomatic.toFixed(1)} (avg) |\n`;
-			report += `| Halstead Volume | ${avgHalstead.toFixed(1)} (avg) |\n`;
-			report += `| Max Nesting Depth | ${maxNesting} levels |\n\n`;
-
-			if (lowMI.length > 0) {
-				report += `## Low Maintainability (MI < 60)\n\n`;
-				report += `| File | MI |\n`;
-				report += `|------|-----|\n`;
-				for (const f of lowMI) {
-					report += `| ${f.filePath} | ${f.maintainabilityIndex.toFixed(1)} |\n`;
-				}
-				report += `\n`;
-			}
+				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);
 
-			if (highCognitive.length > 0) {
-				report += `## High Cognitive Complexity (> 20)\n\n`;
-				report += `| File | Cognitive | Cyclomatic | Max Nesting |\n`;
-				report += `|------|-----------|------------|-------------|\n`;
-				for (const f of highCognitive) {
-					report += `| ${f.filePath} | ${f.cognitiveComplexity} | ${f.cyclomaticComplexity} | ${f.maxNestingDepth} |\n`;
-				}
-				report += `\n`;
-			}
+				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`;
 
-			if (highNesting.length > 0) {
-				report += `## Deep Nesting (> 5 levels)\n\n`;
-				report += `| File | Max Nesting |\n`;
-				report += `|------|-------------|\n`;
-				for (const f of highNesting) {
-					report += `| ${f.filePath} | ${f.maxNestingDepth} levels |\n`;
-				}
-				report += `\n`;
-			}
-
-			// All files sorted by MI
-			report += `## All Files\n\n`;
-			report += `| File | MI | Cognitive | Cyclomatic | Nesting | Halstead |\n`;
-			report += `|------|-----|-----------|------------|---------|----------|\n`;
-			for (const f of results.sort((a, b) => a.maintainabilityIndex - b.maintainabilityIndex)) {
-				report += `| ${f.filePath} | ${f.maintainabilityIndex.toFixed(1)} | ${f.cognitiveComplexity} | ${f.cyclomaticComplexity} | ${f.maxNestingDepth} | ${f.halsteadVolume.toFixed(0)} |\n`;
-			}
-
-			// Save report
-			const fs = require("node:fs");
-			const metricsDir = path.join(targetPath, ".pi-lens", "metrics");
-			if (!fs.existsSync(metricsDir)) {
-				fs.mkdirSync(metricsDir, { recursive: true });
-			}
-			const timestampedPath = path.join(metricsDir, `metrics-${timestamp}.md`);
-			const latestPath = path.join(metricsDir, "latest.md");
-			fs.writeFileSync(timestampedPath, report);
-			fs.writeFileSync(latestPath, report);
-
-			// Build summary for UI (shorter)
-			let summary = `[Lens Metrics] ${results.length} file(s) scanned in ${duration}ms\n\n`;
-			summary += `── Aggregate ──\n`;
-			summary += `  Maintainability Index: ${avgMI.toFixed(1)} (avg)\n`;
-			summary += `  Cognitive Complexity: ${avgCognitive.toFixed(1)} (avg)\n`;
-			summary += `  Cyclomatic Complexity: ${avgCyclomatic.toFixed(1)} (avg)\n`;
-			summary += `  Halstead Volume: ${avgHalstead.toFixed(1)} (avg)\n`;
-			summary += `  Max Nesting Depth: ${maxNesting} levels\n`;
-
-			if (lowMI.length > 0) {
-				summary += `\n── Low Maintainability (MI < 60) ──\n`;
-				for (const f of lowMI.slice(0, 5)) {
-					summary += `  ✗ ${f.filePath}: MI ${f.maintainabilityIndex.toFixed(1)}\n`;
+				if (lowMI.length > 0) {
+					summary += `\n  Low Maintainability (MI < 60):\n`;
+					for (const f of lowMI.slice(0, 5)) {
+						summary += `    ✗ ${f.filePath}: MI ${f.maintainabilityIndex.toFixed(1)}\n`;
+					}
+					if (lowMI.length > 5) summary += `    ... and ${lowMI.length - 5} more\n`;
 				}
-				if (lowMI.length > 5) summary += `  ... and ${lowMI.length - 5} more\n`;
-			}
 
-			if (highCognitive.length > 0) {
-				summary += `\n── High Cognitive Complexity (> 20) ──\n`;
-				for (const f of highCognitive.slice(0, 5)) {
-					summary += `  ⚠ ${f.filePath}: ${f.cognitiveComplexity}\n`;
+				if (highCognitive.length > 0) {
+					summary += `\n  High Cognitive Complexity (> 20):\n`;
+					for (const f of highCognitive.slice(0, 5)) {
+						summary += `    ⚠ ${f.filePath}: ${f.cognitiveComplexity}\n`;
+					}
+					if (highCognitive.length > 5) summary += `    ... and ${highCognitive.length - 5} more\n`;
 				}
-				if (highCognitive.length > 5) summary += `  ... and ${highCognitive.length - 5} more\n`;
-			}
 
-			summary += `\n📁 Full report saved to: .pi-lens/metrics/latest.md`;
+				parts.push(summary);
+			}
 
-			ctx.ui.notify(summary, "info");
+			if (parts.length === 0) {
+				ctx.ui.notify("✓ Code review clean", "info");
+			} else {
+				ctx.ui.notify(parts.join("\n\n"), "info");
+			}
 		},
 	});
 
-	pi.registerCommand("format", {
+	pi.registerCommand("lens-format", {
 		description:
-			"Apply Biome formatting to files. Usage: /format [file-path] or /format --all",
+			"Apply Biome formatting to files. Usage: /lens-format [file-path] or /lens-format --all",
 		handler: async (args, ctx) => {
 			if (!biomeClient.isAvailable()) {
 				ctx.ui.notify(
@@ -582,6 +487,7 @@ export default function (pi: ExtensionAPI) {
 	let sessionSummary: string | null = null;
 	let sessionMetricsShown = false;
 	let cachedJscpdClones: import("./clients/jscpd-client.js").DuplicateClone[] = [];
+	let cachedExports = new Map<string, string>(); // function name -> file path
 	const complexityBaselines: Map<string, import("./clients/complexity-client.js").FileComplexity> = new Map();
 
 	// --- Events ---
@@ -661,6 +567,15 @@ export default function (pi: ExtensionAPI) {
 			dbg(`session_start type-coverage: not available`);
 		}
 
+		// Scan for exported functions (cached for duplicate detection on write)
+		if (astGrepClient.isAvailable()) {
+			const exports = await astGrepClient.scanExports(cwd, "typescript");
+			dbg(`session_start exports scan: ${exports.size} functions found`);
+			for (const [name, file] of exports) {
+				cachedExports.set(name, file);
+			}
+		}
+
 		if (parts.length > 0) {
 			sessionSummary = `[Session Start]\n${parts.join("\n\n")}`;
 			dbg(`session_start summary queued (${parts.length} parts)`);
@@ -844,34 +759,37 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
-		// Biome: lint + format check
+		// Biome: lint only (formatting noise filtered out, use /lens-format)
 		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);
-			dbg(`  biome diags: ${biomeDiags.length}`);
-			if (pi.getFlag("autofix-biome") && biomeDiags.length > 0) {
+			// 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
 				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);
-					if (remaining.length > 0) {
-						lspOutput += `\n\n${biomeClient.formatDiagnostics(remaining, 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(biomeDiags, filePath)}`;
+					lspOutput += `\n\n${biomeClient.formatDiagnostics(lintDiags, filePath)}`;
 				}
-			} else if (biomeDiags.length > 0) {
-				const fixable = biomeDiags.filter((d) => d.fixable);
-				lspOutput += `\n\n${biomeClient.formatDiagnostics(biomeDiags, 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 /format`;
+					lspOutput += `\n\n[Biome] ${fixable.length} fixable — enable --autofix-biome flag or run /lens-format`;
 				}
 			}
 		}
@@ -942,6 +860,36 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
+		// Check for duplicate exports (function already exists elsewhere)
+		if (cachedExports.size > 0 && /\.(ts|tsx|js|jsx)$/.test(filePath)) {
+			try {
+				const newExports = await astGrepClient.scanExports(filePath, "typescript");
+				const dupes: string[] = [];
+				for (const [name, file] of newExports) {
+					if (cachedExports.has(name)) {
+						const existingFile = cachedExports.get(name);
+						if (existingFile && path.resolve(existingFile) !== path.resolve(filePath)) {
+							dupes.push(`${name} (already in ${path.basename(existingFile)})`);
+						}
+					}
+				}
+				if (dupes.length > 0) {
+					dbg(`  duplicate exports: ${dupes.length} found`);
+					let exportReport = `[Duplicate Exports] ${dupes.length} function(s) already exist:\n`;
+					for (const dupe of dupes.slice(0, 5)) {
+						exportReport += `  ${dupe}\n`;
+					}
+					lspOutput += `\n\n${exportReport}`;
+				}
+				// Update cache with new exports
+				for (const [name, file] of newExports) {
+					cachedExports.set(name, file);
+				}
+			} catch {
+				// ast-grep not available, skip
+			}
+		}
+
 		// Silent metrics summary (appended to first tool_result after files are touched)
 		const metricsSummary = metricsClient.formatSessionSummary();
 		if (metricsSummary) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "1.3.4",
+	"version": "1.3.6",
 	"description": "Real-time code feedback for pi — TypeScript LSP, Biome, ast-grep, Ruff, TODO scanner, dead code, duplicate detection, type coverage",
 	"repository": {
 		"type": "git",