pi-lens 2.0.28 → 2.0.35

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to pi-lens will be documented in this file.
 
+## [2.0.29] - 2026-03-26
+
+### Added
+- **`clients/ts-service.ts`**: Shared TypeScript service that creates one `ts.Program` per session. Both `complexity-client` and `type-safety-client` now share the same program instead of creating a new one per file. Significant performance improvement on large codebases.
+
+### Removed
+- **3 redundant ast-grep rules** that overlap with Biome: `no-var`, `prefer-template`, `no-useless-concat`. Biome handles these natively with auto-fix. ast-grep no longer duplicates this coverage.
+- **`prefer-const` from RULE_ACTIONS** — no longer needed (Biome handles directly).
+
+### Changed
+- **Consolidated rule overlap**: Biome is now the single source of truth for style/format rules. ast-grep focuses on structural patterns Biome doesn't cover (security, design smells, AI slop).
+
 ## [2.0.27] - 2026-03-26
 
 ### Added

package/README.md

@@ -195,8 +195,8 @@ Each rule includes a `message` and `note` that are shown in diagnostics, so the
 **TypeScript**
 `no-any-type`, `no-as-any`, `no-non-null-assertion`
 
-**Style**
-`no-var`, `prefer-const`, `prefer-template`, `no-useless-concat`, `prefer-nullish-coalescing`, `prefer-optional-chain`, `nested-ternary`, `no-lonely-if`
+**Style** (Biome handles `no-var`, `prefer-const`, `prefer-template`, `no-useless-concat` natively)
+`prefer-nullish-coalescing`, `prefer-optional-chain`, `nested-ternary`, `no-lonely-if`
 
 **Correctness**
 `no-debugger`, `no-throw-string`, `no-return-await`, `no-await-in-loop`, `no-await-in-promise-all`, `require-await`, `empty-catch`, `strict-equality`, `strict-inequality`

package/clients/architect-client.js

@@ -0,0 +1,216 @@
+/**
+ * Architect Client for pi-lens
+ *
+ * Loads path-based architectural rules from .pi-lens/architect.yaml
+ * and checks file paths against them.
+ *
+ * Provides:
+ * - Pre-write hints: what rules apply before the agent edits
+ * - Post-write validation: check for violations after edits
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { minimatch } from "minimatch";
+// --- Client ---
+export class ArchitectClient {
+    constructor(verbose = false) {
+        this.config = null;
+        this.configPath = null;
+        this.log = verbose
+            ? (msg) => console.error(`[architect] ${msg}`)
+            : () => { };
+    }
+    /**
+     * Load architect config from project root
+     */
+    loadConfig(projectRoot) {
+        // Try common locations
+        const candidates = [
+            path.join(projectRoot, ".pi-lens", "architect.yaml"),
+            path.join(projectRoot, "architect.yaml"),
+            path.join(projectRoot, ".pi-lens", "architect.yml"),
+        ];
+        for (const configPath of candidates) {
+            try {
+                const content = fs.readFileSync(configPath, "utf-8");
+                this.config = this.parseYaml(content);
+                this.configPath = configPath;
+                this.log(`Loaded architect config from ${configPath}`);
+                return true;
+            }
+            catch (error) {
+                this.log(`Could not read ${configPath}: ${error}`);
+                continue;
+            }
+        }
+        this.log("No architect.yaml found");
+        return false;
+    }
+    /**
+     * Check if config is loaded
+     */
+    hasConfig() {
+        return this.config !== null;
+    }
+    /**
+     * Get rules that apply to a file path
+     */
+    getRulesForFile(filePath) {
+        if (!this.config)
+            return [];
+        const matched = [];
+        for (const rule of this.config.rules) {
+            if (minimatch(filePath, rule.pattern, { matchBase: true })) {
+                matched.push(rule);
+            }
+        }
+        return matched;
+    }
+    /**
+     * Check code content against rules for a file path
+     * Returns violations found
+     */
+    checkFile(filePath, content) {
+        const rules = this.getRulesForFile(filePath);
+        const violations = [];
+        for (const rule of rules) {
+            if (!rule.must_not)
+                continue;
+            for (const check of rule.must_not) {
+                const regex = new RegExp(check.pattern, "i");
+                if (regex.test(content)) {
+                    violations.push({
+                        pattern: rule.pattern,
+                        message: check.message,
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check file size against max_lines rule
+     * Returns violation if file exceeds the limit
+     */
+    checkFileSize(filePath, lineCount) {
+        const rules = this.getRulesForFile(filePath);
+        for (const rule of rules) {
+            if (rule.max_lines && lineCount > rule.max_lines) {
+                return {
+                    pattern: rule.pattern,
+                    message: `File is ${lineCount} lines — exceeds ${rule.max_lines} line limit. Split into smaller modules.`,
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Get pre-write hints for a file path
+     * Returns rules that will apply to the file being written
+     */
+    getHints(filePath) {
+        const rules = this.getRulesForFile(filePath);
+        const hints = [];
+        for (const rule of rules) {
+            if (rule.must_not) {
+                for (const check of rule.must_not) {
+                    hints.push(check.message);
+                }
+            }
+            if (rule.must) {
+                for (const req of rule.must) {
+                    hints.push(`Must: ${req}`);
+                }
+            }
+        }
+        return hints;
+    }
+    /**
+     * Simple YAML parser for architect.yaml format
+     * Handles the specific structure we need
+     */
+    parseYaml(content) {
+        const config = { rules: [] };
+        // Split into top-level rule blocks (4-space indent "- pattern:")
+        const ruleBlocks = content.split(/(?=^  - pattern:)/m);
+        for (const block of ruleBlocks) {
+            const lines = block.split("\n");
+            let rule = null;
+            let section = null;
+            let violation = null;
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith("#") || !trimmed)
+                    continue;
+                // Version (top-level)
+                if (trimmed.startsWith("version:") && !rule) {
+                    config.version = trimmed.split(":")[1]?.trim().replace(/['"]/g, "");
+                    continue;
+                }
+                // Rule pattern
+                const ruleMatch = trimmed.match(/^-?\s*pattern:\s*["'](.+?)["']/);
+                if (ruleMatch && trimmed.startsWith("-") && !section) {
+                    rule = { pattern: ruleMatch[1], must_not: [], must: [] };
+                    continue;
+                }
+                // Nested pattern inside must_not (may start with "- ")
+                if ((trimmed.startsWith("pattern:") || trimmed.startsWith("- pattern:")) && section === "must_not") {
+                    // Extract everything after "pattern:" and unquote
+                    const raw = trimmed.replace(/^-?\s*pattern:\s*/, "").trim();
+                    const unquoted = raw.replace(/^["']|["']$/g, "");
+                    if (unquoted) {
+                        violation = { pattern: unquoted, message: "" };
+                    }
+                    continue;
+                }
+                // Section headers
+                if (trimmed === "must_not:" || trimmed.startsWith("must_not:")) {
+                    section = "must_not";
+                    continue;
+                }
+                if (trimmed === "must:") {
+                    section = "must";
+                    continue;
+                }
+                // Message for current violation
+                if (trimmed.startsWith("message:") && violation) {
+                    const match = trimmed.match(/message:\s*["'](.+?)["']/);
+                    if (match) {
+                        violation.message = match[1];
+                        if (rule) {
+                            rule.must_not = rule.must_not ?? [];
+                            rule.must_not.push(violation);
+                        }
+                        violation = null;
+                    }
+                    continue;
+                }
+                // Must items (simple strings)
+                if (section === "must" && trimmed.startsWith("- ") && rule) {
+                    const item = trimmed.slice(2).replace(/^["']|["']$/g, "");
+                    rule.must = rule.must ?? [];
+                    rule.must.push(item);
+                }
+                // max_lines setting
+                if (trimmed.startsWith("max_lines:") && rule) {
+                    const num = parseInt(trimmed.split(":")[1]?.trim(), 10);
+                    if (!Number.isNaN(num)) {
+                        rule.max_lines = num;
+                    }
+                }
+            }
+            if (rule) {
+                config.rules.push(rule);
+            }
+        }
+        return config;
+    }
+}
+// --- Singleton ---
+let instance = null;
+export function getArchitectClient(verbose = false) {
+    if (!instance) {
+        instance = new ArchitectClient(verbose);
+    }
+    return instance;
+}

package/clients/architect-client.ts

@@ -0,0 +1,273 @@
+/**
+ * Architect Client for pi-lens
+ *
+ * Loads path-based architectural rules from .pi-lens/architect.yaml
+ * and checks file paths against them.
+ *
+ * Provides:
+ * - Pre-write hints: what rules apply before the agent edits
+ * - Post-write validation: check for violations after edits
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { minimatch } from "minimatch";
+
+// --- Types ---
+
+export interface ArchitectViolation {
+	pattern: string;
+	message: string;
+}
+
+export interface ArchitectRule {
+	pattern: string;
+	must_not?: Array<{ pattern: string; message: string }>;
+	must?: string[];
+	max_lines?: number;
+}
+
+export interface ArchitectConfig {
+	version?: string;
+	inherits?: string[];
+	rules: ArchitectRule[];
+}
+
+export interface FileArchitectResult {
+	filePath: string;
+	matchedRules: ArchitectRule[];
+	violations: ArchitectViolation[];
+}
+
+// --- Client ---
+
+export class ArchitectClient {
+	private config: ArchitectConfig | null = null;
+	private configPath: string | null = null;
+	private log: (msg: string) => void;
+
+	constructor(verbose = false) {
+		this.log = verbose
+			? (msg: string) => console.error(`[architect] ${msg}`)
+			: () => {};
+	}
+
+	/**
+	 * Load architect config from project root
+	 */
+	loadConfig(projectRoot: string): boolean {
+		// Try common locations
+		const candidates = [
+			path.join(projectRoot, ".pi-lens", "architect.yaml"),
+			path.join(projectRoot, "architect.yaml"),
+			path.join(projectRoot, ".pi-lens", "architect.yml"),
+		];
+
+		for (const configPath of candidates) {
+			try {
+				const content = fs.readFileSync(configPath, "utf-8");
+				this.config = this.parseYaml(content);
+				this.configPath = configPath;
+				this.log(`Loaded architect config from ${configPath}`);
+				return true;
+			} catch (error) {
+				this.log(`Could not read ${configPath}: ${error}`);
+				continue;
+			}
+		}
+
+		this.log("No architect.yaml found");
+		return false;
+	}
+
+	/**
+	 * Check if config is loaded
+	 */
+	hasConfig(): boolean {
+		return this.config !== null;
+	}
+
+	/**
+	 * Get rules that apply to a file path
+	 */
+	getRulesForFile(filePath: string): ArchitectRule[] {
+		if (!this.config) return [];
+
+		const matched: ArchitectRule[] = [];
+		for (const rule of this.config.rules) {
+			if (minimatch(filePath, rule.pattern, { matchBase: true })) {
+				matched.push(rule);
+			}
+		}
+		return matched;
+	}
+
+	/**
+	 * Check code content against rules for a file path
+	 * Returns violations found
+	 */
+	checkFile(filePath: string, content: string): ArchitectViolation[] {
+		const rules = this.getRulesForFile(filePath);
+		const violations: ArchitectViolation[] = [];
+
+		for (const rule of rules) {
+			if (!rule.must_not) continue;
+
+			for (const check of rule.must_not) {
+				const regex = new RegExp(check.pattern, "i");
+				if (regex.test(content)) {
+					violations.push({
+						pattern: rule.pattern,
+						message: check.message,
+					});
+				}
+			}
+		}
+
+		return violations;
+	}
+
+	/**
+	 * Check file size against max_lines rule
+	 * Returns violation if file exceeds the limit
+	 */
+	checkFileSize(filePath: string, lineCount: number): ArchitectViolation | null {
+		const rules = this.getRulesForFile(filePath);
+
+		for (const rule of rules) {
+			if (rule.max_lines && lineCount > rule.max_lines) {
+				return {
+					pattern: rule.pattern,
+					message: `File is ${lineCount} lines — exceeds ${rule.max_lines} line limit. Split into smaller modules.`,
+				};
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Get pre-write hints for a file path
+	 * Returns rules that will apply to the file being written
+	 */
+	getHints(filePath: string): string[] {
+		const rules = this.getRulesForFile(filePath);
+		const hints: string[] = [];
+
+		for (const rule of rules) {
+			if (rule.must_not) {
+				for (const check of rule.must_not) {
+					hints.push(check.message);
+				}
+			}
+			if (rule.must) {
+				for (const req of rule.must) {
+					hints.push(`Must: ${req}`);
+				}
+			}
+		}
+
+		return hints;
+	}
+
+	/**
+	 * Simple YAML parser for architect.yaml format
+	 * Handles the specific structure we need
+	 */
+	private parseYaml(content: string): ArchitectConfig {
+		const config: ArchitectConfig = { rules: [] };
+
+		// Split into top-level rule blocks (4-space indent "- pattern:")
+		const ruleBlocks = content.split(/(?=^  - pattern:)/m);
+
+		for (const block of ruleBlocks) {
+			const lines = block.split("\n");
+			let rule: ArchitectRule | null = null;
+			let section: "must_not" | "must" | null = null;
+			let violation: { pattern: string; message: string } | null = null;
+
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (trimmed.startsWith("#") || !trimmed) continue;
+
+				// Version (top-level)
+				if (trimmed.startsWith("version:") && !rule) {
+					config.version = trimmed.split(":")[1]?.trim().replace(/['"]/g, "");
+					continue;
+				}
+
+				// Rule pattern
+				const ruleMatch = trimmed.match(/^-?\s*pattern:\s*["'](.+?)["']/);
+				if (ruleMatch && trimmed.startsWith("-") && !section) {
+					rule = { pattern: ruleMatch[1], must_not: [], must: [] };
+					continue;
+				}
+				// Nested pattern inside must_not (may start with "- ")
+				if ((trimmed.startsWith("pattern:") || trimmed.startsWith("- pattern:")) && section === "must_not") {
+					// Extract everything after "pattern:" and unquote
+					const raw = trimmed.replace(/^-?\s*pattern:\s*/, "").trim();
+					const unquoted = raw.replace(/^["']|["']$/g, "");
+					if (unquoted) {
+						violation = { pattern: unquoted, message: "" };
+					}
+					continue;
+				}
+
+				// Section headers
+				if (trimmed === "must_not:" || trimmed.startsWith("must_not:")) {
+					section = "must_not";
+					continue;
+				}
+				if (trimmed === "must:") {
+					section = "must";
+					continue;
+				}
+
+				// Message for current violation
+				if (trimmed.startsWith("message:") && violation) {
+					const match = trimmed.match(/message:\s*["'](.+?)["']/);
+					if (match) {
+						violation.message = match[1];
+						if (rule) {
+							rule.must_not = rule.must_not ?? [];
+							rule.must_not.push(violation);
+						}
+						violation = null;
+					}
+					continue;
+				}
+
+				// Must items (simple strings)
+				if (section === "must" && trimmed.startsWith("- ") && rule) {
+					const item = trimmed.slice(2).replace(/^["']|["']$/g, "");
+					rule.must = rule.must ?? [];
+					rule.must.push(item);
+				}
+
+				// max_lines setting
+				if (trimmed.startsWith("max_lines:") && rule) {
+					const num = parseInt(trimmed.split(":")[1]?.trim(), 10);
+					if (!Number.isNaN(num)) {
+						rule.max_lines = num;
+					}
+				}
+			}
+
+			if (rule) {
+				config.rules.push(rule);
+			}
+		}
+
+		return config;
+	}
+}
+
+// --- Singleton ---
+
+let instance: ArchitectClient | null = null;
+
+export function getArchitectClient(verbose = false): ArchitectClient {
+	if (!instance) {
+		instance = new ArchitectClient(verbose);
+	}
+	return instance;
+}

package/clients/jscpd-client.js

@@ -57,7 +57,7 @@ export class JscpdClient {
                 "--output",
                 outDir,
                 "--ignore",
-                "**/node_modules/**,**/dist/**,**/build/**,**/.git/**,**/.pi-lens/**,**/*.md,**/*.txt,**/*.json,**/*.yaml,**/*.yml,**/*.toml,**/*.lock",
+                "**/node_modules/**,**/dist/**,**/build/**,**/.git/**,**/.pi-lens/**,**/*.md,**/*.txt,**/*.json,**/*.yaml,**/*.yml,**/*.toml,**/*.lock,**/*.test.*,**/*.spec.*",
             ], {
                 encoding: "utf-8",
                 timeout: 30000,

package/clients/jscpd-client.ts

@@ -86,7 +86,7 @@ export class JscpdClient {
 					"--output",
 					outDir,
 					"--ignore",
-					"**/node_modules/**,**/dist/**,**/build/**,**/.git/**,**/.pi-lens/**,**/*.md,**/*.txt,**/*.json,**/*.yaml,**/*.yml,**/*.toml,**/*.lock",
+					"**/node_modules/**,**/dist/**,**/build/**,**/.git/**,**/.pi-lens/**,**/*.md,**/*.txt,**/*.json,**/*.yaml,**/*.yml,**/*.toml,**/*.lock,**/*.test.*,**/*.spec.*",
 				],
 				{
 					encoding: "utf-8",

package/clients/scan-architectural-debt.js

@@ -1,6 +1,6 @@
 /**
  * Shared architectural debt scanning — used by booboo-fix and booboo-refactor.
- * Scans ast-grep skip rules + complexity metrics, scores files by combined signal.
+ * Scans ast-grep skip rules + complexity metrics + architect.yaml rules.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -73,11 +73,56 @@ export function scanComplexityMetrics(complexityClient, targetPath, isTsProject)
     scanDir(targetPath);
     return metricsByFile;
 }
+/**
+ * Scan for architectural rule violations grouped by absolute file path.
+ * Returns map of absolute file path → list of violation messages.
+ */
+export function scanArchitectViolations(architectClient, targetPath) {
+    const violationsByFile = new Map();
+    if (!architectClient.hasConfig())
+        return violationsByFile;
+    const scanDir = (dir) => {
+        if (!fs.existsSync(dir))
+            return;
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (["node_modules", ".git", "dist", "build", ".next", ".pi-lens"].includes(entry.name))
+                    continue;
+                scanDir(full);
+            }
+            else if (/\.(ts|tsx|js|jsx|py|go|rs)$/.test(entry.name)) {
+                const relPath = path.relative(targetPath, full).replace(/\\/g, "/");
+                const content = fs.readFileSync(full, "utf-8");
+                const lineCount = content.split("\n").length;
+                const msgs = [];
+                // Check pattern violations
+                for (const v of architectClient.checkFile(relPath, content)) {
+                    msgs.push(v.message);
+                }
+                // Check file size
+                const sizeV = architectClient.checkFileSize(relPath, lineCount);
+                if (sizeV) {
+                    msgs.push(sizeV.message);
+                }
+                if (msgs.length > 0) {
+                    violationsByFile.set(full, msgs);
+                }
+            }
+        }
+    };
+    scanDir(targetPath);
+    return violationsByFile;
+}
 /**
  * Score each file by combined debt signal. Higher = worse.
  */
-export function scoreFiles(skipByFile, metricsByFile) {
-    const allFiles = new Set([...skipByFile.keys(), ...metricsByFile.keys()]);
+export function scoreFiles(skipByFile, metricsByFile, architectViolations) {
+    const allFiles = new Set([
+        ...skipByFile.keys(),
+        ...metricsByFile.keys(),
+        ...(architectViolations?.keys() ?? []),
+    ]);
     return [...allFiles]
         .map((file) => {
         let score = 0;
@@ -108,6 +153,11 @@ export function scoreFiles(skipByFile, metricsByFile) {
             else
                 score += 1;
         }
+        // Architect violations are high-priority signals
+        const archMsgs = architectViolations?.get(file);
+        if (archMsgs && archMsgs.length > 0) {
+            score += archMsgs.length * 3; // Each violation = 3 points
+        }
         return { file, score };
     })
         .filter((f) => f.score > 0)