pi-lens 3.6.2 → 3.6.4

package/clients/dispatch/integration.js

@@ -1,108 +0,0 @@
-/**
- * Dispatch integration helpers
- *
- * Provides utilities for integrating the declarative dispatch system
- * with the existing index.ts tool_result handler.
- */
-import { detectFileKind } from "../file-kinds.js";
-import { clearLatencyReports, createBaselineStore, createDispatchContext, formatLatencyReport, getLatencyReports, } from "./dispatcher.js";
-// Re-export latency tracking types and functions
-export { clearLatencyReports, formatLatencyReport, getLatencyReports };
-// Import runners to register them
-import "./runners/index.js";
-// --- Persistent Baseline Store ---
-// Survives across dispatchLint calls within a session.
-// Without this, delta mode is a no-op: every call creates a fresh empty
-// store, so baselines.get() always returns undefined and every issue
-// looks "new" every time.
-const sessionBaselines = createBaselineStore();
-/**
- * Reset baselines — call on session_start so a new session
- * starts with a clean slate.
- */
-export function resetDispatchBaselines() {
-    sessionBaselines.clear();
-}
-/**
- * Run linting for a file using the declarative dispatch system
- *
- * @param filePath - Path to the file to lint
- * @param cwd - Project root directory
- * @param pi - Pi agent API (for flags)
- * @returns Output string to display to user
- */
-export async function dispatchLint(filePath, cwd, pi) {
-    // By default, only run BLOCKING rules for fast feedback on file write
-    // Uses persistent sessionBaselines so delta mode actually filters
-    // pre-existing issues after the first write.
-    const ctx = createDispatchContext(filePath, cwd, pi, sessionBaselines, true);
-    // Import dispatchForFile dynamically to avoid circular deps
-    const { dispatchForFile } = await import("./dispatcher.js");
-    const { getRunnersForKind } = await import("./dispatcher.js");
-    const { TOOL_PLANS } = await import("./plan.js");
-    const kind = ctx.kind;
-    if (!kind)
-        return "";
-    const plan = TOOL_PLANS[kind];
-    if (!plan)
-        return "";
-    const result = await dispatchForFile(ctx, plan.groups);
-    return result.output;
-}
-/**
- * Run linting and return full result (including diagnostics)
- */
-export async function dispatchLintWithResult(filePath, cwd, pi) {
-    const ctx = createDispatchContext(filePath, cwd, pi, sessionBaselines, true);
-    const { dispatchForFile } = await import("./dispatcher.js");
-    const { getRunnersForKind } = await import("./dispatcher.js");
-    const { TOOL_PLANS } = await import("./plan.js");
-    const kind = ctx.kind;
-    if (!kind) {
-        return {
-            diagnostics: [],
-            blockers: [],
-            warnings: [],
-            fixed: [],
-            output: "",
-            hasBlockers: false,
-        };
-    }
-    const plan = TOOL_PLANS[kind];
-    if (!plan) {
-        return {
-            diagnostics: [],
-            blockers: [],
-            warnings: [],
-            fixed: [],
-            output: "",
-            hasBlockers: false,
-        };
-    }
-    return await dispatchForFile(ctx, plan.groups);
-}
-/**
- * Create a baseline store for delta mode tracking
- */
-export function createLintBaselines() {
-    return createBaselineStore();
-}
-/**
- * Check if a file should be processed by the dispatcher
- * based on the file kind
- */
-export function shouldDispatch(filePath) {
-    const kind = detectFileKind(filePath);
-    return kind !== undefined;
-}
-/**
- * Get list of available runners for a file
- */
-export async function getAvailableRunners(filePath) {
-    const kind = detectFileKind(filePath);
-    if (!kind)
-        return [];
-    const { getRunnersForKind } = await import("./dispatcher.js");
-    const runners = getRunnersForKind(kind);
-    return runners.map((r) => r.id);
-}

package/clients/dispatch/plan.js

@@ -1,183 +0,0 @@
-/**
- * Tool execution plan for pi-lens
- *
- * Defines which tools run for each file kind and in what order.
- * This is the declarative alternative to the if/else chains in index.ts.
- *
- * Modes:
- * - "all": Run all runners in the group
- * - "fallback": Run first available runner
- * - "first-success": Run until one succeeds
- */
-/**
- * Tool plans organized by purpose
- *
- * CORE PRINCIPLE: File write only runs BLOCKING tools
- * - Type checking (LSP) - blocking errors
- * - Security/correctness lint - blocking errors
- * - Auto-format/auto-fix handled by direct calls in index.ts (not here)
- *
- * Warning-only tools run on /lens-booboo command only
- */
-export const TOOL_PLANS = {
-    /**
-     * Linting tools for JS/TS files
-     */
-    jsts: {
-        name: "JavaScript/TypeScript Linting",
-        groups: [
-            // LSP type checking (unified for all languages) - priority 4, blocking errors
-            { mode: "all", runnerIds: ["lsp"], filterKinds: ["jsts"] },
-            // Tree-sitter native structural analysis (blocking rules: constructor-super, dangerouslySetInnerHTML, etc.)
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
-            // AST structural analysis (blocking: no-dupe-keys, no-hardcoded-secrets, jwt-no-verify, etc.)
-            // Only error-severity rules fire inline (blockingOnly=true). Warnings are booboo-only.
-            { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
-            // Type safety checks (has some blocking errors)
-            { mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
-            // Similarity detection — warns about duplicated/reusable code
-            { mode: "fallback", runnerIds: ["similarity"], filterKinds: ["jsts"] },
-            // Note: ast-grep CLI kept for ast_grep_search/ast_grep_replace tools only
-            // Note: biome, oxlint handled by direct auto-fix calls in index.ts (not in dispatch)
-            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
-        ],
-    },
-    /**
-     * Python linting tools
-     */
-    python: {
-        name: "Python Linting",
-        groups: [
-            // Pyright type checking (standard mode - no LSP flag needed)
-            // Provides Python type errors in standard pi mode
-            { mode: "all", runnerIds: ["pyright"], filterKinds: ["python"] },
-            // LSP type checking (unified) - when --lens-lsp enabled
-            { mode: "all", runnerIds: ["lsp"], filterKinds: ["python"] },
-            // Note: ruff handled by direct auto-fix calls in index.ts (not in dispatch)
-            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
-        ],
-    },
-    /**
-     * Go linting tools
-     */
-    go: {
-        name: "Go Linting",
-        groups: [
-            // LSP type checking (gopls)
-            { mode: "all", runnerIds: ["lsp"], filterKinds: ["go"] },
-            // Go vet for additional checks (warning only, but low cost)
-            { mode: "fallback", runnerIds: ["go-vet"], filterKinds: ["go"] },
-            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
-        ],
-    },
-    /**
-     * Rust linting tools
-     */
-    rust: {
-        name: "Rust Linting",
-        groups: [
-            // LSP type checking (rust-analyzer)
-            { mode: "all", runnerIds: ["lsp"], filterKinds: ["rust"] },
-            // Cargo clippy for additional checks
-            { mode: "fallback", runnerIds: ["rust-clippy"], filterKinds: ["rust"] },
-            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
-        ],
-    },
-    /**
-     * C/C++ linting tools
-     */
-    cxx: {
-        name: "C/C++ Linting",
-        groups: [
-        // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
-        ],
-    },
-    /**
-     * JSON/JSONC files
-     */
-    json: {
-        name: "JSON Processing",
-        groups: [
-        // Note: Biome handles JSON formatting via direct call in index.ts
-        // No additional linting needed for JSON
-        ],
-    },
-    /**
-     * Markdown files
-     */
-    markdown: {
-        name: "Markdown Processing",
-        groups: [
-            // Spellcheck for typos (warning only, but useful)
-            { mode: "fallback", runnerIds: ["spellcheck"] },
-        ],
-    },
-    /**
-     * Shell scripts
-     */
-    shell: {
-        name: "Shell Script Linting",
-        groups: [
-            // Shellcheck for bash/sh/zsh linting (has blocking errors for syntax)
-            { mode: "fallback", runnerIds: ["shellcheck"] },
-            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
-        ],
-    },
-    /**
-     * CMake files
-     */
-    cmake: {
-        name: "CMake Processing",
-        groups: [
-        // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
-        ],
-    },
-};
-/**
- * Get the tool plan for a specific file kind
- */
-export function getToolPlan(kind) {
-    return TOOL_PLANS[kind];
-}
-/**
- * Get all registered tool plans
- */
-export function getAllToolPlans() {
-    return TOOL_PLANS;
-}
-/**
- * Full lint plan for /lens-booboo command (includes warning-only tools)
- * This includes ALL runners for comprehensive analysis
- */
-export const FULL_LINT_PLANS = {
-    ...TOOL_PLANS,
-    // Override jsts to include warning-only tools
-    jsts: {
-        name: "JavaScript/TypeScript Full Lint",
-        groups: [
-            { mode: "all", runnerIds: ["lsp"], filterKinds: ["jsts"] },
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
-            { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
-            // Warning-only tools (for full lint, not file write)
-            {
-                mode: "fallback",
-                runnerIds: ["biome-lint", "oxlint"],
-                filterKinds: ["jsts"],
-            },
-            { mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
-            { mode: "fallback", runnerIds: ["similarity"], filterKinds: ["jsts"] },
-            { mode: "fallback", runnerIds: ["architect"], filterKinds: ["jsts"] },
-        ],
-    },
-    // Override python to include warning-only tools
-    python: {
-        name: "Python Full Lint",
-        groups: [
-            { mode: "all", runnerIds: ["lsp"], filterKinds: ["python"] },
-            // Warning-only tools
-            { mode: "fallback", runnerIds: ["ruff-lint"], filterKinds: ["python"] },
-            { mode: "fallback", runnerIds: ["python-slop"], filterKinds: ["python"] },
-            { mode: "fallback", runnerIds: ["architect"], filterKinds: ["python"] },
-        ],
-    },
-};

package/clients/dispatch/runners/architect.js

@@ -1,83 +0,0 @@
-/**
- * Architectural rules runner for dispatch system
- *
- * Checks for architectural violations:
- * - Absolute Windows/Unix paths
- * - Hardcoded localhost URLs
- * - Empty catch blocks
- * - Secrets in code
- * - File size limits
- */
-import { ArchitectClient } from "../../architect-client.js";
-import { readFileContent } from "./utils.js";
-const architectRunner = {
-    id: "architect",
-    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);
-        if (!content) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const architectClient = new ArchitectClient();
-        architectClient.loadConfig(ctx.cwd);
-        if (!architectClient.hasConfig()) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = [];
-        // 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,
-                filePath: ctx.filePath,
-                line: v.line,
-                severity: "warning",
-                semantic: "warning",
-                tool: "architect",
-                rule: v.pattern,
-                fixable: !!v.fix,
-                fixSuggestion,
-            });
-        }
-        // Check file size limit
-        const lineCount = content.split("\n").length;
-        const sizeViolation = architectClient.checkFileSize(relPath, lineCount);
-        if (sizeViolation) {
-            diagnostics.push({
-                id: `architect-size-${lineCount}`,
-                message: sizeViolation.message,
-                filePath: ctx.filePath,
-                severity: "warning",
-                semantic: "warning",
-                tool: "architect",
-                rule: "file-size-limit",
-                fixSuggestion: "Split into smaller modules",
-            });
-        }
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "succeeded", // Warnings don't fail the run
-            diagnostics,
-            semantic: "warning",
-        };
-    },
-};
-export default architectRunner;

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

@@ -1,138 +0,0 @@
-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);
-    });
-});

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

@@ -1,162 +0,0 @@
-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);
-	});
-});