@sentry/junior 0.7.0 → 0.9.0

package/dist/{chunk-Z5E25LRN.js → chunk-KCLEEKYX.js}

@@ -1,5 +1,7 @@
-// src/chat/fs-utils.ts
-import { statSync } from "fs";
+// 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();
@@ -14,11 +16,6 @@ function isFile(targetPath) {
     return false;
   }
 }
-
-// src/chat/discovery-roots.ts
-import { readdirSync } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
 function normalizePath(targetPath) {
   return path.resolve(targetPath);
 }
@@ -95,11 +92,16 @@ function discoverNodeModulesDirs(cwd = process.cwd(), options) {
   ]);
 }
 function discoverProjectRoots(cwd = process.cwd(), options) {
-  const roots = discoverNodeModulesDirs(cwd, options?.nodeModulesDirs ? { candidateDirs: options.nodeModulesDirs } : void 0).map((nodeModulesDir) => path.dirname(nodeModulesDir));
+  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 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);
@@ -107,9 +109,9 @@ function listTopLevelPackages(nodeModulesDir) {
       if (!isDirectory(entryPath)) {
         continue;
       }
-      const scopedEntries = readdirSync(entryPath, { withFileTypes: true }).sort(
-        (left, right) => left.name.localeCompare(right.name)
-      );
+      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);
@@ -127,6 +129,107 @@ function listTopLevelPackages(nodeModulesDir) {
   }
   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
 import { readFileSync, readdirSync as readdirSync2 } from "fs";
@@ -380,7 +483,7 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
     configuredPackageNames
   );
   const manifestRoots = [];
-  const skillRoots = [];
+  const skillRoots2 = [];
   const tracingIncludes = [];
   for (const pkg of discoveredPackages) {
     const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(
@@ -400,7 +503,7 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
       }
     }
     if (pkg.hasSkillsDir) {
-      skillRoots.push(path2.join(pkg.dir, "skills"));
+      skillRoots2.push(path2.join(pkg.dir, "skills"));
       if (tracingBasePath) {
         tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
       }
@@ -421,7 +524,7 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
       }
     }
     if (isDirectory(path2.join(pluginDir, "skills"))) {
-      skillRoots.push(path2.join(pluginDir, "skills"));
+      skillRoots2.push(path2.join(pluginDir, "skills"));
       if (tracingBasePath) {
         tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
       }
@@ -432,7 +535,7 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
       discoveredPackages.map((pkg) => pkg.name)
     ),
     manifestRoots: uniqueStringsInOrder(manifestRoots),
-    skillRoots: uniqueStringsInOrder(skillRoots),
+    skillRoots: uniqueStringsInOrder(skillRoots2),
     tracingIncludes: uniqueStringsInOrder(tracingIncludes)
   };
 }
@@ -440,6 +543,10 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
 export {
   isDirectory,
   discoverNodeModulesDirs,
-  discoverProjectRoots,
+  homeDir,
+  skillRoots,
+  pluginRoots,
+  soulPathCandidates,
+  aboutPathCandidates,
   discoverInstalledPluginPackageContent
 };

package/dist/chunk-VM3CPAZF.js

@@ -0,0 +1,448 @@
+import {
+  getPluginCapabilityProviders,
+  getPluginForSkillPath,
+  getPluginSkillRoots
+} from "./chunk-ZBWWHP6Q.js";
+import {
+  skillRoots
+} from "./chunk-KCLEEKYX.js";
+import {
+  logInfo,
+  logWarn
+} from "./chunk-ZW4OVKF5.js";
+
+// src/chat/skills.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+import { parse as parseYaml } from "yaml";
+
+// src/chat/capabilities/catalog.ts
+function getCapabilityCatalog() {
+  const providers = getPluginCapabilityProviders();
+  const capabilityToProvider = /* @__PURE__ */ new Map();
+  const configKeys = /* @__PURE__ */ new Set();
+  for (const provider of providers) {
+    for (const capability of provider.capabilities) {
+      if (capabilityToProvider.has(capability)) {
+        throw new Error(
+          `Duplicate capability registration for "${capability}"`
+        );
+      }
+      capabilityToProvider.set(capability, provider);
+    }
+    for (const configKey of provider.configKeys) {
+      configKeys.add(configKey);
+    }
+  }
+  return {
+    providers,
+    capabilityToProvider,
+    configKeys
+  };
+}
+function getCapabilityProvider(capability) {
+  return getCapabilityCatalog().capabilityToProvider.get(capability);
+}
+function isKnownCapability(capability) {
+  return getCapabilityCatalog().capabilityToProvider.has(capability);
+}
+function isKnownConfigKey(key) {
+  return getCapabilityCatalog().configKeys.has(key);
+}
+function listCapabilityProviders() {
+  return getCapabilityCatalog().providers.map((provider) => ({
+    ...provider,
+    capabilities: [...provider.capabilities],
+    configKeys: [...provider.configKeys]
+  }));
+}
+var startupCatalogSignature = null;
+function logCapabilityCatalogLoadedOnce() {
+  const providers = listCapabilityProviders();
+  const signature = JSON.stringify(
+    providers.map((provider) => ({
+      provider: provider.provider,
+      capabilities: provider.capabilities,
+      configKeys: provider.configKeys,
+      target: provider.target
+    }))
+  );
+  if (startupCatalogSignature === signature) {
+    return;
+  }
+  startupCatalogSignature = signature;
+  const capabilityNames = providers.flatMap((provider) => provider.capabilities).sort();
+  const configKeys = [
+    ...new Set(providers.flatMap((provider) => provider.configKeys))
+  ].sort();
+  logInfo(
+    "capability_catalog_loaded",
+    {},
+    {
+      "app.capability.providers": providers.map(
+        (provider) => provider.provider
+      ),
+      "app.capability.count": capabilityNames.length,
+      "app.capability.names": capabilityNames,
+      "app.config.key_count": configKeys.length,
+      "app.config.keys": configKeys
+    },
+    "Loaded capability provider catalog"
+  );
+}
+
+// src/chat/skills.ts
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+var SKILL_NAME_RE = /^[a-z0-9-]+$/;
+var DOTTED_TOKEN_RE = /^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
+var MAX_NAME_LENGTH = 64;
+var MAX_DESCRIPTION_LENGTH = 1024;
+var MAX_COMPATIBILITY_LENGTH = 500;
+function hasAngleBrackets(value) {
+  return value.includes("<") || value.includes(">");
+}
+function validateSkillName(name) {
+  if (!name) return "name must not be empty";
+  if (name.length > MAX_NAME_LENGTH)
+    return `name must be <= ${MAX_NAME_LENGTH} characters`;
+  if (!SKILL_NAME_RE.test(name))
+    return "name must contain only lowercase letters, digits, and hyphens";
+  if (name.startsWith("-") || name.endsWith("-"))
+    return "name must not start or end with a hyphen";
+  if (name.includes("--")) return "name must not contain consecutive hyphens";
+  return null;
+}
+function createTokenFieldSchema(fieldName, example) {
+  return z.string({
+    error: `Frontmatter field "${fieldName}" must be a string when present`
+  }).superRefine((value, ctx) => {
+    const tokens = value.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
+    for (const token of tokens) {
+      if (!DOTTED_TOKEN_RE.test(token)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `${fieldName} token "${token}" is invalid; expected dotted lowercase tokens (for example "${example}")`
+        });
+        return;
+      }
+    }
+  });
+}
+function parseTokenList(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const tokens = value.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
+  return tokens.length > 0 ? tokens : void 0;
+}
+var skillFrontmatterSchema = z.object({
+  name: z.string({ error: 'Frontmatter field "name" must be a string' }).superRefine((value, ctx) => {
+    const nameError = validateSkillName(value);
+    if (nameError) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: nameError
+      });
+    }
+  }),
+  description: z.string({ error: 'Frontmatter field "description" must be a string' }).superRefine((value, ctx) => {
+    if (!value.trim()) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "description must not be empty"
+      });
+      return;
+    }
+    if (value.length > MAX_DESCRIPTION_LENGTH) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `description must be <= ${MAX_DESCRIPTION_LENGTH} characters`
+      });
+      return;
+    }
+    if (hasAngleBrackets(value)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'description must not contain "<" or ">"'
+      });
+    }
+  }),
+  metadata: z.record(z.string(), z.unknown(), {
+    error: 'Frontmatter field "metadata" must be an object when present'
+  }).optional(),
+  compatibility: z.string({
+    error: 'Frontmatter field "compatibility" must be a string when present'
+  }).superRefine((value, ctx) => {
+    if (value.length > MAX_COMPATIBILITY_LENGTH) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `compatibility must be <= ${MAX_COMPATIBILITY_LENGTH} characters`
+      });
+    }
+  }).optional(),
+  license: z.string({
+    error: 'Frontmatter field "license" must be a string when present'
+  }).optional(),
+  "allowed-tools": z.string({
+    error: 'Frontmatter field "allowed-tools" must be a string when present'
+  }).optional(),
+  "requires-capabilities": createTokenFieldSchema(
+    "requires-capabilities",
+    "github.issues.write"
+  ).optional(),
+  "uses-config": createTokenFieldSchema(
+    "uses-config",
+    "github.repo"
+  ).optional()
+}).passthrough();
+function stripFrontmatter(raw) {
+  return raw.replace(FRONTMATTER_RE, "").trim();
+}
+function parseSkillFile(raw, expectedName) {
+  const match = FRONTMATTER_RE.exec(raw);
+  if (!match) {
+    return { ok: false, error: "Missing YAML frontmatter at start of file" };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(match[1]);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Invalid YAML frontmatter: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ok: false, error: "Frontmatter must be a YAML object" };
+  }
+  const result = skillFrontmatterSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      ok: false,
+      error: result.error.issues[0]?.message ?? "Invalid YAML frontmatter"
+    };
+  }
+  if (expectedName && result.data.name !== expectedName) {
+    return {
+      ok: false,
+      error: `name "${result.data.name}" must match directory "${expectedName}"`
+    };
+  }
+  const allowedTools = parseTokenList(result.data["allowed-tools"]);
+  const requiresCapabilities = parseTokenList(
+    result.data["requires-capabilities"]
+  );
+  const usesConfig = parseTokenList(result.data["uses-config"]);
+  return {
+    ok: true,
+    skill: {
+      name: result.data.name,
+      description: result.data.description,
+      body: stripFrontmatter(raw),
+      ...result.data.metadata ? { metadata: result.data.metadata } : {},
+      ...result.data.compatibility !== void 0 ? { compatibility: result.data.compatibility } : {},
+      ...result.data.license !== void 0 ? { license: result.data.license } : {},
+      ...allowedTools ? { allowedTools } : {},
+      ...requiresCapabilities ? { requiresCapabilities } : {},
+      ...usesConfig ? { usesConfig } : {}
+    }
+  };
+}
+var SKILL_CACHE_TTL_MS = 5e3;
+var skillCache = null;
+function resolveSkillRoots(options) {
+  const additionalRoots = options?.additionalRoots ?? [];
+  const envRoots = process.env.SKILL_DIRS?.split(path.delimiter).filter(Boolean) ?? [];
+  const defaults = skillRoots();
+  const pluginRoots = getPluginSkillRoots();
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const root of [
+    ...additionalRoots,
+    ...envRoots,
+    ...defaults,
+    ...pluginRoots
+  ]) {
+    const normalized = path.resolve(root);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function validateSkillMetadata(input) {
+  const unknownCapabilities = (input.requiresCapabilities ?? []).filter(
+    (capability) => !isKnownCapability(capability)
+  );
+  if (unknownCapabilities.length > 0) {
+    return `Unknown requires-capabilities values: ${unknownCapabilities.join(", ")}`;
+  }
+  const unknownConfigKeys = (input.usesConfig ?? []).filter(
+    (configKey) => !isKnownConfigKey(configKey)
+  );
+  if (unknownConfigKeys.length > 0) {
+    return `Unknown uses-config values: ${unknownConfigKeys.join(", ")}`;
+  }
+  return void 0;
+}
+async function readSkillDirectory(skillDir) {
+  const skillFile = path.join(skillDir, "SKILL.md");
+  try {
+    const raw = await fs.readFile(skillFile, "utf8");
+    const parsed = parseSkillFile(raw, path.basename(skillDir));
+    if (!parsed.ok) {
+      logWarn(
+        "skill_frontmatter_invalid",
+        {},
+        {
+          "file.path": skillDir,
+          "error.message": parsed.error
+        },
+        "Invalid skill frontmatter"
+      );
+      return null;
+    }
+    const {
+      name,
+      description,
+      allowedTools,
+      requiresCapabilities,
+      usesConfig
+    } = parsed.skill;
+    const plugin = getPluginForSkillPath(skillDir);
+    const metadataError = validateSkillMetadata({
+      requiresCapabilities,
+      usesConfig
+    });
+    if (metadataError) {
+      logWarn(
+        "skill_frontmatter_invalid",
+        {},
+        {
+          "file.path": skillDir,
+          "error.message": metadataError
+        },
+        "Invalid skill frontmatter"
+      );
+      return null;
+    }
+    return {
+      name,
+      description,
+      skillPath: skillDir,
+      ...plugin ? { pluginProvider: plugin.manifest.name } : {},
+      allowedTools,
+      requiresCapabilities,
+      usesConfig
+    };
+  } catch (error) {
+    logWarn(
+      "skill_directory_read_failed",
+      {},
+      {
+        "file.path": skillDir,
+        "error.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to read skill directory"
+    );
+    return null;
+  }
+}
+async function discoverSkills(options) {
+  const roots = resolveSkillRoots(options);
+  const cacheKey = roots.join(path.delimiter);
+  if (skillCache && skillCache.expiresAt > Date.now() && skillCache.key === cacheKey) {
+    return skillCache.skills;
+  }
+  const discovered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    try {
+      const entries = await fs.readdir(root, { withFileTypes: true });
+      for (const entry of entries.sort(
+        (a, b) => a.name.localeCompare(b.name)
+      )) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        const skill = await readSkillDirectory(path.join(root, entry.name));
+        if (skill && !seen.has(skill.name)) {
+          seen.add(skill.name);
+          discovered.push(skill);
+        }
+      }
+    } catch (error) {
+      logWarn(
+        "skill_root_read_failed",
+        {},
+        {
+          "file.directory": root,
+          "error.message": error instanceof Error ? error.message : String(error)
+        },
+        "Failed to read skill root"
+      );
+    }
+  }
+  const sorted = discovered.sort((a, b) => a.name.localeCompare(b.name));
+  skillCache = {
+    expiresAt: Date.now() + SKILL_CACHE_TTL_MS,
+    key: cacheKey,
+    skills: sorted
+  };
+  return sorted;
+}
+function parseSkillInvocation(messageText, availableSkills) {
+  const trimmed = messageText.trim();
+  const match = /(?:^|\s)\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?/i.exec(
+    trimmed
+  );
+  if (!match) {
+    return null;
+  }
+  const skillName = match[1].toLowerCase();
+  if (!availableSkills.some((skill) => skill.name === skillName)) {
+    return null;
+  }
+  return {
+    skillName,
+    args: (match[2] ?? "").trim()
+  };
+}
+function findSkillByName(skillName, available) {
+  return available.find((skill) => skill.name === skillName) ?? null;
+}
+async function loadSkillsByName(skillNames, available) {
+  const selected = new Set(skillNames);
+  const skills = [];
+  for (const meta of available) {
+    if (!selected.has(meta.name)) {
+      continue;
+    }
+    const skillFile = path.join(meta.skillPath, "SKILL.md");
+    const raw = await fs.readFile(skillFile, "utf8");
+    const parsed = parseSkillFile(raw, meta.name);
+    if (!parsed.ok) {
+      throw new Error(`Invalid skill file in ${skillFile}: ${parsed.error}`);
+    }
+    skills.push({
+      ...meta,
+      body: parsed.skill.body
+    });
+  }
+  return skills;
+}
+
+export {
+  getCapabilityProvider,
+  listCapabilityProviders,
+  logCapabilityCatalogLoadedOnce,
+  stripFrontmatter,
+  parseSkillFile,
+  discoverSkills,
+  parseSkillInvocation,
+  findSkillByName,
+  loadSkillsByName
+};