skill-universe 1.1.0

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

@@ -0,0 +1,1643 @@
+import * as $list from "../gleam_stdlib/gleam/list.mjs";
+import * as $option from "../gleam_stdlib/gleam/option.mjs";
+import { None, Some } from "../gleam_stdlib/gleam/option.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, makeError } from "./gleam.mjs";
+import * as $compiler from "./skillc/compiler.mjs";
+import * as $error from "./skillc/error.mjs";
+import * as $importer from "./skillc/importer.mjs";
+import { FrontmatterPair, SourceDirectory } from "./skillc/importer.mjs";
+import * as $semver from "./skillc/semver.mjs";
+import * as $types from "./skillc/types.mjs";
+
+const FILEPATH = "test/importer_test.gleam";
+
+export function parse_frontmatter_openclaw_test() {
+  let content = "---\nname: test\ndescription: \"A test\"\nversion: 1.0.0\nmetadata.openclaw:\n  emoji: rocket\n---\n\nBody here.";
+  let $ = $importer.parse_frontmatter(content);
+  let frontmatter;
+  if ($ instanceof Ok) {
+    frontmatter = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      19,
+      "parse_frontmatter_openclaw_test",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $, start: 623, end: 687, pattern_start: 634, pattern_end: 649 }
+    )
+  }
+  let keys = $list.map(frontmatter.pairs, (p) => { return p.key; });
+  $should.be_true($list.contains(keys, "name"));
+  $should.be_true($list.contains(keys, "metadata.openclaw"));
+  return $should.be_true($string.contains(frontmatter.body, "Body here."));
+}
+
+export function parse_frontmatter_claude_code_test() {
+  let content = "---\nname: test\ndescription: \"A test\"\nversion: 1.0.0\nuser-invocable: true\n---\n\nBody.";
+  let $ = $importer.parse_frontmatter(content);
+  let frontmatter;
+  if ($ instanceof Ok) {
+    frontmatter = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      29,
+      "parse_frontmatter_claude_code_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1083,
+        end: 1147,
+        pattern_start: 1094,
+        pattern_end: 1109
+      }
+    )
+  }
+  let keys = $list.map(frontmatter.pairs, (p) => { return p.key; });
+  $should.be_true($list.contains(keys, "user-invocable"));
+  return $should.be_true($string.contains(frontmatter.body, "Body."));
+}
+
+export function parse_frontmatter_codex_test() {
+  let content = "---\nname: test\nversion: 1.0.0\n---\n\nCodex body.";
+  let $ = $importer.parse_frontmatter(content);
+  let frontmatter;
+  if ($ instanceof Ok) {
+    frontmatter = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      37,
+      "parse_frontmatter_codex_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1438,
+        end: 1502,
+        pattern_start: 1449,
+        pattern_end: 1464
+      }
+    )
+  }
+  $should.equal($list.length(frontmatter.pairs), 2);
+  return $should.be_true($string.contains(frontmatter.body, "Codex body."));
+}
+
+export function parse_frontmatter_missing_error_test() {
+  let content = "# No frontmatter\n\nJust body.";
+  let result = $importer.parse_frontmatter(content);
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ImportError) {
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        46,
+        "parse_frontmatter_missing_error_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 1799,
+          end: 1851,
+          pattern_start: 1810,
+          pattern_end: 1842
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      46,
+      "parse_frontmatter_missing_error_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 1799,
+        end: 1851,
+        pattern_start: 1810,
+        pattern_end: 1842
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "No YAML frontmatter"));
+}
+
+export function parse_frontmatter_unclosed_error_test() {
+  let content = "---\nname: test\nversion: 1.0.0\n\nNo closing fence.";
+  let result = $importer.parse_frontmatter(content);
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ImportError) {
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        54,
+        "parse_frontmatter_unclosed_error_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 2116,
+          end: 2168,
+          pattern_start: 2127,
+          pattern_end: 2159
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      54,
+      "parse_frontmatter_unclosed_error_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 2116,
+        end: 2168,
+        pattern_start: 2127,
+        pattern_end: 2159
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "Unclosed"));
+}
+
+export function detect_provider_openclaw_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("metadata.openclaw", "  emoji: rocket"),
+  ]);
+  let $ = $importer.detect_provider(pairs, "/tmp/nonexistent");
+  let provider;
+  if ($ instanceof Ok) {
+    provider = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      67,
+      "detect_provider_openclaw_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2600,
+        end: 2677,
+        pattern_start: 2611,
+        pattern_end: 2623
+      }
+    )
+  }
+  return $should.equal(provider, new $types.OpenClaw());
+}
+
+export function detect_provider_claude_code_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("user-invocable", "true"),
+    new FrontmatterPair("allowed-tools", "[Read, Grep]"),
+  ]);
+  let $ = $importer.detect_provider(pairs, "/tmp/nonexistent");
+  let provider;
+  if ($ instanceof Ok) {
+    provider = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      77,
+      "detect_provider_claude_code_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2962,
+        end: 3039,
+        pattern_start: 2973,
+        pattern_end: 2985
+      }
+    )
+  }
+  return $should.equal(provider, new $types.ClaudeCode());
+}
+
+export function detect_provider_codex_from_directory_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("version", "1.0.0"),
+  ]);
+  let $ = $importer.detect_provider(pairs, "test/fixtures/import-codex");
+  let provider;
+  if ($ instanceof Ok) {
+    provider = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      86,
+      "detect_provider_codex_from_directory_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3263,
+        end: 3354,
+        pattern_start: 3274,
+        pattern_end: 3286
+      }
+    )
+  }
+  return $should.equal(provider, new $types.Codex());
+}
+
+export function detect_provider_ambiguous_error_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("version", "1.0.0"),
+  ]);
+  let result = $importer.detect_provider(pairs, "/tmp/nonexistent");
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ImportError) {
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        98,
+        "detect_provider_ambiguous_error_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 3661,
+          end: 3713,
+          pattern_start: 3672,
+          pattern_end: 3704
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      98,
+      "detect_provider_ambiguous_error_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 3661,
+        end: 3713,
+        pattern_start: 3672,
+        pattern_end: 3704
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "Cannot auto-detect"));
+}
+
+export function separate_fields_openclaw_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("description", "\"A test\""),
+    new FrontmatterPair("version", "1.0.0"),
+    new FrontmatterPair("license", "MIT"),
+    new FrontmatterPair(
+      "metadata.openclaw",
+      "  emoji: rocket\n  category: devtools",
+    ),
+  ]);
+  let $ = $importer.separate_fields(pairs, new $types.OpenClaw());
+  let separated;
+  if ($ instanceof Ok) {
+    separated = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      117,
+      "separate_fields_openclaw_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4355,
+        end: 4433,
+        pattern_start: 4366,
+        pattern_end: 4379
+      }
+    )
+  }
+  $should.equal(separated.universal.name, "test");
+  $should.equal(separated.universal.description, "A test");
+  $should.equal($semver.to_string(separated.universal.version), "1.0.0");
+  $should.equal(separated.universal.license, new Some("MIT"));
+  let provider_keys = $list.map(separated.provider, (p) => { return p.key; });
+  $should.be_true($list.contains(provider_keys, "emoji"));
+  return $should.be_true($list.contains(provider_keys, "category"));
+}
+
+export function separate_fields_claude_code_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("description", "\"A test\""),
+    new FrontmatterPair("version", "1.0.0"),
+    new FrontmatterPair("user-invocable", "true"),
+    new FrontmatterPair("allowed-tools", "[Read, Grep]"),
+  ]);
+  let $ = $importer.separate_fields(pairs, new $types.ClaudeCode());
+  let separated;
+  if ($ instanceof Ok) {
+    separated = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      136,
+      "separate_fields_claude_code_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5210,
+        end: 5290,
+        pattern_start: 5221,
+        pattern_end: 5234
+      }
+    )
+  }
+  $should.equal(separated.universal.name, "test");
+  $should.equal(separated.universal.license, new None());
+  let provider_keys = $list.map(separated.provider, (p) => { return p.key; });
+  $should.be_true($list.contains(provider_keys, "user-invocable"));
+  $should.be_true($list.contains(provider_keys, "allowed-tools"));
+  return $should.be_false($list.contains(provider_keys, "name"));
+}
+
+export function separate_fields_universal_extracted_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "my-skill"),
+    new FrontmatterPair("description", "Desc"),
+    new FrontmatterPair("version", "3.0.0"),
+  ]);
+  let $ = $importer.separate_fields(pairs, new $types.Codex());
+  let separated;
+  if ($ instanceof Ok) {
+    separated = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      152,
+      "separate_fields_universal_extracted_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5882,
+        end: 5957,
+        pattern_start: 5893,
+        pattern_end: 5906
+      }
+    )
+  }
+  $should.equal(separated.universal.name, "my-skill");
+  $should.equal(separated.universal.description, "Desc");
+  $should.equal($semver.to_string(separated.universal.version), "3.0.0");
+  return $should.equal(separated.provider, toList([]));
+}
+
+export function separate_fields_missing_name_error_test() {
+  let pairs = toList([
+    new FrontmatterPair("description", "Desc"),
+    new FrontmatterPair("version", "1.0.0"),
+  ]);
+  let result = $importer.separate_fields(pairs, new $types.Codex());
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ImportError) {
+      let $1 = $.source;
+      if ($1 === "name") {
+        msg = $.message;
+      } else {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "importer_test",
+          167,
+          "separate_fields_missing_name_error_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: result,
+            start: 6448,
+            end: 6505,
+            pattern_start: 6459,
+            pattern_end: 6496
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        167,
+        "separate_fields_missing_name_error_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 6448,
+          end: 6505,
+          pattern_start: 6459,
+          pattern_end: 6496
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      167,
+      "separate_fields_missing_name_error_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 6448,
+        end: 6505,
+        pattern_start: 6459,
+        pattern_end: 6496
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "missing"));
+}
+
+export function separate_fields_missing_description_error_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("version", "1.0.0"),
+  ]);
+  let result = $importer.separate_fields(pairs, new $types.Codex());
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ImportError) {
+      let $1 = $.source;
+      if ($1 === "description") {
+        msg = $.message;
+      } else {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "importer_test",
+          178,
+          "separate_fields_missing_description_error_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: result,
+            start: 6827,
+            end: 6891,
+            pattern_start: 6838,
+            pattern_end: 6882
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        178,
+        "separate_fields_missing_description_error_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 6827,
+          end: 6891,
+          pattern_start: 6838,
+          pattern_end: 6882
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      178,
+      "separate_fields_missing_description_error_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 6827,
+        end: 6891,
+        pattern_start: 6838,
+        pattern_end: 6882
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "missing"));
+}
+
+export function separate_fields_missing_version_error_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("description", "Desc"),
+  ]);
+  let result = $importer.separate_fields(pairs, new $types.Codex());
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ImportError) {
+      let $1 = $.source;
+      if ($1 === "version") {
+        msg = $.message;
+      } else {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "importer_test",
+          189,
+          "separate_fields_missing_version_error_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: result,
+            start: 7212,
+            end: 7272,
+            pattern_start: 7223,
+            pattern_end: 7263
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        189,
+        "separate_fields_missing_version_error_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 7212,
+          end: 7272,
+          pattern_start: 7223,
+          pattern_end: 7263
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      189,
+      "separate_fields_missing_version_error_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 7212,
+        end: 7272,
+        pattern_start: 7223,
+        pattern_end: 7263
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "missing"));
+}
+
+export function separate_fields_invalid_version_error_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("description", "Desc"),
+    new FrontmatterPair("version", "banana"),
+  ]);
+  let result = $importer.separate_fields(pairs, new $types.Codex());
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ImportError) {
+      let $1 = $.source;
+      if ($1 === "version") {
+        msg = $.message;
+      } else {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "importer_test",
+          201,
+          "separate_fields_invalid_version_error_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: result,
+            start: 7647,
+            end: 7707,
+            pattern_start: 7658,
+            pattern_end: 7698
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        201,
+        "separate_fields_invalid_version_error_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 7647,
+          end: 7707,
+          pattern_start: 7658,
+          pattern_end: 7698
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      201,
+      "separate_fields_invalid_version_error_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 7647,
+        end: 7707,
+        pattern_start: 7658,
+        pattern_end: 7698
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "Invalid version"));
+}
+
+export function generate_skill_yaml_format_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test-skill"),
+    new FrontmatterPair("description", "\"A test skill\""),
+    new FrontmatterPair("version", "1.0.0"),
+    new FrontmatterPair("license", "MIT"),
+  ]);
+  let $ = $importer.separate_fields(pairs, new $types.OpenClaw());
+  let separated;
+  if ($ instanceof Ok) {
+    separated = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      216,
+      "generate_skill_yaml_format_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 8245,
+        end: 8323,
+        pattern_start: 8256,
+        pattern_end: 8269
+      }
+    )
+  }
+  let yaml = $importer.generate_skill_yaml(separated.universal);
+  $should.be_true($string.contains(yaml, "name: test-skill"));
+  $should.be_true($string.contains(yaml, "description: \"A test skill\""));
+  $should.be_true($string.contains(yaml, "version: 1.0.0"));
+  return $should.be_true($string.contains(yaml, "license: MIT"));
+}
+
+export function generate_skill_yaml_no_license_test() {
+  let pairs = toList([
+    new FrontmatterPair("name", "test"),
+    new FrontmatterPair("description", "Desc"),
+    new FrontmatterPair("version", "1.0.0"),
+  ]);
+  let $ = $importer.separate_fields(pairs, new $types.Codex());
+  let separated;
+  if ($ instanceof Ok) {
+    separated = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      231,
+      "generate_skill_yaml_no_license_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 8864,
+        end: 8939,
+        pattern_start: 8875,
+        pattern_end: 8888
+      }
+    )
+  }
+  let yaml = $importer.generate_skill_yaml(separated.universal);
+  return $should.be_false($string.contains(yaml, "license"));
+}
+
+export function generate_metadata_yaml_from_pairs_test() {
+  let pairs = toList([
+    new FrontmatterPair("user-invocable", "true"),
+    new FrontmatterPair("allowed-tools", "[Read, Grep]"),
+  ]);
+  let yaml = $importer.generate_metadata_yaml(pairs, new None());
+  $should.be_true($string.contains(yaml, "user-invocable: true"));
+  return $should.be_true($string.contains(yaml, "allowed-tools: [Read, Grep]"));
+}
+
+export function generate_metadata_yaml_codex_override_test() {
+  let codex_content = "interface:\n  display_name: Test\n";
+  let yaml = $importer.generate_metadata_yaml(
+    toList([]),
+    new Some(codex_content),
+  );
+  return $should.equal(yaml, codex_content);
+}
+
+export function fetch_source_local_directory_test() {
+  let $ = $importer.fetch_source("test/fixtures/import-openclaw");
+  let resolved;
+  if ($ instanceof Ok) {
+    resolved = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      259,
+      "fetch_source_local_directory_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 9908,
+        end: 9992,
+        pattern_start: 9919,
+        pattern_end: 9931
+      }
+    )
+  }
+  return $should.equal(
+    resolved,
+    new SourceDirectory("test/fixtures/import-openclaw"),
+  );
+}
+
+export function fetch_source_local_file_test() {
+  let $ = $importer.fetch_source("test/fixtures/import-openclaw/SKILL.md");
+  let resolved;
+  if ($ instanceof Ok) {
+    resolved = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      265,
+      "fetch_source_local_file_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 10113,
+        end: 10206,
+        pattern_start: 10124,
+        pattern_end: 10136
+      }
+    )
+  }
+  if (resolved instanceof $importer.SourceDirectory) {
+    return $should.fail();
+  } else {
+    let path = resolved.path;
+    let directory = resolved.directory;
+    $should.equal(path, "test/fixtures/import-openclaw/SKILL.md");
+    return $should.equal(directory, "test/fixtures/import-openclaw");
+  }
+}
+
+export function fetch_source_invalid_url_returns_error_test() {
+  let result = $importer.fetch_source(
+    "https://invalid.example.com/nonexistent/SKILL.md",
+  );
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ImportError) {
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        282,
+        "fetch_source_invalid_url_returns_error_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 10721,
+          end: 10773,
+          pattern_start: 10732,
+          pattern_end: 10764
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      282,
+      "fetch_source_invalid_url_returns_error_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 10721,
+        end: 10773,
+        pattern_start: 10732,
+        pattern_end: 10764
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "Failed to download"));
+}
+
+export function import_openclaw_fixture_test() {
+  let output_dir = "/tmp/skillc-test-import-oc";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $importer.import_skill(
+    "test/fixtures/import-openclaw",
+    new None(),
+    output_dir,
+  );
+  let result;
+  if ($1 instanceof Ok) {
+    result = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      294,
+      "import_openclaw_fixture_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 11169,
+        end: 11294,
+        pattern_start: 11180,
+        pattern_end: 11190
+      }
+    )
+  }
+  $should.equal(result.provider, new $types.OpenClaw());
+  $should.be_true(
+    $string.contains(result.skill_yaml, "name: my-imported-skill"),
+  );
+  $should.be_true($string.contains(result.skill_yaml, "version: 2.0.0"));
+  $should.be_true($string.contains(result.skill_yaml, "license: MIT"));
+  $should.be_true(
+    $string.contains(result.instructions_md, "# my-imported-skill"),
+  );
+  $should.be_true($string.contains(result.metadata_yaml, "emoji"));
+  let $2 = $simplifile.read(output_dir + "/skill.yaml");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      308,
+      "import_openclaw_fixture_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 11713,
+        end: 11776,
+        pattern_start: 11724,
+        pattern_end: 11729
+      }
+    )
+  }
+  let $3 = $simplifile.read(output_dir + "/INSTRUCTIONS.md");
+  if (!($3 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      309,
+      "import_openclaw_fixture_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 11779,
+        end: 11847,
+        pattern_start: 11790,
+        pattern_end: 11795
+      }
+    )
+  }
+  let $4 = $simplifile.read(output_dir + "/providers/openclaw/metadata.yaml");
+  if (!($4 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      310,
+      "import_openclaw_fixture_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $4,
+        start: 11850,
+        end: 11939,
+        pattern_start: 11861,
+        pattern_end: 11866
+      }
+    )
+  }
+  let $5 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function import_claude_code_fixture_test() {
+  let output_dir = "/tmp/skillc-test-import-cc";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $importer.import_skill(
+    "test/fixtures/import-claude-code",
+    new None(),
+    output_dir,
+  );
+  let result;
+  if ($1 instanceof Ok) {
+    result = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      321,
+      "import_claude_code_fixture_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 12124,
+        end: 12252,
+        pattern_start: 12135,
+        pattern_end: 12145
+      }
+    )
+  }
+  $should.equal(result.provider, new $types.ClaudeCode());
+  $should.be_true(
+    $string.contains(result.skill_yaml, "name: my-imported-skill"),
+  );
+  $should.be_true(
+    $string.contains(result.instructions_md, "# my-imported-skill"),
+  );
+  $should.be_true($string.contains(result.metadata_yaml, "user-invocable"));
+  $should.be_true($string.contains(result.metadata_yaml, "allowed-tools"));
+  let $2 = $simplifile.read(output_dir + "/providers/claude-code/metadata.yaml");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      334,
+      "import_claude_code_fixture_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 12615,
+        end: 12707,
+        pattern_start: 12626,
+        pattern_end: 12631
+      }
+    )
+  }
+  let $3 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function import_codex_fixture_test() {
+  let output_dir = "/tmp/skillc-test-import-cdx";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $importer.import_skill(
+    "test/fixtures/import-codex",
+    new None(),
+    output_dir,
+  );
+  let result;
+  if ($1 instanceof Ok) {
+    result = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      345,
+      "import_codex_fixture_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 12887,
+        end: 13009,
+        pattern_start: 12898,
+        pattern_end: 12908
+      }
+    )
+  }
+  $should.equal(result.provider, new $types.Codex());
+  $should.be_true(
+    $string.contains(result.skill_yaml, "name: my-imported-skill"),
+  );
+  $should.be_true(
+    $string.contains(result.instructions_md, "# my-imported-skill"),
+  );
+  $should.be_true($string.contains(result.metadata_yaml, "interface"));
+  $should.be_true($string.contains(result.metadata_yaml, "display_name"));
+  let $2 = $simplifile.read(output_dir + "/providers/codex/metadata.yaml");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      358,
+      "import_codex_fixture_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 13361,
+        end: 13447,
+        pattern_start: 13372,
+        pattern_end: 13377
+      }
+    )
+  }
+  let $3 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function roundtrip_openclaw_test() {
+  let compile_dir = "/tmp/skillc-roundtrip-compile-oc";
+  let import_dir = "/tmp/skillc-roundtrip-import-oc";
+  let $ = $simplifile.delete$(compile_dir);
+  
+  let $1 = $simplifile.delete$(import_dir);
+  
+  let $2 = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($2 instanceof Ok) {
+    compiled = $2[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      375,
+      "roundtrip_openclaw_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 13909,
+        end: 13996,
+        pattern_start: 13920,
+        pattern_end: 13932
+      }
+    )
+  }
+  let $3 = $compiler.emit(compiled, compile_dir, "test-skill");
+  if (!($3 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      377,
+      "roundtrip_openclaw_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 13999,
+        end: 14068,
+        pattern_start: 14010,
+        pattern_end: 14015
+      }
+    )
+  }
+  let compiled_skill_dir = compile_dir + "/openclaw/test-skill";
+  let $4 = $importer.import_skill(compiled_skill_dir, new None(), import_dir);
+  let result;
+  if ($4 instanceof Ok) {
+    result = $4[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      380,
+      "roundtrip_openclaw_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $4,
+        start: 14137,
+        end: 14224,
+        pattern_start: 14148,
+        pattern_end: 14158
+      }
+    )
+  }
+  $should.equal(result.provider, new $types.OpenClaw());
+  $should.be_true($string.contains(result.skill_yaml, "name: test-skill"));
+  $should.be_true($string.contains(result.skill_yaml, "version: 1.2.3"));
+  $should.be_true($string.contains(result.metadata_yaml, "emoji"));
+  let $5 = $simplifile.delete$(compile_dir);
+  
+  let $6 = $simplifile.delete$(import_dir);
+  
+  return undefined;
+}
+
+export function roundtrip_claude_code_test() {
+  let compile_dir = "/tmp/skillc-roundtrip-compile-cc";
+  let import_dir = "/tmp/skillc-roundtrip-import-cc";
+  let $ = $simplifile.delete$(compile_dir);
+  
+  let $1 = $simplifile.delete$(import_dir);
+  
+  let $2 = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($2 instanceof Ok) {
+    compiled = $2[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      399,
+      "roundtrip_claude_code_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 14804,
+        end: 14894,
+        pattern_start: 14815,
+        pattern_end: 14827
+      }
+    )
+  }
+  let $3 = $compiler.emit(compiled, compile_dir, "test-skill");
+  if (!($3 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      401,
+      "roundtrip_claude_code_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 14897,
+        end: 14966,
+        pattern_start: 14908,
+        pattern_end: 14913
+      }
+    )
+  }
+  let compiled_skill_dir = compile_dir + "/claude-code/test-skill";
+  let $4 = $importer.import_skill(compiled_skill_dir, new None(), import_dir);
+  let result;
+  if ($4 instanceof Ok) {
+    result = $4[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      404,
+      "roundtrip_claude_code_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $4,
+        start: 15038,
+        end: 15125,
+        pattern_start: 15049,
+        pattern_end: 15059
+      }
+    )
+  }
+  $should.equal(result.provider, new $types.ClaudeCode());
+  $should.be_true($string.contains(result.skill_yaml, "name: test-skill"));
+  $should.be_true($string.contains(result.skill_yaml, "version: 1.2.3"));
+  $should.be_true($string.contains(result.metadata_yaml, "user-invocable"));
+  let $5 = $simplifile.delete$(compile_dir);
+  
+  let $6 = $simplifile.delete$(import_dir);
+  
+  return undefined;
+}
+
+export function roundtrip_codex_test() {
+  let compile_dir = "/tmp/skillc-roundtrip-compile-cdx";
+  let import_dir = "/tmp/skillc-roundtrip-import-cdx";
+  let $ = $simplifile.delete$(compile_dir);
+  
+  let $1 = $simplifile.delete$(import_dir);
+  
+  let $2 = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($2 instanceof Ok) {
+    compiled = $2[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      423,
+      "roundtrip_codex_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 15712,
+        end: 15796,
+        pattern_start: 15723,
+        pattern_end: 15735
+      }
+    )
+  }
+  let $3 = $compiler.emit(compiled, compile_dir, "test-skill");
+  if (!($3 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      425,
+      "roundtrip_codex_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 15799,
+        end: 15868,
+        pattern_start: 15810,
+        pattern_end: 15815
+      }
+    )
+  }
+  let compiled_skill_dir = compile_dir + "/codex/.agents/skills/test-skill";
+  let $4 = $importer.import_skill(
+    compiled_skill_dir,
+    new Some(new $types.Codex()),
+    import_dir,
+  );
+  let result;
+  if ($4 instanceof Ok) {
+    result = $4[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      429,
+      "roundtrip_codex_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $4,
+        start: 15953,
+        end: 16053,
+        pattern_start: 15964,
+        pattern_end: 15974
+      }
+    )
+  }
+  $should.equal(result.provider, new $types.Codex());
+  $should.be_true($string.contains(result.skill_yaml, "name: test-skill"));
+  $should.be_true($string.contains(result.skill_yaml, "version: 1.2.3"));
+  let $5 = $simplifile.delete$(compile_dir);
+  
+  let $6 = $simplifile.delete$(import_dir);
+  
+  return undefined;
+}
+
+export function import_nonexistent_path_fails_test() {
+  let result = $importer.import_skill(
+    "/tmp/nonexistent-import-xyz",
+    new None(),
+    "/tmp/out",
+  );
+  return $should.be_error(result);
+}
+
+export function import_no_skill_md_fails_test() {
+  let dir = "/tmp/skillc-test-no-skill-md";
+  let $ = $simplifile.delete$(dir);
+  
+  let $1 = $simplifile.create_directory_all(dir);
+  
+  let result = $importer.import_skill(dir, new None(), "/tmp/out");
+  $should.be_error(result);
+  let $2 = $simplifile.delete$(dir);
+  
+  return undefined;
+}
+
+export function import_invalid_frontmatter_fails_test() {
+  let dir = "/tmp/skillc-test-invalid-fm";
+  let $ = $simplifile.delete$(dir);
+  
+  let $1 = $simplifile.create_directory_all(dir);
+  
+  let $2 = $simplifile.write(dir + "/SKILL.md", "No frontmatter here.");
+  
+  let result = $importer.import_skill(dir, new None(), "/tmp/out");
+  $should.be_error(result);
+  let $3 = $simplifile.delete$(dir);
+  
+  return undefined;
+}
+
+export function import_output_dir_already_has_skill_yaml_fails_test() {
+  let output_dir = "/tmp/skillc-test-existing-skill";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $simplifile.create_directory_all(output_dir);
+  
+  let $2 = $simplifile.write(output_dir + "/skill.yaml", "name: existing\n");
+  
+  let result = $importer.import_skill(
+    "test/fixtures/import-openclaw",
+    new None(),
+    output_dir,
+  );
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    let $3 = result[0];
+    if ($3 instanceof $error.ImportError) {
+      msg = $3.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        493,
+        "import_output_dir_already_has_skill_yaml_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 17803,
+          end: 17855,
+          pattern_start: 17814,
+          pattern_end: 17846
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      493,
+      "import_output_dir_already_has_skill_yaml_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 17803,
+        end: 17855,
+        pattern_start: 17814,
+        pattern_end: 17846
+      }
+    )
+  }
+  $should.be_true($string.contains(msg, "already exists"));
+  let $4 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function import_with_provider_hint_test() {
+  let output_dir = "/tmp/skillc-test-import-hint";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $importer.import_skill(
+    "test/fixtures/import-codex",
+    new Some(new $types.Codex()),
+    output_dir,
+  );
+  let result;
+  if ($1 instanceof Ok) {
+    result = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      504,
+      "import_with_provider_hint_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 18098,
+        end: 18233,
+        pattern_start: 18109,
+        pattern_end: 18119
+      }
+    )
+  }
+  $should.equal(result.provider, new $types.Codex());
+  let $2 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function import_missing_name_field_fails_test() {
+  let dir = "/tmp/skillc-test-missing-name-field";
+  let $ = $simplifile.delete$(dir);
+  
+  let $1 = $simplifile.create_directory_all(dir);
+  
+  let $2 = $simplifile.write(
+    dir + "/SKILL.md",
+    "---\ndescription: \"A test\"\nversion: 1.0.0\n---\n\nBody.",
+  );
+  
+  let result = $importer.import_skill(
+    dir,
+    new Some(new $types.Codex()),
+    "/tmp/out",
+  );
+  $should.be_error(result);
+  if (result instanceof Error) {
+    let $3 = result[0];
+    if ($3 instanceof $error.ImportError) {
+      let $4 = $3.source;
+      if (!($4 === "name")) {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "importer_test",
+          528,
+          "import_missing_name_field_fails_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: result,
+            start: 18741,
+            end: 18796,
+            pattern_start: 18752,
+            pattern_end: 18787
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        528,
+        "import_missing_name_field_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 18741,
+          end: 18796,
+          pattern_start: 18752,
+          pattern_end: 18787
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      528,
+      "import_missing_name_field_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 18741,
+        end: 18796,
+        pattern_start: 18752,
+        pattern_end: 18787
+      }
+    )
+  }
+  let $5 = $simplifile.delete$(dir);
+  
+  return undefined;
+}
+
+export function import_invalid_version_fails_test() {
+  let dir = "/tmp/skillc-test-invalid-version";
+  let $ = $simplifile.delete$(dir);
+  
+  let $1 = $simplifile.create_directory_all(dir);
+  
+  let $2 = $simplifile.write(
+    dir + "/SKILL.md",
+    "---\nname: test\ndescription: \"A test\"\nversion: not-a-version\n---\n\nBody.",
+  );
+  
+  let result = $importer.import_skill(
+    dir,
+    new Some(new $types.Codex()),
+    "/tmp/out",
+  );
+  $should.be_error(result);
+  if (result instanceof Error) {
+    let $3 = result[0];
+    if ($3 instanceof $error.ImportError) {
+      let $4 = $3.source;
+      if (!($4 === "version")) {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "importer_test",
+          546,
+          "import_invalid_version_fails_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: result,
+            start: 19266,
+            end: 19324,
+            pattern_start: 19277,
+            pattern_end: 19315
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "importer_test",
+        546,
+        "import_invalid_version_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 19266,
+          end: 19324,
+          pattern_start: 19277,
+          pattern_end: 19315
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "importer_test",
+      546,
+      "import_invalid_version_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 19266,
+        end: 19324,
+        pattern_start: 19277,
+        pattern_end: 19315
+      }
+    )
+  }
+  let $5 = $simplifile.delete$(dir);
+  
+  return undefined;
+}