@ashx-j/lunr 0.2.16 → 0.2.18

package/dist/node-runtime/parallel-AI2MNSCU.js

@@ -0,0 +1,265 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/parallel.js
+import { existsSync, readFileSync } from "node:fs";
+var PARALLEL_SEARCH_URL = "https://api.parallel.ai/v1/search", PARALLEL_EXTRACT_URL = "https://api.parallel.ai/v1/extract", CONFIG_PATH = getWebSearchConfigPath(), MIN_PARALLEL_API_KEY_LENGTH = 8, MIN_USEFUL_CONTENT = 500, SEARCH_TIMEOUT_MS = 6e4, PLACEHOLDER_API_KEY_DENYLIST = /* @__PURE__ */ new Set([
+  "replace_with_your_parallel_api_key",
+  "parallel_api_key",
+  "your-key",
+  "your-key-here",
+  "your-api-key-here",
+  "dummy",
+  "placeholder",
+  "changeme",
+  "insert-your-key",
+  "insert-your-key-here",
+  "api-key",
+  "xxx"
+]), cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH))
+    return cachedConfig = {}, cachedConfig;
+  let raw = readFileSync(CONFIG_PATH, "utf-8");
+  try {
+    return cachedConfig = JSON.parse(raw), cachedConfig;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+}
+function clearParallelConfigCache() {
+  cachedConfig = null;
+}
+function normalizeApiKey(value) {
+  if (typeof value != "string")
+    return null;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function isPlaceholderApiKey(key) {
+  let normalized = key.trim();
+  return normalized.length < MIN_PARALLEL_API_KEY_LENGTH || PLACEHOLDER_API_KEY_DENYLIST.has(normalized.toLowerCase());
+}
+function resolveApiKey() {
+  let envKey = normalizeApiKey(process.env.PARALLEL_API_KEY);
+  if (envKey && !isPlaceholderApiKey(envKey))
+    return envKey;
+  let configKey = normalizeApiKey(loadConfig().parallelApiKey);
+  return configKey && !isPlaceholderApiKey(configKey) ? configKey : null;
+}
+function getApiKey() {
+  let key = resolveApiKey();
+  if (!key)
+    throw new Error(`Parallel API key not found. Either:
+  1. Create ${CONFIG_PATH} with { "parallelApiKey": "your-key" }
+  2. Set PARALLEL_API_KEY environment variable
+Get a key at https://platform.parallel.ai`);
+  return key;
+}
+function hasParallelApiKey() {
+  return !!resolveApiKey();
+}
+function isParallelAvailable() {
+  return hasParallelApiKey();
+}
+function requestSignal(signal) {
+  let timeout = AbortSignal.timeout(SEARCH_TIMEOUT_MS);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function activityContext(url, body) {
+  if (typeof body.objective == "string" && body.objective.trim().length > 0)
+    return { type: "api", query: body.objective };
+  let searchQueries = body.search_queries;
+  if (Array.isArray(searchQueries) && typeof searchQueries[0] == "string")
+    return { type: "api", query: searchQueries[0] };
+  let urls = body.urls;
+  return Array.isArray(urls) && typeof urls[0] == "string" ? { type: "fetch", url: urls[0] } : url.includes("/search") ? { type: "api", query: "Parallel search" } : { type: "fetch", url };
+}
+function recencyToAfterDate(filter) {
+  let now = /* @__PURE__ */ new Date(), days = { day: 1, week: 7, month: 30, year: 365 }[filter] ?? 0;
+  return new Date(now.getTime() - days * 864e5).toISOString().slice(0, 10);
+}
+function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input || (input.startsWith("-") && (input = input.slice(1).trim()), !input))
+    return null;
+  try {
+    input = (input.includes("://") ? new URL(input) : new URL(`https://${input}`)).hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  return input = input.replace(/^\.+|\.+$/g, ""), /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}
+function mapDomainFilter(domainFilter) {
+  if (!domainFilter?.length)
+    return {};
+  let include_domains = [], exclude_domains = [];
+  for (let raw of domainFilter) {
+    let domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    let target = raw.trim().startsWith("-") ? exclude_domains : include_domains;
+    target.includes(domain) || target.push(domain);
+  }
+  return {
+    ...include_domains.length ? { include_domains } : {},
+    ...exclude_domains.length ? { exclude_domains } : {}
+  };
+}
+function buildSearchRequestBody(query, options = {}) {
+  let numResults = Math.max(1, Math.min(Math.floor(options.numResults ?? 5), 20)), sourcePolicy = {
+    ...mapDomainFilter(options.domainFilter),
+    ...options.recencyFilter ? { after_date: recencyToAfterDate(options.recencyFilter) } : {}
+  };
+  return {
+    objective: query,
+    search_queries: [query],
+    advanced_settings: {
+      max_results: numResults,
+      ...Object.keys(sourcePolicy).length > 0 ? { source_policy: sourcePolicy } : {}
+    }
+  };
+}
+function normalizeExcerpts(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item == "string" && item.trim().length > 0) : [];
+}
+function mapSearchResults(results) {
+  if (!Array.isArray(results))
+    return [];
+  let mapped = [];
+  for (let i = 0; i < results.length; i++) {
+    let item = results[i];
+    if (!item?.url)
+      continue;
+    let excerpts = normalizeExcerpts(item.excerpts);
+    mapped.push({
+      title: item.title || `Source ${i + 1}`,
+      url: item.url,
+      snippet: excerpts.length > 0 ? excerpts[0].replace(/\s+/g, " ").trim().slice(0, 200) : ""
+    });
+  }
+  return mapped;
+}
+function buildAnswerFromExcerpts(results) {
+  if (!Array.isArray(results))
+    return "";
+  let parts = [];
+  for (let i = 0; i < results.length; i++) {
+    let item = results[i];
+    if (!item?.url)
+      continue;
+    let excerpts = normalizeExcerpts(item.excerpts);
+    excerpts.length !== 0 && parts.push(`${excerpts.join(" ")}
+Source: ${item.title || `Source ${i + 1}`} (${item.url})`);
+  }
+  return parts.join(`
+
+`);
+}
+function mapInlineContent(results) {
+  return Array.isArray(results) ? results.flatMap((result) => {
+    if (!result?.url)
+      return [];
+    let excerpts = normalizeExcerpts(result.excerpts);
+    return excerpts.length === 0 ? [] : [{ url: result.url, title: result.title || "", content: excerpts.join(`
+
+`), error: null }];
+  }) : [];
+}
+function resolveExtractContent(result) {
+  let fullContent = typeof result.full_content == "string" ? result.full_content.trim() : "";
+  return fullContent.length > 0 ? fullContent : normalizeExcerpts(result.excerpts).join(`
+
+`);
+}
+function mapExtractResult(result) {
+  if (!result?.url)
+    return null;
+  let content = resolveExtractContent(result);
+  return content.length < MIN_USEFUL_CONTENT ? null : {
+    url: result.url,
+    title: typeof result.title == "string" ? result.title.trim() : "",
+    content,
+    error: null
+  };
+}
+function buildExtractRequestBody(url, options = {}, fullContent = !1) {
+  let body = { urls: [url] }, prompt = options.prompt?.trim();
+  return prompt && (body.objective = prompt), fullContent && (body.advanced_settings = { full_content: !0 }), body;
+}
+function findExtractResult(results, url) {
+  if (Array.isArray(results))
+    return results.find((item) => item?.url === url) ?? results[0];
+}
+function hasExtractUrlError(errors, url) {
+  return Array.isArray(errors) ? errors.some((entry) => typeof entry == "string" ? entry === url : typeof entry == "object" && entry !== null && entry.url === url) : !1;
+}
+async function fetchAndMapExtractResult(url, body, signal) {
+  let data = await parallelFetch(PARALLEL_EXTRACT_URL, body, signal);
+  if (hasExtractUrlError(data.errors, url))
+    return { mapped: null, result: void 0 };
+  let result = findExtractResult(data.results, url);
+  return { mapped: mapExtractResult(result), result };
+}
+async function searchWithParallel(query, options = {}) {
+  let results = (await parallelFetch(PARALLEL_SEARCH_URL, buildSearchRequestBody(query, options), options.signal)).results, response = {
+    answer: buildAnswerFromExcerpts(results),
+    results: mapSearchResults(results)
+  };
+  if (options.includeContent) {
+    let inlineContent = mapInlineContent(results);
+    inlineContent.length > 0 && (response.inlineContent = inlineContent);
+  }
+  return response;
+}
+async function extractWithParallel(url, signal, options = {}) {
+  let initial = await fetchAndMapExtractResult(url, buildExtractRequestBody(url, options), signal);
+  return initial.mapped ? initial.mapped : !initial.result || resolveExtractContent(initial.result).length >= MIN_USEFUL_CONTENT ? null : (await fetchAndMapExtractResult(url, buildExtractRequestBody(url, options, !0), signal)).mapped;
+}
+async function parallelFetch(url, body, signal) {
+  let apiKey = getApiKey(), activityId = activityMonitor.logStart(activityContext(url, body)), response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: requestSignal(signal)
+    });
+  } catch (err) {
+    let message = errorMessage(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    let errorText = await response.text();
+    throw new Error(`Parallel API error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  try {
+    let data = await response.json();
+    return activityMonitor.logComplete(activityId, response.status), data;
+  } catch (err) {
+    throw activityMonitor.logComplete(activityId, response.status), new Error(`Parallel API returned invalid JSON: ${errorMessage(err)}`);
+  }
+}
+export {
+  clearParallelConfigCache,
+  extractWithParallel,
+  hasParallelApiKey,
+  isParallelAvailable,
+  searchWithParallel
+};

package/dist/node-runtime/parser-manager-TQHWYDH7.js

@@ -0,0 +1,152 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getLanguageIdFromPath
+} from "./chunk-3X3KZKMI.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/parser-manager.js
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import Parser from "web-tree-sitter";
+var require2 = createRequire(new URL("../builtin-extensions/pi-lsp-extension/src/tree-sitter/parser-manager.js", import.meta.url).href), LANGUAGE_TO_GRAMMAR = {
+  typescript: "tree-sitter-typescript.wasm",
+  typescriptreact: "tree-sitter-tsx.wasm",
+  javascript: "tree-sitter-javascript.wasm",
+  javascriptreact: "tree-sitter-javascript.wasm",
+  python: "tree-sitter-python.wasm",
+  rust: "tree-sitter-rust.wasm",
+  go: "tree-sitter-go.wasm",
+  java: "tree-sitter-java.wasm",
+  c: "tree-sitter-c.wasm",
+  cpp: "tree-sitter-cpp.wasm",
+  ruby: "tree-sitter-ruby.wasm",
+  kotlin: "tree-sitter-kotlin.wasm",
+  scala: "tree-sitter-scala.wasm",
+  swift: "tree-sitter-swift.wasm",
+  lua: "tree-sitter-lua.wasm",
+  bash: "tree-sitter-bash.wasm",
+  json: "tree-sitter-json.wasm",
+  html: "tree-sitter-html.wasm",
+  css: "tree-sitter-css.wasm"
+}, TreeSitterManager = class {
+  initialized = !1;
+  initializing = null;
+  languages = /* @__PURE__ */ new Map();
+  loadingLanguages = /* @__PURE__ */ new Map();
+  parsers = /* @__PURE__ */ new Map();
+  cachedTrees = /* @__PURE__ */ new Map();
+  grammarsDir;
+  constructor() {
+    let wasmsPkgJson = require2.resolve("tree-sitter-wasms/package.json");
+    this.grammarsDir = resolve(dirname(wasmsPkgJson), "out");
+  }
+  /** Initialize web-tree-sitter WASM runtime. Must be called before any parsing. */
+  async init() {
+    if (!this.initialized) {
+      if (this.initializing) {
+        await this.initializing;
+        return;
+      }
+      this.initializing = Parser.init({
+        locateFile: (scriptName) => {
+          let webTsPkgJson = require2.resolve("web-tree-sitter/package.json");
+          return resolve(dirname(webTsPkgJson), scriptName);
+        }
+      }), await this.initializing, this.initialized = !0;
+    }
+  }
+  /** Get the language ID for a file path based on extension */
+  getLanguageId(filePath) {
+    return getLanguageIdFromPath(filePath);
+  }
+  /** Check if we have a grammar available for a language */
+  hasGrammar(languageId) {
+    return languageId in LANGUAGE_TO_GRAMMAR;
+  }
+  /** Get all supported language IDs */
+  getSupportedLanguages() {
+    return Object.keys(LANGUAGE_TO_GRAMMAR);
+  }
+  /** Load a language grammar, caching the result */
+  async getLanguage(languageId) {
+    let cached = this.languages.get(languageId);
+    if (cached)
+      return cached;
+    let loading = this.loadingLanguages.get(languageId);
+    if (loading)
+      return loading;
+    let grammarFile = LANGUAGE_TO_GRAMMAR[languageId];
+    if (!grammarFile)
+      return null;
+    let loadPromise = (async () => {
+      await this.init();
+      try {
+        let grammarPath = resolve(this.grammarsDir, grammarFile), language = await Parser.Language.load(grammarPath);
+        return this.languages.set(languageId, language), language;
+      } catch {
+        return null;
+      } finally {
+        this.loadingLanguages.delete(languageId);
+      }
+    })();
+    return this.loadingLanguages.set(languageId, loadPromise), loadPromise;
+  }
+  /** Get or create a parser for a language */
+  async getParser(languageId) {
+    let existing = this.parsers.get(languageId);
+    if (existing)
+      return existing;
+    let language = await this.getLanguage(languageId);
+    if (!language)
+      return null;
+    let parser = new Parser();
+    return parser.setLanguage(language), this.parsers.set(languageId, parser), parser;
+  }
+  /** Parse a file's content and return the tree. Caches by file path + content hash. */
+  async parse(filePath, content) {
+    let languageId = this.getLanguageId(filePath);
+    return languageId ? this.parseWithLanguage(filePath, content, languageId) : null;
+  }
+  /** Parse content with an explicit language ID */
+  async parseWithLanguage(filePath, content, languageId) {
+    let length = content.length, head = djb2Hash(content, 0, Math.min(length, 4096)), tail = length > 4096 ? djb2Hash(content, Math.max(0, length - 4096), length) : head, cached = this.cachedTrees.get(filePath);
+    if (cached && cached.contentLength === length && cached.hashHead === head && cached.hashTail === tail)
+      return cached.tree;
+    let parser = await this.getParser(languageId);
+    if (!parser)
+      return null;
+    let tree = parser.parse(content);
+    return tree ? (cached && cached.tree.delete(), this.cachedTrees.set(filePath, { tree, contentLength: length, hashHead: head, hashTail: tail }), tree) : null;
+  }
+  /** Invalidate the cached tree for a file */
+  invalidate(filePath) {
+    let cached = this.cachedTrees.get(filePath);
+    cached && (cached.tree.delete(), this.cachedTrees.delete(filePath));
+  }
+  /** Get a cached tree without re-parsing */
+  getCachedTree(filePath) {
+    return this.cachedTrees.get(filePath)?.tree ?? null;
+  }
+  /** Shut down — free all resources */
+  shutdown() {
+    for (let [, cached] of this.cachedTrees)
+      cached.tree.delete();
+    this.cachedTrees.clear();
+    for (let [, parser] of this.parsers)
+      parser.delete();
+    this.parsers.clear(), this.languages.clear();
+  }
+  /** Alias for shutdown() — conventional dispose pattern for extension lifecycle */
+  dispose() {
+    this.shutdown();
+  }
+};
+function djb2Hash(str, start, end) {
+  let hash = 5381;
+  for (let i = start; i < end; i++)
+    hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
+  return hash;
+}
+export {
+  TreeSitterManager
+};

package/dist/node-runtime/pdf-extract-IPE6H4HP.js

@@ -0,0 +1,57 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/pdf-extract.js
+import { getDocumentProxy } from "unpdf";
+import { writeFile, mkdir } from "node:fs/promises";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+var DEFAULT_MAX_PAGES = 100, DEFAULT_OUTPUT_DIR = join(homedir(), "Downloads");
+async function extractPDFToMarkdown(buffer, url, options = {}) {
+  let { maxPages = DEFAULT_MAX_PAGES, outputDir = DEFAULT_OUTPUT_DIR, filename } = options, safeMaxPages = Number.isFinite(maxPages) ? Math.max(1, Math.floor(maxPages)) : DEFAULT_MAX_PAGES, pdf = await getDocumentProxy(new Uint8Array(buffer)), metadata = await pdf.getMetadata(), metadataInfo = metadata.info && typeof metadata.info == "object" ? metadata.info : null, metaTitle = typeof metadataInfo?.Title == "string" ? metadataInfo.Title : void 0, metaAuthor = typeof metadataInfo?.Author == "string" ? metadataInfo.Author : void 0, urlTitle = extractTitleFromURL(url), title = metaTitle?.trim() || urlTitle, pagesToExtract = Math.min(pdf.numPages, safeMaxPages), truncated = pdf.numPages > safeMaxPages, pages = [];
+  for (let i = 1; i <= pagesToExtract; i++) {
+    let pageText = (await (await pdf.getPage(i)).getTextContent()).items.map((item) => item.str || "").join(" ").replace(/\s+/g, " ").trim();
+    pageText && pages.push({ pageNum: i, text: pageText });
+  }
+  let lines = [];
+  lines.push(`# ${title}`), lines.push(""), lines.push(`> Source: ${url}`), lines.push(`> Pages: ${pdf.numPages}${truncated ? ` (extracted first ${pagesToExtract})` : ""}`), metaAuthor && lines.push(`> Author: ${metaAuthor}`), lines.push(""), lines.push("---"), lines.push("");
+  for (let i = 0; i < pages.length; i++)
+    i > 0 && (lines.push(""), lines.push(`<!-- Page ${pages[i].pageNum} -->`), lines.push("")), lines.push(pages[i].text);
+  truncated && (lines.push(""), lines.push("---"), lines.push(""), lines.push(`*[Truncated: Only first ${pagesToExtract} of ${pdf.numPages} pages extracted]*`));
+  let content = lines.join(`
+`), outputFilename = filename || sanitizeFilename(title) + ".md", outputPath = join(outputDir, outputFilename);
+  return await mkdir(outputDir, { recursive: !0 }), await writeFile(outputPath, content, "utf-8"), {
+    title,
+    pages: pdf.numPages,
+    chars: content.length,
+    outputPath
+  };
+}
+function extractTitleFromURL(url) {
+  try {
+    let urlObj = new URL(url), pathname = urlObj.pathname, filename = basename(pathname, ".pdf");
+    if (urlObj.hostname.includes("arxiv.org")) {
+      let match = pathname.match(/\/(?:pdf|abs)\/(\d+\.\d+)/);
+      match && (filename = `arxiv-${match[1]}`);
+    }
+    return filename = filename.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim(), filename || "document";
+  } catch {
+    return "document";
+  }
+}
+function sanitizeFilename(name) {
+  return name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 100).replace(/^-|-$/g, "") || "document";
+}
+function isPDF(url, contentType) {
+  if (contentType?.includes("application/pdf"))
+    return !0;
+  try {
+    return new URL(url).pathname.toLowerCase().endsWith(".pdf");
+  } catch {
+    return !1;
+  }
+}
+export {
+  extractPDFToMarkdown,
+  isPDF
+};

package/dist/node-runtime/perplexity-QVJW3I35.js

@@ -0,0 +1,12 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  isPerplexityAvailable,
+  searchWithPerplexity
+} from "./chunk-XBWPBZBN.js";
+import "./chunk-DAPBPCBP.js";
+import "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  isPerplexityAvailable,
+  searchWithPerplexity
+};