@ashx-j/lunr 0.2.17 → 0.2.18

package/dist/node-runtime/chunk-OPEK5RRY.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-CSFI6YXL.js";
+import {
+  theme
+} from "./chunk-RNBHABBA.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-OR4L3IB2.js

@@ -0,0 +1,42 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/extensions/types.js
+function defineTool(tool) {
+  return tool;
+}
+function isBashToolResult(e) {
+  return e.toolName === "bash";
+}
+function isReadToolResult(e) {
+  return e.toolName === "read";
+}
+function isEditToolResult(e) {
+  return e.toolName === "edit";
+}
+function isWriteToolResult(e) {
+  return e.toolName === "write";
+}
+function isGrepToolResult(e) {
+  return e.toolName === "grep";
+}
+function isFindToolResult(e) {
+  return e.toolName === "find";
+}
+function isLsToolResult(e) {
+  return e.toolName === "ls";
+}
+function isToolCallEventType(toolName, event) {
+  return event.toolName === toolName;
+}
+
+export {
+  defineTool,
+  isBashToolResult,
+  isReadToolResult,
+  isEditToolResult,
+  isWriteToolResult,
+  isGrepToolResult,
+  isFindToolResult,
+  isLsToolResult,
+  isToolCallEventType
+};