@sentry/junior 0.11.1 → 0.12.0

package/dist/chunk-XH7TV4JS.js

@@ -1,560 +0,0 @@
-// src/chat/plugins/package-discovery.ts
-import { readFileSync, readdirSync as readdirSync2 } from "fs";
-import path2 from "path";
-import { parse as parseYaml } from "yaml";
-
-// src/chat/discovery.ts
-import fs, { readdirSync, 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 listTopLevelPackages(nodeModulesDir) {
-  const entries = readdirSync(nodeModulesDir, { withFileTypes: true }).filter(
-    (entry) => !entry.name.startsWith(".") && entry.name !== ".bin" && entry.name !== ".pnpm"
-  ).sort((left, right) => left.name.localeCompare(right.name));
-  const packages = [];
-  for (const entry of entries) {
-    const entryPath = path.join(nodeModulesDir, entry.name);
-    if (entry.name.startsWith("@")) {
-      if (!isDirectory(entryPath)) {
-        continue;
-      }
-      const scopedEntries = readdirSync(entryPath, {
-        withFileTypes: true
-      }).sort((left, right) => left.name.localeCompare(right.name));
-      for (const scopedEntry of scopedEntries) {
-        const packageName = `${entry.name}/${scopedEntry.name}`;
-        const packagePath = path.join(entryPath, scopedEntry.name);
-        if (!isDirectory(packagePath)) {
-          continue;
-        }
-        packages.push({ name: packageName, dir: packagePath });
-      }
-      continue;
-    }
-    if (!isDirectory(entryPath)) {
-      continue;
-    }
-    packages.push({ name: entry.name, dir: entryPath });
-  }
-  return packages;
-}
-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, "ABOUT.md"));
-}
-function scoreAppCandidate(appDir) {
-  let score = 0;
-  if (pathExists(path.join(appDir, "SOUL.md"))) {
-    score += 4;
-  }
-  if (pathExists(path.join(appDir, "ABOUT.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 aboutPathCandidates() {
-  const candidates = dataRoots().map((root) => path.join(root, "ABOUT.md"));
-  return unique(candidates);
-}
-
-// src/chat/plugins/package-discovery.ts
-function normalizeForGlob(targetPath) {
-  return targetPath.split(path2.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 = path2.relative(cwd, targetPath);
-  if (!relative || path2.isAbsolute(relative)) {
-    return null;
-  }
-  const normalized = normalizeForGlob(relative);
-  return normalized.startsWith(".") ? normalized : `./${normalized}`;
-}
-function parseRuntimeConfiguredPackageNames(value) {
-  if (!Array.isArray(value)) {
-    return null;
-  }
-  const parsed = value.filter(
-    (entry) => typeof entry === "string" && entry.trim().length > 0
-  );
-  return uniqueStringsInOrder(parsed.map((entry) => entry.trim()));
-}
-var configuredPluginPackages;
-function setPluginPackages(packages) {
-  configuredPluginPackages = packages;
-}
-function readNextRuntimeConfiguredPackageNames() {
-  if (configuredPluginPackages !== void 0) {
-    return configuredPluginPackages;
-  }
-  const raw = process.env.JUNIOR_PLUGIN_PACKAGES;
-  if (raw === void 0) {
-    return null;
-  }
-  try {
-    return parseRuntimeConfiguredPackageNames(JSON.parse(raw)) ?? [];
-  } catch {
-    return [];
-  }
-}
-function findWorkspaceRoot(cwd) {
-  let current = path2.resolve(cwd);
-  while (true) {
-    const candidate = path2.join(current, "pnpm-workspace.yaml");
-    if (isFile(candidate)) {
-      return current;
-    }
-    const parent = path2.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function listWorkspacePackageDirs(cwd) {
-  const workspaceRoot = findWorkspaceRoot(cwd);
-  if (!workspaceRoot) {
-    return [];
-  }
-  let packagePatterns = [];
-  try {
-    const raw = readFileSync(
-      path2.join(workspaceRoot, "pnpm-workspace.yaml"),
-      "utf8"
-    );
-    const parsed = parseYaml(raw);
-    packagePatterns = Array.isArray(parsed.packages) ? parsed.packages.filter(
-      (entry) => typeof entry === "string" && entry.trim().length > 0
-    ) : [];
-  } catch {
-    return [];
-  }
-  const discovered = [];
-  const seen = /* @__PURE__ */ new Set();
-  const addDir = (candidate) => {
-    const normalized = path2.resolve(candidate);
-    if (seen.has(normalized) || !isDirectory(normalized)) {
-      return;
-    }
-    seen.add(normalized);
-    discovered.push(normalized);
-  };
-  for (const pattern of packagePatterns) {
-    const trimmed = pattern.trim();
-    if (!trimmed) {
-      continue;
-    }
-    if (trimmed.endsWith("/*")) {
-      const baseDir = path2.join(workspaceRoot, trimmed.slice(0, -2));
-      if (!isDirectory(baseDir)) {
-        continue;
-      }
-      for (const entry of readdirSync2(baseDir)) {
-        addDir(path2.join(baseDir, entry));
-      }
-      continue;
-    }
-    addDir(path2.join(workspaceRoot, trimmed));
-  }
-  return discovered;
-}
-function readPluginPackageFlags(dir) {
-  const hasRootPluginManifest = isFile(path2.join(dir, "plugin.yaml"));
-  const hasPluginsDir = isDirectory(path2.join(dir, "plugins"));
-  const hasSkillsDir = isDirectory(path2.join(dir, "skills"));
-  if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
-    return null;
-  }
-  return {
-    hasRootPluginManifest,
-    hasPluginsDir,
-    hasSkillsDir
-  };
-}
-function discoverWorkspacePluginPackageDirs(cwd, packageNames) {
-  if (packageNames !== null) {
-    return [];
-  }
-  return listWorkspacePackageDirs(cwd).filter(
-    (candidate) => readPluginPackageFlags(candidate) !== null
-  );
-}
-function readWorkspacePackageName(dir) {
-  try {
-    const raw = readFileSync(path2.join(dir, "package.json"), "utf8");
-    const name = JSON.parse(raw).name;
-    return typeof name === "string" && name.trim().length > 0 ? name : null;
-  } catch {
-    return null;
-  }
-}
-function resolveWorkspacePackageDirFromName(cwd, packageName) {
-  for (const candidate of listWorkspacePackageDirs(cwd)) {
-    if (readWorkspacePackageName(candidate) !== packageName) {
-      continue;
-    }
-    return candidate;
-  }
-  return null;
-}
-function resolvePackageDirFromName(packageName, candidateNodeModulesDirs) {
-  for (const nodeModulesDir of candidateNodeModulesDirs) {
-    const packageDir = path2.join(nodeModulesDir, ...packageName.split("/"));
-    if (isDirectory(packageDir)) {
-      return {
-        dir: path2.resolve(packageDir),
-        nodeModulesDir: path2.resolve(nodeModulesDir)
-      };
-    }
-  }
-  return null;
-}
-function discoverDeclaredPackages(cwd, packageNames, candidateNodeModulesDirs) {
-  const discovered = [];
-  const seenPackageNames = /* @__PURE__ */ new Set();
-  const seenPackageDirs = /* @__PURE__ */ new Set();
-  for (const packageName of packageNames) {
-    const resolved = resolvePackageDirFromName(
-      packageName,
-      candidateNodeModulesDirs
-    );
-    const workspaceDir = resolved ? null : resolveWorkspacePackageDirFromName(cwd, packageName);
-    if (!resolved && !workspaceDir) {
-      continue;
-    }
-    const packageDir = resolved?.dir ?? workspaceDir;
-    if (seenPackageNames.has(packageName) || seenPackageDirs.has(packageDir)) {
-      continue;
-    }
-    const pluginFlags = readPluginPackageFlags(packageDir);
-    if (!pluginFlags) {
-      continue;
-    }
-    seenPackageNames.add(packageName);
-    seenPackageDirs.add(packageDir);
-    discovered.push({
-      name: packageName,
-      dir: packageDir,
-      nodeModulesDir: resolved?.nodeModulesDir ?? null,
-      ...pluginFlags
-    });
-  }
-  return discovered;
-}
-function discoverInstalledJuniorContentPackages(cwd = process.cwd(), nodeModulesDirs, packageNames) {
-  const resolvedCwd = path2.resolve(cwd);
-  const candidateNodeModulesDirs = nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
-  const configuredPackageNames = packageNames ?? readNextRuntimeConfiguredPackageNames();
-  const declaredPackages = discoverDeclaredPackages(
-    resolvedCwd,
-    configuredPackageNames ?? [],
-    candidateNodeModulesDirs
-  );
-  const useFallbackScan = configuredPackageNames === null;
-  const discovered = [...declaredPackages];
-  const seenPackageNames = /* @__PURE__ */ new Set();
-  const seenPackageDirs = /* @__PURE__ */ new Set();
-  for (const pkg of declaredPackages) {
-    seenPackageNames.add(pkg.name);
-    seenPackageDirs.add(pkg.dir);
-  }
-  if (!useFallbackScan) {
-    return discovered;
-  }
-  for (const nodeModulesDir of candidateNodeModulesDirs) {
-    for (const pkg of listTopLevelPackages(nodeModulesDir)) {
-      const resolvedDir = path2.resolve(pkg.dir);
-      if (seenPackageNames.has(pkg.name) || seenPackageDirs.has(resolvedDir)) {
-        continue;
-      }
-      seenPackageNames.add(pkg.name);
-      seenPackageDirs.add(resolvedDir);
-      const hasRootPluginManifest = isFile(
-        path2.join(resolvedDir, "plugin.yaml")
-      );
-      const hasPluginsDir = isDirectory(path2.join(resolvedDir, "plugins"));
-      const hasSkillsDir = isDirectory(path2.join(resolvedDir, "skills"));
-      if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
-        continue;
-      }
-      discovered.push({
-        name: pkg.name,
-        dir: resolvedDir,
-        nodeModulesDir: path2.resolve(nodeModulesDir),
-        hasRootPluginManifest,
-        hasPluginsDir,
-        hasSkillsDir
-      });
-    }
-  }
-  return discovered;
-}
-function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
-  const resolvedCwd = path2.resolve(cwd);
-  const configuredPackageNames = options?.packageNames ?? readNextRuntimeConfiguredPackageNames();
-  const discoveredPackages = discoverInstalledJuniorContentPackages(
-    resolvedCwd,
-    options?.nodeModulesDirs,
-    configuredPackageNames
-  );
-  const workspacePluginDirs = discoverWorkspacePluginPackageDirs(
-    resolvedCwd,
-    configuredPackageNames
-  );
-  const manifestRoots = [];
-  const skillRoots2 = [];
-  const tracingIncludes = [];
-  for (const pkg of discoveredPackages) {
-    const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(
-      resolvedCwd,
-      path2.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(path2.join(pkg.dir, "plugins"));
-      if (tracingBasePath) {
-        tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
-      }
-    }
-    if (pkg.hasSkillsDir) {
-      skillRoots2.push(path2.join(pkg.dir, "skills"));
-      if (tracingBasePath) {
-        tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
-      }
-    }
-  }
-  for (const pluginDir of workspacePluginDirs) {
-    const tracingBasePath = pathForTracingInclude(resolvedCwd, pluginDir);
-    if (isFile(path2.join(pluginDir, "plugin.yaml"))) {
-      manifestRoots.push(pluginDir);
-      if (tracingBasePath) {
-        tracingIncludes.push(`${tracingBasePath}/plugin.yaml`);
-      }
-    }
-    if (isDirectory(path2.join(pluginDir, "plugins"))) {
-      manifestRoots.push(path2.join(pluginDir, "plugins"));
-      if (tracingBasePath) {
-        tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
-      }
-    }
-    if (isDirectory(path2.join(pluginDir, "skills"))) {
-      skillRoots2.push(path2.join(pluginDir, "skills"));
-      if (tracingBasePath) {
-        tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
-      }
-    }
-  }
-  return {
-    packageNames: uniqueStringsInOrder(
-      discoveredPackages.map((pkg) => pkg.name)
-    ),
-    manifestRoots: uniqueStringsInOrder(manifestRoots),
-    skillRoots: uniqueStringsInOrder(skillRoots2),
-    tracingIncludes: uniqueStringsInOrder(tracingIncludes)
-  };
-}
-
-export {
-  homeDir,
-  skillRoots,
-  pluginRoots,
-  soulPathCandidates,
-  aboutPathCandidates,
-  setPluginPackages,
-  discoverInstalledPluginPackageContent
-};

package/dist/nitro.d.ts

@@ -1,27 +0,0 @@
-interface JuniorNitroConfigOptions {
-    cwd?: string;
-    maxDuration?: number;
-}
-/** Return the default Nitro config used by scaffolded Junior apps. */
-declare function juniorNitroConfig(options?: JuniorNitroConfigOptions): {
-    preset: "vercel";
-    vercel: {
-        functions: {
-            maxDuration: number;
-        };
-    };
-    modules: {
-        setup(nitro: {
-            hooks: {
-                hook(name: "compiled", callback: () => void): void;
-            };
-            options: {
-                output: {
-                    serverDir: string;
-                };
-            };
-        }): void;
-    }[];
-};
-
-export { type JuniorNitroConfigOptions, juniorNitroConfig };

package/dist/nitro.js

@@ -1,62 +0,0 @@
-import {
-  discoverInstalledPluginPackageContent
-} from "./chunk-XH7TV4JS.js";
-import "./chunk-2KG3PWR4.js";
-
-// src/nitro.ts
-import { cpSync, existsSync, mkdirSync } from "fs";
-import path from "path";
-function copyAppAndPluginContent(cwd, serverRoot) {
-  copyIfExists(path.join(cwd, "app"), path.join(serverRoot, "app"));
-  const packagedContent = discoverInstalledPluginPackageContent(cwd);
-  for (const root of packagedContent.manifestRoots) {
-    if (existsSync(path.join(root, "plugin.yaml"))) {
-      copyIfExists(
-        path.join(root, "plugin.yaml"),
-        path.join(serverRoot, path.relative(cwd, root), "plugin.yaml")
-      );
-      continue;
-    }
-    copyRootIntoServerOutput(cwd, serverRoot, root);
-  }
-  for (const root of packagedContent.skillRoots) {
-    copyRootIntoServerOutput(cwd, serverRoot, root);
-  }
-}
-function copyIfExists(source, target) {
-  if (!existsSync(source)) {
-    return;
-  }
-  mkdirSync(path.dirname(target), { recursive: true });
-  cpSync(source, target, { recursive: true });
-}
-function copyRootIntoServerOutput(cwd, serverRoot, root) {
-  const relative = path.relative(cwd, root);
-  if (!relative || path.isAbsolute(relative) || relative.startsWith("..")) {
-    return;
-  }
-  copyIfExists(root, path.join(serverRoot, relative));
-}
-function juniorNitroConfig(options = {}) {
-  const cwd = path.resolve(options.cwd ?? process.cwd());
-  return {
-    preset: "vercel",
-    vercel: {
-      functions: {
-        maxDuration: options.maxDuration ?? 800
-      }
-    },
-    modules: [
-      {
-        setup(nitro) {
-          nitro.hooks.hook("compiled", () => {
-            copyAppAndPluginContent(cwd, nitro.options.output.serverDir);
-          });
-        }
-      }
-    ]
-  };
-}
-export {
-  juniorNitroConfig
-};