pi-lens 3.6.2 → 3.6.4

package/clients/jscpd-client.test.ts

@@ -1,145 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { JscpdClient } from "./jscpd-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-
-describe("JscpdClient", () => {
-	let client: JscpdClient;
-	let tmpDir: string;
-	let cleanup: () => void;
-
-	beforeEach(() => {
-		client = new JscpdClient();
-		({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-jscpd-test-"));
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	describe("isAvailable", () => {
-		it("should check jscpd availability", () => {
-			const available = client.isAvailable();
-			expect(typeof available).toBe("boolean");
-		});
-	});
-
-	describe("scan", () => {
-		it("should return success=false when not available", () => {
-			// Create a mock that returns false
-			const mockClient = new JscpdClient();
-			if (mockClient.isAvailable()) return; // Skip if available
-
-			const result = mockClient.scan(tmpDir);
-			expect(result.success).toBe(false);
-			expect(result.clones).toEqual([]);
-		});
-
-		it("should detect duplicate code blocks", { timeout: 15000 }, () => {
-			if (!client.isAvailable()) return;
-
-			// Create identical code blocks in different files
-			const duplicateCode = `
-function processData(data: number[]): number {
-  let sum = 0;
-  for (let i = 0; i < data.length; i++) {
-    sum += data[i];
-  }
-  return sum;
-}
-`;
-			createTempFile(tmpDir, "file1.ts", duplicateCode);
-			createTempFile(tmpDir, "file2.ts", duplicateCode);
-
-			const result = client.scan(tmpDir, 3, 20); // Lower thresholds for test
-
-			expect(result.success).toBe(true);
-			// May or may not detect clones depending on jscpd behavior
-		});
-	});
-
-	describe("formatResult", () => {
-		it("should return empty string for no success", () => {
-			const result = {
-				success: false,
-				clones: [],
-				duplicatedLines: 0,
-				totalLines: 100,
-				percentage: 0,
-			};
-
-			expect(client.formatResult(result)).toBe("");
-		});
-
-		it("should return empty string for no clones", () => {
-			const result = {
-				success: true,
-				clones: [],
-				duplicatedLines: 0,
-				totalLines: 100,
-				percentage: 0,
-			};
-
-			expect(client.formatResult(result)).toBe("");
-		});
-
-		it("should format clones for display", () => {
-			const result = {
-				success: true,
-				clones: [
-					{
-						fileA: "src/file1.ts",
-						startA: 10,
-						fileB: "src/file2.ts",
-						startB: 20,
-						lines: 15,
-						tokens: 50,
-					},
-					{
-						fileA: "src/file3.ts",
-						startA: 5,
-						fileB: "src/file4.ts",
-						startB: 12,
-						lines: 8,
-						tokens: 30,
-					},
-				],
-				duplicatedLines: 23,
-				totalLines: 500,
-				percentage: 4.6,
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("jscpd");
-			expect(formatted).toContain("2 duplicate block(s)");
-			expect(formatted).toContain("4.6%");
-			expect(formatted).toContain("15 lines");
-		});
-
-		it("should truncate long clone lists", () => {
-			const clones = Array.from({ length: 10 }, (_, i) => ({
-				fileA: `file${i}a.ts`,
-				startA: 1,
-				fileB: `file${i}b.ts`,
-				startB: 1,
-				lines: 5,
-				tokens: 20,
-			}));
-
-			const result = {
-				success: true,
-				clones,
-				duplicatedLines: 50,
-				totalLines: 1000,
-				percentage: 5,
-			};
-
-			const formatted = client.formatResult(result, 8);
-			expect(formatted).toContain("...");
-			expect(formatted).toContain("2 more");
-		});
-	});
-});

package/clients/knip-client.js

@@ -1,239 +0,0 @@
-/**
- * Knip Client for pi-local
- *
- * Detects unused exports, files, dependencies, and more.
- * Essential for safe refactoring — I need to know what's dead code
- * before I can clean it up.
- *
- * Requires: npm install -D knip
- * Docs: https://knip.dev/
- */
-import * as path from "node:path";
-import { safeSpawn } from "./safe-spawn.js";
-// --- Client ---
-export class KnipClient {
-    constructor(verbose = false) {
-        this.knipAvailable = null;
-        this.log = verbose
-            ? (msg) => console.error(`[knip] ${msg}`)
-            : () => { };
-    }
-    /**
-     * Check if knip CLI is available, auto-install if not
-     */
-    async ensureAvailable() {
-        // Fast path: already checked
-        if (this.knipAvailable !== null)
-            return this.knipAvailable;
-        // Check if available in PATH (fast)
-        const pathResult = safeSpawn("knip", ["--version"], {
-            timeout: 5000,
-        });
-        if (!pathResult.error && pathResult.status === 0) {
-            this.knipAvailable = true;
-            this.log("Knip found in PATH");
-            return true;
-        }
-        // Auto-install via pi-lens installer
-        this.log("Knip not found, attempting auto-install...");
-        const { ensureTool } = await import("./installer/index.js");
-        const installedPath = await ensureTool("knip");
-        if (installedPath) {
-            this.knipAvailable = true;
-            this.log(`Knip auto-installed: ${installedPath}`);
-            return true;
-        }
-        this.knipAvailable = false;
-        return false;
-    }
-    /**
-     * Check if knip CLI is available (legacy sync method)
-     * Prefer ensureAvailable() for auto-install behavior
-     */
-    isAvailable() {
-        if (this.knipAvailable !== null)
-            return this.knipAvailable;
-        const result = safeSpawn("npx", ["knip", "--version"], {
-            timeout: 10000,
-        });
-        this.knipAvailable = !result.error && result.status === 0;
-        if (this.knipAvailable) {
-            this.log(`Knip available`);
-        }
-        return this.knipAvailable;
-    }
-    /**
-     * Run knip analysis on the project
-     */
-    analyze(cwd, ignore) {
-        if (!this.isAvailable()) {
-            return {
-                success: false,
-                issues: [],
-                unusedExports: [],
-                unusedFiles: [],
-                unusedDeps: [],
-                unlistedDeps: [],
-                summary: "Knip not available. Install with: npm install -D knip",
-            };
-        }
-        const targetDir = cwd || process.cwd();
-        try {
-            const args = [
-                "knip",
-                "--reporter=json",
-                "--include",
-                "files,exports,types,dependencies,unlisted",
-            ];
-            if (ignore && ignore.length > 0) {
-                args.push("--ignore", ignore.join(","));
-            }
-            const result = safeSpawn("npx", args, {
-                timeout: 30000,
-                cwd: targetDir,
-            });
-            // Knip exits 0 on success (even with issues), 1 on errors
-            const output = result.stdout || "";
-            this.log(`Knip output length: ${output.length}`);
-            if (output.length < 500) {
-                this.log(`Knip output sample: ${output}`);
-            }
-            if (!output.trim()) {
-                return {
-                    success: true,
-                    issues: [],
-                    unusedExports: [],
-                    unusedFiles: [],
-                    unusedDeps: [],
-                    unlistedDeps: [],
-                    summary: "No issues found",
-                };
-            }
-            return this.parseOutput(output);
-        }
-        catch (err) {
-            this.log(`Analysis error: ${err.message}`);
-            return {
-                success: false,
-                issues: [],
-                unusedExports: [],
-                unusedFiles: [],
-                unusedDeps: [],
-                unlistedDeps: [],
-                summary: `Error: ${err.message}`,
-            };
-        }
-    }
-    /**
-     * Find unused exports in a specific file
-     */
-    findUnusedExports(filePath) {
-        const result = this.analyze(path.dirname(filePath));
-        const basename = path.basename(filePath);
-        return result.unusedExports
-            .filter((e) => e.file?.includes(basename))
-            .map((e) => e.name);
-    }
-    /**
-     * Format results for LLM consumption
-     */
-    formatResult(result, maxItems = 20) {
-        if (!result.success)
-            return `[Knip] ${result.summary}`;
-        if (result.issues.length === 0)
-            return "";
-        let output = `[Knip] ${result.issues.length} issue(s)`;
-        if (result.unusedExports.length)
-            output += ` — ${result.unusedExports.length} unused export(s)`;
-        if (result.unusedFiles.length)
-            output += ` — ${result.unusedFiles.length} unused file(s)`;
-        if (result.unusedDeps.length)
-            output += ` — ${result.unusedDeps.length} unused dep(s)`;
-        if (result.unlistedDeps.length)
-            output += ` — ${result.unlistedDeps.length} unlisted dep(s)`;
-        output += ":\n";
-        // Show unused exports first (most useful for refactoring)
-        if (result.unusedExports.length > 0) {
-            output += "\n  Unused exports:\n";
-            for (const issue of result.unusedExports.slice(0, maxItems)) {
-                const loc = issue.file ? ` (${path.basename(issue.file)})` : "";
-                output += `    - ${issue.name}${loc}\n`;
-            }
-            if (result.unusedExports.length > maxItems) {
-                output += `    ... and ${result.unusedExports.length - maxItems} more\n`;
-            }
-        }
-        // Show unused files
-        if (result.unusedFiles.length > 0) {
-            output += "\n  Unused files:\n";
-            for (const issue of result.unusedFiles.slice(0, 10)) {
-                output += `    - ${issue.name}\n`;
-            }
-        }
-        // Show unused deps (might be worth removing)
-        if (result.unusedDeps.length > 0) {
-            output += "\n  Unused dependencies:\n";
-            for (const issue of result.unusedDeps) {
-                output += `    - ${issue.package || issue.name}\n`;
-            }
-        }
-        return output;
-    }
-    // --- Internal ---
-    parseOutput(output) {
-        try {
-            const data = JSON.parse(output);
-            const issues = [];
-            const unusedExports = [];
-            const unusedFiles = [];
-            const unusedDeps = [];
-            const unlistedDeps = [];
-            // Knip JSON format: { issues: [ { file, exports:[], files:[], dependencies:[], ... } ] }
-            const fileEntries = data.issues ?? [];
-            for (const entry of fileEntries) {
-                const file = entry.file ?? "";
-                const push = (arr, type, target) => {
-                    for (const item of arr) {
-                        const issue = {
-                            type,
-                            name: item.name ?? item.symbol ?? String(item),
-                            file,
-                            line: item.line,
-                            package: item.package,
-                        };
-                        issues.push(issue);
-                        target.push(issue);
-                    }
-                };
-                push(entry.exports ?? [], "export", unusedExports);
-                push(entry.types ?? [], "export", unusedExports);
-                push(entry.files ?? [], "file", unusedFiles);
-                push(entry.dependencies ?? [], "dependency", unusedDeps);
-                push(entry.devDependencies ?? [], "devDependency", unusedDeps);
-                push(entry.unlisted ?? [], "unlisted", unlistedDeps);
-            }
-            return {
-                success: true,
-                issues,
-                unusedExports,
-                unusedFiles,
-                unusedDeps,
-                unlistedDeps,
-                summary: `Found ${issues.length} issues`,
-            };
-        }
-        catch (err) {
-            void err;
-            this.log("Failed to parse knip JSON output");
-            return {
-                success: false,
-                issues: [],
-                unusedExports: [],
-                unusedFiles: [],
-                unusedDeps: [],
-                unlistedDeps: [],
-                summary: "Failed to parse output",
-            };
-        }
-    }
-}

package/clients/knip-client.test.js

@@ -1,112 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { KnipClient } from "./knip-client.js";
-import { setupTestEnvironment } from "./test-utils.js";
-describe("KnipClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new KnipClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-knip-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isAvailable", () => {
-        it("should check knip availability", () => {
-            const available = client.isAvailable();
-            expect(typeof available).toBe("boolean");
-        });
-    });
-    describe("analyze", () => {
-        it("should return success=false when not available", () => {
-            const mockClient = new KnipClient();
-            if (mockClient.isAvailable())
-                return;
-            const result = mockClient.analyze(tmpDir);
-            expect(result.success).toBe(false);
-        });
-    });
-    describe("formatResult", () => {
-        it("should return empty string for no issues", () => {
-            const result = {
-                success: true,
-                issues: [],
-                unusedExports: [],
-                unusedFiles: [],
-                unusedDeps: [],
-                unlistedDeps: [],
-                summary: "",
-            };
-            expect(client.formatResult(result)).toBe("");
-        });
-        it("should format unused exports", () => {
-            const result = {
-                success: true,
-                issues: [
-                    { type: "export", name: "unusedFunc", file: "utils.ts" },
-                ],
-                unusedExports: [
-                    { type: "export", name: "unusedFunc", file: "utils.ts" },
-                ],
-                unusedFiles: [],
-                unusedDeps: [],
-                unlistedDeps: [],
-                summary: "Found 1 issue",
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("Knip");
-            expect(formatted).toContain("unusedFunc");
-        });
-        it("should format unused dependencies", () => {
-            const result = {
-                success: true,
-                issues: [{ type: "dependency", name: "lodash" }],
-                unusedExports: [],
-                unusedFiles: [],
-                unusedDeps: [{ type: "dependency", name: "lodash" }],
-                unlistedDeps: [],
-                summary: "",
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("lodash");
-            expect(formatted).toContain("unused dep");
-        });
-        it("should show unlisted dependencies count", () => {
-            const result = {
-                success: true,
-                issues: [{ type: "unlisted", name: "axios" }],
-                unusedExports: [],
-                unusedFiles: [],
-                unusedDeps: [],
-                unlistedDeps: [{ type: "unlisted", name: "axios" }],
-                summary: "",
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("unlisted dep");
-        });
-        it("should format multiple issue types", () => {
-            const result = {
-                success: true,
-                issues: [
-                    { type: "export", name: "func1", file: "a.ts" },
-                    { type: "file", name: "old.ts" },
-                ],
-                unusedExports: [
-                    { type: "export", name: "func1", file: "a.ts" },
-                    { type: "export", name: "func2", file: "b.ts" },
-                ],
-                unusedFiles: [{ type: "file", name: "old.ts" }],
-                unusedDeps: [],
-                unlistedDeps: [],
-                summary: "",
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("2 unused export(s)");
-            expect(formatted).toContain("1 unused file(s)");
-        });
-    });
-});

package/clients/knip-client.test.ts

@@ -1,128 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { KnipClient } from "./knip-client.js";
-import { setupTestEnvironment } from "./test-utils.js";
-
-describe("KnipClient", () => {
-	let client: KnipClient;
-	let tmpDir: string;
-	let cleanup: () => void;
-
-	beforeEach(() => {
-		client = new KnipClient();
-		({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-knip-test-"));
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	describe("isAvailable", () => {
-		it("should check knip availability", () => {
-			const available = client.isAvailable();
-			expect(typeof available).toBe("boolean");
-		});
-	});
-
-	describe("analyze", () => {
-		it("should return success=false when not available", () => {
-			const mockClient = new KnipClient();
-			if (mockClient.isAvailable()) return;
-
-			const result = mockClient.analyze(tmpDir);
-			expect(result.success).toBe(false);
-		});
-	});
-
-	describe("formatResult", () => {
-		it("should return empty string for no issues", () => {
-			const result = {
-				success: true,
-				issues: [],
-				unusedExports: [],
-				unusedFiles: [],
-				unusedDeps: [],
-				unlistedDeps: [],
-				summary: "",
-			};
-
-			expect(client.formatResult(result)).toBe("");
-		});
-
-		it("should format unused exports", () => {
-			const result = {
-				success: true,
-				issues: [
-					{ type: "export" as const, name: "unusedFunc", file: "utils.ts" },
-				],
-				unusedExports: [
-					{ type: "export" as const, name: "unusedFunc", file: "utils.ts" },
-				],
-				unusedFiles: [],
-				unusedDeps: [],
-				unlistedDeps: [],
-				summary: "Found 1 issue",
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("Knip");
-			expect(formatted).toContain("unusedFunc");
-		});
-
-		it("should format unused dependencies", () => {
-			const result = {
-				success: true,
-				issues: [{ type: "dependency" as const, name: "lodash" }],
-				unusedExports: [],
-				unusedFiles: [],
-				unusedDeps: [{ type: "dependency" as const, name: "lodash" }],
-				unlistedDeps: [],
-				summary: "",
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("lodash");
-			expect(formatted).toContain("unused dep");
-		});
-
-		it("should show unlisted dependencies count", () => {
-			const result = {
-				success: true,
-				issues: [{ type: "unlisted" as const, name: "axios" }],
-				unusedExports: [],
-				unusedFiles: [],
-				unusedDeps: [],
-				unlistedDeps: [{ type: "unlisted" as const, name: "axios" }],
-				summary: "",
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("unlisted dep");
-		});
-
-		it("should format multiple issue types", () => {
-			const result = {
-				success: true,
-				issues: [
-					{ type: "export" as const, name: "func1", file: "a.ts" },
-					{ type: "file" as const, name: "old.ts" },
-				],
-				unusedExports: [
-					{ type: "export" as const, name: "func1", file: "a.ts" },
-					{ type: "export" as const, name: "func2", file: "b.ts" },
-				],
-				unusedFiles: [{ type: "file" as const, name: "old.ts" }],
-				unusedDeps: [],
-				unlistedDeps: [],
-				summary: "",
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("2 unused export(s)");
-			expect(formatted).toContain("1 unused file(s)");
-		});
-	});
-});

package/clients/latency-logger.js

@@ -1,40 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-const LATENCY_LOG_DIR = path.join(os.homedir(), ".pi-lens");
-const LATENCY_LOG_FILE = path.join(LATENCY_LOG_DIR, "latency.log");
-try {
-    if (!fs.existsSync(LATENCY_LOG_DIR)) {
-        fs.mkdirSync(LATENCY_LOG_DIR, { recursive: true });
-    }
-}
-catch { }
-export function logLatency(entry) {
-    const line = `${JSON.stringify({ ts: new Date().toISOString(), ...entry })}\n`;
-    try {
-        fs.appendFileSync(LATENCY_LOG_FILE, line);
-    }
-    catch { }
-}
-export function getLatencyLogPath() {
-    return LATENCY_LOG_FILE;
-}
-export function readLatencyLog(limit = 100) {
-    try {
-        const content = fs.readFileSync(LATENCY_LOG_FILE, "utf-8");
-        const lines = content.trim().split("\n").filter(Boolean);
-        return lines
-            .slice(-limit)
-            .map((line) => JSON.parse(line))
-            .reverse();
-    }
-    catch {
-        return [];
-    }
-}
-export function clearLatencyLog() {
-    try {
-        fs.writeFileSync(LATENCY_LOG_FILE, "");
-    }
-    catch { }
-}