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

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

@@ -0,0 +1,466 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  flushRawStdout,
+  takeOverStdout,
+  waitForRawStdoutBackpressure,
+  writeRawStdout
+} from "./chunk-OBMWP3I5.js";
+import {
+  killTrackedDetachedChildren
+} from "./chunk-ZCHMJ34K.js";
+import {
+  theme
+} from "./chunk-MX3GJNXJ.js";
+
+// packages/coding-agent/dist/modes/rpc/rpc-mode.js
+import * as crypto from "node:crypto";
+
+// packages/coding-agent/dist/modes/rpc/jsonl.js
+import { StringDecoder } from "node:string_decoder";
+function serializeJsonLine(value) {
+  return `${JSON.stringify(value)}
+`;
+}
+function attachJsonlLineReader(stream, onLine) {
+  let decoder = new StringDecoder("utf8"), buffer = "", emitLine = (line) => {
+    onLine(line.endsWith("\r") ? line.slice(0, -1) : line);
+  }, onData = (chunk) => {
+    for (buffer += typeof chunk == "string" ? chunk : decoder.write(chunk); ; ) {
+      let newlineIndex = buffer.indexOf(`
+`);
+      if (newlineIndex === -1)
+        return;
+      emitLine(buffer.slice(0, newlineIndex)), buffer = buffer.slice(newlineIndex + 1);
+    }
+  }, onEnd = () => {
+    buffer += decoder.end(), buffer.length > 0 && (emitLine(buffer), buffer = "");
+  };
+  return stream.on("data", onData), stream.on("end", onEnd), () => {
+    stream.off("data", onData), stream.off("end", onEnd);
+  };
+}
+
+// packages/coding-agent/dist/modes/rpc/rpc-mode.js
+async function runRpcMode(runtimeHost) {
+  takeOverStdout();
+  let session = runtimeHost.session, unsubscribe, unsubscribeBackpressure, output = (obj) => {
+    writeRawStdout(serializeJsonLine(obj));
+  }, success = (id, command, data) => data === void 0 ? { id, type: "response", command, success: !0 } : { id, type: "response", command, success: !0, data }, error = (id, command, message) => ({ id, type: "response", command, success: !1, error: message }), pendingExtensionRequests = /* @__PURE__ */ new Map(), shutdownRequested = !1, shuttingDown = !1, signalCleanupHandlers = [];
+  function createDialogPromise(opts, defaultValue, request, parseResponse) {
+    if (opts?.signal?.aborted)
+      return Promise.resolve(defaultValue);
+    let id = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      let timeoutId, cleanup = () => {
+        timeoutId && clearTimeout(timeoutId), opts?.signal?.removeEventListener("abort", onAbort), pendingExtensionRequests.delete(id);
+      }, onAbort = () => {
+        cleanup(), resolve(defaultValue);
+      };
+      opts?.signal?.addEventListener("abort", onAbort, { once: !0 }), opts?.timeout && (timeoutId = setTimeout(() => {
+        cleanup(), resolve(defaultValue);
+      }, opts.timeout)), pendingExtensionRequests.set(id, {
+        resolve: (response) => {
+          cleanup(), resolve(parseResponse(response));
+        },
+        reject
+      }), output({ type: "extension_ui_request", id, ...request });
+    });
+  }
+  let createExtensionUIContext = () => ({
+    select: (title, options, opts) => createDialogPromise(opts, void 0, { method: "select", title, options, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? void 0 : "value" in r ? r.value : void 0),
+    confirm: (title, message, opts) => createDialogPromise(opts, !1, { method: "confirm", title, message, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? !1 : "confirmed" in r ? r.confirmed : !1),
+    input: (title, placeholder, opts) => createDialogPromise(opts, void 0, { method: "input", title, placeholder, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? void 0 : "value" in r ? r.value : void 0),
+    notify(message, type) {
+      output({
+        type: "extension_ui_request",
+        id: crypto.randomUUID(),
+        method: "notify",
+        message,
+        notifyType: type
+      });
+    },
+    onTerminalInput() {
+      return () => {
+      };
+    },
+    setStatus(key, text) {
+      output({
+        type: "extension_ui_request",
+        id: crypto.randomUUID(),
+        method: "setStatus",
+        statusKey: key,
+        statusText: text
+      });
+    },
+    setWorkingMessage(_message) {
+    },
+    setWorkingVisible(_visible) {
+    },
+    setWorkingIndicator(_options) {
+    },
+    setHiddenThinkingLabel(_label) {
+    },
+    setWidget(key, content, options) {
+      (content === void 0 || Array.isArray(content)) && output({
+        type: "extension_ui_request",
+        id: crypto.randomUUID(),
+        method: "setWidget",
+        widgetKey: key,
+        widgetLines: content,
+        widgetPlacement: options?.placement
+      });
+    },
+    setFooter(_factory) {
+    },
+    setHeader(_factory) {
+    },
+    setTitle(title) {
+      output({
+        type: "extension_ui_request",
+        id: crypto.randomUUID(),
+        method: "setTitle",
+        title
+      });
+    },
+    async custom() {
+    },
+    pasteToEditor(text) {
+      this.setEditorText(text);
+    },
+    setEditorText(text) {
+      output({
+        type: "extension_ui_request",
+        id: crypto.randomUUID(),
+        method: "set_editor_text",
+        text
+      });
+    },
+    getEditorText() {
+      return "";
+    },
+    async editor(title, prefill) {
+      let id = crypto.randomUUID();
+      return new Promise((resolve, reject) => {
+        pendingExtensionRequests.set(id, {
+          resolve: (response) => {
+            "cancelled" in response && response.cancelled ? resolve(void 0) : "value" in response ? resolve(response.value) : resolve(void 0);
+          },
+          reject
+        }), output({ type: "extension_ui_request", id, method: "editor", title, prefill });
+      });
+    },
+    addAutocompleteProvider() {
+    },
+    setEditorComponent() {
+    },
+    getEditorComponent() {
+    },
+    get theme() {
+      return theme;
+    },
+    getAllThemes() {
+      return [];
+    },
+    getTheme(_name) {
+    },
+    setTheme(_theme) {
+      return { success: !1, error: "Theme switching not supported in RPC mode" };
+    },
+    getToolsExpanded() {
+      return !1;
+    },
+    setToolsExpanded(_expanded) {
+    }
+  });
+  runtimeHost.setRebindSession(async () => {
+    await rebindSession();
+  });
+  let rebindSession = async () => {
+    session = runtimeHost.session, await session.bindExtensions({
+      uiContext: createExtensionUIContext(),
+      mode: "rpc",
+      commandContextActions: {
+        waitForIdle: () => session.waitForIdle(),
+        newSession: async (options) => runtimeHost.newSession(options),
+        fork: async (entryId, forkOptions) => ({ cancelled: (await runtimeHost.fork(entryId, forkOptions)).cancelled }),
+        navigateTree: async (targetId, options) => ({ cancelled: (await session.navigateTree(targetId, {
+          summarize: options?.summarize,
+          customInstructions: options?.customInstructions,
+          replaceInstructions: options?.replaceInstructions,
+          label: options?.label
+        })).cancelled }),
+        switchSession: async (sessionPath, options) => runtimeHost.switchSession(sessionPath, options),
+        reload: async () => {
+          await session.reload();
+        }
+      },
+      shutdownHandler: () => {
+        shutdownRequested = !0;
+      },
+      onError: (err) => {
+        output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error });
+      }
+    }), unsubscribe?.(), unsubscribeBackpressure?.(), unsubscribe = session.subscribe((event) => {
+      output(event), event.type === "agent_settled" && checkShutdownRequested();
+    }), unsubscribeBackpressure = session.agent.subscribe(async () => {
+      await waitForRawStdoutBackpressure();
+    });
+  }, registerSignalHandlers = () => {
+    let signals = ["SIGTERM"];
+    process.platform !== "win32" && signals.push("SIGHUP");
+    for (let signal of signals) {
+      let handler = () => {
+        killTrackedDetachedChildren(), shutdown(signal === "SIGHUP" ? 129 : 143, signal);
+      };
+      process.on(signal, handler), signalCleanupHandlers.push(() => process.off(signal, handler));
+    }
+  };
+  await rebindSession(), registerSignalHandlers();
+  let handleCommand = async (command) => {
+    let id = command.id;
+    switch (command.type) {
+      // =================================================================
+      // Prompting
+      // =================================================================
+      case "prompt": {
+        let preflightSucceeded = !1;
+        session.prompt(command.message, {
+          images: command.images,
+          streamingBehavior: command.streamingBehavior,
+          source: "rpc",
+          preflightResult: (didSucceed) => {
+            didSucceed && (preflightSucceeded = !0, output(success(id, "prompt")));
+          }
+        }).catch((e) => {
+          preflightSucceeded || output(error(id, "prompt", e.message));
+        });
+        return;
+      }
+      case "steer":
+        return await session.steer(command.message, command.images), success(id, "steer");
+      case "follow_up":
+        return await session.followUp(command.message, command.images), success(id, "follow_up");
+      case "abort":
+        return await session.abort(), success(id, "abort");
+      case "new_session": {
+        let options = command.parentSession ? { parentSession: command.parentSession } : void 0, result = await runtimeHost.newSession(options);
+        return result.cancelled || await rebindSession(), success(id, "new_session", result);
+      }
+      // =================================================================
+      // State
+      // =================================================================
+      case "get_state": {
+        let state = {
+          model: session.model,
+          thinkingLevel: session.thinkingLevel,
+          isStreaming: session.isStreaming,
+          isCompacting: session.isCompacting,
+          steeringMode: session.steeringMode,
+          followUpMode: session.followUpMode,
+          sessionFile: session.sessionFile,
+          sessionId: session.sessionId,
+          sessionName: session.sessionName,
+          autoCompactionEnabled: session.autoCompactionEnabled,
+          messageCount: session.messages.length,
+          pendingMessageCount: session.pendingMessageCount
+        };
+        return success(id, "get_state", state);
+      }
+      // =================================================================
+      // Model
+      // =================================================================
+      case "set_model": {
+        let model = (await session.modelRuntime.getAvailable()).find((m) => m.provider === command.provider && m.id === command.modelId);
+        return model ? (await session.setModel(model), success(id, "set_model", model)) : error(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
+      }
+      case "cycle_model": {
+        let result = await session.cycleModel();
+        return result ? success(id, "cycle_model", result) : success(id, "cycle_model", null);
+      }
+      case "get_available_models": {
+        let models = await session.modelRuntime.getAvailable();
+        return success(id, "get_available_models", { models });
+      }
+      // =================================================================
+      // Thinking
+      // =================================================================
+      case "set_thinking_level":
+        return session.setThinkingLevel(command.level), success(id, "set_thinking_level");
+      case "cycle_thinking_level": {
+        let level = session.cycleThinkingLevel();
+        return level ? success(id, "cycle_thinking_level", { level }) : success(id, "cycle_thinking_level", null);
+      }
+      // =================================================================
+      // Queue Modes
+      // =================================================================
+      case "set_steering_mode":
+        return session.setSteeringMode(command.mode), success(id, "set_steering_mode");
+      case "set_follow_up_mode":
+        return session.setFollowUpMode(command.mode), success(id, "set_follow_up_mode");
+      // =================================================================
+      // Compaction
+      // =================================================================
+      case "compact": {
+        let result = await session.compact(command.customInstructions);
+        return success(id, "compact", result);
+      }
+      case "set_auto_compaction":
+        return session.setAutoCompactionEnabled(command.enabled), success(id, "set_auto_compaction");
+      // =================================================================
+      // Retry
+      // =================================================================
+      case "set_auto_retry":
+        return session.setAutoRetryEnabled(command.enabled), success(id, "set_auto_retry");
+      case "abort_retry":
+        return session.abortRetry(), success(id, "abort_retry");
+      // =================================================================
+      // Bash
+      // =================================================================
+      case "bash": {
+        let result = await session.executeBash(command.command, void 0, {
+          excludeFromContext: command.excludeFromContext
+        });
+        return success(id, "bash", result);
+      }
+      case "abort_bash":
+        return session.abortBash(), success(id, "abort_bash");
+      // =================================================================
+      // Session
+      // =================================================================
+      case "get_session_stats": {
+        let stats = session.getSessionStats();
+        return success(id, "get_session_stats", stats);
+      }
+      case "export_html": {
+        let path = await session.exportToHtml(command.outputPath);
+        return success(id, "export_html", { path });
+      }
+      case "switch_session": {
+        let result = await runtimeHost.switchSession(command.sessionPath);
+        return result.cancelled || await rebindSession(), success(id, "switch_session", result);
+      }
+      case "fork": {
+        let result = await runtimeHost.fork(command.entryId);
+        return result.cancelled || await rebindSession(), success(id, "fork", { text: result.selectedText, cancelled: result.cancelled });
+      }
+      case "clone": {
+        let leafId = session.sessionManager.getLeafId();
+        if (!leafId)
+          return error(id, "clone", "Cannot clone session: no current entry selected");
+        let result = await runtimeHost.fork(leafId, { position: "at" });
+        return result.cancelled || await rebindSession(), success(id, "clone", { cancelled: result.cancelled });
+      }
+      case "get_fork_messages": {
+        let messages = session.getUserMessagesForForking();
+        return success(id, "get_fork_messages", { messages });
+      }
+      case "get_entries": {
+        let sessionManager = session.sessionManager, entries = sessionManager.getEntries();
+        if (command.since !== void 0) {
+          let sinceIndex = entries.findIndex((e) => e.id === command.since);
+          if (sinceIndex === -1)
+            return error(id, "get_entries", `Entry not found: ${command.since}`);
+          entries = entries.slice(sinceIndex + 1);
+        }
+        return success(id, "get_entries", { entries, leafId: sessionManager.getLeafId() });
+      }
+      case "get_tree": {
+        let sessionManager = session.sessionManager;
+        return success(id, "get_tree", { tree: sessionManager.getTree(), leafId: sessionManager.getLeafId() });
+      }
+      case "get_last_assistant_text": {
+        let text = session.getLastAssistantText();
+        return success(id, "get_last_assistant_text", { text });
+      }
+      case "set_session_name": {
+        let name = command.name.trim();
+        return name ? (session.setSessionName(name), success(id, "set_session_name")) : error(id, "set_session_name", "Session name cannot be empty");
+      }
+      // =================================================================
+      // Messages
+      // =================================================================
+      case "get_messages":
+        return success(id, "get_messages", { messages: session.messages });
+      // =================================================================
+      // Commands (available for invocation via prompt)
+      // =================================================================
+      case "get_commands": {
+        let commands = [];
+        for (let command2 of session.extensionRunner.getRegisteredCommands())
+          commands.push({
+            name: command2.invocationName,
+            description: command2.description,
+            source: "extension",
+            sourceInfo: command2.sourceInfo
+          });
+        for (let template of session.promptTemplates)
+          commands.push({
+            name: template.name,
+            description: template.description,
+            source: "prompt",
+            sourceInfo: template.sourceInfo
+          });
+        for (let skill of session.resourceLoader.getSkills().skills)
+          commands.push({
+            name: `skill:${skill.name}`,
+            description: skill.description,
+            source: "skill",
+            sourceInfo: skill.sourceInfo
+          });
+        return success(id, "get_commands", { commands });
+      }
+      default: {
+        let unknownCommand = command;
+        return error(id, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
+      }
+    }
+  }, detachInput = () => {
+  };
+  async function shutdown(exitCode = 0, signal) {
+    shuttingDown && process.exit(exitCode), shuttingDown = !0;
+    for (let cleanup of signalCleanupHandlers)
+      cleanup();
+    unsubscribe?.(), unsubscribeBackpressure?.(), await runtimeHost.dispose(), detachInput(), process.stdin.pause(), signal !== "SIGTERM" && await flushRawStdout(), process.exit(exitCode);
+  }
+  async function checkShutdownRequested() {
+    shutdownRequested && await shutdown();
+  }
+  let handleInputLine = async (line) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (parseError) {
+      output(error(void 0, "parse", `Failed to parse command: ${parseError instanceof Error ? parseError.message : String(parseError)}`)), await waitForRawStdoutBackpressure();
+      return;
+    }
+    if (typeof parsed == "object" && parsed !== null && "type" in parsed && parsed.type === "extension_ui_response") {
+      let response = parsed, pending = pendingExtensionRequests.get(response.id);
+      pending && (pendingExtensionRequests.delete(response.id), pending.resolve(response));
+      return;
+    }
+    let command = parsed;
+    try {
+      let response = await handleCommand(command);
+      response && (output(response), await waitForRawStdoutBackpressure()), await checkShutdownRequested();
+    } catch (commandError) {
+      output(error(command.id, command.type, commandError instanceof Error ? commandError.message : String(commandError))), await waitForRawStdoutBackpressure();
+    }
+  }, onInputEnd = () => {
+    shutdown();
+  };
+  return process.stdin.on("end", onInputEnd), detachInput = (() => {
+    let detachJsonl = attachJsonlLineReader(process.stdin, (line) => {
+      handleInputLine(line);
+    });
+    return () => {
+      detachJsonl(), process.stdin.off("end", onInputEnd);
+    };
+  })(), new Promise(() => {
+  });
+}
+
+export {
+  serializeJsonLine,
+  attachJsonlLineReader,
+  runRpcMode
+};

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

@@ -0,0 +1,115 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/gemini-api.js
+import { existsSync, readFileSync } from "node:fs";
+var DEFAULT_API_HOST = "https://generativelanguage.googleapis.com", API_VERSION = "v1beta", API_BASE = `${DEFAULT_API_HOST}/${API_VERSION}`, CONFIG_PATH = getWebSearchConfigPath(), DEFAULT_MODEL = "gemini-3-flash-preview", 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 withTimeout(signal, timeoutMs) {
+  let timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function normalizeApiKey(value) {
+  if (typeof value != "string")
+    return null;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeBaseUrl(value) {
+  if (typeof value != "string")
+    return null;
+  let normalized = value.trim().replace(/\/+$/, "");
+  return normalized.length > 0 ? normalized : null;
+}
+function isCloudflareGateway() {
+  return getApiHost().includes("gateway.ai.cloudflare.com");
+}
+function getApiKey() {
+  return normalizeApiKey(process.env.GEMINI_API_KEY) ?? normalizeApiKey(loadConfig().geminiApiKey);
+}
+function getApiHost() {
+  return normalizeBaseUrl(process.env.GOOGLE_GEMINI_BASE_URL) ?? normalizeBaseUrl(loadConfig().geminiBaseUrl) ?? DEFAULT_API_HOST;
+}
+function getVersionedApiBase() {
+  return `${getApiHost()}/${API_VERSION}`;
+}
+function buildKeyParam(apiKey) {
+  return !apiKey || isCloudflareGateway() ? "" : `?key=${apiKey}`;
+}
+function getCloudflareApiKey() {
+  return normalizeApiKey(process.env.CLOUDFLARE_API_KEY) ?? normalizeApiKey(loadConfig().cloudflareApiKey);
+}
+function isGatewayConfigured() {
+  return isCloudflareGateway() && getCloudflareApiKey() !== null;
+}
+function buildAuthHeaders() {
+  if (!isCloudflareGateway())
+    return {};
+  let cloudflareApiKey = getCloudflareApiKey();
+  return cloudflareApiKey ? { "cf-aig-authorization": `Bearer ${cloudflareApiKey}` } : {};
+}
+function isGeminiApiAvailable() {
+  return getApiKey() !== null || isGatewayConfigured();
+}
+async function queryGeminiApiWithVideo(prompt, videoUri, options = {}) {
+  let apiKey = getApiKey();
+  if (!apiKey && !isGatewayConfigured())
+    throw new Error(`Gemini API not configured. Either:
+  1. Set GEMINI_API_KEY in ${CONFIG_PATH}
+  2. Set GOOGLE_GEMINI_BASE_URL + CLOUDFLARE_API_KEY for Cloudflare AI Gateway routing`);
+  let model = options.model ?? DEFAULT_MODEL, signal = withTimeout(options.signal, options.timeoutMs ?? 12e4), url = `${getVersionedApiBase()}/models/${model}:generateContent${buildKeyParam(apiKey)}`, fileData = { fileUri: videoUri };
+  options.mimeType && (fileData.mimeType = options.mimeType);
+  let body = {
+    contents: [
+      {
+        role: "user",
+        parts: [
+          { fileData },
+          { text: prompt }
+        ]
+      }
+    ]
+  }, res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...buildAuthHeaders() },
+    body: JSON.stringify(body),
+    signal
+  });
+  if (!res.ok) {
+    let errorText = await res.text();
+    throw new Error(`Gemini API error ${res.status}: ${errorText.slice(0, 300)}`);
+  }
+  let text = (await res.json()).candidates?.[0]?.content?.parts?.map((p) => p.text).filter(Boolean).join(`
+`);
+  if (!text)
+    throw new Error("Gemini API returned empty response");
+  return text;
+}
+
+export {
+  API_BASE,
+  DEFAULT_MODEL,
+  getApiKey,
+  getApiHost,
+  getVersionedApiBase,
+  buildKeyParam,
+  getCloudflareApiKey,
+  isGatewayConfigured,
+  buildAuthHeaders,
+  isGeminiApiAvailable,
+  queryGeminiApiWithVideo
+};

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

@@ -0,0 +1,49 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/shared/language-map.js
+var EXT_TO_LANGUAGE = {
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".mts": "typescript",
+  ".mjs": "javascript",
+  ".cts": "typescript",
+  ".cjs": "javascript",
+  ".rs": "rust",
+  ".py": "python",
+  ".go": "go",
+  ".java": "java",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".hpp": "cpp",
+  ".cs": "csharp",
+  ".rb": "ruby",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".scala": "scala",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".lua": "lua",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  ".swift": "swift",
+  ".zig": "zig",
+  ".json": "json",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".vue": "vue",
+  ".php": "php"
+};
+function getLanguageIdFromPath(filePath) {
+  let ext = filePath.match(/\.[^.]+$/)?.[0]?.toLowerCase();
+  return ext ? EXT_TO_LANGUAGE[ext] : void 0;
+}
+
+export {
+  getLanguageIdFromPath
+};

package/dist/node-runtime/chunk-4HXHDDCF.js

@@ -0,0 +1,16 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/agent-dir.js
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+function getAgentDir() {
+  let configured = process.env.PI_CODING_AGENT_DIR?.trim();
+  return configured ? configured === "~" ? homedir() : configured.startsWith("~/") ? resolve(homedir(), configured.slice(2)) : resolve(configured) : join(homedir(), ".lunr", "agent");
+}
+function getAgentPath(...segments) {
+  return join(getAgentDir(), ...segments);
+}
+
+export {
+  getAgentPath
+};