pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/dispatcher.inline.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import { formatDiagnostic } from "./utils/format-utils.js";
+
+describe("formatDiagnostic inline output verification", () => {
+	it("should display complete architect messages (NOT truncated to 'No ')", () => {
+		// Simulate actual architect diagnostic
+		const diagnostic = {
+			id: "architect-1",
+			message:
+				"No absolute Windows paths — breaks CI and cross-platform builds.",
+			filePath: "/test.ts",
+			line: 5,
+			severity: "warning" as const,
+			semantic: "warning" as const,
+			tool: "architect",
+			rule: "no-absolute-windows-paths",
+		};
+
+		const output = formatDiagnostic(diagnostic);
+
+		console.log("\n=== Architect Message Output ===");
+		console.log(output);
+		console.log("=================================\n");
+
+		// Verify complete message is shown
+		expect(output).toBe(
+			"  L5: No absolute Windows paths — breaks CI and cross-platform builds.",
+		);
+	});
+
+	it("should display code fix messages inline correctly", () => {
+		// This is what I actually see from ts-lsp runner
+		const diagnostic = {
+			id: "ts-12-2345",
+			message:
+				"Property 'debug' is missing in type 'Config'\n💡 Quick fix: Add missing property 'debug'",
+			filePath: "/src/config.ts",
+			line: 12,
+			severity: "error" as const,
+			semantic: "blocking" as const,
+			tool: "ts-lsp",
+			rule: "TS2345",
+			fixable: true,
+			fixSuggestion: "Add missing property 'debug'",
+		};
+
+		const output = formatDiagnostic(diagnostic);
+
+		console.log("\n=== Code Fix Message Output ===");
+		console.log(output);
+		console.log("================================\n");
+
+		// Both lines should be properly indented
+		expect(output).toBe(
+			"  L12: Property 'debug' is missing in type 'Config'\n  💡 Quick fix: Add missing property 'debug'",
+		);
+	});
+
+	it("should prove architect 'No ' messages are complete (not noise)", () => {
+		// All the "No " messages from default-architect.yaml
+		const testMessages = [
+			"No absolute Windows paths — breaks CI and cross-platform builds.",
+			"No hardcoded localhost URLs — use environment variables or a config service.",
+			"No empty catch/except blocks. Swallowing errors makes debugging impossible — at least log the error.",
+			"No hardcoded secrets — use environment variables or a secrets manager.",
+			"No 'any' types — use 'unknown' or define a proper interface to maintain type safety.",
+		];
+
+		for (let i = 0; i < testMessages.length; i++) {
+			const diagnostic = {
+				id: `architect-${i}`,
+				message: testMessages[i],
+				filePath: "/test.ts",
+				line: i + 1,
+				severity: "warning" as const,
+				semantic: "warning" as const,
+				tool: "architect",
+				rule: "test",
+			};
+
+			const output = formatDiagnostic(diagnostic);
+
+			// Each message should be complete, NOT truncated to just "No "
+			expect(output.length).toBeGreaterThan(15); // More than "  L1: No "
+			expect(output).toContain("No ");
+			expect(output).toContain("—"); // Contains the em-dash explanation
+
+			// Verify it's not truncated
+			const messageAfterNo = output.split("No ")[1];
+			expect(messageAfterNo.length).toBeGreaterThan(5);
+		}
+	});
+});

package/clients/dispatch/dispatcher.js

@@ -14,6 +14,9 @@
  * - BaselineStore: Track pre-existing issues for delta mode
  */
 import { detectFileKind } from "../file-kinds.js";
+import { isTestFile } from "../file-utils.js";
+import { safeSpawn } from "../safe-spawn.js";
+import { formatDiagnostics } from "./utils/format-utils.js";
 // --- In-Memory Baseline Store ---
 export function createBaselineStore() {
     const baselines = new Map();
@@ -45,10 +48,10 @@ export function getRunnersForKind(kind, filePath) {
     if (!kind)
         return [];
     const runners = [];
-    const isTestFile = filePath ? isTest(filePath) : false;
+    const isTest = filePath ? isTestFile(filePath) : false;
     for (const runner of globalRegistry.values()) {
         // Skip runners that shouldn't run on test files
-        if (isTestFile && runner.skipTestFiles)
+        if (isTest && runner.skipTestFiles)
             continue;
         if (runner.appliesTo.includes(kind) || runner.appliesTo.length === 0) {
             runners.push(runner);
@@ -56,19 +59,15 @@ export function getRunnersForKind(kind, filePath) {
     }
     return runners.sort((a, b) => a.priority - b.priority);
 }
-function isTest(filePath) {
-    const normalized = filePath.replace(/\\/g, "/");
-    return (normalized.includes(".test.") ||
-        normalized.includes(".spec.") ||
-        normalized.includes("/test/") ||
-        normalized.includes("/tests/") ||
-        normalized.includes("__tests__/") ||
-        normalized.includes("test-utils") ||
-        normalized.startsWith("test-"));
-}
 export function listRunners() {
     return Array.from(globalRegistry.values());
 }
+/**
+ * Clear all registered runners. Used primarily for testing.
+ */
+export function clearRunnerRegistry() {
+    globalRegistry.clear();
+}
 // --- Tool Availability Cache ---
 const toolCache = new Map();
 function checkToolAvailability(command) {
@@ -76,11 +75,8 @@ function checkToolAvailability(command) {
         return toolCache.get(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,
         });
         const available = result.status === 0;
         toolCache.set(command, available);
@@ -121,41 +117,6 @@ function filterDelta(after, before, keyFn) {
     const newItems = after.filter((d) => !beforeSet.has(keyFn(d)));
     return { new: newItems, fixed };
 }
-// --- Output Formatting ---
-const EMOJI = {
-    blocking: "🔴",
-    warning: "🟡",
-    fixed: "✅",
-    info: "ℹ️",
-    silent: "📊",
-    none: "",
-};
-function formatDiagnostic(d) {
-    const line = d.line ? `L${d.line}: ` : "";
-    return `  ${line}${d.message}`;
-}
-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;
-}
 // --- Main Dispatch Function ---
 export async function dispatchForFile(ctx, groups) {
     const allDiagnostics = [];
@@ -195,8 +156,13 @@ export async function dispatchForFile(ctx, groups) {
                 ctx.baselines.set(ctx.filePath, [...allDiagnostics, ...diagnostics]);
             }
             allDiagnostics.push(...diagnostics);
-            // Check for blockers
-            if (semantic === "blocking" && diagnostics.length > 0) {
+            // Check for blockers - use result semantic (not group default) and check individual diagnostics
+            const resultSemantic = result.semantic ?? semantic;
+            if (resultSemantic === "blocking" && diagnostics.length > 0) {
+                stopped = true;
+            }
+            // Also check if any individual diagnostic is blocking
+            if (diagnostics.some((d) => d.semantic === "blocking")) {
                 stopped = true;
             }
         }

package/clients/dispatch/dispatcher.ts

@@ -16,7 +16,8 @@
 
 import type { FileKind } from "../file-kinds.js";
 import { detectFileKind } from "../file-kinds.js";
-
+import { isTestFile } from "../file-utils.js";
+import { safeSpawn } from "../safe-spawn.js";
 import type {
 	BaselineStore,
 	Diagnostic,
@@ -28,6 +29,7 @@ import type {
 	RunnerGroup,
 	RunnerResult,
 } from "./types.js";
+import { formatDiagnostics } from "./utils/format-utils.js";
 
 // --- In-Memory Baseline Store ---
 
@@ -69,11 +71,11 @@ export function getRunnersForKind(
 ): RunnerDefinition[] {
 	if (!kind) return [];
 	const runners: RunnerDefinition[] = [];
-	const isTestFile = filePath ? isTest(filePath) : false;
+	const isTest = filePath ? isTestFile(filePath) : false;
 
 	for (const runner of globalRegistry.values()) {
 		// Skip runners that shouldn't run on test files
-		if (isTestFile && runner.skipTestFiles) continue;
+		if (isTest && runner.skipTestFiles) continue;
 
 		if (runner.appliesTo.includes(kind) || runner.appliesTo.length === 0) {
 			runners.push(runner);
@@ -82,23 +84,17 @@ export function getRunnersForKind(
 	return runners.sort((a, b) => a.priority - b.priority);
 }
 
-function isTest(filePath: string): boolean {
-	const normalized = filePath.replace(/\\/g, "/");
-	return (
-		normalized.includes(".test.") ||
-		normalized.includes(".spec.") ||
-		normalized.includes("/test/") ||
-		normalized.includes("/tests/") ||
-		normalized.includes("__tests__/") ||
-		normalized.includes("test-utils") ||
-		normalized.startsWith("test-")
-	);
-}
-
 export function listRunners(): RunnerDefinition[] {
 	return Array.from(globalRegistry.values());
 }
 
+/**
+ * Clear all registered runners. Used primarily for testing.
+ */
+export function clearRunnerRegistry(): void {
+	globalRegistry.clear();
+}
+
 // --- Tool Availability Cache ---
 
 const toolCache = new Map<string, boolean>();
@@ -108,11 +104,8 @@ function checkToolAvailability(command: string): boolean {
 		return toolCache.get(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,
 		});
 		const available = result.status === 0;
 		toolCache.set(command, available);
@@ -171,51 +164,6 @@ function filterDelta<T extends { id: string }>(
 	return { new: newItems, fixed };
 }
 
-// --- Output Formatting ---
-
-const EMOJI: Record<string, string> = {
-	blocking: "🔴",
-	warning: "🟡",
-	fixed: "✅",
-	info: "ℹ️",
-	silent: "📊",
-	none: "",
-};
-
-function formatDiagnostic(d: Diagnostic): string {
-	const line = d.line ? `L${d.line}: ` : "";
-	return `  ${line}${d.message}`;
-}
-
-function formatDiagnostics(
-	diagnostics: Diagnostic[],
-	semantic: OutputSemantic,
-	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;
-}
-
 // --- Main Dispatch Function ---
 
 export async function dispatchForFile(
@@ -271,8 +219,13 @@ export async function dispatchForFile(
 
 			allDiagnostics.push(...diagnostics);
 
-			// Check for blockers
-			if (semantic === "blocking" && diagnostics.length > 0) {
+			// Check for blockers - use result semantic (not group default) and check individual diagnostics
+			const resultSemantic = result.semantic ?? semantic;
+			if (resultSemantic === "blocking" && diagnostics.length > 0) {
+				stopped = true;
+			}
+			// Also check if any individual diagnostic is blocking
+			if (diagnostics.some((d) => d.semantic === "blocking")) {
 				stopped = true;
 			}
 		}

package/clients/dispatch/plan.js

@@ -21,11 +21,13 @@ export const TOOL_PLANS = {
         groups: [
             // TypeScript LSP always runs first - blocks on errors
             { mode: "all", runnerIds: ["ts-lsp"], filterKinds: ["jsts"] },
-            // Then biome for fast linting
-            { mode: "fallback", runnerIds: ["biome-lint"] },
+            // Then biome or oxlint for fast linting (user preference)
+            { mode: "fallback", runnerIds: ["biome-lint", "oxlint"] },
+            // Fast structural analysis via NAPI (weight >= 4 is blocking)
+            { mode: "all", runnerIds: ["ast-grep-napi"] },
             // Type safety checks
             { mode: "fallback", runnerIds: ["type-safety"] },
-            // Structural analysis
+            // Comprehensive structural analysis via CLI (severity: error is blocking)
             { mode: "fallback", runnerIds: ["ast-grep"] },
             // Architectural rules
             { mode: "fallback", runnerIds: ["architect"] },
@@ -93,7 +95,8 @@ export const TOOL_PLANS = {
     markdown: {
         name: "Markdown Processing",
         groups: [
-        // No specific linting for markdown yet
+            // Spellcheck for typos
+            { mode: "fallback", runnerIds: ["spellcheck"] },
         ],
     },
     /**
@@ -102,6 +105,8 @@ export const TOOL_PLANS = {
     shell: {
         name: "Shell Script Linting",
         groups: [
+            // Shellcheck for bash/sh/zsh linting
+            { mode: "fallback", runnerIds: ["shellcheck"] },
             // Architectural rules
             { mode: "fallback", runnerIds: ["architect"] },
         ],

package/clients/dispatch/plan.ts

@@ -25,11 +25,13 @@ export const TOOL_PLANS: Record<string, ToolPlan> = {
 		groups: [
 			// TypeScript LSP always runs first - blocks on errors
 			{ mode: "all", runnerIds: ["ts-lsp"], filterKinds: ["jsts"] },
-			// Then biome for fast linting
-			{ mode: "fallback", runnerIds: ["biome-lint"] },
+			// Then biome or oxlint for fast linting (user preference)
+			{ mode: "fallback", runnerIds: ["biome-lint", "oxlint"] },
+			// Fast structural analysis via NAPI (weight >= 4 is blocking)
+			{ mode: "all", runnerIds: ["ast-grep-napi"] },
 			// Type safety checks
 			{ mode: "fallback", runnerIds: ["type-safety"] },
-			// Structural analysis
+			// Comprehensive structural analysis via CLI (severity: error is blocking)
 			{ mode: "fallback", runnerIds: ["ast-grep"] },
 			// Architectural rules
 			{ mode: "fallback", runnerIds: ["architect"] },
@@ -103,7 +105,8 @@ export const TOOL_PLANS: Record<string, ToolPlan> = {
 	markdown: {
 		name: "Markdown Processing",
 		groups: [
-			// No specific linting for markdown yet
+			// Spellcheck for typos
+			{ mode: "fallback", runnerIds: ["spellcheck"] },
 		],
 	},
 
@@ -113,6 +116,8 @@ export const TOOL_PLANS: Record<string, ToolPlan> = {
 	shell: {
 		name: "Shell Script Linting",
 		groups: [
+			// Shellcheck for bash/sh/zsh linting
+			{ mode: "fallback", runnerIds: ["shellcheck"] },
 			// Architectural rules
 			{ mode: "fallback", runnerIds: ["architect"] },
 		],

package/clients/dispatch/runners/architect.js

@@ -15,6 +15,7 @@ const architectRunner = {
     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) {
         const relPath = ctx.filePath.replace(ctx.cwd, "").replace(/\\/g, "/");
         const content = readFileContent(ctx.filePath);
@@ -30,15 +31,28 @@ const architectRunner = {
         // 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 = 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,
             });
         }
         // Check file size limit
@@ -49,8 +63,8 @@ const architectRunner = {
                 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",
@@ -60,9 +74,9 @@ const architectRunner = {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
         return {
-            status: "failed",
+            status: "succeeded", // Warnings don't fail the run
             diagnostics,
-            semantic: "blocking",
+            semantic: "warning",
         };
     },
 };

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

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, expect, it, beforeAll, afterAll } from "vitest";
+function createMockContext(filePath, kind = "jsts", cwd) {
+    return {
+        filePath,
+        cwd: cwd || process.cwd(),
+        kind,
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => undefined, set: () => { }, clear: () => { } },
+        pi: { getFlag: () => false },
+        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);
+    });
+});