pi-lens 4.3.0 → 4.4.1

package/dist/chunk-ELVWJYRV.js

@@ -0,0 +1,211 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  collectSourceFiles
+} from "./chunk-USHG4DLH.js";
+import "./chunk-H5EV3VMF.js";
+import "./chunk-T54VJRAD.js";
+import "./chunk-QYF5S6P6.js";
+import "./chunk-64LU2OVH.js";
+import "./chunk-N2IRDBZI.js";
+import "./chunk-Z6BB4JLQ.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-7ELY2CSM.js";
+import "./chunk-34OCDWOS.js";
+import "./chunk-3PNFWVHT.js";
+import "./chunk-VSMJK3ZJ.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-G3RLJYA2.js";
+import "./chunk-NXL4FFQQ.js";
+
+// dist/clients/todo-scanner.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var MAX_SCAN_FILE_BYTES = 512 * 1024;
+var MARKDOWN_FILE_RE = /\.(?:md|mdx|markdown)$/i;
+var TodoScanner = class {
+  /**
+   * 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) {
+      const beforeMatch2 = line.slice(0, matchIndex);
+      const open = beforeMatch2.lastIndexOf("<!--");
+      return open !== -1 && beforeMatch2.lastIndexOf("-->") < open;
+    }
+    const trimmed = line.trimStart();
+    if (/^\/\/|^\/\*|^\*|^#/.test(trimmed))
+      return true;
+    const beforeMatch = line.slice(0, matchIndex);
+    const lineCommentPos = beforeMatch.lastIndexOf("//");
+    if (lineCommentPos !== -1) {
+      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;
+      }
+    }
+    const blockOpen = beforeMatch.lastIndexOf("/*");
+    const blockClose = beforeMatch.lastIndexOf("*/");
+    if (blockOpen !== -1 && blockClose < blockOpen)
+      return true;
+    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);
+    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) {
+        if (!this.isInComment(line, match.index ?? 0, markdown))
+          continue;
+        const type = match[1];
+        const message = (match[2] || "").trim().replace(/\s*\*\/\s*$/, "");
+        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) {
+      if (filePath.endsWith("todo-scanner.ts") || filePath.endsWith("todo-scanner.js"))
+        continue;
+      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) {
+    const sourceFiles = collectSourceFiles(dirPath);
+    return this.scanFiles(sourceFiles);
+  }
+  /**
+   * Group scan results by type and file.
+   */
+  groupResults(items) {
+    const byType = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const existing = byType.get(item.type) || [];
+      existing.push(item);
+      byType.set(item.type, existing);
+    }
+    const byFile = /* @__PURE__ */ 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`;
+    const typeCounts = [];
+    for (const [type, items] of result.byType) {
+      typeCounts.push(`${items.length} ${type}`);
+    }
+    if (typeCounts.length > 0) {
+      output += ` (${typeCounts.join(", ")})`;
+    }
+    output += ":\n";
+    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} \u2014 ${item.type}: ${item.message}
+`;
+    }
+    if (result.items.length > maxItems) {
+      output += `  ... and ${result.items.length - maxItems} more
+`;
+    }
+    return output;
+  }
+  getIcon(type) {
+    switch (type) {
+      case "FIXME":
+        return "\u{1F534}";
+      case "HACK":
+        return "\u{1F7E0}";
+      case "BUG":
+        return "\u{1F41B}";
+      case "TODO":
+        return "\u{1F4DD}";
+      case "XXX":
+        return "\u274C";
+      default:
+        return "\u2022";
+    }
+  }
+};
+export {
+  TodoScanner
+};

package/dist/chunk-EUT3B22Y.js

@@ -0,0 +1,27 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  RustClient,
+  resetRustAvailability,
+  rustClient
+} from "./chunk-3MRXIJ6I.js";
+import "./chunk-XHSCVSOL.js";
+import "./chunk-CMU4RMJB.js";
+import "./chunk-O7HZX7CA.js";
+import "./chunk-T54VJRAD.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-N2IRDBZI.js";
+import "./chunk-Z6BB4JLQ.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-7ELY2CSM.js";
+import "./chunk-34OCDWOS.js";
+import "./chunk-3PNFWVHT.js";
+import "./chunk-VSMJK3ZJ.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-G3RLJYA2.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  RustClient,
+  resetRustAvailability,
+  rustClient
+};

package/dist/chunk-F5VLZHUW.js

@@ -0,0 +1,146 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  recordDegradationOnce
+} from "./chunk-7ELY2CSM.js";
+
+// dist/clients/deadline-utils.js
+function combineAbortSignals(...signals) {
+  const live = signals.filter((s) => s !== void 0);
+  if (live.length <= 1)
+    return live[0];
+  if (typeof AbortSignal.any === "function")
+    return AbortSignal.any(live);
+  const controller = new AbortController();
+  for (const s of live) {
+    if (s.aborted) {
+      controller.abort(s.reason);
+      break;
+    }
+    s.addEventListener("abort", () => controller.abort(s.reason), {
+      once: true
+    });
+  }
+  return controller.signal;
+}
+function withDeadline(promise, options) {
+  const onTimeout = options.onTimeout ?? "reject";
+  const onReject = options.onReject ?? "propagate";
+  const ms = options.ms ?? (options.deadlineAt !== void 0 ? options.deadlineAt - Date.now() : 0);
+  if (ms <= 0) {
+    promise.catch(() => {
+    });
+    return onTimeout === "undefined" ? Promise.resolve(void 0) : Promise.reject(new Error(`Timeout after ${Math.max(0, ms)}ms`));
+  }
+  const base = onReject === "undefined" ? promise.catch(() => void 0) : promise;
+  if (onReject === "propagate")
+    promise.catch(() => {
+    });
+  let timer;
+  const timeoutPromise = new Promise((resolve, reject) => {
+    timer = setTimeout(() => {
+      if (onTimeout === "undefined")
+        resolve(void 0);
+      else
+        reject(new Error(`Timeout after ${ms}ms`));
+    }, ms);
+  });
+  return Promise.race([base, timeoutPromise]).finally(() => {
+    if (timer)
+      clearTimeout(timer);
+  });
+}
+function withTimeout(promise, timeoutMs) {
+  return withDeadline(promise, { ms: timeoutMs });
+}
+var BOUND_ABORTED = /* @__PURE__ */ Symbol("pi-lens/bounded/aborted");
+async function bounded(promise, options) {
+  const { signal, shutdownSignal, hook, label } = options;
+  const ms = Number.isFinite(options.ms) ? Math.max(0, options.ms) : 0;
+  const startedAt = Date.now();
+  const boxed = promise.then((value) => ({ value }));
+  void boxed.catch(() => {
+  });
+  let cause;
+  let timer;
+  let onCallerAbort;
+  let onShutdownAbort;
+  const abandoned = new Promise((resolve) => {
+    const fire = (reason) => {
+      cause ??= reason;
+      resolve(BOUND_ABORTED);
+    };
+    if (signal?.aborted)
+      return fire("caller-abort");
+    if (shutdownSignal?.aborted)
+      return fire("shutdown");
+    if (ms <= 0)
+      return fire("deadline");
+    timer = setTimeout(() => fire("deadline"), ms);
+    timer.unref?.();
+    onCallerAbort = () => fire("caller-abort");
+    signal?.addEventListener("abort", onCallerAbort, { once: true });
+    if (shutdownSignal) {
+      onShutdownAbort = () => fire("shutdown");
+      shutdownSignal.addEventListener("abort", onShutdownAbort, {
+        once: true
+      });
+    }
+  });
+  try {
+    const settled = await Promise.race([boxed, abandoned]);
+    if (settled !== BOUND_ABORTED)
+      return settled.value;
+    const elapsedMs = Date.now() - startedAt;
+    const fired = cause ?? "deadline";
+    if (fired === "deadline" || fired === "shutdown") {
+      recordDegradationOnce({
+        kind: fired === "deadline" ? "hook-await-exceeded" : "hook-await-abandoned",
+        subject: `${hook}:${label}`,
+        reason: fired === "deadline" ? `exceeded ${ms}ms budget after ${elapsedMs}ms` : `abandoned after ${elapsedMs}ms: session is shutting down (budget ${ms}ms)`,
+        metadata: { hook, label, budgetMs: ms, elapsedMs, cause: fired }
+      });
+    }
+    return void 0;
+  } finally {
+    if (timer !== void 0)
+      clearTimeout(timer);
+    if (onCallerAbort)
+      signal?.removeEventListener("abort", onCallerAbort);
+    if (onShutdownAbort) {
+      shutdownSignal?.removeEventListener("abort", onShutdownAbort);
+    }
+  }
+}
+
+// dist/clients/hook-budgets.js
+var HOOK_WALL_BUDGET_MS = Object.freeze({
+  /** Visible startup work; the user is watching a progress line. */
+  session_start: 5e3,
+  /** Pure bookkeeping — nothing here may await (#2523 contract). */
+  turn_start: 0,
+  /** Measured p50 3687 ms / p90 14246 ms today. The gap IS the issue. */
+  turn_end: 3e3,
+  /** Measured p90 10043 ms today, from one unbounded pipeline re-entry. */
+  agent_end: 1e3,
+  /** The designated place for settled-time sweeps; the widest non-edit budget. */
+  agent_settled: 1e4,
+  /** Read/Grep/Glob/Bash: must never await analyzer bootstrap (AC5). */
+  tool_result_read_only: 500,
+  /** The ONLY path the contract lets block the host, and only this long. */
+  tool_result_edit: 1e4,
+  /** Teardown: spawning or awaiting here aborts libuv (#234). */
+  session_shutdown: 0,
+  /** Synchronous message contribution; the host is blocked on the answer. */
+  context: 0,
+  /** Fork bookkeeping; the session is being replaced under it. */
+  session_before_fork: 0
+});
+var HOOK_BUDGET_KEYS = Object.keys(HOOK_WALL_BUDGET_MS);
+
+export {
+  combineAbortSignals,
+  withDeadline,
+  withTimeout,
+  bounded,
+  HOOK_WALL_BUDGET_MS
+};

package/dist/chunk-FC4RP4I2.js

@@ -0,0 +1,12 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/clients/sanitize.js
+var ANSI_ESCAPE = /\x1b\[[0-9;]*m/g;
+var ANSI_ESCAPE_EXTENDED = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_ESCAPE, "").replace(ANSI_ESCAPE_EXTENDED, "");
+}
+
+export {
+  stripAnsi
+};

package/dist/chunk-FGALODG3.js

@@ -0,0 +1,55 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  truncatedByOutputCap
+} from "./chunk-2EECBNC5.js";
+import {
+  LEDGER_FIELD_MAX
+} from "./chunk-7ELY2CSM.js";
+
+// dist/clients/dispatch/runners/utils/spawn-outcome.js
+function firstOutputLine(text, max = LEDGER_FIELD_MAX) {
+  for (const line of String(text ?? "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    return trimmed.length > max ? `${trimmed.slice(0, max)}\u2026` : trimmed;
+  }
+  return "";
+}
+function classifyRunOutcome(input) {
+  const { result, exitCodes, reportMissing } = input;
+  const status = result.status ?? null;
+  const signal = result.signal ?? null;
+  const output = input.output ?? result.stdout;
+  const base = {
+    status,
+    signal,
+    firstOutputLine: firstOutputLine(result.stderr) || firstOutputLine(result.stdout) || firstOutputLine(result.error?.message),
+    // Evidence carried alongside the verdict, never part of deciding it — the
+    // branches below are byte-for-byte the pre-#2100 rules.
+    outputCapped: truncatedByOutputCap(result)
+  };
+  if (result.error || signal)
+    return { kind: "did-not-run", ...base };
+  if (status === null)
+    return { kind: "did-not-run", ...base };
+  if (reportMissing) {
+    return status === 0 ? { kind: "ran", ...base } : { kind: "report-missing", ...base };
+  }
+  if (status !== 0 && exitCodes && !exitCodes.ran.includes(status)) {
+    return { kind: "rejected-invocation", ...base };
+  }
+  if (status !== 0 && !output?.trim()) {
+    return { kind: "did-not-run", ...base };
+  }
+  return { kind: "ran", ...base };
+}
+function spawnFailedWithNoOutput(result, output = result.stdout) {
+  return classifyRunOutcome({ result, output }).kind !== "ran" && !output?.trim();
+}
+
+export {
+  firstOutputLine,
+  classifyRunOutcome,
+  spawnFailedWithNoOutput
+};