@herbertgao/pi-extensions 2026.10.1 → 2026.10.3

package/node_modules/pi-lens/dist/chunk-6UYA642J.js

@@ -0,0 +1,145 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  parseSymbolKey
+} from "./chunk-WW5BLB74.js";
+import "./chunk-3MED75HT.js";
+import {
+  isBuildArtifact
+} from "./chunk-USHG4DLH.js";
+import "./chunk-H5EV3VMF.js";
+import {
+  getProjectDataDir
+} from "./chunk-T54VJRAD.js";
+import "./chunk-QYF5S6P6.js";
+import "./chunk-64LU2OVH.js";
+import {
+  detectFileRole
+} from "./chunk-N2IRDBZI.js";
+import "./chunk-Z6BB4JLQ.js";
+import {
+  writeFileAtomic
+} from "./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 {
+  isExternalOrVendorFile
+} from "./chunk-G3RLJYA2.js";
+import "./chunk-NXL4FFQQ.js";
+
+// dist/clients/codebase-model.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET = 1500;
+var MAX_CALLS_PER_SYMBOL = 10;
+var MIN_IN_DEGREE = 0.5;
+var CODEBASE_MODEL_VERSION = 1;
+function inferKind(symbolKey) {
+  const parsed = parseSymbolKey(symbolKey);
+  if (parsed.kind === "class")
+    return "class";
+  if (parsed.kind === "method" || parsed.symbolName?.includes("."))
+    return "method";
+  return /^[A-Z]/.test(parsed.symbolName ?? "") ? "class" : "function";
+}
+function estimateTokens(entry) {
+  const text = [
+    entry.name,
+    entry.file,
+    entry.calls.join(","),
+    entry.calledBy.join(",")
+  ].join(" ");
+  return Math.ceil(text.length / 4) + 5;
+}
+function buildCodebaseModel(graph, cwd, budget = DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET, identity) {
+  const modelIdentity = identity ?? {
+    reviewGraphVersion: graph.builtAt || "call-graph-unknown",
+    reviewGraphSignature: graph.builtAt || "call-graph-unknown"
+  };
+  const ranked = [...graph.inDegree.entries()].filter(([, score]) => score >= MIN_IN_DEGREE).sort(([, a], [, b]) => b - a);
+  const entries = [];
+  let totalTokens = 0;
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const [calleeKey, inDegree] of ranked) {
+    if (totalTokens >= budget)
+      break;
+    const parsedCallee = parseSymbolKey(calleeKey);
+    const name = parsedCallee.symbolName ?? calleeKey;
+    const filePath = parsedCallee.filePath;
+    const fileRole = detectFileRole(filePath);
+    if (fileRole === "test" || fileRole === "generated" || isExternalOrVendorFile(filePath, cwd) || isBuildArtifact(filePath)) {
+      continue;
+    }
+    if (seenNames.has(name))
+      continue;
+    seenNames.add(name);
+    const calls = [...graph.callees.get(calleeKey) ?? /* @__PURE__ */ new Set()].map((k) => parseSymbolKey(k).symbolName ?? k).filter(Boolean).slice(0, MAX_CALLS_PER_SYMBOL);
+    const calledBy = [...graph.callers.get(calleeKey) ?? /* @__PURE__ */ new Set()].map((k) => parseSymbolKey(k).symbolName ?? k).filter((n) => !n.startsWith("file:")).slice(0, MAX_CALLS_PER_SYMBOL);
+    const file = filePath ? path.relative(cwd, filePath).replace(/\\/g, "/") : "unknown";
+    const draft = {
+      file,
+      name,
+      kind: inferKind(calleeKey),
+      calls,
+      calledBy,
+      inDegree
+    };
+    const tokens = estimateTokens(draft);
+    if (totalTokens + tokens > budget)
+      continue;
+    entries.push({ ...draft, tokens });
+    totalTokens += tokens;
+  }
+  const allFiles = new Set([...graph.callers.keys(), ...graph.callees.keys()].map((k) => parseSymbolKey(k).filePath).filter(Boolean));
+  return {
+    version: CODEBASE_MODEL_VERSION,
+    reviewGraphVersion: modelIdentity.reviewGraphVersion,
+    reviewGraphSignature: modelIdentity.reviewGraphSignature,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalSymbols: graph.inDegree.size,
+    totalFiles: allFiles.size,
+    entries,
+    totalTokens
+  };
+}
+function cacheFilePath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "codebase-model.json");
+}
+function metaFilePath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "codebase-model.meta.json");
+}
+function saveCodebaseModel(cwd, model) {
+  const cacheFile = cacheFilePath(cwd);
+  try {
+    fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
+    writeFileAtomic(cacheFile, JSON.stringify(model));
+    writeFileAtomic(metaFilePath(cwd), JSON.stringify({
+      savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      entryCount: model.entries.length,
+      totalTokens: model.totalTokens
+    }));
+  } catch {
+  }
+}
+function loadCodebaseModel(cwd, expectedIdentity) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(cacheFilePath(cwd), "utf-8"));
+    if (raw.version !== CODEBASE_MODEL_VERSION || typeof raw.reviewGraphVersion !== "string" || raw.reviewGraphVersion.length === 0 || typeof raw.reviewGraphSignature !== "string" || raw.reviewGraphSignature.length === 0 || typeof raw.generatedAt !== "string" || !Array.isArray(raw.entries))
+      return void 0;
+    if (raw.reviewGraphVersion !== expectedIdentity.reviewGraphVersion || raw.reviewGraphSignature !== expectedIdentity.reviewGraphSignature)
+      return void 0;
+    return raw;
+  } catch {
+    return void 0;
+  }
+}
+export {
+  CODEBASE_MODEL_VERSION,
+  DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET,
+  buildCodebaseModel,
+  loadCodebaseModel,
+  saveCodebaseModel
+};

package/node_modules/pi-lens/dist/chunk-6XX5HCLK.js

@@ -0,0 +1,398 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  hasCargoWorkspaceTable,
+  readCargoDependencyNames,
+  readCargoPackageName,
+  readCargoWorkspaceMembers
+} from "./chunk-S6AMWKPC.js";
+import {
+  getProjectIgnoreMatcher,
+  isExcludedDirName
+} from "./chunk-T54VJRAD.js";
+import {
+  getWorkspaceManifestMarkers
+} from "./chunk-Z6BB4JLQ.js";
+import {
+  normalizeMapKey
+} from "./chunk-G3RLJYA2.js";
+
+// dist/clients/review-graph/workspace-modules.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var MAX_WORKSPACE_CANDIDATES = 5e3;
+var SOURCE_EXTS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".go",
+  ".rs",
+  ".rb",
+  ".cpp",
+  ".c",
+  ".cc",
+  ".h",
+  ".hpp"
+]);
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function detectWorkspaceType(cwd) {
+  const markers = getWorkspaceManifestMarkers(cwd);
+  if (markers.hasPnpmWorkspaceYaml)
+    return "pnpm";
+  if (markers.hasGoWork)
+    return "go";
+  if (markers.hasCargoToml) {
+    try {
+      const content = fs.readFileSync(path.join(cwd, "Cargo.toml"), "utf-8");
+      if (hasCargoWorkspaceTable(content)) {
+        return "cargo";
+      }
+    } catch {
+    }
+  }
+  if (markers.hasPackageJson) {
+    const pkgJson = readJsonSafe(path.join(cwd, "package.json"));
+    const workspaces = normalizeWorkspacePatterns(pkgJson?.workspaces);
+    if (workspaces.length > 0)
+      return "npm";
+  }
+  return null;
+}
+function stripQuotes(value) {
+  return value.trim().replace(/^['"]|['"]$/g, "");
+}
+function normalizeWorkspacePatterns(value) {
+  if (Array.isArray(value))
+    return value.map(stripQuotes).filter(Boolean);
+  if (value?.packages && Array.isArray(value.packages)) {
+    return value.packages.map(stripQuotes).filter(Boolean);
+  }
+  return [];
+}
+function expandWorkspacePattern(cwd, pattern) {
+  const normalized = stripQuotes(pattern.trim()).replace(/\\/g, "/");
+  if (!normalized || normalized.startsWith("!"))
+    return [];
+  const starIndex = normalized.indexOf("*");
+  if (starIndex === -1) {
+    const root = path.resolve(cwd, normalized);
+    return fs.existsSync(path.join(root, "package.json")) || fs.existsSync(path.join(root, "Cargo.toml")) || fs.existsSync(path.join(root, "go.mod")) ? [root] : [];
+  }
+  const prefix = normalized.slice(0, starIndex).replace(/\/$/, "");
+  const baseDir = path.resolve(cwd, prefix || ".");
+  let entries = [];
+  try {
+    entries = fs.readdirSync(baseDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const ignoreMatcher = getProjectIgnoreMatcher(cwd);
+  return entries.filter((entry) => {
+    const fullPath = path.join(baseDir, entry.name);
+    return entry.isDirectory() && !isExcludedDirName(entry.name) && !ignoreMatcher.isIgnored(fullPath, true);
+  }).slice(0, MAX_WORKSPACE_CANDIDATES).map((entry) => path.join(baseDir, entry.name)).filter((root) => fs.existsSync(path.join(root, "package.json")) || fs.existsSync(path.join(root, "Cargo.toml")) || fs.existsSync(path.join(root, "go.mod")));
+}
+function depsFromPackageJson(pkgJson) {
+  return Object.keys({
+    ...pkgJson.dependencies,
+    ...pkgJson.devDependencies,
+    ...pkgJson.peerDependencies
+  });
+}
+function extractYamlList(content, key) {
+  const values = [];
+  let inList = false;
+  for (const rawLine of content.split(/\r?\n/)) {
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    if (!inList) {
+      if (trimmed === `${key}:`)
+        inList = true;
+      continue;
+    }
+    if (trimmed.startsWith("-")) {
+      const value = stripQuotes(trimmed.slice(1).trim()).replace(/\/$/, "");
+      if (value)
+        values.push(value);
+      continue;
+    }
+    if (!rawLine.startsWith(" ") && !rawLine.startsWith("	"))
+      break;
+  }
+  return values;
+}
+function moduleFromPackageJson(cwd, pkgRoot) {
+  const pkgJson = readJsonSafe(path.join(pkgRoot, "package.json"));
+  if (!pkgJson?.name)
+    return null;
+  return {
+    name: pkgJson.name,
+    root: normalizeMapKey(pkgRoot),
+    relativePath: path.relative(cwd, pkgRoot).replace(/\\/g, "/"),
+    entrypoints: pkgJson.main ? [pkgJson.main] : ["index.js"],
+    internalDeps: [],
+    externalDeps: depsFromPackageJson(pkgJson)
+  };
+}
+function scanPnpmModules(cwd) {
+  let patterns = [];
+  try {
+    const content = fs.readFileSync(path.join(cwd, "pnpm-workspace.yaml"), "utf-8");
+    patterns = extractYamlList(content, "packages");
+  } catch {
+    return [];
+  }
+  return patterns.flatMap((pattern) => expandWorkspacePattern(cwd, pattern)).map((pkgRoot) => moduleFromPackageJson(cwd, pkgRoot)).filter((mod) => mod !== null);
+}
+function scanNpmModules(cwd) {
+  const pkgJson = readJsonSafe(path.join(cwd, "package.json"));
+  const patterns = normalizeWorkspacePatterns(pkgJson?.workspaces);
+  return patterns.flatMap((pattern) => expandWorkspacePattern(cwd, pattern)).map((pkgRoot) => moduleFromPackageJson(cwd, pkgRoot)).filter((mod) => mod !== null);
+}
+function scanCargoModules(cwd) {
+  let members = [];
+  try {
+    const content = fs.readFileSync(path.join(cwd, "Cargo.toml"), "utf-8");
+    members = readCargoWorkspaceMembers(content);
+  } catch {
+    return [];
+  }
+  const modules = [];
+  for (const member of members) {
+    const pkgRoot = path.resolve(cwd, member);
+    const memberToml = path.join(pkgRoot, "Cargo.toml");
+    let name = "";
+    let deps = [];
+    try {
+      const content = fs.readFileSync(memberToml, "utf-8");
+      name = readCargoPackageName(content) ?? "";
+      deps = readCargoDependencyNames(content);
+    } catch {
+      continue;
+    }
+    if (!name)
+      continue;
+    modules.push({
+      name,
+      root: normalizeMapKey(pkgRoot),
+      relativePath: path.relative(cwd, pkgRoot).replace(/\\/g, "/"),
+      entrypoints: ["src/lib.rs", "src/main.rs"],
+      internalDeps: [],
+      externalDeps: deps
+    });
+  }
+  return modules;
+}
+function scanGoModules(cwd) {
+  let dirs = [];
+  try {
+    const content = fs.readFileSync(path.join(cwd, "go.work"), "utf-8");
+    dirs = [...content.matchAll(/(?:^|\s)(\.\/?[^\s)]+)/gm)].map((m) => m[1]);
+  } catch {
+    return [];
+  }
+  const modules = [];
+  for (const dir of dirs) {
+    const pkgRoot = path.resolve(cwd, dir);
+    let name = "";
+    try {
+      const content = fs.readFileSync(path.join(pkgRoot, "go.mod"), "utf-8");
+      const match = content.match(/^module\s+(\S+)/m);
+      if (match)
+        name = match[1];
+    } catch {
+      continue;
+    }
+    if (!name)
+      continue;
+    modules.push({
+      name,
+      root: normalizeMapKey(pkgRoot),
+      relativePath: path.relative(cwd, pkgRoot).replace(/\\/g, "/"),
+      entrypoints: ["."],
+      internalDeps: [],
+      externalDeps: []
+    });
+  }
+  return modules;
+}
+function resolveInternalDeps(modules) {
+  const nameSet = new Set(modules.map((m) => m.name));
+  for (const mod of modules) {
+    const internal = [];
+    const external = [];
+    for (const dep of mod.externalDeps) {
+      if (nameSet.has(dep))
+        internal.push(dep);
+      else
+        external.push(dep);
+    }
+    mod.internalDeps = internal;
+    mod.externalDeps = external;
+  }
+}
+function buildDependents(modules) {
+  const dependents = /* @__PURE__ */ new Map();
+  for (const mod of modules) {
+    for (const dep of mod.internalDeps) {
+      const list = dependents.get(dep) ?? [];
+      list.push(mod.name);
+      dependents.set(dep, list);
+    }
+  }
+  return dependents;
+}
+var _moduleGraphCache = null;
+function buildModuleGraph(cwd) {
+  if (_moduleGraphCache && _moduleGraphCache.cwd === cwd) {
+    return _moduleGraphCache.graph;
+  }
+  const type = detectWorkspaceType(cwd);
+  if (!type)
+    return null;
+  let modules = [];
+  switch (type) {
+    case "pnpm":
+      modules = scanPnpmModules(cwd);
+      break;
+    case "npm":
+      modules = scanNpmModules(cwd);
+      break;
+    case "cargo":
+      modules = scanCargoModules(cwd);
+      break;
+    case "go":
+      modules = scanGoModules(cwd);
+      break;
+  }
+  if (modules.length === 0)
+    return null;
+  resolveInternalDeps(modules);
+  const graph = {
+    root: cwd,
+    modules: new Map(modules.map((m) => [m.name, m])),
+    dependents: buildDependents(modules)
+  };
+  _moduleGraphCache = { cwd, graph };
+  return graph;
+}
+function clearModuleGraphCache() {
+  _moduleGraphCache = null;
+  _moduleSourceFilesMemo.clear();
+}
+function findModuleForPath(graph, filePath) {
+  const normalized = normalizeMapKey(filePath);
+  let best;
+  for (const mod of graph.modules.values()) {
+    if (normalized === mod.root || normalized.startsWith(`${mod.root}/`)) {
+      if (!best || mod.root.length > best.root.length)
+        best = mod;
+    }
+  }
+  return best;
+}
+function getDownstreamModules(graph, moduleName) {
+  const downstream = /* @__PURE__ */ new Set();
+  const queue = [moduleName];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const dep of graph.dependents.get(current) ?? []) {
+      if (!downstream.has(dep)) {
+        downstream.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return [...downstream];
+}
+var _moduleSourceFilesMemo = /* @__PURE__ */ new Map();
+var MTIME_GRANULARITY_GUARD_MS = 2e3;
+function isMemoEntryFresh(entry) {
+  const validatedAt = Date.now();
+  for (const { dir, mtimeMs, stampedAt } of entry.dirs) {
+    if (validatedAt - stampedAt < MTIME_GRANULARITY_GUARD_MS)
+      return false;
+    try {
+      if (fs.statSync(dir).mtimeMs !== mtimeMs)
+        return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function getModuleSourceFiles(moduleRoot, maxFiles = 20) {
+  const root = normalizeMapKey(moduleRoot);
+  const ignoreMatcher = getProjectIgnoreMatcher(root);
+  const cached = _moduleSourceFilesMemo.get(root);
+  if (cached && cached.maxFiles === maxFiles && cached.matcher === ignoreMatcher && isMemoEntryFresh(cached)) {
+    return [...cached.files];
+  }
+  const files = [];
+  const dirs = [];
+  let allDirsStamped = true;
+  const visit = (dir, depth) => {
+    if (files.length >= maxFiles || depth > 4)
+      return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    try {
+      dirs.push({
+        dir,
+        mtimeMs: fs.statSync(dir).mtimeMs,
+        stampedAt: Date.now()
+      });
+    } catch {
+      allDirsStamped = false;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (files.length >= maxFiles)
+        break;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!isExcludedDirName(entry.name) && !ignoreMatcher.isIgnored(fullPath, true)) {
+          visit(fullPath, depth + 1);
+        }
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      if (!SOURCE_EXTS.has(path.extname(entry.name).toLowerCase()))
+        continue;
+      if (ignoreMatcher.isIgnored(fullPath, false))
+        continue;
+      files.push(normalizeMapKey(fullPath));
+    }
+  };
+  visit(root, 0);
+  if (allDirsStamped) {
+    _moduleSourceFilesMemo.set(root, {
+      files: [...files],
+      maxFiles,
+      dirs,
+      matcher: ignoreMatcher
+    });
+  }
+  return files;
+}
+
+export {
+  buildModuleGraph,
+  clearModuleGraphCache,
+  findModuleForPath,
+  getDownstreamModules,
+  getModuleSourceFiles
+};

package/node_modules/pi-lens/dist/chunk-7AXO3ZDF.js

@@ -0,0 +1,30 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  calcCyclomaticComplexity,
+  functionFactProvider
+} from "./chunk-MQA2YBAH.js";
+import "./chunk-TQFBZVCG.js";
+import "./chunk-5W3R6LFT.js";
+import "./chunk-UEAHAMEI.js";
+import "./chunk-Z54ZSOBZ.js";
+import "./chunk-KJCWXUUS.js";
+import "./chunk-QOZXJ4NA.js";
+import "./chunk-D6YF5HKX.js";
+import "./chunk-O7HZX7CA.js";
+import "./chunk-T54VJRAD.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";
+export {
+  calcCyclomaticComplexity,
+  functionFactProvider
+};