@sentry/junior 0.96.0 → 0.97.1

package/dist/{chunk-PMNN6ST4.js → chunk-3ECW2K2O.js}

@@ -1,12 +1,12 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-L7CDEIVJ.js";
+} from "./chunk-LMJPRYHP.js";
 import {
   logWarn
 } from "./chunk-I35CTGPO.js";
 import {
   skillRoots
-} from "./chunk-6APU57E6.js";
+} from "./chunk-3V7OFJZC.js";
 
 // src/chat/skills.ts
 import fs from "fs/promises";
@@ -157,6 +157,9 @@ function parseSkillFile(raw, expectedName) {
 }
 var SKILL_CACHE_TTL_MS = 5e3;
 var skillCache = null;
+function resetSkillDiscoveryCache() {
+  skillCache = null;
+}
 function resolveSkillRoots(options) {
   const additionalRoots = options?.additionalRoots ?? [];
   const envRoots = process.env.SKILL_DIRS?.split(path.delimiter).filter(Boolean) ?? [];
@@ -368,7 +371,9 @@ async function loadSkillsByName(skillNames, available) {
 }
 
 export {
+  stripFrontmatter,
   parseSkillFile,
+  resetSkillDiscoveryCache,
   discoverSkills,
   parseSkillInvocation,
   findSkillByName,

package/dist/{chunk-5C6XTTFI.js → chunk-3F4OPKGF.js}

@@ -9,14 +9,16 @@ import {
   juniorConversationMessages,
   juniorConversations,
   legacyActorProvenance,
+  piMessageSchema,
   readSessionLogEntries
-} from "./chunk-RITD7E5L.js";
+} from "./chunk-35BNLDOJ.js";
 import {
   botConfig,
   escapeXml,
   getStateAdapter,
-  resolveGatewayModel
-} from "./chunk-YDVEH3SB.js";
+  resolveGatewayModel,
+  unescapeXml
+} from "./chunk-EEZCY5WX.js";
 import {
   logWarn,
   setSpanAttributes
@@ -28,7 +30,7 @@ import {
 // src/chat/conversations/legacy-import.ts
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 import { eq as eq2 } from "drizzle-orm";
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // src/chat/conversations/visible-compactions.ts
 import { isDeepStrictEqual } from "util";
@@ -462,7 +464,7 @@ async function hydrateConversationMessages(args) {
     args.conversation.messages = [];
     return;
   }
-  const { ensureLegacyConversationImport: ensureLegacyConversationImport2 } = await import("./legacy-import-VZ2MEGP7.js");
+  const { ensureLegacyConversationImport: ensureLegacyConversationImport2 } = await import("./legacy-import-3NQJVGQL.js");
   await ensureLegacyConversationImport2({ conversationId: args.conversationId });
   await hydrateConversationCompactions({
     conversation: args.conversation,
@@ -495,34 +497,21 @@ async function persistConversationMessages(args) {
   }
 }
 
-// src/chat/state/ttl.ts
-var JUNIOR_THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-
-// src/chat/tools/advisor/session-store.ts
-var ADVISOR_SESSION_TTL_MS = JUNIOR_THREAD_STATE_TTL_MS;
-function cloneMessages(messages) {
-  return structuredClone(messages);
-}
-function getAdvisorSessionKey(conversationId) {
+// src/chat/conversations/legacy-advisor-session.ts
+import { z } from "zod";
+var legacyAdvisorMessagesSchema = z.array(piMessageSchema);
+function key(conversationId) {
   return `junior:${conversationId}:advisor_session`;
 }
-function createStateAdvisorSessionStore() {
+function createLegacyAdvisorSessionReader() {
   return {
     load: async (conversationId) => {
       const stateAdapter = getStateAdapter();
       await stateAdapter.connect();
-      const messages = await stateAdapter.get(
-        getAdvisorSessionKey(conversationId)
-      ) ?? [];
-      return cloneMessages(messages);
-    },
-    save: async (conversationId, messages) => {
-      const stateAdapter = getStateAdapter();
-      await stateAdapter.connect();
-      await stateAdapter.set(
-        getAdvisorSessionKey(conversationId),
-        cloneMessages(messages),
-        ADVISOR_SESSION_TTL_MS
+      return legacyAdvisorMessagesSchema.parse(
+        structuredClone(
+          await stateAdapter.get(key(conversationId)) ?? []
+        )
       );
     }
   };
@@ -531,6 +520,10 @@ function createStateAdvisorSessionStore() {
 // src/chat/conversations/sql/legacy-history-import.ts
 import { eq, sql } from "drizzle-orm";
 var INITIAL_SESSION_ID = "session_0";
+var ADVISOR_TASK_OPEN = "<advisor-task>\n";
+var ADVISOR_TASK_CLOSE = "\n</advisor-task>";
+var ADVISOR_CONTEXT_OPEN = "<executor-context>\n";
+var ADVISOR_CONTEXT_CLOSE = "\n</executor-context>";
 function importedAdvisorChildConversationId(parentConversationId) {
   return `advisor:${parentConversationId}`;
 }
@@ -542,6 +535,47 @@ function messageTimestampMs(message) {
   const timestamp = message.timestamp;
   return typeof timestamp === "number" ? timestamp : void 0;
 }
+function readAdvisorRequest(text) {
+  if (!text.startsWith(ADVISOR_TASK_OPEN) || !text.endsWith(ADVISOR_CONTEXT_CLOSE)) {
+    return void 0;
+  }
+  const taskEnd = text.indexOf(ADVISOR_TASK_CLOSE, ADVISOR_TASK_OPEN.length);
+  if (taskEnd < 0) {
+    return void 0;
+  }
+  const contextStart = taskEnd + ADVISOR_TASK_CLOSE.length + 2;
+  if (!text.startsWith(ADVISOR_CONTEXT_OPEN, contextStart)) {
+    return void 0;
+  }
+  const task = text.slice(ADVISOR_TASK_OPEN.length, taskEnd);
+  const context = text.slice(
+    contextStart + ADVISOR_CONTEXT_OPEN.length,
+    -ADVISOR_CONTEXT_CLOSE.length
+  );
+  return `${unescapeXml(task)}
+
+Executor context:
+${unescapeXml(context)}`;
+}
+function normalizeAdvisorMessage(message) {
+  const record = message;
+  if (record.role !== "user" || !Array.isArray(record.content)) {
+    return message;
+  }
+  let changed = false;
+  const content = record.content.map((part) => {
+    if (!part || typeof part !== "object" || part.type !== "text" || typeof part.text !== "string") {
+      return part;
+    }
+    const text = readAdvisorRequest(part.text);
+    if (text === void 0) {
+      return part;
+    }
+    changed = true;
+    return { ...part, text };
+  });
+  return changed ? { ...record, content } : message;
+}
 function piEntryProvenance(entry) {
   if (entry.provenance) {
     return entry.provenance;
@@ -693,12 +727,15 @@ function convertLegacySessionLog(args) {
   };
 }
 function convertAdvisorMessages(messages, fallbackCreatedAtMs) {
-  return messages.map((message, seq) => ({
-    seq,
-    contextEpoch: 0,
-    entry: { type: "pi_message", message, provenance: contextProvenance },
-    createdAtMs: messageTimestampMs(message) ?? fallbackCreatedAtMs
-  }));
+  return messages.map((sourceMessage, seq) => {
+    const message = normalizeAdvisorMessage(sourceMessage);
+    return {
+      seq,
+      contextEpoch: 0,
+      entry: { type: "pi_message", message, provenance: contextProvenance },
+      createdAtMs: messageTimestampMs(message) ?? fallbackCreatedAtMs
+    };
+  });
 }
 function messageRole(entry) {
   if (entry.type !== "pi_message") {
@@ -835,25 +872,25 @@ async function ensureChildConversationRow(executor, childConversationId, parentC
 }
 
 // src/chat/conversations/legacy-import.ts
-var legacyVisibleMessageSchema = z.object({
-  id: z.string(),
-  role: z.enum(["user", "assistant", "system"]),
-  text: z.string(),
-  createdAtMs: z.number().finite(),
-  author: z.object({}).passthrough().optional(),
-  meta: z.object({}).passthrough().optional()
+var legacyVisibleMessageSchema = z2.object({
+  id: z2.string(),
+  role: z2.enum(["user", "assistant", "system"]),
+  text: z2.string(),
+  createdAtMs: z2.number().finite(),
+  author: z2.object({}).passthrough().optional(),
+  meta: z2.object({}).passthrough().optional()
 });
-var legacyCompactionSchema = z.object({
-  coveredMessageIds: z.array(z.string()),
-  createdAtMs: z.number().finite(),
-  id: z.string(),
-  summary: z.string()
+var legacyCompactionSchema = z2.object({
+  coveredMessageIds: z2.array(z2.string()),
+  createdAtMs: z2.number().finite(),
+  id: z2.string(),
+  summary: z2.string()
 });
-var legacyThreadStateSnapshotSchema = z.object({
-  conversation: z.object({
-    compactions: z.array(legacyCompactionSchema).optional(),
-    messages: z.array(legacyVisibleMessageSchema).optional(),
-    stats: z.object({ updatedAtMs: z.number().finite().optional() }).passthrough().optional()
+var legacyThreadStateSnapshotSchema = z2.object({
+  conversation: z2.object({
+    compactions: z2.array(legacyCompactionSchema).optional(),
+    messages: z2.array(legacyVisibleMessageSchema).optional(),
+    stats: z2.object({ updatedAtMs: z2.number().finite().optional() }).passthrough().optional()
   }).passthrough().optional()
 });
 async function loadThreadStateSnapshot(conversationId) {
@@ -911,9 +948,7 @@ async function importConversationFromLegacy(conversationId, deps) {
     return { imported: false };
   }
   const hasAdvisor = entries.some((entry) => entry.type === "subagent_started");
-  const advisorMessages = hasAdvisor ? await (deps.advisorSessionStore ?? createStateAdvisorSessionStore()).load(
-    conversationId
-  ) : [];
+  const advisorMessages = hasAdvisor ? await (deps.advisorSessionStore ?? createLegacyAdvisorSessionReader()).load(conversationId) : [];
   const intrinsic = intrinsicTimestamps(entries, visible, compactions);
   for (const message of advisorMessages) {
     const timestamp = message.timestamp;
@@ -952,7 +987,7 @@ async function importConversationFromLegacy(conversationId, deps) {
       const existingMessage = existingMessages.get(message.id);
       const projected = toStoredConversationMessage(message);
       return existingMessage !== void 0 && Object.entries(projected.meta ?? {}).every(
-        ([key, value]) => isDeepStrictEqual2(existingMessage.meta?.[key], value)
+        ([key2, value]) => isDeepStrictEqual2(existingMessage.meta?.[key2], value)
       ) && (message.meta?.replied !== true || existingMessage.repliedAtMs !== void 0);
     });
     if (fullyImported) {
@@ -1031,7 +1066,6 @@ export {
   getConversationMessageSlackTs,
   hydrateConversationMessages,
   persistConversationMessages,
-  JUNIOR_THREAD_STATE_TTL_MS,
   importConversationFromLegacy,
   ensureLegacyConversationImport
 };

package/dist/chunk-3V7OFJZC.js

@@ -0,0 +1,264 @@
+// src/chat/discovery.ts
+import fs, { statSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function isDirectory(targetPath) {
+  try {
+    return statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(targetPath) {
+  try {
+    return statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function normalizePath(targetPath) {
+  return path.resolve(targetPath);
+}
+function uniqueResolvedPathsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = normalizePath(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function isNodeModulesPath(candidatePath) {
+  return path.basename(candidatePath) === "node_modules";
+}
+function isInsidePnpmStore(candidatePath) {
+  return candidatePath.split(path.sep).includes(".pnpm");
+}
+function runningFromInstalledPackage() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const marker = `${path.sep}node_modules${path.sep}@sentry${path.sep}junior${path.sep}`;
+  return currentFile.includes(marker);
+}
+function listInstalledPackageNodeModulesDirs() {
+  if (!runningFromInstalledPackage()) {
+    return [];
+  }
+  const dirs = [];
+  let current = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+  while (true) {
+    if (isNodeModulesPath(current) && !isInsidePnpmStore(current) && isDirectory(current)) {
+      dirs.push(current);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function listCwdAncestorNodeModulesDirs(cwd) {
+  const resolvedCwd = normalizePath(cwd);
+  const dirs = [];
+  let current = resolvedCwd;
+  while (true) {
+    const nodeModulesDir = path.join(current, "node_modules");
+    if (isDirectory(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    if (isFile(path.join(current, "package.json"))) {
+      break;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function discoverNodeModulesDirs(cwd = process.cwd(), options) {
+  const explicit = options?.candidateDirs?.filter((dir) => isDirectory(dir)) ?? [];
+  if (explicit.length > 0) {
+    return uniqueResolvedPathsInOrder(explicit);
+  }
+  return uniqueResolvedPathsInOrder([
+    ...listInstalledPackageNodeModulesDirs(),
+    ...listCwdAncestorNodeModulesDirs(cwd)
+  ]);
+}
+function discoverProjectRoots(cwd = process.cwd(), options) {
+  const roots = discoverNodeModulesDirs(
+    cwd,
+    options?.nodeModulesDirs ? { candidateDirs: options.nodeModulesDirs } : void 0
+  ).map((nodeModulesDir) => path.dirname(nodeModulesDir));
+  return uniqueResolvedPathsInOrder([cwd, ...roots]);
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function pathExists(targetPath) {
+  try {
+    fs.accessSync(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasAnyDataMarkers(appDir) {
+  return pathExists(path.join(appDir, "SOUL.md")) || pathExists(path.join(appDir, "WORLD.md"));
+}
+function scoreAppCandidate(appDir) {
+  let score = 0;
+  if (pathExists(path.join(appDir, "SOUL.md"))) {
+    score += 4;
+  }
+  if (pathExists(path.join(appDir, "WORLD.md"))) {
+    score += 2;
+  }
+  if (pathExists(path.join(appDir, "skills"))) {
+    score += 1;
+  }
+  if (pathExists(path.join(appDir, "plugins"))) {
+    score += 1;
+  }
+  return score;
+}
+function resolveCandidateAppDirs(cwd, projectRoots) {
+  const roots = projectRoots ?? discoverProjectRoots(cwd);
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const appDir = path.resolve(root, "app");
+    if (!pathExists(appDir)) {
+      continue;
+    }
+    if (seen.has(appDir)) {
+      continue;
+    }
+    seen.add(appDir);
+    resolved.push(appDir);
+  }
+  return resolved;
+}
+function homeDir() {
+  return resolveHomeDir();
+}
+function resolveHomeDir(cwd = process.cwd(), options) {
+  const resolvedCwd = path.resolve(cwd);
+  const directApp = path.resolve(resolvedCwd, "app");
+  if (pathExists(directApp) && hasAnyDataMarkers(directApp)) {
+    return directApp;
+  }
+  const candidates = resolveCandidateAppDirs(
+    resolvedCwd,
+    options?.projectRoots
+  );
+  if (candidates.length === 0) {
+    return directApp;
+  }
+  candidates.sort((left, right) => {
+    const leftScore = scoreAppCandidate(left);
+    const rightScore = scoreAppCandidate(right);
+    if (leftScore !== rightScore) {
+      return rightScore - leftScore;
+    }
+    const leftDistance = path.relative(resolvedCwd, left).split(path.sep).length;
+    const rightDistance = path.relative(resolvedCwd, right).split(path.sep).length;
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    return left.localeCompare(right);
+  });
+  return candidates[0];
+}
+function resolveContentRoots(subdir) {
+  if (subdir === "data") {
+    return [homeDir()];
+  }
+  return [path.join(homeDir(), subdir)];
+}
+function dataDir() {
+  return resolveContentRoots("data")[0];
+}
+function soulPath() {
+  return path.join(dataDir(), "SOUL.md");
+}
+function worldPath() {
+  return path.join(dataDir(), "WORLD.md");
+}
+function descriptionPath() {
+  return path.join(dataDir(), "DESCRIPTION.md");
+}
+function skillsDir() {
+  return resolveContentRoots("skills")[0];
+}
+function pluginsDir() {
+  return resolveContentRoots("plugins")[0];
+}
+function dataRoots() {
+  return unique(resolveContentRoots("data"));
+}
+function skillRoots() {
+  return unique(resolveContentRoots("skills"));
+}
+function pluginRoots() {
+  return unique(resolveContentRoots("plugins"));
+}
+function soulPathCandidates() {
+  const candidates = dataRoots().map((root) => path.join(root, "SOUL.md"));
+  return unique(candidates);
+}
+function worldPathCandidates() {
+  const candidates = dataRoots().map((root) => path.join(root, "WORLD.md"));
+  return unique(candidates);
+}
+function descriptionPathCandidates() {
+  const candidates = dataRoots().map(
+    (root) => path.join(root, "DESCRIPTION.md")
+  );
+  return unique(candidates);
+}
+var RESERVED_APP_FILES = /* @__PURE__ */ new Set([
+  "SOUL.md",
+  "WORLD.md",
+  "DESCRIPTION.md",
+  "ABOUT.md"
+]);
+function listReferenceFiles() {
+  const appDir = homeDir();
+  try {
+    const entries = fs.readdirSync(appDir, { withFileTypes: true });
+    return entries.filter(
+      (entry) => entry.isFile() && entry.name.endsWith(".md") && !RESERVED_APP_FILES.has(entry.name)
+    ).map((entry) => path.join(appDir, entry.name)).sort();
+  } catch {
+    return [];
+  }
+}
+
+export {
+  isDirectory,
+  isFile,
+  discoverNodeModulesDirs,
+  discoverProjectRoots,
+  homeDir,
+  resolveHomeDir,
+  dataDir,
+  soulPath,
+  worldPath,
+  descriptionPath,
+  skillsDir,
+  pluginsDir,
+  dataRoots,
+  skillRoots,
+  pluginRoots,
+  soulPathCandidates,
+  worldPathCandidates,
+  descriptionPathCandidates,
+  listReferenceFiles
+};

package/dist/chunk-4ZNGQH7C.js

@@ -0,0 +1,25 @@
+// src/chat/sleep.ts
+function sleep(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+export {
+  sleep
+};