pi-lens 2.1.0 → 2.2.0

package/commands/rate.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import { formatRateResult } from "./rate.js";
+// Test the formatting functions directly with mock data
+describe("formatRateResult", () => {
+    it("should format a visual score breakdown", () => {
+        const result = {
+            overall: 75,
+            categories: [
+                { name: "Type Safety", score: 85, icon: "🔷", issues: [] },
+                { name: "Complexity", score: 70, icon: "🧩", issues: [] },
+                { name: "Security", score: 100, icon: "🔒", issues: [] },
+                { name: "Architecture", score: 85, icon: "🏗️", issues: [] },
+                { name: "Dead Code", score: 100, icon: "🗑️", issues: [] },
+                { name: "Tests", score: 100, icon: "✅", issues: [] },
+            ],
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("CODE QUALITY SCORE");
+        expect(output).toContain("75/100");
+        expect(output).toContain("Type Safety");
+        expect(output).toContain("Security");
+        expect(output).toContain("Tests");
+    });
+    it("should show correct grade for A", () => {
+        const result = {
+            overall: 95,
+            categories: Array(6).fill({
+                name: "Test",
+                score: 95,
+                icon: "✅",
+                issues: [],
+            }),
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("A");
+    });
+    it("should show correct grade for B", () => {
+        const result = {
+            overall: 85,
+            categories: Array(6).fill({
+                name: "Test",
+                score: 85,
+                icon: "✅",
+                issues: [],
+            }),
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("B");
+    });
+    it("should show correct grade for C", () => {
+        const result = {
+            overall: 75,
+            categories: Array(6).fill({
+                name: "Test",
+                score: 75,
+                icon: "✅",
+                issues: [],
+            }),
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("C");
+    });
+    it("should show issues section when there are problems", () => {
+        const result = {
+            overall: 50,
+            categories: [
+                {
+                    name: "Type Safety",
+                    score: 50,
+                    icon: "🔷",
+                    issues: ["50 untyped identifiers"],
+                },
+                {
+                    name: "Complexity",
+                    score: 50,
+                    icon: "🧩",
+                    issues: ["High complexity: foo.ts"],
+                },
+                { name: "Security", score: 100, icon: "🔒", issues: [] },
+                { name: "Architecture", score: 100, icon: "🏗️", issues: [] },
+                { name: "Dead Code", score: 100, icon: "🗑️", issues: [] },
+                { name: "Tests", score: 100, icon: "✅", issues: [] },
+            ],
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("Issues to address");
+        expect(output).toContain("Type Safety");
+        expect(output).toContain("/lens-booboo");
+    });
+    it("should not show issues section when clean", () => {
+        const result = {
+            overall: 100,
+            categories: Array(6).fill({
+                name: "Test",
+                score: 100,
+                icon: "✅",
+                issues: [],
+            }),
+        };
+        const output = formatRateResult(result);
+        expect(output).not.toContain("Issues to address");
+    });
+    it("should use colored bars based on score", () => {
+        const resultHigh = {
+            overall: 90,
+            categories: [{ name: "Test", score: 85, icon: "✅", issues: [] }],
+        };
+        const resultLow = {
+            overall: 50,
+            categories: [{ name: "Test", score: 50, icon: "✅", issues: [] }],
+        };
+        const outputHigh = formatRateResult(resultHigh);
+        const outputLow = formatRateResult(resultLow);
+        // High score should have green squares
+        expect(outputHigh).toContain("🟩");
+        // Low score should have red squares
+        expect(outputLow).toContain("🟥");
+    });
+});

package/commands/rate.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it } from "vitest";
+import { formatRateResult } from "./rate.js";
+
+// Test the formatting functions directly with mock data
+
+describe("formatRateResult", () => {
+	it("should format a visual score breakdown", () => {
+		const result = {
+			overall: 75,
+			categories: [
+				{ name: "Type Safety", score: 85, icon: "🔷", issues: [] },
+				{ name: "Complexity", score: 70, icon: "🧩", issues: [] },
+				{ name: "Security", score: 100, icon: "🔒", issues: [] },
+				{ name: "Architecture", score: 85, icon: "🏗️", issues: [] },
+				{ name: "Dead Code", score: 100, icon: "🗑️", issues: [] },
+				{ name: "Tests", score: 100, icon: "✅", issues: [] },
+			],
+		};
+
+		const output = formatRateResult(result);
+
+		expect(output).toContain("CODE QUALITY SCORE");
+		expect(output).toContain("75/100");
+		expect(output).toContain("Type Safety");
+		expect(output).toContain("Security");
+		expect(output).toContain("Tests");
+	});
+
+	it("should show correct grade for A", () => {
+		const result = {
+			overall: 95,
+			categories: Array(6).fill({
+				name: "Test",
+				score: 95,
+				icon: "✅",
+				issues: [],
+			}),
+		};
+		const output = formatRateResult(result);
+		expect(output).toContain("A");
+	});
+
+	it("should show correct grade for B", () => {
+		const result = {
+			overall: 85,
+			categories: Array(6).fill({
+				name: "Test",
+				score: 85,
+				icon: "✅",
+				issues: [],
+			}),
+		};
+		const output = formatRateResult(result);
+		expect(output).toContain("B");
+	});
+
+	it("should show correct grade for C", () => {
+		const result = {
+			overall: 75,
+			categories: Array(6).fill({
+				name: "Test",
+				score: 75,
+				icon: "✅",
+				issues: [],
+			}),
+		};
+		const output = formatRateResult(result);
+		expect(output).toContain("C");
+	});
+
+	it("should show issues section when there are problems", () => {
+		const result = {
+			overall: 50,
+			categories: [
+				{
+					name: "Type Safety",
+					score: 50,
+					icon: "🔷",
+					issues: ["50 untyped identifiers"],
+				},
+				{
+					name: "Complexity",
+					score: 50,
+					icon: "🧩",
+					issues: ["High complexity: foo.ts"],
+				},
+				{ name: "Security", score: 100, icon: "🔒", issues: [] },
+				{ name: "Architecture", score: 100, icon: "🏗️", issues: [] },
+				{ name: "Dead Code", score: 100, icon: "🗑️", issues: [] },
+				{ name: "Tests", score: 100, icon: "✅", issues: [] },
+			],
+		};
+		const output = formatRateResult(result);
+		expect(output).toContain("Issues to address");
+		expect(output).toContain("Type Safety");
+		expect(output).toContain("/lens-booboo");
+	});
+
+	it("should not show issues section when clean", () => {
+		const result = {
+			overall: 100,
+			categories: Array(6).fill({
+				name: "Test",
+				score: 100,
+				icon: "✅",
+				issues: [],
+			}),
+		};
+		const output = formatRateResult(result);
+		expect(output).not.toContain("Issues to address");
+	});
+
+	it("should use colored bars based on score", () => {
+		const resultHigh = {
+			overall: 90,
+			categories: [{ name: "Test", score: 85, icon: "✅", issues: [] }],
+		};
+		const resultLow = {
+			overall: 50,
+			categories: [{ name: "Test", score: 50, icon: "✅", issues: [] }],
+		};
+
+		const outputHigh = formatRateResult(resultHigh);
+		const outputLow = formatRateResult(resultLow);
+
+		// High score should have green squares
+		expect(outputHigh).toContain("🟩");
+		// Low score should have red squares
+		expect(outputLow).toContain("🟥");
+	});
+});

package/commands/rate.ts

@@ -0,0 +1,348 @@
+/**
+ * /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 type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ArchitectClient } from "../clients/architect-client.js";
+import type { ComplexityClient } from "../clients/complexity-client.js";
+import type { KnipClient } from "../clients/knip-client.js";
+import { getSourceFiles } from "../clients/scan-utils.js";
+import type { TypeCoverageClient } from "../clients/type-coverage-client.js";
+
+interface CategoryScore {
+	name: string;
+	score: number; // 0-100
+	icon: string;
+	issues: string[];
+}
+
+interface RateResult {
+	overall: number;
+	categories: CategoryScore[];
+}
+
+interface ScanClients {
+	complexity: ComplexityClient;
+	knip: KnipClient;
+	typeCoverage: TypeCoverageClient;
+	architect: ArchitectClient;
+}
+
+/**
+ * Run all scans and calculate scores
+ */
+export async function gatherScores(
+	targetPath: string,
+	clients: ScanClients,
+): Promise<RateResult> {
+	const isTsProject = nodeFs.existsSync(path.join(targetPath, "tsconfig.json"));
+	const files = getSourceFiles(targetPath, isTsProject);
+	const categories: CategoryScore[] = [];
+
+	// ─── Type Safety ───
+	let typeCoverageScore = 100;
+	const typeIssues: string[] = [];
+
+	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: string[] = [];
+
+	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: string[] = [];
+	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: string[] = [];
+
+	clients.architect.loadConfig(targetPath);
+	if (clients.architect.hasConfig()) {
+		let archViolations = 0;
+		const scanDir = (dir: string) => {
+			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: string[] = [];
+
+	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: string[] = [];
+
+	// 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: number, width = 10): string {
+	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: number): string {
+	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: RateResult): string {
+	const lines: string[] = [];
+
+	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: string,
+	ctx: ExtensionContext,
+	clients: ScanClients,
+): Promise<string> {
+	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);
+}

package/commands/refactor.js

@@ -1,7 +1,7 @@
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
 import { createAutoLoop } from "../clients/auto-loop.js";
-import { extractCodeSnippet, scanArchitectViolations, scanComplexityMetrics, scanSkipViolations, scoreFiles, } from "../clients/scan-architectural-debt.js";
+import { scanArchitectViolations, scanComplexityMetrics, scanSkipViolations, scoreFiles, } from "../clients/scan-architectural-debt.js";
 // Auto-loop singleton for refactor command (initialized at module load)
 let refactorLoop = null;
 export function initRefactorLoop(pi) {
@@ -49,15 +49,28 @@ export async function handleRefactor(args, ctx, clients, pi, skipRules, ruleActi
         ctx.ui.notify("✅ No architectural debt found — codebase is clean.", "info");
         return;
     }
+    // --- Write ranked list to TSV for agent reference ---
+    const reportDir = path.join(process.cwd(), ".pi-lens", "reports");
+    nodeFs.mkdirSync(reportDir, { recursive: true });
+    const reportPath = path.join(reportDir, "refactor-ranked.tsv");
+    const tsvRows = [
+        "rank\tfile\tscore\tmi\tcognitive\tnesting\tviolations",
+    ];
+    scored.slice(0, 50).forEach((f, i) => {
+        const m = metricsByFile.get(f.file);
+        const skipCount = skipByFile.get(f.file)?.length ?? 0;
+        const archCount = architectViolations?.get(f.file)?.length ?? 0;
+        const totalViolations = skipCount + archCount;
+        const relPath = path.relative(targetPath, f.file).replace(/\\/g, "/");
+        tsvRows.push(`${i + 1}\t${relPath}\t${f.score}\t${m?.mi.toFixed(1) ?? "-"}\t${m?.cognitive ?? "-"}\t${m?.nesting ?? "-"}\t${totalViolations}`);
+    });
+    nodeFs.writeFileSync(reportPath, tsvRows.join("\n"), "utf-8");
+    // --- Current worst offender ---
     const { file: worstFile, score } = scored[0];
     const relFile = path.relative(targetPath, worstFile).replace(/\\/g, "/");
     const issues = skipByFile.get(worstFile) ?? [];
     const metrics = metricsByFile.get(worstFile);
     const archIssues = architectViolations.get(worstFile) ?? [];
-    const snippetResult = issues.length > 0 ? extractCodeSnippet(worstFile, issues[0].line) : null;
-    const snippet = snippetResult?.snippet ?? "";
-    const snippetStart = snippetResult?.start ?? 1;
-    const snippetEnd = snippetResult?.end ?? 1;
     const ruleGroups = new Map();
     for (const i of issues)
         ruleGroups.set(i.rule, (ruleGroups.get(i.rule) ?? 0) + 1);
@@ -68,6 +81,19 @@ export async function handleRefactor(args, ctx, clients, pi, skipRules, ruleActi
     const metricsSummary = metrics
         ? `MI: ${metrics.mi.toFixed(1)}, Cognitive: ${metrics.cognitive}, Nesting: ${metrics.nesting}`
         : "";
+    // First violation line for quick reference
+    const firstViolationLine = issues.length > 0 ? issues[0].line : null;
+    // --- Compact terminal summary ---
+    const topFiles = scored
+        .slice(0, 5)
+        .map((f, i) => {
+        const name = path.relative(targetPath, f.file).replace(/\\/g, "/");
+        return `  ${i + 1}. ${name} (score: ${f.score})`;
+    })
+        .join("\n");
+    ctx.ui.notify(`🏗️ Worst: ${relFile} (score: ${score}) — ${scored.length} files with debt`, "info");
+    console.log(`\n📊 Top ${Math.min(scored.length, 5)} worst offenders:\n${topFiles}\n📄 Full ranked list: .pi-lens/reports/refactor-ranked.tsv\n`);
+    // --- Steer message for agent ---
     const steer = [
         `🏗️ BOOBOO REFACTOR — worst offender identified`,
         "",
@@ -79,11 +105,9 @@ export async function handleRefactor(args, ctx, clients, pi, skipRules, ruleActi
         archIssues.length > 0
             ? `**Architectural rules violated**:\n${archSummary}`
             : "",
+        firstViolationLine ? `First violation at line ${firstViolationLine}` : "",
         "",
-        `**Code** (\`${relFile}\` lines ${snippetStart}–${snippetEnd}):`,
-        "```typescript",
-        snippet,
-        "```",
+        `📄 Full details: .pi-lens/reports/refactor-ranked.tsv — read \`${relFile}\` when ready`,
         "",
         "**Your job**:",
         "1. Analyze this code — what's the most impactful refactoring for this file?",