@sentry/junior 0.96.0 → 0.97.1

package/dist/{chunk-6APU57E6.js → chunk-B3IT5END.js}

@@ -1,245 +1,32 @@
-// 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 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);
-}
-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 [];
-  }
-}
+import {
+  discoverNodeModulesDirs,
+  isDirectory,
+  isFile
+} from "./chunk-3V7OFJZC.js";
 
 // src/package-resolution.ts
-import { statSync as statSync2 } from "fs";
+import { statSync } from "fs";
 import { createRequire } from "module";
-import path2 from "path";
+import path from "path";
 function isDirectory2(targetPath) {
   try {
-    return statSync2(targetPath).isDirectory();
+    return statSync(targetPath).isDirectory();
   } catch {
     return false;
   }
 }
 function isFile2(targetPath) {
   try {
-    return statSync2(targetPath).isFile();
+    return statSync(targetPath).isFile();
   } catch {
     return false;
   }
 }
-function uniqueResolvedPathsInOrder2(values) {
+function uniqueResolvedPathsInOrder(values) {
   const seen = /* @__PURE__ */ new Set();
   const resolved = [];
   for (const value of values) {
-    const normalized = path2.resolve(value);
+    const normalized = path.resolve(value);
     if (seen.has(normalized)) {
       continue;
     }
@@ -250,13 +37,13 @@ function uniqueResolvedPathsInOrder2(values) {
 }
 function ancestorNodeModulesDirs(cwd) {
   const dirs = [];
-  let current = path2.resolve(cwd);
+  let current = path.resolve(cwd);
   while (true) {
-    const nodeModulesDir = path2.join(current, "node_modules");
+    const nodeModulesDir = path.join(current, "node_modules");
     if (isDirectory2(nodeModulesDir)) {
       dirs.push(nodeModulesDir);
     }
-    const parent = path2.dirname(current);
+    const parent = path.dirname(current);
     if (parent === current) {
       break;
     }
@@ -265,14 +52,14 @@ function ancestorNodeModulesDirs(cwd) {
   return dirs;
 }
 function packageDirInNodeModules(nodeModulesDir, packageName) {
-  const packageDir = path2.join(nodeModulesDir, ...packageName.split("/"));
-  return isDirectory2(packageDir) ? path2.resolve(packageDir) : void 0;
+  const packageDir = path.join(nodeModulesDir, ...packageName.split("/"));
+  return isDirectory2(packageDir) ? path.resolve(packageDir) : void 0;
 }
 function isValidPackageSegment(segment) {
   return Boolean(segment) && segment !== "." && segment !== ".." && !segment.startsWith(".") && /^[A-Za-z0-9._~-]+$/.test(segment);
 }
 function isValidPackageName(packageName) {
-  if (!packageName || packageName.includes("\\") || path2.isAbsolute(packageName)) {
+  if (!packageName || packageName.includes("\\") || path.isAbsolute(packageName)) {
     return false;
   }
   const parts = packageName.split("/");
@@ -282,17 +69,17 @@ function isValidPackageName(packageName) {
   return parts.length === 1 && isValidPackageSegment(parts[0]);
 }
 function findPackageRoot(entryPath) {
-  let dir = path2.dirname(entryPath);
-  while (dir !== path2.dirname(dir)) {
-    if (isFile2(path2.join(dir, "package.json"))) {
-      return path2.resolve(dir);
+  let dir = path.dirname(entryPath);
+  while (dir !== path.dirname(dir)) {
+    if (isFile2(path.join(dir, "package.json"))) {
+      return path.resolve(dir);
     }
-    dir = path2.dirname(dir);
+    dir = path.dirname(dir);
   }
   return void 0;
 }
 function findPackageNodeModulesDir(packageDir, packageName) {
-  const parts = path2.resolve(packageDir).split(path2.sep);
+  const parts = path.resolve(packageDir).split(path.sep);
   const packageParts = packageName.split("/");
   for (let index = parts.length - 1; index >= 0; index -= 1) {
     if (parts[index] !== "node_modules") {
@@ -305,21 +92,21 @@ function findPackageNodeModulesDir(packageDir, packageName) {
     if (candidatePackageParts.join("/") !== packageParts.join("/")) {
       continue;
     }
-    return path2.resolve(parts.slice(0, index + 1).join(path2.sep) || path2.sep);
+    return path.resolve(parts.slice(0, index + 1).join(path.sep) || path.sep);
   }
   return void 0;
 }
 function resolvePackageWithNode(cwd, packageName) {
   let requireFromCwd;
   try {
-    requireFromCwd = createRequire(path2.join(cwd, "package.json"));
+    requireFromCwd = createRequire(path.join(cwd, "package.json"));
   } catch {
     return void 0;
   }
   for (const specifier of [`${packageName}/package.json`, packageName]) {
     try {
       const resolved = requireFromCwd.resolve(specifier);
-      const dir = specifier.endsWith("/package.json") ? path2.dirname(resolved) : findPackageRoot(resolved);
+      const dir = specifier.endsWith("/package.json") ? path.dirname(resolved) : findPackageRoot(resolved);
       if (!dir) {
         continue;
       }
@@ -337,7 +124,7 @@ function resolvePackageLocation(cwd, packageName, options) {
   if (!isValidPackageName(packageName)) {
     return void 0;
   }
-  const nodeModulesDirs = uniqueResolvedPathsInOrder2([
+  const nodeModulesDirs = uniqueResolvedPathsInOrder([
     ...options?.nodeModulesDirs ?? [],
     ...ancestorNodeModulesDirs(cwd)
   ]);
@@ -354,9 +141,9 @@ function resolvePackageDir(cwd, packageName) {
 }
 
 // src/chat/plugins/package-discovery.ts
-import path3 from "path";
+import path2 from "path";
 function normalizeForGlob(targetPath) {
-  return targetPath.split(path3.sep).join("/");
+  return targetPath.split(path2.sep).join("/");
 }
 function uniqueStringsInOrder(values) {
   const seen = /* @__PURE__ */ new Set();
@@ -371,8 +158,8 @@ function uniqueStringsInOrder(values) {
   return resolved;
 }
 function pathForTracingInclude(cwd, targetPath) {
-  const relative = path3.relative(cwd, targetPath);
-  if (!relative || path3.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path3.sep}`)) {
+  const relative = path2.relative(cwd, targetPath);
+  if (!relative || path2.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path2.sep}`)) {
     return null;
   }
   const normalized = normalizeForGlob(relative);
@@ -409,10 +196,10 @@ function resolvePackageDirFromName(cwd, packageName, candidateNodeModulesDirs) {
   }) ?? null;
 }
 function readPluginPackageFlags(dir) {
-  const hasRootPluginManifest = isFile(path3.join(dir, "plugin.yaml"));
-  const hasMigrationsDir = isDirectory(path3.join(dir, "migrations"));
-  const hasPluginsDir = isDirectory(path3.join(dir, "plugins"));
-  const hasSkillsDir = isDirectory(path3.join(dir, "skills"));
+  const hasRootPluginManifest = isFile(path2.join(dir, "plugin.yaml"));
+  const hasMigrationsDir = isDirectory(path2.join(dir, "migrations"));
+  const hasPluginsDir = isDirectory(path2.join(dir, "plugins"));
+  const hasSkillsDir = isDirectory(path2.join(dir, "skills"));
   if (!hasRootPluginManifest && !hasMigrationsDir && !hasPluginsDir && !hasSkillsDir) {
     return null;
   }
@@ -457,7 +244,7 @@ function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs, cwd) {
   return discovered;
 }
 function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
-  const resolvedCwd = path3.resolve(cwd);
+  const resolvedCwd = path2.resolve(cwd);
   const packageNames = normalizePluginPackageNames(options?.packageNames);
   const nodeModulesDirs = options?.nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
   const discoveredPackages = discoverDeclaredPackages(
@@ -466,12 +253,12 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
     resolvedCwd
   );
   const manifestRoots = [];
-  const skillRoots2 = [];
+  const skillRoots = [];
   const tracingIncludes = [];
   for (const pkg of discoveredPackages) {
     const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(
       resolvedCwd,
-      path3.join(pkg.nodeModulesDir, ...pkg.packageName.split("/"))
+      path2.join(pkg.nodeModulesDir, ...pkg.packageName.split("/"))
     ) : pathForTracingInclude(resolvedCwd, pkg.dir);
     if (pkg.hasRootPluginManifest) {
       manifestRoots.push(pkg.dir);
@@ -485,13 +272,13 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
       }
     }
     if (pkg.hasPluginsDir) {
-      manifestRoots.push(path3.join(pkg.dir, "plugins"));
+      manifestRoots.push(path2.join(pkg.dir, "plugins"));
       if (tracingBasePath) {
         tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
       }
     }
     if (pkg.hasSkillsDir) {
-      skillRoots2.push(path3.join(pkg.dir, "skills"));
+      skillRoots.push(path2.join(pkg.dir, "skills"));
       if (tracingBasePath) {
         tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
       }
@@ -508,18 +295,12 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
       packageName: pkg.packageName
     })),
     manifestRoots: uniqueStringsInOrder(manifestRoots),
-    skillRoots: uniqueStringsInOrder(skillRoots2),
+    skillRoots: uniqueStringsInOrder(skillRoots),
     tracingIncludes: uniqueStringsInOrder(tracingIncludes)
   };
 }
 
 export {
-  homeDir,
-  skillRoots,
-  pluginRoots,
-  soulPathCandidates,
-  worldPathCandidates,
-  listReferenceFiles,
   isValidPackageName,
   resolvePackageDir,
   normalizePluginPackageNames,

package/dist/chunk-CEA3A3UA.js

@@ -0,0 +1,86 @@
+// src/reporting-schema.ts
+import { z } from "zod";
+var healthReportSchema = z.object({
+  status: z.literal("ok"),
+  service: z.string(),
+  timestamp: z.string()
+}).strict();
+var pluginReportSchema = z.object({ name: z.string() }).strict();
+var pluginReportsSchema = z.array(pluginReportSchema);
+var skillReportSchema = z.object({
+  name: z.string(),
+  pluginProvider: z.string().optional()
+}).strict();
+var skillReportsSchema = z.array(skillReportSchema);
+var pluginPackageContentItemReportSchema = z.object({
+  dir: z.string(),
+  hasMigrationsDir: z.boolean(),
+  hasSkillsDir: z.boolean(),
+  packageName: z.string()
+}).strict();
+var pluginPackageContentReportSchema = z.object({
+  packageNames: z.array(z.string()),
+  packages: z.array(pluginPackageContentItemReportSchema),
+  manifestRoots: z.array(z.string()),
+  skillRoots: z.array(z.string()),
+  tracingIncludes: z.array(z.string())
+}).strict();
+var runtimeInfoReportSchema = z.object({
+  cwd: z.string(),
+  homeDir: z.string(),
+  descriptionText: z.string().optional(),
+  providers: z.array(z.string()),
+  skills: z.array(skillReportSchema),
+  packagedContent: pluginPackageContentReportSchema
+}).strict();
+var pluginOperationalToneSchema = z.enum([
+  "danger",
+  "good",
+  "neutral",
+  "warning"
+]);
+var pluginOperationalMetricSchema = z.object({
+  label: z.string(),
+  tone: pluginOperationalToneSchema.optional(),
+  value: z.string()
+}).strict();
+var pluginOperationalFieldSchema = z.object({
+  key: z.string(),
+  label: z.string()
+}).strict();
+var pluginOperationalRecordSchema = z.object({
+  id: z.string(),
+  tone: pluginOperationalToneSchema.optional(),
+  values: z.record(z.string(), z.string())
+}).strict();
+var pluginOperationalRecordSetSchema = z.object({
+  fields: z.array(pluginOperationalFieldSchema).optional(),
+  emptyText: z.string().optional(),
+  records: z.array(pluginOperationalRecordSchema).optional(),
+  title: z.string()
+}).strict();
+var pluginOperationalReportSchema = z.object({
+  generatedAt: z.string().optional(),
+  metrics: z.array(pluginOperationalMetricSchema).optional(),
+  recordSets: z.array(pluginOperationalRecordSetSchema).optional(),
+  title: z.string().optional(),
+  pluginName: z.string()
+}).strict();
+var pluginOperationalReportFeedSchema = z.object({
+  generatedAt: z.string(),
+  reports: z.array(pluginOperationalReportSchema),
+  source: z.literal("plugins")
+}).strict();
+
+export {
+  healthReportSchema,
+  pluginReportSchema,
+  pluginReportsSchema,
+  skillReportSchema,
+  skillReportsSchema,
+  pluginPackageContentItemReportSchema,
+  pluginPackageContentReportSchema,
+  runtimeInfoReportSchema,
+  pluginOperationalReportSchema,
+  pluginOperationalReportFeedSchema
+};

package/dist/{chunk-YDT7SNCN.js → chunk-D5KZYS4T.js}

@@ -1,6 +1,6 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-L7CDEIVJ.js";
+} from "./chunk-LMJPRYHP.js";
 
 // src/chat/plugins/validation.ts
 import { isDeepStrictEqual } from "util";