pi-lens 2.1.0 → 2.2.0

package/commands/fix.js

@@ -84,71 +84,69 @@ function generatePlan(results, session, _isTsProject, prevCounts) {
     if (noProgress) {
         return `⚠️ BOOBOO FIX LOOP STOPPED — No progress after ${session.iteration} iteration(s).\n\nRemaining items may be false positives. Mark with: /lens-booboo-fix --false-positive "<type>:<file>:<line>"`;
     }
-    // Build plan
-    const lines = [];
-    lines.push(`📋 BOOBOO FIX PLAN — Iteration ${session.iteration}/${MAX_ITERATIONS} (${totalFixable} fixable items remaining)`);
-    lines.push("");
+    // --- Write TSV plan file for agent to read ---
+    const reportDir = path.join(process.cwd(), ".pi-lens", "reports");
+    nodeFs.mkdirSync(reportDir, { recursive: true });
+    const reportPath = path.join(reportDir, "fix-plan.tsv");
+    const tsvRows = ["type\tfile\trule\tmessage"];
     // Duplicates
-    if (filteredDups.length > 0) {
-        lines.push(`## 🔁 Duplicate code [${filteredDups.length} block(s)] — fix first`);
-        lines.push("→ Extract duplicated blocks into shared utilities.");
-        for (const clone of filteredDups.slice(0, 5)) {
-            lines.push(`  - ${clone.lines} lines: \`${clone.fileA}:${clone.startA}\` ↔ \`${clone.fileB}:${clone.startB}\``);
-        }
-        if (filteredDups.length > 5)
-            lines.push(`  ... and ${filteredDups.length - 5} more`);
-        lines.push("");
+    for (const clone of filteredDups) {
+        tsvRows.push(`dup\t${clone.fileA}:${clone.startA}\tduplicate-code\t${clone.lines} lines duplicated with ${clone.fileB}:${clone.startB}`);
     }
     // Dead code
-    if (filteredDeadCode.length > 0) {
-        lines.push(`## 🗑️ Dead code [${filteredDeadCode.length} item(s)]`);
-        for (const issue of filteredDeadCode.slice(0, 10)) {
-            lines.push(`  - [${issue.type}] \`${issue.name}\`${issue.file ? ` in ${issue.file}` : ""}`);
+    for (const issue of filteredDeadCode) {
+        tsvRows.push(`dead\t${issue.file || issue.name}\t${issue.type}\t${issue.name} is unused`);
+    }
+    // AST issues
+    for (const issue of agentTasks) {
+        tsvRows.push(`ast\t${issue.file}:${issue.line}\t${issue.rule}\t${issue.message}`);
+    }
+    // Biome
+    for (const issue of filteredBiome) {
+        tsvRows.push(`biome\t${issue.file}:${issue.line}\t${issue.rule}\t${issue.message}`);
+    }
+    // Slop
+    for (const { file, warnings } of filteredSlop) {
+        for (const w of warnings) {
+            tsvRows.push(`slop\t${file}\tcomplexity\t${w}`);
         }
-        if (filteredDeadCode.length > 10)
-            lines.push(`  ... and ${filteredDeadCode.length - 10} more`);
-        lines.push("");
     }
-    // AST issues to fix
+    nodeFs.writeFileSync(reportPath, tsvRows.join("\n"), "utf-8");
+    // --- Build compact summary for terminal ---
+    const lines = [];
+    lines.push(`📋 FIX PLAN — Iteration ${session.iteration}/${MAX_ITERATIONS} — ${totalFixable} issues`);
+    lines.push(`📄 Full plan: .pi-lens/reports/fix-plan.tsv\n`);
+    // Summary by category with counts
+    if (filteredDups.length > 0) {
+        lines.push(`🔁 Duplicates: ${filteredDups.length} block(s) — extract to shared utils`);
+    }
+    if (filteredDeadCode.length > 0) {
+        lines.push(`🗑️ Dead code: ${filteredDeadCode.length} item(s) — remove unused exports`);
+    }
     if (agentTasks.length > 0) {
-        lines.push(`## 🔨 Fix these [${agentTasks.length} items]`);
+        // Group by rule, show top 5 rules
         const grouped = new Map();
         for (const t of agentTasks) {
-            const list = grouped.get(t.rule) ?? [];
-            list.push(t);
-            grouped.set(t.rule, list);
+            grouped.set(t.rule, (grouped.get(t.rule) ?? 0) + 1);
         }
-        for (const [rule, issues] of grouped) {
-            lines.push(`### ${rule} (${issues.length})`);
-            for (const issue of issues.slice(0, 10)) {
-                lines.push(`  - \`${issue.file}:${issue.line}\``);
-            }
-            if (issues.length > 10)
-                lines.push(`  ... and ${issues.length - 10} more`);
-            lines.push("");
+        const sorted = [...grouped.entries()].sort((a, b) => b[1] - a[1]);
+        lines.push(`🔨 Lint: ${agentTasks.length} item(s)`);
+        for (const [rule, count] of sorted.slice(0, 5)) {
+            lines.push(`   ${rule}: ${count}`);
         }
+        if (sorted.length > 5)
+            lines.push(`   ... and ${sorted.length - 5} more rules`);
     }
-    // Biome lint
     if (filteredBiome.length > 0) {
-        lines.push(`## 🟠 Biome lint [${filteredBiome.length} items]`);
-        for (const d of filteredBiome.slice(0, 5)) {
-            lines.push(`  - \`${d.file}:${d.line}\` [${d.rule}] ${d.message}`);
-        }
-        if (filteredBiome.length > 5)
-            lines.push(`  ... and ${filteredBiome.length - 5} more`);
-        lines.push("");
+        lines.push(`🟠 Biome: ${filteredBiome.length} item(s) — auto-fixable`);
     }
-    // AI slop
     if (filteredSlop.length > 0) {
-        lines.push(`## 🤖 AI Slop indicators [${filteredSlop.length} files]`);
-        for (const { file, warnings } of filteredSlop.slice(0, 5)) {
-            lines.push(`  - \`${file}\`: ${warnings.map((w) => w.split(" — ")[0]).join(", ")}`);
-        }
-        lines.push("");
+        lines.push(`🤖 AI Slop: ${filteredSlop.length} file(s) — review complexity`);
     }
-    lines.push("---");
-    lines.push("**ACTION REQUIRED**: Fix items above, then run `/lens-booboo-fix --loop` again.");
-    lines.push('Mark false positives with: `/lens-booboo-fix --false-positive "type:file:line"`');
+    lines.push("\n---");
+    lines.push("📖 **Read plan**: `read .pi-lens/reports/fix-plan.tsv` for full details");
+    lines.push("🚀 **Fix & loop**: Fix items, then run `/lens-booboo-fix --loop`");
+    lines.push('🚫 **False positive**: `/lens-booboo-fix --false-positive "type:file:line"`');
     return lines.join("\n");
 }
 // --- Main handler ---

package/commands/fix.ts

@@ -139,90 +139,100 @@ function generatePlan(
 		return `⚠️ BOOBOO FIX LOOP STOPPED — No progress after ${session.iteration} iteration(s).\n\nRemaining items may be false positives. Mark with: /lens-booboo-fix --false-positive "<type>:<file>:<line>"`;
 	}
 
-	// Build plan
+	// --- Write TSV plan file for agent to read ---
+	const reportDir = path.join(process.cwd(), ".pi-lens", "reports");
+	nodeFs.mkdirSync(reportDir, { recursive: true });
+	const reportPath = path.join(reportDir, "fix-plan.tsv");
+
+	const tsvRows: string[] = ["type\tfile\trule\tmessage"];
+
+	// Duplicates
+	for (const clone of filteredDups) {
+		tsvRows.push(
+			`dup\t${clone.fileA}:${clone.startA}\tduplicate-code\t${clone.lines} lines duplicated with ${clone.fileB}:${clone.startB}`,
+		);
+	}
+
+	// Dead code
+	for (const issue of filteredDeadCode) {
+		tsvRows.push(
+			`dead\t${issue.file || issue.name}\t${issue.type}\t${issue.name} is unused`,
+		);
+	}
+
+	// AST issues
+	for (const issue of agentTasks) {
+		tsvRows.push(
+			`ast\t${issue.file}:${issue.line}\t${issue.rule}\t${issue.message}`,
+		);
+	}
+
+	// Biome
+	for (const issue of filteredBiome) {
+		tsvRows.push(
+			`biome\t${issue.file}:${issue.line}\t${issue.rule}\t${issue.message}`,
+		);
+	}
+
+	// Slop
+	for (const { file, warnings } of filteredSlop) {
+		for (const w of warnings) {
+			tsvRows.push(`slop\t${file}\tcomplexity\t${w}`);
+		}
+	}
+
+	nodeFs.writeFileSync(reportPath, tsvRows.join("\n"), "utf-8");
+
+	// --- Build compact summary for terminal ---
 	const lines: string[] = [];
 	lines.push(
-		`📋 BOOBOO FIX PLAN — Iteration ${session.iteration}/${MAX_ITERATIONS} (${totalFixable} fixable items remaining)`,
+		`📋 FIX PLAN — Iteration ${session.iteration}/${MAX_ITERATIONS} — ${totalFixable} issues`,
 	);
-	lines.push("");
+	lines.push(`📄 Full plan: .pi-lens/reports/fix-plan.tsv\n`);
 
-	// Duplicates
+	// Summary by category with counts
 	if (filteredDups.length > 0) {
 		lines.push(
-			`## 🔁 Duplicate code [${filteredDups.length} block(s)] — fix first`,
+			`🔁 Duplicates: ${filteredDups.length} block(s) — extract to shared utils`,
 		);
-		lines.push("→ Extract duplicated blocks into shared utilities.");
-		for (const clone of filteredDups.slice(0, 5)) {
-			lines.push(
-				`  - ${clone.lines} lines: \`${clone.fileA}:${clone.startA}\` ↔ \`${clone.fileB}:${clone.startB}\``,
-			);
-		}
-		if (filteredDups.length > 5)
-			lines.push(`  ... and ${filteredDups.length - 5} more`);
-		lines.push("");
 	}
-
-	// Dead code
 	if (filteredDeadCode.length > 0) {
-		lines.push(`## 🗑️ Dead code [${filteredDeadCode.length} item(s)]`);
-		for (const issue of filteredDeadCode.slice(0, 10)) {
-			lines.push(
-				`  - [${issue.type}] \`${issue.name}\`${issue.file ? ` in ${issue.file}` : ""}`,
-			);
-		}
-		if (filteredDeadCode.length > 10)
-			lines.push(`  ... and ${filteredDeadCode.length - 10} more`);
-		lines.push("");
+		lines.push(
+			`🗑️ Dead code: ${filteredDeadCode.length} item(s) — remove unused exports`,
+		);
 	}
-
-	// AST issues to fix
 	if (agentTasks.length > 0) {
-		lines.push(`## 🔨 Fix these [${agentTasks.length} items]`);
-		const grouped = new Map<string, AstIssue[]>();
+		// Group by rule, show top 5 rules
+		const grouped = new Map<string, number>();
 		for (const t of agentTasks) {
-			const list = grouped.get(t.rule) ?? [];
-			list.push(t);
-			grouped.set(t.rule, list);
+			grouped.set(t.rule, (grouped.get(t.rule) ?? 0) + 1);
 		}
-		for (const [rule, issues] of grouped) {
-			lines.push(`### ${rule} (${issues.length})`);
-			for (const issue of issues.slice(0, 10)) {
-				lines.push(`  - \`${issue.file}:${issue.line}\``);
-			}
-			if (issues.length > 10)
-				lines.push(`  ... and ${issues.length - 10} more`);
-			lines.push("");
+		const sorted = [...grouped.entries()].sort((a, b) => b[1] - a[1]);
+		lines.push(`🔨 Lint: ${agentTasks.length} item(s)`);
+		for (const [rule, count] of sorted.slice(0, 5)) {
+			lines.push(`   ${rule}: ${count}`);
 		}
+		if (sorted.length > 5)
+			lines.push(`   ... and ${sorted.length - 5} more rules`);
 	}
-
-	// Biome lint
 	if (filteredBiome.length > 0) {
-		lines.push(`## 🟠 Biome lint [${filteredBiome.length} items]`);
-		for (const d of filteredBiome.slice(0, 5)) {
-			lines.push(`  - \`${d.file}:${d.line}\` [${d.rule}] ${d.message}`);
-		}
-		if (filteredBiome.length > 5)
-			lines.push(`  ... and ${filteredBiome.length - 5} more`);
-		lines.push("");
+		lines.push(`🟠 Biome: ${filteredBiome.length} item(s) — auto-fixable`);
 	}
-
-	// AI slop
 	if (filteredSlop.length > 0) {
-		lines.push(`## 🤖 AI Slop indicators [${filteredSlop.length} files]`);
-		for (const { file, warnings } of filteredSlop.slice(0, 5)) {
-			lines.push(
-				`  - \`${file}\`: ${warnings.map((w) => w.split(" — ")[0]).join(", ")}`,
-			);
-		}
-		lines.push("");
+		lines.push(
+			`🤖 AI Slop: ${filteredSlop.length} file(s) — review complexity`,
+		);
 	}
 
-	lines.push("---");
+	lines.push("\n---");
+	lines.push(
+		"📖 **Read plan**: `read .pi-lens/reports/fix-plan.tsv` for full details",
+	);
 	lines.push(
-		"**ACTION REQUIRED**: Fix items above, then run `/lens-booboo-fix --loop` again.",
+		"🚀 **Fix & loop**: Fix items, then run `/lens-booboo-fix --loop`",
 	);
 	lines.push(
-		'Mark false positives with: `/lens-booboo-fix --false-positive "type:file:line"`',
+		'🚫 **False positive**: `/lens-booboo-fix --false-positive "type:file:line"`',
 	);
 
 	return lines.join("\n");

package/commands/rate.js

@@ -0,0 +1,285 @@
+/**
+ * /lens-rate command
+ *
+ * Provides a visual scoring breakdown of code quality across multiple dimensions.
+ * Uses existing scan data to calculate scores.
+ */
+import * as childProcess from "node:child_process";
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+import { getSourceFiles } from "../clients/scan-utils.js";
+/**
+ * Run all scans and calculate scores
+ */
+export async function gatherScores(targetPath, clients) {
+    const isTsProject = nodeFs.existsSync(path.join(targetPath, "tsconfig.json"));
+    const files = getSourceFiles(targetPath, isTsProject);
+    const categories = [];
+    // ─── Type Safety ───
+    let typeCoverageScore = 100;
+    const typeIssues = [];
+    if (clients.typeCoverage.isAvailable()) {
+        const result = clients.typeCoverage.scan(targetPath);
+        if (result.success) {
+            typeCoverageScore = result.percentage;
+            if (result.percentage < 90) {
+                typeIssues.push(`${result.total - result.typed} untyped identifiers`);
+            }
+        }
+    }
+    categories.push({
+        name: "Type Safety",
+        score: Math.round(typeCoverageScore),
+        icon: "🔷",
+        issues: typeIssues,
+    });
+    // ─── Complexity ───
+    let complexityScore = 100;
+    const complexityIssues = [];
+    let totalScore = 0;
+    let fileCount = 0;
+    let worstFile = "";
+    let worstScore = 100;
+    for (const file of files.slice(0, 50)) {
+        if (clients.complexity.isSupportedFile(file)) {
+            const metrics = clients.complexity.analyzeFile(file);
+            if (metrics) {
+                totalScore += metrics.maintainabilityIndex;
+                fileCount++;
+                if (metrics.maintainabilityIndex < worstScore) {
+                    worstScore = metrics.maintainabilityIndex;
+                    worstFile = path.basename(file);
+                }
+            }
+        }
+    }
+    if (fileCount > 0) {
+        complexityScore = totalScore / fileCount;
+        if (complexityScore < 70) {
+            complexityIssues.push(`High complexity: ${worstFile}`);
+        }
+    }
+    categories.push({
+        name: "Complexity",
+        score: Math.round(complexityScore),
+        icon: "🧩",
+        issues: complexityIssues,
+    });
+    // ─── Security ───
+    let securityScore = 100;
+    const securityIssues = [];
+    let secretsFound = 0;
+    // Check for secrets in source files
+    const secretPatterns = [
+        { name: "API Key (sk-)", pattern: /sk-[a-zA-Z0-9]{20,}/ },
+        { name: "GitHub Token", pattern: /ghp_[a-zA-Z0-9]{36}/ },
+        { name: "AWS Key", pattern: /AKIA[A-Z0-9]{16}/ },
+        { name: "Anthropic Key", pattern: /sk-ant-[a-zA-Z0-9]{20,}/ },
+        { name: "OpenAI Key", pattern: /sk-proj-[a-zA-Z0-9]{20,}/ },
+        {
+            name: "Private Key",
+            pattern: /-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----/,
+        },
+    ];
+    for (const file of files.slice(0, 100)) {
+        try {
+            const content = nodeFs.readFileSync(file, "utf-8");
+            for (const line of content.split("\n")) {
+                if (line.trim().startsWith("//") || line.trim().startsWith("#"))
+                    continue;
+                for (const { name, pattern } of secretPatterns) {
+                    if (pattern.test(line)) {
+                        secretsFound++;
+                        if (securityIssues.length < 3) {
+                            securityIssues.push(`${name} in ${path.basename(file)}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    securityScore = Math.max(0, 100 - secretsFound * 15);
+    categories.push({
+        name: "Security",
+        score: securityScore,
+        icon: "🔒",
+        issues: securityIssues,
+    });
+    // ─── Architecture ───
+    let archScore = 100;
+    const archIssues = [];
+    clients.architect.loadConfig(targetPath);
+    if (clients.architect.hasConfig()) {
+        let archViolations = 0;
+        const scanDir = (dir) => {
+            for (const entry of nodeFs.readdirSync(dir, { withFileTypes: true })) {
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if ([
+                        "node_modules",
+                        ".git",
+                        "dist",
+                        "build",
+                        ".next",
+                        ".pi-lens",
+                    ].includes(entry.name))
+                        continue;
+                    scanDir(full);
+                }
+                else if (/\.(ts|tsx|js|jsx|py|go|rs)$/.test(entry.name)) {
+                    const relPath = path.relative(targetPath, full).replace(/\\/g, "/");
+                    const content = nodeFs.readFileSync(full, "utf-8");
+                    const violations = clients.architect.checkFile(relPath, content);
+                    archViolations += violations.length;
+                    if (violations.length > 0 && archIssues.length < 3) {
+                        archIssues.push(`${violations.length} in ${path.basename(full)}`);
+                    }
+                    const sizeV = clients.architect.checkFileSize(relPath, content.split("\n").length);
+                    if (sizeV)
+                        archViolations++;
+                }
+            }
+        };
+        scanDir(targetPath);
+        archScore = Math.max(0, 100 - archViolations * 10);
+    }
+    categories.push({
+        name: "Architecture",
+        score: archScore,
+        icon: "🏗️",
+        issues: archIssues,
+    });
+    // ─── Dead Code ───
+    let deadCodeScore = 100;
+    const deadCodeIssues = [];
+    if (clients.knip.isAvailable()) {
+        const result = clients.knip.analyze(targetPath);
+        if (result.success) {
+            const unusedExports = result.unusedExports.length;
+            const unusedFiles = result.unusedFiles.length;
+            const total = unusedExports + unusedFiles;
+            deadCodeScore = Math.max(0, 100 - total * 3);
+            if (unusedExports > 0) {
+                deadCodeIssues.push(`${unusedExports} unused export(s)`);
+            }
+            if (unusedFiles > 0) {
+                deadCodeIssues.push(`${unusedFiles} unused file(s)`);
+            }
+        }
+    }
+    categories.push({
+        name: "Dead Code",
+        score: deadCodeScore,
+        icon: "🗑️",
+        issues: deadCodeIssues,
+    });
+    // ─── Tests ───
+    let testScore = 100;
+    const testIssues = [];
+    // Quick test run
+    try {
+        const testResult = childProcess.spawnSync("npx", ["vitest", "run", "--reporter=basic"], {
+            encoding: "utf-8",
+            timeout: 60000,
+            shell: true,
+            cwd: targetPath,
+        });
+        if (testResult.status !== 0) {
+            const output = (testResult.stdout || "") + (testResult.stderr || "");
+            if (output.includes("failed")) {
+                // Count failing tests
+                const failMatch = output.match(/(\d+) failed/);
+                testScore = 50;
+                testIssues.push(failMatch ? `${failMatch[1]} test(s) failing` : "Some tests failing");
+            }
+            else {
+                testScore = 70;
+                testIssues.push("Tests timed out or errored");
+            }
+        }
+    }
+    catch {
+        testScore = 70;
+        testIssues.push("Could not run tests");
+    }
+    categories.push({
+        name: "Tests",
+        score: testScore,
+        icon: "✅",
+        issues: testIssues,
+    });
+    // ─── Calculate Overall ───
+    const overall = Math.round(categories.reduce((sum, c) => sum + c.score, 0) / categories.length);
+    return { overall, categories };
+}
+/**
+ * Format score as a bar
+ */
+function scoreBar(score, width = 10) {
+    const filled = Math.round((score / 100) * width);
+    const empty = width - filled;
+    const color = score >= 80 ? "🟩" : score >= 60 ? "🟨" : "🟥";
+    return color.repeat(filled) + "⬜".repeat(empty);
+}
+/**
+ * Get grade from score
+ */
+function getGrade(score) {
+    if (score >= 90)
+        return "A";
+    if (score >= 80)
+        return "B";
+    if (score >= 70)
+        return "C";
+    if (score >= 60)
+        return "D";
+    return "F";
+}
+/**
+ * Format rate result for terminal
+ */
+export function formatRateResult(result) {
+    const lines = [];
+    lines.push("┌─────────────────────────────────────────────────────────┐");
+    const gradeText = ` (${getGrade(result.overall)})`;
+    const scoreText = `📊 CODE QUALITY SCORE: ${result.overall}/100${gradeText}`;
+    const padding = Math.max(0, 55 - scoreText.length);
+    lines.push(`│  ${scoreText}${" ".repeat(padding)}│`);
+    lines.push("├─────────────────────────────────────────────────────────┤");
+    for (const cat of result.categories) {
+        const name = cat.name.padEnd(14);
+        const bar = scoreBar(cat.score);
+        const score = String(cat.score).padStart(3);
+        lines.push(`│  ${cat.icon} ${name} ${bar} ${score} │`);
+    }
+    lines.push("└─────────────────────────────────────────────────────────┘");
+    // Show issues if any
+    const allIssues = result.categories
+        .filter((c) => c.issues.length > 0)
+        .flatMap((c) => c.issues.map((i) => `${c.icon} ${c.name}: ${i}`));
+    if (allIssues.length > 0) {
+        lines.push("");
+        lines.push("Issues to address:");
+        for (const issue of allIssues.slice(0, 5)) {
+            lines.push(`  • ${issue}`);
+        }
+        if (allIssues.length > 5) {
+            lines.push(`  ... and ${allIssues.length - 5} more`);
+        }
+        lines.push("");
+        lines.push("💡 Run /lens-booboo for full details");
+    }
+    return lines.join("\n");
+}
+/**
+ * Handle /lens-rate command
+ */
+export async function handleRate(args, ctx, clients) {
+    const targetPath = args.trim() || ctx.cwd || process.cwd();
+    ctx.ui.notify("📊 Calculating code quality scores...", "info");
+    const result = await gatherScores(targetPath, clients);
+    return formatRateResult(result);
+}