pi-lens 3.6.3 → 3.6.4

package/clients/dispatch/runners/utils/diagnostic-parsers.js

@@ -1,134 +0,0 @@
-/**
- * Shared diagnostic output parsers for pi-lens runners
- *
- * Common patterns for parsing tool output into standardized diagnostics.
- * Supports the common `file:line:col: message` format used by most linters.
- */
-/**
- * Create a parser for line-based tool output.
- * Common format: file:line:col: message (with variations)
- */
-export function createLineParser(config) {
-    return (raw, filePath) => {
-        const diagnostics = [];
-        // Optionally strip ANSI codes (for tools that output colored text)
-        const clean = config.stripAnsi !== false
-            ? raw.replace(/\x1b\[[0-9;]*m/g, "")
-            : raw;
-        const lines = clean.split("\n").filter((l) => l.trim());
-        for (const line of lines) {
-            const match = line.match(config.regex);
-            if (!match)
-                continue;
-            const lineNum = parseInt(match[2], 10);
-            const colNum = parseInt(match[3], 10);
-            const severity = config.getSeverity
-                ? config.getSeverity(line, match)
-                : "warning";
-            const fixable = typeof config.fixable === "function"
-                ? config.fixable(match)
-                : config.fixable ?? false;
-            diagnostics.push({
-                id: config.generateId(match),
-                message: config.extractMessage(match),
-                filePath,
-                line: lineNum,
-                column: colNum,
-                severity,
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool: config.tool,
-                rule: config.extractRule?.(match),
-                fixable,
-            });
-        }
-        return diagnostics;
-    };
-}
-// =============================================================================
-// PRE-BUILT PARSERS FOR COMMON TOOLS
-// =============================================================================
-/**
- * Parse Ruff output: file:line:col: CODE message
- */
-export const parseRuffOutput = createLineParser({
-    tool: "ruff",
-    regex: /^(.+?):(\d+):(\d+):\s*(\w+)\s*(.+)/,
-    extractMessage: (m) => `${m[4]}: ${m[5]}`, // CODE: message
-    extractRule: (m) => m[4],
-    generateId: (m) => `ruff-${m[4]}`,
-    fixable: true, // Ruff can fix most issues
-});
-/**
- * Parse Go vet output: file:line:col: message
- */
-export const parseGoVetOutput = createLineParser({
-    tool: "go-vet",
-    regex: /^(.+?):(\d+):(\d+):\s*(.+)/,
-    extractMessage: (m) => m[4],
-    generateId: (m) => `go-vet-${m[2]}`,
-});
-/**
- * Parse Biome output: file:line:col message (category)
- * With autofix support for fix suggestions
- */
-export function createBiomeParser(autofix = false) {
-    return createLineParser({
-        tool: "biome",
-        regex: /^(.+?):(\d+):(\d+)\s+(.+?)\s*\((.+?)\)/,
-        extractMessage: (m) => `${m[5]}: ${m[4]}`, // category: message
-        extractRule: (m) => m[5],
-        generateId: (m) => `biome-${m[2]}-${m[5]}`,
-        getSeverity: (line) => (line.includes("error") ? "error" : "warning"),
-        fixable: true,
-    });
-}
-// Backward-compatible default biome parser
-export const parseBiomeOutput = createBiomeParser(false);
-// =============================================================================
-// GENERIC PARSER FACTORY
-// =============================================================================
-/**
- * Create a simple parser for tools using standard file:line:col format.
- * Format variations: :line:col:, line:col, (line,col), etc.
- */
-export function createSimpleParser(tool, options = {}) {
-    const sep = options.separator ?? ":";
-    const severity = options.severity ?? "warning";
-    const fixable = options.fixable ?? false;
-    // Build regex based on separator type
-    const escapedSep = sep === " " ? "\\s+" : escapeRegExp(sep);
-    const regex = options.includesFileName
-        ? new RegExp(`^(.+?)${escapedSep}(\\d+)${escapedSep}(\\d+)${escapedSep}(.+)`)
-        : new RegExp(`^(\\d+)${escapedSep}(\\d+)${escapedSep}(.+)`);
-    return (raw, filePath) => {
-        const diagnostics = [];
-        const lines = raw.split("\n").filter((l) => l.trim());
-        for (const line of lines) {
-            const match = line.match(regex);
-            if (!match)
-                continue;
-            const lineNum = options.includesFileName
-                ? parseInt(match[2], 10)
-                : parseInt(match[1], 10);
-            const colNum = options.includesFileName
-                ? parseInt(match[3], 10)
-                : parseInt(match[2], 10);
-            const message = options.includesFileName ? match[4] : match[3];
-            diagnostics.push({
-                id: `${tool}-${lineNum}`,
-                message: message.trim(),
-                filePath,
-                line: lineNum,
-                column: colNum,
-                severity,
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool,
-                fixable,
-            });
-        }
-        return diagnostics;
-    };
-}
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/clients/dispatch/runners/utils/runner-helpers.js

@@ -1,115 +0,0 @@
-/**
- * Shared runner utilities for pi-lens dispatch system
- *
- * Extracted common patterns from multiple runners to reduce duplication:
- * - Venv-aware command finders
- * - Availability checkers with caching
- * - Config file finders
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { safeSpawn } from "../../../safe-spawn.js";
-/**
- * Find a command in venv first, then fall back to global.
- * Checks common venv locations (.venv, venv) before trying global.
- */
-export function createVenvFinder(command, windowsExt = "", quoteWindows = false) {
-    return (cwd) => {
-        const venvPaths = [
-            `.venv/bin/${command}`,
-            `venv/bin/${command}`,
-            `.venv/Scripts/${command}${windowsExt}`,
-            `venv/Scripts/${command}${windowsExt}`,
-        ];
-        for (const venvPath of venvPaths) {
-            const fullPath = path.join(cwd, venvPath);
-            if (fs.existsSync(fullPath)) {
-                return quoteWindows && windowsExt
-                    ? `"${fullPath}"`
-                    : fullPath;
-            }
-        }
-        // Fall back to global
-        return command;
-    };
-}
-/**
- * Create a cached availability checker for a command.
- * The checker will look for the command in venv first, then global.
- */
-export function createAvailabilityChecker(command, windowsExt = "") {
-    const cache = {
-        available: null,
-        command: null,
-    };
-    const findCommand = createVenvFinder(command, windowsExt, true);
-    function isAvailable(cwd) {
-        if (cache.available !== null)
-            return cache.available;
-        const cmd = findCommand(cwd || process.cwd());
-        const result = safeSpawn(cmd, ["--version"], {
-            timeout: 5000,
-        });
-        cache.available = !result.error && result.status === 0;
-        if (cache.available) {
-            cache.command = cmd;
-        }
-        return cache.available;
-    }
-    function getCommand() {
-        return cache.command;
-    }
-    return { isAvailable, getCommand };
-}
-// =============================================================================
-// CONFIG FILE FINDER FACTORY
-// =============================================================================
-/**
- * Create a config file finder for rule directories.
- * Common pattern used by slop runners and similar tools.
- */
-export function createConfigFinder(ruleDirName) {
-    return (cwd) => {
-        // Check for local config first
-        const localPath = path.join(cwd, "rules", ruleDirName, ".sgconfig.yml");
-        if (fs.existsSync(localPath)) {
-            return localPath;
-        }
-        // Fall back to extension rules
-        const extensionPaths = [
-            `rules/${ruleDirName}/.sgconfig.yml`,
-            `../rules/${ruleDirName}/.sgconfig.yml`,
-        ];
-        for (const candidate of extensionPaths) {
-            const fullPath = path.resolve(cwd, candidate);
-            if (fs.existsSync(fullPath)) {
-                return fullPath;
-            }
-        }
-        return undefined;
-    };
-}
-// =============================================================================
-// SHARED AST-GREP AVAILABILITY
-// =============================================================================
-// Shared sg availability cache across all slop runners
-let sgAvailable = null;
-/**
- * Check if ast-grep CLI is available (shared cache)
- */
-export function isSgAvailable() {
-    if (sgAvailable !== null)
-        return sgAvailable;
-    const check = safeSpawn("npx", ["sg", "--version"], {
-        timeout: 5000,
-    });
-    sgAvailable = !check.error && check.status === 0;
-    return sgAvailable;
-}
-// =============================================================================
-// PRE-BUILT CHECKERS FOR COMMON TOOLS
-// =============================================================================
-export const pyright = createAvailabilityChecker("pyright", ".exe");
-export const ruff = createAvailabilityChecker("ruff", ".exe");
-export const biome = createAvailabilityChecker("biome");
-export const sg = { isAvailable: isSgAvailable, getCommand: () => "npx" };

package/clients/dispatch/runners/utils.js

@@ -1,51 +0,0 @@
-/**
- * Shared utilities for runners
- */
-import * as fs from "node:fs";
-import { safeSpawn } from "../../safe-spawn.js";
-/**
- * Read file content, returning undefined if it can't be read
- */
-export function readFileContent(filePath) {
-    try {
-        return fs.readFileSync(filePath, "utf-8");
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Check if a command is available
- */
-export function isCommandAvailable(command) {
-    try {
-        const result = safeSpawn(command, ["--version"], {
-            timeout: 5000,
-        });
-        return result.status === 0;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Parse common tool output line into a diagnostic
- * Format: file:line:col message (category)
- */
-export function parseToolLine(line, toolName, filePath) {
-    const match = line.match(/^(.+?):(\d+):(\d+)\s+(.+?)\s*\((.+?)\)/);
-    if (!match)
-        return null;
-    return {
-        id: `${toolName}-${match[2]}-${match[5]}`,
-        message: `${match[5]}: ${match[4]}`,
-        filePath,
-        line: parseInt(match[2], 10),
-        column: parseInt(match[3], 10),
-        severity: line.includes("error") ? "error" : "warning",
-        semantic: "warning",
-        tool: toolName,
-        rule: match[5],
-        fixable: false,
-    };
-}

package/clients/dispatch/runners/yaml-rule-parser.js

@@ -1,360 +0,0 @@
-/**
- * YAML Rule Parser for ast-grep
- *
- * Parses simplified YAML rule files for structural code analysis.
- * Supports pattern matching, kind matching, and structured conditions
- * (has/any/all/not/regex).
- *
- * Features:
- * - Caching with mtime-based invalidation
- * - Severity filtering (error-only for blocking mode)
- * - Complexity scoring for performance optimization
- * - Overly broad pattern detection
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-// --- Constants ---
-/** Overly broad patterns that match everything (cause false positive explosions) */
-export const OVERLY_BROAD_PATTERNS = [
-    "$NAME",
-    "$FIELD",
-    "$_",
-    "$X",
-    "$VAR",
-    "$EXPR",
-];
-/** Maximum complexity score for rules in blockingOnly mode */
-export const MAX_BLOCKING_RULE_COMPLEXITY = 8;
-// --- Caches ---
-const rulesCache = new Map();
-const blockingRulesCache = new Map();
-// --- Public API ---
-export function clearRulesCache() {
-    rulesCache.clear();
-    blockingRulesCache.clear();
-}
-export function loadYamlRules(ruleDir, severityFilter) {
-    return getCachedRules(ruleDir, severityFilter);
-}
-export function loadYamlRulesUncached(ruleDir, severityFilter) {
-    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");
-            const documents = content.split(/^---$/m).filter((d) => d.trim());
-            for (const doc of documents) {
-                const rule = parseSimpleYaml(doc.trim());
-                if (rule?.id) {
-                    if (severityFilter && rule.severity !== severityFilter) {
-                        continue;
-                    }
-                    rules.push(rule);
-                }
-            }
-        }
-        catch {
-            // Skip invalid files
-        }
-    }
-    return rules;
-}
-export function getCachedRules(ruleDir, severityFilter) {
-    if (!fs.existsSync(ruleDir)) {
-        return [];
-    }
-    let currentMtime = 0;
-    try {
-        currentMtime = fs.statSync(ruleDir).mtimeMs;
-    }
-    catch {
-        return [];
-    }
-    const cache = severityFilter === "error" ? blockingRulesCache : rulesCache;
-    const cached = cache.get(ruleDir);
-    if (cached && cached.mtime === currentMtime) {
-        return cached.rules;
-    }
-    const rules = loadYamlRulesUncached(ruleDir, severityFilter);
-    cache.set(ruleDir, { rules, mtime: currentMtime });
-    return rules;
-}
-export function isOverlyBroadPattern(pattern) {
-    if (!pattern)
-        return false;
-    if (OVERLY_BROAD_PATTERNS.includes(pattern.trim()))
-        return true;
-    return /^\$[A-Z_]+$/i.test(pattern.trim());
-}
-export function isValidCondition(condition) {
-    if (!condition)
-        return false;
-    if (condition.all !== undefined && condition.all.length === 0)
-        return false;
-    if (condition.any !== undefined && condition.any.length === 0)
-        return false;
-    if (isOverlyBroadPattern(condition.pattern))
-        return false;
-    return true;
-}
-export function isStructuredRule(rule) {
-    if (!rule.rule)
-        return false;
-    return !!(rule.rule.has ||
-        rule.rule.any ||
-        rule.rule.all ||
-        rule.rule.not ||
-        rule.rule.regex);
-}
-/**
- * Check if a rule or any of its nested conditions use features
- * not supported by the NAPI runner (inside, follows, precedes,
- * stopBy, field, nthChild). Rules using these must be skipped
- * to prevent false positives from incomplete condition evaluation.
- */
-export function hasUnsupportedConditions(rule) {
-    if (rule.constraints)
-        return true;
-    if (!rule.rule)
-        return false;
-    return conditionHasUnsupported(rule.rule);
-}
-function conditionHasUnsupported(c) {
-    if (c.inside ||
-        c.follows ||
-        c.precedes ||
-        c.stopBy ||
-        c.field ||
-        c.nthChild) {
-        return true;
-    }
-    if (c.has && conditionHasUnsupported(c.has))
-        return true;
-    if (c.not && conditionHasUnsupported(c.not))
-        return true;
-    if (c.any) {
-        for (const sub of c.any) {
-            if (conditionHasUnsupported(sub))
-                return true;
-        }
-    }
-    if (c.all) {
-        for (const sub of c.all) {
-            if (conditionHasUnsupported(sub))
-                return true;
-        }
-    }
-    return false;
-}
-export function calculateRuleComplexity(condition) {
-    if (!condition)
-        return 0;
-    let score = 0;
-    if (condition.has)
-        score += 3;
-    if (condition.not)
-        score += 2;
-    if (condition.regex)
-        score += 2;
-    if (condition.any)
-        score += condition.any.length * 2;
-    if (condition.all)
-        score += condition.all.length * 3;
-    if (condition.has)
-        score += calculateRuleComplexity(condition.has);
-    if (condition.not)
-        score += calculateRuleComplexity(condition.not);
-    if (condition.any) {
-        for (const sub of condition.any)
-            score += calculateRuleComplexity(sub);
-    }
-    if (condition.all) {
-        for (const sub of condition.all)
-            score += calculateRuleComplexity(sub);
-    }
-    return score;
-}
-// --- YAML Parser ---
-function getIndent(line) {
-    let count = 0;
-    for (const char of line) {
-        if (char === " ")
-            count++;
-        else if (char === "\t")
-            count += 2;
-        else
-            break;
-    }
-    return count;
-}
-function stripQuotes(value) {
-    let s = value;
-    while (s.startsWith('"') && s.endsWith('"') && s.length > 1)
-        s = s.slice(1, -1);
-    while (s.startsWith("'") && s.endsWith("'") && s.length > 1)
-        s = s.slice(1, -1);
-    return s;
-}
-export function parseSimpleYaml(content) {
-    const lines = content.split("\n");
-    const rule = { id: "", metadata: {} };
-    const stack = [];
-    let multilineBuffer = [];
-    let multilineKey = "";
-    const currentObj = () => stack.length === 0
-        ? rule
-        : stack[stack.length - 1].obj;
-    const flushMultiline = () => {
-        if (!multilineKey || multilineBuffer.length === 0)
-            return;
-        const value = multilineBuffer.join("\n");
-        const obj = currentObj();
-        if (multilineKey === "pattern")
-            obj.pattern = value;
-        else if (multilineKey === "message")
-            rule.message = value;
-        multilineKey = "";
-        multilineBuffer = [];
-    };
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#") || trimmed === "---")
-            continue;
-        const indent = getIndent(line);
-        while (stack.length > 0 && indent <= stack[stack.length - 1].indent) {
-            stack.pop();
-        }
-        if (line.startsWith(" ") && !trimmed.includes(":") && multilineKey) {
-            multilineBuffer.push(trimmed);
-            continue;
-        }
-        flushMultiline();
-        const colonIdx = trimmed.indexOf(":");
-        const key = colonIdx > 0 ? trimmed.substring(0, colonIdx).trim() : trimmed;
-        const value = colonIdx > 0 ? trimmed.substring(colonIdx + 1).trim() : "";
-        if (key === "id") {
-            rule.id = stripQuotes(value);
-        }
-        else if (key === "language") {
-            rule.language = value;
-        }
-        else if (key === "severity") {
-            rule.severity = value;
-        }
-        else if (key === "message") {
-            value === "|"
-                ? (multilineKey = "message")
-                : (rule.message = stripQuotes(value));
-        }
-        else if (key === "constraints") {
-            rule.constraints = {};
-            stack.push({
-                name: "constraints",
-                indent,
-                obj: rule.constraints,
-            });
-        }
-        else if (key === "metadata") {
-            rule.metadata = {};
-            stack.push({ name: "metadata", indent, obj: rule.metadata });
-        }
-        else if (key === "rule") {
-            rule.rule = {};
-            stack.push({ name: "rule", indent, obj: rule.rule });
-        }
-        else if (stack.length > 0) {
-            const obj = currentObj();
-            const section = stack[stack.length - 1].name;
-            if (key === "weight" && section === "metadata") {
-                if (!rule.metadata)
-                    rule.metadata = {};
-                rule.metadata.weight = parseInt(value, 10) || 3;
-            }
-            else if (key === "category" && section === "metadata") {
-                if (!rule.metadata)
-                    rule.metadata = {};
-                rule.metadata.category = stripQuotes(value);
-            }
-            else if (key === "pattern") {
-                value === "|"
-                    ? (multilineKey = "pattern")
-                    : (obj.pattern = stripQuotes(value));
-            }
-            else if (key === "kind") {
-                obj.kind = value;
-            }
-            else if (key === "regex") {
-                obj.regex = stripQuotes(value);
-            }
-            else if (key === "inside" || key === "follows" || key === "precedes") {
-                // Mark as present for unsupported-condition detection
-                obj[key] = {};
-                stack.push({ name: key, indent, obj: obj[key] });
-            }
-            else if (key === "stopBy") {
-                obj.stopBy = stripQuotes(value) || "end";
-            }
-            else if (key === "field") {
-                obj.field = stripQuotes(value);
-            }
-            else if (key === "nthChild") {
-                obj.nthChild = value || true;
-                stack.push({ name: "nthChild", indent, obj: {} });
-            }
-            else if (key === "has" || key === "not") {
-                obj[key] = {};
-                stack.push({ name: key, indent, obj: obj[key] });
-            }
-            else if (key === "any" || key === "all") {
-                if (!obj[key])
-                    obj[key] = [];
-                const list = obj[key];
-                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("- ")) {
-                        const item = {};
-                        list.push(item);
-                        stack.push({
-                            name: key,
-                            indent: nextIndent,
-                            obj: item,
-                        });
-                        const itemContent = nextTrimmed.substring(2);
-                        const colonPos = itemContent.indexOf(":");
-                        if (colonPos !== -1) {
-                            const itemKey = itemContent.substring(0, colonPos);
-                            const itemVal = itemContent.substring(colonPos + 1);
-                            if (itemKey.trim() === "pattern") {
-                                item.pattern = stripQuotes(itemVal.trim());
-                            }
-                            else if (itemKey.trim() === "kind") {
-                                item.kind = itemVal.trim();
-                            }
-                            else if (itemKey.trim() === "regex") {
-                                item.regex = stripQuotes(itemVal.trim());
-                            }
-                        }
-                        else if (itemContent) {
-                            item.pattern = stripQuotes(itemContent);
-                        }
-                    }
-                    j++;
-                }
-            }
-        }
-    }
-    flushMultiline();
-    return rule.id ? rule : null;
-}

package/clients/dispatch/types.js

@@ -1,16 +0,0 @@
-/**
- * Redesigned Dispatch Types for pi-lens
- *
- * Key insight: Different clients have different OUTPUT SEMANTICS:
- * - BLOCKING: Errors that stop the agent (architect, ts-lsp errors)
- * - WARNING: Non-blocking issues (biome warnings, type-safety)
- * - FIXABLE: Issues with auto-fix available
- * - SILENT: Metrics tracked but not shown (complexity)
- * - INFORMATIONAL: Shown in session summary only
- *
- * The dispatcher must handle these semantics consistently.
- */
-// --- Registry ---
-// Test edit - adding unused variable to check inline diagnostics flow
-const _unusedTestVariable = "checking pre-write and post-write flow";
-export {};