skill-universe 1.1.0

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

@@ -0,0 +1,26 @@
+import * as $should from "../gleeunit/gleeunit/should.mjs";
+import * as $path from "./skillc/path.mjs";
+
+export function parent_dir_nested_test() {
+  return $should.equal($path.parent_dir("a/b/c"), "a/b");
+}
+
+export function parent_dir_root_relative_test() {
+  return $should.equal($path.parent_dir("/foo"), "/");
+}
+
+export function parent_dir_single_component_test() {
+  return $should.equal($path.parent_dir("foo"), ".");
+}
+
+export function basename_nested_test() {
+  return $should.equal($path.basename("a/b/c"), "c");
+}
+
+export function basename_trailing_slash_test() {
+  return $should.equal($path.basename("a/b/c/"), "c");
+}
+
+export function basename_single_component_test() {
+  return $should.equal($path.basename("foo"), "foo");
+}

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

@@ -0,0 +1,221 @@
+import * as $list from "../gleam_stdlib/gleam/list.mjs";
+import * as $should from "../gleeunit/gleeunit/should.mjs";
+import { Ok, toList, makeError } from "./gleam.mjs";
+import * as $provider from "./skillc/provider.mjs";
+import * as $types from "./skillc/types.mjs";
+
+const FILEPATH = "test/provider_test.gleam";
+
+export function discover_valid_providers_test() {
+  let result = $provider.discover_providers("test/fixtures/valid-skill");
+  let providers;
+  if (result instanceof Ok) {
+    providers = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "provider_test",
+      12,
+      "discover_valid_providers_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 389,
+        end: 422,
+        pattern_start: 400,
+        pattern_end: 413
+      }
+    )
+  }
+  return $should.equal(
+    providers,
+    toList([new $types.ClaudeCode(), new $types.Codex(), new $types.OpenClaw()]),
+  );
+}
+
+export function discover_minimal_provider_test() {
+  let result = $provider.discover_providers("test/fixtures/minimal-skill");
+  let providers;
+  if (result instanceof Ok) {
+    providers = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "provider_test",
+      18,
+      "discover_minimal_provider_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 619,
+        end: 652,
+        pattern_start: 630,
+        pattern_end: 643
+      }
+    )
+  }
+  return $should.equal(providers, toList([new $types.OpenClaw()]));
+}
+
+export function discover_no_providers_directory_test() {
+  let result = $provider.discover_providers("test/fixtures/no-providers");
+  let providers;
+  if (result instanceof Ok) {
+    providers = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "provider_test",
+      24,
+      "discover_no_providers_directory_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 823,
+        end: 856,
+        pattern_start: 834,
+        pattern_end: 847
+      }
+    )
+  }
+  return $should.equal(providers, toList([]));
+}
+
+export function discover_empty_providers_directory_test() {
+  let result = $provider.discover_providers("test/fixtures/empty-providers");
+  let providers;
+  if (result instanceof Ok) {
+    providers = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "provider_test",
+      30,
+      "discover_empty_providers_directory_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 1019,
+        end: 1052,
+        pattern_start: 1030,
+        pattern_end: 1043
+      }
+    )
+  }
+  return $should.equal(providers, toList([]));
+}
+
+export function subdirectory_without_metadata_ignored_test() {
+  let result = $provider.discover_providers(
+    "test/fixtures/provider-no-metadata",
+  );
+  let providers;
+  if (result instanceof Ok) {
+    providers = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "provider_test",
+      36,
+      "subdirectory_without_metadata_ignored_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 1223,
+        end: 1256,
+        pattern_start: 1234,
+        pattern_end: 1247
+      }
+    )
+  }
+  return $should.equal(providers, toList([]));
+}
+
+export function is_supported_valid_test() {
+  $should.be_true(
+    $provider.is_supported("test/fixtures/valid-skill", new $types.OpenClaw()),
+  );
+  $should.be_true(
+    $provider.is_supported("test/fixtures/valid-skill", new $types.ClaudeCode()),
+  );
+  return $should.be_true(
+    $provider.is_supported("test/fixtures/valid-skill", new $types.Codex()),
+  );
+}
+
+export function is_supported_invalid_test() {
+  return $should.be_false(
+    $provider.is_supported("test/fixtures/no-providers", new $types.OpenClaw()),
+  );
+}
+
+export function validate_provider_supported_test() {
+  let result = $provider.validate_provider(
+    "test/fixtures/valid-skill",
+    new $types.OpenClaw(),
+  );
+  return $should.be_ok(result);
+}
+
+export function validate_provider_unsupported_test() {
+  let result = $provider.validate_provider(
+    "test/fixtures/no-providers",
+    new $types.OpenClaw(),
+  );
+  return $should.be_error(result);
+}
+
+export function known_providers_no_warnings_test() {
+  let $ = $provider.discover_providers("test/fixtures/valid-skill");
+  let providers;
+  if ($ instanceof Ok) {
+    providers = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "provider_test",
+      73,
+      "known_providers_no_warnings_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2198,
+        end: 2285,
+        pattern_start: 2209,
+        pattern_end: 2222
+      }
+    )
+  }
+  return $should.equal($list.length(providers), 3);
+}
+
+export function unknown_provider_silently_skipped_test() {
+  let $ = $provider.discover_providers("test/fixtures/unknown-provider");
+  let providers;
+  if ($ instanceof Ok) {
+    providers = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "provider_test",
+      80,
+      "unknown_provider_silently_skipped_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2465,
+        end: 2557,
+        pattern_start: 2476,
+        pattern_end: 2489
+      }
+    )
+  }
+  return $should.equal(providers, toList([new $types.OpenClaw()]));
+}

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

@@ -0,0 +1,359 @@
+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, toList, makeError } from "./gleam.mjs";
+import * as $skillc from "./skillc.mjs";
+import * as $registry from "./skillc/registry.mjs";
+import * as $shell from "./skillc/shell.mjs";
+
+const FILEPATH = "test/registry_test.gleam";
+
+export function parse_repo_url_ssh_test() {
+  let result = $registry.parse_repo_url("git@github.com:owner/repo.git");
+  return $should.equal(result, "owner/repo");
+}
+
+export function parse_repo_url_https_test() {
+  let result = $registry.parse_repo_url("https://github.com/owner/repo.git");
+  return $should.equal(result, "owner/repo");
+}
+
+export function parse_repo_url_https_no_git_suffix_test() {
+  let result = $registry.parse_repo_url("https://github.com/owner/repo");
+  return $should.equal(result, "owner/repo");
+}
+
+export function parse_repo_url_trailing_slash_test() {
+  let result = $registry.parse_repo_url("https://github.com/owner/repo/");
+  return $should.equal(result, "owner/repo");
+}
+
+export function parse_repo_url_with_whitespace_test() {
+  let result = $registry.parse_repo_url("  git@github.com:owner/repo.git  ");
+  return $should.equal(result, "owner/repo");
+}
+
+export function parse_install_spec_no_version_test() {
+  let $ = $registry.parse_install_spec("owner/repo");
+  let repo;
+  let skill_name;
+  let version;
+  repo = $[0];
+  skill_name = $[1];
+  version = $[2];
+  $should.equal(repo, "owner/repo");
+  $should.equal(skill_name, new None());
+  return $should.equal(version, new None());
+}
+
+export function parse_install_spec_with_version_test() {
+  let $ = $registry.parse_install_spec("owner/repo@v1.0.0");
+  let repo;
+  let skill_name;
+  let version;
+  repo = $[0];
+  skill_name = $[1];
+  version = $[2];
+  $should.equal(repo, "owner/repo");
+  $should.equal(skill_name, new None());
+  return $should.equal(version, new Some("v1.0.0"));
+}
+
+export function parse_install_spec_with_prerelease_test() {
+  let $ = $registry.parse_install_spec("owner/repo@v1.0.0-beta.1");
+  let repo;
+  let skill_name;
+  let version;
+  repo = $[0];
+  skill_name = $[1];
+  version = $[2];
+  $should.equal(repo, "owner/repo");
+  $should.equal(skill_name, new None());
+  return $should.equal(version, new Some("v1.0.0-beta.1"));
+}
+
+export function parse_install_spec_three_segment_test() {
+  let $ = $registry.parse_install_spec("owner/repo/my-skill");
+  let repo;
+  let skill_name;
+  let version;
+  repo = $[0];
+  skill_name = $[1];
+  version = $[2];
+  $should.equal(repo, "owner/repo");
+  $should.equal(skill_name, new Some("my-skill"));
+  return $should.equal(version, new None());
+}
+
+export function parse_install_spec_three_segment_with_version_test() {
+  let $ = $registry.parse_install_spec("owner/repo/my-skill@v1.0.0");
+  let repo;
+  let skill_name;
+  let version;
+  repo = $[0];
+  skill_name = $[1];
+  version = $[2];
+  $should.equal(repo, "owner/repo");
+  $should.equal(skill_name, new Some("my-skill"));
+  return $should.equal(version, new Some("v1.0.0"));
+}
+
+export function shell_exec_success_test() {
+  let $ = $shell.exec("echo hello");
+  let output;
+  if ($ instanceof Ok) {
+    output = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      86,
+      "shell_exec_success_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2794,
+        end: 2842,
+        pattern_start: 2805,
+        pattern_end: 2815
+      }
+    )
+  }
+  return $should.equal(output, "hello");
+}
+
+export function shell_exec_failure_test() {
+  let result = $shell.exec("false");
+  return $should.be_error(result);
+}
+
+export function shell_exec_nonexistent_command_test() {
+  let result = $shell.exec("nonexistent_command_xyz_123");
+  return $should.be_error(result);
+}
+
+export function list_installed_empty_dir_test() {
+  let dir = "/tmp/skillc-test-list-empty";
+  let $ = $simplifile.delete$(dir);
+  
+  let $1 = $simplifile.create_directory_all(dir);
+  if (!($1 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      107,
+      "list_installed_empty_dir_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 3415,
+        end: 3470,
+        pattern_start: 3426,
+        pattern_end: 3431
+      }
+    )
+  }
+  let $2 = $registry.list_installed(dir);
+  let output;
+  if ($2 instanceof Ok) {
+    output = $2[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      109,
+      "list_installed_empty_dir_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 3474,
+        end: 3526,
+        pattern_start: 3485,
+        pattern_end: 3495
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "No skills installed"));
+  let $3 = $simplifile.delete$(dir);
+  
+  return undefined;
+}
+
+export function list_installed_nonexistent_dir_test() {
+  let $ = $registry.list_installed("/tmp/nonexistent-dir-xyz-123");
+  let output;
+  if ($ instanceof Ok) {
+    output = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      117,
+      "list_installed_nonexistent_dir_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3684,
+        end: 3767,
+        pattern_start: 3695,
+        pattern_end: 3705
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "No skills installed"));
+}
+
+export function list_installed_with_skills_test() {
+  let dir = "/tmp/skillc-test-list-skills";
+  let $ = $simplifile.delete$(dir);
+  
+  let skill_dir = dir + "/openclaw/my-skill";
+  let $1 = $simplifile.create_directory_all(skill_dir);
+  if (!($1 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      128,
+      "list_installed_with_skills_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 4049,
+        end: 4110,
+        pattern_start: 4060,
+        pattern_end: 4065
+      }
+    )
+  }
+  let $2 = $simplifile.write(
+    skill_dir + "/SKILL.md",
+    "---\nname: my-skill\n---\n",
+  );
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      129,
+      "list_installed_with_skills_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 4113,
+        end: 4208,
+        pattern_start: 4124,
+        pattern_end: 4129
+      }
+    )
+  }
+  let $3 = $registry.list_installed(dir);
+  let output;
+  if ($3 instanceof Ok) {
+    output = $3[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      132,
+      "list_installed_with_skills_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 4212,
+        end: 4264,
+        pattern_start: 4223,
+        pattern_end: 4233
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "my-skill"));
+  $should.be_true($string.contains(output, "openclaw"));
+  let $4 = $simplifile.delete$(dir);
+  
+  return undefined;
+}
+
+export function cli_help_includes_registry_commands_test() {
+  let $ = $skillc.run(toList(["help"]));
+  let output;
+  if ($ instanceof Ok) {
+    output = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      145,
+      "cli_help_includes_registry_commands_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4646,
+        end: 4690,
+        pattern_start: 4657,
+        pattern_end: 4667
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "publish"));
+  $should.be_true($string.contains(output, "search"));
+  $should.be_true($string.contains(output, "install"));
+  return $should.be_true($string.contains(output, "list"));
+}
+
+export function cli_list_installed_test() {
+  let dir = "/tmp/skillc-test-cli-list";
+  let $ = $simplifile.delete$(dir);
+  
+  let $1 = $simplifile.create_directory_all(dir);
+  if (!($1 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      155,
+      "cli_list_installed_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 5012,
+        end: 5067,
+        pattern_start: 5023,
+        pattern_end: 5028
+      }
+    )
+  }
+  let $2 = $skillc.run(toList(["list", "--installed", "--output", dir]));
+  let output;
+  if ($2 instanceof Ok) {
+    output = $2[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "registry_test",
+      157,
+      "cli_list_installed_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 5071,
+        end: 5147,
+        pattern_start: 5082,
+        pattern_end: 5092
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "No skills installed"));
+  let $3 = $simplifile.delete$(dir);
+  
+  return undefined;
+}