skill-universe 1.1.0

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

@@ -0,0 +1,172 @@
+import * as $list from "../../gleam_stdlib/gleam/list.mjs";
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import { Ok, Empty as $Empty, CustomType as $CustomType } from "../gleam.mjs";
+import * as $types from "../skillc/types.mjs";
+import { Optional, OptionalWithDefault, Required } from "../skillc/types.mjs";
+import { get_env } from "../skillc_ffi.mjs";
+
+export class Provided extends $CustomType {
+  constructor(field, value) {
+    super();
+    this.field = field;
+    this.value = value;
+  }
+}
+export const ConfigStatus$Provided = (field, value) =>
+  new Provided(field, value);
+export const ConfigStatus$isProvided = (value) => value instanceof Provided;
+export const ConfigStatus$Provided$field = (value) => value.field;
+export const ConfigStatus$Provided$0 = (value) => value.field;
+export const ConfigStatus$Provided$value = (value) => value.value;
+export const ConfigStatus$Provided$1 = (value) => value.value;
+
+export class MissingRequired extends $CustomType {
+  constructor(field) {
+    super();
+    this.field = field;
+  }
+}
+export const ConfigStatus$MissingRequired = (field) =>
+  new MissingRequired(field);
+export const ConfigStatus$isMissingRequired = (value) =>
+  value instanceof MissingRequired;
+export const ConfigStatus$MissingRequired$field = (value) => value.field;
+export const ConfigStatus$MissingRequired$0 = (value) => value.field;
+
+export class DefaultUsed extends $CustomType {
+  constructor(field, default$) {
+    super();
+    this.field = field;
+    this.default = default$;
+  }
+}
+export const ConfigStatus$DefaultUsed = (field, default$) =>
+  new DefaultUsed(field, default$);
+export const ConfigStatus$isDefaultUsed = (value) =>
+  value instanceof DefaultUsed;
+export const ConfigStatus$DefaultUsed$field = (value) => value.field;
+export const ConfigStatus$DefaultUsed$0 = (value) => value.field;
+export const ConfigStatus$DefaultUsed$default = (value) => value.default;
+export const ConfigStatus$DefaultUsed$1 = (value) => value.default;
+
+export class Skipped extends $CustomType {
+  constructor(field) {
+    super();
+    this.field = field;
+  }
+}
+export const ConfigStatus$Skipped = (field) => new Skipped(field);
+export const ConfigStatus$isSkipped = (value) => value instanceof Skipped;
+export const ConfigStatus$Skipped$field = (value) => value.field;
+export const ConfigStatus$Skipped$0 = (value) => value.field;
+
+export const ConfigStatus$field = (value) => value.field;
+
+function to_upper_snake(s) {
+  let _pipe = s;
+  let _pipe$1 = $string.replace(_pipe, "-", "_");
+  let _pipe$2 = $string.replace(_pipe$1, ".", "_");
+  return $string.uppercase(_pipe$2);
+}
+
+function config_env_name(skill_name, field_name) {
+  return (("SKILL_CONFIG_" + to_upper_snake(skill_name)) + "_") + to_upper_snake(
+    field_name,
+  );
+}
+
+/**
+ * Generate a .env-format template for a skill's configuration fields.
+ */
+export function generate_template(skill) {
+  let $ = skill.config;
+  if ($ instanceof $Empty) {
+    return ("# No configuration fields defined for " + skill.name) + "\n";
+  } else {
+    let fields = $;
+    let header = (("# Configuration for " + skill.name) + "\n") + "# Set these environment variables before using the skill.\n\n";
+    let lines = $list.map(
+      fields,
+      (field) => {
+        let comment = ("# " + field.description) + "\n";
+        let _block;
+        let $1 = field.requirement;
+        if ($1 instanceof Required) {
+          _block = "# Required\n";
+        } else if ($1 instanceof Optional) {
+          _block = "# Optional\n";
+        } else {
+          let d = $1[0];
+          _block = ("# Optional (default: " + d) + ")\n";
+        }
+        let req_comment = _block;
+        let _block$1;
+        let $2 = field.secret;
+        if ($2) {
+          _block$1 = "# Secret: yes\n";
+        } else {
+          _block$1 = "";
+        }
+        let secret_comment = _block$1;
+        let env_name = config_env_name(skill.name, field.name);
+        let _block$2;
+        let $3 = field.requirement;
+        if ($3 instanceof OptionalWithDefault) {
+          let d = $3[0];
+          _block$2 = d;
+        } else {
+          _block$2 = "";
+        }
+        let default_value = _block$2;
+        return (((((comment + req_comment) + secret_comment) + env_name) + "=") + default_value) + "\n";
+      },
+    );
+    return header + $string.join(lines, "\n");
+  }
+}
+
+/**
+ * Check configuration status using an injectable lookup function.
+ */
+export function check_with_lookup(skill, lookup) {
+  return $list.map(
+    skill.config,
+    (field) => {
+      let env_name = config_env_name(skill.name, field.name);
+      let $ = lookup(env_name);
+      if ($ instanceof Ok) {
+        let value = $[0];
+        if (value !== "") {
+          return new Provided(field, value);
+        } else {
+          let $1 = field.requirement;
+          if ($1 instanceof Required) {
+            return new MissingRequired(field);
+          } else if ($1 instanceof Optional) {
+            return new Skipped(field);
+          } else {
+            let d = $1[0];
+            return new DefaultUsed(field, d);
+          }
+        }
+      } else {
+        let $1 = field.requirement;
+        if ($1 instanceof Required) {
+          return new MissingRequired(field);
+        } else if ($1 instanceof Optional) {
+          return new Skipped(field);
+        } else {
+          let d = $1[0];
+          return new DefaultUsed(field, d);
+        }
+      }
+    },
+  );
+}
+
+/**
+ * Check configuration status using real environment variables.
+ */
+export function check(skill) {
+  return check_with_lookup(skill, get_env);
+}

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

@@ -0,0 +1,145 @@
+import * as $int from "../../gleam_stdlib/gleam/int.mjs";
+import * as $result from "../../gleam_stdlib/gleam/result.mjs";
+import * as $simplifile from "../../simplifile/simplifile.mjs";
+import { CustomType as $CustomType } from "../gleam.mjs";
+
+export class ParseError extends $CustomType {
+  constructor(file, message) {
+    super();
+    this.file = file;
+    this.message = message;
+  }
+}
+export const SkillError$ParseError = (file, message) =>
+  new ParseError(file, message);
+export const SkillError$isParseError = (value) => value instanceof ParseError;
+export const SkillError$ParseError$file = (value) => value.file;
+export const SkillError$ParseError$0 = (value) => value.file;
+export const SkillError$ParseError$message = (value) => value.message;
+export const SkillError$ParseError$1 = (value) => value.message;
+
+export class ValidationError extends $CustomType {
+  constructor(field, message) {
+    super();
+    this.field = field;
+    this.message = message;
+  }
+}
+export const SkillError$ValidationError = (field, message) =>
+  new ValidationError(field, message);
+export const SkillError$isValidationError = (value) =>
+  value instanceof ValidationError;
+export const SkillError$ValidationError$field = (value) => value.field;
+export const SkillError$ValidationError$0 = (value) => value.field;
+export const SkillError$ValidationError$message = (value) => value.message;
+export const SkillError$ValidationError$1 = (value) => value.message;
+
+export class TemplateError extends $CustomType {
+  constructor(line, message) {
+    super();
+    this.line = line;
+    this.message = message;
+  }
+}
+export const SkillError$TemplateError = (line, message) =>
+  new TemplateError(line, message);
+export const SkillError$isTemplateError = (value) =>
+  value instanceof TemplateError;
+export const SkillError$TemplateError$line = (value) => value.line;
+export const SkillError$TemplateError$0 = (value) => value.line;
+export const SkillError$TemplateError$message = (value) => value.message;
+export const SkillError$TemplateError$1 = (value) => value.message;
+
+export class ProviderError extends $CustomType {
+  constructor(provider, message) {
+    super();
+    this.provider = provider;
+    this.message = message;
+  }
+}
+export const SkillError$ProviderError = (provider, message) =>
+  new ProviderError(provider, message);
+export const SkillError$isProviderError = (value) =>
+  value instanceof ProviderError;
+export const SkillError$ProviderError$provider = (value) => value.provider;
+export const SkillError$ProviderError$0 = (value) => value.provider;
+export const SkillError$ProviderError$message = (value) => value.message;
+export const SkillError$ProviderError$1 = (value) => value.message;
+
+export class FileError extends $CustomType {
+  constructor(path, error) {
+    super();
+    this.path = path;
+    this.error = error;
+  }
+}
+export const SkillError$FileError = (path, error) => new FileError(path, error);
+export const SkillError$isFileError = (value) => value instanceof FileError;
+export const SkillError$FileError$path = (value) => value.path;
+export const SkillError$FileError$0 = (value) => value.path;
+export const SkillError$FileError$error = (value) => value.error;
+export const SkillError$FileError$1 = (value) => value.error;
+
+export class RegistryError extends $CustomType {
+  constructor(message) {
+    super();
+    this.message = message;
+  }
+}
+export const SkillError$RegistryError = (message) => new RegistryError(message);
+export const SkillError$isRegistryError = (value) =>
+  value instanceof RegistryError;
+export const SkillError$RegistryError$message = (value) => value.message;
+export const SkillError$RegistryError$0 = (value) => value.message;
+
+export class ImportError extends $CustomType {
+  constructor(source, message) {
+    super();
+    this.source = source;
+    this.message = message;
+  }
+}
+export const SkillError$ImportError = (source, message) =>
+  new ImportError(source, message);
+export const SkillError$isImportError = (value) => value instanceof ImportError;
+export const SkillError$ImportError$source = (value) => value.source;
+export const SkillError$ImportError$0 = (value) => value.source;
+export const SkillError$ImportError$message = (value) => value.message;
+export const SkillError$ImportError$1 = (value) => value.message;
+
+export function to_string(error) {
+  if (error instanceof ParseError) {
+    let file = error.file;
+    let message = error.message;
+    return (("Parse error in " + file) + ": ") + message;
+  } else if (error instanceof ValidationError) {
+    let field = error.field;
+    let message = error.message;
+    return (("Validation error for field '" + field) + "': ") + message;
+  } else if (error instanceof TemplateError) {
+    let line = error.line;
+    let message = error.message;
+    return (("Template error at line " + $int.to_string(line)) + ": ") + message;
+  } else if (error instanceof ProviderError) {
+    let provider = error.provider;
+    let message = error.message;
+    return (("Provider error (" + provider) + "): ") + message;
+  } else if (error instanceof FileError) {
+    let path = error.path;
+    let error$1 = error.error;
+    return (("File error at " + path) + ": ") + $simplifile.describe_error(
+      error$1,
+    );
+  } else if (error instanceof RegistryError) {
+    let message = error.message;
+    return "Registry error: " + message;
+  } else {
+    let source = error.source;
+    let message = error.message;
+    return (("Import error (" + source) + "): ") + message;
+  }
+}
+
+export function map_file_error(result, path) {
+  return $result.map_error(result, (e) => { return new FileError(path, e); });
+}

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

@@ -0,0 +1,40 @@
+import * as $list from "../../gleam_stdlib/gleam/list.mjs";
+import * as $result from "../../gleam_stdlib/gleam/result.mjs";
+import * as $simplifile from "../../simplifile/simplifile.mjs";
+import { Ok, Empty as $Empty } from "../gleam.mjs";
+import * as $error from "../skillc/error.mjs";
+import { map_file_error } from "../skillc/error.mjs";
+import * as $path from "../skillc/path.mjs";
+import * as $types from "../skillc/types.mjs";
+
+export function copy_file_list(files, dest_dir) {
+  if (files instanceof $Empty) {
+    return new Ok(undefined);
+  } else {
+    return $result.try$(
+      (() => {
+        let _pipe = $simplifile.create_directory_all(dest_dir);
+        return map_file_error(_pipe, dest_dir);
+      })(),
+      (_) => {
+        return $list.try_each(
+          files,
+          (f) => {
+            let dest = (dest_dir + "/") + f.relative_path;
+            let parent = $path.parent_dir(dest);
+            return $result.try$(
+              (() => {
+                let _pipe = $simplifile.create_directory_all(parent);
+                return map_file_error(_pipe, parent);
+              })(),
+              (_) => {
+                let _pipe = $simplifile.copy_file(f.src, dest);
+                return map_file_error(_pipe, f.src);
+              },
+            );
+          },
+        );
+      },
+    );
+  }
+}