pi-lens 4.3.0 → 4.4.0

package/dist/clients/runtime-config.js

@@ -1,77 +0,0 @@
-/**
- * Central runtime tuning knobs for pipeline/dispatch behavior.
- * Keep these values in one place so behavior is consistent and easy to tune.
- */
-import { toPositiveFinite } from "./env-utils.js";
-import { loadPiLensGlobalConfig } from "./lens-config.js";
-let _runnerTimeoutFloorCache;
-/**
- * Minimum wall-clock budget (ms) for every dispatch runner. Acts as a floor:
- * effective timeout = max(runner.timeoutMs ?? 30_000, runnerTimeoutFloorMs).
- *
- * Resolution order (highest priority first):
- *   1. `dispatch.runnerTimeoutFloorMs` in `~/.pi-lens/config.json`
- *   2. `PI_LENS_RUNNER_TIMEOUT_FLOOR_MS` environment variable
- *   3. 0 (no floor — runner budgets and the 30 s default apply as-is)
- *
- * Lazy + memoized so importing `runtime-config.ts` does not trigger disk IO.
- * The config file is read at most once per process, on first dispatch.
- *
- * @example ~/.pi-lens/config.json
- * ```json
- * { "dispatch": { "runnerTimeoutFloorMs": 180000 } }
- * ```
- *
- * @example env var
- * ```bash
- * PI_LENS_RUNNER_TIMEOUT_FLOOR_MS=180000 pi
- * ```
- */
-export function getRunnerTimeoutFloorMs() {
-    if (_runnerTimeoutFloorCache !== undefined)
-        return _runnerTimeoutFloorCache;
-    const config = loadPiLensGlobalConfig();
-    const configFloor = toPositiveFinite(config?.dispatch?.runnerTimeoutFloorMs);
-    const envFloor = toPositiveFinite(process.env.PI_LENS_RUNNER_TIMEOUT_FLOOR_MS);
-    _runnerTimeoutFloorCache = Math.max(configFloor, envFloor, 0);
-    return _runnerTimeoutFloorCache;
-}
-/**
- * Test-only: clear the memoized floor so a subsequent call re-reads the
- * config file and env var. Use after mutating either in a test.
- */
-export function _resetRunnerTimeoutFloorCacheForTests() {
-    _runnerTimeoutFloorCache = undefined;
-}
-export const RUNTIME_CONFIG = {
-    pipeline: {
-        lspMaxFileBytes: 2 * 1024 * 1024,
-        lspMaxFileLines: 5000,
-        cascadeMaxFiles: 5,
-        cascadeMaxDiagnosticsPerFile: 20,
-        // Hard cap on how long the pipeline will wait for an LSP client to spawn.
-        // Keeps tool_result from blocking the TUI during cold LSP start (e.g.
-        // pyright workspace indexing). The LSP server continues spawning in the
-        // background; subsequent edits get full diagnostics once it is ready.
-        lspSpawnBudgetMs: 5_000,
-    },
-    dispatch: {
-        runnerTimeoutMs: 30_000,
-    },
-    crashNotice: {
-        alwaysShowFirstN: 2,
-        showEveryNth: 5,
-    },
-    reviewGraph: {
-        // Deprecated (#776): no longer read by `review-graph/builder.ts`, which
-        // now derives its fallback from `project-scale.ts`'s `maxProjectFiles`
-        // knob (reproducing this same 1,000 default at the default base). Left
-        // in place only in case an external caller still reads the constant.
-        maxFiles: 1_000,
-        maxFileBytes: 1 * 1024 * 1024,
-    },
-    turnEnd: {
-        maxLines: 20,
-        maxChars: 1000,
-    },
-};

package/dist/clients/runtime-context.js

@@ -1,211 +0,0 @@
-import { provenanceStamp, validateAdvisoryProvenance, } from "./advisory-provenance.js";
-import { logLatency } from "./latency-logger.js";
-import { translateGuidanceToolNames, } from "./tool-config.js";
-// Exported so the Stop-hook bin strips exactly what these bridges prepend.
-export const AUTOMATION_FRAMING = "[pi-lens automated check — not a user request] ";
-// #1432 review (S3b): a multi-file bash write can carry hundreds of changed
-// paths, one `reasons` entry apiece — logging all of them shrinks the
-// smells-rollup tail window (a fixed-size ring) to a handful of these
-// records. Cap what this decision row carries; the full list is never
-// needed for triage, only "how many and roughly what kind".
-const MAX_LOGGED_REASONS = 8;
-function boundedReasons(reasons) {
-    if (reasons.length <= MAX_LOGGED_REASONS)
-        return reasons;
-    return [
-        ...reasons.slice(0, MAX_LOGGED_REASONS),
-        `+${reasons.length - MAX_LOGGED_REASONS} more`,
-    ];
-}
-function logProvenanceDecision(validation, provenance, advisoryKind, cwd) {
-    logLatency({
-        type: "phase",
-        phase: "advisory_provenance_decision",
-        filePath: cwd,
-        durationMs: 0,
-        metadata: {
-            decision: validation.status === "current" ? "current" : "historical",
-            reasons: boundedReasons(validation.reasons),
-            changedPathCount: validation.changedPathCount,
-            provenanceStamp: provenanceStamp(provenance),
-            advisoryKind,
-        },
-    });
-}
-function historicalPrefix(provenance) {
-    return `Historical finding; workspace changed since capture; re-run to confirm. (${provenanceStamp(provenance)})`;
-}
-function historicalTestContent(content, provenance) {
-    return content.startsWith("[from a prior turn")
-        ? content
-        : `${historicalPrefix(provenance)}\n\n${content}`;
-}
-function turnEndMessage(content, current, provenance) {
-    return {
-        role: "user",
-        content: current
-            ? `${AUTOMATION_FRAMING}Address 🔴 blockers before continuing; ℹ️ advisories are informational only.\n\n${content}`
-            : `${AUTOMATION_FRAMING}${historicalPrefix(provenance)}\n\n${content}`,
-    };
-}
-/** Read a turn-end finding without changing its durable delivery state. */
-export function peekTurnEndFindings(cacheManager, cwd, runtime, logDelivery = false) {
-    const findings = cacheManager.readCache("turn-end-findings", cwd);
-    if (!findings?.data?.content || findings.data.consumed === true)
-        return;
-    const validation = validateAdvisoryProvenance(findings.data, cwd, runtime);
-    if (logDelivery)
-        logProvenanceDecision(validation, findings.data.provenance, "turn-end", cwd);
-    if (validation.allFilesDeleted)
-        return;
-    return {
-        messages: [
-            turnEndMessage(findings.data.content, validation.status === "current", findings.data.provenance),
-        ],
-    };
-}
-export function consumeTurnEndFindings(cacheManager, cwd, runtime) {
-    const findings = cacheManager.readCache("turn-end-findings", cwd);
-    if (!findings?.data?.content || findings.data.consumed === true)
-        return;
-    const validation = validateAdvisoryProvenance(findings.data, cwd, runtime);
-    logProvenanceDecision(validation, findings.data.provenance, "turn-end", cwd);
-    // A blocker record is also the opt-in commit gate's durable state. Mark the
-    // context message consumed without deleting the record; clean/advisory-only
-    // records retain the historical consume-and-clear behavior.
-    if (findings.data.hasBlockers === true &&
-        typeof findings.data.sessionId === "string") {
-        cacheManager.writeCache("turn-end-findings", { ...findings.data, consumed: true }, cwd);
-    }
-    else {
-        cacheManager.clearCache("turn-end-findings", cwd);
-    }
-    if (validation.allFilesDeleted)
-        return;
-    return {
-        messages: [
-            turnEndMessage(findings.data.content, validation.status === "current", findings.data.provenance),
-        ],
-    };
-}
-/** Read test findings without consuming them; used by acknowledged IPC delivery. */
-export function peekTestFindings(cacheManager, cwd, runtime, logDelivery = false) {
-    const findings = cacheManager.readCache("test-runner-findings", cwd);
-    if (!findings?.data?.content)
-        return;
-    const validation = validateAdvisoryProvenance(findings.data, cwd, runtime);
-    if (logDelivery)
-        logProvenanceDecision(validation, findings.data.provenance, "test-findings", cwd);
-    if (validation.allFilesDeleted)
-        return;
-    const current = validation.status === "current";
-    return {
-        messages: [
-            {
-                role: "user",
-                content: current
-                    ? `${AUTOMATION_FRAMING}${testFindingsCurrentPrefix(findings.data.runnerErrorOnly)}\n\n${findings.data.content}`
-                    : `${AUTOMATION_FRAMING}${historicalTestContent(findings.data.content, findings.data.provenance)}`,
-            },
-        ],
-    };
-}
-/**
- * #2522: a batch made entirely of RUNNER errors (timeout, missing
- * provider/binary — see `TestRunnerFindingsCache.runnerErrorOnly`) is not a
- * failure the agent introduced, so it must not read as a blocker the way a
- * genuine failing test does.
- */
-function testFindingsCurrentPrefix(runnerErrorOnly) {
-    return runnerErrorOnly
-        ? "Test runner could not complete last turn (advisory — not a failure introduced this turn):"
-        : "Test failures detected last turn — fix before continuing:";
-}
-/**
- * Retire a delivered test-findings record: blank the content, keep everything a
- * delivery does not settle.
- *
- * ONE function, called by both `consumeTestFindings` (the in-process context
- * hook) and `acknowledgeTestFindings` (the MCP Stop-hook commit), because
- * "what survives a retire" is exactly the kind of rule that rots when it is
- * stated twice. It already had: round 2 taught the consume copy to preserve
- * `deferredTargets` and left the acknowledge copy dropping them, and the
- * acknowledge copy is the LIVE Stop-hook path — including the branch where
- * `handleTurnEnd` never runs at all — so on that path the deferral set was
- * wiped before anything could ever dispatch it (#2522 review round 3, F2).
- *
- * What survives, and why:
- *  - `testRunGeneration` — nulling the slot would let a still-in-flight OLDER
- *    batch read `undefined`, pass the strictly-greater suppression check, and
- *    resurrect a consumed one-shot advisory with stale results.
- *  - `deferredTargets` — delivering the advisory says the agent has SEEN the
- *    deferral, not that those targets ran. Dropping the list silently un-defers
- *    them and the cut batch is never finished.
- *  - `retiredTargets` — the session-scoped deferral cap. Dropping it re-arms a
- *    suite already measured as too slow for the batch budget, which puts the
- *    livelock back.
- *
- * An empty-content record peeks as undelivered while keeping all three intact.
- */
-function retireTestFindings(cacheManager, cwd) {
-    const prior = cacheManager.readCache("test-runner-findings", cwd)?.data;
-    cacheManager.writeCache("test-runner-findings", {
-        content: "",
-        testRunGeneration: prior?.testRunGeneration,
-        deferredTargets: prior?.deferredTargets,
-        retiredTargets: prior?.retiredTargets,
-    }, cwd);
-}
-export function consumeTestFindings(cacheManager, cwd, runtime) {
-    const record = cacheManager.readCache("test-runner-findings", cwd);
-    if (!record?.data?.content)
-        return;
-    const findings = peekTestFindings(cacheManager, cwd, runtime, true);
-    if (!findings)
-        return;
-    retireTestFindings(cacheManager, cwd);
-    return findings;
-}
-/** Complete an acknowledged MCP delivery without re-validating or re-rendering it. */
-export function acknowledgeTurnEndFindings(cacheManager, cwd) {
-    const findings = cacheManager.readCache("turn-end-findings", cwd);
-    if (!findings?.data?.content || findings.data.consumed === true)
-        return;
-    if (findings.data.hasBlockers === true &&
-        typeof findings.data.sessionId === "string") {
-        cacheManager.writeCache("turn-end-findings", { ...findings.data, consumed: true }, cwd);
-    }
-    else {
-        cacheManager.clearCache("turn-end-findings", cwd);
-    }
-}
-export function acknowledgeTestFindings(cacheManager, cwd) {
-    const findings = cacheManager.readCache("test-runner-findings", cwd);
-    if (!findings?.data?.content)
-        return;
-    retireTestFindings(cacheManager, cwd);
-}
-export function consumeSessionStartGuidance(cacheManager, cwd, host = "pi") {
-    const guidance = cacheManager.readCache("session-start-guidance", cwd);
-    if (!guidance?.data?.content)
-        return;
-    // Consume by writing empty guidance, not by casting `null` into the entry's
-    // own type. `writeCache` infers its type parameter from `data`, so the cast
-    // bought nothing and claimed the file held a `{ content: string }` when it
-    // held JSON `null`. The producer (`runtime-session.ts`) always writes
-    // `{ content }`, and this reader gates on `data?.content` being non-empty,
-    // so an empty string is the same "already consumed" signal with the type
-    // the entry actually has. Same idiom as `acknowledgeTestFindings` above.
-    cacheManager.writeCache("session-start-guidance", { content: "" }, cwd);
-    return {
-        messages: [
-            {
-                role: "user",
-                // #2535: the stored guidance names pi tools; MCP agents receive
-                // the registry-translated rendering. The stored record keeps
-                // its shape — resolution happens here, at delivery.
-                content: `[pi-lens automated context — not a user request]\n\n${translateGuidanceToolNames(guidance.data.content, host)}`,
-            },
-        ],
-    };
-}