pi-lens 4.3.0 → 4.4.0

package/dist/clients/test-runner-delivery.js

@@ -1,287 +0,0 @@
-/**
- * Automatic test-runner delivery for the post-agent idle window (#2366).
- *
- * Test results remain in `test-runner-findings` for pull diagnostics and the
- * commit guard. This module stages an owner-qualified pointer and marks it
- * eligible for the next context build after the host proves that the agent is
- * idle. Provenance validation stays in `peekTestFindings`, the one shared
- * delivery gate for this cache.
- */
-import { emitBounded } from "./bounded-telemetry.js";
-import { recordDegradationOnce } from "./degradation-ledger.js";
-import { logLatency } from "./latency-logger.js";
-import { consumeTestFindings, peekTestFindings } from "./runtime-context.js";
-const MAX_PENDING_DELIVERIES = 32;
-const pending = new Map();
-function logDeliveredVerdicts(cacheManager, cwd, runtime, delivery) {
-    const verdicts = cacheManager.readCache("test-runner-findings", cwd)?.data?.verdicts;
-    let knownCount = 0;
-    let staleCount = 0;
-    let unknownCount = 0;
-    for (const verdict of verdicts ?? []) {
-        const evidence = verdict.fileSeq ?? {
-            state: "unknown",
-            reason: "legacy-cache-record",
-        };
-        if (evidence.state === "unknown") {
-            unknownCount += 1;
-            recordDegradationOnce({
-                kind: "test-runner-delivery",
-                subject: `${delivery.sessionId}:${verdict.sourceFile}`,
-                reason: `missing file sequence evidence (${evidence.reason})`,
-            });
-            continue;
-        }
-        knownCount += 1;
-        const currentFileSeq = runtime.getFileSeq(verdict.sourceFile);
-        if (currentFileSeq > evidence.value)
-            staleCount += 1;
-    }
-    if (knownCount === 0 && unknownCount === 0)
-        return;
-    logLatency({
-        type: "phase",
-        phase: "test_runner_verdict_delivery",
-        filePath: cwd,
-        durationMs: 0,
-        metadata: {
-            sessionId: delivery.sessionId,
-            generation: delivery.generation,
-            verdictCount: knownCount,
-            staleCount,
-            unknownCount,
-        },
-    });
-}
-function key(cwd, sessionId, ownerId) {
-    // `cwd` comes from the same host session field at turn_end and settle. Keep
-    // that canonical value unchanged so cache reads use the identical workspace
-    // identity; dispatch contexts already normalize their own path fields.
-    return `${ownerId ?? "direct"}\u0000${cwd}\u0000${sessionId}`;
-}
-function record(identity, outcome, delivery, metadata = {}) {
-    emitBounded("test_runner_delivery", identity, {
-        filePath: delivery.cwd,
-        durationMs: 0,
-        metadata: {
-            outcome,
-            sessionId: delivery.sessionId,
-            generation: delivery.generation,
-            targetCount: delivery.targetCount,
-            deliveryBoundary: "agent_settled",
-            ownership: "pi",
-            droppedDetailCount: 0,
-            ...metadata,
-        },
-    }, {
-        capPerTurn: { limit: 8, turnIndex: delivery.generation },
-        ledgerKind: outcome === "delivery-failed" ? "test-runner-delivery" : undefined,
-        reason: `test runner delivery ${outcome}`,
-    });
-}
-function prunePending() {
-    while (pending.size > MAX_PENDING_DELIVERIES) {
-        const oldest = pending.keys().next();
-        if (oldest.done)
-            return;
-        pending.delete(oldest.value);
-    }
-}
-/** Stage the newest result for this session. Clean results supersede failures. */
-export function stageTestRunnerDelivery(args) {
-    const deliveryKey = key(args.cwd, args.sessionId, args.owner?.ownerId);
-    const prior = pending.get(deliveryKey);
-    if (prior && prior.generation > args.generation) {
-        const superseded = {
-            cwd: args.cwd,
-            sessionId: args.sessionId,
-            ownerId: args.owner?.ownerId,
-            generation: args.generation,
-            targetCount: args.targetCount,
-            createdAt: Date.now(),
-            eligible: false,
-            owner: args.owner,
-        };
-        record(deliveryKey, "superseded", superseded, {
-            currentGeneration: prior.generation,
-        });
-        return;
-    }
-    if (!args.hasFindings) {
-        if (prior) {
-            pending.delete(deliveryKey);
-            record(deliveryKey, "superseded", {
-                ...prior,
-                targetCount: args.targetCount,
-                generation: args.generation,
-            });
-        }
-        return;
-    }
-    const delivery = {
-        cwd: args.cwd,
-        sessionId: args.sessionId,
-        ownerId: args.owner?.ownerId,
-        generation: args.generation,
-        targetCount: args.targetCount,
-        createdAt: Date.now(),
-        eligible: false,
-        owner: args.owner,
-    };
-    pending.set(deliveryKey, delivery);
-    prunePending();
-    record(deliveryKey, "staged", delivery);
-}
-/** Mark the latest staged result eligible during a host-confirmed idle window. */
-export function deliverTestRunnerFindings(args) {
-    const cwd = args.ctx.cwd ?? process.cwd();
-    const deliveryKey = key(cwd, args.sessionId, args.ownerId);
-    const delivery = pending.get(deliveryKey);
-    if (!delivery)
-        return;
-    const currentGeneration = args.cacheManager.readCache("test-runner-findings", cwd)?.data?.testRunGeneration;
-    if (currentGeneration !== undefined &&
-        currentGeneration > delivery.generation) {
-        pending.delete(deliveryKey);
-        record(deliveryKey, "superseded", delivery, { currentGeneration });
-        return;
-    }
-    if (typeof args.ctx.isIdle !== "function") {
-        pending.delete(deliveryKey);
-        return;
-    }
-    try {
-        if (!args.ctx.isIdle()) {
-            record(deliveryKey, "carried", delivery);
-            return;
-        }
-    }
-    catch (error) {
-        record(deliveryKey, "delivery-failed", delivery, {
-            error: String(error).slice(0, 500),
-        });
-        return;
-    }
-    if (!peekTestFindings(args.cacheManager, cwd, args.runtime, true)) {
-        pending.delete(deliveryKey);
-        record(deliveryKey, "superseded", delivery);
-        return;
-    }
-    // Recheck immediately before marking eligible. The host may accept a prompt
-    // between the first check and this synchronous call.
-    try {
-        if (!args.ctx.isIdle()) {
-            record(deliveryKey, "carried", delivery);
-            return;
-        }
-    }
-    catch (error) {
-        record(deliveryKey, "delivery-failed", delivery, {
-            error: String(error).slice(0, 500),
-        });
-        return;
-    }
-    delivery.eligible = true;
-    const current = args.cacheManager.readCache("test-runner-findings", cwd)?.data;
-    if (!current?.content || current.testRunGeneration !== delivery.generation) {
-        pending.delete(deliveryKey);
-        return;
-    }
-    args.cacheManager.writeCache("test-runner-findings", {
-        ...current,
-        deliveryEligible: {
-            sessionId: delivery.sessionId,
-            generation: delivery.generation,
-            eligibleAt: Date.now(),
-        },
-    }, cwd);
-    record(deliveryKey, "eligible", delivery, {
-        ageMs: Math.max(0, Date.now() - delivery.createdAt),
-    });
-}
-/** Deliver only the result staged by this activation and settled session. */
-export function deliverStagedTestRunnerFindings(args) {
-    if (!args?.cwd || !args.ownerId)
-        return;
-    const delivery = args.sessionId
-        ? pending.get(key(args.cwd, args.sessionId, args.ownerId))
-        : [...pending.values()]
-            .reverse()
-            .find((candidate) => candidate.cwd === args.cwd && candidate.ownerId === args.ownerId);
-    if (!delivery?.owner)
-        return;
-    deliverTestRunnerFindings({
-        ctx: delivery.owner.getCtx(),
-        cacheManager: delivery.owner.cacheManager,
-        runtime: delivery.owner.runtime,
-        sessionId: delivery.sessionId,
-        ownerId: delivery.ownerId,
-    });
-}
-/** Consume the result made eligible by the settled idle boundary. */
-export function consumeStagedTestRunnerFindings(args) {
-    const deliveryKey = key(args.cwd, args.sessionId, args.ownerId);
-    let delivery = pending.get(deliveryKey);
-    const persisted = args.cacheManager.readCache("test-runner-findings", args.cwd)?.data;
-    const eligible = persisted?.deliveryEligible;
-    if (!delivery && persisted?.content && eligible) {
-        const sameSession = eligible.sessionId === args.sessionId;
-        if (!sameSession) {
-            const foreignDelivery = {
-                cwd: args.cwd,
-                sessionId: eligible.sessionId,
-                generation: eligible.generation,
-                targetCount: 0,
-                createdAt: eligible.eligibleAt,
-                eligible: true,
-                rehydrated: true,
-            };
-            record(deliveryKey, "foreign-session", foreignDelivery, {
-                currentSessionId: args.sessionId,
-                currentOwnerId: args.ownerId,
-                reason: "session-mismatch",
-            });
-            return undefined;
-        }
-        delivery = {
-            cwd: args.cwd,
-            sessionId: args.sessionId,
-            ownerId: args.ownerId,
-            generation: eligible.generation,
-            targetCount: 0,
-            createdAt: eligible.eligibleAt,
-            eligible: true,
-            rehydrated: true,
-        };
-        pending.set(deliveryKey, delivery);
-    }
-    if (!delivery?.eligible)
-        return undefined;
-    const currentGeneration = persisted?.testRunGeneration;
-    if (currentGeneration !== delivery.generation) {
-        pending.delete(deliveryKey);
-        record(deliveryKey, "superseded", delivery, { currentGeneration });
-        return undefined;
-    }
-    logDeliveredVerdicts(args.cacheManager, args.cwd, args.runtime, delivery);
-    const findings = consumeTestFindings(args.cacheManager, args.cwd, args.runtime);
-    if (!findings) {
-        pending.delete(deliveryKey);
-        record(deliveryKey, "superseded", delivery);
-        return undefined;
-    }
-    pending.delete(deliveryKey);
-    record(deliveryKey, "delivered", delivery, {
-        ageMs: Math.max(0, Date.now() - delivery.createdAt),
-        rehydrated: delivery.rehydrated === true,
-    });
-    return findings;
-}
-/** Test-only reset; session ownership prevents cross-session consumption. */
-export function _resetTestRunnerDeliveryForTests() {
-    pending.clear();
-}
-/** Clear staged results when a primary session replaces the owning runtime. */
-export function resetTestRunnerDelivery() {
-    pending.clear();
-}

package/dist/clients/todo-scanner.js

@@ -1,229 +0,0 @@
-/**
- * TODO Scanner for pi-local.
- *
- * Scans codebase for TODO, FIXME, HACK, XXX, and BUG annotations.
- * Helps understand what's already flagged as problematic or incomplete.
- *
- * No dependencies required — uses regex scanning.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { collectSourceFiles } from "./source-filter.js";
-// --- Scanner ---
-/**
- * Per-file size cap (#894 review, defense in depth): broadened enumeration can
- * surface large data files that slip past generated-artifact filtering, and a
- * multi-MB read + regex sweep per file on session start is exactly the stall
- * this scanner must avoid. 512 KiB matches word-index's WORD_INDEX_MAX_BYTES
- * precedent — hand-written source is essentially never larger.
- */
-const MAX_SCAN_FILE_BYTES = 512 * 1024;
-const MARKDOWN_FILE_RE = /\.(?:md|mdx|markdown)$/i;
-export class TodoScanner {
-    /**
-     * Pattern matches actionable annotations only.
-     * Excludes NOTE and DEPRECATED — these are documentation, not work items.
-     * Case-sensitive to avoid matching "Note:" in prose.
-     */
-    pattern = /\b(TODO|FIXME|HACK|XXX|BUG)\b\s*[(:]?\s*(.+)/g;
-    /**
-     * Check if a match position is inside a comment context.
-     * Handles: // line comments, star-slash block comments, * JSDoc lines, # Python comments
-     */
-    isInComment(line, matchIndex, markdown = false) {
-        if (markdown) {
-            // Markdown has no '#'/'//' comments — '# TODO refactor' is a section
-            // heading, not a flagged work item (#894 review: .md files are now
-            // enumerated). Only HTML comments (<!-- TODO: … -->) count.
-            const beforeMatch = line.slice(0, matchIndex);
-            const open = beforeMatch.lastIndexOf("<!--");
-            return open !== -1 && beforeMatch.lastIndexOf("-->") < open;
-        }
-        const trimmed = line.trimStart();
-        // Line starts with comment markers — entire line is a comment
-        if (/^\/\/|^\/\*|^\*|^#/.test(trimmed))
-            return true;
-        // Check if there's a // before the match position (not inside a string)
-        const beforeMatch = line.slice(0, matchIndex);
-        const lineCommentPos = beforeMatch.lastIndexOf("//");
-        if (lineCommentPos !== -1) {
-            // Count quotes before // to see if it's inside a string
-            const beforeComment = beforeMatch.slice(0, lineCommentPos);
-            const singleQuotes = (beforeComment.match(/'/g) || []).length;
-            const doubleQuotes = (beforeComment.match(/"/g) || []).length;
-            const backticks = (beforeComment.match(/`/g) || []).length;
-            if (singleQuotes % 2 === 0 &&
-                doubleQuotes % 2 === 0 &&
-                backticks % 2 === 0) {
-                return true;
-            }
-        }
-        // Check for /* ... */ block comment before match
-        const blockOpen = beforeMatch.lastIndexOf("/*");
-        const blockClose = beforeMatch.lastIndexOf("*/");
-        if (blockOpen !== -1 && blockClose < blockOpen)
-            return true;
-        // Check for # comment (Python)
-        const hashPos = beforeMatch.lastIndexOf("#");
-        if (hashPos !== -1) {
-            const beforeHash = beforeMatch.slice(0, hashPos);
-            const singleQuotes = (beforeHash.match(/'/g) || []).length;
-            const doubleQuotes = (beforeHash.match(/"/g) || []).length;
-            if (singleQuotes % 2 === 0 && doubleQuotes % 2 === 0) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Scan a single file for TODOs.
-     */
-    scanFile(filePath) {
-        const absolutePath = path.resolve(filePath);
-        // Size gate before the read (#894 review): a lockfile-sized data file
-        // must never pay a full read + per-line regex sweep. statSync doubles as
-        // the existence check.
-        try {
-            const stat = fs.statSync(absolutePath);
-            if (!stat.isFile() || stat.size > MAX_SCAN_FILE_BYTES)
-                return [];
-        }
-        catch {
-            return [];
-        }
-        let content;
-        try {
-            content = fs.readFileSync(absolutePath, "utf-8");
-        }
-        catch {
-            return [];
-        }
-        const markdown = MARKDOWN_FILE_RE.test(absolutePath);
-        const lines = content.split("\n");
-        const items = [];
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const matches = line.matchAll(this.pattern);
-            for (const match of matches) {
-                // Skip matches that aren't inside comments
-                if (!this.isInComment(line, match.index ?? 0, markdown))
-                    continue;
-                const type = match[1];
-                const message = (match[2] || "").trim().replace(/\s*\*\/\s*$/, ""); // Strip closing comment
-                items.push({
-                    type,
-                    message: message.slice(0, 200), // Limit message length
-                    file: path.relative(process.cwd(), absolutePath),
-                    line: i + 1,
-                    column: match.index || 0,
-                });
-            }
-        }
-        return items;
-    }
-    /**
-     * Scan a list of pre-filtered files (recommended — uses source-filter module).
-     * Callers should use collectSourceFiles() to get deduplicated source files.
-     */
-    scanFiles(filePaths) {
-        const items = [];
-        for (const filePath of filePaths) {
-            // Skip this scanner file — its own type literals and regex cause false positives
-            if (filePath.endsWith("todo-scanner.ts") ||
-                filePath.endsWith("todo-scanner.js"))
-                continue;
-            // Skip test files — intentional annotations are test fixtures, not work items
-            if (/\.(test|spec)\.[jt]sx?$/.test(filePath))
-                continue;
-            items.push(...this.scanFile(filePath));
-        }
-        return this.groupResults(items);
-    }
-    /**
-     * Scan a directory recursively using the source-filter module to exclude build artifacts.
-     * This is the preferred entry point for new callers.
-     */
-    scanDirectory(dirPath) {
-        // Use source-filter to collect only source files (no build artifacts).
-        // #760: the walk is bounded by source-filter's default visited-entry
-        // budget (DEFAULT_MAX_SCAN_ENTRIES) — on a pathological mixed tree this
-        // sync call gets a truncated best-effort list instead of blocking its
-        // caller for a full-tree walk; a partial TODO sweep is acceptable here.
-        const sourceFiles = collectSourceFiles(dirPath);
-        return this.scanFiles(sourceFiles);
-    }
-    /**
-     * Group scan results by type and file.
-     */
-    groupResults(items) {
-        // Group by type
-        const byType = new Map();
-        for (const item of items) {
-            const existing = byType.get(item.type) || [];
-            existing.push(item);
-            byType.set(item.type, existing);
-        }
-        // Group by file
-        const byFile = new Map();
-        for (const item of items) {
-            const existing = byFile.get(item.file) || [];
-            existing.push(item);
-            byFile.set(item.file, existing);
-        }
-        return { items, byType, byFile };
-    }
-    /**
-     * Format scan results for LLM consumption.
-     */
-    formatResult(result, maxItems = 30) {
-        if (result.items.length === 0)
-            return "";
-        let output = `[TODOs] ${result.items.length} annotation(s) found`;
-        // Summary by type
-        const typeCounts = [];
-        for (const [type, items] of result.byType) {
-            typeCounts.push(`${items.length} ${type}`);
-        }
-        if (typeCounts.length > 0) {
-            output += ` (${typeCounts.join(", ")})`;
-        }
-        output += ":\n";
-        // Show by priority: FIXME/HACK first, then TODO
-        const priorityOrder = [
-            "FIXME",
-            "HACK",
-            "BUG",
-            "TODO",
-            "XXX",
-        ];
-        const sorted = [...result.items].sort((a, b) => {
-            const aIdx = priorityOrder.indexOf(a.type);
-            const bIdx = priorityOrder.indexOf(b.type);
-            return (aIdx === -1 ? 99 : aIdx) - (bIdx === -1 ? 99 : bIdx);
-        });
-        for (const item of sorted.slice(0, maxItems)) {
-            const icon = this.getIcon(item.type);
-            output += `  ${icon} ${item.file}:${item.line} — ${item.type}: ${item.message}\n`;
-        }
-        if (result.items.length > maxItems) {
-            output += `  ... and ${result.items.length - maxItems} more\n`;
-        }
-        return output;
-    }
-    getIcon(type) {
-        switch (type) {
-            case "FIXME":
-                return "🔴";
-            case "HACK":
-                return "🟠";
-            case "BUG":
-                return "🐛";
-            case "TODO":
-                return "📝";
-            case "XXX":
-                return "❌";
-            default:
-                return "•";
-        }
-    }
-}