@sentry/junior 0.68.0 → 0.70.0

package/dist/chunk-KVZL5NZS.js

@@ -1,519 +0,0 @@
-// 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 [];
-  }
-}
-
-// src/package-resolution.ts
-import { statSync as statSync2 } from "fs";
-import { createRequire } from "module";
-import path2 from "path";
-function isDirectory2(targetPath) {
-  try {
-    return statSync2(targetPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function isFile2(targetPath) {
-  try {
-    return statSync2(targetPath).isFile();
-  } catch {
-    return false;
-  }
-}
-function uniqueResolvedPathsInOrder2(values) {
-  const seen = /* @__PURE__ */ new Set();
-  const resolved = [];
-  for (const value of values) {
-    const normalized = path2.resolve(value);
-    if (seen.has(normalized)) {
-      continue;
-    }
-    seen.add(normalized);
-    resolved.push(normalized);
-  }
-  return resolved;
-}
-function ancestorNodeModulesDirs(cwd) {
-  const dirs = [];
-  let current = path2.resolve(cwd);
-  while (true) {
-    const nodeModulesDir = path2.join(current, "node_modules");
-    if (isDirectory2(nodeModulesDir)) {
-      dirs.push(nodeModulesDir);
-    }
-    const parent = path2.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  return dirs;
-}
-function packageDirInNodeModules(nodeModulesDir, packageName) {
-  const packageDir = path2.join(nodeModulesDir, ...packageName.split("/"));
-  return isDirectory2(packageDir) ? path2.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)) {
-    return false;
-  }
-  const parts = packageName.split("/");
-  if (parts[0].startsWith("@")) {
-    return parts.length === 2 && parts[0].length > 1 && isValidPackageSegment(parts[0].slice(1)) && isValidPackageSegment(parts[1]);
-  }
-  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);
-    }
-    dir = path2.dirname(dir);
-  }
-  return void 0;
-}
-function findPackageNodeModulesDir(packageDir, packageName) {
-  const parts = path2.resolve(packageDir).split(path2.sep);
-  const packageParts = packageName.split("/");
-  for (let index = parts.length - 1; index >= 0; index -= 1) {
-    if (parts[index] !== "node_modules") {
-      continue;
-    }
-    const candidatePackageParts = parts.slice(
-      index + 1,
-      index + 1 + packageParts.length
-    );
-    if (candidatePackageParts.join("/") !== packageParts.join("/")) {
-      continue;
-    }
-    return path2.resolve(parts.slice(0, index + 1).join(path2.sep) || path2.sep);
-  }
-  return void 0;
-}
-function resolvePackageWithNode(cwd, packageName) {
-  let requireFromCwd;
-  try {
-    requireFromCwd = createRequire(path2.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);
-      if (!dir) {
-        continue;
-      }
-      const nodeModulesDir = findPackageNodeModulesDir(dir, packageName);
-      return {
-        dir,
-        ...nodeModulesDir ? { nodeModulesDir } : {}
-      };
-    } catch {
-    }
-  }
-  return void 0;
-}
-function resolvePackageLocation(cwd, packageName, options) {
-  if (!isValidPackageName(packageName)) {
-    return void 0;
-  }
-  const nodeModulesDirs = uniqueResolvedPathsInOrder2([
-    ...options?.nodeModulesDirs ?? [],
-    ...ancestorNodeModulesDirs(cwd)
-  ]);
-  for (const nodeModulesDir of nodeModulesDirs) {
-    const dir = packageDirInNodeModules(nodeModulesDir, packageName);
-    if (dir) {
-      return { dir, nodeModulesDir };
-    }
-  }
-  return resolvePackageWithNode(cwd, packageName);
-}
-function resolvePackageDir(cwd, packageName) {
-  return resolvePackageLocation(cwd, packageName)?.dir;
-}
-
-// src/chat/plugins/package-discovery.ts
-import path3 from "path";
-function normalizeForGlob(targetPath) {
-  return targetPath.split(path3.sep).join("/");
-}
-function uniqueStringsInOrder(values) {
-  const seen = /* @__PURE__ */ new Set();
-  const resolved = [];
-  for (const value of values) {
-    if (seen.has(value)) {
-      continue;
-    }
-    seen.add(value);
-    resolved.push(value);
-  }
-  return resolved;
-}
-function pathForTracingInclude(cwd, targetPath) {
-  const relative = path3.relative(cwd, targetPath);
-  if (!relative || path3.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path3.sep}`)) {
-    return null;
-  }
-  const normalized = normalizeForGlob(relative);
-  return normalized.startsWith(".") ? normalized : `./${normalized}`;
-}
-function normalizePluginPackageNames(packageNames) {
-  if (packageNames === void 0) {
-    return [];
-  }
-  if (!Array.isArray(packageNames)) {
-    throw new Error("Plugin package names must be an array");
-  }
-  const normalized = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const packageName of packageNames) {
-    const normalizedPackageName = typeof packageName === "string" ? packageName.trim() : "";
-    if (!normalizedPackageName || !isValidPackageName(normalizedPackageName)) {
-      throw new Error("Plugin package names must be valid npm package names");
-    }
-    if (seen.has(normalizedPackageName)) {
-      continue;
-    }
-    seen.add(normalizedPackageName);
-    normalized.push(normalizedPackageName);
-  }
-  return normalized;
-}
-function formatNodeModulesDirs(candidateNodeModulesDirs) {
-  return candidateNodeModulesDirs.length > 0 ? candidateNodeModulesDirs.join(", ") : "none found";
-}
-function resolvePackageDirFromName(cwd, packageName, candidateNodeModulesDirs) {
-  return resolvePackageLocation(cwd, packageName, {
-    nodeModulesDirs: candidateNodeModulesDirs
-  }) ?? null;
-}
-function readPluginPackageFlags(dir) {
-  const hasRootPluginManifest = isFile(path3.join(dir, "plugin.yaml"));
-  const hasPluginsDir = isDirectory(path3.join(dir, "plugins"));
-  const hasSkillsDir = isDirectory(path3.join(dir, "skills"));
-  if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
-    return null;
-  }
-  return {
-    hasRootPluginManifest,
-    hasPluginsDir,
-    hasSkillsDir
-  };
-}
-function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs, cwd) {
-  const discovered = [];
-  const seenPackageDirs = /* @__PURE__ */ new Set();
-  for (const packageName of packageNames) {
-    const resolved = resolvePackageDirFromName(
-      cwd,
-      packageName,
-      candidateNodeModulesDirs
-    );
-    if (!resolved) {
-      throw new Error(
-        `Plugin package "${packageName}" was configured but could not be resolved from node_modules or package resolution (${formatNodeModulesDirs(candidateNodeModulesDirs)})`
-      );
-    }
-    if (seenPackageDirs.has(resolved.dir)) {
-      continue;
-    }
-    const pluginFlags = readPluginPackageFlags(resolved.dir);
-    if (!pluginFlags) {
-      throw new Error(
-        `Plugin package "${packageName}" was configured but does not contain plugin content; expected plugin.yaml, plugins/, or skills/ in ${resolved.dir}`
-      );
-    }
-    seenPackageDirs.add(resolved.dir);
-    discovered.push({
-      name: packageName,
-      dir: resolved.dir,
-      nodeModulesDir: resolved.nodeModulesDir,
-      ...pluginFlags
-    });
-  }
-  return discovered;
-}
-function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
-  const resolvedCwd = path3.resolve(cwd);
-  const packageNames = normalizePluginPackageNames(options?.packageNames);
-  const nodeModulesDirs = options?.nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
-  const discoveredPackages = discoverDeclaredPackages(
-    packageNames,
-    nodeModulesDirs,
-    resolvedCwd
-  );
-  const manifestRoots = [];
-  const skillRoots2 = [];
-  const tracingIncludes = [];
-  for (const pkg of discoveredPackages) {
-    const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(
-      resolvedCwd,
-      path3.join(pkg.nodeModulesDir, ...pkg.name.split("/"))
-    ) : pathForTracingInclude(resolvedCwd, pkg.dir);
-    if (pkg.hasRootPluginManifest) {
-      manifestRoots.push(pkg.dir);
-      if (tracingBasePath) {
-        tracingIncludes.push(`${tracingBasePath}/plugin.yaml`);
-      }
-    }
-    if (pkg.hasPluginsDir) {
-      manifestRoots.push(path3.join(pkg.dir, "plugins"));
-      if (tracingBasePath) {
-        tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
-      }
-    }
-    if (pkg.hasSkillsDir) {
-      skillRoots2.push(path3.join(pkg.dir, "skills"));
-      if (tracingBasePath) {
-        tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
-      }
-    }
-  }
-  return {
-    packageNames: uniqueStringsInOrder(
-      discoveredPackages.map((pkg) => pkg.name)
-    ),
-    packages: discoveredPackages.map((pkg) => ({
-      dir: pkg.dir,
-      hasSkillsDir: pkg.hasSkillsDir,
-      name: pkg.name
-    })),
-    manifestRoots: uniqueStringsInOrder(manifestRoots),
-    skillRoots: uniqueStringsInOrder(skillRoots2),
-    tracingIncludes: uniqueStringsInOrder(tracingIncludes)
-  };
-}
-
-export {
-  homeDir,
-  skillRoots,
-  pluginRoots,
-  soulPathCandidates,
-  worldPathCandidates,
-  listReferenceFiles,
-  isValidPackageName,
-  resolvePackageDir,
-  normalizePluginPackageNames,
-  discoverInstalledPluginPackageContent
-};