@sentry/junior 0.8.0 → 0.9.1

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
+};