@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/chunk-OS32RNR2.js

@@ -0,0 +1,442 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  calcCyclomaticComplexity
+} from "./chunk-YLF3PPT5.js";
+import "./chunk-JOLITGCC.js";
+import "./chunk-5W3R6LFT.js";
+import {
+  firstChildOfType,
+  isComplexityLanguageId,
+  isComplexitySupportedFile,
+  resolveTreeSitterLanguage,
+  walk,
+  withTreeSitterRoot
+} from "./chunk-LW6XKDZQ.js";
+import "./chunk-Z54ZSOBZ.js";
+import "./chunk-TGPXLY2J.js";
+import "./chunk-QOZXJ4NA.js";
+import "./chunk-NTUJEGDZ.js";
+import "./chunk-WONERJTP.js";
+import "./chunk-VN2AXLEX.js";
+import "./chunk-5ZEJHV35.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-N3YQJI6O.js";
+import {
+  createSubsystemLogger
+} from "./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/complexity-client.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var JSTS = {
+  functionLike: /* @__PURE__ */ new Set([
+    "function_declaration",
+    "method_definition",
+    "function_expression",
+    "arrow_function",
+    "generator_function",
+    "generator_function_declaration"
+  ]),
+  nesting: /* @__PURE__ */ new Set([
+    "if_statement",
+    "while_statement",
+    "for_statement",
+    "for_in_statement",
+    "switch_statement",
+    "function_declaration",
+    "function_expression",
+    "arrow_function",
+    "method_definition",
+    "class_declaration",
+    "try_statement",
+    "catch_clause"
+  ]),
+  decision: /* @__PURE__ */ new Set([
+    "if_statement",
+    "while_statement",
+    "for_statement",
+    "for_in_statement",
+    "switch_case",
+    "ternary_expression"
+  ]),
+  cognitive: /* @__PURE__ */ new Set([
+    "if_statement",
+    "while_statement",
+    "for_statement",
+    "for_in_statement",
+    "switch_statement",
+    "switch_case",
+    "ternary_expression",
+    "catch_clause"
+  ]),
+  logicalOpNodes: /* @__PURE__ */ new Set(),
+  logicalBinaryOps: /* @__PURE__ */ new Set(["&&", "||", "??"]),
+  tryNode: "try_statement",
+  nameChildTypes: ["identifier", "property_identifier"]
+};
+var PYTHON = {
+  functionLike: /* @__PURE__ */ new Set(["function_definition", "lambda"]),
+  nesting: /* @__PURE__ */ new Set([
+    "if_statement",
+    "for_statement",
+    "while_statement",
+    "match_statement",
+    "function_definition",
+    "class_definition",
+    "try_statement",
+    "except_clause",
+    "elif_clause"
+  ]),
+  decision: /* @__PURE__ */ new Set([
+    "if_statement",
+    "elif_clause",
+    "for_statement",
+    "while_statement",
+    "case_clause",
+    "conditional_expression"
+  ]),
+  cognitive: /* @__PURE__ */ new Set([
+    "if_statement",
+    "elif_clause",
+    "for_statement",
+    "while_statement",
+    "match_statement",
+    "case_clause",
+    "conditional_expression",
+    "except_clause"
+  ]),
+  logicalOpNodes: /* @__PURE__ */ new Set(["boolean_operator"]),
+  logicalBinaryOps: /* @__PURE__ */ new Set(),
+  tryNode: "try_statement",
+  nameChildTypes: ["identifier"]
+};
+var GO = {
+  functionLike: /* @__PURE__ */ new Set([
+    "function_declaration",
+    "method_declaration",
+    "func_literal"
+  ]),
+  nesting: /* @__PURE__ */ new Set([
+    "if_statement",
+    "for_statement",
+    "expression_switch_statement",
+    "type_switch_statement",
+    "select_statement",
+    "function_declaration",
+    "method_declaration"
+  ]),
+  decision: /* @__PURE__ */ new Set([
+    "if_statement",
+    "for_statement",
+    "expression_case",
+    "type_case",
+    "communication_case"
+  ]),
+  cognitive: /* @__PURE__ */ new Set([
+    "if_statement",
+    "for_statement",
+    "expression_switch_statement",
+    "type_switch_statement",
+    "select_statement",
+    "expression_case",
+    "type_case",
+    "communication_case"
+  ]),
+  logicalOpNodes: /* @__PURE__ */ new Set(),
+  logicalBinaryOps: /* @__PURE__ */ new Set(["&&", "||"]),
+  tryNode: void 0,
+  // Go has no try/catch (error returns)
+  nameChildTypes: ["identifier", "field_identifier"]
+};
+var RUST = {
+  functionLike: /* @__PURE__ */ new Set(["function_item", "closure_expression"]),
+  nesting: /* @__PURE__ */ new Set([
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "match_expression",
+    "function_item"
+  ]),
+  decision: /* @__PURE__ */ new Set([
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "match_arm"
+  ]),
+  cognitive: /* @__PURE__ */ new Set([
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "match_expression",
+    "match_arm"
+  ]),
+  logicalOpNodes: /* @__PURE__ */ new Set(),
+  logicalBinaryOps: /* @__PURE__ */ new Set(["&&", "||"]),
+  tryNode: void 0,
+  // Rust uses Result/? — no try/catch
+  nameChildTypes: ["identifier"]
+};
+var LANGUAGE_NODES = {
+  typescript: JSTS,
+  tsx: JSTS,
+  javascript: JSTS,
+  python: PYTHON,
+  go: GO,
+  rust: RUST
+};
+var COMMENT_TYPES = /* @__PURE__ */ new Set(["comment", "line_comment", "block_comment"]);
+function isLogicalOp(node, nodes) {
+  if (nodes.logicalOpNodes.has(node.type))
+    return true;
+  if (nodes.logicalBinaryOps.size > 0 && node.type === "binary_expression") {
+    return (node.children ?? []).some((c) => c && nodes.logicalBinaryOps.has(c.type));
+  }
+  return false;
+}
+function subtreeCyclomatic(root, nodes) {
+  if (nodes === JSTS)
+    return calcCyclomaticComplexity(root) - 1;
+  let cc = 0;
+  walk(root, (n) => {
+    if (nodes.decision.has(n.type))
+      cc++;
+    if (isLogicalOp(n, nodes))
+      cc++;
+  });
+  return cc;
+}
+function subtreeCognitive(node, nesting, nodes) {
+  let complexity = 0;
+  if (nodes.cognitive.has(node.type))
+    complexity += 1 + nesting;
+  if ((node.type === "break_statement" || node.type === "continue_statement") && (node.children ?? []).some((c) => c && (c.type === "statement_identifier" || c.type === "identifier" || c.type === "label_name" || c.type === "label"))) {
+    complexity += 1 + nesting;
+  }
+  if (isLogicalOp(node, nodes))
+    complexity += 1;
+  const childNesting = nodes.nesting.has(node.type) ? nesting + 1 : nesting;
+  for (const child of node.children ?? []) {
+    if (child)
+      complexity += subtreeCognitive(child, childNesting, nodes);
+  }
+  return complexity;
+}
+function subtreeMaxNesting(node, currentDepth, nodes) {
+  let maxDepth = currentDepth;
+  if (nodes.nesting.has(node.type)) {
+    currentDepth++;
+    maxDepth = Math.max(maxDepth, currentDepth);
+  }
+  for (const child of node.children ?? []) {
+    if (child) {
+      maxDepth = Math.max(maxDepth, subtreeMaxNesting(child, currentDepth, nodes));
+    }
+  }
+  return maxDepth;
+}
+function functionName(fnNode, nodes) {
+  for (const t of nodes.nameChildTypes) {
+    const id = firstChildOfType(fnNode, t);
+    if (id)
+      return id.text;
+  }
+  return void 0;
+}
+function collectFunctionMetrics(root, nodes) {
+  const functions = [];
+  const visit = (node, nestingLevel) => {
+    if (nodes.functionLike.has(node.type)) {
+      const startLine = node.startPosition.row;
+      const endLine = node.endPosition.row;
+      functions.push({
+        name: functionName(node, nodes) ?? `<anonymous@L${startLine + 1}>`,
+        line: startLine + 1,
+        length: endLine - startLine + 1,
+        cyclomatic: subtreeCyclomatic(node, nodes),
+        cognitive: subtreeCognitive(node, nestingLevel, nodes),
+        nestingDepth: subtreeMaxNesting(node, 0, nodes)
+      });
+    }
+    const newNesting = nodes.nesting.has(node.type) ? nestingLevel + 1 : nestingLevel;
+    for (const child of node.children ?? []) {
+      if (child)
+        visit(child, newNesting);
+    }
+  };
+  visit(root, 0);
+  return functions;
+}
+function countTryCatch(root, nodes) {
+  if (!nodes.tryNode)
+    return 0;
+  let count = 0;
+  walk(root, (n) => {
+    if (n.type === nodes.tryNode)
+      count++;
+  });
+  return count;
+}
+function countLines(content, root) {
+  const lines = content.split(/\r?\n/);
+  const commentLineSet = /* @__PURE__ */ new Set();
+  walk(root, (n) => {
+    if (COMMENT_TYPES.has(n.type)) {
+      for (let l = n.startPosition.row; l <= n.endPosition.row; l++) {
+        commentLineSet.add(l);
+      }
+    }
+  });
+  const codeLines = lines.filter((line, i) => {
+    if (line.trim().length === 0)
+      return false;
+    if (!commentLineSet.has(i))
+      return true;
+    const stripped = line.replace(/\/\/.*$/, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/#.*$/, "").trim();
+    return stripped.length > 0;
+  }).length;
+  return { codeLines, commentLines: commentLineSet.size };
+}
+var AI_COMMENT_PATTERNS = [
+  /(?:🔍|✅|📝|🔧|🐛|⚠️|🚀|💡|🎯|📌|🏷️|🔑|🏗️|🧪|🗑️|🔄|♻️|📋|🔖|📊|💬|🔥|💎|⭐|🌟|🎨|🛠️)/u,
+  /(?:\/\/|#)\s*(Initialize|Setup|Clean up|Create|Define|Check if|Handle|Process|Validate|Return|Get|Set|Add|Remove|Update|Fetch)\b/i,
+  /(?:\/\/|#)\s*(This function|This method|This code|Here we|Now we)\b/i,
+  /\/\*\*?\s*(Overview|Summary|Description|Example|Usage)\s*\*?\//i
+];
+function countAICommentPatterns(sourceText) {
+  let count = 0;
+  for (const line of sourceText.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("#")) {
+      for (const pattern of AI_COMMENT_PATTERNS) {
+        if (pattern.test(line)) {
+          count++;
+          break;
+        }
+      }
+    }
+  }
+  return count;
+}
+function calculateCodeEntropy(sourceText) {
+  const tokens = sourceText.replace(/\/\/.*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/["'`][^"'`]*["'`]/g, "STR").replace(/\b\d+(\.\d+)?\b/g, "NUM").split(/[\s\n\r\t,;:()[\]{}=<>!&|+\-*/%^~?]+/).filter((t) => t.length > 0);
+  if (tokens.length === 0)
+    return 0;
+  const freq = /* @__PURE__ */ new Map();
+  for (const token of tokens)
+    freq.set(token, (freq.get(token) || 0) + 1);
+  let entropy = 0;
+  for (const count of freq.values()) {
+    const p = count / tokens.length;
+    if (p > 0)
+      entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+function calculateMaintainabilityIndex(cyclomatic, loc, comments) {
+  if (loc === 0)
+    return 100;
+  const lnLOC = Math.log(loc);
+  let mi = (171 - 0.23 * cyclomatic - 16.2 * lnLOC) * 100 / 171;
+  const commentBonus = Math.min(10, comments / loc * 50);
+  mi += commentBonus;
+  return Math.max(0, Math.min(100, mi));
+}
+function calculateMaxParams(functions) {
+  return Math.min(10, Math.max(2, Math.round(functions.reduce((a, f) => a + f.length, 0) / Math.max(1, functions.length) / 5)));
+}
+function countSingleUseFunctions(functions) {
+  return functions.filter((f) => f.length < 10 && f.cyclomatic <= 2 && /^(get|set|check|is|has|validate|format|parse|convert|create|make)/i.test(f.name)).length;
+}
+var ComplexityClient = class {
+  log;
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("complexity") : () => {
+    };
+  }
+  /** True if the file's grammar has a complexity node mapping.
+   *
+   * Delegates to the module-free predicate in `tree-sitter-shared.ts`: the
+   * same question is asked by `handleToolCallImpl` BEFORE the analyzer
+   * bootstrap is loaded (#2467), and two copies of it would be two answers. */
+  isSupportedFile(filePath) {
+    return isComplexitySupportedFile(filePath);
+  }
+  /** Analyze complexity metrics for a file (null if unsupported / unparseable). */
+  async analyzeFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    const languageId = resolveTreeSitterLanguage(absolutePath);
+    const nodes = languageId && isComplexityLanguageId(languageId) ? LANGUAGE_NODES[languageId] : void 0;
+    if (!nodes)
+      return null;
+    let content;
+    try {
+      if (!fs.existsSync(absolutePath))
+        return null;
+      content = fs.readFileSync(absolutePath, "utf-8");
+    } catch (err) {
+      this.log(`Read error for ${filePath}: ${err.message}`);
+      return null;
+    }
+    try {
+      const parsed = await withTreeSitterRoot(absolutePath, content, (root) => this.computeMetrics(absolutePath, content, root, nodes), "complexity");
+      return parsed.parsed ? parsed.value : null;
+    } catch (err) {
+      this.log(`Analysis error for ${filePath}: ${err.message}`);
+      return null;
+    }
+  }
+  computeMetrics(absolutePath, content, root, nodes) {
+    const { codeLines, commentLines } = countLines(content, root);
+    const functions = collectFunctionMetrics(root, nodes);
+    const maxNestingDepth = subtreeMaxNesting(root, 0, nodes);
+    const cognitive = subtreeCognitive(root, 0, nodes);
+    const funcStats = this.aggregateFunctionStats(functions);
+    return {
+      filePath: path.relative(process.cwd(), absolutePath),
+      maxNestingDepth,
+      avgFunctionLength: funcStats.avgLength,
+      maxFunctionLength: funcStats.maxLength,
+      functionCount: functions.length,
+      cyclomaticComplexity: funcStats.avgCyclomatic,
+      maxCyclomaticComplexity: funcStats.maxCyclomatic,
+      cognitiveComplexity: cognitive,
+      maintainabilityIndex: Math.round(calculateMaintainabilityIndex(funcStats.avgCyclomatic, codeLines, commentLines) * 10) / 10,
+      linesOfCode: codeLines,
+      commentLines,
+      codeEntropy: Math.round(calculateCodeEntropy(content) * 100) / 100,
+      maxParamsInFunction: calculateMaxParams(functions),
+      aiCommentPatterns: countAICommentPatterns(content),
+      singleUseFunctions: countSingleUseFunctions(functions),
+      tryCatchCount: countTryCatch(root, nodes),
+      functions
+    };
+  }
+  aggregateFunctionStats(functions) {
+    if (functions.length === 0) {
+      return { avgLength: 0, maxLength: 0, avgCyclomatic: 1, maxCyclomatic: 1 };
+    }
+    const lengths = functions.map((f) => f.length);
+    const cyclomatics = functions.map((f) => f.cyclomatic);
+    const sum = (arr) => arr.reduce((a, b) => a + b, 0);
+    return {
+      avgLength: Math.round(sum(lengths) / lengths.length),
+      maxLength: Math.max(...lengths),
+      avgCyclomatic: Math.max(1, Math.round(sum(cyclomatics) / cyclomatics.length)),
+      maxCyclomatic: Math.max(1, Math.max(...cyclomatics))
+    };
+  }
+};
+export {
+  ComplexityClient
+};

package/node_modules/pi-lens/dist/chunk-PAK6IDME.js

@@ -0,0 +1,189 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  logExtension
+} from "./chunk-O6TQT6RI.js";
+import {
+  findNearestMarkerRoot,
+  isAtOrAboveHomeDir
+} from "./chunk-Q5U6FMDI.js";
+
+// dist/clients/cargo-manifest.js
+import { readFile } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+async function readTextFileOrUndefined(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function stripTomlLineComment(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quote) {
+      if (ch === quote)
+        quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "#")
+      return line.slice(0, i);
+  }
+  return line;
+}
+function normalizeToml(content) {
+  return content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").split("\n").map(stripTomlLineComment).join("\n");
+}
+function extractTomlTableSection(content, tableName) {
+  const normalized = normalizeToml(content);
+  const heading = new RegExp(`^[ \\t]*\\[${tableName}\\][ \\t]*(?:#.*)?$`, "m");
+  const match = heading.exec(normalized);
+  if (!match)
+    return void 0;
+  const rest = normalized.slice(match.index + match[0].length);
+  const nextHeading = rest.match(/^[ \t]*\[{1,2}[^\]]+\]{1,2}[ \t]*(?:#.*)?$/m);
+  return nextHeading?.index !== void 0 ? rest.slice(0, nextHeading.index) : rest;
+}
+function parseTomlStringArray(content, key) {
+  if (content === void 0)
+    return [];
+  const normalized = normalizeToml(content);
+  const open = normalized.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\[`, "m"));
+  if (open?.index === void 0)
+    return [];
+  const from = open.index + open[0].length;
+  const to = indexOfArrayEnd(normalized, from);
+  if (to < 0)
+    return [];
+  return [...normalized.slice(from, to).matchAll(/"([^"]*)"|'([^']*)'/g)].map((m) => (m[1] ?? m[2] ?? "").trim());
+}
+function indexOfArrayEnd(text, from) {
+  let quote = null;
+  for (let i = from; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === "\\" && quote === '"')
+        i++;
+      else if (ch === quote)
+        quote = null;
+    } else if (ch === '"' || ch === "'")
+      quote = ch;
+    else if (ch === "]")
+      return i;
+  }
+  return -1;
+}
+function parseTomlScalarString(content, key) {
+  if (content === void 0)
+    return void 0;
+  const match = content.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*(?:"([^"]*)"|'([^']*)')`, "m"));
+  if (!match)
+    return void 0;
+  return match[1] ?? match[2];
+}
+function hasCargoWorkspaceTable(content) {
+  return hasTomlTable(content, "workspace");
+}
+function hasTomlTable(content, tableName) {
+  return extractTomlTableSection(content, tableName) !== void 0;
+}
+function readCargoPackageName(content) {
+  const packageSection = extractTomlTableSection(content, "package");
+  return parseTomlScalarString(packageSection, "name");
+}
+function readCargoWorkspaceMembers(content) {
+  return parseTomlStringArray(extractTomlTableSection(content, "workspace"), "members");
+}
+function readCargoWorkspaceExclude(content) {
+  return parseTomlStringArray(extractTomlTableSection(content, "workspace"), "exclude");
+}
+function readCargoDependencyNames(content) {
+  const section = extractTomlTableSection(content, "dependencies");
+  if (section === void 0)
+    return [];
+  const names = [];
+  for (const rawLine of section.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    const match = line.match(/^([A-Za-z0-9_-]+)\s*=/);
+    if (match)
+      names.push(match[1]);
+  }
+  return names;
+}
+function isTomlKeyWorkspaceInherited(content, key) {
+  if (content === void 0)
+    return false;
+  const dotted = new RegExp(`^[ \\t]*${key}\\.workspace[ \\t]*=[ \\t]*true`, "m");
+  const inline = new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\{[^}\\n]*\\bworkspace[ \\t]*=[ \\t]*true`, "m");
+  return dotted.test(content) || inline.test(content);
+}
+var SUPPORTED_RUSTFMT_EDITIONS = /* @__PURE__ */ new Set(["2015", "2018", "2021", "2024"]);
+function validatedEdition(value, filePath) {
+  if (value === void 0)
+    return void 0;
+  if (SUPPORTED_RUSTFMT_EDITIONS.has(value))
+    return value;
+  logExtension({
+    subsystem: "format",
+    message: "resolveCargoPackageEdition: manifest edition is not a rustfmt-supported value; falling back to the static rustfmt command",
+    level: "debug",
+    metadata: { rejectedEdition: value, filePath }
+  });
+  return void 0;
+}
+function readWorkspacePackageEdition(content) {
+  const workspaceSection = extractTomlTableSection(content, "workspace.package");
+  return parseTomlScalarString(workspaceSection, "edition");
+}
+async function resolveCargoPackageEdition(filePath, homeDir = os.homedir()) {
+  const startDir = path.dirname(path.resolve(filePath));
+  const packageDir = findNearestMarkerRoot(startDir, ["Cargo.toml"], {
+    homeDir
+  });
+  if (!packageDir)
+    return void 0;
+  const packageContent = await readTextFileOrUndefined(path.join(packageDir, "Cargo.toml"));
+  if (packageContent === void 0)
+    return void 0;
+  const packageSection = extractTomlTableSection(packageContent, "package");
+  const direct = parseTomlScalarString(packageSection, "edition");
+  if (direct !== void 0)
+    return validatedEdition(direct, filePath);
+  if (!isTomlKeyWorkspaceInherited(packageSection, "edition"))
+    return void 0;
+  if (hasCargoWorkspaceTable(packageContent)) {
+    return validatedEdition(readWorkspacePackageEdition(packageContent), filePath);
+  }
+  let current = path.dirname(packageDir);
+  for (let depth = 0; depth < 64; depth++) {
+    if (isAtOrAboveHomeDir(current, homeDir))
+      return void 0;
+    const ancestorContent = await readTextFileOrUndefined(path.join(current, "Cargo.toml"));
+    if (ancestorContent !== void 0 && hasCargoWorkspaceTable(ancestorContent)) {
+      return validatedEdition(readWorkspacePackageEdition(ancestorContent), filePath);
+    }
+    const parent = path.dirname(current);
+    if (parent === current)
+      return void 0;
+    current = parent;
+  }
+  return void 0;
+}
+
+export {
+  readTextFileOrUndefined,
+  extractTomlTableSection,
+  parseTomlStringArray,
+  hasCargoWorkspaceTable,
+  hasTomlTable,
+  readCargoPackageName,
+  readCargoWorkspaceMembers,
+  readCargoWorkspaceExclude,
+  readCargoDependencyNames,
+  resolveCargoPackageEdition
+};