@ashx-j/lunr-dev 0.2.13-dev.7.1 → 0.2.16-dev.9.1

package/dist/node-runtime/brave-UWDA3I22.js

@@ -0,0 +1,143 @@
+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/brave.js
+import { existsSync, readFileSync } from "node:fs";
+var BRAVE_API_URL = "https://api.search.brave.com/res/v1/web/search", CONFIG_PATH = getWebSearchConfigPath(), SEARCH_TIMEOUT_MS = 3e4, 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 normalizeApiKey(value) {
+  if (typeof value != "string")
+    return null;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function getApiKey() {
+  return normalizeApiKey(process.env.BRAVE_API_KEY) ?? normalizeApiKey(loadConfig().braveApiKey);
+}
+function normalizeCount(value) {
+  return typeof value != "number" || !Number.isFinite(value) ? 5 : Math.max(1, Math.min(Math.floor(value), 20));
+}
+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 normalizeDomainFilters(domainFilter) {
+  let filters = { allowed: [], blocked: [] };
+  if (!domainFilter?.length)
+    return filters;
+  for (let raw of domainFilter) {
+    let domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    let target = raw.trim().startsWith("-") ? filters.blocked : filters.allowed;
+    target.includes(domain) || target.push(domain);
+  }
+  return filters;
+}
+function buildBraveQuery(query, domainFilter) {
+  let filters = normalizeDomainFilters(domainFilter), parts = [query];
+  filters.allowed.length === 1 ? parts.push(`site:${filters.allowed[0]}`) : filters.allowed.length > 1 && parts.push(filters.allowed.map((domain) => `site:${domain}`).join(" OR "));
+  for (let domain of filters.blocked)
+    parts.push(`NOT site:${domain}`);
+  return parts.join(" ");
+}
+function hostMatchesDomain(hostname, domain) {
+  return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+function matchesDomainFilters(url, filters) {
+  if (filters.allowed.length === 0 && filters.blocked.length === 0)
+    return !0;
+  let hostname = "";
+  try {
+    hostname = new URL(url).hostname.toLowerCase();
+  } catch {
+    return !1;
+  }
+  return filters.allowed.length > 0 && !filters.allowed.some((domain) => hostMatchesDomain(hostname, domain)) ? !1 : !filters.blocked.some((domain) => hostMatchesDomain(hostname, domain));
+}
+function isBraveAvailable() {
+  return !!getApiKey();
+}
+async function searchWithBrave(query, options = {}) {
+  let apiKey = getApiKey();
+  if (!apiKey)
+    throw new Error(`Brave Search API key not found. Either:
+  1. Create ${CONFIG_PATH} with { "braveApiKey": "your-key" }
+  2. Set BRAVE_API_KEY environment variable
+Get a key at https://brave.com/search/api/`);
+  let numResults = normalizeCount(options.numResults), domainFilters = normalizeDomainFilters(options.domainFilter), searchQuery = buildBraveQuery(query, options.domainFilter), activityId = activityMonitor.logStart({ type: "api", query: searchQuery }), params = new URLSearchParams({
+    q: searchQuery,
+    count: String(options.domainFilter?.length ? 20 : numResults)
+  });
+  if (options.recencyFilter) {
+    let freshness = {
+      day: "pd",
+      week: "pw",
+      month: "pm",
+      year: "py"
+    }[options.recencyFilter];
+    freshness && params.set("freshness", freshness);
+  }
+  try {
+    let response = await fetch(`${BRAVE_API_URL}?${params.toString()}`, {
+      method: "GET",
+      headers: {
+        "X-Subscription-Token": apiKey,
+        Accept: "application/json",
+        "Accept-Encoding": "gzip"
+      },
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      activityMonitor.logError(activityId, `HTTP ${response.status}`);
+      let errorText = await response.text();
+      throw new Error(`Brave Search API error ${response.status}: ${errorText.slice(0, 300)}`);
+    }
+    let data = await response.json();
+    activityMonitor.logComplete(activityId, response.status);
+    let results = [];
+    for (let item of data.web?.results ?? [])
+      if (!(!item.url || !matchesDomainFilters(item.url, domainFilters)) && (results.push({
+        title: item.title || item.url,
+        url: item.url,
+        snippet: item.description || ""
+      }), results.length >= numResults))
+        break;
+    return { answer: results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`), results };
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+}
+export {
+  isBraveAvailable,
+  searchWithBrave
+};

package/dist/node-runtime/builtin-extensions-LYZ3BFWQ.js

@@ -0,0 +1,28 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  DEFERRED_BUILTIN_EXTENSION_NAMES,
+  DEFERRED_BUILTIN_FLAGS,
+  builtinExtensions,
+  lightBuiltinExtensions,
+  loadAllBuiltinExtensions,
+  loadDeferredBuiltinExtensions
+} from "./chunk-PCGNAY2O.js";
+import "./chunk-LZAW4ZX3.js";
+import "./chunk-M3LZLQW2.js";
+import "./chunk-PL6JKXWI.js";
+import "./chunk-JHYKXIMM.js";
+import "./chunk-H2EOZYMP.js";
+import "./chunk-PVCDKGR6.js";
+import "./chunk-C4O2RSQQ.js";
+import "./chunk-MX3GJNXJ.js";
+import "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  DEFERRED_BUILTIN_EXTENSION_NAMES,
+  DEFERRED_BUILTIN_FLAGS,
+  builtinExtensions,
+  lightBuiltinExtensions,
+  loadAllBuiltinExtensions,
+  loadDeferredBuiltinExtensions
+};

package/dist/node-runtime/chunk-2QKLKMKC.js

@@ -0,0 +1,173 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  require_proper_lockfile
+} from "./chunk-AJX357CL.js";
+import {
+  CONFIG_DIR_NAME,
+  canonicalizePath,
+  resolvePath
+} from "./chunk-PCIGF2XK.js";
+import {
+  __toESM
+} from "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/trust-manager.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES = [
+  "settings.json",
+  "extensions",
+  "skills",
+  "prompts",
+  "themes",
+  "SYSTEM.md",
+  "APPEND_SYSTEM.md"
+];
+function normalizeCwd(cwd) {
+  return canonicalizePath(resolvePath(cwd));
+}
+function findNearestTrustEntry(data, cwd) {
+  let currentDir = normalizeCwd(cwd);
+  for (; ; ) {
+    let value = data[currentDir];
+    if (value === !0 || value === !1)
+      return { path: currentDir, decision: value };
+    let parentDir = dirname(currentDir);
+    if (parentDir === currentDir)
+      return null;
+    currentDir = parentDir;
+  }
+}
+function getProjectTrustParentPath(cwd) {
+  let trustPath = normalizeCwd(cwd), parentDir = dirname(trustPath);
+  return parentDir === trustPath ? void 0 : parentDir;
+}
+function getProjectTrustOptions(cwd, options) {
+  let trustPath = normalizeCwd(cwd), trustOptions = [
+    { label: "Trust", trusted: !0, updates: [{ path: trustPath, decision: !0 }], savedPath: trustPath }
+  ], parentPath = getProjectTrustParentPath(cwd);
+  return parentPath !== void 0 && trustOptions.push({
+    label: `Trust parent folder (${parentPath})`,
+    trusted: !0,
+    updates: [
+      { path: parentPath, decision: !0 },
+      { path: trustPath, decision: null }
+    ],
+    savedPath: parentPath
+  }), options?.includeSessionOnly && trustOptions.push({ label: "Trust (this session only)", trusted: !0, updates: [] }), trustOptions.push({
+    label: "Do not trust",
+    trusted: !1,
+    updates: [{ path: trustPath, decision: !1 }],
+    savedPath: trustPath
+  }), options?.includeSessionOnly && trustOptions.push({ label: "Do not trust (this session only)", trusted: !1, updates: [] }), trustOptions;
+}
+function readTrustFile(path) {
+  if (!existsSync(path))
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read trust store ${path}: ${message}`);
+  }
+  if (typeof parsed != "object" || parsed === null || Array.isArray(parsed))
+    throw new Error(`Invalid trust store ${path}: expected an object`);
+  let data = {};
+  for (let [key, value] of Object.entries(parsed)) {
+    if (value !== !0 && value !== !1 && value !== null)
+      throw new Error(`Invalid trust store ${path}: value for ${JSON.stringify(key)} must be true, false, or null`);
+    data[key] = value;
+  }
+  return data;
+}
+function writeTrustFile(path, data) {
+  let sorted = {};
+  for (let key of Object.keys(data).sort()) {
+    let value = data[key];
+    (value === !0 || value === !1 || value === null) && (sorted[key] = value);
+  }
+  mkdirSync(dirname(path), { recursive: !0 }), writeFileSync(path, `${JSON.stringify(sorted, null, 2)}
+`, "utf-8");
+}
+function acquireTrustLockSync(path) {
+  let trustDir = dirname(path);
+  mkdirSync(trustDir, { recursive: !0 });
+  let maxAttempts = 10, delayMs = 20, lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++)
+    try {
+      return import_proper_lockfile.default.lockSync(trustDir, { realpath: !1, lockfilePath: `${path}.lock` });
+    } catch (error) {
+      if ((typeof error == "object" && error !== null && "code" in error ? String(error.code) : void 0) !== "ELOCKED" || attempt === maxAttempts)
+        throw error;
+      lastError = error;
+      let start = Date.now();
+      for (; Date.now() - start < delayMs; )
+        ;
+    }
+  throw lastError instanceof Error ? lastError : new Error("Failed to acquire trust store lock");
+}
+function withTrustFileLock(path, fn) {
+  let release = acquireTrustLockSync(path);
+  try {
+    return fn();
+  } finally {
+    release();
+  }
+}
+function hasTrustRequiringProjectResources(cwd) {
+  let homeDir = canonicalizePath(resolvePath(process.env.HOME || homedir())), userAgentsSkillsDir = join(homeDir, ".agents", "skills"), currentDir = canonicalizePath(resolvePath(cwd)), configDir = join(currentDir, CONFIG_DIR_NAME);
+  if (TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES.some((entry) => existsSync(join(configDir, entry))))
+    return !0;
+  for (; ; ) {
+    let agentsSkillsDir = join(currentDir, ".agents", "skills");
+    if (agentsSkillsDir !== userAgentsSkillsDir && existsSync(agentsSkillsDir))
+      return !0;
+    let parentDir = dirname(currentDir);
+    if (parentDir === currentDir)
+      return !1;
+    currentDir = parentDir;
+  }
+}
+var ProjectTrustStore = class {
+  trustPath;
+  constructor(agentDir) {
+    this.trustPath = join(resolvePath(agentDir), "trust.json");
+  }
+  get(cwd) {
+    return this.getEntry(cwd)?.decision ?? null;
+  }
+  getEntry(cwd) {
+    return withTrustFileLock(this.trustPath, () => {
+      let data = readTrustFile(this.trustPath);
+      return findNearestTrustEntry(data, cwd);
+    });
+  }
+  set(cwd, decision) {
+    this.setMany([{ path: cwd, decision }]);
+  }
+  setMany(decisions) {
+    withTrustFileLock(this.trustPath, () => {
+      let data = readTrustFile(this.trustPath);
+      for (let { path, decision } of decisions) {
+        let key = normalizeCwd(path);
+        decision === null ? delete data[key] : data[key] = decision;
+      }
+      writeTrustFile(this.trustPath, data);
+    });
+  }
+};
+
+// packages/coding-agent/dist/core/experimental.js
+function areExperimentalFeaturesEnabled() {
+  return process.env.PI_EXPERIMENTAL === "1";
+}
+
+export {
+  areExperimentalFeaturesEnabled,
+  getProjectTrustOptions,
+  hasTrustRequiringProjectResources,
+  ProjectTrustStore
+};

package/dist/node-runtime/chunk-3GHXVUAK.js

@@ -0,0 +1,21 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  theme
+} from "./chunk-MX3GJNXJ.js";
+
+// packages/coding-agent/dist/modes/interactive/components/dynamic-border.js
+var DynamicBorder = class {
+  color;
+  constructor(color = (str) => theme.fg("border", str)) {
+    this.color = color;
+  }
+  invalidate() {
+  }
+  render(width) {
+    return [this.color("\u2500".repeat(Math.max(1, width)))];
+  }
+};
+
+export {
+  DynamicBorder
+};