@sentry/junior 0.4.1 → 0.6.0

package/dist/cli/check.js

@@ -0,0 +1,303 @@
+import {
+  parseSkillFile
+} from "../chunk-KT5HARSN.js";
+import {
+  parsePluginManifest
+} from "../chunk-VW26MOSO.js";
+
+// src/cli/check.ts
+import fs from "fs/promises";
+import path from "path";
+var DEFAULT_IO = {
+  info: console.log,
+  warn: console.warn,
+  error: console.error
+};
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m"
+};
+function supportsColor(stream) {
+  if (process.env.NO_COLOR !== void 0) {
+    return false;
+  }
+  if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0") {
+    return true;
+  }
+  return Boolean(stream?.isTTY);
+}
+var COLOR_ENABLED = supportsColor(process.stdout) || supportsColor(process.stderr);
+function color(text, ...codes) {
+  if (!COLOR_ENABLED || codes.length === 0) {
+    return text;
+  }
+  return `${codes.join("")}${text}${ANSI.reset}`;
+}
+function contentRoot(rootDir, subdir) {
+  return path.resolve(rootDir, "app", subdir);
+}
+async function pathIsDirectory(targetPath) {
+  try {
+    return (await fs.stat(targetPath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function pathIsFile(targetPath) {
+  try {
+    return (await fs.stat(targetPath)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function validateSkillDirectory(skillDir, duplicateNames) {
+  const skillFile = path.join(skillDir, "SKILL.md");
+  const errors = [];
+  const warnings = [];
+  let raw;
+  try {
+    raw = await fs.readFile(skillFile, "utf8");
+  } catch {
+    errors.push(`${skillFile}: missing SKILL.md`);
+    return { skillFile, errors, warnings };
+  }
+  const parsed = parseSkillFile(raw, path.basename(skillDir));
+  if (!parsed.ok) {
+    errors.push(`${skillFile}: ${parsed.error}`);
+    return { skillFile, errors, warnings };
+  }
+  const name = parsed.skill.name;
+  const firstSeen = duplicateNames.get(name);
+  if (firstSeen) {
+    errors.push(
+      `${skillFile}: duplicate skill name "${name}" (already defined in ${firstSeen})`
+    );
+  } else {
+    duplicateNames.set(name, skillFile);
+  }
+  if (!parsed.skill.body) {
+    warnings.push(`${skillFile}: no skill instructions after frontmatter`);
+  }
+  return { skillFile, skill: parsed.skill, errors, warnings };
+}
+async function validatePluginDirectory(pluginDir, duplicatePluginNames) {
+  const manifestPath = path.join(pluginDir, "plugin.yaml");
+  try {
+    const raw = await fs.readFile(manifestPath, "utf8");
+    const manifest = parsePluginManifest(raw, pluginDir);
+    const firstSeen = duplicatePluginNames.get(manifest.name);
+    if (firstSeen) {
+      return {
+        manifestPath,
+        manifest,
+        errors: [
+          `${manifestPath}: duplicate plugin name "${manifest.name}" (already defined in ${firstSeen})`
+        ]
+      };
+    }
+    duplicatePluginNames.set(manifest.name, manifestPath);
+    return { manifestPath, manifest, errors: [] };
+  } catch (error) {
+    return {
+      manifestPath,
+      errors: [
+        `${manifestPath}: ${error instanceof Error ? error.message : String(error)}`
+      ]
+    };
+  }
+}
+async function collectPluginDirectories(rootDir) {
+  const pluginDirs = [];
+  let entries;
+  try {
+    entries = await fs.readdir(contentRoot(rootDir, "plugins"), {
+      withFileTypes: true
+    });
+  } catch {
+    return pluginDirs;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const pluginDir = path.join(contentRoot(rootDir, "plugins"), entry.name);
+    if (await pathIsFile(path.join(pluginDir, "plugin.yaml"))) {
+      pluginDirs.push(pluginDir);
+    }
+  }
+  return pluginDirs.sort((left, right) => left.localeCompare(right));
+}
+async function collectSkillDirectories(root) {
+  const skillDirs = [];
+  let entries;
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true });
+  } catch {
+    return skillDirs;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      skillDirs.push(path.join(root, entry.name));
+    }
+  }
+  return skillDirs.sort((left, right) => left.localeCompare(right));
+}
+function formatDisplayPath(rootDir, targetPath) {
+  const relativePath = path.relative(rootDir, targetPath);
+  const displayPath = relativePath.length > 0 && !relativePath.startsWith("..") && !path.isAbsolute(relativePath) ? relativePath : targetPath;
+  return displayPath.split(path.sep).join("/");
+}
+function formatStatus(errorCount, warningCount) {
+  if (errorCount > 0) {
+    return "error";
+  }
+  if (warningCount > 0) {
+    return "warn";
+  }
+  return "ok";
+}
+function statusIcon(status) {
+  switch (status) {
+    case "ok":
+      return color("\u2713", ANSI.green, ANSI.bold);
+    case "warn":
+      return color("\u26A0", ANSI.yellow, ANSI.bold);
+    case "error":
+      return color("\u2716", ANSI.red, ANSI.bold);
+  }
+}
+function formatHeading(status, label) {
+  const styledLabel = status === "ok" ? color(label, ANSI.bold) : status === "warn" ? color(label, ANSI.bold, ANSI.yellow) : color(label, ANSI.bold, ANSI.red);
+  return `${statusIcon(status)} ${styledLabel}`;
+}
+function reportSkillResult(result, io, indent, isLast) {
+  const status = formatStatus(result.errors.length, result.warnings.length);
+  const skillName = result.skill?.name ?? path.basename(path.dirname(result.skillFile));
+  const branch = isLast ? "\u2514\u2500" : "\u251C\u2500";
+  io.info(`${indent}${branch} ${formatHeading(status, `skill ${skillName}`)}`);
+}
+function reportPluginResult(result, io) {
+  const skillErrorCount = result.skillResults.reduce(
+    (count, skillResult) => count + skillResult.errors.length,
+    0
+  );
+  const skillWarningCount = result.skillResults.reduce(
+    (count, skillResult) => count + skillResult.warnings.length,
+    0
+  );
+  const status = formatStatus(
+    result.errors.length + skillErrorCount,
+    skillWarningCount
+  );
+  const pluginName = result.manifest?.name ?? path.basename(result.pluginDir);
+  io.info(formatHeading(status, `plugin ${pluginName}`));
+  for (const [index, skillResult] of result.skillResults.entries()) {
+    reportSkillResult(
+      skillResult,
+      io,
+      "  ",
+      index === result.skillResults.length - 1
+    );
+  }
+}
+function reportAppSkills(skillResults, io) {
+  const errorCount = skillResults.reduce(
+    (count, skillResult) => count + skillResult.errors.length,
+    0
+  );
+  const warningCount = skillResults.reduce(
+    (count, skillResult) => count + skillResult.warnings.length,
+    0
+  );
+  const status = formatStatus(errorCount, warningCount);
+  io.info(formatHeading(status, "app skills"));
+  for (const [index, skillResult] of skillResults.entries()) {
+    reportSkillResult(skillResult, io, "  ", index === skillResults.length - 1);
+  }
+}
+async function runCheck(rootDir = process.cwd(), io = DEFAULT_IO) {
+  const resolvedRoot = path.resolve(rootDir);
+  if (!await pathIsDirectory(resolvedRoot)) {
+    throw new Error(
+      `validation root does not exist or is not a directory: ${resolvedRoot}`
+    );
+  }
+  const pluginDirs = await collectPluginDirectories(resolvedRoot);
+  const appSkillsRoot = contentRoot(resolvedRoot, "skills");
+  const appSkillDirs = await collectSkillDirectories(appSkillsRoot);
+  const pluginSkillDirs = /* @__PURE__ */ new Map();
+  for (const pluginDir of pluginDirs) {
+    pluginSkillDirs.set(
+      pluginDir,
+      await collectSkillDirectories(path.join(pluginDir, "skills"))
+    );
+  }
+  const skillDirs = [
+    ...appSkillDirs,
+    ...pluginDirs.flatMap((pluginDir) => pluginSkillDirs.get(pluginDir) ?? [])
+  ].sort((left, right) => left.localeCompare(right));
+  const duplicateSkillNames = /* @__PURE__ */ new Map();
+  const duplicatePluginNames = /* @__PURE__ */ new Map();
+  const warnings = [];
+  const errors = [];
+  const pluginResults = [];
+  const skillResultsByDir = /* @__PURE__ */ new Map();
+  for (const pluginDir of pluginDirs) {
+    const result = await validatePluginDirectory(
+      pluginDir,
+      duplicatePluginNames
+    );
+    pluginResults.push({
+      pluginDir,
+      manifestPath: result.manifestPath,
+      ...result.manifest ? { manifest: result.manifest } : {},
+      errors: result.errors,
+      skillResults: []
+    });
+    errors.push(...result.errors);
+  }
+  for (const skillDir of skillDirs) {
+    const result = await validateSkillDirectory(skillDir, duplicateSkillNames);
+    skillResultsByDir.set(skillDir, result);
+    warnings.push(...result.warnings);
+    errors.push(...result.errors);
+  }
+  for (const pluginResult of pluginResults) {
+    pluginResult.skillResults = (pluginSkillDirs.get(pluginResult.pluginDir) ?? []).map((skillDir) => skillResultsByDir.get(skillDir)).filter((result) => Boolean(result));
+  }
+  const appSkillResults = appSkillDirs.map((skillDir) => skillResultsByDir.get(skillDir)).filter((result) => Boolean(result));
+  io.info(
+    `${color("Checking", ANSI.bold, ANSI.cyan)} ${color(
+      formatDisplayPath(resolvedRoot, resolvedRoot),
+      ANSI.dim
+    )}`
+  );
+  for (const pluginResult of pluginResults) {
+    reportPluginResult(pluginResult, io);
+  }
+  if (appSkillResults.length > 0) {
+    reportAppSkills(appSkillResults, io);
+  }
+  for (const warning of warnings) {
+    io.warn(`${statusIcon("warn")} warning: ${warning}`);
+  }
+  if (errors.length > 0) {
+    for (const error of errors) {
+      io.error(`${statusIcon("error")} error: ${error}`);
+    }
+    throw new Error(
+      `Validation failed (${errors.length} error${errors.length === 1 ? "" : "s"}, ${pluginDirs.length} plugin manifest${pluginDirs.length === 1 ? "" : "s"}, ${skillDirs.length} skill director${skillDirs.length === 1 ? "y" : "ies"} checked).`
+    );
+  }
+  io.info(
+    `${formatHeading("ok", `Validation passed (${pluginDirs.length} plugin manifest${pluginDirs.length === 1 ? "" : "s"}, ${skillDirs.length} skill director${skillDirs.length === 1 ? "y" : "ies"} checked).`)}`
+  );
+}
+export {
+  runCheck
+};

package/dist/cli/init.js

@@ -74,6 +74,13 @@ async function runInit(dir, log = console.log) {
 
 You are ${name}, a helpful assistant.
 `);
+  fs.writeFileSync(
+    path.join(dataDir, "ABOUT.md"),
+    `# About ${name}
+
+Describe what ${name} helps users do.
+`
+  );
   const skillsDir = path.join(target, "app", "skills");
   fs.mkdirSync(skillsDir, { recursive: true });
   fs.writeFileSync(path.join(skillsDir, ".gitkeep"), "");

package/dist/cli/run.d.ts

@@ -1,7 +1,8 @@
-declare const CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create";
+declare const CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]";
 interface CliHandlers {
     runInit: (dir: string) => Promise<void>;
     runSnapshotCreate: () => Promise<void>;
+    runCheck: (dir?: string) => Promise<void>;
 }
 interface CliIo {
     error: (line: string) => void;

package/dist/cli/run.js

@@ -1,5 +1,5 @@
 // src/cli/run.ts
-var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create";
+var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]";
 var DEFAULT_IO = {
   error: console.error
 };
@@ -21,6 +21,14 @@ async function runCli(argv, handlers, io = DEFAULT_IO) {
     await handlers.runSnapshotCreate();
     return 0;
   }
+  if (command === "check") {
+    if (rest.length > 0) {
+      io.error(CLI_USAGE);
+      return 1;
+    }
+    await handlers.runCheck(subcommand);
+    return 0;
+  }
   io.error(CLI_USAGE);
   return 1;
 }

package/dist/cli/snapshot-warmup.js

@@ -1,9 +1,13 @@
 import {
   disconnectStateAdapter,
+  getPluginProviders,
+  getPluginRuntimeDependencies,
+  getPluginRuntimePostinstall,
   resolveRuntimeDependencySnapshot
-} from "../chunk-OZFXD5IG.js";
-import "../chunk-PY4AI2GZ.js";
+} from "../chunk-5UJSQX4R.js";
 import "../chunk-Z5E25LRN.js";
+import "../chunk-PY4AI2GZ.js";
+import "../chunk-VW26MOSO.js";
 
 // src/cli/snapshot-warmup.ts
 var DEFAULT_RUNTIME = "node22";
@@ -23,10 +27,63 @@ function progressMessage(phase) {
   }
   return "Sandbox snapshot build complete.";
 }
+function formatList(values) {
+  return values.length > 0 ? values.join(", ") : "none";
+}
+function logSnapshotProfile(log) {
+  const providers = getPluginProviders();
+  const pluginNames = providers.map((plugin) => plugin.manifest.name).sort();
+  const snapshotPluginNames = providers.filter(
+    (plugin) => (plugin.manifest.runtimeDependencies?.length ?? 0) > 0 || (plugin.manifest.runtimePostinstall?.length ?? 0) > 0
+  ).map((plugin) => plugin.manifest.name).sort();
+  const systemDependencies = [];
+  const npmDependencies = [];
+  for (const dep of getPluginRuntimeDependencies()) {
+    if (dep.type === "npm") {
+      npmDependencies.push(`${dep.package}@${dep.version}`);
+      continue;
+    }
+    systemDependencies.push("package" in dep ? dep.package : dep.url);
+  }
+  const postinstallCommands = getPluginRuntimePostinstall().map(
+    ({ cmd, args }) => [cmd, ...args ?? []].filter((part) => part.trim().length > 0).join(" ")
+  );
+  log(`Loaded plugins (${pluginNames.length}): ${formatList(pluginNames)}`);
+  log(
+    "Sandbox snapshot inputs: " + [
+      `plugins=${snapshotPluginNames.length}`,
+      `system_dependencies=${systemDependencies.length}`,
+      `npm_dependencies=${npmDependencies.length}`,
+      `postinstall_commands=${postinstallCommands.length}`
+    ].join(" ")
+  );
+  if (snapshotPluginNames.length === 0 && systemDependencies.length === 0 && npmDependencies.length === 0 && postinstallCommands.length === 0) {
+    return;
+  }
+  log(
+    `Snapshot plugins (${snapshotPluginNames.length}): ${formatList(snapshotPluginNames)}`
+  );
+  if (systemDependencies.length > 0) {
+    log(
+      `System dependencies (${systemDependencies.length}): ${systemDependencies.join(", ")}`
+    );
+  }
+  if (npmDependencies.length > 0) {
+    log(
+      `NPM dependencies (${npmDependencies.length}): ${npmDependencies.join(", ")}`
+    );
+  }
+  if (postinstallCommands.length > 0) {
+    log(
+      `Runtime postinstall (${postinstallCommands.length}): ${postinstallCommands.join(", ")}`
+    );
+  }
+}
 async function runSnapshotCreate(log = console.log) {
   const runtime = DEFAULT_RUNTIME;
   const timeoutMs = DEFAULT_TIMEOUT_MS;
   try {
+    logSnapshotProfile(log);
     const emitted = /* @__PURE__ */ new Set();
     const snapshot = await resolveRuntimeDependencySnapshot({
       runtime,

package/dist/handlers/queue-callback.js

@@ -1,10 +1,12 @@
 import {
   POST
-} from "../chunk-DGKNXMK4.js";
-import "../chunk-RFUE5VBK.js";
-import "../chunk-OZFXD5IG.js";
-import "../chunk-PY4AI2GZ.js";
+} from "../chunk-VPCCZ3PK.js";
+import "../chunk-QNOV65P4.js";
+import "../chunk-KT5HARSN.js";
+import "../chunk-5UJSQX4R.js";
 import "../chunk-Z5E25LRN.js";
+import "../chunk-PY4AI2GZ.js";
+import "../chunk-VW26MOSO.js";
 export {
   POST
 };

package/dist/handlers/router.js

@@ -1,9 +1,9 @@
 import {
   POST as POST2
-} from "../chunk-TEQ3UIS7.js";
+} from "../chunk-EZ6WIJL2.js";
 import {
   POST
-} from "../chunk-DGKNXMK4.js";
+} from "../chunk-VPCCZ3PK.js";
 import {
   escapeXml,
   formatProviderLabel,
@@ -13,22 +13,24 @@ import {
   publishAppHomeView,
   resolveBaseUrl,
   truncateStatusText
-} from "../chunk-RFUE5VBK.js";
+} from "../chunk-QNOV65P4.js";
 import {
   GET
 } from "../chunk-4RBEYCOG.js";
+import "../chunk-KT5HARSN.js";
 import {
   botConfig,
   buildOAuthTokenRequest,
   getPluginOAuthConfig,
   getStateAdapter,
   parseOAuthTokenResponse
-} from "../chunk-OZFXD5IG.js";
+} from "../chunk-5UJSQX4R.js";
+import "../chunk-Z5E25LRN.js";
 import {
   logException,
   logInfo
 } from "../chunk-PY4AI2GZ.js";
-import "../chunk-Z5E25LRN.js";
+import "../chunk-VW26MOSO.js";
 
 // src/handlers/oauth-callback.ts
 import { after } from "next/server";

package/dist/handlers/webhooks.js

@@ -1,6 +1,6 @@
 import {
   POST
-} from "../chunk-TEQ3UIS7.js";
+} from "../chunk-EZ6WIJL2.js";
 import "../chunk-PY4AI2GZ.js";
 export {
   POST

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "private": false,
   "publishConfig": {
     "access": "public"