pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/architect.test.ts

@@ -0,0 +1,162 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, expect, it, beforeAll, afterAll } from "vitest";
+import type { DispatchContext } from "../types.js";
+
+function createMockContext(
+	filePath: string,
+	kind: "jsts" | "python" | "go" | "rust" = "jsts",
+	cwd?: string,
+): DispatchContext {
+	return {
+		filePath,
+		cwd: cwd || process.cwd(),
+		kind,
+		autofix: false,
+		deltaMode: false,
+		baselines: { get: () => undefined, set: () => {}, clear: () => {} } as any,
+		pi: { getFlag: () => false } as any,
+		hasTool: async () => false,
+		log: () => {},
+	};
+}
+
+describe("architect runner", () => {
+	const testDir = path.join(process.env.TEMP || "/tmp", `architect_test_${Date.now()}`);
+	const configPath = path.join(testDir, ".pi-lens", "architect.yaml");
+
+	beforeAll(() => {
+		// Create test config
+		fs.mkdirSync(path.dirname(configPath), { recursive: true });
+		fs.writeFileSync(
+			configPath,
+			`version: "1.0"
+rules:
+  - pattern: "**/*.ts"
+    max_lines: 50
+    must_not:
+      - pattern: 'hardcoded_secret_12345'
+        message: "No hardcoded secrets"
+        fix: "Use process.env.SECRET"
+      - pattern: 'console\.log'
+        message: "No console.log in production"
+`,
+		);
+	});
+
+	afterAll(() => {
+		try {
+			if (fs.existsSync(testDir)) {
+				fs.rmSync(testDir, { recursive: true, force: true });
+			}
+		} catch {
+			// Ignore cleanup errors
+		}
+	});
+
+	it("should load default config when no user config exists", async () => {
+		const module = await import("./architect.js");
+		const runner = module.default;
+
+		// Use a unique temp dir with no user config (will fall back to default)
+		const noUserConfigDir = path.join(process.env.TEMP || "/tmp", `no_arch_user_config_${Date.now()}`);
+		fs.mkdirSync(noUserConfigDir, { recursive: true });
+
+		// Create a very large file that should trigger default max_lines rule
+		const tmpFile = path.join(noUserConfigDir, `large_${Date.now()}.ts`);
+		fs.writeFileSync(tmpFile, Array(5000).fill("// line").join("\n"));
+
+		try {
+			const result = await runner.run(
+				createMockContext(tmpFile, "jsts", noUserConfigDir),
+			);
+			// Should use default config and find violations
+			expect(result.status).toBe("succeeded");
+			// Should have size violation from default config
+			expect(result.diagnostics.some((d) => d.message.includes("line limit"))).toBe(true);
+		} finally {
+			try {
+				if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile);
+				if (fs.existsSync(noUserConfigDir)) fs.rmdirSync(noUserConfigDir);
+			} catch {}
+		}
+	});
+
+	it("should detect file size violations", async () => {
+		const module = await import("./architect.js");
+		const runner = module.default;
+
+		const tmpFile = path.join(testDir, `large_file_${Date.now()}.ts`);
+		// Create file with 100 lines (exceeds 50 line limit)
+		fs.writeFileSync(tmpFile, Array(100).fill("// line").join("\n"));
+
+		try {
+			const result = await runner.run(createMockContext(tmpFile, "jsts", testDir));
+			expect(result.status).toBe("succeeded");
+			expect(result.diagnostics.length).toBeGreaterThan(0);
+			expect(result.diagnostics.some((d) => d.message.includes("50 line limit"))).toBe(
+				true,
+			);
+		} finally {
+			try {
+				if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile);
+			} catch {}
+		}
+	});
+
+	it("should detect pattern violations", async () => {
+		const module = await import("./architect.js");
+		const runner = module.default;
+
+		const tmpFile = path.join(testDir, `bad_patterns_${Date.now()}.ts`);
+		fs.writeFileSync(
+			tmpFile,
+			`const x = hardcoded_secret_12345;
+console.log(x);
+`,
+		);
+
+		try {
+			const result = await runner.run(createMockContext(tmpFile, "jsts", testDir));
+			expect(result.status).toBe("succeeded");
+			expect(result.diagnostics.length).toBeGreaterThanOrEqual(2);
+			expect(
+				result.diagnostics.some((d) => d.message.includes("hardcoded")),
+			).toBe(true);
+			expect(
+				result.diagnostics.some((d) => d.message.includes("console.log")),
+			).toBe(true);
+		} finally {
+			try {
+				if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile);
+			} catch {}
+		}
+	});
+
+	it("should return no diagnostics for clean files", async () => {
+		const module = await import("./architect.js");
+		const runner = module.default;
+
+		const tmpFile = path.join(testDir, `clean_${Date.now()}.ts`);
+		// Small file (20 lines) with no violations
+		fs.writeFileSync(tmpFile, Array(20).fill("// clean code").join("\n"));
+
+		try {
+			const result = await runner.run(createMockContext(tmpFile, "jsts", testDir));
+			expect(result.status).toBe("succeeded");
+			expect(result.diagnostics.length).toBe(0);
+		} finally {
+			try {
+				if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile);
+			} catch {}
+		}
+	});
+
+	it("should skip test files", async () => {
+		const module = await import("./architect.js");
+		const runner = module.default;
+
+		// The runner should have skipTestFiles: true
+		expect(runner.skipTestFiles).toBe(true);
+	});
+});

package/clients/dispatch/runners/architect.ts

@@ -23,6 +23,7 @@ const architectRunner: RunnerDefinition = {
 	appliesTo: ["jsts", "python", "go", "rust", "cxx", "shell", "cmake"],
 	priority: 40,
 	enabledByDefault: true,
+	skipTestFiles: true, // Skip test files - rules can be noisy there
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		const relPath = ctx.filePath.replace(ctx.cwd, "").replace(/\\/g, "/");
@@ -44,15 +45,29 @@ const architectRunner: RunnerDefinition = {
 		// Check for violations
 		const violations = architectClient.checkFile(relPath, content);
 		for (const v of violations) {
+			// Build message with inline fix guidance
+			let message = v.message;
+			let fixSuggestion: string | undefined = v.fix;
+			
+			if (v.fix) {
+				const fixPreview = v.fix.length > 60 ? `${v.fix.substring(0, 60)}...` : v.fix;
+				message += `\n💡 Suggested fix: ${fixPreview}`;
+			} else if (v.note) {
+				const notePreview = v.note.length > 80 ? `${v.note.substring(0, 80)}...` : v.note;
+				message += `\n📝 ${notePreview}`;
+			}
+			
 			diagnostics.push({
 				id: `architect-${v.line || 0}-${v.pattern}`,
-				message: v.message,
+				message,
 				filePath: ctx.filePath,
 				line: v.line,
-				severity: "error",
-				semantic: "blocking",
+				severity: "warning",
+				semantic: "warning",
 				tool: "architect",
 				rule: v.pattern,
+				fixable: !!v.fix,
+				fixSuggestion,
 			});
 		}
 
@@ -64,8 +79,8 @@ const architectRunner: RunnerDefinition = {
 				id: `architect-size-${lineCount}`,
 				message: sizeViolation.message,
 				filePath: ctx.filePath,
-				severity: "error",
-				semantic: "blocking",
+				severity: "warning",
+				semantic: "warning",
 				tool: "architect",
 				rule: "file-size-limit",
 				fixSuggestion: "Split into smaller modules",
@@ -77,9 +92,9 @@ const architectRunner: RunnerDefinition = {
 		}
 
 		return {
-			status: "failed",
+			status: "succeeded", // Warnings don't fail the run
 			diagnostics,
-			semantic: "blocking",
+			semantic: "warning",
 		};
 	},
 };

package/clients/dispatch/runners/ast-grep-napi.js

@@ -0,0 +1,462 @@
+/**
+ * ast-grep NAPI runner for dispatch system
+ *
+ * Uses @ast-grep/napi for programmatic parsing instead of CLI.
+ * Handles TypeScript/JavaScript/CSS/HTML files with YAML rule support.
+ *
+ * Replaces CLI-based runners for faster performance (100x speedup).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Lazy load the napi package
+let sg;
+async function loadSg() {
+    if (sg)
+        return sg;
+    try {
+        sg = await import("@ast-grep/napi");
+        return sg;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Supported extensions for NAPI
+const SUPPORTED_EXTS = [".ts", ".tsx", ".js", ".jsx", ".css", ".html", ".htm"];
+function canHandle(filePath) {
+    return SUPPORTED_EXTS.includes(path.extname(filePath).toLowerCase());
+}
+function getLang(filePath, sgModule) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case ".ts": return sgModule.Lang.TypeScript;
+        case ".tsx": return sgModule.Lang.Tsx;
+        case ".js":
+        case ".jsx": return sgModule.Lang.JavaScript;
+        case ".css": return sgModule.Lang.Css;
+        case ".html":
+        case ".htm": return sgModule.Lang.Html;
+        default: return undefined;
+    }
+}
+function loadYamlRules(ruleDir) {
+    const rules = [];
+    if (!fs.existsSync(ruleDir))
+        return rules;
+    const files = fs.readdirSync(ruleDir).filter(f => f.endsWith(".yml"));
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(path.join(ruleDir, file), "utf-8");
+            // Split by --- to handle multiple YAML documents in one file
+            const documents = content.split(/^---$/m).filter(d => d.trim());
+            for (const doc of documents) {
+                const rule = parseSimpleYaml(doc.trim());
+                if (rule && rule.id) {
+                    rules.push(rule);
+                }
+            }
+        }
+        catch {
+            // Skip invalid files
+        }
+    }
+    return rules;
+}
+function parseSimpleYaml(content) {
+    const lines = content.split("\n");
+    const rule = { id: "", metadata: {} };
+    let currentSection = "root";
+    let sectionStack = [];
+    let multilineBuffer = [];
+    let multilineKey = "";
+    function getCurrentObj() {
+        if (sectionStack.length === 0)
+            return rule;
+        return sectionStack[sectionStack.length - 1].obj;
+    }
+    function getIndent(line) {
+        let count = 0;
+        for (const char of line) {
+            if (char === " ")
+                count++;
+            else if (char === "\t")
+                count += 2;
+            else
+                break;
+        }
+        return count;
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        if (trimmed === "---")
+            continue;
+        const indent = getIndent(line);
+        // Pop stack if indent decreased
+        while (sectionStack.length > 0 && indent <= sectionStack[sectionStack.length - 1].indent) {
+            sectionStack.pop();
+        }
+        // Check for multiline continuation
+        if (line.startsWith(" ") && !trimmed.includes(":") && multilineKey) {
+            multilineBuffer.push(trimmed);
+            continue;
+        }
+        // Flush multiline buffer
+        if (multilineKey && multilineBuffer.length > 0) {
+            const value = multilineBuffer.join("\n");
+            const current = getCurrentObj();
+            if (multilineKey === "pattern" && current) {
+                current.pattern = value;
+            }
+            multilineKey = "";
+            multilineBuffer = [];
+        }
+        const colonIndex = trimmed.indexOf(":");
+        const key = colonIndex > 0 ? trimmed.substring(0, colonIndex).trim() : trimmed;
+        const value = colonIndex > 0 ? trimmed.substring(colonIndex + 1).trim() : "";
+        if (key === "id") {
+            rule.id = value.replace(/^["']|["']$/g, "");
+        }
+        else if (key === "language") {
+            rule.language = value;
+        }
+        else if (key === "severity") {
+            rule.severity = value;
+        }
+        else if (key === "message") {
+            if (value === "|") {
+                multilineKey = "message";
+            }
+            else {
+                rule.message = value.replace(/^["']|["']$/g, "");
+            }
+        }
+        else if (key === "metadata") {
+            currentSection = "metadata";
+            const newObj = {};
+            rule.metadata = newObj;
+            sectionStack.push({ name: "metadata", indent, obj: newObj });
+        }
+        else if (key === "rule") {
+            currentSection = "rule";
+            const newObj = {};
+            rule.rule = newObj;
+            sectionStack.push({ name: "rule", indent, obj: newObj });
+        }
+        else if (sectionStack.length > 0) {
+            const current = getCurrentObj();
+            const currentSectionName = sectionStack[sectionStack.length - 1]?.name;
+            if (key === "weight" && currentSectionName === "metadata") {
+                if (!rule.metadata)
+                    rule.metadata = {};
+                rule.metadata.weight = parseInt(value, 10) || 3;
+            }
+            else if (key === "category" && currentSectionName === "metadata") {
+                if (!rule.metadata)
+                    rule.metadata = {};
+                rule.metadata.category = value.replace(/^["']|["']$/g, "");
+            }
+            else if (key === "pattern") {
+                if (value === "|") {
+                    multilineKey = "pattern";
+                }
+                else {
+                    // Strip all surrounding quotes (handle nested quotes from YAML)
+                    let stripped = value;
+                    while (stripped.startsWith('"') && stripped.endsWith('"') && stripped.length > 1) {
+                        stripped = stripped.slice(1, -1);
+                    }
+                    while (stripped.startsWith("'") && stripped.endsWith("'") && stripped.length > 1) {
+                        stripped = stripped.slice(1, -1);
+                    }
+                    current.pattern = stripped;
+                }
+            }
+            else if (key === "kind") {
+                current.kind = value;
+            }
+            else if (key === "regex") {
+                // Strip all surrounding quotes
+                let stripped = value;
+                while (stripped.startsWith('"') && stripped.endsWith('"') && stripped.length > 1) {
+                    stripped = stripped.slice(1, -1);
+                }
+                while (stripped.startsWith("'") && stripped.endsWith("'") && stripped.length > 1) {
+                    stripped = stripped.slice(1, -1);
+                }
+                current.regex = stripped;
+            }
+            else if (key === "has" || key === "not") {
+                const newObj = {};
+                current[key] = newObj;
+                sectionStack.push({ name: key, indent, obj: newObj });
+            }
+            else if (key === "any" || key === "all") {
+                if (!current[key])
+                    current[key] = [];
+                // Check if next lines with more indent are list items
+                let j = i + 1;
+                while (j < lines.length) {
+                    const nextLine = lines[j];
+                    const nextTrimmed = nextLine.trim();
+                    if (!nextTrimmed || nextTrimmed.startsWith("#")) {
+                        j++;
+                        continue;
+                    }
+                    const nextIndent = getIndent(nextLine);
+                    if (nextIndent <= indent)
+                        break;
+                    if (nextTrimmed.startsWith("- ")) {
+                        // New list item
+                        const itemObj = {};
+                        current[key].push(itemObj);
+                        sectionStack.push({ name: key, indent: nextIndent, obj: itemObj });
+                        // Parse the item content after "- "
+                        const itemContent = nextTrimmed.substring(2);
+                        if (itemContent.includes(":")) {
+                            const [itemKey, itemVal] = itemContent.split(":", 2);
+                            if (itemKey.trim() === "pattern") {
+                                itemObj.pattern = itemVal.trim().replace(/^["']|["']$/g, "");
+                            }
+                            else if (itemKey.trim() === "kind") {
+                                itemObj.kind = itemVal.trim();
+                            }
+                        }
+                        else if (itemContent) {
+                            // Assume it's a pattern
+                            itemObj.pattern = itemContent.replace(/^["']|["']$/g, "");
+                        }
+                    }
+                    j++;
+                }
+            }
+        }
+    }
+    // Flush remaining multiline buffer
+    if (multilineKey && multilineBuffer.length > 0) {
+        const value = multilineBuffer.join("\n");
+        const current = getCurrentObj();
+        if (multilineKey === "pattern" && current) {
+            current.pattern = value;
+        }
+        else if (multilineKey === "message") {
+            rule.message = value;
+        }
+    }
+    return rule.id ? rule : null;
+}
+/**
+ * Check if a rule uses structured conditions (has/any/all/not/regex)
+ */
+function isStructuredRule(rule) {
+    if (!rule.rule)
+        return false;
+    return !!(rule.rule.has || rule.rule.any || rule.rule.all || rule.rule.not || rule.rule.regex);
+}
+/**
+ * Execute a structured rule using manual AST traversal
+ */
+function executeStructuredRule(rootNode, condition, matches = []) {
+    // Start with finding nodes by kind or pattern
+    let candidates = [];
+    if (condition.pattern) {
+        // Use pattern matching via findAll
+        try {
+            candidates = rootNode.findAll(condition.pattern);
+        }
+        catch {
+            return matches;
+        }
+    }
+    else if (condition.kind) {
+        // Manual traversal for kind matching
+        function findByKind(node, kind) {
+            const results = [];
+            if (node.kind() === kind) {
+                results.push(node);
+            }
+            for (const child of node.children()) {
+                results.push(...findByKind(child, kind));
+            }
+            return results;
+        }
+        candidates = findByKind(rootNode, condition.kind);
+    }
+    else {
+        // No kind or pattern, search all nodes
+        function getAllNodes(node) {
+            const results = [node];
+            for (const child of node.children()) {
+                results.push(...getAllNodes(child));
+            }
+            return results;
+        }
+        candidates = getAllNodes(rootNode);
+    }
+    // Filter candidates by conditions
+    for (const candidate of candidates) {
+        let matchesCondition = true;
+        // Check 'has' condition
+        if (condition.has && matchesCondition) {
+            const subMatches = executeStructuredRule(candidate, condition.has, []);
+            if (subMatches.length === 0)
+                matchesCondition = false;
+        }
+        // Check 'not' condition
+        if (condition.not && matchesCondition) {
+            const subMatches = executeStructuredRule(candidate, condition.not, []);
+            if (subMatches.length > 0)
+                matchesCondition = false;
+        }
+        // Check 'any' condition (at least one must match)
+        if (condition.any && matchesCondition) {
+            let anyMatches = false;
+            for (const subCondition of condition.any) {
+                const subMatches = executeStructuredRule(candidate, subCondition, []);
+                if (subMatches.length > 0) {
+                    anyMatches = true;
+                    break;
+                }
+            }
+            if (!anyMatches)
+                matchesCondition = false;
+        }
+        // Check 'all' condition (all must match)
+        if (condition.all && matchesCondition) {
+            for (const subCondition of condition.all) {
+                const subMatches = executeStructuredRule(candidate, subCondition, []);
+                if (subMatches.length === 0) {
+                    matchesCondition = false;
+                    break;
+                }
+            }
+        }
+        // Check 'regex' condition
+        if (condition.regex && matchesCondition) {
+            const text = candidate.text();
+            const regex = new RegExp(condition.regex);
+            if (!regex.test(text))
+                matchesCondition = false;
+        }
+        if (matchesCondition) {
+            matches.push(candidate);
+        }
+    }
+    return matches;
+}
+const astGrepNapiRunner = {
+    id: "ast-grep-napi",
+    appliesTo: ["jsts"], // TypeScript/JavaScript only
+    priority: 15, // Run early (after type checkers, before other linters)
+    enabledByDefault: true,
+    skipTestFiles: true,
+    async run(ctx) {
+        const startTime = Date.now();
+        if (!canHandle(ctx.filePath)) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        const sgModule = await loadSg();
+        if (!sgModule) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        if (!fs.existsSync(ctx.filePath)) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        const lang = getLang(ctx.filePath, sgModule);
+        if (!lang) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        const content = fs.readFileSync(ctx.filePath, "utf-8");
+        let root;
+        try {
+            root = sgModule.parse(lang, content);
+        }
+        catch {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        const diagnostics = [];
+        const rootNode = root.root();
+        // Load rules from ts-slop-rules only (complementary to ast-grep CLI)
+        const ruleDirs = [
+            path.join(process.cwd(), "rules/ts-slop-rules/rules"),
+        ];
+        for (const ruleDir of ruleDirs) {
+            const rules = loadYamlRules(ruleDir);
+            for (const rule of rules) {
+                // Skip rules for different languages (case-insensitive)
+                const lang = rule.language?.toLowerCase();
+                if (lang && lang !== "typescript" && lang !== "javascript") {
+                    continue;
+                }
+                try {
+                    let matches = [];
+                    if (isStructuredRule(rule) && rule.rule) {
+                        // Use structured rule execution
+                        matches = executeStructuredRule(rootNode, rule.rule, []);
+                    }
+                    else if (rule.rule?.pattern || rule.rule?.kind) {
+                        // Use simple pattern matching
+                        const pattern = rule.rule.pattern || rule.rule.kind;
+                        if (pattern) {
+                            try {
+                                matches = rootNode.findAll(pattern);
+                            }
+                            catch {
+                                // Pattern failed, try manual traversal for kind
+                                if (rule.rule.kind) {
+                                    function findByKind(node, kind) {
+                                        const results = [];
+                                        if (node.kind() === kind)
+                                            results.push(node);
+                                        for (const child of node.children()) {
+                                            results.push(...findByKind(child, kind));
+                                        }
+                                        return results;
+                                    }
+                                    matches = findByKind(rootNode, rule.rule.kind);
+                                }
+                            }
+                        }
+                    }
+                    for (const match of matches) {
+                        const range = match.range();
+                        const weight = rule.metadata?.weight || 3;
+                        const severity = weight >= 4 ? "error" : "warning";
+                        diagnostics.push({
+                            id: `ast-grep-napi-${range.start.line}-${rule.id}`,
+                            message: `[${rule.metadata?.category || "slop"}] ${rule.message || rule.id}`,
+                            filePath: ctx.filePath,
+                            line: range.start.line + 1,
+                            column: range.start.column + 1,
+                            severity,
+                            semantic: severity === "error" ? "blocking" : "warning",
+                            tool: "ast-grep-napi",
+                            rule: rule.id,
+                            fixable: false,
+                        });
+                    }
+                }
+                catch {
+                    // Rule failed, skip
+                }
+            }
+        }
+        const elapsed = Date.now() - startTime;
+        if (diagnostics.length > 0 || elapsed > 50) {
+            console.error(`[ast-grep-napi] ${ctx.filePath}: ${elapsed}ms, ${diagnostics.length} issues`);
+        }
+        if (diagnostics.length === 0) {
+            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        }
+        return {
+            status: "failed",
+            diagnostics,
+            semantic: "warning",
+        };
+    },
+};
+export default astGrepNapiRunner;