pi-lens 4.2.1 → 4.4.0

package/dist/chunk-YLF3PPT5.js

@@ -0,0 +1,308 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  extractFactsFromTree
+} from "./chunk-JOLITGCC.js";
+import {
+  findOwnerName
+} from "./chunk-5W3R6LFT.js";
+import {
+  firstChildOfType,
+  walk
+} from "./chunk-LW6XKDZQ.js";
+import {
+  isJstsFactFile
+} from "./chunk-5ZEJHV35.js";
+
+// dist/clients/dispatch/facts/function-facts.js
+var BOUNDARY_PREFIXES = [
+  "fetch",
+  "fs.",
+  "db.",
+  "http",
+  "axios",
+  "got",
+  "req.",
+  "res."
+];
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "method_definition",
+  "function_expression",
+  "arrow_function"
+]);
+var COMPLEXITY_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  // for…of and for…in both parse to for_in_statement
+  "while_statement",
+  "do_statement",
+  "switch_case",
+  // `case` only — `default` (switch_default) is not counted
+  "catch_clause",
+  "ternary_expression"
+]);
+var NESTING_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_statement",
+  "try_statement"
+]);
+var LOGICAL_OPERATORS = /* @__PURE__ */ new Set(["&&", "||", "??"]);
+function namedChildren(node) {
+  return (node.children ?? []).filter((c) => c && c.isNamed && c.type !== "comment");
+}
+function firstNamedChild(node) {
+  return namedChildren(node)[0];
+}
+function getBody(node) {
+  return firstChildOfType(node, "statement_block");
+}
+function getParameters(node) {
+  const fp = firstChildOfType(node, "formal_parameters");
+  if (!fp)
+    return [];
+  return (fp.children ?? []).filter((c) => c && (c.type === "identifier" || c.type === "required_parameter" || c.type === "optional_parameter" || c.type === "rest_pattern" || c.type === "assignment_pattern" || // Plain JavaScript's grammar places a top-level destructured
+  // parameter directly as an object_pattern/array_pattern child
+  // of formal_parameters — no required_parameter wrapper (the TS
+  // grammar always wraps every parameter, destructured or not,
+  // which is why the wrapper types above already covered TS).
+  // Without this, `function f({a, b})` counted 0 params in JS
+  // while the TS-annotated equivalent counted correctly (#1089 P3-4).
+  c.type === "object_pattern" || c.type === "array_pattern"));
+}
+function parameterName(param) {
+  return param.type === "identifier" ? param.text : firstNamedChild(param)?.text ?? "";
+}
+function getFunctionName(node) {
+  if (node.type === "function_declaration") {
+    return firstChildOfType(node, "identifier")?.text ?? "<anonymous>";
+  }
+  if (node.type === "method_definition") {
+    const kids = node.children ?? [];
+    const paramsIdx = kids.findIndex((c) => c?.type === "formal_parameters");
+    for (let i = paramsIdx - 1; i >= 0; i -= 1) {
+      const t = kids[i]?.type;
+      if (t === "property_identifier" || t === "private_property_identifier" || t === "computed_property_name" || t === "string" || t === "number") {
+        return kids[i].text;
+      }
+    }
+    return "<anonymous>";
+  }
+  if (node.type === "arrow_function" || node.type === "function_expression") {
+    const parent = node.parent;
+    if (parent?.type === "variable_declarator") {
+      const id = firstChildOfType(parent, "identifier");
+      if (id)
+        return id.text;
+    } else if (parent?.type === "pair") {
+      const key = (parent.children ?? [])[0];
+      if (key)
+        return key.text;
+    }
+    return "<anonymous>";
+  }
+  return "<unknown>";
+}
+function isCallPassThrough(stmt, paramNames) {
+  if (stmt.type !== "return_statement")
+    return { pass: false };
+  const expr = firstNamedChild(stmt);
+  if (!expr || expr.type !== "call_expression")
+    return { pass: false };
+  const argsNode = firstChildOfType(expr, "arguments");
+  const args = argsNode ? namedChildren(argsNode).map((a) => a.text) : [];
+  if (args.length !== paramNames.length)
+    return { pass: false };
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] !== paramNames[i])
+      return { pass: false };
+  }
+  return { pass: true, target: (expr.children ?? [])[0]?.text };
+}
+function calcCyclomaticComplexity(body) {
+  let cc = 1;
+  walk(body, (node) => {
+    if (COMPLEXITY_TYPES.has(node.type)) {
+      cc++;
+    } else if (node.type === "binary_expression") {
+      if ((node.children ?? []).some((c) => LOGICAL_OPERATORS.has(c?.type))) {
+        cc++;
+      }
+    }
+  });
+  return cc;
+}
+function calcMaxNestingDepth(body) {
+  let maxDepth = 0;
+  const walkDepth = (node, depth) => {
+    if (depth > maxDepth)
+      maxDepth = depth;
+    const next = NESTING_TYPES.has(node.type) ? depth + 1 : depth;
+    for (const child of node.children ?? []) {
+      if (child)
+        walkDepth(child, next);
+    }
+  };
+  for (const child of body.children ?? []) {
+    if (child)
+      walkDepth(child, 0);
+  }
+  return maxDepth;
+}
+function collectOutgoingCalls(body) {
+  const calls = /* @__PURE__ */ new Set();
+  walk(body, (node) => {
+    if (node.type === "call_expression") {
+      const callee = (node.children ?? [])[0]?.text ?? "";
+      if (callee.length < 80)
+        calls.add(callee);
+    }
+  });
+  return [...calls];
+}
+function collectMemberCallSites(body) {
+  const sites = [];
+  walk(body, (node) => {
+    if (node.type !== "call_expression")
+      return;
+    const callee = (node.children ?? [])[0];
+    if (!callee || callee.type !== "member_expression")
+      return;
+    const object = (callee.children ?? [])[0];
+    const property = (callee.children ?? []).find((c) => c?.type === "property_identifier");
+    if (!object || object.type !== "identifier" || !property)
+      return;
+    sites.push({ receiver: object.text, method: property.text });
+  });
+  return sites;
+}
+function collectReceiverTypes(body, params) {
+  const types = {};
+  for (const param of params) {
+    const id = firstNamedChild(param);
+    if (!id || id.type !== "identifier")
+      continue;
+    const typeAnnotation = (param.children ?? []).find((c) => c?.type === "type_annotation");
+    const typeId = typeAnnotation ? firstChildOfType(typeAnnotation, "type_identifier") : void 0;
+    if (typeId)
+      types[id.text] = typeId.text;
+  }
+  walk(body, (node) => {
+    if (node.type !== "variable_declarator")
+      return;
+    const id = firstChildOfType(node, "identifier");
+    if (!id)
+      return;
+    const value = (node.children ?? []).find((c) => c?.type === "new_expression");
+    if (!value)
+      return;
+    const ctor = firstNamedChild(value);
+    if (ctor?.type === "identifier")
+      types[id.text] = ctor.text;
+  });
+  return types;
+}
+function hasExplicitPromiseReturnType(node) {
+  const returnType = firstChildOfType(node, "type_annotation");
+  if (!returnType)
+    return false;
+  return /:\s*Promise\b/.test(returnType.text);
+}
+function hasAwaitInNode(node) {
+  let found = false;
+  walk(node, (n) => {
+    if (n.type === "await_expression")
+      found = true;
+  });
+  return found;
+}
+function hasReturnAwaitCall(node) {
+  let found = false;
+  walk(node, (n) => {
+    if (n.type !== "return_statement")
+      return;
+    const ret = firstNamedChild(n);
+    if (ret?.type !== "await_expression")
+      return;
+    const awaited = firstNamedChild(ret);
+    if (awaited?.type === "call_expression")
+      found = true;
+  });
+  return found;
+}
+var functionFactProvider = {
+  id: "fact.file.functions",
+  provides: ["file.functionSummaries", "file.functionFactsCoverage"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return isJstsFactFile(ctx.filePath);
+  },
+  async run(ctx, store) {
+    await extractFactsFromTree(ctx, store, functionFactProvider.id, { "file.functionSummaries": [] }, (root) => {
+      const summaries = [];
+      const containers = [];
+      const addSummary = (node) => {
+        const body = getBody(node);
+        if (!body)
+          return;
+        const params = getParameters(node);
+        const paramNames = params.map(parameterName);
+        const statements = namedChildren(body);
+        const statementCount = statements.length;
+        const passThrough = statementCount === 1 ? isCallPassThrough(statements[0], paramNames) : { pass: false };
+        const target = passThrough.target ?? "";
+        const lowerTarget = target.toLowerCase();
+        const isBoundaryWrapper = BOUNDARY_PREFIXES.some((prefix) => lowerTarget.startsWith(prefix));
+        summaries.push({
+          name: getFunctionName(node),
+          line: node.startPosition.row + 1,
+          column: node.startPosition.column + 1,
+          endLine: body.endPosition.row + 1,
+          isAsync: Boolean(firstChildOfType(node, "async")),
+          hasAwait: hasAwaitInNode(body),
+          hasReturnAwaitCall: hasReturnAwaitCall(body),
+          statementCount,
+          parameterCount: params.length,
+          isPassThroughWrapper: passThrough.pass,
+          passThroughTarget: passThrough.target,
+          isBoundaryWrapper,
+          hasExplicitPromiseReturnType: hasExplicitPromiseReturnType(node),
+          cyclomaticComplexity: calcCyclomaticComplexity(body),
+          maxNestingDepth: calcMaxNestingDepth(body),
+          outgoingCalls: collectOutgoingCalls(body),
+          memberCallSites: collectMemberCallSites(body),
+          receiverTypes: collectReceiverTypes(body, params)
+        });
+      };
+      walk(root, (node) => {
+        if (FUNCTION_TYPES.has(node.type))
+          addSummary(node);
+        if (node.type === "class_declaration" || node.type === "interface_declaration") {
+          const nameNode = firstChildOfType(node, "type_identifier") ?? firstChildOfType(node, "identifier");
+          if (nameNode) {
+            containers.push({
+              name: nameNode.text,
+              startLine: node.startPosition.row + 1,
+              endLine: node.endPosition.row + 1
+            });
+          }
+        }
+      });
+      for (const summary of summaries) {
+        const owner = findOwnerName(containers, summary.line, summary.endLine ?? summary.line);
+        if (owner)
+          summary.owner = owner;
+      }
+      return { "file.functionSummaries": summaries };
+    }, "file.functionFactsCoverage");
+  }
+};
+
+export {
+  calcCyclomaticComplexity,
+  functionFactProvider
+};

package/dist/chunk-YSNFMJKN.js

@@ -0,0 +1,14 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  FactStore,
+  getFactStoreEvictionReporter,
+  setFactStoreEvictionReporter
+} from "./chunk-NMABWBZN.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  FactStore,
+  getFactStoreEvictionReporter,
+  setFactStoreEvictionReporter
+};

package/dist/chunk-Z3CCVDUB.js

@@ -0,0 +1,76 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  BoundedFifoMap
+} from "./chunk-ABBOA7UD.js";
+
+// dist/clients/path-keyed-map.js
+var PathKeyedMap = class {
+  normalize;
+  store;
+  /**
+   * `maxEntries` bounds the map with insertion-order (FIFO) eviction, on
+   * `BoundedFifoMap` — the repo's one eviction implementation (#2442). Omit
+   * it for an unbounded map. A path-keyed map that needs a bound gets it
+   * here rather than hand-rolling `keys().next().value` at the call site,
+   * which is what `PartialApplyRecordStore` did before #2442's review round.
+   *
+   * FIFO, not LRU, and evicting AFTER the write, not before: a `set` of an
+   * already-resident path is an update, and must not drop an unrelated file
+   * to make room for a key that needs none.
+   */
+  constructor(normalize, maxEntries) {
+    this.normalize = normalize;
+    this.store = maxEntries === void 0 ? /* @__PURE__ */ new Map() : new BoundedFifoMap(maxEntries);
+  }
+  get size() {
+    return this.store.size;
+  }
+  get(path) {
+    return this.store.get(this.normalize(path))?.value;
+  }
+  has(path) {
+    return this.store.has(this.normalize(path));
+  }
+  set(path, value) {
+    this.store.set(this.normalize(path), { displayPath: path, value });
+    return this;
+  }
+  delete(path) {
+    if (this.store.delete(this.normalize(path)))
+      return true;
+    for (const [key, entry] of this.store) {
+      if (entry.displayPath !== path)
+        continue;
+      this.store.delete(key);
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    this.store.clear();
+  }
+  *keys() {
+    for (const entry of this.store.values())
+      yield entry.displayPath;
+  }
+  *values() {
+    for (const entry of this.store.values())
+      yield entry.value;
+  }
+  *entries() {
+    for (const entry of this.store.values())
+      yield [entry.displayPath, entry.value];
+  }
+  forEach(callback) {
+    for (const entry of this.store.values()) {
+      callback(entry.value, entry.displayPath, this);
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+
+export {
+  PathKeyedMap
+};

package/dist/chunk-Z54ZSOBZ.js

@@ -0,0 +1,61 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/scripts/lib/web-tree-sitter-dir.mjs
+import * as fs from "node:fs";
+import * as path from "node:path";
+var WEB_TREE_SITTER = "web-tree-sitter";
+var RUNTIME_WASM = "tree-sitter.wasm";
+function isWebTreeSitterPackageDir(dir) {
+  try {
+    if (!fs.existsSync(path.join(dir, RUNTIME_WASM)))
+      return false;
+    const manifest = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+    return manifest?.name === WEB_TREE_SITTER;
+  } catch {
+    return false;
+  }
+}
+function packageDirOf(resolvedFile) {
+  let dir = path.dirname(resolvedFile);
+  for (; ; ) {
+    if (isWebTreeSitterPackageDir(dir))
+      return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      return void 0;
+    dir = parent;
+  }
+}
+function resolveWebTreeSitterPackageDir(deps) {
+  for (const specifier of [
+    `${WEB_TREE_SITTER}/${RUNTIME_WASM}`,
+    WEB_TREE_SITTER
+  ]) {
+    try {
+      const dir = packageDirOf(deps.resolve(specifier));
+      if (dir)
+        return dir;
+    } catch {
+    }
+  }
+  for (const base of [deps.packageRoot, deps.cwd]) {
+    try {
+      const candidate = path.join(base(), "node_modules", WEB_TREE_SITTER);
+      if (isWebTreeSitterPackageDir(candidate))
+        return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function findCoreGrammarDir({ packageRoot, webTreeSitterDir }) {
+  return [
+    path.join(packageRoot, "grammars"),
+    webTreeSitterDir && path.join(webTreeSitterDir, "grammars")
+  ].find((dir) => dir && fs.existsSync(path.join(dir, "tree-sitter-typescript.wasm")));
+}
+
+export {
+  resolveWebTreeSitterPackageDir,
+  findCoreGrammarDir
+};

package/dist/chunk-ZAWW3AF6.js

@@ -0,0 +1,97 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  getProjectDataDir
+} from "./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 {
+  redactSecrets
+} from "./chunk-UK3CMEAL.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+
+// dist/clients/fix-worklog.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+function getWorklogPath(cwd) {
+  return path.join(getProjectDataDir(cwd), "worklog.jsonl");
+}
+function appendToWorklog(cwd, diagnostics, autoFixed, identity) {
+  if (diagnostics.length === 0)
+    return;
+  const worklogPath = getWorklogPath(cwd);
+  try {
+    fs.mkdirSync(path.dirname(worklogPath), { recursive: true });
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const model = identity?.model?.trim() || void 0;
+    const provider = identity?.provider?.trim() || void 0;
+    const lines = diagnostics.map((d) => {
+      const entry = {
+        timestamp,
+        filePath: d.filePath,
+        rule: d.rule ?? d.id ?? "unknown",
+        tool: d.tool,
+        message: d.message,
+        line: d.line ?? 1,
+        column: d.column,
+        fixable: d.fixable ?? false,
+        fixSuggestion: d.fixSuggestion,
+        autoFixed,
+        model,
+        provider
+      };
+      return JSON.stringify(entry);
+    }).join("\n") + "\n";
+    fs.appendFileSync(worklogPath, redactSecrets(lines), "utf8");
+  } catch {
+  }
+}
+function readWorklog(cwd) {
+  const worklogPath = getWorklogPath(cwd);
+  try {
+    const raw = fs.readFileSync(worklogPath, "utf8");
+    return raw.split(/\r?\n/).filter(Boolean).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function summarizeWorklog(cwd) {
+  const entries = readWorklog(cwd);
+  const byRule = /* @__PURE__ */ new Map();
+  let totalAutoFixed = 0;
+  let totalFixable = 0;
+  for (const e of entries) {
+    const r = byRule.get(e.rule) ?? { count: 0, autoFixed: 0 };
+    r.count++;
+    if (e.autoFixed) {
+      r.autoFixed++;
+      totalAutoFixed++;
+    }
+    if (e.fixable)
+      totalFixable++;
+    byRule.set(e.rule, r);
+  }
+  return {
+    totalAutoFixed,
+    totalFixable,
+    byRule: [...byRule.entries()].map(([rule, v]) => ({ rule, ...v })).sort((a, b) => b.count - a.count)
+  };
+}
+export {
+  appendToWorklog,
+  getWorklogPath,
+  readWorklog,
+  summarizeWorklog
+};