skill-universe 1.1.0

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

@@ -0,0 +1,1601 @@
+import * as $option from "../gleam_stdlib/gleam/option.mjs";
+import { None, Some } from "../gleam_stdlib/gleam/option.mjs";
+import * as $order from "../gleam_stdlib/gleam/order.mjs";
+import * as $string from "../gleam_stdlib/gleam/string.mjs";
+import * as $should from "../gleeunit/gleeunit/should.mjs";
+import * as $simplifile from "../simplifile/simplifile.mjs";
+import { Ok, Error, toList, Empty as $Empty, makeError } from "./gleam.mjs";
+import * as $error from "./skillc/error.mjs";
+import * as $parser from "./skillc/parser.mjs";
+import * as $semver from "./skillc/semver.mjs";
+import * as $types from "./skillc/types.mjs";
+import * as $version_constraint from "./skillc/version_constraint.mjs";
+
+const FILEPATH = "test/parser_test.gleam";
+
+export function parse_empty_yaml_fails_test() {
+  let result = $parser.parse_skill_yaml("");
+  return $should.be_error(result);
+}
+
+export function valid_semver_test() {
+  $should.be_ok($semver.parse("1.0.0"));
+  $should.be_ok($semver.parse("0.1.0"));
+  return $should.be_ok($semver.parse("10.20.30"));
+}
+
+export function valid_semver_prerelease_test() {
+  $should.be_ok($semver.parse("1.0.0-alpha"));
+  return $should.be_ok($semver.parse("1.0.0-beta.1"));
+}
+
+export function valid_semver_build_metadata_test() {
+  $should.be_ok($semver.parse("1.0.0+build"));
+  return $should.be_ok($semver.parse("1.0.0+build.123"));
+}
+
+export function valid_semver_build_metadata_with_dashes_test() {
+  $should.be_ok($semver.parse("1.0.0+build-123"));
+  return $should.be_ok($semver.parse("1.0.0+20130313144700-abc"));
+}
+
+export function valid_semver_prerelease_and_build_test() {
+  $should.be_ok($semver.parse("1.0.0-alpha+build"));
+  return $should.be_ok($semver.parse("1.0.0-rc.1+build-456"));
+}
+
+export function invalid_semver_format_test() {
+  $should.be_error($semver.parse("not-a-version"));
+  $should.be_error($semver.parse("1.0"));
+  $should.be_error($semver.parse("1"));
+  return $should.be_error($semver.parse(""));
+}
+
+export function invalid_semver_error_message_test() {
+  let $ = $semver.parse("bad");
+  let field;
+  let msg;
+  if ($ instanceof Error) {
+    let $1 = $[0];
+    if ($1 instanceof $error.ValidationError) {
+      field = $1.field;
+      msg = $1.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        174,
+        "invalid_semver_error_message_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $,
+          start: 5717,
+          end: 5790,
+          pattern_start: 5728,
+          pattern_end: 5768
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      174,
+      "invalid_semver_error_message_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5717,
+        end: 5790,
+        pattern_start: 5728,
+        pattern_end: 5768
+      }
+    )
+  }
+  $should.equal(field, "version");
+  $should.be_true($string.contains(msg, "Invalid semver"));
+  return $should.be_true($string.contains(msg, "bad"));
+}
+
+export function error_to_string_parse_error_test() {
+  let err = new $error.ParseError("skill.yaml", "unexpected token");
+  let s = $error.to_string(err);
+  $should.be_true($string.contains(s, "skill.yaml"));
+  return $should.be_true($string.contains(s, "unexpected token"));
+}
+
+export function error_to_string_validation_error_test() {
+  let err = new $error.ValidationError("version", "Invalid semver format: bad");
+  let s = $error.to_string(err);
+  $should.be_true($string.contains(s, "version"));
+  return $should.be_true($string.contains(s, "Invalid semver"));
+}
+
+export function error_to_string_template_error_test() {
+  let err = new $error.TemplateError(42, "Unclosed block");
+  let s = $error.to_string(err);
+  $should.be_true($string.contains(s, "42"));
+  return $should.be_true($string.contains(s, "Unclosed block"));
+}
+
+export function parse_invalid_provider_metadata_fails_test() {
+  let result = $parser.parse_metadata_yaml(
+    "{{invalid: yaml: [",
+    new $types.OpenClaw(),
+  );
+  $should.be_error(result);
+  let file;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ParseError) {
+      file = $.file;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        230,
+        "parse_invalid_provider_metadata_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 7841,
+          end: 7896,
+          pattern_start: 7852,
+          pattern_end: 7887
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      230,
+      "parse_invalid_provider_metadata_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 7841,
+        end: 7896,
+        pattern_start: 7852,
+        pattern_end: 7887
+      }
+    )
+  }
+  return $should.equal(file, "providers/openclaw/metadata.yaml");
+}
+
+export function has_frontmatter_false_for_empty_test() {
+  return $should.be_false($parser.has_frontmatter(""));
+}
+
+export function dependency_default_version_star_test() {
+  let yaml = "name: dep-test\ndescription: Test\nversion: 1.0.0\ndependencies:\n  - name: no-version-dep\n";
+  let $ = $parser.parse_skill_yaml(yaml);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      316,
+      "dependency_default_version_star_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 10172,
+        end: 10224,
+        pattern_start: 10183,
+        pattern_end: 10192
+      }
+    )
+  }
+  let $1 = skill.dependencies;
+  let dep;
+  if ($1 instanceof $Empty) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      317,
+      "dependency_default_version_star_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 10227,
+        end: 10264,
+        pattern_start: 10238,
+        pattern_end: 10243
+      }
+    )
+  } else {
+    let $2 = $1.tail;
+    if ($2 instanceof $Empty) {
+      dep = $1.head;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        317,
+        "dependency_default_version_star_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $1,
+          start: 10227,
+          end: 10264,
+          pattern_start: 10238,
+          pattern_end: 10243
+        }
+      )
+    }
+  }
+  return $should.equal(dep.version, $version_constraint.wildcard());
+}
+
+export function config_field_without_name_skipped_test() {
+  let yaml = "name: config-test\ndescription: Test\nversion: 1.0.0\nconfig:\n  - description: missing name field\n    required: true\n  - name: valid_field\n    description: has a name\n";
+  let $ = $parser.parse_skill_yaml(yaml);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      336,
+      "config_field_without_name_skipped_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 10754,
+        end: 10806,
+        pattern_start: 10765,
+        pattern_end: 10774
+      }
+    )
+  }
+  return $should.equal(
+    skill.config,
+    toList([
+      new $types.ConfigField(
+        "valid_field",
+        "has a name",
+        new $types.Optional(),
+        false,
+      ),
+    ]),
+  );
+}
+
+export function config_field_all_properties_test() {
+  let yaml = "name: config-test\ndescription: Test\nversion: 1.0.0\nconfig:\n  - name: api_key\n    description: API key\n    required: true\n    secret: true\n  - name: cache_ttl\n    description: Cache TTL\n    required: false\n    default: \"300\"\n";
+  let $ = $parser.parse_skill_yaml(yaml);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      363,
+      "config_field_all_properties_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 11326,
+        end: 11378,
+        pattern_start: 11337,
+        pattern_end: 11346
+      }
+    )
+  }
+  let $1 = skill.config;
+  let first;
+  let second;
+  if ($1 instanceof $Empty) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      364,
+      "config_field_all_properties_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 11381,
+        end: 11422,
+        pattern_start: 11392,
+        pattern_end: 11407
+      }
+    )
+  } else {
+    let $2 = $1.tail;
+    if ($2 instanceof $Empty) {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        364,
+        "config_field_all_properties_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $1,
+          start: 11381,
+          end: 11422,
+          pattern_start: 11392,
+          pattern_end: 11407
+        }
+      )
+    } else {
+      let $3 = $2.tail;
+      if ($3 instanceof $Empty) {
+        first = $1.head;
+        second = $2.head;
+      } else {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "parser_test",
+          364,
+          "config_field_all_properties_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: $1,
+            start: 11381,
+            end: 11422,
+            pattern_start: 11392,
+            pattern_end: 11407
+          }
+        )
+      }
+    }
+  }
+  $should.equal(first.name, "api_key");
+  $should.equal(first.requirement, new $types.Required());
+  $should.equal(first.secret, true);
+  $should.equal(second.name, "cache_ttl");
+  $should.equal(second.requirement, new $types.OptionalWithDefault("300"));
+  return $should.equal(second.secret, false);
+}
+
+export function error_to_string_provider_error_test() {
+  let err = new $error.ProviderError("my-provider", "not supported");
+  let s = $error.to_string(err);
+  $should.be_true($string.contains(s, "my-provider"));
+  return $should.be_true($string.contains(s, "not supported"));
+}
+
+export function error_to_string_file_error_test() {
+  let err = new $error.FileError("/some/path.yaml", new $simplifile.Enoent());
+  let s = $error.to_string(err);
+  return $should.be_true($string.contains(s, "/some/path.yaml"));
+}
+
+export function semver_leading_zeros_rejected_test() {
+  $should.be_error($semver.parse("01.0.0"));
+  $should.be_error($semver.parse("1.01.0"));
+  return $should.be_error($semver.parse("1.0.01"));
+}
+
+export function semver_empty_prerelease_rejected_test() {
+  return $should.be_error($semver.parse("1.0.0-"));
+}
+
+export function semver_empty_build_metadata_rejected_test() {
+  return $should.be_error($semver.parse("1.0.0+"));
+}
+
+export function has_frontmatter_with_leading_whitespace_test() {
+  $should.be_true($parser.has_frontmatter("  ---\ntitle: Test\n---"));
+  $should.be_true($parser.has_frontmatter("\n---\ntitle: Test\n---"));
+  return $should.be_true($parser.has_frontmatter(" \n ---\ntitle: Test\n---"));
+}
+
+export function has_frontmatter_with_dashes_only_no_newline_test() {
+  return $should.be_true($parser.has_frontmatter("---"));
+}
+
+export function empty_skill_name_rejected_test() {
+  let yaml = "name: \"\"\ndescription: Test\nversion: 1.0.0\n";
+  let result = $parser.parse_skill_yaml(yaml);
+  $should.be_error(result);
+  let field;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      field = $.field;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        434,
+        "empty_skill_name_rejected_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 13891,
+          end: 13951,
+          pattern_start: 13902,
+          pattern_end: 13942
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      434,
+      "empty_skill_name_rejected_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 13891,
+        end: 13951,
+        pattern_start: 13902,
+        pattern_end: 13942
+      }
+    )
+  }
+  $should.equal(field, "name");
+  return $should.be_true($string.contains(msg, "must not be empty"));
+}
+
+export function whitespace_only_skill_name_rejected_test() {
+  let yaml = "name: \"  \"\ndescription: Test\nversion: 1.0.0\n";
+  let result = $parser.parse_skill_yaml(yaml);
+  $should.be_error(result);
+  let field;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      field = $.field;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        447,
+        "whitespace_only_skill_name_rejected_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 14236,
+          end: 14297,
+          pattern_start: 14247,
+          pattern_end: 14288
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      447,
+      "whitespace_only_skill_name_rejected_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 14236,
+        end: 14297,
+        pattern_start: 14247,
+        pattern_end: 14288
+      }
+    )
+  }
+  return $should.equal(field, "name");
+}
+
+export function empty_description_rejected_test() {
+  let yaml = "name: test\ndescription: \"\"\nversion: 1.0.0\n";
+  let result = $parser.parse_skill_yaml(yaml);
+  $should.be_error(result);
+  let field;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      field = $.field;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        459,
+        "empty_description_rejected_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 14511,
+          end: 14571,
+          pattern_start: 14522,
+          pattern_end: 14562
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      459,
+      "empty_description_rejected_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 14511,
+        end: 14571,
+        pattern_start: 14522,
+        pattern_end: 14562
+      }
+    )
+  }
+  $should.equal(field, "description");
+  return $should.be_true($string.contains(msg, "must not be empty"));
+}
+
+export function empty_license_normalized_to_none_test() {
+  let yaml = "name: test\ndescription: A test\nversion: 1.0.0\nlicense: \"\"\n";
+  let $ = $parser.parse_skill_yaml(yaml);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      471,
+      "empty_license_normalized_to_none_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 14803,
+        end: 14855,
+        pattern_start: 14814,
+        pattern_end: 14823
+      }
+    )
+  }
+  return $should.equal(skill.license, new None());
+}
+
+export function empty_homepage_normalized_to_none_test() {
+  let yaml = "name: test\ndescription: A test\nversion: 1.0.0\nhomepage: \"\"\n";
+  let $ = $parser.parse_skill_yaml(yaml);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      482,
+      "empty_homepage_normalized_to_none_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 15028,
+        end: 15080,
+        pattern_start: 15039,
+        pattern_end: 15048
+      }
+    )
+  }
+  return $should.equal(skill.homepage, new None());
+}
+
+export function empty_repository_normalized_to_none_test() {
+  let yaml = "name: test\ndescription: A test\nversion: 1.0.0\nrepository: \"\"\n";
+  let $ = $parser.parse_skill_yaml(yaml);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      493,
+      "empty_repository_normalized_to_none_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 15258,
+        end: 15310,
+        pattern_start: 15269,
+        pattern_end: 15278
+      }
+    )
+  }
+  return $should.equal(skill.repository, new None());
+}
+
+export function duplicate_dependency_names_rejected_test() {
+  let yaml = "name: test\ndescription: A test\nversion: 1.0.0\ndependencies:\n  - name: my-dep\n    version: ^1.0.0\n  - name: my-dep\n    version: ^2.0.0\n";
+  let result = $parser.parse_skill_yaml(yaml);
+  $should.be_error(result);
+  let field;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      field = $.field;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        510,
+        "duplicate_dependency_names_rejected_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 15632,
+          end: 15692,
+          pattern_start: 15643,
+          pattern_end: 15683
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      510,
+      "duplicate_dependency_names_rejected_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 15632,
+        end: 15692,
+        pattern_start: 15643,
+        pattern_end: 15683
+      }
+    )
+  }
+  $should.equal(field, "dependencies");
+  $should.be_true($string.contains(msg, "Duplicate dependency"));
+  return $should.be_true($string.contains(msg, "my-dep"));
+}
+
+export function duplicate_config_field_names_rejected_test() {
+  let yaml = "name: test\ndescription: A test\nversion: 1.0.0\nconfig:\n  - name: api_key\n    description: First\n  - name: api_key\n    description: Second\n";
+  let result = $parser.parse_skill_yaml(yaml);
+  $should.be_error(result);
+  let field;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      field = $.field;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        529,
+        "duplicate_config_field_names_rejected_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 16130,
+          end: 16190,
+          pattern_start: 16141,
+          pattern_end: 16181
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      529,
+      "duplicate_config_field_names_rejected_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 16130,
+        end: 16190,
+        pattern_start: 16141,
+        pattern_end: 16181
+      }
+    )
+  }
+  $should.equal(field, "config");
+  $should.be_true($string.contains(msg, "Duplicate config field"));
+  return $should.be_true($string.contains(msg, "api_key"));
+}
+
+export function self_dependency_rejected_test() {
+  let yaml = "name: my-skill\ndescription: A skill\nversion: 1.0.0\ndependencies:\n  - name: my-skill\n    version: ^1.0.0\n";
+  let result = $parser.parse_skill_yaml(yaml);
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      let $1 = $.field;
+      if ($1 === "dependencies") {
+        msg = $.message;
+      } else {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "parser_test",
+          544,
+          "self_dependency_rejected_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: result,
+            start: 16781,
+            end: 16850,
+            pattern_start: 16792,
+            pattern_end: 16841
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        544,
+        "self_dependency_rejected_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 16781,
+          end: 16850,
+          pattern_start: 16792,
+          pattern_end: 16841
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      544,
+      "self_dependency_rejected_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 16781,
+        end: 16850,
+        pattern_start: 16792,
+        pattern_end: 16841
+      }
+    )
+  }
+  $should.be_true($string.contains(msg, "depend on itself"));
+  return $should.be_true($string.contains(msg, "my-skill"));
+}
+
+export function non_self_dependency_passes_test() {
+  let yaml = "name: my-skill\ndescription: A skill\nversion: 1.0.0\ndependencies:\n  - name: other-skill\n    version: ^1.0.0\n";
+  let result = $parser.parse_skill_yaml(yaml);
+  return $should.be_ok(result);
+}
+
+export function semver_compare_lt_test() {
+  let $ = $semver.parse("1.0.0");
+  let a;
+  if ($ instanceof Ok) {
+    a = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      561,
+      "semver_compare_lt_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 17450,
+        end: 17490,
+        pattern_start: 17461,
+        pattern_end: 17466
+      }
+    )
+  }
+  let $1 = $semver.parse("2.0.0");
+  let b;
+  if ($1 instanceof Ok) {
+    b = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      562,
+      "semver_compare_lt_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 17493,
+        end: 17533,
+        pattern_start: 17504,
+        pattern_end: 17509
+      }
+    )
+  }
+  return $should.equal($semver.compare(a, b), new $order.Lt());
+}
+
+export function semver_compare_eq_test() {
+  let $ = $semver.parse("1.0.0");
+  let a;
+  if ($ instanceof Ok) {
+    a = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      567,
+      "semver_compare_eq_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 17620,
+        end: 17660,
+        pattern_start: 17631,
+        pattern_end: 17636
+      }
+    )
+  }
+  let $1 = $semver.parse("1.0.0");
+  let b;
+  if ($1 instanceof Ok) {
+    b = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      568,
+      "semver_compare_eq_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 17663,
+        end: 17703,
+        pattern_start: 17674,
+        pattern_end: 17679
+      }
+    )
+  }
+  return $should.equal($semver.compare(a, b), new $order.Eq());
+}
+
+export function semver_compare_prerelease_lt_release_test() {
+  let $ = $semver.parse("1.0.0-alpha");
+  let a;
+  if ($ instanceof Ok) {
+    a = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      573,
+      "semver_compare_prerelease_lt_release_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 17809,
+        end: 17855,
+        pattern_start: 17820,
+        pattern_end: 17825
+      }
+    )
+  }
+  let $1 = $semver.parse("1.0.0");
+  let b;
+  if ($1 instanceof Ok) {
+    b = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      574,
+      "semver_compare_prerelease_lt_release_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 17858,
+        end: 17898,
+        pattern_start: 17869,
+        pattern_end: 17874
+      }
+    )
+  }
+  return $should.equal($semver.compare(a, b), new $order.Lt());
+}
+
+export function semver_major_accessor_test() {
+  let $ = $semver.parse("3.2.1");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      579,
+      "semver_major_accessor_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 17989,
+        end: 18029,
+        pattern_start: 18000,
+        pattern_end: 18005
+      }
+    )
+  }
+  return $should.equal($semver.major(v), 3);
+}
+
+export function semver_minor_accessor_test() {
+  let $ = $semver.parse("3.2.1");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      584,
+      "semver_minor_accessor_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 18108,
+        end: 18148,
+        pattern_start: 18119,
+        pattern_end: 18124
+      }
+    )
+  }
+  return $should.equal($semver.minor(v), 2);
+}
+
+export function semver_patch_accessor_test() {
+  let $ = $semver.parse("3.2.1");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      589,
+      "semver_patch_accessor_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 18227,
+        end: 18267,
+        pattern_start: 18238,
+        pattern_end: 18243
+      }
+    )
+  }
+  return $should.equal($semver.patch(v), 1);
+}
+
+export function semver_negative_version_rejected_test() {
+  return $should.be_error($semver.parse("-1.0.0"));
+}
+
+export function error_to_string_registry_error_test() {
+  let err = new $error.RegistryError("connection failed");
+  let s = $error.to_string(err);
+  $should.be_true($string.contains(s, "Registry"));
+  return $should.be_true($string.contains(s, "connection failed"));
+}
+
+export function error_to_string_import_error_test() {
+  let err = new $error.ImportError("SKILL.md", "missing frontmatter");
+  let s = $error.to_string(err);
+  $should.be_true($string.contains(s, "SKILL.md"));
+  return $should.be_true($string.contains(s, "missing frontmatter"));
+}
+
+function read_fixture(path) {
+  let full_path = "test/fixtures/" + path;
+  let $ = $simplifile.read(full_path);
+  let content;
+  if ($ instanceof Ok) {
+    content = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      621,
+      "read_fixture",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 19374,
+        end: 19425,
+        pattern_start: 19385,
+        pattern_end: 19396
+      }
+    )
+  }
+  return content;
+}
+
+export function parse_valid_skill_yaml_test() {
+  let content = read_fixture("valid-skill/skill.yaml");
+  let result = $parser.parse_skill_yaml(content);
+  let skill;
+  if (result instanceof Ok) {
+    skill = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      19,
+      "parse_valid_skill_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 562,
+        end: 591,
+        pattern_start: 573,
+        pattern_end: 582
+      }
+    )
+  }
+  $should.equal(skill.name, "test-skill");
+  $should.equal(skill.description, "A test skill for validation");
+  $should.equal($semver.to_string(skill.version), "1.2.3");
+  $should.equal(skill.license, new Some("MIT"));
+  $should.equal(skill.homepage, new Some("https://example.com/test-skill"));
+  return $should.equal(
+    skill.repository,
+    new Some("https://github.com/example/test-skill"),
+  );
+}
+
+export function parse_valid_skill_yaml_metadata_test() {
+  let content = read_fixture("valid-skill/skill.yaml");
+  let $ = $parser.parse_skill_yaml(content);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      30,
+      "parse_valid_skill_yaml_metadata_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1057,
+        end: 1112,
+        pattern_start: 1068,
+        pattern_end: 1077
+      }
+    )
+  }
+  let $1 = skill.metadata;
+  let metadata;
+  if ($1 instanceof Some) {
+    metadata = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      31,
+      "parse_valid_skill_yaml_metadata_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 1115,
+        end: 1157,
+        pattern_start: 1126,
+        pattern_end: 1140
+      }
+    )
+  }
+  $should.equal(metadata.author, new Some("Test Author"));
+  $should.equal(metadata.author_email, new Some("test@example.com"));
+  return $should.equal(metadata.tags, toList(["test", "example", "demo"]));
+}
+
+export function parse_valid_skill_yaml_config_test() {
+  let content = read_fixture("valid-skill/skill.yaml");
+  let $ = $parser.parse_skill_yaml(content);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      56,
+      "parse_valid_skill_yaml_config_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1892,
+        end: 1947,
+        pattern_start: 1903,
+        pattern_end: 1912
+      }
+    )
+  }
+  return $should.equal(
+    skill.config,
+    toList([
+      new $types.ConfigField(
+        "api_key",
+        "API key for authentication",
+        new $types.Required(),
+        true,
+      ),
+      new $types.ConfigField(
+        "timeout",
+        "Request timeout in seconds",
+        new $types.OptionalWithDefault("30"),
+        false,
+      ),
+    ]),
+  );
+}
+
+export function parse_minimal_skill_yaml_test() {
+  let content = read_fixture("minimal-skill/skill.yaml");
+  let $ = $parser.parse_skill_yaml(content);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      75,
+      "parse_minimal_skill_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2419,
+        end: 2474,
+        pattern_start: 2430,
+        pattern_end: 2439
+      }
+    )
+  }
+  $should.equal(skill.name, "minimal");
+  $should.equal(skill.description, "A minimal skill");
+  $should.equal($semver.to_string(skill.version), "0.1.0");
+  $should.equal(skill.license, new None());
+  $should.equal(skill.homepage, new None());
+  $should.equal(skill.repository, new None());
+  $should.equal(skill.metadata, new None());
+  $should.equal(skill.dependencies, toList([]));
+  return $should.equal(skill.config, toList([]));
+}
+
+export function parse_invalid_yaml_fails_test() {
+  let content = read_fixture("invalid-yaml/skill.yaml");
+  let result = $parser.parse_skill_yaml(content);
+  $should.be_error(result);
+  let file;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ParseError) {
+      file = $.file;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        91,
+        "parse_invalid_yaml_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 3020,
+          end: 3075,
+          pattern_start: 3031,
+          pattern_end: 3066
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      91,
+      "parse_invalid_yaml_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 3020,
+        end: 3075,
+        pattern_start: 3031,
+        pattern_end: 3066
+      }
+    )
+  }
+  return $should.equal(file, "skill.yaml");
+}
+
+export function parse_missing_name_fails_test() {
+  let content = read_fixture("missing-name/skill.yaml");
+  let result = $parser.parse_skill_yaml(content);
+  $should.be_error(result);
+  let field;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      field = $.field;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        99,
+        "parse_missing_name_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 3287,
+          end: 3347,
+          pattern_start: 3298,
+          pattern_end: 3338
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      99,
+      "parse_missing_name_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 3287,
+        end: 3347,
+        pattern_start: 3298,
+        pattern_end: 3338
+      }
+    )
+  }
+  $should.equal(field, "name");
+  return $should.be_true($string.contains(msg, "name"));
+}
+
+export function parse_missing_description_fails_test() {
+  let content = read_fixture("missing-description/skill.yaml");
+  let result = $parser.parse_skill_yaml(content);
+  $should.be_error(result);
+  let field;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      field = $.field;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        108,
+        "parse_missing_description_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 3615,
+          end: 3675,
+          pattern_start: 3626,
+          pattern_end: 3666
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      108,
+      "parse_missing_description_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 3615,
+        end: 3675,
+        pattern_start: 3626,
+        pattern_end: 3666
+      }
+    )
+  }
+  $should.equal(field, "description");
+  return $should.be_true($string.contains(msg, "description"));
+}
+
+export function parse_missing_version_fails_test() {
+  let content = read_fixture("missing-version/skill.yaml");
+  let result = $parser.parse_skill_yaml(content);
+  $should.be_error(result);
+  let field;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      field = $.field;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        117,
+        "parse_missing_version_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 3949,
+          end: 4009,
+          pattern_start: 3960,
+          pattern_end: 4000
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      117,
+      "parse_missing_version_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 3949,
+        end: 4009,
+        pattern_start: 3960,
+        pattern_end: 4000
+      }
+    )
+  }
+  $should.equal(field, "version");
+  return $should.be_true($string.contains(msg, "version"));
+}
+
+export function invalid_semver_test() {
+  let content = read_fixture("bad-version/skill.yaml");
+  let result = $parser.parse_skill_yaml(content);
+  $should.be_error(result);
+  let field;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ValidationError) {
+      field = $.field;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "parser_test",
+        162,
+        "invalid_semver_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 5370,
+          end: 5431,
+          pattern_start: 5381,
+          pattern_end: 5422
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      162,
+      "invalid_semver_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 5370,
+        end: 5431,
+        pattern_start: 5381,
+        pattern_end: 5422
+      }
+    )
+  }
+  return $should.equal(field, "version");
+}
+
+export function parse_openclaw_metadata_test() {
+  let content = read_fixture("valid-skill/providers/openclaw/metadata.yaml");
+  let result = $parser.parse_metadata_yaml(content, new $types.OpenClaw());
+  return $should.be_ok(result);
+}
+
+export function parse_claude_code_metadata_test() {
+  let content = read_fixture("valid-skill/providers/claude-code/metadata.yaml");
+  let result = $parser.parse_metadata_yaml(content, new $types.ClaudeCode());
+  return $should.be_ok(result);
+}
+
+export function parse_codex_metadata_test() {
+  let content = read_fixture("valid-skill/providers/codex/metadata.yaml");
+  let result = $parser.parse_metadata_yaml(content, new $types.Codex());
+  return $should.be_ok(result);
+}
+
+export function has_frontmatter_detects_yaml_frontmatter_test() {
+  let content = read_fixture("frontmatter-instructions/INSTRUCTIONS.md");
+  return $should.be_true($parser.has_frontmatter(content));
+}
+
+export function has_frontmatter_false_for_normal_markdown_test() {
+  let content = read_fixture("valid-skill/INSTRUCTIONS.md");
+  return $should.be_false($parser.has_frontmatter(content));
+}
+
+function assert_parse_vc(input) {
+  let $ = $version_constraint.parse(input);
+  let vc;
+  if ($ instanceof Ok) {
+    vc = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      626,
+      "assert_parse_vc",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 19517,
+        end: 19568,
+        pattern_start: 19528,
+        pattern_end: 19534
+      }
+    )
+  }
+  return vc;
+}
+
+export function parse_valid_skill_yaml_dependencies_test() {
+  let content = read_fixture("valid-skill/skill.yaml");
+  let $ = $parser.parse_skill_yaml(content);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      39,
+      "parse_valid_skill_yaml_dependencies_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1446,
+        end: 1501,
+        pattern_start: 1457,
+        pattern_end: 1466
+      }
+    )
+  }
+  return $should.equal(
+    skill.dependencies,
+    toList([
+      new $types.Dependency("helper-skill", assert_parse_vc("^1.0.0"), false),
+      new $types.Dependency("extra-skill", assert_parse_vc("~2.1.0"), true),
+    ]),
+  );
+}
+
+export function dependency_with_name_and_version_test() {
+  let yaml = "name: dep-test\ndescription: Test\nversion: 1.0.0\ndependencies:\n  - name: my-dep\n    version: ^1.0.0\n  - name: optional-dep\n    version: ~2.0.0\n    optional: true\n";
+  let $ = $parser.parse_skill_yaml(yaml);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      250,
+      "dependency_with_name_and_version_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 8372,
+        end: 8424,
+        pattern_start: 8383,
+        pattern_end: 8392
+      }
+    )
+  }
+  return $should.equal(
+    skill.dependencies,
+    toList([
+      new $types.Dependency("my-dep", assert_parse_vc("^1.0.0"), false),
+      new $types.Dependency("optional-dep", assert_parse_vc("~2.0.0"), true),
+    ]),
+  );
+}
+
+export function dependency_without_name_skipped_test() {
+  let yaml = "name: dep-test\ndescription: Test\nversion: 1.0.0\ndependencies:\n  - version: ^1.0.0\n  - name: valid-dep\n    version: ~2.0.0\n";
+  let $ = $parser.parse_skill_yaml(yaml);
+  let skill;
+  if ($ instanceof Ok) {
+    skill = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "parser_test",
+      297,
+      "dependency_without_name_skipped_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 9741,
+        end: 9793,
+        pattern_start: 9752,
+        pattern_end: 9761
+      }
+    )
+  }
+  return $should.equal(
+    skill.dependencies,
+    toList([
+      new $types.Dependency("valid-dep", assert_parse_vc("~2.0.0"), false),
+    ]),
+  );
+}