pi-lens 4.3.0 → 4.4.0

package/dist/clients/ruff-client.js

@@ -1,179 +0,0 @@
-/**
- * Ruff Client for pi-lens
- *
- * Fast Python linting and formatting via Ruff CLI.
- * Replaces flake8, pylint, isort, black, pyupgrade.
- *
- * Requires: pip install ruff
- * Docs: https://docs.astral.sh/ruff/
- */
-import { createSubsystemLogger } from "./extension-log.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./dispatch/runners/utils/runner-helpers.js";
-import { isFileKind } from "./file-kinds.js";
-import { pathsEqual } from "./path-utils.js";
-import { safeSpawnAsync } from "./safe-spawn.js";
-import { resolveToolCwd } from "./tool-cwd.js";
-import { ruffConfigArgs } from "./tool-policy.js";
-// --- Client ---
-const ruffAvailability = createAvailabilityChecker("ruff", ".exe");
-export class RuffClient {
-    ruffCommand = "ruff";
-    log;
-    constructor(verbose = false) {
-        this.log = verbose ? createSubsystemLogger("ruff") : () => { };
-    }
-    /**
-     * Check if ruff CLI is available, auto-install if not.
-     *
-     * Re-entrancy safe: the shared availability seam deduplicates the complete
-     * probe/auto-install transaction per cwd and tool, so concurrent callers do
-     * not duplicate installation attempts.
-     */
-    async ensureAvailable() {
-        const resolved = await resolveAvailableOrInstall(ruffAvailability, "ruff", process.cwd());
-        if (!resolved)
-            return false;
-        this.ruffCommand = resolved;
-        return true;
-    }
-    /**
-     * Check if a file is a Python file
-     */
-    isPythonFile(filePath) {
-        return isFileKind(filePath, "python");
-    }
-    /**
-     * Async auto-fix variant for pipeline use (non-blocking spawn).
-     * `cwd` is the dispatch language root. It is the seam's starting point,
-     * not the answer: `resolveToolCwd` walks from the file to the nearest
-     * `pyproject.toml`/`ruff.toml`/`.ruff.toml` at or above it, capped inside
-     * `cwd` (and at `$HOME` when there is none), so a file in a nested package
-     * gets that package's config rather than the workspace-root one.
-     */
-    async fixFileAsync(filePath, cwd) {
-        if (!(await this.ensureAvailable())) {
-            return {
-                success: false,
-                changed: false,
-                fixed: 0,
-                error: "Ruff not available",
-            };
-        }
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath)) {
-            return {
-                success: false,
-                changed: false,
-                fixed: 0,
-                error: "File not found",
-            };
-        }
-        try {
-            const before = await fs.promises.readFile(absolutePath, "utf-8");
-            // #2894: the root ruff resolves its config from now comes from the
-            // shared seam, not a local `cwd ?? path.dirname(file)`. `tool-policy.ts`
-            // requires the lint runner (`ruff.ts`, on `resolveRunnerCwd`) and this
-            // autofix path to consume the SAME policy; deriving the root two
-            // different ways is how they drift, and the hand-rolled form ignored a
-            // nested `pyproject.toml` whenever the caller passed a workspace root.
-            const ruffCwd = resolveToolCwd("runner", "ruff", absolutePath, {
-                ...(cwd !== undefined && { cwd }),
-            }).cwd;
-            // Shared config-args seam (#1247): the lint runner consumes the same
-            // builder, so `check --fix` can never drift to ruff's default rule
-            // set when the project lacks its own config and the package-owned
-            // core.toml fallback applies.
-            const configArgs = ruffConfigArgs(ruffCwd);
-            const pre = await safeSpawnAsync(this.ruffCommand, [
-                "check",
-                "--output-format",
-                "json",
-                "--target-version",
-                "py310",
-                ...configArgs,
-                absolutePath,
-            ], { timeout: 10000, cwd: ruffCwd });
-            const beforeDiags = pre.stdout?.trim()
-                ? this.parseOutput(pre.stdout, ruffCwd, absolutePath)
-                : [];
-            const fixableCount = beforeDiags.filter((d) => d.fixable).length;
-            const fix = await safeSpawnAsync(this.ruffCommand, ["check", "--fix", ...configArgs, absolutePath], { timeout: 15000, cwd: ruffCwd });
-            if (fix.error) {
-                return {
-                    success: false,
-                    changed: false,
-                    fixed: 0,
-                    error: fix.error.message,
-                };
-            }
-            const after = await fs.promises.readFile(absolutePath, "utf-8");
-            const changed = before !== after;
-            if (changed) {
-                this.log(`Fixed ${fixableCount} issue(s) in ${path.basename(filePath)}`);
-            }
-            return { success: true, changed, fixed: fixableCount };
-        }
-        catch (err) {
-            return { success: false, changed: false, fixed: 0, error: err.message };
-        }
-    }
-    // --- Internal ---
-    /**
-     * `cwd` is the directory ruff RAN in, and it is REQUIRED: a default would
-     * hide the wrong base at a call site that forgot it (#3284's D11).
-     *
-     * ruff's JSON `filename` is the `SourceFile`'s name verbatim — the JSON
-     * renderer reads `span.file().path(resolver)` (ruff 0.16.8
-     * `crates/ruff_db/src/diagnostic/render/json.rs:58,120`), which for a ruff
-     * (not `ty`) diagnostic is `file.name()` (`crates/ruff_db/src/diagnostic/
-     * mod.rs:1187-1193`), NOT the cwd-relative `relative_path` the text
-     * renderers use (`mod.rs:1195-1204`). That name is
-     * `SourceFileBuilder::new(path.to_string_lossy(), …)`
-     * (`crates/ruff_linter/src/linter.rs:1049`) over a path the resolver has
-     * already absolutized ("Normalize every path (e.g., convert from relative to
-     * absolute)", `crates/ruff_workspace/src/resolver.rs:484`). So ruff echoes
-     * the absolute path we hand it as argv: the BASE was already right here and
-     * the fold deletes a `path.resolve` with no base — which silently meant the
-     * EXTENSION's `process.cwd()`, not ruff's — rather than leaving it for a
-     * future relative invocation to re-enable.
-     */
-    parseOutput(output, cwd, filterFile) {
-        if (!output.trim())
-            return [];
-        try {
-            const items = JSON.parse(output);
-            const diagnostics = [];
-            for (const item of items) {
-                // Filter to single file if requested. #3278/#3286: one seam answers
-                // "is this reported diagnostic about the file I ran for?" — resolve
-                // the tool's spelling against the cwd the tool RAN in and compare
-                // through `pathsEqual`, the repo's on-disk identity predicate. A bare
-                // `!==` treats a spelling that differs only in case (the SAME file on
-                // Windows and on a case-folding POSIX mount) as a different file and
-                // drops every finding for the edited file (#209, #3277).
-                if (filterFile &&
-                    !pathsEqual(path.resolve(cwd, item.filename), filterFile))
-                    continue;
-                diagnostics.push({
-                    line: item.location.row - 1, // ruff is 1-indexed
-                    column: item.location.column - 1,
-                    endLine: item.end_location.row - 1,
-                    endColumn: item.end_location.column - 1,
-                    severity: item.code?.startsWith("E") ? "error" : "warning",
-                    message: item.message,
-                    rule: item.code || "unknown",
-                    file: item.filename,
-                    fixable: item.fix !== null,
-                });
-            }
-            return diagnostics;
-        }
-        catch (err) {
-            void err;
-            this.log("Failed to parse ruff JSON output");
-            return [];
-        }
-    }
-}

package/dist/clients/rules-scanner.js

@@ -1,131 +0,0 @@
-/**
- * Project rules scanner for pi-lens.
- *
- * Scans for rule files that other tools/agents may have left:
- * - .claude/rules/   — Claude Code rule files
- * - .agents/rules/   — Generic agent rule files
- * - .cursorrules     — Cursor IDE rules
- * - CLAUDE.md        — Claude Code project context
- * - AGENTS.md        — Generic agent context
- *
- * These are surfaced in the system prompt so the agent knows
- * to read them when relevant.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-const RULE_DIRS = [
-    { dir: ".claude/rules", source: ".claude/rules" },
-    { dir: ".agents/rules", source: ".agents/rules" },
-];
-const RULE_FILES = [
-    { file: "CLAUDE.md", source: "root" },
-    { file: "AGENTS.md", source: "root" },
-    { file: ".cursorrules", source: "root" },
-];
-const PROMPT_RULES_MAX_TOTAL = 12;
-const PROMPT_RULES_MAX_PER_SOURCE = 4;
-const PROMPT_RULES_MAX_CHARS = 900;
-// #250/#747 class: this walk is scoped to `.claude/rules`/`.agents/rules`
-// subtrees, so it never walks the whole cwd — but it's still unbounded
-// recursion. A small depth/file cap guards a pathologically deep or huge rules
-// directory (or a symlink loop) without needing the full home ceiling the
-// project-wide walkers use. Rules trees are shallow and small in practice, so
-// these bounds never trim a legitimate layout.
-const RULES_SCAN_MAX_DEPTH = 8;
-const RULES_SCAN_MAX_FILES = 500;
-function findMarkdownFiles(dir, baseDir, depth = 0, collected = { count: 0 }) {
-    const results = [];
-    if (depth > RULES_SCAN_MAX_DEPTH)
-        return results;
-    if (!fs.existsSync(dir))
-        return results;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (collected.count >= RULES_SCAN_MAX_FILES)
-            break;
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            results.push(...findMarkdownFiles(fullPath, baseDir, depth + 1, collected));
-        }
-        else if (entry.isFile() && entry.name.endsWith(".md")) {
-            collected.count += 1;
-            results.push({
-                source: path.relative(baseDir, dir) || path.basename(baseDir),
-                name: entry.name,
-                filePath: fullPath,
-                relativePath: path.relative(baseDir, fullPath).replace(/\\/g, "/"),
-            });
-        }
-    }
-    return results;
-}
-export function scanProjectRules(cwd) {
-    const rules = [];
-    // Scan rule directories
-    for (const { dir, source } of RULE_DIRS) {
-        const dirPath = path.join(cwd, dir);
-        if (fs.existsSync(dirPath)) {
-            const found = findMarkdownFiles(dirPath, path.join(cwd, dir));
-            for (const rule of found) {
-                rules.push({
-                    source,
-                    name: rule.name,
-                    filePath: rule.filePath,
-                    relativePath: `${dir}/${rule.relativePath}`,
-                });
-            }
-        }
-    }
-    // Check for root-level rule files
-    for (const { file, source } of RULE_FILES) {
-        const filePath = path.join(cwd, file);
-        if (fs.existsSync(filePath)) {
-            rules.push({
-                source,
-                name: file,
-                filePath,
-                relativePath: file,
-            });
-        }
-    }
-    return {
-        rules,
-        hasCustomRules: rules.length > 0,
-    };
-}
-export function formatRulesForPrompt(result) {
-    if (!result.hasCustomRules)
-        return "";
-    // Group by source
-    const bySource = new Map();
-    for (const rule of result.rules) {
-        const existing = bySource.get(rule.source) ?? [];
-        existing.push(rule);
-        bySource.set(rule.source, existing);
-    }
-    const sections = [];
-    let emittedTotal = 0;
-    const sortedSources = [...bySource.keys()].sort((a, b) => a.localeCompare(b));
-    for (const source of sortedSources) {
-        if (emittedTotal >= PROMPT_RULES_MAX_TOTAL)
-            break;
-        const rules = bySource.get(source) ?? [];
-        const sortedRules = [...rules].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-        const remainingBudget = PROMPT_RULES_MAX_TOTAL - emittedTotal;
-        const shown = sortedRules.slice(0, Math.min(PROMPT_RULES_MAX_PER_SOURCE, remainingBudget));
-        emittedTotal += shown.length;
-        const list = shown.map((r) => `- \`${r.relativePath}\``);
-        if (sortedRules.length > shown.length) {
-            list.push(`- ... and ${sortedRules.length - shown.length} more in ${source}`);
-        }
-        sections.push(`From ${source}/:\n${list.join("\n")}`);
-    }
-    const hidden = result.rules.length - emittedTotal;
-    if (hidden > 0) {
-        sections.push(`... and ${hidden} additional rule file(s) not listed.`);
-    }
-    const full = sections.join("\n\n");
-    if (full.length <= PROMPT_RULES_MAX_CHARS)
-        return full;
-    return `${full.slice(0, PROMPT_RULES_MAX_CHARS)}\n... (truncated)`;
-}

package/dist/clients/run-duration.js

@@ -1,55 +0,0 @@
-/**
- * #1479/#1480: one place decides whether a test run was actually timed, and
- * one place renders the answer.
- *
- * `TestResult.duration` is optional, and the two states are different facts.
- * A present number is a MEASUREMENT — including `0`, because pytest really
- * does print `in 0.00s` and a suite whose `startTime` equals its `endTime`
- * really did run in under a millisecond. An absent value means no
- * runner-reported figure was found at all.
- *
- * That contract was written down once, in the doc comment on
- * `TestResult.duration`, and then re-derived at every site that reads or
- * produces a duration. A reader of any one of those sites cannot see the
- * contract, and a producer that reaches for `0` when it means "did not
- * measure" reintroduces exactly the defect #1479 removed. These three
- * functions are the contract in executable form: `isMeasuredDuration`
- * classifies, `toMeasuredDurationMs` normalises a freshly parsed figure into
- * it, and `formatRunDurationMs` renders it.
- *
- * NOTE FOR ANYONE EDITING `isMeasuredDuration`: the predicate is `>= 0`, not
- * `> 0`. A measured zero is real. `> 0` looks like a harmless tightening and
- * is the single change that would silently restore the bug.
- *
- * Kept in its own module rather than exported from `test-runner-client.ts`:
- * `runtime-turn.ts` needs it on the hot turn-end path, and the client is
- * deliberately loaded lazily (`bootstrap.ts` dynamic-imports it), so a value
- * import from there would drag the whole runner into startup.
- */
-/**
- * True only for a value that represents a real measurement.
- *
- * `0` is measured. `undefined`, `null`, `NaN`, the infinities, and a negative
- * figure are not: the last three can only come from a garbled parse, and a
- * garbled parse must degrade to "we did not measure this", never to a wrong
- * number.
- */
-export function isMeasuredDuration(duration) {
-    return (typeof duration === "number" && Number.isFinite(duration) && duration >= 0);
-}
-/**
- * Normalise a parsed elapsed time to the `TestResult.duration` contract.
- *
- * Returns whole milliseconds for a real reading — `0` included — and
- * `undefined` for anything that is not one, so a producer never has to spell
- * out the absent case itself.
- */
-export function toMeasuredDurationMs(duration) {
-    return isMeasuredDuration(duration) ? Math.round(duration) : undefined;
-}
-/** Render a duration for a log line: `123ms`, or `unmeasured` when absent. */
-export function formatRunDurationMs(duration) {
-    return isMeasuredDuration(duration)
-        ? `${Math.round(duration)}ms`
-        : "unmeasured";
-}