@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/chunk-2BEMIWEW.js

@@ -0,0 +1,51 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/clients/project-snapshot-fingerprint.js
+import { createHash } from "node:crypto";
+var QUOTE = 34;
+var BACKSLASH = 92;
+var OPEN_BRACE = 123;
+var CLOSE_BRACE = 125;
+function fingerprintProjectSnapshotJson(json, generatedAt) {
+  const bytes = typeof json === "string" ? Buffer.from(json) : Buffer.from(json.buffer, json.byteOffset, json.byteLength);
+  const marker = Buffer.from(`"generatedAt":${JSON.stringify(generatedAt)}`);
+  let markerIndex = -1;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < bytes.length; index++) {
+    const byte = bytes[index];
+    if (inString) {
+      if (escaped)
+        escaped = false;
+      else if (byte === BACKSLASH)
+        escaped = true;
+      else if (byte === QUOTE)
+        inString = false;
+      continue;
+    }
+    if (byte === QUOTE) {
+      if (depth === 1 && index + marker.length <= bytes.length && bytes.compare(marker, 0, marker.length, index, index + marker.length) === 0) {
+        markerIndex = index;
+        break;
+      }
+      inString = true;
+    } else if (byte === OPEN_BRACE)
+      depth++;
+    else if (byte === CLOSE_BRACE)
+      depth--;
+  }
+  const hash = createHash("sha256");
+  if (markerIndex < 0) {
+    hash.update(bytes);
+  } else {
+    hash.update(bytes.subarray(0, markerIndex));
+    hash.update('"generatedAt":""');
+    hash.update(bytes.subarray(markerIndex + marker.length));
+  }
+  return hash.digest("hex");
+}
+
+export {
+  fingerprintProjectSnapshotJson
+};

package/node_modules/pi-lens/dist/chunk-2EECBNC5.js

@@ -0,0 +1,89 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  stagePathFor
+} from "./chunk-LJDODBBZ.js";
+
+// dist/clients/atomic-write.js
+import * as fs from "node:fs";
+function writeFileAtomic(targetPath, data, options) {
+  const bestEffort = options?.bestEffort ?? true;
+  const tmpPath = stagePathFor(targetPath);
+  try {
+    fs.writeFileSync(tmpPath, data, {
+      encoding: typeof data === "string" ? "utf-8" : void 0,
+      mode: options?.mode
+    });
+    fs.renameSync(tmpPath, targetPath);
+  } catch (err) {
+    try {
+      fs.rmSync(tmpPath, { force: true });
+    } catch {
+    }
+    if (!bestEffort)
+      throw err;
+  }
+}
+async function writeFileAtomicAsync(targetPath, data, options) {
+  const bestEffort = options?.bestEffort ?? true;
+  const tmpPath = stagePathFor(targetPath);
+  try {
+    await fs.promises.writeFile(tmpPath, data, {
+      encoding: typeof data === "string" ? "utf-8" : void 0,
+      mode: options?.mode
+    });
+    await fs.promises.rename(tmpPath, targetPath);
+  } catch (err) {
+    try {
+      await fs.promises.rm(tmpPath, { force: true });
+    } catch {
+    }
+    if (!bestEffort)
+      throw err;
+  }
+}
+
+// dist/clients/spawn-output-cap.js
+var DEFAULT_MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+function createBoundedOutputSink(maxBytes = DEFAULT_MAX_OUTPUT_BYTES) {
+  let text = "";
+  let retained = 0;
+  let truncated = false;
+  let observed = 0;
+  return {
+    append(chunk) {
+      const part = typeof chunk === "string" ? chunk : chunk.toString();
+      const bytes = Buffer.byteLength(part);
+      observed += bytes;
+      if (retained + bytes <= maxBytes) {
+        retained += bytes;
+        text += part;
+        return;
+      }
+      truncated = true;
+    },
+    get text() {
+      return text;
+    },
+    get truncated() {
+      return truncated;
+    },
+    get observedBytes() {
+      return observed;
+    }
+  };
+}
+function truncatedByOutputCap(result) {
+  return result.outputTruncated === true && result.failure !== "timeout" && result.failure !== "aborted";
+}
+function killedForOutputCap(result) {
+  return result.killedForOutputCap === true && result.failure !== "timeout" && result.failure !== "aborted";
+}
+
+export {
+  writeFileAtomic,
+  writeFileAtomicAsync,
+  DEFAULT_MAX_OUTPUT_BYTES,
+  createBoundedOutputSink,
+  truncatedByOutputCap,
+  killedForOutputCap
+};

package/node_modules/pi-lens/dist/chunk-34U7PLGE.js

@@ -0,0 +1,23 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  computeImpactCascade,
+  computeTransitiveImpact
+} from "./chunk-E2WFBRHM.js";
+import "./chunk-V7R425XG.js";
+import "./chunk-PAK6IDME.js";
+import "./chunk-VN2AXLEX.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-N3YQJI6O.js";
+import "./chunk-O6TQT6RI.js";
+import "./chunk-5THXD6X5.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  computeImpactCascade,
+  computeTransitiveImpact
+};

package/node_modules/pi-lens/dist/chunk-3I5QFT3N.js

@@ -0,0 +1,181 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  isUnderDir,
+  normalizeFilePath,
+  pathsEqual,
+  walkUpDirs
+} from "./chunk-Q5U6FMDI.js";
+
+// dist/clients/review-graph/git-identity.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { dirname, join as join2, resolve as resolve2 } from "node:path";
+function createGitIdentityResolver() {
+  const memo = /* @__PURE__ */ new Map();
+  return (cwd) => {
+    if (memo.has(cwd))
+      return memo.get(cwd);
+    const identity = resolveGitIdentity(cwd);
+    memo.set(cwd, identity);
+    return identity;
+  };
+}
+function readCommonDir(gitDir) {
+  try {
+    const raw = fs.readFileSync(path.join(gitDir, "commondir"), "utf-8").trim();
+    if (!raw)
+      return gitDir;
+    return path.isAbsolute(raw) ? raw : path.resolve(gitDir, raw);
+  } catch {
+    return gitDir;
+  }
+}
+function resolveGitDir(cwd) {
+  for (const dir of walkUpDirs(cwd)) {
+    const gitPath = path.join(dir, ".git");
+    let stat;
+    try {
+      stat = fs.statSync(gitPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      return {
+        gitDir: gitPath,
+        commonDir: readCommonDir(gitPath),
+        worktreeRoot: dir
+      };
+    }
+    if (stat.isFile()) {
+      try {
+        const contents = fs.readFileSync(gitPath, "utf-8").trim();
+        const match = contents.match(/^gitdir:\s*(.+)$/);
+        if (!match)
+          return null;
+        const linkedGitDir = path.isAbsolute(match[1]) ? match[1] : path.resolve(dir, match[1]);
+        if (!fs.statSync(linkedGitDir).isDirectory())
+          return null;
+        return {
+          gitDir: linkedGitDir,
+          commonDir: readCommonDir(linkedGitDir),
+          worktreeRoot: dir
+        };
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function getResolvedGitDir(cwd) {
+  let resolved;
+  try {
+    resolved = resolveGitDir(cwd);
+  } catch {
+    resolved = null;
+  }
+  return resolved;
+}
+function canonicalDirectory(dir) {
+  try {
+    return fs.realpathSync.native(dir);
+  } catch {
+    return dir;
+  }
+}
+function resolveGitCheckout(startPath) {
+  const resolved = getResolvedGitDir(startPath);
+  return resolved ? {
+    root: canonicalDirectory(resolved.worktreeRoot),
+    spelledRoot: resolved.worktreeRoot,
+    commonDir: canonicalDirectory(resolved.commonDir)
+  } : null;
+}
+function resolveLinkedWorktreeOwner(session, absoluteFile) {
+  const owner = resolveGitCheckout(dirname(absoluteFile));
+  return owner !== null && !pathsEqual(owner.root, session.root) && pathsEqual(owner.commonDir, session.commonDir) ? owner : null;
+}
+function listLinkedWorktreeRoots(commonDir) {
+  const roots = [];
+  let names;
+  try {
+    names = fs.readdirSync(join2(commonDir, "worktrees"));
+  } catch {
+    return roots;
+  }
+  for (const name of names) {
+    try {
+      const entryDir = join2(commonDir, "worktrees", name);
+      const gitFile = fs.readFileSync(join2(entryDir, "gitdir"), "utf-8").trim();
+      if (gitFile)
+        roots.push(canonicalDirectory(dirname(resolve2(entryDir, gitFile))));
+    } catch {
+    }
+  }
+  return roots;
+}
+function listNestedLinkedWorktreeRoots(scanRoot) {
+  const checkout = resolveGitCheckout(scanRoot);
+  if (!checkout)
+    return [];
+  const base = canonicalDirectory(scanRoot);
+  const nested = [];
+  for (const root of listLinkedWorktreeRoots(checkout.commonDir)) {
+    if (!pathsEqual(root, base) && isUnderDir(root, base))
+      nested.push(root);
+  }
+  return nested;
+}
+function resolveRefToSha(commonDir, ref) {
+  try {
+    const loose = fs.readFileSync(path.join(commonDir, ref), "utf-8").trim();
+    if (loose)
+      return loose;
+  } catch {
+  }
+  try {
+    const packed = fs.readFileSync(path.join(commonDir, "packed-refs"), "utf-8");
+    for (const line of packed.split("\n")) {
+      if (line.startsWith("#") || line.startsWith("^") || !line.trim())
+        continue;
+      const [sha, packedRef] = line.trim().split(/\s+/, 2);
+      if (packedRef === ref)
+        return sha;
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveGitIdentity(cwd) {
+  try {
+    const resolved = getResolvedGitDir(cwd);
+    if (!resolved)
+      return void 0;
+    const headRaw = fs.readFileSync(path.join(resolved.gitDir, "HEAD"), "utf-8").trim();
+    const refMatch = headRaw.match(/^ref:\s*(.+)$/);
+    let headCommit;
+    if (refMatch) {
+      headCommit = resolveRefToSha(resolved.commonDir, refMatch[1].trim());
+    } else {
+      headCommit = /^[0-9a-f]{7,40}$/i.test(headRaw) ? headRaw : null;
+    }
+    if (!headCommit)
+      return void 0;
+    return {
+      headCommit,
+      worktreeRoot: normalizeFilePath(resolved.worktreeRoot)
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  createGitIdentityResolver,
+  canonicalDirectory,
+  resolveGitCheckout,
+  resolveLinkedWorktreeOwner,
+  listNestedLinkedWorktreeRoots,
+  resolveGitIdentity
+};

package/node_modules/pi-lens/dist/chunk-3MED75HT.js

@@ -0,0 +1,37 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/clients/review-graph/symbol-id.js
+function buildSymbolId(filePath, name, kind, startLine) {
+  return `${filePath}:${name}:${kind}:${startLine}`;
+}
+var KIND_TOKEN_RE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+function parseSymbolKey(key, knownFilePath) {
+  if (key.startsWith("file:")) {
+    return { filePath: key.slice("file:".length) };
+  }
+  const canonical = /^(.*):([^:]*):([^:]+):(\d+)$/.exec(key);
+  if (canonical && KIND_TOKEN_RE.test(canonical[3])) {
+    return {
+      filePath: canonical[1],
+      symbolName: canonical[2] || void 0,
+      kind: canonical[3],
+      line: Number(canonical[4])
+    };
+  }
+  if (knownFilePath && key.startsWith(`${knownFilePath}:`)) {
+    return {
+      filePath: knownFilePath,
+      symbolName: key.slice(knownFilePath.length + 1) || void 0
+    };
+  }
+  const separator = key.lastIndexOf(":");
+  return separator < 0 ? { filePath: key } : {
+    filePath: key.slice(0, separator),
+    symbolName: key.slice(separator + 1) || void 0
+  };
+}
+
+export {
+  buildSymbolId,
+  parseSymbolKey
+};

package/node_modules/pi-lens/dist/chunk-47D2BO4S.js

@@ -0,0 +1,87 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  parseSymbolKey
+} from "./chunk-NKOUFPQF.js";
+import {
+  isTestRoleCollateral
+} from "./chunk-I3R7GKDR.js";
+import "./chunk-3MED75HT.js";
+import "./chunk-VN2AXLEX.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-N3YQJI6O.js";
+import "./chunk-O6TQT6RI.js";
+import "./chunk-5THXD6X5.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+
+// dist/clients/project-diagnostics/runner-adapters/call-graph-impact.js
+import * as path from "node:path";
+function resolveImpactFile(cwd, filePath) {
+  return path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+}
+function displayName(key) {
+  return parseSymbolKey(key).symbolName ?? key;
+}
+function severityFor(severity) {
+  if (severity === "WillBreak") {
+    return {
+      severity: "warning",
+      message: "Direct caller of a symbol edited this turn \u2014 verify this call site still matches its new signature/behavior."
+    };
+  }
+  if (severity === "MayBreak") {
+    return {
+      severity: "info",
+      message: "Indirect caller (one hop) of a symbol edited this turn \u2014 worth a quick check."
+    };
+  }
+  return null;
+}
+var SEVERITY_RANK = {
+  error: 3,
+  warning: 2,
+  info: 1,
+  hint: 0
+};
+function callGraphImpactToProjectDiagnostics(cwd, findings) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const { calleeKey, results } of findings) {
+    const calleeName = displayName(calleeKey);
+    for (const result of results) {
+      const mapped = severityFor(result.severity);
+      if (!mapped)
+        continue;
+      const { filePath } = parseSymbolKey(result.symbolKey);
+      if (!filePath)
+        continue;
+      const resolvedFile = resolveImpactFile(cwd, filePath);
+      if (isTestRoleCollateral(resolvedFile))
+        continue;
+      const dedupeKey = `${resolvedFile}:${result.symbolKey}`;
+      const existing = byKey.get(dedupeKey);
+      if (existing && SEVERITY_RANK[existing.severity] >= SEVERITY_RANK[mapped.severity]) {
+        continue;
+      }
+      const callerName = displayName(result.symbolKey);
+      byKey.set(dedupeKey, {
+        filePath: resolvedFile,
+        severity: mapped.severity,
+        semantic: "warning",
+        tool: "call-graph",
+        runner: "call-graph",
+        rule: `call-graph:${result.severity.toLowerCase()}`,
+        message: `${mapped.message} (${callerName} calls edited symbol '${calleeName}')`,
+        source: "project-scan"
+      });
+    }
+  }
+  return [...byKey.values()];
+}
+export {
+  callGraphImpactToProjectDiagnostics
+};