@sentry/junior 0.74.1 → 0.76.0

package/dist/{chunk-2LUZA3LY.js → chunk-ZQB37HUX.js}

@@ -1,22 +1,22 @@
-import {
-  normalizeSlackConversationId
-} from "./chunk-YRDS7VKO.js";
 import {
   getStateAdapter
-} from "./chunk-F6HWCPOC.js";
+} from "./chunk-Y5OFBCBZ.js";
+import {
+  normalizeSlackConversationId
+} from "./chunk-Q6XFTRV5.js";
 import {
   parseSlackThreadId
-} from "./chunk-GM7HTXYC.js";
+} from "./chunk-T77LUIX3.js";
 import {
   parseStoredSlackRequester
-} from "./chunk-CYUI7JU5.js";
+} from "./chunk-VALUBQ7R.js";
 import {
   isRecord,
   toOptionalNumber
-} from "./chunk-3BYAPS6B.js";
+} from "./chunk-EJN6G5A2.js";
 import {
-  sentry_exports
-} from "./chunk-SJHUF3DP.js";
+  getClient
+} from "./chunk-ST6YNAXG.js";
 
 // src/handlers/health.ts
 function GET() {
@@ -44,7 +44,7 @@ function buildSentryWebBaseUrl(dsn) {
   return `${dsn.protocol}://${dsn.host}${port}${path}`;
 }
 function buildSentryConversationUrl(conversationId) {
-  const client = sentry_exports.getClient();
+  const client = getClient();
   const dsn = client?.getDsn();
   if (!dsn?.host || !dsn.projectId) {
     return void 0;
@@ -63,7 +63,7 @@ function buildSentryConversationUrl(conversationId) {
   return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
 }
 function buildSentryTraceUrl(traceId) {
-  const client = sentry_exports.getClient();
+  const client = getClient();
   const dsn = client?.getDsn();
   if (!dsn?.host || !dsn.projectId) {
     return void 0;

package/dist/cli/chat.js

@@ -1,4 +1,7 @@
-import "../chunk-2KG3PWR4.js";
+import {
+  loadAppPluginSet
+} from "../chunk-Y2CM7HXH.js";
+import "../chunk-MLKGABMK.js";
 
 // src/cli/chat.ts
 import {
@@ -8,6 +11,7 @@ import {
 } from "process";
 import { randomUUID } from "crypto";
 import * as readline from "readline/promises";
+import { createJiti } from "jiti";
 
 // src/chat/local/conversation.ts
 import { createHash } from "crypto";
@@ -40,6 +44,7 @@ var DEFAULT_IO = {
   output: defaultStdout,
   write: (text) => writeStream(defaultStdout, text)
 };
+var localPluginLoader = createJiti(import.meta.url, { moduleCache: false });
 var ChatOutputError = class extends Error {
   constructor(error) {
     super(errorMessage(error));
@@ -70,6 +75,29 @@ async function reportStatus(io, status) {
     throw new ChatOutputError(error);
   }
 }
+function formatToolPayload(payload) {
+  if (payload && typeof payload === "object" && !Array.isArray(payload) && Object.keys(payload).length === 0) {
+    return "";
+  }
+  const rendered = JSON.stringify(payload);
+  if (rendered.length <= 500) {
+    return ` ${rendered}`;
+  }
+  return ` ${rendered.slice(0, 497)}...`;
+}
+async function reportToolResult(io, result) {
+  if (!result.ok) {
+    await reportStatus(
+      io,
+      `tool: ${result.toolName} error ${result.error ?? "Tool execution failed"}`
+    );
+    return;
+  }
+  await reportStatus(
+    io,
+    `tool: ${result.toolName} ok${formatToolPayload(result.result ?? {})}`
+  );
+}
 function writeStream(stream, text) {
   return new Promise((resolve, reject) => {
     stream.write(text, (error) => {
@@ -87,6 +115,49 @@ function defaultStateAdapterForLocalChat() {
   }
   process.env.JUNIOR_STATE_ADAPTER = "memory";
 }
+async function loadLocalPluginSet() {
+  return await loadAppPluginSet(
+    process.cwd(),
+    async (moduleRef) => localPluginLoader.import(moduleRef.importPath)
+  );
+}
+async function configureLocalChatPlugins(pluginSet) {
+  const [
+    pluginsModule,
+    agentHooksModule,
+    registryModule,
+    validationModule,
+    databaseModule
+  ] = await Promise.all([
+    import("../plugins-PZMDS7AT.js"),
+    import("../agent-hooks-ZOE7RIED.js"),
+    import("../registry-OIPAJU2O.js"),
+    import("../validation-SLA6IGF7.js"),
+    import("../db-7A7PFRGL.js")
+  ]);
+  const resolvedPluginSet = pluginSet === void 0 ? await loadLocalPluginSet() : pluginSet ?? void 0;
+  const plugins = pluginsModule.pluginRuntimeRegistrationsFromPluginSet(resolvedPluginSet);
+  const pluginConfig = resolvedPluginSet ? pluginsModule.pluginCatalogConfigFromPluginSet(resolvedPluginSet) : pluginsModule.pluginCatalogConfigFromEnv();
+  const shouldValidatePluginCatalog = Boolean(pluginConfig) || Boolean(resolvedPluginSet?.registrations.length);
+  agentHooksModule.validatePlugins(plugins);
+  const previousPluginCatalogConfig = registryModule.setPluginCatalogConfig(pluginConfig);
+  try {
+    if (shouldValidatePluginCatalog) {
+      registryModule.getPluginCatalogSignature();
+      validationModule.validatePluginRegistrations(
+        resolvedPluginSet?.registrations ?? []
+      );
+      validationModule.validatePluginEgressCredentialHooks(
+        resolvedPluginSet?.registrations ?? []
+      );
+    }
+    databaseModule.getDb();
+    agentHooksModule.setPlugins(plugins);
+  } catch (error) {
+    registryModule.setPluginCatalogConfig(previousPluginCatalogConfig);
+    throw error;
+  }
+}
 function parseChatArgs(argv) {
   if (argv.length === 0) {
     return { mode: "interactive" };
@@ -118,10 +189,11 @@ function newRunConversationId() {
   }
   return conversationId;
 }
-async function runPrompt(options, io) {
+async function runPrompt(options, io, pluginSet) {
   defaultStateAdapterForLocalChat();
+  await configureLocalChatPlugins(pluginSet);
   const conversationId = newRunConversationId();
-  const { runLocalAgentTurn } = await import("../runner-27NP2TEO.js");
+  const { runLocalAgentTurn } = await import("../runner-KPLNHDCV.js");
   const result = await runLocalAgentTurn(
     {
       conversationId,
@@ -133,15 +205,19 @@ async function runPrompt(options, io) {
       },
       onStatus: async (status) => {
         await reportStatus(io, status);
+      },
+      onToolResult: async (result2) => {
+        await reportToolResult(io, result2);
       }
     }
   );
   return result.outcome === "success" ? 0 : 1;
 }
-async function runInteractive(io) {
+async function runInteractive(io, pluginSet) {
   defaultStateAdapterForLocalChat();
+  await configureLocalChatPlugins(pluginSet);
   const conversationId = newRunConversationId();
-  const { runLocalAgentTurn } = await import("../runner-27NP2TEO.js");
+  const { runLocalAgentTurn } = await import("../runner-KPLNHDCV.js");
   const rl = readline.createInterface({
     input: io.input,
     output: io.output,
@@ -168,6 +244,9 @@ async function runInteractive(io) {
             },
             onStatus: async (status) => {
               await reportStatus(io, status);
+            },
+            onToolResult: async (result) => {
+              await reportToolResult(io, result);
             }
           }
         );
@@ -182,7 +261,7 @@ async function runInteractive(io) {
     rl.close();
   }
 }
-async function runChat(argv, io = DEFAULT_IO) {
+async function runChat(argv, io = DEFAULT_IO, deps = {}) {
   const options = parseChatArgs(argv);
   if (!options) {
     await io.error(CHAT_USAGE);
@@ -190,9 +269,9 @@ async function runChat(argv, io = DEFAULT_IO) {
   }
   try {
     if (options.mode === "prompt") {
-      return await runPrompt(options, io);
+      return await runPrompt(options, io, deps.pluginSet);
     }
-    await runInteractive(io);
+    await runInteractive(io, deps.pluginSet);
     return 0;
   } catch (error) {
     await io.error(errorMessage(error));

package/dist/cli/check.js

@@ -1,19 +1,20 @@
 import {
   parseSkillFile
-} from "../chunk-OR6NQJ5E.js";
+} from "../chunk-4SCWV7TJ.js";
 import {
   parseInlinePluginManifest,
   parsePluginManifest
-} from "../chunk-7Q5YOUUT.js";
-import "../chunk-KVZL5NZS.js";
-import "../chunk-CYUI7JU5.js";
-import "../chunk-3BYAPS6B.js";
+} from "../chunk-ZLMBNBUG.js";
+import "../chunk-VALUBQ7R.js";
+import "../chunk-Q3XNY442.js";
+import "../chunk-EJN6G5A2.js";
 import {
   JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
   JUNIOR_HEARTBEAT_ROUTE,
   LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
-} from "../chunk-SJHUF3DP.js";
-import "../chunk-2KG3PWR4.js";
+} from "../chunk-OJ53FYVG.js";
+import "../chunk-ST6YNAXG.js";
+import "../chunk-MLKGABMK.js";
 
 // src/cli/check.ts
 import fs from "fs/promises";

package/dist/cli/env.js

@@ -1,56 +1,7 @@
-import "../chunk-2KG3PWR4.js";
-
-// src/cli/env.ts
-import fs from "fs";
-import path from "path";
-function envFileNames(nodeEnv) {
-  return [
-    `.env.${nodeEnv}.local`,
-    ...nodeEnv === "test" ? [] : [".env.local"],
-    `.env.${nodeEnv}`,
-    ".env"
-  ];
-}
-function hasEnvRootMarker(dir) {
-  return fs.existsSync(path.join(dir, "package.json")) || fs.existsSync(path.join(dir, "pnpm-workspace.yaml"));
-}
-function resolveCliEnvRoots(cwd) {
-  const roots = [];
-  const seen = /* @__PURE__ */ new Set();
-  const addRoot = (candidate) => {
-    const resolved = path.resolve(candidate);
-    if (seen.has(resolved)) {
-      return;
-    }
-    seen.add(resolved);
-    roots.push(resolved);
-  };
-  let current = path.resolve(cwd);
-  addRoot(current);
-  while (true) {
-    if (hasEnvRootMarker(current)) {
-      addRoot(current);
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  return roots;
-}
-function loadCliEnvFiles(cwd = process.cwd()) {
-  const nodeEnv = process.env.NODE_ENV ?? "development";
-  for (const root of resolveCliEnvRoots(cwd)) {
-    for (const envFile of envFileNames(nodeEnv)) {
-      const absolutePath = path.join(root, envFile);
-      if (!fs.existsSync(absolutePath)) {
-        continue;
-      }
-      process.loadEnvFile(absolutePath);
-    }
-  }
-}
+import {
+  loadCliEnvFiles
+} from "../chunk-RV5RYIJW.js";
+import "../chunk-MLKGABMK.js";
 export {
   loadCliEnvFiles
 };

package/dist/cli/init.js

@@ -1,7 +1,7 @@
 import {
   juniorVercelConfig
 } from "../chunk-Y7X25LFY.js";
-import "../chunk-2KG3PWR4.js";
+import "../chunk-MLKGABMK.js";
 
 // src/cli/init.ts
 import fs from "fs";
@@ -35,8 +35,10 @@ function writePluginsFile(targetDir) {
   fs.writeFileSync(
     path.join(targetDir, "plugins.ts"),
     `import { defineJuniorPlugins } from "@sentry/junior";
+import { createMemoryPlugin } from "@sentry/junior-memory";
 
 export const plugins = defineJuniorPlugins([
+  createMemoryPlugin(),
   "@sentry/junior-maintenance",
 ]);
 `
@@ -144,6 +146,7 @@ async function runInit(dir, log = console.log) {
     },
     dependencies: {
       "@sentry/junior": "latest",
+      "@sentry/junior-memory": "latest",
       "@sentry/junior-maintenance": "latest",
       hono: "^4.12.0"
     },
@@ -205,6 +208,8 @@ JUNIOR_BOT_NAME=
 JUNIOR_SLASH_COMMAND=
 AI_MODEL=
 AI_FAST_MODEL=
+AI_MEMORY_MODEL=
+AI_EMBEDDING_MODEL=
 AI_VISION_MODEL=
 AI_WEB_SEARCH_MODEL=
 REDIS_URL=

package/dist/cli/main.js

@@ -0,0 +1,84 @@
+import {
+  loadCliEnvFiles
+} from "../chunk-RV5RYIJW.js";
+import {
+  runCli
+} from "../chunk-4UO6FK4G.js";
+import "../chunk-MLKGABMK.js";
+
+// src/cli/main.ts
+import { pathToFileURL } from "url";
+var SENTRY_FLUSH_TIMEOUT_MS = 2e3;
+async function flushSentry() {
+  const mod = await import("../sentry-4CP5NNQ5.js");
+  await mod.flush(SENTRY_FLUSH_TIMEOUT_MS);
+}
+async function initSentry() {
+  const mod = await import("../instrumentation.js");
+  mod.initSentry();
+}
+async function runInit(dir) {
+  const mod = await import("./init.js");
+  await mod.runInit(dir);
+}
+async function runSnapshotCreate() {
+  const mod = await import("./snapshot-warmup.js");
+  await mod.runSnapshotCreate();
+}
+async function runCheck(dir) {
+  const mod = await import("./check.js");
+  await mod.runCheck(dir);
+}
+async function runUpgrade(pluginSet) {
+  const mod = await import("./upgrade.js");
+  await mod.runUpgrade(void 0, { pluginSet });
+}
+async function runChat(argv, pluginSet) {
+  const mod = await import("./chat.js");
+  return await mod.runChat(argv, void 0, { pluginSet });
+}
+function topLevelCommand(argv) {
+  const normalized = argv[0] === "--" ? argv.slice(1) : argv;
+  return normalized[0];
+}
+async function runMain(argv, options = {}) {
+  loadCliEnvFiles();
+  const instrument = options.instrument ?? true;
+  if (instrument) {
+    await initSentry();
+  }
+  const command = topLevelCommand(argv);
+  const cliPluginsModule = command && command !== "init" ? await import("./plugins.js") : void 0;
+  const pluginSet = cliPluginsModule ? await cliPluginsModule.loadCliPluginSet() ?? null : void 0;
+  const pluginCommands = cliPluginsModule ? await cliPluginsModule.loadCliPluginCommands(pluginSet) : void 0;
+  const exitCode = await runCli(argv, {
+    runChat: async (chatArgv) => await runChat(chatArgv, pluginSet),
+    runInit,
+    runSnapshotCreate,
+    runCheck,
+    runUpgrade: async () => await runUpgrade(pluginSet),
+    ...pluginCommands ? { runPluginCommand: pluginCommands.run } : {}
+  });
+  if (instrument) {
+    await flushSentry();
+  }
+  process.exit(exitCode);
+}
+function isDirectCliEntry() {
+  return Boolean(
+    process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href
+  );
+}
+if (isDirectCliEntry()) {
+  runMain(process.argv.slice(2)).catch((error) => {
+    void (async () => {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`junior command failed: ${message}`);
+      await flushSentry();
+      process.exit(1);
+    })();
+  });
+}
+export {
+  runMain
+};

package/dist/cli/plugins.js

@@ -0,0 +1,244 @@
+import {
+  validatePluginEgressCredentialHooks,
+  validatePluginRegistrations
+} from "../chunk-XBBC6W45.js";
+import {
+  pluginCatalogConfigFromPluginSet,
+  pluginCliRegistrationsFromPluginSet,
+  pluginRuntimeRegistrationsFromPluginSet
+} from "../chunk-SG5WAA7H.js";
+import {
+  setPlugins,
+  validatePlugins
+} from "../chunk-NFTMTIP3.js";
+import {
+  createPluginLogger
+} from "../chunk-56TBVRJG.js";
+import {
+  getDb
+} from "../chunk-NYKJ3KON.js";
+import "../chunk-G3E7SCME.js";
+import "../chunk-Y5OFBCBZ.js";
+import "../chunk-Q6XFTRV5.js";
+import "../chunk-T77LUIX3.js";
+import {
+  loadAppPluginSet
+} from "../chunk-Y2CM7HXH.js";
+import {
+  setPluginCatalogConfig
+} from "../chunk-ZLMBNBUG.js";
+import "../chunk-VALUBQ7R.js";
+import "../chunk-Q3XNY442.js";
+import "../chunk-EJN6G5A2.js";
+import "../chunk-OJ53FYVG.js";
+import "../chunk-ST6YNAXG.js";
+import "../chunk-MLKGABMK.js";
+
+// src/cli/plugins.ts
+import { stderr as defaultStderr, stdout as defaultStdout } from "process";
+import { createJiti } from "jiti";
+import { Command, CommanderError } from "commander";
+var pluginCliLoader = createJiti(import.meta.url, { moduleCache: false });
+var CORE_COMMAND_NAMES = /* @__PURE__ */ new Set([
+  "chat",
+  "check",
+  "init",
+  "snapshot",
+  "upgrade"
+]);
+var PLUGIN_COMMAND_NAME_RE = /^[a-z][a-z0-9-]*$/;
+var DEFAULT_IO = {
+  writeError: (text) => writeStream(defaultStderr, text),
+  writeOutput: (text) => writeStream(defaultStdout, text)
+};
+function writeStream(stream, text) {
+  return new Promise((resolve, reject) => {
+    stream.write(text, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function loadCliPluginSet() {
+  return await loadAppPluginSet(
+    process.cwd(),
+    async (moduleRef) => pluginCliLoader.import(moduleRef.importPath)
+  );
+}
+function findPluginCommand(plugins, commandName) {
+  for (const plugin of plugins) {
+    const command = plugin.cli?.commands.find(
+      (candidate) => candidate.name === commandName
+    );
+    if (command) {
+      return { command, plugin };
+    }
+  }
+  return void 0;
+}
+function createPluginCliHost(args) {
+  return {
+    action(handler) {
+      return async (...actionArgs) => {
+        const pluginName = args.plugin.manifest.name;
+        const result = await handler(
+          {
+            db: getDb(),
+            command: {
+              name: args.command.name,
+              summary: args.command.summary
+            },
+            io: args.io,
+            log: createPluginLogger(pluginName),
+            plugin: { name: pluginName }
+          },
+          ...actionArgs
+        );
+        args.setExitCode(result ?? 0);
+      };
+    }
+  };
+}
+function createPluginCommanderCommand(args) {
+  const command = new Command(args.command.name).description(args.command.summary).exitOverride().showHelpAfterError().showSuggestionAfterError().configureOutput({
+    writeOut: (text) => {
+      void args.io.writeOutput(text);
+    },
+    writeErr: (text) => {
+      void args.io.writeError(text);
+    },
+    outputError: (text, write) => {
+      write(text);
+    }
+  });
+  args.command.configure(command, createPluginCliHost(args));
+  return command;
+}
+function validateConfiguredPluginCommand(args) {
+  const pluginName = args.plugin.manifest.name;
+  if (args.command.name() !== args.definition.name) {
+    throw new Error(
+      `Plugin CLI command "${args.definition.name}" from plugin "${pluginName}" must not rename its top-level command`
+    );
+  }
+  if (args.command.commands.length === 0) {
+    throw new Error(
+      `Plugin CLI command "${args.definition.name}" from plugin "${pluginName}" must define at least one subcommand`
+    );
+  }
+  if (args.command.aliases().length > 0) {
+    throw new Error(
+      `Plugin CLI command "${args.definition.name}" from plugin "${pluginName}" must not define top-level aliases`
+    );
+  }
+}
+function validateConfiguredPluginCommands(plugins) {
+  const ownerByName = /* @__PURE__ */ new Map();
+  const validationIo = DEFAULT_IO;
+  for (const plugin of plugins) {
+    for (const definition of plugin.cli?.commands ?? []) {
+      const pluginName = plugin.manifest.name;
+      const existingOwner = ownerByName.get(definition.name);
+      if (!PLUGIN_COMMAND_NAME_RE.test(definition.name)) {
+        throw new Error(
+          `Plugin CLI command "${definition.name}" from plugin "${pluginName}" must be a lowercase command identifier`
+        );
+      }
+      if (CORE_COMMAND_NAMES.has(definition.name)) {
+        throw new Error(
+          `Plugin CLI command "${definition.name}" from plugin "${pluginName}" conflicts with a core command`
+        );
+      }
+      if (existingOwner) {
+        throw new Error(
+          `Plugin CLI command "${definition.name}" from plugin "${pluginName}" conflicts with plugin "${existingOwner}"`
+        );
+      }
+      ownerByName.set(definition.name, pluginName);
+      if (typeof definition.configure !== "function") {
+        throw new Error(
+          `Plugin CLI command "${definition.name}" from plugin "${pluginName}" must define a configure function`
+        );
+      }
+      let exitCode = 0;
+      validateConfiguredPluginCommand({
+        command: createPluginCommanderCommand({
+          command: definition,
+          io: validationIo,
+          plugin,
+          setExitCode: (nextExitCode) => {
+            exitCode = nextExitCode;
+          }
+        }),
+        definition,
+        plugin
+      });
+      void exitCode;
+    }
+  }
+}
+async function loadPluginRegistrations(args) {
+  const pluginSet = args.pluginSet;
+  if (!pluginSet) {
+    return { cliPlugins: [], runtimePlugins: [] };
+  }
+  const cliPlugins = pluginCliRegistrationsFromPluginSet(pluginSet);
+  const runtimePlugins = pluginRuntimeRegistrationsFromPluginSet(pluginSet);
+  const pluginConfig = pluginCatalogConfigFromPluginSet(pluginSet);
+  validatePlugins(runtimePlugins);
+  const previousPluginCatalogConfig = setPluginCatalogConfig(pluginConfig);
+  try {
+    validatePluginRegistrations(pluginSet.registrations);
+    validatePluginEgressCredentialHooks(pluginSet.registrations);
+    args.validateConfiguredCommands?.(cliPlugins);
+    setPlugins(runtimePlugins);
+    return { cliPlugins, runtimePlugins };
+  } catch (error) {
+    setPluginCatalogConfig(previousPluginCatalogConfig);
+    throw error;
+  }
+}
+async function loadCliPluginCommands(pluginSet) {
+  const resolvedPluginSet = pluginSet === void 0 ? await loadCliPluginSet() : pluginSet ?? void 0;
+  const { cliPlugins } = await loadPluginRegistrations({
+    pluginSet: resolvedPluginSet,
+    validateConfiguredCommands: validateConfiguredPluginCommands
+  });
+  const commandNames = cliPlugins.flatMap(
+    (plugin) => (plugin.cli?.commands ?? []).map((command) => command.name)
+  );
+  return {
+    commandNames,
+    async run(commandName, argv, io = DEFAULT_IO) {
+      const resolved = findPluginCommand(cliPlugins, commandName);
+      if (!resolved) {
+        return void 0;
+      }
+      let exitCode = 0;
+      const command = createPluginCommanderCommand({
+        command: resolved.command,
+        io,
+        plugin: resolved.plugin,
+        setExitCode: (nextExitCode) => {
+          exitCode = nextExitCode;
+        }
+      });
+      try {
+        await command.parseAsync(argv, { from: "user" });
+      } catch (error) {
+        if (error instanceof CommanderError) {
+          return error.exitCode;
+        }
+        throw error;
+      }
+      return exitCode;
+    }
+  };
+}
+export {
+  loadCliPluginCommands,
+  loadCliPluginSet
+};