nuxt-ai-ready 1.7.4 → 1.7.5

package/dist/chunks/agent-skills.mjs

@@ -0,0 +1,243 @@
+import { createHash } from 'node:crypto';
+import { realpath, readFile } from 'node:fs/promises';
+import { resolve, isAbsolute, relative, sep } from 'node:path';
+import { parseDocument } from 'yaml';
+import { A as AGENT_SKILLS_SCHEMA } from '../shared/nuxt-ai-ready.CDEc2X7T.mjs';
+import 'node:module';
+import '@nuxt/kit';
+import 'defu';
+import 'nuxt-site-config/kit';
+import 'nuxtseo-shared/kit';
+import 'pkg-types';
+import 'node:url';
+import '../../dist/runtime/server/utils/discovery-response.js';
+import 'pathe';
+import 'nuxtseo-shared/i18n';
+
+const namePattern = /^(?!.*--)[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+const digestPattern = /^sha256:[a-f0-9]{64}$/;
+const urlBase = "https://example.com/.well-known/agent-skills/index.json";
+function skillRoute(name) {
+  return `/.well-known/agent-skills/${name}/SKILL.md`;
+}
+function skillUrl(name) {
+  return `${name}/SKILL.md`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWithinDirectory(directory, file) {
+  const path = relative(directory, file);
+  return path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+function validateCommonFields(skill, index) {
+  const issues = [];
+  if (typeof skill.name !== "string" || !namePattern.test(skill.name)) {
+    issues.push({
+      index,
+      field: "name",
+      message: "must contain 1 to 64 lowercase alphanumeric or hyphen characters, without leading, trailing, or consecutive hyphens"
+    });
+  }
+  if (typeof skill.description !== "string" || skill.description.length === 0 || [...skill.description].length > 1024) {
+    issues.push({
+      index,
+      field: "description",
+      message: "must contain 1 to 1024 characters"
+    });
+  }
+  return issues;
+}
+function validateSkill(skill, index) {
+  if (!isRecord(skill)) {
+    return [{ index, field: "source", message: "must be a local or external skill entry" }];
+  }
+  const issues = validateCommonFields(skill, index);
+  if (skill.source === "local") {
+    if (typeof skill.file !== "string" || skill.file.trim().length === 0)
+      issues.push({ index, field: "file", message: "must be a non-empty path relative to the Nuxt root directory" });
+    return issues;
+  }
+  if (skill.source === "external") {
+    if (skill.type !== "skill-md" && skill.type !== "archive")
+      issues.push({ index, field: "type", message: 'must be "skill-md" or "archive"' });
+    if (typeof skill.url !== "string" || skill.url.trim().length === 0 || skill.url !== skill.url.trim() || !URL.canParse(skill.url, urlBase) || !["http:", "https:"].includes(new URL(skill.url, urlBase).protocol)) {
+      issues.push({ index, field: "url", message: "must be an HTTP(S), path-absolute, or relative URL" });
+    }
+    if (typeof skill.digest !== "string" || !digestPattern.test(skill.digest))
+      issues.push({ index, field: "digest", message: "must use the format sha256: followed by 64 lowercase hexadecimal characters" });
+    return issues;
+  }
+  issues.push({ index, field: "source", message: 'must be "local" or "external"' });
+  return issues;
+}
+function resolveExternalEntry(skill) {
+  return {
+    name: skill.name,
+    type: skill.type,
+    description: skill.description,
+    url: skill.url,
+    digest: skill.digest
+  };
+}
+function parseLocalSkillMetadata(content, skill, index) {
+  const match = content.match(/^\uFEFF?---[\t ]*\r?\n([\s\S]*?)\r?\n---[\t ]*(?:\r?\n|$)/);
+  if (!match?.[1]) {
+    return [{
+      index,
+      field: "file",
+      message: "must contain YAML frontmatter with name and description fields"
+    }];
+  }
+  const document = parseDocument(match[1], { prettyErrors: false });
+  if (document.errors.length > 0) {
+    return [{
+      index,
+      field: "file",
+      message: `contains invalid YAML frontmatter: ${document.errors[0]?.message || "unknown YAML error"}`
+    }];
+  }
+  const metadata = document.toJS();
+  if (!isRecord(metadata)) {
+    return [{
+      index,
+      field: "file",
+      message: "frontmatter must be a YAML mapping with name and description fields"
+    }];
+  }
+  const issues = [];
+  if (!content.slice(match[0].length).trim()) {
+    issues.push({
+      index,
+      field: "file",
+      message: "must contain Markdown instructions after its frontmatter"
+    });
+  }
+  if (metadata.name !== skill.name) {
+    issues.push({
+      index,
+      field: "name",
+      message: `must exactly match the local SKILL.md frontmatter name "${String(metadata.name)}"`
+    });
+  }
+  if (metadata.description !== skill.description) {
+    issues.push({
+      index,
+      field: "description",
+      message: "must exactly match the local SKILL.md frontmatter description"
+    });
+  }
+  return issues;
+}
+async function resolveLocalEntry(skill, index, rootDir) {
+  const file = resolve(rootDir, skill.file);
+  if (isAbsolute(skill.file) || !isWithinDirectory(rootDir, file)) {
+    return {
+      _tag: "Invalid",
+      issues: [{
+        index,
+        field: "file",
+        message: "must resolve within the Nuxt root directory"
+      }]
+    };
+  }
+  return Promise.all([realpath(rootDir), realpath(file)]).then(([realRootDir, realFile]) => {
+    if (!isWithinDirectory(realRootDir, realFile)) {
+      return {
+        _tag: "Invalid",
+        issues: [{
+          index,
+          field: "file",
+          message: "must resolve within the Nuxt root directory"
+        }]
+      };
+    }
+    return readFile(realFile).then((content) => {
+      const text = content.toString("utf8");
+      if (!Buffer.from(text, "utf8").equals(content)) {
+        return {
+          _tag: "Invalid",
+          issues: [{
+            index,
+            field: "file",
+            message: "must contain valid UTF-8 text"
+          }]
+        };
+      }
+      const metadataIssues = parseLocalSkillMetadata(text, skill, index);
+      if (metadataIssues.length > 0) {
+        return {
+          _tag: "Invalid",
+          issues: metadataIssues
+        };
+      }
+      const route = skillRoute(skill.name);
+      const digest = `sha256:${createHash("sha256").update(content).digest("hex")}`;
+      return {
+        _tag: "Resolved",
+        entry: {
+          name: skill.name,
+          type: "skill-md",
+          description: skill.description,
+          url: skillUrl(skill.name),
+          digest
+        },
+        route,
+        content: text
+      };
+    });
+  }).catch((error) => ({
+    _tag: "Invalid",
+    issues: [{
+      index,
+      field: "file",
+      message: `could not read ${file}: ${error instanceof Error ? error.message : String(error)}`
+    }]
+  }));
+}
+async function resolveAgentSkillsConfig(config, rootDir) {
+  if (config === false || config === void 0)
+    return { _tag: "Disabled" };
+  if (!isRecord(config) || !Array.isArray(config.skills)) {
+    return {
+      _tag: "Invalid",
+      issues: [{ field: "agentSkills", message: "must contain a skills array" }]
+    };
+  }
+  const issues = config.skills.flatMap((skill, index) => validateSkill(skill, index));
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const [index, skill] of config.skills.entries()) {
+    if (!isRecord(skill) || typeof skill.name !== "string" || seenNames.has(skill.name)) {
+      if (isRecord(skill) && typeof skill.name === "string" && seenNames.has(skill.name))
+        issues.push({ index, field: "name", message: `duplicates the skill name "${skill.name}"` });
+      continue;
+    }
+    seenNames.add(skill.name);
+  }
+  if (issues.length > 0)
+    return { _tag: "Invalid", issues };
+  const skills = config.skills;
+  const resolved = await Promise.all(skills.map((skill, index) => skill.source === "local" ? resolveLocalEntry(skill, index, rootDir) : Promise.resolve({ _tag: "Resolved", entry: resolveExternalEntry(skill) })));
+  const fileIssues = resolved.flatMap((result) => result._tag === "Invalid" ? result.issues : []);
+  if (fileIssues.length > 0)
+    return { _tag: "Invalid", issues: fileIssues };
+  const entries = [];
+  const localArtifacts = {};
+  for (const result of resolved) {
+    if (result._tag !== "Resolved")
+      continue;
+    entries.push(result.entry);
+    if ("route" in result)
+      localArtifacts[result.route] = result.content;
+  }
+  return {
+    _tag: "Enabled",
+    index: {
+      $schema: AGENT_SKILLS_SCHEMA,
+      skills: entries
+    },
+    localArtifacts
+  };
+}
+
+export { AGENT_SKILLS_SCHEMA, resolveAgentSkillsConfig };