pi-lens 2.0.7 → 2.0.8

package/clients/type-coverage-client.test.ts

@@ -1,123 +1,123 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { TypeCoverageClient } from "./type-coverage-client.js";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { setupTestEnvironment } from "./test-utils.js";
+import { TypeCoverageClient } from "./type-coverage-client.js";
 
 describe("TypeCoverageClient", () => {
-  let client: TypeCoverageClient;
-  let tmpDir: string;
-  let cleanup: () => void;
-
-  beforeEach(() => {
-    client = new TypeCoverageClient();
-    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-typecoverage-test-"));
-  });
-
-  afterEach(() => {
-    cleanup();
-  });
-
-  afterEach(() => {
-    cleanup();
-  });
-
-  describe("isAvailable", () => {
-    it("should check type-coverage availability", () => {
-      const available = client.isAvailable();
-      expect(typeof available).toBe("boolean");
-    });
-  });
-
-  describe("formatResult", () => {
-    it("should return empty string when not successful", () => {
-      const result = {
-        success: false,
-        percentage: 0,
-        typed: 0,
-        total: 0,
-        untypedLocations: [],
-      };
-
-      expect(client.formatResult(result)).toBe("");
-    });
-
-    it("should show coverage percentage", () => {
-      const result = {
-        success: true,
-        percentage: 95,
-        typed: 95,
-        total: 100,
-        untypedLocations: [],
-      };
-
-      const formatted = client.formatResult(result);
-      expect(formatted).toContain("95.0%");
-      expect(formatted).toContain("95/100");
-    });
-
-    it("should show warning for low coverage", () => {
-      const result = {
-        success: true,
-        percentage: 80,
-        typed: 80,
-        total: 100,
-        untypedLocations: [],
-      };
-
-      const formatted = client.formatResult(result);
-      expect(formatted).toContain("⚠");
-    });
-
-    it("should show checkmark for high coverage", () => {
-      const result = {
-        success: true,
-        percentage: 100,
-        typed: 100,
-        total: 100,
-        untypedLocations: [],
-      };
-
-      const formatted = client.formatResult(result);
-      expect(formatted).toContain("✓");
-    });
-
-    it("should show untyped locations", () => {
-      const result = {
-        success: true,
-        percentage: 90,
-        typed: 90,
-        total: 100,
-        untypedLocations: [
-          { file: "test.ts", line: 10, column: 5, name: "x" },
-          { file: "test.ts", line: 20, column: 8, name: "y" },
-        ],
-      };
-
-      const formatted = client.formatResult(result);
-      expect(formatted).toContain("test.ts:10");
-      expect(formatted).toContain("test.ts:20");
-      expect(formatted).toContain("x");
-      expect(formatted).toContain("y");
-    });
-
-    it("should truncate long untyped location lists", () => {
-      const locations = Array.from({ length: 20 }, (_, i) => ({
-        file: `file${i}.ts`,
-        line: i + 1,
-        column: 0,
-        name: `var${i}`,
-      }));
-
-      const result = {
-        success: true,
-        percentage: 80,
-        typed: 80,
-        total: 100,
-        untypedLocations: locations,
-      };
-
-      const formatted = client.formatResult(result, 10);
-      expect(formatted).toContain("...");
-      expect(formatted).toContain("10 more");
-    });
-  });
+	let client: TypeCoverageClient;
+	let _tmpDir: string;
+	let cleanup: () => void;
+
+	beforeEach(() => {
+		client = new TypeCoverageClient();
+		({ tmpDir: _tmpDir, cleanup } = setupTestEnvironment("pi-lens-typecoverage-test-"));
+	});
+
+	afterEach(() => {
+		cleanup();
+	});
+
+	afterEach(() => {
+		cleanup();
+	});
+
+	describe("isAvailable", () => {
+		it("should check type-coverage availability", () => {
+			const available = client.isAvailable();
+			expect(typeof available).toBe("boolean");
+		});
+	});
+
+	describe("formatResult", () => {
+		it("should return empty string when not successful", () => {
+			const result = {
+				success: false,
+				percentage: 0,
+				typed: 0,
+				total: 0,
+				untypedLocations: [],
+			};
+
+			expect(client.formatResult(result)).toBe("");
+		});
+
+		it("should show coverage percentage", () => {
+			const result = {
+				success: true,
+				percentage: 95,
+				typed: 95,
+				total: 100,
+				untypedLocations: [],
+			};
+
+			const formatted = client.formatResult(result);
+			expect(formatted).toContain("95.0%");
+			expect(formatted).toContain("95/100");
+		});
+
+		it("should show warning for low coverage", () => {
+			const result = {
+				success: true,
+				percentage: 80,
+				typed: 80,
+				total: 100,
+				untypedLocations: [],
+			};
+
+			const formatted = client.formatResult(result);
+			expect(formatted).toContain("⚠");
+		});
+
+		it("should show checkmark for high coverage", () => {
+			const result = {
+				success: true,
+				percentage: 100,
+				typed: 100,
+				total: 100,
+				untypedLocations: [],
+			};
+
+			const formatted = client.formatResult(result);
+			expect(formatted).toContain("✓");
+		});
+
+		it("should show untyped locations", () => {
+			const result = {
+				success: true,
+				percentage: 90,
+				typed: 90,
+				total: 100,
+				untypedLocations: [
+					{ file: "test.ts", line: 10, column: 5, name: "x" },
+					{ file: "test.ts", line: 20, column: 8, name: "y" },
+				],
+			};
+
+			const formatted = client.formatResult(result);
+			expect(formatted).toContain("test.ts:10");
+			expect(formatted).toContain("test.ts:20");
+			expect(formatted).toContain("x");
+			expect(formatted).toContain("y");
+		});
+
+		it("should truncate long untyped location lists", () => {
+			const locations = Array.from({ length: 20 }, (_, i) => ({
+				file: `file${i}.ts`,
+				line: i + 1,
+				column: 0,
+				name: `var${i}`,
+			}));
+
+			const result = {
+				success: true,
+				percentage: 80,
+				typed: 80,
+				total: 100,
+				untypedLocations: locations,
+			};
+
+			const formatted = client.formatResult(result, 10);
+			expect(formatted).toContain("...");
+			expect(formatted).toContain("10 more");
+		});
+	});
 });

package/clients/type-coverage-client.ts

@@ -15,127 +15,154 @@ import * as path from "node:path";
 // --- Types ---
 
 export interface TypeCoverageResult {
-  success: boolean;
-  percentage: number;
-  typed: number;
-  total: number;
-  untypedLocations: UntypedLocation[];
+	success: boolean;
+	percentage: number;
+	typed: number;
+	total: number;
+	untypedLocations: UntypedLocation[];
 }
 
 export interface UntypedLocation {
-  file: string;
-  line: number;
-  column: number;
-  name: string;
+	file: string;
+	line: number;
+	column: number;
+	name: string;
 }
 
 // --- Client ---
 
 export class TypeCoverageClient {
-  private available: boolean | null = null;
-  private log: (msg: string) => void;
-
-  constructor(verbose = false) {
-    this.log = verbose ? (msg) => console.log(`[type-coverage] ${msg}`) : () => {};
-  }
-
-  isAvailable(): boolean {
-    if (this.available !== null) return this.available;
-    const result = spawnSync("npx", ["type-coverage", "--version"], {
-      encoding: "utf-8",
-      timeout: 10000,
-      shell: true,
-    });
-    this.available = !result.error && result.status === 0;
-    return this.available;
-  }
-
-  /**
-   * Run type-coverage on the project at cwd.
-   * Uses --detail to get per-identifier locations for untyped names.
-   * Uses --strict to count `any` casts as untyped.
-   */
-  scan(cwd: string): TypeCoverageResult {
-    if (!this.isAvailable()) {
-      return { success: false, percentage: 0, typed: 0, total: 0, untypedLocations: [] };
-    }
-
-    try {
-      const result = spawnSync("npx", [
-        "type-coverage",
-        "--detail",
-        "--strict",
-        "--ignore-files", "**/*.d.ts",
-      ], {
-        encoding: "utf-8",
-        timeout: 30000,
-        cwd,
-        shell: true,
-      });
-
-      const output = (result.stdout ?? "") + (result.stderr ?? "");
-      return this.parseOutput(output, cwd);
-    } catch (err: any) {
-      this.log(`Scan error: ${err.message}`);
-      return { success: false, percentage: 0, typed: 0, total: 0, untypedLocations: [] };
-    }
-  }
-
-  formatResult(result: TypeCoverageResult, maxLocations = 10): string {
-    if (!result.success) return "";
-
-    const pct = result.percentage.toFixed(1);
-    const icon = result.percentage >= 95 ? "✓" : result.percentage >= 80 ? "⚠" : "✗";
-
-    let output = `[type-coverage] ${icon} ${pct}% typed (${result.typed}/${result.total} identifiers)`;
-
-    if (result.untypedLocations.length === 0) {
-      output += " — fully typed\n";
-      return output;
-    }
-
-    output += `:\n`;
-    for (const loc of result.untypedLocations.slice(0, maxLocations)) {
-      output += `  ${path.basename(loc.file)}:${loc.line}:${loc.column} — ${loc.name}\n`;
-    }
-
-    if (result.untypedLocations.length > maxLocations) {
-      output += `  ... and ${result.untypedLocations.length - maxLocations} more\n`;
-    }
-
-    return output;
-  }
-
-  // --- Internal ---
-
-  private parseOutput(output: string, cwd: string): TypeCoverageResult {
-    const untypedLocations: UntypedLocation[] = [];
-
-    // Parse detail lines: "path/to/file.ts:line:col: name"
-    const detailPattern = /^(.+):(\d+):(\d+):\s+(.+)$/gm;
-    let match: RegExpExecArray | null;
-    while ((match = detailPattern.exec(output)) !== null) {
-      const [, file, line, col, name] = match;
-      // Skip the summary line which also matches the pattern
-      if (name.includes("%") || name.includes("/")) continue;
-      untypedLocations.push({
-        file: path.resolve(cwd, file),
-        line: parseInt(line, 10),
-        column: parseInt(col, 10),
-        name: name.trim(),
-      });
-    }
-
-    // Parse summary: "(3979 / 4100) 97.04%"
-    const summaryMatch = output.match(/\((\d+)\s*\/\s*(\d+)\)\s*([\d.]+)%/);
-    if (!summaryMatch) {
-      return { success: false, percentage: 0, typed: 0, total: 0, untypedLocations: [] };
-    }
-
-    const typed = parseInt(summaryMatch[1], 10);
-    const total = parseInt(summaryMatch[2], 10);
-    const percentage = parseFloat(summaryMatch[3]);
-
-    return { success: true, percentage, typed, total, untypedLocations };
-  }
+	private available: boolean | null = null;
+	private log: (msg: string) => void;
+
+	constructor(verbose = false) {
+		this.log = verbose
+			? (msg) => console.log(`[type-coverage] ${msg}`)
+			: () => {};
+	}
+
+	isAvailable(): boolean {
+		if (this.available !== null) return this.available;
+		const result = spawnSync("npx", ["type-coverage", "--version"], {
+			encoding: "utf-8",
+			timeout: 10000,
+			shell: true,
+		});
+		this.available = !result.error && result.status === 0;
+		return this.available;
+	}
+
+	/**
+	 * Run type-coverage on the project at cwd.
+	 * Uses --detail to get per-identifier locations for untyped names.
+	 * Uses --strict to count `any` casts as untyped.
+	 */
+	scan(cwd: string): TypeCoverageResult {
+		if (!this.isAvailable()) {
+			return {
+				success: false,
+				percentage: 0,
+				typed: 0,
+				total: 0,
+				untypedLocations: [],
+			};
+		}
+
+		try {
+			const result = spawnSync(
+				"npx",
+				[
+					"type-coverage",
+					"--detail",
+					"--strict",
+					"--ignore-files",
+					"**/*.d.ts",
+				],
+				{
+					encoding: "utf-8",
+					timeout: 30000,
+					cwd,
+					shell: true,
+				},
+			);
+
+			const output = (result.stdout ?? "") + (result.stderr ?? "");
+			return this.parseOutput(output, cwd);
+		} catch (err: any) {
+			this.log(`Scan error: ${err.message}`);
+			return {
+				success: false,
+				percentage: 0,
+				typed: 0,
+				total: 0,
+				untypedLocations: [],
+			};
+		}
+	}
+
+	formatResult(result: TypeCoverageResult, maxLocations = 10): string {
+		if (!result.success) return "";
+
+		const pct = result.percentage.toFixed(1);
+		let icon = "✗";
+		if (result.percentage >= 95) icon = "✓";
+		else if (result.percentage >= 80) icon = "⚠";
+
+		let output = `[type-coverage] ${icon} ${pct}% typed (${result.typed}/${result.total} identifiers)`;
+
+		if (result.untypedLocations.length === 0) {
+			output += " — fully typed\n";
+			return output;
+		}
+
+		output += `:\n`;
+		for (const loc of result.untypedLocations.slice(0, maxLocations)) {
+			output += `  ${path.basename(loc.file)}:${loc.line}:${loc.column} — ${loc.name}\n`;
+		}
+
+		if (result.untypedLocations.length > maxLocations) {
+			output += `  ... and ${result.untypedLocations.length - maxLocations} more\n`;
+		}
+
+		return output;
+	}
+
+	// --- Internal ---
+
+	private parseOutput(output: string, cwd: string): TypeCoverageResult {
+		const untypedLocations: UntypedLocation[] = [];
+
+		// Parse detail lines: "path/to/file.ts:line:col: name"
+		const detailPattern = /^(.+):(\d+):(\d+):\s+(.+)$/gm;
+		let match: RegExpExecArray | null;
+		while ((match = detailPattern.exec(output)) !== null) {
+			const [, file, line, col, name] = match;
+			// Skip the summary line which also matches the pattern
+			if (name.includes("%") || name.includes("/")) continue;
+			untypedLocations.push({
+				file: path.resolve(cwd, file),
+				line: parseInt(line, 10),
+				column: parseInt(col, 10),
+				name: name.trim(),
+			});
+		}
+
+		// Parse summary: "(3979 / 4100) 97.04%"
+		const summaryMatch = output.match(/\((\d+)\s*\/\s*(\d+)\)\s*([\d.]+)%/);
+		if (!summaryMatch) {
+			return {
+				success: false,
+				percentage: 0,
+				typed: 0,
+				total: 0,
+				untypedLocations: [],
+			};
+		}
+
+		const typed = parseInt(summaryMatch[1], 10);
+		const total = parseInt(summaryMatch[2], 10);
+		const percentage = parseFloat(summaryMatch[3]);
+
+		return { success: true, percentage, typed, total, untypedLocations };
+	}
 }

package/clients/types.ts

@@ -4,56 +4,56 @@
  */
 
 export interface Position {
-  line: number;
-  character: number;
+	line: number;
+	character: number;
 }
 
 export interface Range {
-  start: Position;
-  end: Position;
+	start: Position;
+	end: Position;
 }
 
 export enum DiagnosticSeverity {
-  Error = 1,
-  Warning = 2,
-  Information = 3,
-  Hint = 4,
+	Error = 1,
+	Warning = 2,
+	Information = 3,
+	Hint = 4,
 }
 
 export interface Diagnostic {
-  range: Range;
-  severity?: DiagnosticSeverity;
-  code?: string | number;
-  source?: string;
-  message: string;
+	range: Range;
+	severity?: DiagnosticSeverity;
+	code?: string | number;
+	source?: string;
+	message: string;
 }
 
 export interface SymbolInfo {
-  name: string;
-  kind: string;
-  line: number;
-  containerName?: string;
+	name: string;
+	kind: string;
+	line: number;
+	containerName?: string;
 }
 
 export interface HoverInfo {
-  type: string;
-  documentation?: string;
+	type: string;
+	documentation?: string;
 }
 
 export interface Location {
-  file: string;
-  line: number;
-  character: number;
+	file: string;
+	line: number;
+	character: number;
 }
 
 export interface CompletionItem {
-  name: string;
-  kind: string;
-  sortText?: string;
+	name: string;
+	kind: string;
+	sortText?: string;
 }
 
 export interface FoldingRange {
-  startLine: number;
-  endLine: number;
-  kind: string;
+	startLine: number;
+	endLine: number;
+	kind: string;
 }