skill-universe 1.1.0

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

@@ -0,0 +1,427 @@
+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 $result from "../../gleam_stdlib/gleam/result.mjs";
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import * as $yay from "../../yay/yay.mjs";
+import { Ok, Error, toList, Empty as $Empty, prepend as listPrepend } from "../gleam.mjs";
+import * as $error from "../skillc/error.mjs";
+import { ParseError, ValidationError } from "../skillc/error.mjs";
+import * as $semver from "../skillc/semver.mjs";
+import * as $types from "../skillc/types.mjs";
+import {
+  ConfigField,
+  Dependency,
+  Optional,
+  OptionalWithDefault,
+  Required,
+  Skill,
+  SkillMetadata,
+} from "../skillc/types.mjs";
+import * as $version_constraint from "../skillc/version_constraint.mjs";
+
+function normalize_optional(opt) {
+  if (opt instanceof Some) {
+    let $ = opt[0];
+    if ($ === "") {
+      return new None();
+    } else {
+      return opt;
+    }
+  } else {
+    return opt;
+  }
+}
+
+function parse_metadata(node) {
+  let $ = $yay.select_sugar(node, "metadata");
+  if ($ instanceof Ok) {
+    let _block;
+    let _pipe = $yay.extract_optional_string(node, "metadata.author");
+    _block = $result.unwrap(_pipe, new None());
+    let author = _block;
+    let _block$1;
+    let _pipe$1 = $yay.extract_optional_string(node, "metadata.author_email");
+    _block$1 = $result.unwrap(_pipe$1, new None());
+    let author_email = _block$1;
+    let _block$2;
+    let _pipe$2 = $yay.extract_string_list(node, "metadata.tags");
+    _block$2 = $result.unwrap(_pipe$2, toList([]));
+    let tags = _block$2;
+    return new Some(new SkillMetadata(author, author_email, tags));
+  } else {
+    return new None();
+  }
+}
+
+function parse_dependencies(node) {
+  let $ = $yay.select_sugar(node, "dependencies");
+  if ($ instanceof Ok) {
+    let $1 = $[0];
+    if ($1 instanceof $yay.NodeSeq) {
+      let items = $1[0];
+      return $list.filter_map(
+        items,
+        (item) => {
+          let $2 = $yay.extract_string(item, "name");
+          if ($2 instanceof Ok) {
+            let name = $2[0];
+            let $3 = $string.is_empty($string.trim(name));
+            if ($3) {
+              return new Error(undefined);
+            } else {
+              let _block;
+              let _pipe = $yay.extract_string(item, "version");
+              _block = $result.unwrap(_pipe, "*");
+              let version_str = _block;
+              let $4 = $version_constraint.parse(version_str);
+              if ($4 instanceof Ok) {
+                let version = $4[0];
+                let _block$1;
+                let _pipe$1 = $yay.extract_bool_or(item, "optional", false);
+                _block$1 = $result.unwrap(_pipe$1, false);
+                let optional = _block$1;
+                return new Ok(new Dependency(name, version, optional));
+              } else {
+                return new Error(undefined);
+              }
+            }
+          } else {
+            return new Error(undefined);
+          }
+        },
+      );
+    } else {
+      return toList([]);
+    }
+  } else {
+    return toList([]);
+  }
+}
+
+function parse_config(node) {
+  let $ = $yay.select_sugar(node, "config");
+  if ($ instanceof Ok) {
+    let $1 = $[0];
+    if ($1 instanceof $yay.NodeSeq) {
+      let items = $1[0];
+      return $list.filter_map(
+        items,
+        (item) => {
+          let $2 = $yay.extract_string(item, "name");
+          if ($2 instanceof Ok) {
+            let name = $2[0];
+            let $3 = $string.is_empty($string.trim(name));
+            if ($3) {
+              return new Error(undefined);
+            } else {
+              let _block;
+              let _pipe = $yay.extract_string(item, "description");
+              _block = $result.unwrap(_pipe, "");
+              let description = _block;
+              let _block$1;
+              let _pipe$1 = $yay.extract_bool_or(item, "required", false);
+              _block$1 = $result.unwrap(_pipe$1, false);
+              let required = _block$1;
+              let _block$2;
+              let _pipe$2 = $yay.extract_bool_or(item, "secret", false);
+              _block$2 = $result.unwrap(_pipe$2, false);
+              let secret = _block$2;
+              let _block$3;
+              let _pipe$3 = $yay.extract_optional_string(item, "default");
+              _block$3 = $result.unwrap(_pipe$3, new None());
+              let default$ = _block$3;
+              let _block$4;
+              if (required) {
+                _block$4 = new Required();
+              } else {
+                if (default$ instanceof Some) {
+                  let d = default$[0];
+                  _block$4 = new OptionalWithDefault(d);
+                } else {
+                  _block$4 = new Optional();
+                }
+              }
+              let requirement = _block$4;
+              return new Ok(
+                new ConfigField(name, description, requirement, secret),
+              );
+            }
+          } else {
+            return new Error(undefined);
+          }
+        },
+      );
+    } else {
+      return toList([]);
+    }
+  } else {
+    return toList([]);
+  }
+}
+
+function do_check_unique_names(items, get_name, field, label, seen) {
+  if (items instanceof $Empty) {
+    return new Ok(items);
+  } else {
+    let first = items.head;
+    let rest = items.tail;
+    let name = get_name(first);
+    let $ = $list.contains(seen, name);
+    if ($) {
+      return new Error(
+        new ValidationError(field, (("Duplicate " + label) + ": ") + name),
+      );
+    } else {
+      return $result.try$(
+        do_check_unique_names(
+          rest,
+          get_name,
+          field,
+          label,
+          listPrepend(name, seen),
+        ),
+        (_) => { return new Ok(items); },
+      );
+    }
+  }
+}
+
+function check_unique_names(items, get_name, field, label) {
+  return do_check_unique_names(items, get_name, field, label, toList([]));
+}
+
+function parse_skill_from_node(node) {
+  return $result.try$(
+    (() => {
+      let _pipe = $yay.extract_string(node, "name");
+      return $result.map_error(
+        _pipe,
+        (_) => {
+          return new ValidationError("name", "Required field 'name' is missing");
+        },
+      );
+    })(),
+    (name) => {
+      return $result.try$(
+        (() => {
+          let $ = $string.is_empty($string.trim(name));
+          if ($) {
+            return new Error(
+              new ValidationError("name", "Field 'name' must not be empty"),
+            );
+          } else {
+            return new Ok(undefined);
+          }
+        })(),
+        (_) => {
+          return $result.try$(
+            (() => {
+              let _pipe = $yay.extract_string(node, "description");
+              return $result.map_error(
+                _pipe,
+                (_) => {
+                  return new ValidationError(
+                    "description",
+                    "Required field 'description' is missing",
+                  );
+                },
+              );
+            })(),
+            (description) => {
+              return $result.try$(
+                (() => {
+                  let $ = $string.is_empty($string.trim(description));
+                  if ($) {
+                    return new Error(
+                      new ValidationError(
+                        "description",
+                        "Field 'description' must not be empty",
+                      ),
+                    );
+                  } else {
+                    return new Ok(undefined);
+                  }
+                })(),
+                (_) => {
+                  return $result.try$(
+                    (() => {
+                      let _pipe = $yay.extract_string(node, "version");
+                      return $result.map_error(
+                        _pipe,
+                        (_) => {
+                          return new ValidationError(
+                            "version",
+                            "Required field 'version' is missing",
+                          );
+                        },
+                      );
+                    })(),
+                    (version_str) => {
+                      return $result.try$(
+                        $semver.parse(version_str),
+                        (version) => {
+                          let _block;
+                          let _pipe = $yay.extract_optional_string(
+                            node,
+                            "license",
+                          );
+                          let _pipe$1 = $result.unwrap(_pipe, new None());
+                          _block = normalize_optional(_pipe$1);
+                          let license = _block;
+                          let _block$1;
+                          let _pipe$2 = $yay.extract_optional_string(
+                            node,
+                            "homepage",
+                          );
+                          let _pipe$3 = $result.unwrap(_pipe$2, new None());
+                          _block$1 = normalize_optional(_pipe$3);
+                          let homepage = _block$1;
+                          let _block$2;
+                          let _pipe$4 = $yay.extract_optional_string(
+                            node,
+                            "repository",
+                          );
+                          let _pipe$5 = $result.unwrap(_pipe$4, new None());
+                          _block$2 = normalize_optional(_pipe$5);
+                          let repository = _block$2;
+                          let metadata = parse_metadata(node);
+                          let dependencies = parse_dependencies(node);
+                          return $result.try$(
+                            (() => {
+                              let $ = $list.find(
+                                dependencies,
+                                (d) => { return d.name === name; },
+                              );
+                              if ($ instanceof Ok) {
+                                return new Error(
+                                  new ValidationError(
+                                    "dependencies",
+                                    "Skill cannot depend on itself: " + name,
+                                  ),
+                                );
+                              } else {
+                                return new Ok(undefined);
+                              }
+                            })(),
+                            (_) => {
+                              return $result.try$(
+                                check_unique_names(
+                                  dependencies,
+                                  (d) => { return d.name; },
+                                  "dependencies",
+                                  "dependency",
+                                ),
+                                (dependencies) => {
+                                  let config = parse_config(node);
+                                  return $result.try$(
+                                    check_unique_names(
+                                      config,
+                                      (c) => { return c.name; },
+                                      "config",
+                                      "config field",
+                                    ),
+                                    (config) => {
+                                      return new Ok(
+                                        new Skill(
+                                          name,
+                                          description,
+                                          version,
+                                          license,
+                                          homepage,
+                                          repository,
+                                          metadata,
+                                          dependencies,
+                                          config,
+                                        ),
+                                      );
+                                    },
+                                  );
+                                },
+                              );
+                            },
+                          );
+                        },
+                      );
+                    },
+                  );
+                },
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+export function has_frontmatter(content) {
+  return $string.starts_with($string.trim_start(content), "---");
+}
+
+function yaml_error_to_skill_error(file, err) {
+  if (err instanceof $yay.UnexpectedParsingError) {
+    return new ParseError(file, "Unexpected parsing error");
+  } else {
+    let msg = err.msg;
+    return new ParseError(file, msg);
+  }
+}
+
+export function parse_skill_yaml(content) {
+  return $result.try$(
+    (() => {
+      let _pipe = $yay.parse_string(content);
+      return $result.map_error(
+        _pipe,
+        (e) => { return yaml_error_to_skill_error("skill.yaml", e); },
+      );
+    })(),
+    (docs) => {
+      return $result.try$(
+        (() => {
+          if (docs instanceof $Empty) {
+            return new Error(
+              new ParseError("skill.yaml", "Empty YAML document"),
+            );
+          } else {
+            let first = docs.head;
+            return new Ok(first);
+          }
+        })(),
+        (doc) => {
+          let root = $yay.document_root(doc);
+          if (root instanceof $yay.NodeNil) {
+            return new Error(
+              new ParseError("skill.yaml", "Empty YAML document"),
+            );
+          } else {
+            return parse_skill_from_node(root);
+          }
+        },
+      );
+    },
+  );
+}
+
+export function parse_metadata_yaml(content, provider) {
+  let provider_name = $types.provider_to_string(provider);
+  let file = ("providers/" + provider_name) + "/metadata.yaml";
+  return $result.try$(
+    (() => {
+      let _pipe = $yay.parse_string(content);
+      return $result.map_error(
+        _pipe,
+        (e) => { return yaml_error_to_skill_error(file, e); },
+      );
+    })(),
+    (docs) => {
+      if (docs instanceof $Empty) {
+        return new Error(new ParseError(file, "Empty YAML document"));
+      } else {
+        let first = docs.head;
+        return new Ok($yay.document_root(first));
+      }
+    },
+  );
+}

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

@@ -0,0 +1,52 @@
+import * as $list from "../../gleam_stdlib/gleam/list.mjs";
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import { Ok, toList, Empty as $Empty, isEqual } from "../gleam.mjs";
+
+export function normalize_separators(path) {
+  return $string.replace(path, "\\", "/");
+}
+
+export function parent_dir(path) {
+  let path$1 = normalize_separators(path);
+  let $ = (() => {
+    let _pipe = $string.split(path$1, "/");
+    return $list.reverse(_pipe);
+  })();
+  if ($ instanceof $Empty) {
+    return ".";
+  } else {
+    let rest = $.tail;
+    if (!isEqual(rest, toList([]))) {
+      let $1 = $string.join($list.reverse(rest), "/");
+      if ($1 === "") {
+        return "/";
+      } else {
+        return $1;
+      }
+    } else {
+      return ".";
+    }
+  }
+}
+
+export function basename(path) {
+  let path$1 = normalize_separators(path);
+  let _block;
+  let $ = $string.ends_with(path$1, "/");
+  if ($) {
+    _block = $string.drop_end(path$1, 1);
+  } else {
+    _block = path$1;
+  }
+  let trimmed = _block;
+  let $1 = (() => {
+    let _pipe = $string.split(trimmed, "/");
+    return $list.last(_pipe);
+  })();
+  if ($1 instanceof Ok) {
+    let name = $1[0];
+    return name;
+  } else {
+    return trimmed;
+  }
+}

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

@@ -0,0 +1,44 @@
+import { CustomType as $CustomType } from "../gleam.mjs";
+import { platform_string, tmpdir } from "../skillc_ffi.mjs";
+
+export { tmpdir };
+
+export class Windows extends $CustomType {}
+export const Platform$Windows = () => new Windows();
+export const Platform$isWindows = (value) => value instanceof Windows;
+
+export class Linux extends $CustomType {}
+export const Platform$Linux = () => new Linux();
+export const Platform$isLinux = (value) => value instanceof Linux;
+
+export class MacOS extends $CustomType {}
+export const Platform$MacOS = () => new MacOS();
+export const Platform$isMacOS = (value) => value instanceof MacOS;
+
+export class Other extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Platform$Other = ($0) => new Other($0);
+export const Platform$isOther = (value) => value instanceof Other;
+export const Platform$Other$0 = (value) => value[0];
+
+export function detect() {
+  let $ = platform_string();
+  if ($ === "win32") {
+    return new Windows();
+  } else if ($ === "linux") {
+    return new Linux();
+  } else if ($ === "darwin") {
+    return new MacOS();
+  } else {
+    let other = $;
+    return new Other(other);
+  }
+}
+
+export function is_windows() {
+  return detect() instanceof Windows;
+}

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

@@ -0,0 +1,86 @@
+import * as $list from "../../gleam_stdlib/gleam/list.mjs";
+import * as $result from "../../gleam_stdlib/gleam/result.mjs";
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import * as $simplifile from "../../simplifile/simplifile.mjs";
+import { Ok, Error, toList } from "../gleam.mjs";
+import * as $error from "../skillc/error.mjs";
+import { FileError, ProviderError } from "../skillc/error.mjs";
+import * as $types from "../skillc/types.mjs";
+
+export function discover_providers(skill_dir) {
+  let providers_dir = skill_dir + "/providers";
+  let $ = $simplifile.is_directory(providers_dir);
+  if ($ instanceof Ok) {
+    let $1 = $[0];
+    if ($1) {
+      return $result.try$(
+        (() => {
+          let _pipe = $simplifile.read_directory(providers_dir);
+          return $result.map_error(
+            _pipe,
+            (e) => { return new FileError(providers_dir, e); },
+          );
+        })(),
+        (entries) => {
+          let _block;
+          let _pipe = $list.filter(
+            entries,
+            (entry) => {
+              let metadata_path = ((providers_dir + "/") + entry) + "/metadata.yaml";
+              let $2 = $simplifile.is_file(metadata_path);
+              if ($2 instanceof Ok) {
+                let $3 = $2[0];
+                if ($3) {
+                  return true;
+                } else {
+                  return false;
+                }
+              } else {
+                return false;
+              }
+            },
+          );
+          let _pipe$1 = $list.sort(_pipe, $string.compare);
+          _block = $list.filter_map(_pipe$1, $types.provider_from_string);
+          let providers = _block;
+          return new Ok(providers);
+        },
+      );
+    } else {
+      return new Ok(toList([]));
+    }
+  } else {
+    return new Ok(toList([]));
+  }
+}
+
+export function is_supported(skill_dir, provider) {
+  let provider_name = $types.provider_to_string(provider);
+  let metadata_path = ((skill_dir + "/providers/") + provider_name) + "/metadata.yaml";
+  let $ = $simplifile.is_file(metadata_path);
+  if ($ instanceof Ok) {
+    let $1 = $[0];
+    if ($1) {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+
+export function validate_provider(skill_dir, provider) {
+  let provider_name = $types.provider_to_string(provider);
+  let $ = is_supported(skill_dir, provider);
+  if ($) {
+    return new Ok(undefined);
+  } else {
+    return new Error(
+      new ProviderError(
+        provider_name,
+        ("Provider '" + provider_name) + "' is not supported by this skill",
+      ),
+    );
+  }
+}