@ashx-j/lunr 0.2.16 → 0.2.18

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

@@ -0,0 +1,173 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  require_proper_lockfile
+} from "./chunk-CBGB57XT.js";
+import {
+  CONFIG_DIR_NAME,
+  canonicalizePath,
+  resolvePath
+} from "./chunk-FQMM2EZ2.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
+};