skill-universe 1.1.0

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

@@ -0,0 +1,117 @@
+import * as $simplifile from "../../simplifile/simplifile.mjs";
+import { Ok, Error } from "../gleam.mjs";
+import * as $error from "../skillc/error.mjs";
+import { FileError, ValidationError } from "../skillc/error.mjs";
+
+function try_write_dir(path, next) {
+  let $ = $simplifile.create_directory_all(path);
+  if ($ instanceof Ok) {
+    return next(undefined);
+  } else {
+    let e = $[0];
+    return new Error(new FileError(path, e));
+  }
+}
+
+function try_write_file(path, content, next) {
+  let $ = $simplifile.write(path, content);
+  if ($ instanceof Ok) {
+    return next(undefined);
+  } else {
+    let e = $[0];
+    return new Error(new FileError(path, e));
+  }
+}
+
+function skill_yaml_template(name) {
+  return ("name: " + name) + "\ndescription: Describe what this skill does\nversion: 0.1.0\n\nmetadata:\n  author: Your Name\n  tags: []\n\ndependencies: []\n\nconfig: []\n";
+}
+
+function instructions_template() {
+  return "# {{name}} v{{version}}\n\n{{description}}\n\n## When to Use\n\nDescribe when this skill should be triggered.\n\n## Steps\n\n1. Step one\n2. Step two\n";
+}
+
+function openclaw_metadata_template() {
+  return "emoji: \"\"\ncategory: general\n";
+}
+
+function claude_code_metadata_template() {
+  return "user-invocable: true\n";
+}
+
+function codex_metadata_template() {
+  return "interface:\n  display_name: \"\"\n  short_description: \"\"\n";
+}
+
+function do_init(skill_dir, name) {
+  return try_write_dir(
+    skill_dir,
+    (_) => {
+      return try_write_dir(
+        skill_dir + "/providers",
+        (_) => {
+          return try_write_dir(
+            skill_dir + "/providers/openclaw",
+            (_) => {
+              return try_write_dir(
+                skill_dir + "/providers/claude-code",
+                (_) => {
+                  return try_write_dir(
+                    skill_dir + "/providers/codex",
+                    (_) => {
+                      return try_write_file(
+                        skill_dir + "/skill.yaml",
+                        skill_yaml_template(name),
+                        (_) => {
+                          return try_write_file(
+                            skill_dir + "/INSTRUCTIONS.md",
+                            instructions_template(),
+                            (_) => {
+                              return try_write_file(
+                                skill_dir + "/providers/openclaw/metadata.yaml",
+                                openclaw_metadata_template(),
+                                (_) => {
+                                  return try_write_file(
+                                    skill_dir + "/providers/claude-code/metadata.yaml",
+                                    claude_code_metadata_template(),
+                                    (_) => {
+                                      return try_write_file(
+                                        skill_dir + "/providers/codex/metadata.yaml",
+                                        codex_metadata_template(),
+                                        (_) => { return new Ok(undefined); },
+                                      );
+                                    },
+                                  );
+                                },
+                              );
+                            },
+                          );
+                        },
+                      );
+                    },
+                  );
+                },
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+export function init_skill(skill_dir, name) {
+  let $ = $simplifile.is_file(skill_dir + "/skill.yaml");
+  if ($ instanceof Ok) {
+    let $1 = $[0];
+    if ($1) {
+      return new Error(
+        new ValidationError("init", "skill.yaml already exists in " + skill_dir),
+      );
+    } else {
+      return do_init(skill_dir, name);
+    }
+  } else {
+    return do_init(skill_dir, name);
+  }
+}

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

@@ -0,0 +1,293 @@
+import * as $int from "../../gleam_stdlib/gleam/int.mjs";
+import * as $option from "../../gleam_stdlib/gleam/option.mjs";
+import { None, Some } from "../../gleam_stdlib/gleam/option.mjs";
+import * as $order from "../../gleam_stdlib/gleam/order.mjs";
+import * as $result from "../../gleam_stdlib/gleam/result.mjs";
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import { Ok, Error, Empty as $Empty, CustomType as $CustomType, makeError } from "../gleam.mjs";
+import * as $error from "../skillc/error.mjs";
+import { ValidationError } from "../skillc/error.mjs";
+
+const FILEPATH = "src/skillc/semver.gleam";
+
+class SemVer extends $CustomType {
+  constructor(major, minor, patch, prerelease, build) {
+    super();
+    this.major = major;
+    this.minor = minor;
+    this.patch = patch;
+    this.prerelease = prerelease;
+    this.build = build;
+  }
+}
+
+export function new$(major, minor, patch) {
+  let $ = major >= 0;
+  let $1 = minor >= 0;
+  let $2 = patch >= 0;
+  if ($ && $1 && $2) {
+    return new Ok(new SemVer(major, minor, patch, new None(), new None()));
+  } else {
+    return new Error(
+      new ValidationError("version", "SemVer components must be non-negative"),
+    );
+  }
+}
+
+export function prerelease(ver) {
+  return ver.prerelease;
+}
+
+export function to_string(ver) {
+  let base = ((($int.to_string(ver.major) + ".") + $int.to_string(ver.minor)) + ".") + $int.to_string(
+    ver.patch,
+  );
+  let _block;
+  let $ = ver.prerelease;
+  if ($ instanceof Some) {
+    let pre = $[0];
+    _block = (base + "-") + pre;
+  } else {
+    _block = base;
+  }
+  let with_pre = _block;
+  let $1 = ver.build;
+  if ($1 instanceof Some) {
+    let b = $1[0];
+    return (with_pre + "+") + b;
+  } else {
+    return with_pre;
+  }
+}
+
+export function major(ver) {
+  return ver.major;
+}
+
+export function minor(ver) {
+  return ver.minor;
+}
+
+export function patch(ver) {
+  return ver.patch;
+}
+
+function compare_prerelease(a, b) {
+  if (a instanceof Some) {
+    if (b instanceof Some) {
+      let pa = a[0];
+      let pb = b[0];
+      return $string.compare(pa, pb);
+    } else {
+      return new $order.Lt();
+    }
+  } else if (b instanceof Some) {
+    return new $order.Gt();
+  } else {
+    return new $order.Eq();
+  }
+}
+
+export function compare(a, b) {
+  let $ = $int.compare(a.major, b.major);
+  if ($ instanceof $order.Eq) {
+    let $1 = $int.compare(a.minor, b.minor);
+    if ($1 instanceof $order.Eq) {
+      let $2 = $int.compare(a.patch, b.patch);
+      if ($2 instanceof $order.Eq) {
+        return compare_prerelease(a.prerelease, b.prerelease);
+      } else {
+        return $2;
+      }
+    } else {
+      return $1;
+    }
+  } else {
+    return $;
+  }
+}
+
+function return_semver_error(version) {
+  return new Error(
+    new ValidationError("version", "Invalid semver format: " + version),
+  );
+}
+
+function is_valid_semver_number(s) {
+  if (s === "") {
+    return false;
+  } else if (s === "0") {
+    return true;
+  } else {
+    return (!$string.starts_with(s, "0") && !$string.starts_with(s, "-")) && $result.is_ok(
+      $int.parse(s),
+    );
+  }
+}
+
+export function parse(version) {
+  let _block;
+  let $1 = $string.split_once(version, "+");
+  if ($1 instanceof Ok) {
+    let before = $1[0][0];
+    let after = $1[0][1];
+    if (after === "") {
+      _block = [new Error(undefined), new None()];
+    } else {
+      _block = [new Ok(before), new Some(after)];
+    }
+  } else {
+    _block = [new Ok(version), new None()];
+  }
+  let $ = _block;
+  let without_build;
+  let build;
+  without_build = $[0];
+  build = $[1];
+  return $result.try$(
+    (() => {
+      let _pipe = without_build;
+      return $result.map_error(
+        _pipe,
+        (_) => {
+          return new ValidationError(
+            "version",
+            "Invalid semver format: " + version,
+          );
+        },
+      );
+    })(),
+    (without_build) => {
+      let _block$1;
+      let $3 = $string.split_once(without_build, "-");
+      if ($3 instanceof Ok) {
+        let before = $3[0][0];
+        let after = $3[0][1];
+        if (after === "") {
+          _block$1 = [new Error(undefined), new None()];
+        } else {
+          _block$1 = [new Ok(before), new Some(after)];
+        }
+      } else {
+        _block$1 = [new Ok(without_build), new None()];
+      }
+      let $2 = _block$1;
+      let base;
+      let prerelease$1;
+      base = $2[0];
+      prerelease$1 = $2[1];
+      return $result.try$(
+        (() => {
+          let _pipe = base;
+          return $result.map_error(
+            _pipe,
+            (_) => {
+              return new ValidationError(
+                "version",
+                "Invalid semver format: " + version,
+              );
+            },
+          );
+        })(),
+        (base) => {
+          let parts = $string.split(base, ".");
+          if (parts instanceof $Empty) {
+            return return_semver_error(version);
+          } else {
+            let $4 = parts.tail;
+            if ($4 instanceof $Empty) {
+              return return_semver_error(version);
+            } else {
+              let $5 = $4.tail;
+              if ($5 instanceof $Empty) {
+                return return_semver_error(version);
+              } else {
+                let $6 = $5.tail;
+                if ($6 instanceof $Empty) {
+                  let major_s = parts.head;
+                  let minor_s = $4.head;
+                  let patch_s = $5.head;
+                  let $7 = is_valid_semver_number(major_s);
+                  let $8 = is_valid_semver_number(minor_s);
+                  let $9 = is_valid_semver_number(patch_s);
+                  if ($7 && $8 && $9) {
+                    let $10 = $int.parse(major_s);
+                    let major$1;
+                    if ($10 instanceof Ok) {
+                      major$1 = $10[0];
+                    } else {
+                      throw makeError(
+                        "let_assert",
+                        FILEPATH,
+                        "skillc/semver",
+                        78,
+                        "parse",
+                        "Pattern match failed, no pattern matched the value.",
+                        {
+                          value: $10,
+                          start: 2067,
+                          end: 2108,
+                          pattern_start: 2078,
+                          pattern_end: 2087
+                        }
+                      )
+                    }
+                    let $11 = $int.parse(minor_s);
+                    let minor$1;
+                    if ($11 instanceof Ok) {
+                      minor$1 = $11[0];
+                    } else {
+                      throw makeError(
+                        "let_assert",
+                        FILEPATH,
+                        "skillc/semver",
+                        79,
+                        "parse",
+                        "Pattern match failed, no pattern matched the value.",
+                        {
+                          value: $11,
+                          start: 2119,
+                          end: 2160,
+                          pattern_start: 2130,
+                          pattern_end: 2139
+                        }
+                      )
+                    }
+                    let $12 = $int.parse(patch_s);
+                    let patch$1;
+                    if ($12 instanceof Ok) {
+                      patch$1 = $12[0];
+                    } else {
+                      throw makeError(
+                        "let_assert",
+                        FILEPATH,
+                        "skillc/semver",
+                        80,
+                        "parse",
+                        "Pattern match failed, no pattern matched the value.",
+                        {
+                          value: $12,
+                          start: 2171,
+                          end: 2212,
+                          pattern_start: 2182,
+                          pattern_end: 2191
+                        }
+                      )
+                    }
+                    return new Ok(
+                      new SemVer(major$1, minor$1, patch$1, prerelease$1, build),
+                    );
+                  } else {
+                    return return_semver_error(version);
+                  }
+                } else {
+                  return return_semver_error(version);
+                }
+              }
+            }
+          }
+        },
+      );
+    },
+  );
+}

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

@@ -0,0 +1,14 @@
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import * as $platform from "../skillc/platform.mjs";
+import { exec } from "../skillc_ffi.mjs";
+
+export { exec };
+
+export function quote(s) {
+  let $ = $platform.is_windows();
+  if ($) {
+    return ("\"" + $string.replace(s, "\"", "\\\"")) + "\"";
+  } else {
+    return ("'" + $string.replace(s, "'", "'\\''")) + "'";
+  }
+}