pi-lens 4.3.0 → 4.4.0

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

@@ -1,242 +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:
- * - Mtime caching for bundled rules; content/path caching for project rules
- * - Severity filtering (error-only for blocking mode)
- * - Complexity scoring for performance optimization
- * - Overly broad pattern detection
- */
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import yaml from "../../deps/js-yaml.js";
-import { BoundedLruCache } from "../../bounded-cache.js";
-import { compareOrdinal } from "../../string-utils.js";
-// --- Constants ---
-/** Overly broad patterns that match everything (cause false positive explosions) */
-const OVERLY_BROAD_PATTERNS = ["$NAME", "$FIELD", "$_", "$X", "$VAR", "$EXPR"];
-/** Maximum complexity score for rules in blockingOnly mode */
-export const MAX_BLOCKING_RULE_COMPLEXITY = 8;
-/**
- * `getCachedRules` re-stats a rule directory's files at most once per this
- * window (#2262 round 2). `scanner.ts:235` calls `loadYamlRules` per file
- * scanned; a full metadata sweep (readdir + stat every rule file) on every
- * warmed call measured 250x master's per-call cost on a mid-size catalog.
- * Same value and same shape as `file-utils.ts`'s
- * `PROJECT_IGNORE_FRESHNESS_CADENCE_MS` (#2159/#2071): 2s is the accepted
- * staleness bound for a rule tree pi-lens itself did not just write.
- */
-export const RULES_CACHE_FRESHNESS_CADENCE_MS = 2_000;
-// --- Caches ---
-const rulesCache = new BoundedLruCache(64);
-const blockingRulesCache = new BoundedLruCache(64);
-const contentRulesCache = new BoundedLruCache(64);
-const contentBlockingRulesCache = new BoundedLruCache(64);
-// --- Public API ---
-export function loadYamlRules(ruleDir, severityFilter) {
-    return getCachedRules(ruleDir, severityFilter);
-}
-function findYamlRuleFiles(ruleDir) {
-    let entries;
-    try {
-        entries = fs
-            .readdirSync(ruleDir, { withFileTypes: true })
-            // Ordinal (code-unit), not locale, comparison: this order feeds the
-            // index-aligned file-stamp identity compared in `getCachedRules` and
-            // the hash input order in `loadYamlRulesFresh`. `localeCompare` can
-            // order the same file set differently across locales/processes,
-            // which would desync the two and mint spurious cache misses or
-            // (worse) content-hash collisions across differently-ordered runs.
-            // Same reasoning as `rule-cache.ts`'s `computeRuleHash` (#2155/#2165).
-            .sort((a, b) => compareOrdinal(a.name, b.name));
-    }
-    catch {
-        return [];
-    }
-    const files = [];
-    for (const entry of entries) {
-        const full = path.join(ruleDir, entry.name);
-        if (entry.isDirectory()) {
-            files.push(...findYamlRuleFiles(full));
-        }
-        else if (entry.isFile() && /\.ya?ml$/i.test(entry.name)) {
-            files.push(full);
-        }
-    }
-    return files;
-}
-function loadYamlRuleFiles(files, severityFilter) {
-    const rules = [];
-    for (const file of files) {
-        let content;
-        try {
-            content = fs.readFileSync(file, "utf-8");
-        }
-        catch {
-            continue;
-        }
-        const documents = content.split(/^---\s*$/m).filter((doc) => doc.trim());
-        for (const document of documents) {
-            const rule = parseSimpleYaml(document.trim());
-            if (!rule?.id)
-                continue;
-            if (severityFilter && rule.severity !== severityFilter)
-                continue;
-            rules.push(rule);
-        }
-    }
-    return rules;
-}
-export function loadYamlRulesUncached(ruleDir, severityFilter) {
-    return loadYamlRuleFiles(findYamlRuleFiles(ruleDir), severityFilter);
-}
-/** Content/path-aware cache used for mutable project-owned rule trees. */
-export function loadYamlRulesFresh(ruleDir, severityFilter) {
-    const files = findYamlRuleFiles(ruleDir);
-    const hash = createHash("sha256");
-    for (const file of files) {
-        hash.update(path.relative(ruleDir, file));
-        hash.update("\0");
-        try {
-            hash.update(fs.readFileSync(file));
-        }
-        catch {
-            hash.update("missing");
-        }
-        hash.update("\0");
-    }
-    const signature = hash.digest("hex");
-    const cache = severityFilter === "error" ? contentBlockingRulesCache : contentRulesCache;
-    const cached = cache.get(ruleDir);
-    if (cached?.signature === signature)
-        return cached.rules;
-    const rules = loadYamlRuleFiles(files, severityFilter);
-    cache.set(ruleDir, { rules, signature });
-    return rules;
-}
-function getCachedRules(ruleDir, severityFilter) {
-    if (!fs.existsSync(ruleDir)) {
-        return [];
-    }
-    const cache = severityFilter === "error" ? blockingRulesCache : rulesCache;
-    const cached = cache.get(ruleDir);
-    const now = Date.now();
-    if (cached && now - cached.checkedAtMs < RULES_CACHE_FRESHNESS_CADENCE_MS) {
-        // Inside the cadence window: no stat sweep at all. `getCachedRules` is
-        // the bundled-catalog path only (project rules route through
-        // `loadYamlRulesFresh` — see `ast-grep-napi.ts`'s route split), and
-        // `scanner.ts:235` calls it once per scanned file, so a per-call
-        // `readdirSync`+`statSync*N` sweep is the hot-path cost this window
-        // exists to remove.
-        return cached.rules;
-    }
-    const files = findYamlRuleFiles(ruleDir);
-    const fileStamps = files.flatMap((file) => {
-        try {
-            const stat = fs.statSync(file);
-            return [{ path: file, mtimeMs: stat.mtimeMs, size: stat.size }];
-        }
-        catch {
-            return [];
-        }
-    });
-    const metadataMatches = cached?.files.length === fileStamps.length &&
-        cached.files.every((file, index) => file.path === fileStamps[index].path &&
-            file.mtimeMs === fileStamps[index].mtimeMs &&
-            file.size === fileStamps[index].size);
-    if (cached && metadataMatches) {
-        // Nothing drifted. Re-arm the window from *now* regardless — otherwise
-        // the next call re-stats immediately instead of waiting a full cadence
-        // (the #2260/#2071 "checkedAtMs must re-arm on every check, not only on
-        // a miss" lesson).
-        cached.checkedAtMs = now;
-        return cached.rules;
-    }
-    const rules = loadYamlRuleFiles(files, severityFilter);
-    cache.set(ruleDir, { rules, files: fileStamps, checkedAtMs: now });
-    return rules;
-}
-export function isOverlyBroadPattern(pattern) {
-    // The rich pattern form ({context, selector, ...}) is structured and never a
-    // single-metavar trap; only string patterns can be overly-broad literals.
-    if (!pattern)
-        return false;
-    if (typeof pattern !== "string")
-        return false;
-    if (OVERLY_BROAD_PATTERNS.includes(pattern.trim()))
-        return true;
-    return /^\$[A-Z_]+$/i.test(pattern.trim());
-}
-export function isStructuredRule(rule) {
-    if (!rule.rule)
-        return false;
-    // The rich pattern form ({context, selector, …}) is itself a structured
-    // match — it specifies a context snippet plus the AST node to pick out.
-    // Without recognizing it as structure, an otherwise-rich rule with only
-    // `pattern: {context, selector}` and no other combinators would be wrongly
-    // classified as "unstructured single-metavar" and dropped by the runner.
-    const hasRichPattern = typeof rule.rule.pattern === "object" && rule.rule.pattern !== null;
-    return !!(hasRichPattern ||
-        rule.rule.has ||
-        rule.rule.any ||
-        rule.rule.all ||
-        rule.rule.not ||
-        rule.rule.regex);
-}
-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 ---
-/**
- * Parse a single YAML rule document into a {@link YamlRule}.
- *
- * Uses `js-yaml` so the full ast-grep rule grammar — nested `any`/`all`/`has`,
- * `field`/`inside`/`stopBy`, and metavariable `constraints` — survives intact and
- * can be handed straight to napi's native engine. (The former hand-rolled parser
- * flattened nested structures and dropped constraints, which is why those rules
- * had to be skipped; see #206.) A malformed document returns `null` rather than
- * throwing, so callers skip just that rule.
- */
-export function parseSimpleYaml(content) {
-    let parsed;
-    try {
-        parsed = yaml.load(content);
-    }
-    catch {
-        return null;
-    }
-    if (!parsed || typeof parsed !== "object")
-        return null;
-    const rule = parsed;
-    return rule.id ? rule : null;
-}

package/dist/clients/dispatch/runners/yamllint.js

@@ -1,95 +0,0 @@
-import * as path from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { logRunnerAdvisoryOnce } from "../../tool-cwd.js";
-import { getLinterPolicyForCwd, hasYamllintConfig } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveRunnerCwd, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-const yamllint = createAvailabilityChecker("yamllint", ".exe");
-export { hasYamllintConfig };
-function parseYamllintParsable(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const line of raw.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        const match = line.match(/^(.*?):(\d+):(\d+):\s*\[(error|warning)\]\s*(.*?)\s*\(([^)]+)\)\s*$/i);
-        if (!match)
-            continue;
-        if (!pathsEqual(path.resolve(cwd, match[1]), absTarget))
-            continue;
-        const severity = match[4].toLowerCase() === "error" ? "error" : "warning";
-        diagnostics.push({
-            id: `yamllint-${match[2]}-${match[3]}-${match[6]}`,
-            message: `[${match[6]}] ${match[5]}`,
-            filePath,
-            line: Number(match[2]),
-            column: Number(match[3]),
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "yamllint",
-            rule: match[6],
-        });
-    }
-    return diagnostics;
-}
-const yamllintRunner = {
-    id: "yamllint",
-    appliesTo: ["yaml"],
-    priority: PRIORITY.YAML_LINT,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "yamllint");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("yamllint")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const hasConfig = hasYamllintConfig(cwd);
-        if (!hasConfig) {
-            logRunnerAdvisoryOnce(ctx, "yamllint", cwd, "yamllint: no config detected, running with default rules");
-        }
-        let cmd = null;
-        if (await yamllint.isAvailableAsync(cwd)) {
-            cmd = yamllint.getCommand(cwd);
-        }
-        else {
-            cmd = await resolveToolCommandWithInstallFallback(cwd, "yamllint");
-        }
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        const result = await safeSpawnAsync(cmd, ["-f", "parsable", ctx.filePath], {
-            cwd,
-            timeout: 15000,
-        });
-        // #1816: this runner read `result.status` zero times, so a yamllint
-        // that rejected its config reported a clean YAML file.
-        //
-        // No exit-code table: yamllint returns 2 both for "warnings only" and
-        // for an argparse usage error, so declaring 2 a rejection would discard
-        // real warnings. The discriminator is the STREAM instead. `-f parsable`
-        // writes findings to stdout and nothing else; stderr carries usage text
-        // and tracebacks. So the gate judges "nothing to parse" on stdout alone,
-        // while the parser still reads both streams.
-        const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        // #1948: classify on stdout as before, parse both streams as before, and
-        // record when a failing run yields nothing.
-        const run = parseToolRun("yamllint", {
-            result,
-            output: result.stdout,
-            // EXIT TABLE (yamllint 1.35 docs https://yamllint.readthedocs.io/en/stable/): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (out) => parseYamllintParsable(out, ctx.filePath, cwd), { parseOutput: raw });
-        if (run.skipped)
-            return run.skipped;
-        const diagnostics = run.diagnostics;
-        return finishParsedRun({
-            tool: "yamllint",
-            ctx,
-            result,
-            diagnostics,
-        });
-    },
-};
-export default yamllintRunner;

package/dist/clients/dispatch/runners/zig-check.js

@@ -1,79 +0,0 @@
-import * as path from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { PRIORITY } from "../priorities.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-// zig rejects `--version`; the version subcommand is `zig version`. Using the
-// default probe would make this runner skip on every machine.
-const zig = createAvailabilityChecker("zig", ".exe", ["version"]);
-function parseZigOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const line of raw.split(/\r?\n/)) {
-        const match = line.match(/^(.*?):(\d+):(\d+):\s*(error|warning|note):\s*(.+)$/);
-        if (!match)
-            continue;
-        const [, rawFile, lineStr, colStr, level, message] = match;
-        // #3278: one seam for reported-path attribution — see javac.ts.
-        if (!pathsEqual(path.resolve(cwd, rawFile.trim()), absTarget))
-            continue;
-        const severity = level === "error" ? "error" : "warning";
-        diagnostics.push({
-            id: `zig-${level}-${lineStr}-${colStr}`,
-            message,
-            filePath,
-            line: Number.parseInt(lineStr, 10) || 1,
-            column: Number.parseInt(colStr, 10) || 1,
-            severity,
-            // `zig build-exe <file>` does not load build.zig module/import context.
-            // Its findings are useful evidence, but cannot prove a project blocker.
-            semantic: "warning",
-            tool: "zig",
-            rule: `zig-${level}`,
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-const zigCheckRunner = {
-    id: "zig-check",
-    appliesTo: ["zig"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "zig-check");
-        if (!(await zig.isAvailableAsync(cwd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = zig.getCommand(cwd);
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const result = await safeSpawnAsync(cmd, ["build-exe", absPath, "-fno-emit-bin"], { cwd, timeout: 30000 });
-        if (result.error && !result.stdout && !result.stderr) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const raw = `${result.stdout || ""}\n${result.stderr || ""}`;
-        const parsed = parseToolRun("zig-check", {
-            result,
-            output: raw,
-            // EXIT TABLE (Zig 0.13 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (output) => parseZigOutput(output, ctx.filePath, cwd));
-        if (parsed.skipped)
-            return parsed.skipped;
-        return finishParsedRun({
-            tool: "zig-check",
-            ctx,
-            result,
-            diagnostics: parsed.diagnostics,
-            classify: (diagnostics) => ({
-                status: diagnostics.some((d) => d.severity === "error")
-                    ? "failed"
-                    : "succeeded",
-                semantic: "warning",
-            }),
-        });
-    },
-};
-export default zigCheckRunner;

package/dist/clients/dispatch/suppress-writer.js

@@ -1,79 +0,0 @@
-/**
- * Writes the `pi-lens-ignore` suppression comment that inline-suppressions.ts
- * already knows how to read (#690's `suppress` disposition). The reader
- * accepts either `//` or `#` on any line regardless of language, but the
- * WRITER must pick the syntactically valid comment character for the target
- * file — an errant `#` line breaks parsing in a `//`-comment language and
- * vice versa.
- */
-import * as path from "node:path";
-import { parseInlineSuppressionRuleIds, splitInlineSuppressionPayload, } from "./inline-suppressions.js";
-const HASH_COMMENT_EXTENSIONS = new Set([
-    ".py",
-    ".rb",
-    ".sh",
-    ".bash",
-    ".zsh",
-    ".yml",
-    ".yaml",
-    ".toml",
-    ".r",
-    ".pl",
-    ".pm",
-    ".ex",
-    ".exs",
-    ".elixir",
-    ".dockerfile",
-    ".gitignore",
-    ".conf",
-    ".cfg",
-    ".ini",
-]);
-function commentPrefixFor(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    return HASH_COMMENT_EXTENSIONS.has(ext) ? "#" : "//";
-}
-/**
- * Insert a `pi-lens-ignore: <rule>` comment on the line immediately above
- * `line` (1-based), matching inline-suppressions.ts's "same line or line
- * above" read semantics. If the line above already carries a pi-lens-ignore
- * comment, the rule is appended to its list instead of adding a duplicate
- * comment line. Returns the updated content; throws if `line` is out of range.
- */
-export function insertSuppressComment(content, filePath, line, rule) {
-    const lines = content.split(/\r?\n/);
-    if (line < 1 || line > lines.length) {
-        throw new Error(`line ${line} is out of range (file has ${lines.length} lines)`);
-    }
-    const prefix = commentPrefixFor(filePath);
-    const aboveIdx = line - 2; // 0-based index of the line immediately above
-    const existingAbove = aboveIdx >= 0 ? lines[aboveIdx] : undefined;
-    const suppressRe = /((?:\/\/|#)\s*pi-lens-ignore:\s*)(.+)$/;
-    const match = existingAbove !== undefined ? suppressRe.exec(existingAbove) : null;
-    if (match && existingAbove !== undefined) {
-        const prefix = match[1];
-        const payload = match[2];
-        if (prefix === undefined || payload === undefined)
-            return content;
-        const { ruleList, trailingReason } = splitInlineSuppressionPayload(payload);
-        const rules = ruleList
-            .split(",")
-            .map((r) => r.trim())
-            .filter(Boolean);
-        const ruleIds = parseInlineSuppressionRuleIds(ruleList);
-        if (!ruleIds.includes(rule))
-            rules.push(rule);
-        lines[aboveIdx] =
-            existingAbove.slice(0, match.index) +
-                prefix +
-                rules.join(", ") +
-                trailingReason;
-        return lines.join("\n");
-    }
-    // Match the indentation of the flagged line so the inserted comment lines
-    // up rather than sitting at column 0.
-    const targetLine = lines[line - 1] ?? "";
-    const indent = /^\s*/.exec(targetLine)?.[0] ?? "";
-    lines.splice(line - 1, 0, `${indent}${prefix} pi-lens-ignore: ${rule}`);
-    return lines.join("\n");
-}

package/dist/clients/dispatch/tool-profile.js

@@ -1,30 +0,0 @@
-const DEFAULT_TOOL_PROFILE = {
-    dedupPriority: 50,
-    lintLike: false,
-};
-const TOOL_PROFILE_MAP = {
-    "tree-sitter:silent-error": { dedupPriority: 200, lintLike: false },
-    lsp: { dedupPriority: 120, lintLike: false },
-    eslint: { dedupPriority: 110, lintLike: true },
-    biome: { dedupPriority: 100, lintLike: true },
-    "biome-check-json": { dedupPriority: 100, lintLike: true },
-    "tree-sitter": { dedupPriority: 90, lintLike: false },
-    "ast-grep-napi": { dedupPriority: 80, lintLike: false },
-    "ast-grep": { dedupPriority: 80, lintLike: false },
-    "ruff-lint": { dedupPriority: 95, lintLike: true },
-    oxlint: { dedupPriority: 95, lintLike: true },
-    rubocop: { dedupPriority: 95, lintLike: true },
-    "go-vet": { dedupPriority: 95, lintLike: true },
-    "golangci-lint": { dedupPriority: 95, lintLike: true },
-    "rust-clippy": { dedupPriority: 95, lintLike: true },
-    shellcheck: { dedupPriority: 95, lintLike: true },
-    opengrep: { dedupPriority: 105, lintLike: false },
-    "trivy-config": { dedupPriority: 105, lintLike: false },
-};
-export function getToolProfile(tool, defectClass) {
-    const t = tool.toLowerCase();
-    if (defectClass === "silent-error" && t === "tree-sitter") {
-        return TOOL_PROFILE_MAP["tree-sitter:silent-error"];
-    }
-    return TOOL_PROFILE_MAP[t] ?? DEFAULT_TOOL_PROFILE;
-}

package/dist/clients/dispatch/types.js

@@ -1,21 +0,0 @@
-/**
- * Redesigned Dispatch Types for pi-lens
- *
- * Key insight: Different clients have different OUTPUT SEMANTICS:
- * - BLOCKING: Errors that stop the agent (architect, 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.
- */
-/** Closed telemetry taxonomy for expected runner skips. */
-export const RUNNER_SKIP_REASONS = [
-    "no-files-matched",
-    "configured-non-biome-linter",
-];
-/** Runtime guard for untyped/plugin-provided runner results. */
-export function isRunnerSkipReason(value) {
-    return RUNNER_SKIP_REASONS.some((reason) => reason === value);
-}

package/dist/clients/dispatch/utils/format-utils.js

@@ -1,45 +0,0 @@
-/**
- * Shared formatting utilities for the dispatch system.
- */
-const EMOJI = {
-    blocking: "🔴",
-    warning: "🟡",
-    fixed: "✅",
-    info: "ℹ️",
-    silent: "📊",
-    none: "",
-};
-/**
- * Format a single diagnostic for display
- */
-function formatDiagnostic(d) {
-    const line = d.line ? `L${d.line}: ` : "";
-    const indented = d.message.split("\n").join("\n  ");
-    const fix = d.fixSuggestion ? `\n    💡 Fix: ${d.fixSuggestion}` : "";
-    return `  ${line}${indented}${fix}`;
-}
-/**
- * Format a group of diagnostics with semantic header
- */
-export 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;
-}

package/dist/clients/dispatch/utils/lsp-diagnostics.js

@@ -1,35 +0,0 @@
-export function convertLspDiagnostics(diags, filePath, options = {}) {
-    const tool = options.tool ?? "lsp";
-    return diags
-        .filter((d) => d.range?.start?.line !== undefined)
-        .map((d, idx) => {
-        const severityMap = {
-            1: "error",
-            2: "warning",
-            4: "hint",
-        };
-        const severity = severityMap[d.severity] ?? "info";
-        const semantic = d.severity === 1 ? "blocking" : d.severity === 2 ? "warning" : "none";
-        const code = String(d.code ?? "unknown");
-        // #692: identity ALWAYS derives from the diagnostic's own source — never
-        // from a caller-supplied scan label (see `scanOrigin`'s doc comment above).
-        const source = d.source ?? tool;
-        const hasSuggestion = options.fixSuggestionByIndex?.has(idx) ?? false;
-        return {
-            id: `${tool}:${code}:${d.range.start.line}`,
-            message: d.message,
-            filePath,
-            line: d.range.start.line + 1,
-            column: d.range.start.character + 1,
-            severity,
-            semantic,
-            tool,
-            rule: `${source}:${code}`,
-            fixable: hasSuggestion,
-            autoFixAvailable: false,
-            fixKind: hasSuggestion ? "suggestion" : undefined,
-            fixSuggestion: options.fixSuggestionByIndex?.get(idx),
-            scanOrigin: options.scanOrigin,
-        };
-    });
-}

package/dist/clients/disposition-logger.js

@@ -1,32 +0,0 @@
-/**
- * NDJSON telemetry log for diagnostic disposition marks (#690). Same shape as
- * clients/actionable-warnings-logger.ts: machine-global (getGlobalPiLensLogDir),
- * size-capped with a single `.log.1` backup, isTestMode no-op.
- *
- * Why a log at all: #181 identified false-positive marks flowing to telemetry
- * as THE highest-value rule-tuning signal — which shipped rules misfire, on
- * what tools, how often — and this is that hookup. The disposition store
- * itself is not enough: it keeps only the LATEST entry per anchor (a re-mark
- * overwrites), and `defer` marks never touch the store at all (in-memory by
- * design), so this log is the only durable trace of both re-mark history and
- * defer activity.
- */
-import * as path from "node:path";
-import { isTestMode } from "./env-utils.js";
-import { getGlobalPiLensLogDir } from "./probe-home-state.js";
-import { createNdjsonLogger } from "./ndjson-logger.js";
-const DISPOSITION_LOG_DIR = getGlobalPiLensLogDir();
-const DISPOSITION_LOG_FILE = path.join(DISPOSITION_LOG_DIR, "dispositions.log");
-const DISPOSITION_LOG_BACKUP_FILE = path.join(DISPOSITION_LOG_DIR, "dispositions.log.1");
-const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.PI_LENS_DISPOSITION_LOG_MAX_BYTES ?? "1048576", 10) || 1048576);
-const writer = createNdjsonLogger({
-    filePath: DISPOSITION_LOG_FILE,
-    maxBytes: MAX_LOG_BYTES,
-    backupPath: DISPOSITION_LOG_BACKUP_FILE,
-});
-export function logDispositionEvent(entry) {
-    if (isTestMode()) {
-        return;
-    }
-    writer.log({ ts: new Date().toISOString(), ...entry });
-}