skill-universe 1.1.0

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

@@ -0,0 +1,461 @@
+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 $skillc from "./skillc.mjs";
+
+const FILEPATH = "test/cli_test.gleam";
+
+export function cli_version_test() {
+  let $ = $skillc.run(toList(["version"]));
+  let output;
+  if ($ instanceof Ok) {
+    output = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      11,
+      "cli_version_test",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $, start: 292, end: 339, pattern_start: 303, pattern_end: 313 }
+    )
+  }
+  $should.be_true($string.contains(output, "skill-universe"));
+  return $should.be_true($string.contains(output, "1.1.0"));
+}
+
+export function cli_help_test() {
+  let $ = $skillc.run(toList(["help"]));
+  let output;
+  if ($ instanceof Ok) {
+    output = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      21,
+      "cli_help_test",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $, start: 664, end: 708, pattern_start: 675, pattern_end: 685 }
+    )
+  }
+  $should.be_true($string.contains(output, "Usage:"));
+  $should.be_true($string.contains(output, "compile"));
+  $should.be_true($string.contains(output, "check"));
+  return $should.be_true($string.contains(output, "init"));
+}
+
+export function cli_help_flag_test() {
+  let $ = $skillc.run(toList(["--help"]));
+  let output;
+  if ($ instanceof Ok) {
+    output = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      29,
+      "cli_help_flag_test",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $, start: 950, end: 996, pattern_start: 961, pattern_end: 971 }
+    )
+  }
+  return $should.be_true($string.contains(output, "Usage:"));
+}
+
+export function cli_unknown_command_test() {
+  let result = $skillc.run(toList(["unknown"]));
+  return $should.be_error(result);
+}
+
+export function cli_compile_all_test() {
+  let output_dir = "/tmp/skillc-cli-test-compile-all";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $skillc.run(
+    toList(["compile", "test/fixtures/valid-skill", "--output", output_dir]),
+  );
+  let output;
+  if ($1 instanceof Ok) {
+    output = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      46,
+      "cli_compile_all_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 1471,
+        end: 1606,
+        pattern_start: 1482,
+        pattern_end: 1492
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "Compiled"));
+  $should.be_true($string.contains(output, "openclaw"));
+  $should.be_true($string.contains(output, "claude-code"));
+  $should.be_true($string.contains(output, "codex"));
+  let $2 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function cli_compile_single_target_test() {
+  let output_dir = "/tmp/skillc-cli-test-compile-target";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $skillc.run(
+    toList([
+      "compile",
+      "test/fixtures/valid-skill",
+      "--target",
+      "openclaw",
+      "--output",
+      output_dir,
+    ]),
+  );
+  let output;
+  if ($1 instanceof Ok) {
+    output = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      66,
+      "cli_compile_single_target_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 2015,
+        end: 2186,
+        pattern_start: 2026,
+        pattern_end: 2036
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "Compiled"));
+  $should.be_true($string.contains(output, "openclaw"));
+  let $2 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function cli_compile_providers_flag_test() {
+  let output_dir = "/tmp/skillc-cli-test-providers";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $skillc.run(
+    toList([
+      "compile",
+      "test/fixtures/valid-skill",
+      "--providers",
+      "openclaw,codex",
+      "--output",
+      output_dir,
+    ]),
+  );
+  let output;
+  if ($1 instanceof Ok) {
+    output = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      86,
+      "cli_compile_providers_flag_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 2483,
+        end: 2663,
+        pattern_start: 2494,
+        pattern_end: 2504
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "openclaw"));
+  $should.be_true($string.contains(output, "codex"));
+  $should.be_false($string.contains(output, "claude-code"));
+  let $2 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function cli_compile_invalid_provider_test() {
+  let result = $skillc.run(
+    toList(["compile", "test/fixtures/valid-skill", "--target", "invalid"]),
+  );
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    msg = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      112,
+      "cli_compile_invalid_provider_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 3076,
+        end: 3106,
+        pattern_start: 3087,
+        pattern_end: 3097
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "Unknown provider"));
+}
+
+export function cli_compile_nonexistent_dir_test() {
+  let result = $skillc.run(toList(["compile", "/tmp/nonexistent-dir-xyz"]));
+  return $should.be_error(result);
+}
+
+export function cli_check_test() {
+  let $ = $skillc.run(toList(["check", "test/fixtures/valid-skill"]));
+  let output;
+  if ($ instanceof Ok) {
+    output = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      126,
+      "cli_check_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3521,
+        end: 3595,
+        pattern_start: 3532,
+        pattern_end: 3542
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "test-skill"));
+  $should.be_true($string.contains(output, "v1.2.3"));
+  $should.be_true($string.contains(output, "openclaw"));
+  $should.be_true($string.contains(output, "claude-code"));
+  return $should.be_true($string.contains(output, "codex"));
+}
+
+export function cli_check_minimal_skill_test() {
+  let $ = $skillc.run(toList(["check", "test/fixtures/minimal-skill"]));
+  let output;
+  if ($ instanceof Ok) {
+    output = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      135,
+      "cli_check_minimal_skill_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3911,
+        end: 3987,
+        pattern_start: 3922,
+        pattern_end: 3932
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "minimal"));
+  return $should.be_true($string.contains(output, "openclaw"));
+}
+
+export function cli_check_nonexistent_dir_test() {
+  let result = $skillc.run(toList(["check", "/tmp/nonexistent-dir-xyz"]));
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    msg = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      143,
+      "cli_check_nonexistent_dir_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 4233,
+        end: 4263,
+        pattern_start: 4244,
+        pattern_end: 4254
+      }
+    )
+  }
+  return $should.be_true($string.contains(msg, "skill.yaml not found"));
+}
+
+export function cli_check_invalid_yaml_test() {
+  let result = $skillc.run(toList(["check", "test/fixtures/invalid-yaml"]));
+  return $should.be_error(result);
+}
+
+export function cli_init_test() {
+  let dir = "/tmp/skillc-cli-test-init";
+  let $ = $simplifile.delete$(dir);
+  
+  let $1 = $skillc.run(toList(["init", dir]));
+  let output;
+  if ($1 instanceof Ok) {
+    output = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      160,
+      "cli_init_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 4749,
+        end: 4798,
+        pattern_start: 4760,
+        pattern_end: 4770
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "Created skill"));
+  $should.be_true($string.contains(output, "skillc-cli-test-init"));
+  let $2 = $simplifile.delete$(dir);
+  
+  return undefined;
+}
+
+export function cli_init_with_name_test() {
+  let dir = "/tmp/skillc-cli-test-init-named";
+  let $ = $simplifile.delete$(dir);
+  
+  let $1 = $skillc.run(toList(["init", dir, "--name", "my-cool-skill"]));
+  let output;
+  if ($1 instanceof Ok) {
+    output = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      174,
+      "cli_init_with_name_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 5123,
+        end: 5199,
+        pattern_start: 5134,
+        pattern_end: 5144
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "my-cool-skill"));
+  let $2 = $simplifile.read(dir + "/skill.yaml");
+  let content;
+  if ($2 instanceof Ok) {
+    content = $2[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      178,
+      "cli_init_with_name_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 5300,
+        end: 5362,
+        pattern_start: 5311,
+        pattern_end: 5322
+      }
+    )
+  }
+  $should.be_true($string.contains(content, "name: my-cool-skill"));
+  let $3 = $simplifile.delete$(dir);
+  
+  return undefined;
+}
+
+export function cli_init_already_exists_test() {
+  let dir = "/tmp/skillc-cli-test-init-exists";
+  let $ = $simplifile.delete$(dir);
+  
+  let $1 = $skillc.run(toList(["init", dir]));
+  if (!($1 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      189,
+      "cli_init_already_exists_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 5595,
+        end: 5639,
+        pattern_start: 5606,
+        pattern_end: 5611
+      }
+    )
+  }
+  let result = $skillc.run(toList(["init", dir]));
+  $should.be_error(result);
+  let msg;
+  if (result instanceof Error) {
+    msg = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "cli_test",
+      192,
+      "cli_init_already_exists_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 5709,
+        end: 5739,
+        pattern_start: 5720,
+        pattern_end: 5730
+      }
+    )
+  }
+  $should.be_true($string.contains(msg, "already exists"));
+  let $2 = $simplifile.delete$(dir);
+  
+  return undefined;
+}
+
+export function name_from_path_simple_test() {
+  return $should.equal($skillc.name_from_path("my-skill"), "my-skill");
+}
+
+export function name_from_path_nested_test() {
+  return $should.equal(
+    $skillc.name_from_path("/home/user/my-skill"),
+    "my-skill",
+  );
+}
+
+export function name_from_path_trailing_slash_test() {
+  return $should.equal($skillc.name_from_path("my-skill/"), "my-skill");
+}