pi-lens 2.2.9 → 3.0.0

package/clients/services/runner-service.ts

@@ -0,0 +1,179 @@
+/**
+ * Effect-TS Service Infrastructure for pi-lens
+ * 
+ * Simplified implementation focusing on:
+ * - Concurrent runner execution
+ * - Timeout handling
+ * - Error recovery
+ */
+
+import { Effect } from "effect";
+
+// --- Error Types ---
+
+export class RunnerError {
+	readonly _tag = "RunnerError";
+	constructor(
+		readonly runnerId: string,
+		readonly cause: unknown,
+	) {}
+}
+
+export class TimeoutError {
+	readonly _tag = "TimeoutError";
+	constructor(
+		readonly operation: string,
+		readonly timeoutMs: number,
+	) {}
+}
+
+// --- Result Types ---
+
+export interface RunnerResult {
+	diagnostics: Array<{
+		id: string;
+		message: string;
+		severity: "error" | "warning" | "info" | "hint";
+		semantic?: "blocking" | "warning" | "fixed" | "silent" | "none";
+	}>;
+	durationMs: number;
+	error?: string;
+}
+
+export interface ConcurrentRunnerResult {
+	runnerId: string;
+	status: "success" | "failure" | "skipped";
+	diagnostics: Array<{
+		id: string;
+		message: string;
+		severity: "error" | "warning" | "info" | "hint";
+		semantic?: "blocking" | "warning" | "fixed" | "silent" | "none";
+	}>;
+	durationMs: number;
+	error?: string;
+}
+
+// --- Concurrent Execution Helper ---
+
+/**
+ * Run multiple runners concurrently with Effect
+ * 
+ * Features:
+ * - Parallel execution with Effect.all
+ * - Per-runner timeout handling
+ * - Graceful error recovery (individual failures don't stop others)
+ * - Automatic resource cleanup
+ */
+export function runRunnersConcurrent(
+	filePath: string,
+	runnerIds: string[],
+	runSingle: (filePath: string, runnerId: string) => Promise<RunnerResult>,
+	timeoutMs = 30_000
+): Effect.Effect<ConcurrentRunnerResult[], never, never> {
+	return Effect.gen(function* () {
+		const startTime = Date.now();
+
+		// Run all runners in parallel
+		const results = yield* Effect.all(
+			runnerIds.map((runnerId) =>
+				Effect.gen(function* () {
+					const runnerStart = Date.now();
+
+					// Execute with timeout and error handling
+					const result = yield* Effect.tryPromise({
+						try: () => runSingle(filePath, runnerId),
+						catch: (err) => err,
+					}).pipe(
+						Effect.timeout(timeoutMs),
+						Effect.catchAll((err) =>
+							Effect.succeed({
+								diagnostics: [],
+								durationMs: Date.now() - runnerStart,
+								error: String(err),
+							})
+						)
+					);
+
+					const isError = "error" in result;
+
+					return {
+						runnerId,
+						status: isError ? "failure" as const : "success" as const,
+						diagnostics: isError ? [] : result.diagnostics,
+						durationMs: isError ? result.durationMs : result.durationMs,
+						error: isError ? result.error : undefined,
+					};
+				})
+			),
+			{ concurrency: "unbounded" }
+		);
+
+		return results;
+	});
+}
+
+/**
+ * Run a single runner with timeout and error handling
+ */
+export function runRunnerWithTimeout(
+	filePath: string,
+	runnerId: string,
+	runSingle: (filePath: string, runnerId: string) => Promise<RunnerResult>,
+	timeoutMs = 30_000
+): Effect.Effect<RunnerResult, RunnerError | TimeoutError, never> {
+	return Effect.gen(function* () {
+		const startTime = Date.now();
+
+		const result = yield* Effect.tryPromise({
+			try: () => runSingle(filePath, runnerId),
+			catch: (err) => new RunnerError(runnerId, err),
+		}).pipe(
+			Effect.timeout(timeoutMs),
+			Effect.mapError((err) => {
+				if (err instanceof RunnerError) return err;
+				return new TimeoutError(`runner:${runnerId}`, timeoutMs);
+			})
+		);
+
+		return {
+			diagnostics: result.diagnostics,
+			durationMs: Date.now() - startTime,
+		};
+	});
+}
+
+// --- Execution Helpers ---
+
+/**
+ * Execute Effect and get result
+ */
+export function executeEffect<T>(
+	effect: Effect.Effect<T, never, never>
+): Promise<T> {
+	return Effect.runPromise(effect);
+}
+
+/**
+ * Execute Effect with error handling
+ */
+export function executeEffectWithError<T, E>(
+	effect: Effect.Effect<T, E, never>,
+	onError: (err: E) => T
+): Promise<T> {
+	return Effect.runPromise(
+		Effect.catchAll(effect, (err) => Effect.succeed(onError(err)))
+	);
+}
+
+// --- Error Formatting ---
+
+export function formatError(err: RunnerError | TimeoutError): string {
+	switch (err._tag) {
+		case "RunnerError":
+			return `Runner ${err.runnerId} failed: ${err.cause}`;
+		case "TimeoutError":
+			return `Operation ${err.operation} timed out after ${err.timeoutMs}ms`;
+		default:
+			return "Unknown error";
+	}
+}

package/clients/sg-runner.js

@@ -4,10 +4,22 @@
  * Extracted from AstGrepClient to simplify the main client.
  * Handles: spawn, spawnSync, temp dir management, JSON parsing.
  */
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
+/**
+ * Escape an argument for Windows cmd.exe shell execution.
+ * Handles spaces, quotes, and special characters.
+ */
+function escapeWindowsArg(arg) {
+    // If no special characters, return as-is
+    if (!/[\s\"]/.test(arg))
+        return arg;
+    // Escape quotes by doubling them
+    return `"${arg.replace(/"/g, "\"\"")}"`;
+}
 export class SgRunner {
     constructor(verbose = false) {
         this.log = verbose
@@ -18,10 +30,8 @@ export class SgRunner {
      * Check if ast-grep CLI is available
      */
     isAvailable() {
-        const result = spawnSync("npx", ["sg", "--version"], {
-            encoding: "utf-8",
+        const result = safeSpawn("npx", ["sg", "--version"], {
             timeout: 10000,
-            shell: true,
         });
         return !result.error && result.status === 0;
     }
@@ -30,10 +40,46 @@ export class SgRunner {
      */
     async exec(args) {
         return new Promise((resolve) => {
-            const proc = spawn("npx", ["sg", ...args], {
-                stdio: ["ignore", "pipe", "pipe"],
-                shell: true,
-            });
+            // On Windows with Git Bash/MSYS2, we need to use bash to properly
+            // handle $variables in patterns (prevent shell expansion)
+            const isWindows = process.platform === "win32";
+            const hasBash = process.env.MSYSTEM || process.env.GIT_SHELL;
+            let proc;
+            if (isWindows && hasBash) {
+                // Use bash -c with properly escaped command
+                // In bash, use single quotes around arguments containing $ to prevent expansion
+                const escapedArgs = args.map((arg) => {
+                    // For bash, wrap $-containing args in single quotes
+                    if (arg.includes("$")) {
+                        return `'${arg.replace(/'/g, "'\\''")}'`;
+                    }
+                    // For other args with spaces/special chars, use double quotes
+                    if (/[\s\"]/.test(arg)) {
+                        return `"${arg.replace(/"/g, "\\\"")}"`;
+                    }
+                    return arg;
+                });
+                const bashCommand = `npx sg ${escapedArgs.join(" ")}`;
+                proc = spawn("bash", ["-c", bashCommand], {
+                    stdio: ["ignore", "pipe", "pipe"],
+                    windowsHide: true,
+                });
+            }
+            else if (isWindows) {
+                // Fallback: use cmd.exe with standard escaping
+                const fullCommand = `npx sg ${args.map(escapeWindowsArg).join(" ")}`;
+                proc = spawn(fullCommand, {
+                    stdio: ["ignore", "pipe", "pipe"],
+                    shell: true,
+                    windowsHide: true,
+                });
+            }
+            else {
+                // Unix: normal spawn without shell
+                proc = spawn("npx", ["sg", ...args], {
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+            }
             let stdout = "";
             let stderr = "";
             proc.stdout.on("data", (data) => (stdout += data.toString()));
@@ -78,11 +124,8 @@ export class SgRunner {
      * Run ast-grep synchronously (for simple scans)
      */
     execSync(args) {
-        const result = spawnSync("npx", ["sg", ...args], {
-            encoding: "utf-8",
+        const result = safeSpawn("npx", ["sg", ...args], {
             timeout: 30000,
-            shell: true,
-            maxBuffer: 32 * 1024 * 1024,
         });
         if (result.error) {
             return { output: "", error: result.error.message };
@@ -104,7 +147,38 @@ export class SgRunner {
             fs.mkdirSync(rulesSubdir, { recursive: true });
             fs.writeFileSync(configFile, `ruleDirs:\n  - ./rules\n`);
             fs.writeFileSync(ruleFile, ruleYaml);
-            const result = spawnSync("npx", ["sg", "scan", "--config", configFile, "--json", dir], { encoding: "utf-8", timeout, shell: true });
+            const result = safeSpawn("npx", ["sg", "scan", "--config", configFile, "--json", dir], { timeout });
+            const output = result.stdout || result.stderr || "";
+            if (!output.trim())
+                return [];
+            const items = JSON.parse(output);
+            return Array.isArray(items) ? items : [items];
+        }
+        catch {
+            return [];
+        }
+        finally {
+            try {
+                fs.rmSync(sessionDir, { recursive: true, force: true });
+            }
+            catch (err) {
+                this.log(`Cleanup failed: ${err.message}`);
+            }
+        }
+    }
+    /**
+     * Run a rule file scan (temporary config approach) - alias for tempScan
+     */
+    scanWithRule(ruleYaml, dir, timeout = 30000) {
+        const sessionDir = path.join(os.tmpdir(), `sg-scan-${Date.now()}`);
+        const rulesSubdir = path.join(sessionDir, "rules");
+        const configFile = path.join(sessionDir, ".sgconfig.yml");
+        const ruleFile = path.join(rulesSubdir, "rule.yml");
+        try {
+            fs.mkdirSync(rulesSubdir, { recursive: true });
+            fs.writeFileSync(configFile, `ruleDirs:\n  - ./rules\n`);
+            fs.writeFileSync(ruleFile, ruleYaml);
+            const result = safeSpawn("npx", ["sg", "scan", "--config", configFile, "--json", dir], { timeout });
             const output = result.stdout || result.stderr || "";
             if (!output.trim())
                 return [];

package/clients/sg-runner.ts

@@ -9,6 +9,19 @@ import { spawn, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
+
+/**
+ * Escape an argument for Windows cmd.exe shell execution.
+ * Handles spaces, quotes, and special characters.
+ */
+function escapeWindowsArg(arg: string): string {
+	// If no special characters, return as-is
+	if (!/[\s\"]/.test(arg)) return arg;
+
+	// Escape quotes by doubling them
+	return `"${arg.replace(/"/g, "\"\"")}"`;
+}
 
 export interface SgMatch {
 	file: string;
@@ -38,10 +51,8 @@ export class SgRunner {
 	 * Check if ast-grep CLI is available
 	 */
 	isAvailable(): boolean {
-		const result = spawnSync("npx", ["sg", "--version"], {
-			encoding: "utf-8",
+		const result = safeSpawn("npx", ["sg", "--version"], {
 			timeout: 10000,
-			shell: true,
 		});
 		return !result.error && result.status === 0;
 	}
@@ -51,10 +62,46 @@ export class SgRunner {
 	 */
 	async exec(args: string[]): Promise<SgResult> {
 		return new Promise((resolve) => {
-			const proc = spawn("npx", ["sg", ...args], {
-				stdio: ["ignore", "pipe", "pipe"],
-				shell: true,
-			});
+			// On Windows with Git Bash/MSYS2, we need to use bash to properly
+			// handle $variables in patterns (prevent shell expansion)
+			const isWindows = process.platform === "win32";
+			const hasBash = process.env.MSYSTEM || process.env.GIT_SHELL;
+
+			let proc;
+			if (isWindows && hasBash) {
+				// Use bash -c with properly escaped command
+				// In bash, use single quotes around arguments containing $ to prevent expansion
+				const escapedArgs = args.map((arg) => {
+					// For bash, wrap $-containing args in single quotes
+					if (arg.includes("$")) {
+						return `'${arg.replace(/'/g, "'\\''")}'`;
+					}
+					// For other args with spaces/special chars, use double quotes
+					if (/[\s\"]/.test(arg)) {
+						return `"${arg.replace(/"/g, "\\\"")}"`;
+					}
+					return arg;
+				});
+				const bashCommand = `npx sg ${escapedArgs.join(" ")}`;
+				proc = spawn("bash", ["-c", bashCommand], {
+					stdio: ["ignore", "pipe", "pipe"],
+					windowsHide: true,
+				});
+			} else if (isWindows) {
+				// Fallback: use cmd.exe with standard escaping
+				const fullCommand = `npx sg ${args.map(escapeWindowsArg).join(" ")}`;
+				proc = spawn(fullCommand, {
+					stdio: ["ignore", "pipe", "pipe"],
+					shell: true,
+					windowsHide: true,
+				});
+			} else {
+				// Unix: normal spawn without shell
+				proc = spawn("npx", ["sg", ...args], {
+					stdio: ["ignore", "pipe", "pipe"],
+				});
+			}
+
 			let stdout = "";
 			let stderr = "";
 
@@ -101,11 +148,8 @@ export class SgRunner {
 	 * Run ast-grep synchronously (for simple scans)
 	 */
 	execSync(args: string[]): { output: string; error?: string } {
-		const result = spawnSync("npx", ["sg", ...args], {
-			encoding: "utf-8",
+		const result = safeSpawn("npx", ["sg", ...args], {
 			timeout: 30000,
-			shell: true,
-			maxBuffer: 32 * 1024 * 1024,
 		});
 
 		if (result.error) {
@@ -137,10 +181,50 @@ export class SgRunner {
 			fs.writeFileSync(configFile, `ruleDirs:\n  - ./rules\n`);
 			fs.writeFileSync(ruleFile, ruleYaml);
 
-			const result = spawnSync(
+			const result = safeSpawn(
+				"npx",
+				["sg", "scan", "--config", configFile, "--json", dir],
+				{ timeout },
+			);
+
+			const output = result.stdout || result.stderr || "";
+			if (!output.trim()) return [];
+
+			const items = JSON.parse(output);
+			return Array.isArray(items) ? items : [items];
+		} catch {
+			return [];
+		} finally {
+			try {
+				fs.rmSync(sessionDir, { recursive: true, force: true });
+			} catch (err) {
+				this.log(`Cleanup failed: ${(err as Error).message}`);
+			}
+		}
+	}
+
+	/**
+	 * Run a rule file scan (temporary config approach) - alias for tempScan
+	 */
+	scanWithRule(
+		ruleYaml: string,
+		dir: string,
+		timeout = 30000,
+	): SgMatch[] {
+		const sessionDir = path.join(os.tmpdir(), `sg-scan-${Date.now()}`);
+		const rulesSubdir = path.join(sessionDir, "rules");
+		const configFile = path.join(sessionDir, ".sgconfig.yml");
+		const ruleFile = path.join(rulesSubdir, "rule.yml");
+
+		try {
+			fs.mkdirSync(rulesSubdir, { recursive: true });
+			fs.writeFileSync(configFile, `ruleDirs:\n  - ./rules\n`);
+			fs.writeFileSync(ruleFile, ruleYaml);
+
+			const result = safeSpawn(
 				"npx",
 				["sg", "scan", "--config", configFile, "--json", dir],
-				{ encoding: "utf-8", timeout, shell: true },
+				{ timeout },
 			);
 
 			const output = result.stdout || result.stderr || "";

package/clients/state-matrix.js

@@ -0,0 +1,160 @@
+/**
+ * State Matrix Builder
+ *
+ * Implements Amain's 57×72 state transfer matrix construction.
+ * Counts parent→child transitions in the TypeScript AST.
+ */
+import * as ts from "typescript";
+import { getStateIndex, NUM_STATES, NUM_SYNTAX } from "./amain-types.js";
+// ============================================================================
+// Matrix Construction
+// ============================================================================
+/**
+ * Build a 57×72 state transfer matrix from TypeScript source code.
+ *
+ * matrix[i][j] = count of transitions from syntax state i to state j
+ *
+ * @param sourceCode TypeScript source code
+ * @returns 57×72 matrix of transition counts
+ */
+export function buildStateMatrix(sourceCode) {
+    const sourceFile = ts.createSourceFile("temp.ts", sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    // Initialize 57×72 matrix with zeros
+    const matrix = Array(NUM_SYNTAX)
+        .fill(0)
+        .map(() => Array(NUM_STATES).fill(0));
+    // Walk AST and count transitions
+    function visitNode(node, parentKind) {
+        const nodeState = getStateIndex(node);
+        if (parentKind !== undefined) {
+            const parentState = getStateIndex({ kind: parentKind });
+            // Only count transitions from syntax states (first 57)
+            if (parentState < NUM_SYNTAX) {
+                matrix[parentState][nodeState]++;
+            }
+        }
+        // Continue to children
+        ts.forEachChild(node, (child) => visitNode(child, node.kind));
+    }
+    visitNode(sourceFile);
+    return matrix;
+}
+/**
+ * Build matrix from a source file node (for incremental updates)
+ */
+export function buildStateMatrixFromFile(sourceFile) {
+    // Initialize 57×72 matrix with zeros
+    const matrix = Array(NUM_SYNTAX)
+        .fill(0)
+        .map(() => Array(NUM_STATES).fill(0));
+    // Walk AST and count transitions
+    function visitNode(node, parentKind) {
+        const nodeState = getStateIndex(node);
+        if (parentKind !== undefined) {
+            const parentState = getStateIndex({ kind: parentKind });
+            // Only count transitions from syntax states (first 57)
+            if (parentState < NUM_SYNTAX) {
+                matrix[parentState][nodeState]++;
+            }
+        }
+        // Continue to children
+        ts.forEachChild(node, (child) => visitNode(child, node.kind));
+    }
+    visitNode(sourceFile);
+    return matrix;
+}
+// ============================================================================
+// Probability Normalization
+// ============================================================================
+/**
+ * Convert count matrix to probability matrix.
+ * Each row sums to 1 (Markov chain property).
+ *
+ * @param matrix 57×72 count matrix
+ * @returns 57×72 probability matrix
+ */
+export function toProbabilityMatrix(matrix) {
+    return matrix.map((row) => {
+        const sum = row.reduce((a, b) => a + b, 0);
+        if (sum === 0)
+            return row.map(() => 0);
+        return row.map((val) => val / sum);
+    });
+}
+// ============================================================================
+// Similarity Calculation
+// ============================================================================
+/**
+ * Calculate cosine similarity between two state matrices.
+ * Returns 0-1 similarity score (1 = identical).
+ *
+ * @param matrix1 57×72 count matrix
+ * @param matrix2 57×72 count matrix
+ * @returns similarity score 0-1
+ */
+export function calculateSimilarity(matrix1, matrix2) {
+    const prob1 = toProbabilityMatrix(matrix1);
+    const prob2 = toProbabilityMatrix(matrix2);
+    const similarities = [];
+    for (let i = 0; i < NUM_SYNTAX; i++) {
+        const row1 = prob1[i];
+        const row2 = prob2[i];
+        // Skip if both rows are empty
+        const hasData1 = row1.some((v) => v > 0);
+        const hasData2 = row2.some((v) => v > 0);
+        if (hasData1 || hasData2) {
+            // Calculate cosine similarity for this state
+            let dotProduct = 0;
+            let norm1 = 0;
+            let norm2 = 0;
+            for (let j = 0; j < NUM_STATES; j++) {
+                dotProduct += row1[j] * row2[j];
+                norm1 += row1[j] * row1[j];
+                norm2 += row2[j] * row2[j];
+            }
+            if (norm1 > 0 && norm2 > 0) {
+                similarities.push(dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2)));
+            }
+        }
+    }
+    // Return average similarity across all states
+    if (similarities.length === 0)
+        return 0;
+    return similarities.reduce((a, b) => a + b, 0) / similarities.length;
+}
+/**
+ * Calculate similarity from source code directly (convenience method)
+ */
+export function calculateSimilarityFromCode(code1, code2) {
+    const matrix1 = buildStateMatrix(code1);
+    const matrix2 = buildStateMatrix(code2);
+    return calculateSimilarity(matrix1, matrix2);
+}
+// ============================================================================
+// Matrix Statistics (for guardrails)
+// ============================================================================
+/**
+ * Count total non-zero transitions in matrix (proxy for function complexity)
+ */
+export function countTransitions(matrix) {
+    return matrix.flat().filter((v) => v > 0).length;
+}
+/**
+ * Check if function meets complexity threshold (>20 transitions)
+ */
+export function isComplexEnough(matrix) {
+    return countTransitions(matrix) >= 20;
+}
+/**
+ * Serialize matrix for storage (sparse format to save space)
+ */
+export function serializeMatrix(matrix) {
+    // Return full matrix for now - can optimize to sparse later if needed
+    return matrix;
+}
+/**
+ * Deserialize matrix from storage
+ */
+export function deserializeMatrix(data) {
+    return data;
+}