@sentry/junior 0.5.0 → 0.6.0

package/dist/chunk-KT5HARSN.js

@@ -0,0 +1,164 @@
+// src/chat/skill-frontmatter.ts
+import { z } from "zod";
+import { parse as parseYaml } from "yaml";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+var SKILL_NAME_RE = /^[a-z0-9-]+$/;
+var CAPABILITY_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 (!CAPABILITY_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 } : {}
+    }
+  };
+}
+
+export {
+  stripFrontmatter,
+  parseSkillFile
+};