@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/chunk-AUXVGBO4.js

@@ -0,0 +1,19 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/session-cleanup.js
+var cleanups = [];
+function registerSessionCleanup(fn) {
+  cleanups.includes(fn) || cleanups.push(fn);
+}
+function runSessionCleanups() {
+  for (let fn of cleanups)
+    try {
+      fn();
+    } catch {
+    }
+}
+
+export {
+  registerSessionCleanup,
+  runSessionCleanups
+};

package/dist/node-runtime/chunk-AY6CAJSL.js

@@ -0,0 +1,30 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/memory-cap.js
+var MEMORY_CAP_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/memory-cap"), MEMORY_CHAR_CAP_DEFAULT = 5e3, MEMORY_CHAR_CAP_MIN = 1, MEMORY_CHAR_CAP_MAX = 3e4, MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set(["memory_add", "memory_remove", "memory_load"]), activeSettingsManager, bridge = {
+  isEnabled() {
+    return activeSettingsManager?.getMemoryEnabled() ?? !0;
+  },
+  getCharCap() {
+    return activeSettingsManager?.getMemoryCharCap() ?? MEMORY_CHAR_CAP_DEFAULT;
+  },
+  setCharCap(cap) {
+    activeSettingsManager?.setMemoryCharCap(cap);
+  }
+};
+function registerMemoryCapBridge(settingsManager) {
+  activeSettingsManager = settingsManager, globalThis[MEMORY_CAP_BRIDGE_SYMBOL] = bridge;
+}
+function getMemoryCapBridge() {
+  return globalThis[MEMORY_CAP_BRIDGE_SYMBOL];
+}
+
+export {
+  MEMORY_CAP_BRIDGE_SYMBOL,
+  MEMORY_CHAR_CAP_DEFAULT,
+  MEMORY_CHAR_CAP_MIN,
+  MEMORY_CHAR_CAP_MAX,
+  MEMORY_TOOL_NAMES,
+  registerMemoryCapBridge,
+  getMemoryCapBridge
+};

package/dist/node-runtime/chunk-BHO7O6E5.js

@@ -0,0 +1,296 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/symbol-extractor.js
+var SymbolKind = {
+  File: 1,
+  Module: 2,
+  Namespace: 3,
+  Package: 4,
+  Class: 5,
+  Method: 6,
+  Property: 7,
+  Field: 8,
+  Constructor: 9,
+  Enum: 10,
+  Interface: 11,
+  Function: 12,
+  Variable: 13,
+  Constant: 14,
+  String: 15,
+  Number: 16,
+  Boolean: 17,
+  Array: 18,
+  Object: 19,
+  Struct: 22
+}, TS_JS_SYMBOLS = [
+  { nodeType: "function_declaration", kind: SymbolKind.Function },
+  { nodeType: "class_declaration", kind: SymbolKind.Class, recurse: !0 },
+  { nodeType: "interface_declaration", kind: SymbolKind.Interface, recurse: !0 },
+  { nodeType: "enum_declaration", kind: SymbolKind.Enum, recurse: !0 },
+  { nodeType: "type_alias_declaration", kind: SymbolKind.Variable },
+  { nodeType: "method_definition", kind: SymbolKind.Method },
+  { nodeType: "public_field_definition", kind: SymbolKind.Field },
+  { nodeType: "abstract_method_signature", kind: SymbolKind.Method },
+  { nodeType: "lexical_declaration", kind: SymbolKind.Variable },
+  { nodeType: "variable_declaration", kind: SymbolKind.Variable }
+], PYTHON_SYMBOLS = [
+  { nodeType: "function_definition", kind: SymbolKind.Function },
+  { nodeType: "class_definition", kind: SymbolKind.Class, recurse: !0 },
+  { nodeType: "decorated_definition", kind: SymbolKind.Function }
+], RUST_SYMBOLS = [
+  { nodeType: "function_item", kind: SymbolKind.Function },
+  { nodeType: "struct_item", kind: SymbolKind.Struct },
+  { nodeType: "enum_item", kind: SymbolKind.Enum, recurse: !0 },
+  { nodeType: "impl_item", kind: SymbolKind.Class, recurse: !0 },
+  { nodeType: "trait_item", kind: SymbolKind.Interface, recurse: !0 },
+  { nodeType: "mod_item", kind: SymbolKind.Module, recurse: !0 },
+  { nodeType: "type_item", kind: SymbolKind.Variable },
+  { nodeType: "const_item", kind: SymbolKind.Constant },
+  { nodeType: "static_item", kind: SymbolKind.Constant },
+  { nodeType: "macro_definition", kind: SymbolKind.Function }
+], GO_SYMBOLS = [
+  { nodeType: "function_declaration", kind: SymbolKind.Function },
+  { nodeType: "method_declaration", kind: SymbolKind.Method },
+  { nodeType: "type_declaration", kind: SymbolKind.Class },
+  { nodeType: "type_spec", kind: SymbolKind.Class },
+  { nodeType: "const_declaration", kind: SymbolKind.Constant },
+  { nodeType: "var_declaration", kind: SymbolKind.Variable }
+], JAVA_SYMBOLS = [
+  { nodeType: "class_declaration", kind: SymbolKind.Class, recurse: !0 },
+  { nodeType: "interface_declaration", kind: SymbolKind.Interface, recurse: !0 },
+  { nodeType: "enum_declaration", kind: SymbolKind.Enum, recurse: !0 },
+  { nodeType: "method_declaration", kind: SymbolKind.Method },
+  { nodeType: "constructor_declaration", kind: SymbolKind.Constructor },
+  { nodeType: "field_declaration", kind: SymbolKind.Field },
+  { nodeType: "annotation_type_declaration", kind: SymbolKind.Interface }
+], C_CPP_SYMBOLS = [
+  { nodeType: "function_definition", kind: SymbolKind.Function },
+  { nodeType: "declaration", kind: SymbolKind.Variable },
+  { nodeType: "struct_specifier", kind: SymbolKind.Struct },
+  { nodeType: "enum_specifier", kind: SymbolKind.Enum },
+  { nodeType: "class_specifier", kind: SymbolKind.Class, recurse: !0 },
+  { nodeType: "namespace_definition", kind: SymbolKind.Namespace, recurse: !0 }
+], RUBY_SYMBOLS = [
+  { nodeType: "method", kind: SymbolKind.Method },
+  { nodeType: "singleton_method", kind: SymbolKind.Method },
+  { nodeType: "class", kind: SymbolKind.Class, recurse: !0 },
+  { nodeType: "module", kind: SymbolKind.Module, recurse: !0 }
+], LANGUAGE_SYMBOLS = {
+  typescript: TS_JS_SYMBOLS,
+  typescriptreact: TS_JS_SYMBOLS,
+  javascript: TS_JS_SYMBOLS,
+  javascriptreact: TS_JS_SYMBOLS,
+  python: PYTHON_SYMBOLS,
+  rust: RUST_SYMBOLS,
+  go: GO_SYMBOLS,
+  java: JAVA_SYMBOLS,
+  c: C_CPP_SYMBOLS,
+  cpp: C_CPP_SYMBOLS,
+  ruby: RUBY_SYMBOLS
+};
+function extractSymbols(tree, languageId) {
+  let mappings = LANGUAGE_SYMBOLS[languageId];
+  return mappings ? extractFromNode(tree.rootNode, mappings, languageId) : extractGenericSymbols(tree);
+}
+function extractFromNode(node, mappings, languageId, deep = !1) {
+  let symbols = [];
+  for (let child of node.namedChildren) {
+    let mapping = mappings.find((m) => m.nodeType === child.type);
+    if (mapping) {
+      let name = extractName(child, mapping, languageId);
+      if (name) {
+        let sym = {
+          name,
+          kind: mapping.kind,
+          line: child.startPosition.row + 1,
+          endLine: child.endPosition.row + 1
+        };
+        if (mapping.recurse) {
+          let children = extractFromNode(child, mappings, languageId, !0);
+          children.length > 0 && (sym.children = children);
+        }
+        symbols.push(sym);
+      }
+    } else if (child.type === "export_statement" && (languageId.startsWith("typescript") || languageId.startsWith("javascript"))) {
+      let inner = extractFromNode(child, mappings, languageId, deep);
+      symbols.push(...inner);
+    } else deep && child.namedChildCount > 0 && symbols.push(...extractFromNode(child, mappings, languageId, !0));
+  }
+  return symbols;
+}
+function extractName(node, mapping, languageId) {
+  let nameNode = node.childForFieldName(mapping.nameField ?? "name");
+  if (nameNode)
+    return nameNode.text;
+  switch (node.type) {
+    case "lexical_declaration":
+    case "variable_declaration": {
+      let declarator = node.namedChildren.find((c) => c.type === "variable_declarator" || c.type === "init_declarator");
+      return declarator ? declarator.childForFieldName("name")?.text ?? null : null;
+    }
+    case "decorated_definition": {
+      let inner = node.namedChildren.find((c) => c.type === "function_definition" || c.type === "class_definition");
+      return inner ? inner.childForFieldName("name")?.text ?? null : null;
+    }
+    case "impl_item": {
+      let typeNode = node.childForFieldName("type");
+      return typeNode ? `impl ${typeNode.text}` : null;
+    }
+    case "type_declaration": {
+      let spec = node.namedChildren.find((c) => c.type === "type_spec");
+      return spec ? spec.childForFieldName("name")?.text ?? null : null;
+    }
+    case "const_declaration":
+    case "var_declaration": {
+      let spec = node.namedChildren.find((c) => c.type === "const_spec" || c.type === "var_spec");
+      return spec ? spec.childForFieldName("name")?.text ?? null : null;
+    }
+    case "field_declaration": {
+      let declarator = node.namedChildren.find((c) => c.type === "variable_declarator");
+      return declarator ? declarator.childForFieldName("name")?.text ?? null : null;
+    }
+    case "declaration": {
+      let declarator = node.namedChildren.find((c) => c.type === "init_declarator" || c.type === "function_declarator");
+      return declarator ? (declarator.childForFieldName("declarator") ?? declarator.childForFieldName("name"))?.text ?? null : null;
+    }
+    default:
+      break;
+  }
+  let first = node.firstNamedChild;
+  return first && first.text.length < 60 ? first.text : null;
+}
+function extractGenericSymbols(tree) {
+  let symbols = [], root = tree.rootNode;
+  for (let child of root.namedChildren)
+    if (child.type.includes("function") || child.type.includes("method")) {
+      let name = child.childForFieldName("name")?.text;
+      name && symbols.push({
+        name,
+        kind: SymbolKind.Function,
+        line: child.startPosition.row + 1,
+        endLine: child.endPosition.row + 1
+      });
+    } else if (child.type.includes("class") || child.type.includes("struct")) {
+      let name = child.childForFieldName("name")?.text;
+      name && symbols.push({
+        name,
+        kind: SymbolKind.Class,
+        line: child.startPosition.row + 1,
+        endLine: child.endPosition.row + 1
+      });
+    }
+  return symbols;
+}
+function getNodeAtPosition(tree, line, character) {
+  let point = { row: line, column: character };
+  return tree.rootNode.namedDescendantForPosition(point);
+}
+function findDefinition(tree, symbolName, languageId) {
+  let allSymbols = extractSymbols(tree, languageId);
+  return findSymbolByName(allSymbols, symbolName);
+}
+function findSymbolByName(symbols, name) {
+  let results = [];
+  for (let sym of symbols)
+    sym.name === name && results.push(sym), sym.children && results.push(...findSymbolByName(sym.children, name));
+  return results;
+}
+function getSyntaxErrors(tree) {
+  let errors = [];
+  function walk(node) {
+    if (node.isError)
+      errors.push({
+        line: node.startPosition.row,
+        character: node.startPosition.column,
+        endLine: node.endPosition.row,
+        endCharacter: node.endPosition.column,
+        message: `Syntax error: unexpected "${node.text.slice(0, 50)}${node.text.length > 50 ? "..." : ""}"`
+      });
+    else if (node.isMissing)
+      errors.push({
+        line: node.startPosition.row,
+        character: node.startPosition.column,
+        endLine: node.endPosition.row,
+        endCharacter: node.endPosition.column,
+        message: `Missing ${node.type}`
+      });
+    else if (node.hasError)
+      for (let child of node.children)
+        walk(child);
+  }
+  return walk(tree.rootNode), errors;
+}
+function getSignatureText(node) {
+  return node.text.split(`
+`)[0].replace(/\s*[{:]\s*$/, "").trim();
+}
+function getEnclosingDeclaration(tree, line, character) {
+  let point = { row: line, column: character }, node = tree.rootNode.namedDescendantForPosition(point), declarationTypes = /* @__PURE__ */ new Set([
+    "function_declaration",
+    "function_definition",
+    "function_item",
+    "method_declaration",
+    "method_definition",
+    "class_declaration",
+    "class_definition",
+    "class_specifier",
+    "interface_declaration",
+    "enum_declaration",
+    "enum_item",
+    "struct_item",
+    "impl_item",
+    "trait_item",
+    "mod_item",
+    "type_alias_declaration",
+    "type_declaration",
+    "variable_declarator",
+    "lexical_declaration",
+    "const_item",
+    "static_item",
+    "decorated_definition"
+  ]);
+  for (; node; ) {
+    if (declarationTypes.has(node.type))
+      return node;
+    node = node.parent;
+  }
+  return null;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/shared/constants.js
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "build",
+  "dist",
+  "target",
+  "out",
+  ".next",
+  "__pycache__",
+  ".tox",
+  ".venv",
+  "venv",
+  ".mypy_cache",
+  ".pytest_cache",
+  "vendor",
+  ".gradle",
+  ".idea",
+  ".vscode",
+  ".bemol",
+  "env",
+  "coverage",
+  ".nyc_output",
+  ".cache"
+]), MAX_FILE_SIZE = 500 * 1024, MAX_INDEX_FILES = 5e3;
+
+export {
+  extractSymbols,
+  getNodeAtPosition,
+  findDefinition,
+  getSyntaxErrors,
+  getSignatureText,
+  getEnclosingDeclaration,
+  SKIP_DIRS,
+  MAX_FILE_SIZE,
+  MAX_INDEX_FILES
+};