skill-universe 1.1.0

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

@@ -0,0 +1,308 @@
+import * as $list from "../gleam_stdlib/gleam/list.mjs";
+import * as $option from "../gleam_stdlib/gleam/option.mjs";
+import { None } from "../gleam_stdlib/gleam/option.mjs";
+import * as $string from "../gleam_stdlib/gleam/string.mjs";
+import * as $should from "../gleeunit/gleeunit/should.mjs";
+import { Ok, Error, toList, makeError } from "./gleam.mjs";
+import * as $skillc from "./skillc.mjs";
+import * as $config from "./skillc/config.mjs";
+import * as $semver from "./skillc/semver.mjs";
+import * as $types from "./skillc/types.mjs";
+import { ConfigField, Optional, OptionalWithDefault, Required, Skill } from "./skillc/types.mjs";
+
+const FILEPATH = "test/config_test.gleam";
+
+export function cli_config_init_test() {
+  let $ = $skillc.run(toList(["config", "init", "test/fixtures/valid-skill"]));
+  let output;
+  if ($ instanceof Ok) {
+    output = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "config_test",
+      135,
+      "cli_config_init_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4345,
+        end: 4432,
+        pattern_start: 4356,
+        pattern_end: 4366
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "SKILL_CONFIG_"));
+}
+
+export function cli_config_check_missing_dir_test() {
+  let result = $skillc.run(
+    toList(["config", "check", "/tmp/nonexistent-dir-xyz"]),
+  );
+  return $should.be_error(result);
+}
+
+function test_skill_with_config() {
+  let $ = $semver.parse("1.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "config_test",
+      150,
+      "test_skill_with_config",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4862,
+        end: 4902,
+        pattern_start: 4873,
+        pattern_end: 4878
+      }
+    )
+  }
+  return new Skill(
+    "test-skill",
+    "A test skill",
+    v,
+    new None(),
+    new None(),
+    new None(),
+    new None(),
+    toList([]),
+    toList([
+      new ConfigField(
+        "api_key",
+        "API key for the service",
+        new Required(),
+        true,
+      ),
+      new ConfigField(
+        "timeout",
+        "Request timeout",
+        new OptionalWithDefault("30"),
+        false,
+      ),
+      new ConfigField("debug", "Enable debug mode", new Optional(), false),
+    ]),
+  );
+}
+
+export function generate_template_with_fields_test() {
+  let skill = test_skill_with_config();
+  let template = $config.generate_template(skill);
+  $should.be_true(
+    $string.contains(template, "SKILL_CONFIG_TEST_SKILL_API_KEY="),
+  );
+  $should.be_true($string.contains(template, "Required"));
+  $should.be_true($string.contains(template, "Secret: yes"));
+  $should.be_true(
+    $string.contains(template, "SKILL_CONFIG_TEST_SKILL_TIMEOUT="),
+  );
+  $should.be_true($string.contains(template, "default: 30"));
+  return $should.be_true($string.contains(template, "30"));
+}
+
+export function generate_template_includes_description_test() {
+  let skill = test_skill_with_config();
+  let template = $config.generate_template(skill);
+  $should.be_true($string.contains(template, "API key for the service"));
+  return $should.be_true($string.contains(template, "Request timeout"));
+}
+
+export function check_all_satisfied_test() {
+  let skill = test_skill_with_config();
+  let lookup = (name) => {
+    if (name === "SKILL_CONFIG_TEST_SKILL_API_KEY") {
+      return new Ok("my-key");
+    } else if (name === "SKILL_CONFIG_TEST_SKILL_TIMEOUT") {
+      return new Ok("60");
+    } else if (name === "SKILL_CONFIG_TEST_SKILL_DEBUG") {
+      return new Ok("");
+    } else {
+      return new Error(undefined);
+    }
+  };
+  let statuses = $config.check_with_lookup(skill, lookup);
+  let missing = $list.filter(
+    statuses,
+    (s) => {
+      if (s instanceof $config.MissingRequired) {
+        return true;
+      } else {
+        return false;
+      }
+    },
+  );
+  return $should.equal(missing, toList([]));
+}
+
+export function check_missing_required_test() {
+  let skill = test_skill_with_config();
+  let lookup = (_) => { return new Error(undefined); };
+  let statuses = $config.check_with_lookup(skill, lookup);
+  let missing = $list.filter_map(
+    statuses,
+    (s) => {
+      if (s instanceof $config.MissingRequired) {
+        let field = s.field;
+        return new Ok(field.name);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+  return $should.be_true($list.contains(missing, "api_key"));
+}
+
+export function check_optional_not_missing_test() {
+  let skill = test_skill_with_config();
+  let lookup = (_) => { return new Error(undefined); };
+  let statuses = $config.check_with_lookup(skill, lookup);
+  let missing = $list.filter_map(
+    statuses,
+    (s) => {
+      if (s instanceof $config.MissingRequired) {
+        let field = s.field;
+        return new Ok(field.name);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+  return $should.be_false($list.contains(missing, "debug"));
+}
+
+export function check_default_used_when_not_set_test() {
+  let skill = test_skill_with_config();
+  let lookup = (_) => { return new Error(undefined); };
+  let statuses = $config.check_with_lookup(skill, lookup);
+  let timeout_status = $list.find(
+    statuses,
+    (s) => {
+      if (s instanceof $config.Provided) {
+        let field = s.field;
+        return field.name === "timeout";
+      } else if (s instanceof $config.MissingRequired) {
+        let field = s.field;
+        return field.name === "timeout";
+      } else if (s instanceof $config.DefaultUsed) {
+        let field = s.field;
+        return field.name === "timeout";
+      } else {
+        let field = s.field;
+        return field.name === "timeout";
+      }
+    },
+  );
+  let default$;
+  if (timeout_status instanceof Ok) {
+    let $ = timeout_status[0];
+    if ($ instanceof $config.DefaultUsed) {
+      default$ = $.default;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "config_test",
+        107,
+        "check_default_used_when_not_set_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: timeout_status,
+          start: 3533,
+          end: 3595,
+          pattern_start: 3544,
+          pattern_end: 3578
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "config_test",
+      107,
+      "check_default_used_when_not_set_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: timeout_status,
+        start: 3533,
+        end: 3595,
+        pattern_start: 3544,
+        pattern_end: 3578
+      }
+    )
+  }
+  return $should.equal(default$, "30");
+}
+
+export function check_empty_string_counts_as_missing_for_required_test() {
+  let skill = test_skill_with_config();
+  let lookup = (name) => {
+    if (name === "SKILL_CONFIG_TEST_SKILL_API_KEY") {
+      return new Ok("");
+    } else {
+      return new Error(undefined);
+    }
+  };
+  let statuses = $config.check_with_lookup(skill, lookup);
+  let missing = $list.filter_map(
+    statuses,
+    (s) => {
+      if (s instanceof $config.MissingRequired) {
+        let field = s.field;
+        return new Ok(field.name);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+  return $should.be_true($list.contains(missing, "api_key"));
+}
+
+function test_skill_no_config() {
+  let $ = $semver.parse("1.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "config_test",
+      184,
+      "test_skill_no_config",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5620,
+        end: 5660,
+        pattern_start: 5631,
+        pattern_end: 5636
+      }
+    )
+  }
+  return new Skill(
+    "simple-skill",
+    "A simple skill",
+    v,
+    new None(),
+    new None(),
+    new None(),
+    new None(),
+    toList([]),
+    toList([]),
+  );
+}
+
+export function generate_template_no_fields_test() {
+  let skill = test_skill_no_config();
+  let template = $config.generate_template(skill);
+  return $should.be_true($string.contains(template, "No configuration fields"));
+}

package/build/dev/javascript/skillc/gleam.main.mjs

@@ -0,0 +1,2 @@
+import { main } from "./skillc_test.mjs";
+main();

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

@@ -0,0 +1 @@
+export * from "../prelude.mjs";