skill-universe 1.1.0

package/build/dev/javascript/skillc/skillc/types.mjs

@@ -0,0 +1,249 @@
+import * as $option from "../../gleam_stdlib/gleam/option.mjs";
+import { Ok, Error, CustomType as $CustomType } from "../gleam.mjs";
+import * as $semver from "../skillc/semver.mjs";
+import * as $version_constraint from "../skillc/version_constraint.mjs";
+
+export class OpenClaw extends $CustomType {}
+export const Provider$OpenClaw = () => new OpenClaw();
+export const Provider$isOpenClaw = (value) => value instanceof OpenClaw;
+
+export class ClaudeCode extends $CustomType {}
+export const Provider$ClaudeCode = () => new ClaudeCode();
+export const Provider$isClaudeCode = (value) => value instanceof ClaudeCode;
+
+export class Codex extends $CustomType {}
+export const Provider$Codex = () => new Codex();
+export const Provider$isCodex = (value) => value instanceof Codex;
+
+export class Required extends $CustomType {}
+export const ConfigRequirement$Required = () => new Required();
+export const ConfigRequirement$isRequired = (value) =>
+  value instanceof Required;
+
+export class Optional extends $CustomType {}
+export const ConfigRequirement$Optional = () => new Optional();
+export const ConfigRequirement$isOptional = (value) =>
+  value instanceof Optional;
+
+export class OptionalWithDefault extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const ConfigRequirement$OptionalWithDefault = ($0) =>
+  new OptionalWithDefault($0);
+export const ConfigRequirement$isOptionalWithDefault = (value) =>
+  value instanceof OptionalWithDefault;
+export const ConfigRequirement$OptionalWithDefault$0 = (value) => value[0];
+
+export class Skill extends $CustomType {
+  constructor(name, description, version, license, homepage, repository, metadata, dependencies, config) {
+    super();
+    this.name = name;
+    this.description = description;
+    this.version = version;
+    this.license = license;
+    this.homepage = homepage;
+    this.repository = repository;
+    this.metadata = metadata;
+    this.dependencies = dependencies;
+    this.config = config;
+  }
+}
+export const Skill$Skill = (name, description, version, license, homepage, repository, metadata, dependencies, config) =>
+  new Skill(name,
+  description,
+  version,
+  license,
+  homepage,
+  repository,
+  metadata,
+  dependencies,
+  config);
+export const Skill$isSkill = (value) => value instanceof Skill;
+export const Skill$Skill$name = (value) => value.name;
+export const Skill$Skill$0 = (value) => value.name;
+export const Skill$Skill$description = (value) => value.description;
+export const Skill$Skill$1 = (value) => value.description;
+export const Skill$Skill$version = (value) => value.version;
+export const Skill$Skill$2 = (value) => value.version;
+export const Skill$Skill$license = (value) => value.license;
+export const Skill$Skill$3 = (value) => value.license;
+export const Skill$Skill$homepage = (value) => value.homepage;
+export const Skill$Skill$4 = (value) => value.homepage;
+export const Skill$Skill$repository = (value) => value.repository;
+export const Skill$Skill$5 = (value) => value.repository;
+export const Skill$Skill$metadata = (value) => value.metadata;
+export const Skill$Skill$6 = (value) => value.metadata;
+export const Skill$Skill$dependencies = (value) => value.dependencies;
+export const Skill$Skill$7 = (value) => value.dependencies;
+export const Skill$Skill$config = (value) => value.config;
+export const Skill$Skill$8 = (value) => value.config;
+
+export class SkillMetadata extends $CustomType {
+  constructor(author, author_email, tags) {
+    super();
+    this.author = author;
+    this.author_email = author_email;
+    this.tags = tags;
+  }
+}
+export const SkillMetadata$SkillMetadata = (author, author_email, tags) =>
+  new SkillMetadata(author, author_email, tags);
+export const SkillMetadata$isSkillMetadata = (value) =>
+  value instanceof SkillMetadata;
+export const SkillMetadata$SkillMetadata$author = (value) => value.author;
+export const SkillMetadata$SkillMetadata$0 = (value) => value.author;
+export const SkillMetadata$SkillMetadata$author_email = (value) =>
+  value.author_email;
+export const SkillMetadata$SkillMetadata$1 = (value) => value.author_email;
+export const SkillMetadata$SkillMetadata$tags = (value) => value.tags;
+export const SkillMetadata$SkillMetadata$2 = (value) => value.tags;
+
+export class Dependency extends $CustomType {
+  constructor(name, version, optional) {
+    super();
+    this.name = name;
+    this.version = version;
+    this.optional = optional;
+  }
+}
+export const Dependency$Dependency = (name, version, optional) =>
+  new Dependency(name, version, optional);
+export const Dependency$isDependency = (value) => value instanceof Dependency;
+export const Dependency$Dependency$name = (value) => value.name;
+export const Dependency$Dependency$0 = (value) => value.name;
+export const Dependency$Dependency$version = (value) => value.version;
+export const Dependency$Dependency$1 = (value) => value.version;
+export const Dependency$Dependency$optional = (value) => value.optional;
+export const Dependency$Dependency$2 = (value) => value.optional;
+
+export class ConfigField extends $CustomType {
+  constructor(name, description, requirement, secret) {
+    super();
+    this.name = name;
+    this.description = description;
+    this.requirement = requirement;
+    this.secret = secret;
+  }
+}
+export const ConfigField$ConfigField = (name, description, requirement, secret) =>
+  new ConfigField(name, description, requirement, secret);
+export const ConfigField$isConfigField = (value) =>
+  value instanceof ConfigField;
+export const ConfigField$ConfigField$name = (value) => value.name;
+export const ConfigField$ConfigField$0 = (value) => value.name;
+export const ConfigField$ConfigField$description = (value) => value.description;
+export const ConfigField$ConfigField$1 = (value) => value.description;
+export const ConfigField$ConfigField$requirement = (value) => value.requirement;
+export const ConfigField$ConfigField$2 = (value) => value.requirement;
+export const ConfigField$ConfigField$secret = (value) => value.secret;
+export const ConfigField$ConfigField$3 = (value) => value.secret;
+
+export class FrontmatterInInstructions extends $CustomType {
+  constructor(file) {
+    super();
+    this.file = file;
+  }
+}
+export const CompileWarning$FrontmatterInInstructions = (file) =>
+  new FrontmatterInInstructions(file);
+export const CompileWarning$isFrontmatterInInstructions = (value) =>
+  value instanceof FrontmatterInInstructions;
+export const CompileWarning$FrontmatterInInstructions$file = (value) =>
+  value.file;
+export const CompileWarning$FrontmatterInInstructions$0 = (value) => value.file;
+
+export class MissingDependency extends $CustomType {
+  constructor(dependency) {
+    super();
+    this.dependency = dependency;
+  }
+}
+export const CompileWarning$MissingDependency = (dependency) =>
+  new MissingDependency(dependency);
+export const CompileWarning$isMissingDependency = (value) =>
+  value instanceof MissingDependency;
+export const CompileWarning$MissingDependency$dependency = (value) =>
+  value.dependency;
+export const CompileWarning$MissingDependency$0 = (value) => value.dependency;
+
+export class CompiledSkill extends $CustomType {
+  constructor(name, provider, skill_md, scripts, assets, warnings, codex_yaml) {
+    super();
+    this.name = name;
+    this.provider = provider;
+    this.skill_md = skill_md;
+    this.scripts = scripts;
+    this.assets = assets;
+    this.warnings = warnings;
+    this.codex_yaml = codex_yaml;
+  }
+}
+export const CompiledSkill$CompiledSkill = (name, provider, skill_md, scripts, assets, warnings, codex_yaml) =>
+  new CompiledSkill(name,
+  provider,
+  skill_md,
+  scripts,
+  assets,
+  warnings,
+  codex_yaml);
+export const CompiledSkill$isCompiledSkill = (value) =>
+  value instanceof CompiledSkill;
+export const CompiledSkill$CompiledSkill$name = (value) => value.name;
+export const CompiledSkill$CompiledSkill$0 = (value) => value.name;
+export const CompiledSkill$CompiledSkill$provider = (value) => value.provider;
+export const CompiledSkill$CompiledSkill$1 = (value) => value.provider;
+export const CompiledSkill$CompiledSkill$skill_md = (value) => value.skill_md;
+export const CompiledSkill$CompiledSkill$2 = (value) => value.skill_md;
+export const CompiledSkill$CompiledSkill$scripts = (value) => value.scripts;
+export const CompiledSkill$CompiledSkill$3 = (value) => value.scripts;
+export const CompiledSkill$CompiledSkill$assets = (value) => value.assets;
+export const CompiledSkill$CompiledSkill$4 = (value) => value.assets;
+export const CompiledSkill$CompiledSkill$warnings = (value) => value.warnings;
+export const CompiledSkill$CompiledSkill$5 = (value) => value.warnings;
+export const CompiledSkill$CompiledSkill$codex_yaml = (value) =>
+  value.codex_yaml;
+export const CompiledSkill$CompiledSkill$6 = (value) => value.codex_yaml;
+
+export class FileCopy extends $CustomType {
+  constructor(src, relative_path) {
+    super();
+    this.src = src;
+    this.relative_path = relative_path;
+  }
+}
+export const FileCopy$FileCopy = (src, relative_path) =>
+  new FileCopy(src, relative_path);
+export const FileCopy$isFileCopy = (value) => value instanceof FileCopy;
+export const FileCopy$FileCopy$src = (value) => value.src;
+export const FileCopy$FileCopy$0 = (value) => value.src;
+export const FileCopy$FileCopy$relative_path = (value) => value.relative_path;
+export const FileCopy$FileCopy$1 = (value) => value.relative_path;
+
+export function provider_from_string(s) {
+  if (s === "openclaw") {
+    return new Ok(new OpenClaw());
+  } else if (s === "claude-code") {
+    return new Ok(new ClaudeCode());
+  } else if (s === "codex") {
+    return new Ok(new Codex());
+  } else {
+    return new Error(undefined);
+  }
+}
+
+export function all_provider_names() {
+  return "openclaw, claude-code, codex";
+}
+
+export function provider_to_string(provider) {
+  if (provider instanceof OpenClaw) {
+    return "openclaw";
+  } else if (provider instanceof ClaudeCode) {
+    return "claude-code";
+  } else {
+    return "codex";
+  }
+}

package/build/dev/javascript/skillc/skillc/version_constraint.mjs

@@ -0,0 +1,290 @@
+import * as $order from "../../gleam_stdlib/gleam/order.mjs";
+import * as $result from "../../gleam_stdlib/gleam/result.mjs";
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import { Ok, Error, CustomType as $CustomType } from "../gleam.mjs";
+import * as $error from "../skillc/error.mjs";
+import { ValidationError } from "../skillc/error.mjs";
+import * as $semver from "../skillc/semver.mjs";
+
+class Caret extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+class Tilde extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+class Gte extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+class Lte extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+class Gt extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+class Lt extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+class Exact extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+
+class Wildcard extends $CustomType {}
+
+class VersionConstraint extends $CustomType {
+  constructor(op) {
+    super();
+    this.op = op;
+  }
+}
+
+/**
+ * The wildcard constraint, matching any version.
+ */
+export function wildcard() {
+  return new VersionConstraint(new Wildcard());
+}
+
+/**
+ * Convert back to the underlying string representation.
+ */
+export function to_string(vc) {
+  let $ = vc.op;
+  if ($ instanceof Caret) {
+    let v = $[0];
+    return "^" + $semver.to_string(v);
+  } else if ($ instanceof Tilde) {
+    let v = $[0];
+    return "~" + $semver.to_string(v);
+  } else if ($ instanceof Gte) {
+    let v = $[0];
+    return ">=" + $semver.to_string(v);
+  } else if ($ instanceof Lte) {
+    let v = $[0];
+    return "<=" + $semver.to_string(v);
+  } else if ($ instanceof Gt) {
+    let v = $[0];
+    return ">" + $semver.to_string(v);
+  } else if ($ instanceof Lt) {
+    let v = $[0];
+    return "<" + $semver.to_string(v);
+  } else if ($ instanceof Exact) {
+    let v = $[0];
+    return $semver.to_string(v);
+  } else {
+    return "*";
+  }
+}
+
+function satisfies_caret(version, constraint) {
+  let $ = $semver.compare(version, constraint);
+  if ($ instanceof $order.Lt) {
+    return false;
+  } else {
+    let _block;
+    let $1 = $semver.major(constraint);
+    if ($1 === 0) {
+      let $2 = $semver.minor(constraint);
+      if ($2 === 0) {
+        _block = $semver.new$(0, 0, $semver.patch(constraint) + 1);
+      } else {
+        let minor = $2;
+        _block = $semver.new$(0, minor + 1, 0);
+      }
+    } else {
+      let major = $1;
+      _block = $semver.new$(major + 1, 0, 0);
+    }
+    let upper = _block;
+    if (upper instanceof Ok) {
+      let upper_ver = upper[0];
+      return $semver.compare(version, upper_ver) instanceof $order.Lt;
+    } else {
+      return false;
+    }
+  }
+}
+
+function satisfies_tilde(version, constraint) {
+  let $ = $semver.compare(version, constraint);
+  if ($ instanceof $order.Lt) {
+    return false;
+  } else {
+    let $1 = $semver.new$(
+      $semver.major(constraint),
+      $semver.minor(constraint) + 1,
+      0,
+    );
+    if ($1 instanceof Ok) {
+      let upper = $1[0];
+      return $semver.compare(version, upper) instanceof $order.Lt;
+    } else {
+      return false;
+    }
+  }
+}
+
+/**
+ * Check if a version satisfies a constraint.
+ */
+export function satisfies(version, constraint) {
+  let $ = constraint.op;
+  if ($ instanceof Caret) {
+    let v = $[0];
+    return satisfies_caret(version, v);
+  } else if ($ instanceof Tilde) {
+    let v = $[0];
+    return satisfies_tilde(version, v);
+  } else if ($ instanceof Gte) {
+    let v = $[0];
+    return !($semver.compare(version, v) instanceof $order.Lt);
+  } else if ($ instanceof Lte) {
+    let v = $[0];
+    return !($semver.compare(version, v) instanceof $order.Gt);
+  } else if ($ instanceof Gt) {
+    let v = $[0];
+    return $semver.compare(version, v) instanceof $order.Gt;
+  } else if ($ instanceof Lt) {
+    let v = $[0];
+    return $semver.compare(version, v) instanceof $order.Lt;
+  } else if ($ instanceof Exact) {
+    let v = $[0];
+    return $semver.compare(version, v) instanceof $order.Eq;
+  } else {
+    return true;
+  }
+}
+
+function validate_has_version(rest, original, make_op) {
+  let version_part = $string.trim(rest);
+  let $ = $string.is_empty(version_part);
+  if ($) {
+    return new Error(
+      new ValidationError(
+        "version",
+        ("Invalid version constraint: operator without version in '" + original) + "'",
+      ),
+    );
+  } else {
+    return $result.try$(
+      (() => {
+        let _pipe = $semver.parse(version_part);
+        return $result.map_error(
+          _pipe,
+          (_) => {
+            return new ValidationError(
+              "version",
+              ("Invalid version in constraint: '" + original) + "'",
+            );
+          },
+        );
+      })(),
+      (ver) => { return new Ok(new VersionConstraint(make_op(ver))); },
+    );
+  }
+}
+
+function validate_bare_version(input) {
+  let $ = $semver.parse(input);
+  if ($ instanceof Ok) {
+    let ver = $[0];
+    return new Ok(new VersionConstraint(new Exact(ver)));
+  } else {
+    return new Error(
+      new ValidationError(
+        "version",
+        ("Invalid version constraint: '" + input) + "' (expected valid semver like 1.0.0)",
+      ),
+    );
+  }
+}
+
+function validate(input) {
+  if (input === "*") {
+    return new Ok(new VersionConstraint(new Wildcard()));
+  } else if (input.startsWith("^")) {
+    let rest = input.slice(1);
+    return validate_has_version(
+      rest,
+      input,
+      (var0) => { return new Caret(var0); },
+    );
+  } else if (input.startsWith("~")) {
+    let rest = input.slice(1);
+    return validate_has_version(
+      rest,
+      input,
+      (var0) => { return new Tilde(var0); },
+    );
+  } else if (input.startsWith(">=")) {
+    let rest = input.slice(2);
+    return validate_has_version(
+      rest,
+      input,
+      (var0) => { return new Gte(var0); },
+    );
+  } else if (input.startsWith("<=")) {
+    let rest = input.slice(2);
+    return validate_has_version(
+      rest,
+      input,
+      (var0) => { return new Lte(var0); },
+    );
+  } else if (input.startsWith(">")) {
+    let rest = input.slice(1);
+    return validate_has_version(rest, input, (var0) => { return new Gt(var0); });
+  } else if (input.startsWith("<")) {
+    let rest = input.slice(1);
+    return validate_has_version(rest, input, (var0) => { return new Lt(var0); });
+  } else if (input.startsWith("=")) {
+    let rest = input.slice(1);
+    return validate_has_version(
+      rest,
+      input,
+      (var0) => { return new Exact(var0); },
+    );
+  } else {
+    return validate_bare_version(input);
+  }
+}
+
+/**
+ * Parse a version constraint string. Empty/whitespace-only strings are
+ * normalized to the wildcard constraint "*". Returns an error if the
+ * constraint uses an unrecognized operator.
+ */
+export function parse(input) {
+  let trimmed = $string.trim(input);
+  let $ = $string.is_empty(trimmed);
+  if ($) {
+    return new Ok(new VersionConstraint(new Wildcard()));
+  } else {
+    return validate(trimmed);
+  }
+}

package/build/dev/javascript/skillc/skillc/yaml.mjs

@@ -0,0 +1,51 @@
+import * as $list from "../../gleam_stdlib/gleam/list.mjs";
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import { toList } from "../gleam.mjs";
+
+const special_chars = /* @__PURE__ */ toList([
+  ":",
+  "#",
+  " ",
+  "\"",
+  "'",
+  "[",
+  "]",
+  "{",
+  "}",
+  ",",
+  "&",
+  "*",
+  "!",
+  "|",
+  ">",
+  "%",
+  "@",
+  "\n",
+]);
+
+const reserved_words = /* @__PURE__ */ toList([
+  "true",
+  "false",
+  "yes",
+  "no",
+  "on",
+  "off",
+  "null",
+  "~",
+  "",
+]);
+
+export function quote_string(s) {
+  let needs_quoting = $list.any(
+    special_chars,
+    (c) => { return $string.contains(s, c); },
+  ) || $list.contains(reserved_words, s);
+  if (needs_quoting) {
+    let escaped = $string.replace(s, "\\", "\\\\");
+    let escaped$1 = $string.replace(escaped, "\"", "\\\"");
+    let escaped$2 = $string.replace(escaped$1, "\n", "\\n");
+    return ("\"" + escaped$2) + "\"";
+  } else {
+    return s;
+  }
+}