pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/utils/runner-helpers.js

@@ -0,0 +1,115 @@
+/**
+ * Shared runner utilities for pi-lens dispatch system
+ *
+ * Extracted common patterns from multiple runners to reduce duplication:
+ * - Venv-aware command finders
+ * - Availability checkers with caching
+ * - Config file finders
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeSpawn } from "../../../safe-spawn.js";
+/**
+ * Find a command in venv first, then fall back to global.
+ * Checks common venv locations (.venv, venv) before trying global.
+ */
+export function createVenvFinder(command, windowsExt = "", quoteWindows = false) {
+    return (cwd) => {
+        const venvPaths = [
+            `.venv/bin/${command}`,
+            `venv/bin/${command}`,
+            `.venv/Scripts/${command}${windowsExt}`,
+            `venv/Scripts/${command}${windowsExt}`,
+        ];
+        for (const venvPath of venvPaths) {
+            const fullPath = path.join(cwd, venvPath);
+            if (fs.existsSync(fullPath)) {
+                return quoteWindows && windowsExt
+                    ? `"${fullPath}"`
+                    : fullPath;
+            }
+        }
+        // Fall back to global
+        return command;
+    };
+}
+/**
+ * Create a cached availability checker for a command.
+ * The checker will look for the command in venv first, then global.
+ */
+export function createAvailabilityChecker(command, windowsExt = "") {
+    const cache = {
+        available: null,
+        command: null,
+    };
+    const findCommand = createVenvFinder(command, windowsExt, true);
+    function isAvailable(cwd) {
+        if (cache.available !== null)
+            return cache.available;
+        const cmd = findCommand(cwd || process.cwd());
+        const result = safeSpawn(cmd, ["--version"], {
+            timeout: 5000,
+        });
+        cache.available = !result.error && result.status === 0;
+        if (cache.available) {
+            cache.command = cmd;
+        }
+        return cache.available;
+    }
+    function getCommand() {
+        return cache.command;
+    }
+    return { isAvailable, getCommand };
+}
+// =============================================================================
+// CONFIG FILE FINDER FACTORY
+// =============================================================================
+/**
+ * Create a config file finder for rule directories.
+ * Common pattern used by slop runners and similar tools.
+ */
+export function createConfigFinder(ruleDirName) {
+    return (cwd) => {
+        // Check for local config first
+        const localPath = path.join(cwd, "rules", ruleDirName, ".sgconfig.yml");
+        if (fs.existsSync(localPath)) {
+            return localPath;
+        }
+        // Fall back to extension rules
+        const extensionPaths = [
+            `rules/${ruleDirName}/.sgconfig.yml`,
+            `../rules/${ruleDirName}/.sgconfig.yml`,
+        ];
+        for (const candidate of extensionPaths) {
+            const fullPath = path.resolve(cwd, candidate);
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        return undefined;
+    };
+}
+// =============================================================================
+// SHARED AST-GREP AVAILABILITY
+// =============================================================================
+// Shared sg availability cache across all slop runners
+let sgAvailable = null;
+/**
+ * Check if ast-grep CLI is available (shared cache)
+ */
+export function isSgAvailable() {
+    if (sgAvailable !== null)
+        return sgAvailable;
+    const check = safeSpawn("npx", ["sg", "--version"], {
+        timeout: 5000,
+    });
+    sgAvailable = !check.error && check.status === 0;
+    return sgAvailable;
+}
+// =============================================================================
+// PRE-BUILT CHECKERS FOR COMMON TOOLS
+// =============================================================================
+export const pyright = createAvailabilityChecker("pyright", ".exe");
+export const ruff = createAvailabilityChecker("ruff", ".exe");
+export const biome = createAvailabilityChecker("biome");
+export const sg = { isAvailable: isSgAvailable, getCommand: () => "npx" };

package/clients/dispatch/runners/utils/runner-helpers.ts

@@ -0,0 +1,167 @@
+/**
+ * Shared runner utilities for pi-lens dispatch system
+ *
+ * Extracted common patterns from multiple runners to reduce duplication:
+ * - Venv-aware command finders
+ * - Availability checkers with caching
+ * - Config file finders
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeSpawn } from "../../../safe-spawn.js";
+
+// =============================================================================
+// VENV-AWARE COMMAND FINDER
+// =============================================================================
+
+export interface VenvPathConfig {
+	unixPaths: string[];
+	windowsPaths: string[];
+	quoteWindowsPaths?: boolean;
+}
+
+/**
+ * Find a command in venv first, then fall back to global.
+ * Checks common venv locations (.venv, venv) before trying global.
+ */
+export function createVenvFinder(
+	command: string,
+	windowsExt = "",
+	quoteWindows = false,
+): (cwd: string) => string {
+	return (cwd: string): string => {
+		const venvPaths = [
+			`.venv/bin/${command}`,
+			`venv/bin/${command}`,
+			`.venv/Scripts/${command}${windowsExt}`,
+			`venv/Scripts/${command}${windowsExt}`,
+		];
+
+		for (const venvPath of venvPaths) {
+			const fullPath = path.join(cwd, venvPath);
+			if (fs.existsSync(fullPath)) {
+				return quoteWindows && windowsExt
+					? `"${fullPath}"`
+					: fullPath;
+			}
+		}
+
+		// Fall back to global
+		return command;
+	};
+}
+
+// =============================================================================
+// AVAILABILITY CHECKER FACTORY
+// =============================================================================
+
+type AvailabilityCache = {
+	available: boolean | null;
+	command: string | null;
+};
+
+/**
+ * Create a cached availability checker for a command.
+ * The checker will look for the command in venv first, then global.
+ */
+export function createAvailabilityChecker(
+	command: string,
+	windowsExt = "",
+): {
+	isAvailable: (cwd?: string) => boolean;
+	getCommand: () => string | null;
+} {
+	const cache: AvailabilityCache = {
+		available: null,
+		command: null,
+	};
+
+	const findCommand = createVenvFinder(command, windowsExt, true);
+
+	function isAvailable(cwd?: string): boolean {
+		if (cache.available !== null) return cache.available;
+
+		const cmd = findCommand(cwd || process.cwd());
+		const result = safeSpawn(cmd, ["--version"], {
+			timeout: 5000,
+		});
+
+		cache.available = !result.error && result.status === 0;
+		if (cache.available) {
+			cache.command = cmd;
+		}
+		return cache.available;
+	}
+
+	function getCommand(): string | null {
+		return cache.command;
+	}
+
+	return { isAvailable, getCommand };
+}
+
+// =============================================================================
+// CONFIG FILE FINDER FACTORY
+// =============================================================================
+
+/**
+ * Create a config file finder for rule directories.
+ * Common pattern used by slop runners and similar tools.
+ */
+export function createConfigFinder(
+	ruleDirName: string,
+): (cwd: string) => string | undefined {
+	return (cwd: string): string | undefined => {
+		// Check for local config first
+		const localPath = path.join(cwd, "rules", ruleDirName, ".sgconfig.yml");
+		if (fs.existsSync(localPath)) {
+			return localPath;
+		}
+
+		// Fall back to extension rules
+		const extensionPaths = [
+			`rules/${ruleDirName}/.sgconfig.yml`,
+			`../rules/${ruleDirName}/.sgconfig.yml`,
+		];
+
+		for (const candidate of extensionPaths) {
+			const fullPath = path.resolve(cwd, candidate);
+			if (fs.existsSync(fullPath)) {
+				return fullPath;
+			}
+		}
+
+		return undefined;
+	};
+}
+
+// =============================================================================
+// SHARED AST-GREP AVAILABILITY
+// =============================================================================
+
+// Shared sg availability cache across all slop runners
+let sgAvailable: boolean | null = null;
+
+/**
+ * Check if ast-grep CLI is available (shared cache)
+ */
+export function isSgAvailable(): boolean {
+	if (sgAvailable !== null) return sgAvailable;
+
+	const check = safeSpawn("npx", ["sg", "--version"], {
+		timeout: 5000,
+	});
+
+	sgAvailable = !check.error && check.status === 0;
+	return sgAvailable;
+}
+
+// =============================================================================
+// PRE-BUILT CHECKERS FOR COMMON TOOLS
+// =============================================================================
+
+export const pyright = createAvailabilityChecker("pyright", ".exe");
+export const ruff = createAvailabilityChecker("ruff", ".exe");
+export const biome = createAvailabilityChecker("biome");
+export const sg = { isAvailable: isSgAvailable, getCommand: () => "npx" };

package/clients/dispatch/runners/utils.js

@@ -2,6 +2,7 @@
  * Shared utilities for runners
  */
 import * as fs from "node:fs";
+import { safeSpawn } from "../../safe-spawn.js";
 /**
  * Read file content, returning undefined if it can't be read
  */
@@ -18,11 +19,8 @@ export function readFileContent(filePath) {
  */
 export function isCommandAvailable(command) {
     try {
-        const { spawnSync } = require("node:child_process");
-        const result = spawnSync(command, ["--version"], {
-            encoding: "utf-8",
+        const result = safeSpawn(command, ["--version"], {
             timeout: 5000,
-            shell: true,
         });
         return result.status === 0;
     }

package/clients/dispatch/runners/utils.ts

@@ -3,6 +3,7 @@
  */
 
 import * as fs from "node:fs";
+import { safeSpawn } from "../../safe-spawn.js";
 import type { Diagnostic } from "../types.js";
 
 /**
@@ -21,11 +22,8 @@ export function readFileContent(filePath: string): string | undefined {
  */
 export function isCommandAvailable(command: string): boolean {
 	try {
-		const { spawnSync } = require("node:child_process");
-		const result = spawnSync(command, ["--version"], {
-			encoding: "utf-8",
+		const result = safeSpawn(command, ["--version"], {
 			timeout: 5000,
-			shell: true,
 		});
 		return result.status === 0;
 	} catch {

package/clients/dispatch/types.ts

@@ -48,7 +48,7 @@ export interface Diagnostic {
 	/** Column (1-based) */
 	column?: number;
 	/** Severity level */
-	severity: "error" | "warning" | "info";
+	severity: "error" | "warning" | "info" | "hint";
 	/** Output semantic */
 	semantic: OutputSemantic;
 	/** Which tool produced this */

package/clients/dispatch/utils/format-utils.js

@@ -0,0 +1,49 @@
+/**
+ * Shared formatting utilities for dispatch system
+ *
+ * Consolidated from:
+ * - clients/dispatch/dispatcher.ts
+ * - clients/dispatch/bus-dispatcher.ts
+ * - clients/services/effect-integration.ts
+ */
+export const EMOJI = {
+    blocking: "🔴",
+    warning: "🟡",
+    fixed: "✅",
+    info: "ℹ️",
+    silent: "📊",
+    none: "",
+};
+/**
+ * Format a single diagnostic for display
+ */
+export function formatDiagnostic(d) {
+    const line = d.line ? `L${d.line}: ` : "";
+    const indented = d.message.split("\n").join("\n  ");
+    return `  ${line}${indented}`;
+}
+/**
+ * Format a group of diagnostics with semantic header
+ */
+export function formatDiagnostics(diagnostics, semantic, maxDisplay = 10) {
+    if (diagnostics.length === 0)
+        return "";
+    const emoji = EMOJI[semantic] ?? EMOJI.warning;
+    let output = "";
+    if (semantic === "blocking") {
+        output += `\n${emoji} STOP — ${diagnostics.length} issue(s) must be fixed:\n`;
+    }
+    else if (semantic === "warning") {
+        output += `\n${emoji} ${diagnostics.length} warning(s):\n`;
+    }
+    else if (semantic === "fixed") {
+        output += `\n${emoji} Auto-fixed ${diagnostics.length} issue(s):\n`;
+    }
+    for (const d of diagnostics.slice(0, maxDisplay)) {
+        output += `${formatDiagnostic(d)}\n`;
+    }
+    if (diagnostics.length > maxDisplay) {
+        output += `  ... and ${diagnostics.length - maxDisplay} more\n`;
+    }
+    return output;
+}

package/clients/dispatch/utils/format-utils.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared formatting utilities for dispatch system
+ * 
+ * Consolidated from:
+ * - clients/dispatch/dispatcher.ts
+ * - clients/dispatch/bus-dispatcher.ts
+ * - clients/services/effect-integration.ts
+ */
+
+import type { Diagnostic, OutputSemantic } from "../types.js";
+
+export const EMOJI: Record<string, string> = {
+	blocking: "🔴",
+	warning: "🟡",
+	fixed: "✅",
+	info: "ℹ️",
+	silent: "📊",
+	none: "",
+};
+
+/**
+ * Format a single diagnostic for display
+ */
+export function formatDiagnostic(d: Diagnostic): string {
+	const line = d.line ? `L${d.line}: ` : "";
+	const indented = d.message.split("\n").join("\n  ");
+	return `  ${line}${indented}`;
+}
+
+/**
+ * Format a group of diagnostics with semantic header
+ */
+export function formatDiagnostics(
+	diagnostics: Diagnostic[],
+	semantic: OutputSemantic | string,
+	maxDisplay = 10,
+): string {
+	if (diagnostics.length === 0) return "";
+
+	const emoji = EMOJI[semantic] ?? EMOJI.warning;
+	let output = "";
+
+	if (semantic === "blocking") {
+		output += `\n${emoji} STOP — ${diagnostics.length} issue(s) must be fixed:\n`;
+	} else if (semantic === "warning") {
+		output += `\n${emoji} ${diagnostics.length} warning(s):\n`;
+	} else if (semantic === "fixed") {
+		output += `\n${emoji} Auto-fixed ${diagnostics.length} issue(s):\n`;
+	}
+
+	for (const d of diagnostics.slice(0, maxDisplay)) {
+		output += `${formatDiagnostic(d)}\n`;
+	}
+
+	if (diagnostics.length > maxDisplay) {
+		output += `  ... and ${diagnostics.length - maxDisplay} more\n`;
+	}
+
+	return output;
+}

package/clients/dogfood.test.js

@@ -0,0 +1,201 @@
+/**
+ * Meta-test: Run similarity detection on pi-lens codebase
+ *
+ * This is a "dogfood" test - we run the reuse detection on our own code
+ * to see what it finds. Educational and useful for improving the algorithm!
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { glob } from "glob";
+import { beforeAll, describe, expect, it } from "vitest";
+import { buildProjectIndex, findSimilarFunctions, } from "./project-index.js";
+import { calculateSimilarity as calcMatrixSimilarity } from "./state-matrix.js";
+// Find project root by looking for package.json
+async function findProjectRoot(startDir) {
+    let dir = startDir;
+    while (dir !== path.dirname(dir)) {
+        try {
+            await fs.access(path.join(dir, "package.json"));
+            return dir;
+        }
+        catch {
+            dir = path.dirname(dir);
+        }
+    }
+    throw new Error("Could not find project root (no package.json)");
+}
+// Test a known similar pair
+const _SIMILAR_FUNCTIONS = {
+    description: "Extracting similar logic patterns in pi-lens",
+    pairs: [
+        {
+            name: "runners/index.ts pattern",
+            files: [
+                "clients/dispatch/runners/index.ts",
+                "clients/dispatch/runners/architect.ts",
+            ],
+            expected: "High similarity in runner registration patterns",
+        },
+        {
+            name: "Client pattern",
+            files: ["clients/typescript-client.ts", "clients/biome-client.ts"],
+            expected: "Similar client structures",
+        },
+    ],
+};
+describe("🐶 Dogfood Test: Similarity on pi-lens codebase", () => {
+    let index;
+    let projectRoot;
+    beforeAll(async () => {
+        // Find project root
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        projectRoot = await findProjectRoot(__dirname);
+        // Build index of the entire codebase
+        console.log("\n🏗️  Building index of pi-lens codebase...");
+        console.log(`   Project root: ${projectRoot}`);
+        const files = await glob("clients/**/*.ts", {
+            cwd: projectRoot,
+            ignore: ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**"],
+        });
+        console.log(`   Found ${files.length} source files`);
+        const absoluteFiles = files.map((f) => path.join(projectRoot, f));
+        index = await buildProjectIndex(projectRoot, absoluteFiles);
+        console.log(`   Indexed ${index.entries.size} functions`);
+        // Show some indexed functions
+        const sample = Array.from(index.entries.values()).slice(0, 5);
+        console.log("\n📋 Sample indexed functions:");
+        sample.forEach((e, i) => {
+            console.log(`   ${i + 1}. ${e.id} (${e.transitionCount} transitions)`);
+        });
+    }, 30000); // 30s timeout for indexing
+    describe("Index validation", () => {
+        it("should have indexed functions", () => {
+            expect(index.entries.size).toBeGreaterThan(0);
+            console.log(`\n✅ Indexed ${index.entries.size} functions`);
+        });
+        it("should have functions with >20 transitions", () => {
+            const complex = Array.from(index.entries.values()).filter((e) => e.transitionCount >= 20);
+            expect(complex.length).toBeGreaterThan(0);
+            console.log(`\n✅ ${complex.length} functions pass complexity guardrail`);
+        });
+    });
+    describe("Find similar functions in our own codebase", () => {
+        it("should find similar patterns among runners", async () => {
+            // Find runner files
+            const runnerEntries = Array.from(index.entries.values()).filter((e) => e.filePath.includes("dispatch/runners/"));
+            console.log(`\n🔍 Testing ${runnerEntries.length} runner functions`);
+            const similarities = [];
+            // Compare each pair
+            for (let i = 0; i < runnerEntries.length; i++) {
+                for (let j = i + 1; j < runnerEntries.length; j++) {
+                    const entry1 = runnerEntries[i];
+                    const entry2 = runnerEntries[j];
+                    // Skip if same file
+                    if (entry1.filePath === entry2.filePath)
+                        continue;
+                    const sim = calcMatrixSimilarity(entry1.matrix, entry2.matrix);
+                    if (sim >= 0.75) {
+                        similarities.push({
+                            func1: entry1.id,
+                            func2: entry2.id,
+                            similarity: sim,
+                        });
+                    }
+                }
+            }
+            // Sort by similarity
+            similarities.sort((a, b) => b.similarity - a.similarity);
+            console.log(`\n📊 Found ${similarities.length} similar pairs (>75%):`);
+            similarities.slice(0, 5).forEach((s, i) => {
+                console.log(`   ${i + 1}. ${s.func1} ↔ ${s.func2}`);
+                console.log(`      Similarity: ${(s.similarity * 100).toFixed(1)}%`);
+            });
+            // Log findings but don't fail - this is exploratory
+            expect(similarities.length).toBeGreaterThanOrEqual(0);
+        });
+        it("should find similar client patterns", async () => {
+            const clientEntries = Array.from(index.entries.values()).filter((e) => e.filePath.includes("clients/") &&
+                e.filePath.includes("-client.ts") &&
+                !e.filePath.includes("test"));
+            console.log(`\n🔍 Testing ${clientEntries.length} client functions`);
+            const similarities = [];
+            for (let i = 0; i < clientEntries.length; i++) {
+                for (let j = i + 1; j < clientEntries.length; j++) {
+                    const entry1 = clientEntries[i];
+                    const entry2 = clientEntries[j];
+                    if (entry1.filePath === entry2.filePath)
+                        continue;
+                    const sim = calcMatrixSimilarity(entry1.matrix, entry2.matrix);
+                    if (sim >= 0.75) {
+                        similarities.push({
+                            func1: entry1.id,
+                            func2: entry2.id,
+                            similarity: sim,
+                        });
+                    }
+                }
+            }
+            similarities.sort((a, b) => b.similarity - a.similarity);
+            console.log(`\n📊 Found ${similarities.length} similar client patterns (>75%):`);
+            similarities.slice(0, 3).forEach((s, i) => {
+                console.log(`   ${i + 1}. ${s.func1} ↔ ${s.func2}`);
+                console.log(`      Similarity: ${(s.similarity * 100).toFixed(1)}%`);
+            });
+            expect(similarities.length).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe("Find potential refactor opportunities", () => {
+        it("should identify duplicate utility functions", () => {
+            // Look for functions with very high similarity (>90%)
+            const entries = Array.from(index.entries.values());
+            const seenPairs = new Set(); // Deduplicate A→B and B→A
+            const duplicates = [];
+            for (const entry of entries) {
+                const matches = findSimilarFunctions(entry.matrix, index, 0.9, 3);
+                for (const match of matches) {
+                    if (match.targetId === entry.id)
+                        continue;
+                    // Canonical pair key (sorted to avoid A,B and B,A)
+                    const pairKey = [entry.id, match.targetId].sort().join("::");
+                    if (seenPairs.has(pairKey))
+                        continue;
+                    seenPairs.add(pairKey);
+                    duplicates.push({
+                        func: entry.id,
+                        similarTo: match.targetId,
+                        similarity: match.similarity,
+                    });
+                }
+            }
+            console.log(`\n🎯 Found ${duplicates.length} unique potential duplicates (>90%):`);
+            duplicates.slice(0, 5).forEach((d, i) => {
+                console.log(`   ${i + 1}. ${d.func}`);
+                console.log(`      Similar to: ${d.similarTo}`);
+                console.log(`      Match: ${(d.similarity * 100).toFixed(1)}%`);
+            });
+            // This is informational - we don't assert on it
+            expect(true).toBe(true);
+        });
+    });
+    describe("Complexity distribution", () => {
+        it("should show transition count distribution", () => {
+            const entries = Array.from(index.entries.values());
+            const transitionCounts = entries.map((e) => e.transitionCount);
+            const avg = transitionCounts.reduce((a, b) => a + b, 0) / transitionCounts.length;
+            const min = Math.min(...transitionCounts);
+            const max = Math.max(...transitionCounts);
+            const belowThreshold = transitionCounts.filter((c) => c < 20).length;
+            const aboveThreshold = transitionCounts.filter((c) => c >= 20).length;
+            console.log("\n📊 Complexity Distribution:");
+            console.log(`   Total functions: ${entries.length}`);
+            console.log(`   Below threshold (<20): ${belowThreshold}`);
+            console.log(`   Above threshold (≥20): ${aboveThreshold}`);
+            console.log(`   Min transitions: ${min}`);
+            console.log(`   Max transitions: ${max}`);
+            console.log(`   Average: ${avg.toFixed(1)}`);
+            // Most functions should pass the guardrail
+            expect(aboveThreshold).toBeGreaterThan(0);
+        });
+    });
+});