@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/live-bus-emitter.js

@@ -1,74 +0,0 @@
-import { recordDegradation } from "./degradation-ledger.js";
-import { probeCtxActive } from "./session-lifecycle.js";
-import { logBusEvent } from "./bus-events-logger.js";
-const STALE_CTX_MESSAGE = "This extension ctx is stale after session replacement";
-/** Ledger a dead activation once, at the publisher's occurrence-window guard. */
-export function recordStaleBusFailure(subject, error) {
-    const reason = String(error);
-    if (!reason.includes(STALE_CTX_MESSAGE))
-        return;
-    recordDegradation({ kind: "bus-stale", subject, reason });
-}
-export function createLiveBusEmitter() {
-    let emit;
-    let getter;
-    return {
-        wire(next) {
-            emit = next;
-            getter = undefined;
-        },
-        wireGetter(next) {
-            getter = next;
-            emit = undefined;
-        },
-        resolve() {
-            // Invoke the getter for every delivery so session_start rewiring can
-            // replace a captured pre-await activation with the current primary. When
-            // the current target is nevertheless confirmed stale, never invoke it.
-            const target = getter?.() ?? emit;
-            if (!target)
-                return { outcome: "unwired", ctxSource: "unwired" };
-            if (typeof target === "function") {
-                return { outcome: "ready", emit: target, ctxSource: "global-fallback" };
-            }
-            // Object targets are always "own"-sourced (only `wire(fn)`'s bare
-            // function arm is "global-fallback", and it never reaches this
-            // branch) — compute it once so the ready/stale-session outcomes
-            // below both carry the same value instead of restating the
-            // literal independently.
-            const ctxSource = "own";
-            if (probeCtxActive(target.ctx) === false) {
-                return { outcome: "stale-session", ctxSource };
-            }
-            return { outcome: "ready", emit: target.emit, ctxSource };
-        },
-        reset() {
-            emit = undefined;
-            getter = undefined;
-        },
-    };
-}
-/**
- * Resolve through the shared stale-session guard and record a declined
- * target.
- *
- * `entry` is a THUNK, not a value (M1, #1415 review): building the log entry
- * (every producer's version normalizes `cwd` via `normalizeFilePath`, a sync
- * `realpathSync.native` call on Windows and, since #3098, on POSIX too) is
- * real per-publish cost that used
- * to be paid on EVERY call regardless of outcome, even though it is only
- * consumed on the `stale-session` branch. Invoking the thunk only there means
- * the common `ready` path pays nothing for it.
- */
-export function resolveLiveBusEmitter(liveEmitter, entry) {
-    const resolution = liveEmitter.resolve();
-    if (resolution.outcome === "stale-session") {
-        logBusEvent({
-            ...entry(),
-            outcome: "skipped_stale_session",
-            level: "info",
-            ctxSource: resolution.ctxSource,
-        });
-    }
-    return resolution;
-}

package/node_modules/pi-lens/dist/clients/log-cleanup.js

@@ -1,222 +0,0 @@
-/**
- * Log Cleanup Utility — manages log retention and rotation
- *
- * Environment variables:
- *   PI_LENS_LOG_RETENTION_DAYS - Days to keep logs (default: 7)
- *   PI_LENS_MAX_LOG_SIZE_MB    - Max size before rotation (default: 10)
- *
- * Scope:
- *   - ~/.pi-lens/*.log (every global log — see getManagedLogFiles())
- *   - ~/.pi-lens/logs/*.jsonl (daily diagnostic logs)
- *   - ~/.pi-lens/<name>.<timestamp>.log (rotated backups, and legacy .log.<ts>)
- *
- * Excluded (intentionally NOT cleaned - project-scoped or persistent):
- *   - <project-data>/worklog.jsonl                - Agent fixable diagnostics
- *   - <project-data>/code-quality-warnings.jsonl  - Non-fixable warning history
- *   - <project-data>/actionable-warnings.jsonl    - Actionable warning history
- *   - <project-data>/metrics-history.json         - Complexity trends (capped internally)
- *   - <project-data>/reviews/*                    - Code review snapshots
- *   - <project-data>/turn-state.json              - Turn tracking
- *   - <project-data>/fix-session.json             - Active fix sessions
- *   - <project-data>/todo-baseline.json           - TODO baseline
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getGlobalPiLensLogDir } from "./probe-home-state.js";
-import { getRegisteredLogFiles } from "./ndjson-logger.js";
-import { pathsEqual } from "./path-utils.js";
-const LOG_DIR = getGlobalPiLensLogDir();
-const LOGS_SUBDIR = path.join(LOG_DIR, "logs");
-/**
- * Every global `.log` pi-lens writes under ~/.pi-lens, resolved dynamically so
- * rotation and the storage summary can't drift out of sync with what's
- * actually written — that drift is exactly what left
- * actionable-warnings/ast-grep-tools/dead-code, and later bus-events.log,
- * unrotated and growing unbounded.
- *
- * Three sources are unioned:
- *   1. `getRegisteredLogFiles()` — every static-path `createNdjsonLogger`
- *      instance self-registers at construction (module load) time. A brand
- *      new `*-logger.ts` module built on the shared writer is picked up with
- *      zero action here, as long as it's imported before this runs (true for
- *      the whole current codebase — every logger module is statically
- *      imported from index.ts's transitive graph before session start).
- *   2. A direct `~/.pi-lens/*.log` directory read, excluding rotated-backup
- *      names — a defensive backstop in case some future logger module is only
- *      *dynamically* imported and hasn't registered yet when this runs. Once
- *      a file has content on disk, this catches it regardless of import
- *      timing; an unregistered file that doesn't exist yet has nothing to
- *      clean up anyway.
- * `dir` is overridable for tests; production callers use the default
- * (real `~/.pi-lens`).
- */
-export function getManagedLogFiles(dir = LOG_DIR) {
-    const names = new Set();
-    for (const absPath of getRegisteredLogFiles()) {
-        if (pathsEqual(path.dirname(absPath), dir)) {
-            names.add(path.basename(absPath));
-        }
-    }
-    try {
-        if (fs.existsSync(dir)) {
-            for (const entry of fs.readdirSync(dir)) {
-                if (entry.endsWith(".log") && !ROTATED_BACKUP_RE.test(entry)) {
-                    names.add(entry);
-                }
-            }
-        }
-    }
-    catch {
-        // best-effort backstop — registry + straggler list still apply
-    }
-    return [...names].sort((a, b) => a.localeCompare(b));
-}
-/**
- * Matches a rotated backup, never an active log. Rotation writes
- * `name.<ISO-timestamp>.log` (timestamp before the extension); an older shape
- * was `name.log.<timestamp>`. Match both so every backup — whichever version
- * produced it — is reaped by the retention sweep. The active `name.log` has no
- * timestamp segment and no trailing suffix after `.log`, so it never matches.
- */
-export const ROTATED_BACKUP_RE = /(\.\d{4}-\d{2}-\d{2}T.*\.log|\.log\..+)$/;
-/** Rotation threshold for every active `~/.pi-lens/*.log`, in MB. */
-export function getMaxLogSizeMB() {
-    return Math.max(1, Number.parseInt(process.env.PI_LENS_MAX_LOG_SIZE_MB ?? "10", 10) || 10);
-}
-function getConfig() {
-    return {
-        retentionDays: Math.max(1, Number.parseInt(process.env.PI_LENS_LOG_RETENTION_DAYS ?? "7", 10) || 7),
-        maxSizeMB: getMaxLogSizeMB(),
-    };
-}
-function getFileAgeDays(filePath) {
-    try {
-        const stats = fs.statSync(filePath);
-        const ageMs = Date.now() - stats.mtime.getTime();
-        return ageMs / (1000 * 60 * 60 * 24);
-    }
-    catch {
-        return 0;
-    }
-}
-function getFileSizeMB(filePath) {
-    try {
-        const stats = fs.statSync(filePath);
-        return stats.size / (1024 * 1024);
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * Delete files older than retentionDays
- */
-export function cleanupOldLogs(directory, pattern, retentionDays) {
-    const config = getConfig();
-    const maxAge = retentionDays ?? config.retentionDays;
-    const deleted = [];
-    const errors = [];
-    try {
-        if (!fs.existsSync(directory)) {
-            return { deleted, errors };
-        }
-        const files = fs.readdirSync(directory);
-        for (const file of files) {
-            if (!pattern.test(file))
-                continue;
-            const filePath = path.join(directory, file);
-            const ageDays = getFileAgeDays(filePath);
-            if (ageDays > maxAge) {
-                try {
-                    fs.unlinkSync(filePath);
-                    deleted.push(file);
-                }
-                catch (err) {
-                    errors.push(`${file}: ${err}`);
-                }
-            }
-        }
-    }
-    catch (err) {
-        errors.push(`Directory read failed: ${err}`);
-    }
-    return { deleted, errors };
-}
-/**
- * Rotate a log file if it exceeds max size
- */
-export function rotateLogIfNeeded(logFile, maxSizeMB) {
-    const config = getConfig();
-    const maxSize = maxSizeMB ?? config.maxSizeMB;
-    const sizeMB = getFileSizeMB(logFile);
-    if (sizeMB < maxSize) {
-        return { rotated: false };
-    }
-    try {
-        // Create timestamped backup
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const ext = path.extname(logFile);
-        const base = logFile.slice(0, -ext.length);
-        const backupFile = `${base}.${timestamp}${ext}`;
-        // Rename current to backup, create fresh file
-        fs.renameSync(logFile, backupFile);
-        fs.writeFileSync(logFile, "", "utf8");
-        return { rotated: true, newFile: backupFile };
-    }
-    catch {
-        return { rotated: false };
-    }
-}
-/**
- * Main cleanup function - call on session start
- * Cleans up all pi-lens log files based on retention policy
- */
-export function runLogCleanup(dbg) {
-    const config = getConfig();
-    const results = {
-        cleaned: 0,
-        rotated: 0,
-        report: "",
-    };
-    // Cleanup old daily diagnostic logs (*.jsonl)
-    const dailyLogs = cleanupOldLogs(LOGS_SUBDIR, /\.jsonl$/, config.retentionDays);
-    results.cleaned += dailyLogs.deleted.length;
-    // Cleanup old rotated log backups. This sweep runs unconditionally on every
-    // session start, so correcting the pattern self-heals any pre-existing
-    // backlog on the next launch — no separate migration needed. (The prior
-    // `/\.log\./` only matched the legacy `name.log.<ts>` shape, never the
-    // current `name.<ts>.log`, so backups accumulated indefinitely.)
-    const rotatedLogs = cleanupOldLogs(LOG_DIR, ROTATED_BACKUP_RE, config.retentionDays);
-    results.cleaned += rotatedLogs.deleted.length;
-    // Check main logs for rotation
-    const mainLogs = getManagedLogFiles().map((name) => path.join(LOG_DIR, name));
-    for (const logFile of mainLogs) {
-        const rotation = rotateLogIfNeeded(logFile, config.maxSizeMB);
-        if (rotation.rotated) {
-            results.rotated++;
-            if (rotation.newFile) {
-                const sizeMB = getFileSizeMB(rotation.newFile);
-                dbg?.(`log_cleanup: rotated ${path.basename(logFile)} (${sizeMB.toFixed(1)}MB) → ${path.basename(rotation.newFile)}`);
-            }
-        }
-    }
-    // Build report
-    const parts = [];
-    if (dailyLogs.deleted.length > 0) {
-        parts.push(`${dailyLogs.deleted.length} daily logs`);
-    }
-    if (rotatedLogs.deleted.length > 0) {
-        parts.push(`${rotatedLogs.deleted.length} rotated logs`);
-    }
-    if (results.rotated > 0) {
-        parts.push(`${results.rotated} active logs rotated`);
-    }
-    results.report =
-        parts.length > 0
-            ? `log_cleanup: removed ${parts.join(", ")} (retention: ${config.retentionDays}d, maxSize: ${config.maxSizeMB}MB)`
-            : `log_cleanup: no cleanup needed (retention: ${config.retentionDays}d, maxSize: ${config.maxSizeMB}MB)`;
-    if (dailyLogs.errors.length > 0 || rotatedLogs.errors.length > 0) {
-        dbg?.(`log_cleanup errors: ${[...dailyLogs.errors, ...rotatedLogs.errors].join("; ")}`);
-    }
-    return results;
-}

package/node_modules/pi-lens/dist/clients/lsp/aggregation.js

@@ -1,178 +0,0 @@
-/**
- * Diagnostic Aggregation Utilities for pi-lens LSP
- *
- * Provides result-aware racing for multi-client diagnostic collection.
- * Replaces the simple Promise.race + grace window pattern with one that
- * only fires the grace window when a client actually returned diagnostics.
- */
-/**
- * Race a set of promises to completion, resolving as soon as the
- * `shouldComplete` predicate is satisfied by the accumulated results.
- *
- * Key difference from Promise.race: Promise.race resolves when ANY promise
- * settles (even with an empty/useless result). raceToCompletion only resolves
- * early when results meet a quality threshold, optionally with a grace window
- * to let more results accumulate.
- *
- * @param promises - Array of promises producing results
- * @param shouldComplete - Called after each settled promise with all results
- *   accumulated so far. Return true to trigger early completion.
- * @param options.timeoutMs - Hard deadline; after this, resolve with whatever is ready
- * @param options.graceMs - After shouldComplete returns true, wait this many ms
- *   for additional results before finalizing. 0 = finalize immediately.
- * @param options.descriptors - Optional per-promise role descriptors (parallel array
- *   to `promises`). When any descriptor carries `role:"auxiliary"`, an
- *   additional policy applies: once all PRIMARY-role promises settle, auxiliaries
- *   receive `options.auxGraceMs` before the race finalises. Aux results within
- *   that window are included; later arrivals are dropped. When no descriptors
- *   carry `role:"auxiliary"` the aux-grace path is never entered.
- * @param options.auxGraceMs - Ceiling on the grace period given to auxiliary
- *   promises after all primary promises have settled. Only relevant when at
- *   least one descriptor carries `role:"auxiliary"`. Defaults to 500ms. When a
- *   still-pending auxiliary's descriptor carries `budgetMs`, the actual window
- *   is `min(auxGraceMs, max(budgetMs of still-pending auxiliaries))` — see
- *   `PromiseDescriptor.budgetMs`.
- */
-export async function raceToCompletion(promises, shouldComplete, options = { timeoutMs: 1500 }) {
-    const results = [];
-    results.length = promises.length;
-    results.fill(undefined);
-    let graceTimer;
-    let auxGraceTimer;
-    let completed = false;
-    let remaining = promises.length;
-    // Determine which indices are "auxiliary" — only meaningful when at least
-    // one descriptor carries role:"auxiliary". When there are no auxiliaries the
-    // aux-grace code path is never entered (zero overhead on the primary-only
-    // hot path).
-    const descriptors = options.descriptors ?? [];
-    const hasAuxiliaries = descriptors.some((d) => d.role === "auxiliary");
-    const auxIndices = hasAuxiliaries
-        ? new Set(descriptors
-            .map((d, i) => (d.role === "auxiliary" ? i : -1))
-            .filter((i) => i >= 0))
-        : new Set();
-    const primaryCount = promises.length - auxIndices.size;
-    // Track how many PRIMARY promises are still pending. When this reaches 0
-    // we start the aux-grace window (if there are auxiliaries).
-    let primaryRemaining = primaryCount;
-    let auxGraceStarted = false;
-    return new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-            completed = true;
-            if (graceTimer)
-                clearTimeout(graceTimer);
-            if (auxGraceTimer)
-                clearTimeout(auxGraceTimer);
-            resolve(results.filter((r) => r !== undefined));
-        }, options.timeoutMs);
-        const finalize = () => {
-            if (completed)
-                return;
-            completed = true;
-            clearTimeout(timeout);
-            if (graceTimer)
-                clearTimeout(graceTimer);
-            if (auxGraceTimer)
-                clearTimeout(auxGraceTimer);
-            resolve(results.filter((r) => r !== undefined));
-        };
-        const startAuxGrace = () => {
-            if (auxGraceStarted || completed)
-                return;
-            auxGraceStarted = true;
-            const ceilingMs = options.auxGraceMs ?? 500;
-            // #1458 S2: cap the grace window by the still-pending auxiliaries' own
-            // declared budgets, not just the flat ceiling — mirrors touchFile's
-            // per-server `min(declared, ceiling)`.
-            //
-            // This is ONE shared timer, not a deadline per promise, so it grants
-            // every pending auxiliary the window of its slowest pending sibling.
-            // That is safe here only because of an invariant the caller upholds,
-            // not because of anything this function enforces: every promise
-            // `getDiagnostics` passes in is already self-bounded by the same
-            // `strategy.aggregateWaitMs` it declares as `budgetMs`, so a fast
-            // auxiliary resolves on its own deadline long before a slow sibling's
-            // window expires. A caller that passes a promise NOT self-bounded by
-            // its descriptor's `budgetMs` — or one that outlives it, the way
-            // `expectSemanticSecondPush` extends a primary — would get a window
-            // wider than it declared. `PromiseDescriptor` is public, so treat that
-            // as a real constraint on new callers rather than a theoretical one.
-            const pendingAuxBudgets = [...auxIndices]
-                .filter((i) => results[i] === undefined)
-                .map((i) => descriptors[i]?.budgetMs)
-                .filter((b) => typeof b === "number" && b >= 0);
-            const graceMs = pendingAuxBudgets.length > 0
-                ? Math.min(ceilingMs, Math.max(...pendingAuxBudgets))
-                : ceilingMs;
-            if (graceMs <= 0) {
-                finalize();
-                return;
-            }
-            auxGraceTimer = setTimeout(() => finalize(), graceMs);
-        };
-        const check = () => {
-            if (completed)
-                return;
-            if (remaining === 0) {
-                finalize();
-                return;
-            }
-            // Aux-grace: start the aux window when all primaries have settled.
-            // This runs regardless of the shouldComplete predicate — even when
-            // shouldComplete hasn't fired, we don't want slow auxiliaries to block
-            // past the primary-settled moment.
-            if (hasAuxiliaries && primaryRemaining === 0 && !auxGraceStarted) {
-                startAuxGrace();
-                // Don't return — also check shouldComplete in case it triggers its
-                // own grace window simultaneously (the first finalize() wins).
-            }
-            const collected = results.filter((r) => r !== undefined);
-            if (shouldComplete(collected)) {
-                if (options.graceMs !== undefined &&
-                    options.graceMs > 0 &&
-                    !graceTimer) {
-                    // Start quality-grace window — more results may arrive.
-                    // (When aux-grace is also running the first finalize() wins.)
-                    graceTimer = setTimeout(() => finalize(), options.graceMs);
-                }
-                else if (auxGraceStarted) {
-                    // Aux grace is already running — let it conclude naturally.
-                    // The first finalize() wins.
-                }
-                else if (!hasAuxiliaries || primaryRemaining === 0) {
-                    // No aux-grace scenario, OR all primaries have already settled
-                    // (aux-grace either fired or isn't relevant) — finalize now.
-                    finalize();
-                }
-                // Otherwise: auxiliaries exist, primaries haven't all settled yet,
-                // and no quality-grace window is running. Don't finalize — wait for
-                // primaries to settle and let the aux-grace path take over. This
-                // preserves the invariant that primary confirmation is never reported
-                // from a state where the primary hasn't answered (#617/#619).
-            }
-        };
-        for (let i = 0; i < promises.length; i++) {
-            const index = i;
-            const isAux = auxIndices.has(index);
-            promises[i]
-                .then((result) => {
-                if (!completed) {
-                    results[index] = result;
-                    remaining--;
-                    if (!isAux)
-                        primaryRemaining--;
-                    check();
-                }
-            })
-                .catch(() => {
-                if (!completed) {
-                    remaining--;
-                    if (!isAux)
-                        primaryRemaining--;
-                    check();
-                }
-            });
-        }
-    });
-}