pi-lens 3.6.2 → 3.6.4

package/clients/sanitize.test.js

@@ -1,177 +0,0 @@
-/**
- * Tests for sanitize.ts
- * Tool output sanitization
- */
-import { describe, expect, it } from "vitest";
-import { extractErrorMessage, normalizeWhitespace, sanitizeBiomeOutput, sanitizeLine, sanitizeOutput, sanitizeRuffOutput, sanitizeToolOutput, stripAnsi, truncateMessage, } from "./sanitize.js";
-describe("stripAnsi", () => {
-    it("should remove ANSI color codes", () => {
-        expect(stripAnsi("\x1b[31mError\x1b[0m")).toBe("Error");
-        expect(stripAnsi("\x1b[1;32mSuccess\x1b[0m")).toBe("Success");
-    });
-    it("should remove extended ANSI codes", () => {
-        expect(stripAnsi("\x1b[1;2;3mText\x1b[0m")).toBe("Text");
-    });
-    it("should return original string if no ANSI codes", () => {
-        expect(stripAnsi("Plain text")).toBe("Plain text");
-    });
-});
-describe("normalizeWhitespace", () => {
-    it("should collapse multiple spaces", () => {
-        expect(normalizeWhitespace("Hello    World")).toBe("Hello World");
-    });
-    it("should trim lines", () => {
-        expect(normalizeWhitespace("  Hello  \n  World  ")).toBe("Hello\nWorld");
-    });
-    it("should remove empty lines", () => {
-        expect(normalizeWhitespace("Hello\n\n\nWorld")).toBe("Hello\nWorld");
-    });
-});
-describe("sanitizeLine", () => {
-    it("should remove common error prefixes", () => {
-        expect(sanitizeLine("[error] Something went wrong")).toBe("Something went wrong");
-        expect(sanitizeLine("error: Something went wrong")).toBe("Something went wrong");
-    });
-    it("should remove check/cross marks", () => {
-        expect(sanitizeLine("× Error message")).toBe("Error message");
-        expect(sanitizeLine("✓ Success message")).toBe("Success message");
-    });
-    it("should normalize whitespace", () => {
-        expect(sanitizeLine("  Error   message  ")).toBe("Error message");
-    });
-});
-describe("sanitizeOutput", () => {
-    it("should return empty string for empty input", () => {
-        expect(sanitizeOutput("")).toBe("");
-        expect(sanitizeOutput("   ")).toBe("");
-    });
-    it("should filter out detail lines", () => {
-        const output = "Error message\n    at line 10\n    at function foo";
-        const result = sanitizeOutput(output);
-        expect(result).toBe("Error message");
-    });
-    it("should remove ANSI codes and normalize", () => {
-        const output = "\x1b[31mError\x1b[0m\n\x1b[32mSuccess\x1b[0m";
-        const result = sanitizeOutput(output);
-        expect(result).toBe("Error\nSuccess");
-    });
-});
-describe("extractErrorMessage", () => {
-    it("should return undefined for empty input", () => {
-        expect(extractErrorMessage("")).toBeUndefined();
-        expect(extractErrorMessage("   ")).toBeUndefined();
-    });
-    it("should return first error line containing error indicator", () => {
-        // Note: extractErrorMessage sanitizes lines first, then checks isErrorLine
-        // Since "error:" prefix is removed by sanitizeLine, we need to use a keyword
-        // that remains in the sanitized line, like "failed" or "syntax"
-        const output = "Some info\nOperation failed: disk full\nMore info";
-        const result = extractErrorMessage(output);
-        expect(result).toBe("Operation failed: disk full");
-    });
-    it("should fall back to first non-empty line", () => {
-        const output = "info line\nanother info\nand more";
-        expect(extractErrorMessage(output)).toBe("info line");
-    });
-    it("should find error by keyword", () => {
-        const result = extractErrorMessage("warning: low severity\nfailed: operation");
-        // extractErrorMessage returns the first line with error indicators
-        // "failed:" contains "failed" which matches ERROR_INDICATORS
-        expect(result).toBe("failed: operation");
-    });
-});
-describe("truncateMessage", () => {
-    it("should not truncate short messages", () => {
-        const msg = "Short message";
-        expect(truncateMessage(msg, 100)).toBe(msg);
-    });
-    it("should truncate long messages", () => {
-        const msg = "A".repeat(200);
-        const result = truncateMessage(msg, 50);
-        expect(result).toBe(`${"A".repeat(49)}…`);
-    });
-    it("should use default max length of 140", () => {
-        const msg = "A".repeat(200);
-        const result = truncateMessage(msg);
-        expect(result.length).toBe(140);
-    });
-});
-describe("sanitizeToolOutput", () => {
-    it("should return empty result for empty input", () => {
-        const result = sanitizeToolOutput("");
-        expect(result.summary).toBeUndefined();
-        expect(result.details).toBeUndefined();
-        expect(result.truncated).toBe(false);
-    });
-    it("should extract summary and details", () => {
-        const output = "error: something failed\nline 2\nline 3\nline 4";
-        const result = sanitizeToolOutput(output);
-        // sanitizeLine removes "error:" prefix
-        expect(result.summary).toContain("something failed");
-        expect(result.details).toBeDefined();
-    });
-    it("should mark as truncated when too many lines", () => {
-        const lines = [];
-        for (let i = 0; i < 30; i++) {
-            lines.push(`error line ${i}`);
-        }
-        const result = sanitizeToolOutput(lines.join("\n"));
-        expect(result.truncated).toBe(true);
-        expect(result.details).toContain("more lines");
-    });
-    it("should respect max summary length", () => {
-        const output = `error: ${"x".repeat(200)}`;
-        const result = sanitizeToolOutput(output, 50);
-        expect(result.summary?.length).toBeLessThanOrEqual(50);
-    });
-});
-describe("sanitizeBiomeOutput", () => {
-    it("should parse JSON diagnostics", () => {
-        const json = JSON.stringify({
-            diagnostics: [
-                {
-                    location: {
-                        path: "file.ts",
-                        span: { start: { line: 10, column: 0 } },
-                    },
-                    message: "Unexpected token",
-                },
-            ],
-        });
-        const result = sanitizeBiomeOutput(json);
-        expect(result).toContain("file.ts");
-        expect(result).toContain("11"); // line + 1
-        expect(result).toContain("Unexpected token");
-    });
-    it("should handle text output with errors", () => {
-        const output = "error: something went wrong\ninfo: some info";
-        const result = sanitizeBiomeOutput(output);
-        expect(result).toContain("error");
-    });
-    it("should return empty for empty input", () => {
-        expect(sanitizeBiomeOutput("")).toBe("");
-    });
-});
-describe("sanitizeRuffOutput", () => {
-    it("should parse JSON diagnostics", () => {
-        const json = JSON.stringify([
-            {
-                location: { row: 10, column: 5 },
-                code: "E501",
-                message: "Line too long",
-            },
-        ]);
-        const result = sanitizeRuffOutput(json);
-        expect(result).toContain("10:5");
-        expect(result).toContain("[E501]");
-        expect(result).toContain("Line too long");
-    });
-    it("should handle text output", () => {
-        const output = "file.py:10:5 [E501] Line too long";
-        const result = sanitizeRuffOutput(output);
-        expect(result).toContain("E501");
-    });
-    it("should return empty for empty input", () => {
-        expect(sanitizeRuffOutput("")).toBe("");
-    });
-});

package/clients/sanitize.test.ts

@@ -1,223 +0,0 @@
-/**
- * Tests for sanitize.ts
- * Tool output sanitization
- */
-
-import { describe, expect, it } from "vitest";
-import {
-	extractErrorMessage,
-	normalizeWhitespace,
-	sanitizeBiomeOutput,
-	sanitizeLine,
-	sanitizeOutput,
-	sanitizeRuffOutput,
-	sanitizeToolOutput,
-	stripAnsi,
-	truncateMessage,
-} from "./sanitize.js";
-
-describe("stripAnsi", () => {
-	it("should remove ANSI color codes", () => {
-		expect(stripAnsi("\x1b[31mError\x1b[0m")).toBe("Error");
-		expect(stripAnsi("\x1b[1;32mSuccess\x1b[0m")).toBe("Success");
-	});
-
-	it("should remove extended ANSI codes", () => {
-		expect(stripAnsi("\x1b[1;2;3mText\x1b[0m")).toBe("Text");
-	});
-
-	it("should return original string if no ANSI codes", () => {
-		expect(stripAnsi("Plain text")).toBe("Plain text");
-	});
-});
-
-describe("normalizeWhitespace", () => {
-	it("should collapse multiple spaces", () => {
-		expect(normalizeWhitespace("Hello    World")).toBe("Hello World");
-	});
-
-	it("should trim lines", () => {
-		expect(normalizeWhitespace("  Hello  \n  World  ")).toBe("Hello\nWorld");
-	});
-
-	it("should remove empty lines", () => {
-		expect(normalizeWhitespace("Hello\n\n\nWorld")).toBe("Hello\nWorld");
-	});
-});
-
-describe("sanitizeLine", () => {
-	it("should remove common error prefixes", () => {
-		expect(sanitizeLine("[error] Something went wrong")).toBe(
-			"Something went wrong",
-		);
-		expect(sanitizeLine("error: Something went wrong")).toBe(
-			"Something went wrong",
-		);
-	});
-
-	it("should remove check/cross marks", () => {
-		expect(sanitizeLine("× Error message")).toBe("Error message");
-		expect(sanitizeLine("✓ Success message")).toBe("Success message");
-	});
-
-	it("should normalize whitespace", () => {
-		expect(sanitizeLine("  Error   message  ")).toBe("Error message");
-	});
-});
-
-describe("sanitizeOutput", () => {
-	it("should return empty string for empty input", () => {
-		expect(sanitizeOutput("")).toBe("");
-		expect(sanitizeOutput("   ")).toBe("");
-	});
-
-	it("should filter out detail lines", () => {
-		const output = "Error message\n    at line 10\n    at function foo";
-		const result = sanitizeOutput(output);
-		expect(result).toBe("Error message");
-	});
-
-	it("should remove ANSI codes and normalize", () => {
-		const output = "\x1b[31mError\x1b[0m\n\x1b[32mSuccess\x1b[0m";
-		const result = sanitizeOutput(output);
-		expect(result).toBe("Error\nSuccess");
-	});
-});
-
-describe("extractErrorMessage", () => {
-	it("should return undefined for empty input", () => {
-		expect(extractErrorMessage("")).toBeUndefined();
-		expect(extractErrorMessage("   ")).toBeUndefined();
-	});
-
-	it("should return first error line containing error indicator", () => {
-		// Note: extractErrorMessage sanitizes lines first, then checks isErrorLine
-		// Since "error:" prefix is removed by sanitizeLine, we need to use a keyword
-		// that remains in the sanitized line, like "failed" or "syntax"
-		const output = "Some info\nOperation failed: disk full\nMore info";
-		const result = extractErrorMessage(output);
-		expect(result).toBe("Operation failed: disk full");
-	});
-
-	it("should fall back to first non-empty line", () => {
-		const output = "info line\nanother info\nand more";
-		expect(extractErrorMessage(output)).toBe("info line");
-	});
-
-	it("should find error by keyword", () => {
-		const result = extractErrorMessage(
-			"warning: low severity\nfailed: operation",
-		);
-		// extractErrorMessage returns the first line with error indicators
-		// "failed:" contains "failed" which matches ERROR_INDICATORS
-		expect(result).toBe("failed: operation");
-	});
-});
-
-describe("truncateMessage", () => {
-	it("should not truncate short messages", () => {
-		const msg = "Short message";
-		expect(truncateMessage(msg, 100)).toBe(msg);
-	});
-
-	it("should truncate long messages", () => {
-		const msg = "A".repeat(200);
-		const result = truncateMessage(msg, 50);
-		expect(result).toBe(`${"A".repeat(49)}…`);
-	});
-
-	it("should use default max length of 140", () => {
-		const msg = "A".repeat(200);
-		const result = truncateMessage(msg);
-		expect(result.length).toBe(140);
-	});
-});
-
-describe("sanitizeToolOutput", () => {
-	it("should return empty result for empty input", () => {
-		const result = sanitizeToolOutput("");
-		expect(result.summary).toBeUndefined();
-		expect(result.details).toBeUndefined();
-		expect(result.truncated).toBe(false);
-	});
-
-	it("should extract summary and details", () => {
-		const output = "error: something failed\nline 2\nline 3\nline 4";
-		const result = sanitizeToolOutput(output);
-		// sanitizeLine removes "error:" prefix
-		expect(result.summary).toContain("something failed");
-		expect(result.details).toBeDefined();
-	});
-
-	it("should mark as truncated when too many lines", () => {
-		const lines: string[] = [];
-		for (let i = 0; i < 30; i++) {
-			lines.push(`error line ${i}`);
-		}
-		const result = sanitizeToolOutput(lines.join("\n"));
-		expect(result.truncated).toBe(true);
-		expect(result.details).toContain("more lines");
-	});
-
-	it("should respect max summary length", () => {
-		const output = `error: ${"x".repeat(200)}`;
-		const result = sanitizeToolOutput(output, 50);
-		expect(result.summary?.length).toBeLessThanOrEqual(50);
-	});
-});
-
-describe("sanitizeBiomeOutput", () => {
-	it("should parse JSON diagnostics", () => {
-		const json = JSON.stringify({
-			diagnostics: [
-				{
-					location: {
-						path: "file.ts",
-						span: { start: { line: 10, column: 0 } },
-					},
-					message: "Unexpected token",
-				},
-			],
-		});
-		const result = sanitizeBiomeOutput(json);
-		expect(result).toContain("file.ts");
-		expect(result).toContain("11"); // line + 1
-		expect(result).toContain("Unexpected token");
-	});
-
-	it("should handle text output with errors", () => {
-		const output = "error: something went wrong\ninfo: some info";
-		const result = sanitizeBiomeOutput(output);
-		expect(result).toContain("error");
-	});
-
-	it("should return empty for empty input", () => {
-		expect(sanitizeBiomeOutput("")).toBe("");
-	});
-});
-
-describe("sanitizeRuffOutput", () => {
-	it("should parse JSON diagnostics", () => {
-		const json = JSON.stringify([
-			{
-				location: { row: 10, column: 5 },
-				code: "E501",
-				message: "Line too long",
-			},
-		]);
-		const result = sanitizeRuffOutput(json);
-		expect(result).toContain("10:5");
-		expect(result).toContain("[E501]");
-		expect(result).toContain("Line too long");
-	});
-
-	it("should handle text output", () => {
-		const output = "file.py:10:5 [E501] Line too long";
-		const result = sanitizeRuffOutput(output);
-		expect(result).toContain("E501");
-	});
-
-	it("should return empty for empty input", () => {
-		expect(sanitizeRuffOutput("")).toBe("");
-	});
-});

package/clients/scan-architectural-debt.js

@@ -1,167 +0,0 @@
-/**
- * Shared architectural debt scanning.
- * Scans ast-grep skip rules + complexity metrics + architect.yaml rules.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { safeSpawn } from "./safe-spawn.js";
-import { getSourceFiles, parseAstGrepJson } from "./scan-utils.js";
-/**
- * Scan for skip-category ast-grep violations grouped by absolute file path.
- */
-export function scanSkipViolations(astGrepClient, configPath, targetPath, isTsProject, skipRules, ruleActions) {
-    const skipByFile = new Map();
-    if (!astGrepClient.isAvailable())
-        return skipByFile;
-    const sgResult = safeSpawn("npx", [
-        "sg",
-        "scan",
-        "--config",
-        configPath,
-        "--json",
-        "--globs",
-        "!**/*.test.ts",
-        "--globs",
-        "!**/*.spec.ts",
-        "--globs",
-        "!**/test-utils.ts",
-        "--globs",
-        "!**/.pi-lens/**",
-        ...(isTsProject ? ["--globs", "!**/*.js"] : []),
-        targetPath,
-    ], {
-        timeout: 30000,
-    });
-    const items = parseAstGrepJson(sgResult.stdout?.trim() ?? "");
-    for (const item of items) {
-        const rule = item.ruleId || item.rule?.title || item.name || "unknown";
-        if (!skipRules.has(rule))
-            continue;
-        const line = (item.labels?.[0]?.range?.start?.line ?? item.range?.start?.line ?? 0) +
-            1;
-        const absFile = path.resolve(item.file ?? "");
-        const list = skipByFile.get(absFile) ?? [];
-        list.push({ rule, line, note: ruleActions[rule]?.note ?? "" });
-        skipByFile.set(absFile, list);
-    }
-    return skipByFile;
-}
-/**
- * Scan complexity metrics for all supported files, grouped by absolute file path.
- */
-export function scanComplexityMetrics(complexityClient, targetPath, isTsProject) {
-    const metricsByFile = new Map();
-    const files = getSourceFiles(targetPath, isTsProject);
-    for (const full of files) {
-        if (complexityClient.isSupportedFile(full) &&
-            !/\.(test|spec)\.[jt]sx?$/.test(path.basename(full))) {
-            const m = complexityClient.analyzeFile(full);
-            if (m)
-                metricsByFile.set(full, {
-                    mi: m.maintainabilityIndex,
-                    cognitive: m.cognitiveComplexity,
-                    nesting: m.maxNestingDepth,
-                });
-        }
-    }
-    return metricsByFile;
-}
-/**
- * Scan for architectural rule violations grouped by absolute file path.
- * Returns map of absolute file path → list of violation messages.
- */
-export function scanArchitectViolations(architectClient, targetPath) {
-    const violationsByFile = new Map();
-    if (!architectClient.hasConfig())
-        return violationsByFile;
-    const isTsProject = fs.existsSync(path.join(targetPath, "tsconfig.json"));
-    const files = getSourceFiles(targetPath, isTsProject);
-    for (const full of files) {
-        const relPath = path.relative(targetPath, full).replace(/\\/g, "/");
-        const content = fs.readFileSync(full, "utf-8");
-        const lineCount = content.split("\n").length;
-        const msgs = [];
-        // Check pattern violations
-        for (const v of architectClient.checkFile(relPath, content)) {
-            const lineStr = v.line ? `L${v.line}: ` : "";
-            msgs.push(`${lineStr}${v.message}`);
-        }
-        // Check file size
-        const sizeV = architectClient.checkFileSize(relPath, lineCount);
-        if (sizeV) {
-            msgs.push(sizeV.message);
-        }
-        if (msgs.length > 0) {
-            violationsByFile.set(full, msgs);
-        }
-    }
-    return violationsByFile;
-}
-/**
- * Score each file by combined debt signal. Higher = worse.
- */
-export function scoreFiles(skipByFile, metricsByFile, architectViolations) {
-    const allFiles = new Set([
-        ...skipByFile.keys(),
-        ...metricsByFile.keys(),
-        ...(architectViolations?.keys() ?? []),
-    ]);
-    return [...allFiles]
-        .map((file) => {
-        let score = 0;
-        const m = metricsByFile.get(file);
-        if (m) {
-            if (m.mi < 20)
-                score += 5;
-            else if (m.mi < 40)
-                score += 3;
-            else if (m.mi < 60)
-                score += 1;
-            if (m.cognitive > 300)
-                score += 4;
-            else if (m.cognitive > 150)
-                score += 2;
-            else if (m.cognitive > 80)
-                score += 1;
-            if (m.nesting > 8)
-                score += 2;
-            else if (m.nesting > 5)
-                score += 1;
-        }
-        for (const issue of skipByFile.get(file) ?? []) {
-            if (issue.rule === "large-class")
-                score += 5;
-            else if (issue.rule === "no-as-any")
-                score += 2;
-            else
-                score += 1;
-        }
-        // Architect violations are high-priority signals
-        const archMsgs = architectViolations?.get(file);
-        if (archMsgs && archMsgs.length > 0) {
-            score += archMsgs.length * 3; // Each violation = 3 points
-        }
-        return { file, score };
-    })
-        .filter((f) => f.score > 0)
-        .sort((a, b) => b.score - a.score);
-}
-/**
- * Read a code snippet around the first violation line.
- * Returns { snippet, start, end } or null.
- */
-export function extractCodeSnippet(filePath, firstLine, contextLines = 2, maxLines = 45) {
-    try {
-        const fileLines = fs.readFileSync(filePath, "utf-8").split("\n");
-        const start = Math.max(0, firstLine - 1 - contextLines);
-        const end = Math.min(fileLines.length, start + maxLines);
-        return {
-            snippet: fileLines.slice(start, end).join("\n"),
-            start: start + 1,
-            end,
-        };
-    }
-    catch {
-        return null;
-    }
-}

package/clients/scan-utils.js

@@ -1,83 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { EXCLUDED_DIRS, isTestFile } from "./file-utils.js";
-/**
- * Common parsing logic for ast-grep JSON output (handles both array and NDJSON).
- */
-// biome-ignore lint/suspicious/noExplicitAny: ast-grep JSON output is untyped
-export function parseAstGrepJson(raw) {
-    if (!raw)
-        return [];
-    const trimmed = raw.trim();
-    if (trimmed.startsWith("[")) {
-        try {
-            return JSON.parse(trimmed);
-        }
-        catch {
-            return [];
-        }
-    }
-    return trimmed.split("\n").flatMap((l) => {
-        try {
-            return [JSON.parse(l)];
-        }
-        catch {
-            return [];
-        }
-    });
-}
-/**
- * Check if a file should be ignored based on project type and common patterns.
- */
-export function shouldIgnoreFile(filePath, isTsProject) {
-    const relPath = filePath.replace(/\\/g, "/");
-    const _basename = path.basename(relPath);
-    // Ignore compiled JS in TS projects
-    const isJs = relPath.endsWith(".js") ||
-        relPath.endsWith(".mjs") ||
-        relPath.endsWith(".cjs");
-    if (isTsProject && isJs)
-        return true;
-    // Ignore test scripts and common test patterns
-    if (isTestFile(filePath))
-        return true;
-    // Ignore hidden directories and common build outputs
-    if (EXCLUDED_DIRS.some((d) => relPath.includes(`/${d}/`)))
-        return true;
-    return false;
-}
-/**
- * Recursively find source files in a directory, respecting common excludes.
- */
-export function getSourceFiles(dir, isTsProject) {
-    const files = [];
-    if (!fs.existsSync(dir))
-        return files;
-    const scan = (d) => {
-        let entries = [];
-        try {
-            entries = fs.readdirSync(d, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const full = path.join(d, entry.name);
-            if (entry.isDirectory()) {
-                if (EXCLUDED_DIRS.includes(entry.name))
-                    continue;
-                scan(full);
-            }
-            else if (/\.(ts|tsx|js|jsx|py|go|rs)$/.test(entry.name)) {
-                // Skip compiled JS if it's a TS project
-                if (isTsProject &&
-                    entry.name.endsWith(".js") &&
-                    fs.existsSync(full.replace(/\.js$/, ".ts")))
-                    continue;
-                files.push(full);
-            }
-        }
-    };
-    scan(dir);
-    return files;
-}