pi-lens 2.2.9 → 3.0.0

package/clients/state-matrix.ts

@@ -0,0 +1,202 @@
+/**
+ * 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: string): number[][] {
+	const sourceFile = ts.createSourceFile(
+		"temp.ts",
+		sourceCode,
+		ts.ScriptTarget.Latest,
+		true,
+		ts.ScriptKind.TS,
+	);
+
+	// Initialize 57×72 matrix with zeros
+	const matrix: number[][] = Array(NUM_SYNTAX)
+		.fill(0)
+		.map(() => Array(NUM_STATES).fill(0));
+
+	// Walk AST and count transitions
+	function visitNode(node: ts.Node, parentKind?: number) {
+		const nodeState = getStateIndex(node);
+
+		if (parentKind !== undefined) {
+			const parentState = getStateIndex({ kind: parentKind } as ts.Node);
+			// 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: ts.SourceFile,
+): number[][] {
+	// Initialize 57×72 matrix with zeros
+	const matrix: number[][] = Array(NUM_SYNTAX)
+		.fill(0)
+		.map(() => Array(NUM_STATES).fill(0));
+
+	// Walk AST and count transitions
+	function visitNode(node: ts.Node, parentKind?: number) {
+		const nodeState = getStateIndex(node);
+
+		if (parentKind !== undefined) {
+			const parentState = getStateIndex({ kind: parentKind } as ts.Node);
+			// 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: number[][]): number[][] {
+	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: number[][],
+	matrix2: number[][],
+): number {
+	const prob1 = toProbabilityMatrix(matrix1);
+	const prob2 = toProbabilityMatrix(matrix2);
+
+	const similarities: number[] = [];
+
+	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: string,
+	code2: string,
+): number {
+	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: number[][]): number {
+	return matrix.flat().filter((v) => v > 0).length;
+}
+
+/**
+ * Check if function meets complexity threshold (>20 transitions)
+ */
+export function isComplexEnough(matrix: number[][]): boolean {
+	return countTransitions(matrix) >= 20;
+}
+
+/**
+ * Serialize matrix for storage (sparse format to save space)
+ */
+export function serializeMatrix(matrix: number[][]): number[][] {
+	// Return full matrix for now - can optimize to sparse later if needed
+	return matrix;
+}
+
+/**
+ * Deserialize matrix from storage
+ */
+export function deserializeMatrix(data: number[][]): number[][] {
+	return data;
+}

package/clients/subprocess-client.js

@@ -1,5 +1,5 @@
-import { spawnSync } from "node:child_process";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 export class SubprocessClient {
     constructor(verbose = false) {
         this.available = null;
@@ -13,10 +13,8 @@ export class SubprocessClient {
             return this.available;
         const cmd = this.getCheckCommand();
         try {
-            const result = spawnSync(cmd[0], cmd.slice(1), {
-                encoding: "utf-8",
+            const result = safeSpawn(cmd[0], cmd.slice(1), {
                 timeout: 10000,
-                shell: true,
             });
             this.available = !result.error && result.status === 0;
             if (this.available) {
@@ -39,17 +37,20 @@ export class SubprocessClient {
     runCommand(cmd, options = {}) {
         const { cwd, timeout = 15000, input } = options;
         try {
-            const result = spawnSync(cmd[0], cmd.slice(1), {
-                encoding: "utf-8",
+            const result = safeSpawn(cmd[0], cmd.slice(1), {
                 timeout,
                 cwd,
-                shell: true,
-                input,
             });
             if (result.error) {
                 this.log(`Command error: ${result.error.message}`);
             }
-            return result;
+            // Return in a shape compatible with spawnSync return type
+            return {
+                status: result.status,
+                stdout: result.stdout,
+                stderr: result.stderr,
+                error: result.error,
+            };
         }
         catch (err) {
             this.log(`Command failed: ${err.message}`);

package/clients/subprocess-client.ts

@@ -1,5 +1,6 @@
 import { spawnSync } from "node:child_process";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 
 export interface Diagnostic {
 	line: number;
@@ -35,10 +36,8 @@ export abstract class SubprocessClient<T extends Diagnostic> {
 
 		const cmd = this.getCheckCommand();
 		try {
-			const result = spawnSync(cmd[0], cmd.slice(1), {
-				encoding: "utf-8",
+			const result = safeSpawn(cmd[0], cmd.slice(1), {
 				timeout: 10000,
-				shell: true,
 			});
 
 			this.available = !result.error && result.status === 0;
@@ -73,19 +72,22 @@ export abstract class SubprocessClient<T extends Diagnostic> {
 		const { cwd, timeout = 15000, input } = options;
 
 		try {
-			const result = spawnSync(cmd[0], cmd.slice(1), {
-				encoding: "utf-8",
+			const result = safeSpawn(cmd[0], cmd.slice(1), {
 				timeout,
 				cwd,
-				shell: true,
-				input,
 			});
 
 			if (result.error) {
 				this.log(`Command error: ${result.error.message}`);
 			}
 
-			return result;
+			// Return in a shape compatible with spawnSync return type
+			return {
+				status: result.status,
+				stdout: result.stdout,
+				stderr: result.stderr,
+				error: result.error,
+			} as unknown as ReturnType<typeof spawnSync>;
 		} catch (err: any) {
 			this.log(`Command failed: ${err.message}`);
 			return {

package/clients/test-runner-client.js

@@ -9,9 +9,9 @@
  * Design: File-level targeted testing — only runs tests for the
  * specific file being edited, not the entire suite.
  */
-import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 // --- Test File Patterns ---
 const _TEST_FILE_PATTERNS = [
     {
@@ -250,10 +250,8 @@ export class TestRunnerClient {
         // Priority 5: Check if pytest is available globally (for Python)
         try {
             const whichCmd = process.platform === "win32" ? "where" : "which";
-            const result = spawnSync(whichCmd, ["pytest"], {
-                encoding: "utf-8",
+            const result = safeSpawn(whichCmd, ["pytest"], {
                 timeout: 2000,
-                shell: true,
             });
             if (result.status === 0) {
                 this.log("Detected pytest globally");
@@ -336,11 +334,9 @@ export class TestRunnerClient {
         try {
             const args = config.args(absoluteTestFile, cwd);
             this.log(`Running: ${config.command} ${args.join(" ")}`);
-            const result = spawnSync(config.command, args, {
-                encoding: "utf-8",
+            const result = safeSpawn(config.command, args, {
                 cwd,
                 timeout: 60000, // 60s timeout
-                shell: true,
             });
             const stdout = result.stdout || "";
             const stderr = result.stderr || "";

package/clients/test-runner-client.ts

@@ -13,6 +13,7 @@
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 
 // --- Types ---
 
@@ -303,10 +304,8 @@ export class TestRunnerClient {
 		// Priority 5: Check if pytest is available globally (for Python)
 		try {
 			const whichCmd = process.platform === "win32" ? "where" : "which";
-			const result = spawnSync(whichCmd, ["pytest"], {
-				encoding: "utf-8",
+			const result = safeSpawn(whichCmd, ["pytest"], {
 				timeout: 2000,
-				shell: true,
 			});
 			if (result.status === 0) {
 				this.log("Detected pytest globally");
@@ -413,11 +412,9 @@ export class TestRunnerClient {
 			const args = config.args(absoluteTestFile, cwd);
 			this.log(`Running: ${config.command} ${args.join(" ")}`);
 
-			const result = spawnSync(config.command, args, {
-				encoding: "utf-8",
+			const result = safeSpawn(config.command, args, {
 				cwd,
 				timeout: 60000, // 60s timeout
-				shell: true,
 			});
 
 			const stdout = result.stdout || "";

package/clients/tool-availability.js

@@ -4,7 +4,7 @@
  * Provides cached tool availability checks to avoid repeated spawnSync calls.
  * Tools like biome, ruff, ast-grep are checked once per session.
  */
-import { spawnSync } from "node:child_process";
+import { safeSpawn } from "./safe-spawn.js";
 // --- Tool Registry ---
 export const TOOL_REGISTRY = [
     {
@@ -91,10 +91,8 @@ export function isToolAvailable(toolName) {
     const tool = TOOL_REGISTRY.find((t) => t.name === toolName);
     if (!tool) {
         // Unknown tool - try direct command check
-        const result = spawnSync(toolName, ["--version"], {
-            encoding: "utf-8",
+        const result = safeSpawn(toolName, ["--version"], {
             timeout: 5000,
-            shell: true,
         });
         const available = !result.error && result.status === 0;
         TOOL_CACHE.set(toolName, {
@@ -108,10 +106,8 @@ export function isToolAvailable(toolName) {
     }
     // Check using tool's version command
     if (tool.versionCommand) {
-        const result = spawnSync(tool.command, tool.versionCommand, {
-            encoding: "utf-8",
+        const result = safeSpawn(tool.command, tool.versionCommand, {
             timeout: 10000,
-            shell: true,
         });
         const available = !result.error && result.status === 0;
         const output = result.stdout + result.stderr;
@@ -138,10 +134,8 @@ export function getToolVersion(toolName) {
     // Try to get version even if not cached
     const tool = TOOL_REGISTRY.find((t) => t.name === toolName);
     if (tool?.versionCommand) {
-        const result = spawnSync(tool.command, tool.versionCommand, {
-            encoding: "utf-8",
+        const result = safeSpawn(tool.command, tool.versionCommand, {
             timeout: 10000,
-            shell: true,
         });
         if (!result.error && result.status === 0) {
             const output = result.stdout + result.stderr;

package/clients/tool-availability.ts

@@ -6,6 +6,7 @@
  */
 
 import { spawnSync } from "node:child_process";
+import { safeSpawn } from "./safe-spawn.js";
 
 // --- Types ---
 
@@ -116,10 +117,8 @@ export function isToolAvailable(toolName: string): boolean {
 	const tool = TOOL_REGISTRY.find((t) => t.name === toolName);
 	if (!tool) {
 		// Unknown tool - try direct command check
-		const result = spawnSync(toolName, ["--version"], {
-			encoding: "utf-8",
+		const result = safeSpawn(toolName, ["--version"], {
 			timeout: 5000,
-			shell: true,
 		});
 		const available = !result.error && result.status === 0;
 		TOOL_CACHE.set(toolName, {
@@ -134,10 +133,8 @@ export function isToolAvailable(toolName: string): boolean {
 
 	// Check using tool's version command
 	if (tool.versionCommand) {
-		const result = spawnSync(tool.command, tool.versionCommand, {
-			encoding: "utf-8",
+		const result = safeSpawn(tool.command, tool.versionCommand, {
 			timeout: 10000,
-			shell: true,
 		});
 		const available = !result.error && result.status === 0;
 		const output = result.stdout + result.stderr;
@@ -169,10 +166,8 @@ export function getToolVersion(toolName: string): string | undefined {
 	// Try to get version even if not cached
 	const tool = TOOL_REGISTRY.find((t) => t.name === toolName);
 	if (tool?.versionCommand) {
-		const result = spawnSync(tool.command, tool.versionCommand, {
-			encoding: "utf-8",
+		const result = safeSpawn(tool.command, tool.versionCommand, {
 			timeout: 10000,
-			shell: true,
 		});
 		if (!result.error && result.status === 0) {
 			const output = result.stdout + result.stderr;