skill-universe 1.1.0

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

@@ -0,0 +1,724 @@
+import * as $float from "../../gleam_stdlib/gleam/float.mjs";
+import * as $int from "../../gleam_stdlib/gleam/int.mjs";
+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 $set from "../../gleam_stdlib/gleam/set.mjs";
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import * as $simplifile from "../../simplifile/simplifile.mjs";
+import * as $yay from "../../yay/yay.mjs";
+import {
+  Ok,
+  Error,
+  toList,
+  Empty as $Empty,
+  prepend as listPrepend,
+  CustomType as $CustomType,
+} from "../gleam.mjs";
+import * as $error from "../skillc/error.mjs";
+import { ProviderError, map_file_error } from "../skillc/error.mjs";
+import * as $fs from "../skillc/fs.mjs";
+import * as $parser from "../skillc/parser.mjs";
+import * as $provider from "../skillc/provider.mjs";
+import * as $semver from "../skillc/semver.mjs";
+import * as $template from "../skillc/template.mjs";
+import * as $types from "../skillc/types.mjs";
+import {
+  ClaudeCode,
+  Codex,
+  CompiledSkill,
+  FileCopy,
+  FrontmatterInInstructions,
+  MissingDependency,
+  OpenClaw,
+} from "../skillc/types.mjs";
+import * as $yaml from "../skillc/yaml.mjs";
+
+class FrontmatterData extends $CustomType {
+  constructor(lines, extra_pairs) {
+    super();
+    this.lines = lines;
+    this.extra_pairs = extra_pairs;
+  }
+}
+
+class Scripts extends $CustomType {}
+
+class Assets extends $CustomType {}
+
+function file_category_to_string(category) {
+  if (category instanceof Scripts) {
+    return "scripts";
+  } else {
+    return "assets";
+  }
+}
+
+function read_shared_inputs(skill_dir) {
+  return $result.try$(
+    (() => {
+      let _pipe = $simplifile.read(skill_dir + "/skill.yaml");
+      return map_file_error(_pipe, skill_dir + "/skill.yaml");
+    })(),
+    (skill_content) => {
+      return $result.try$(
+        $parser.parse_skill_yaml(skill_content),
+        (skill) => {
+          return $result.try$(
+            (() => {
+              let _pipe = $simplifile.read(skill_dir + "/INSTRUCTIONS.md");
+              return map_file_error(_pipe, skill_dir + "/INSTRUCTIONS.md");
+            })(),
+            (instructions_content) => {
+              return new Ok([skill, instructions_content]);
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+export function emit(compiled, output_dir, skill_name) {
+  let provider_str = $types.provider_to_string(compiled.provider);
+  let _block;
+  let $ = compiled.provider;
+  if ($ instanceof Codex) {
+    _block = (output_dir + "/codex/.agents/skills/") + skill_name;
+  } else {
+    _block = (((output_dir + "/") + provider_str) + "/") + skill_name;
+  }
+  let provider_dir = _block;
+  return $result.try$(
+    (() => {
+      let _pipe = $simplifile.create_directory_all(provider_dir);
+      return map_file_error(_pipe, provider_dir);
+    })(),
+    (_) => {
+      return $result.try$(
+        (() => {
+          let _pipe = $simplifile.write(
+            provider_dir + "/SKILL.md",
+            compiled.skill_md,
+          );
+          return map_file_error(_pipe, provider_dir + "/SKILL.md");
+        })(),
+        (_) => {
+          return $result.try$(
+            (() => {
+              let $1 = compiled.codex_yaml;
+              if ($1 instanceof Some) {
+                let yaml_content = $1[0];
+                let agents_dir = provider_dir + "/agents";
+                return $result.try$(
+                  (() => {
+                    let _pipe = $simplifile.create_directory_all(agents_dir);
+                    return map_file_error(_pipe, agents_dir);
+                  })(),
+                  (_) => {
+                    let _pipe = $simplifile.write(
+                      agents_dir + "/openai.yaml",
+                      yaml_content,
+                    );
+                    return map_file_error(_pipe, agents_dir + "/openai.yaml");
+                  },
+                );
+              } else {
+                return new Ok(undefined);
+              }
+            })(),
+            (_) => {
+              return $result.try$(
+                $fs.copy_file_list(compiled.scripts, provider_dir + "/scripts"),
+                (_) => {
+                  return $result.try$(
+                    $fs.copy_file_list(
+                      compiled.assets,
+                      provider_dir + "/assets",
+                    ),
+                    (_) => { return new Ok(undefined); },
+                  );
+                },
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+function format_codex(skill, body) {
+  let version_str = $semver.to_string(skill.version);
+  let frontmatter_lines = toList([
+    "---",
+    "name: " + $yaml.quote_string(skill.name),
+    "description: " + $yaml.quote_string(skill.description),
+    "version: " + version_str,
+    "---",
+  ]);
+  return ($string.join(frontmatter_lines, "\n") + "\n\n") + body;
+}
+
+function meta_string_or(meta, key, default$) {
+  let $ = $yay.extract_optional_string(meta, key);
+  if ($ instanceof Ok) {
+    let $1 = $[0];
+    if ($1 instanceof Some) {
+      let value = $1[0];
+      return value;
+    } else {
+      return default$;
+    }
+  } else {
+    return default$;
+  }
+}
+
+/**
+ * Build common frontmatter lines and extract remaining provider metadata pairs.
+ * Returns the base frontmatter lines and the non-universal metadata key-value pairs.
+ * 
+ * @ignore
+ */
+function build_base_frontmatter(skill, provider_meta) {
+  let universal_keys = toList(["name", "description", "version"]);
+  let version_str = $semver.to_string(skill.version);
+  let name = meta_string_or(provider_meta, "name", skill.name);
+  let description = meta_string_or(
+    provider_meta,
+    "description",
+    skill.description,
+  );
+  let version = meta_string_or(provider_meta, "version", version_str);
+  let lines = toList([
+    "---",
+    "name: " + $yaml.quote_string(name),
+    "description: " + $yaml.quote_string(description),
+    "version: " + version,
+  ]);
+  let _block;
+  if (provider_meta instanceof $yay.NodeMap) {
+    let pairs = provider_meta[0];
+    _block = $list.filter(
+      pairs,
+      (pair) => {
+        let $ = pair[0];
+        if ($ instanceof $yay.NodeStr) {
+          let key = $[0];
+          return !$list.contains(universal_keys, key);
+        } else {
+          return false;
+        }
+      },
+    );
+  } else {
+    _block = toList([]);
+  }
+  let extra_pairs = _block;
+  return new FrontmatterData(lines, extra_pairs);
+}
+
+function seq_is_simple(items) {
+  return $list.all(
+    items,
+    (item) => {
+      if (item instanceof $yay.NodeNil) {
+        return true;
+      } else if (item instanceof $yay.NodeStr) {
+        return true;
+      } else if (item instanceof $yay.NodeBool) {
+        return true;
+      } else if (item instanceof $yay.NodeInt) {
+        return true;
+      } else if (item instanceof $yay.NodeFloat) {
+        return true;
+      } else {
+        return false;
+      }
+    },
+  );
+}
+
+function dependency_exists(dep_name, output_dir) {
+  let $ = $simplifile.read_directory(output_dir);
+  if ($ instanceof Ok) {
+    let entries = $[0];
+    return $list.any(
+      entries,
+      (provider_dir) => {
+        let skill_md_path = ((((output_dir + "/") + provider_dir) + "/") + dep_name) + "/SKILL.md";
+        let $1 = $simplifile.is_file(skill_md_path);
+        if ($1 instanceof Ok) {
+          let $2 = $1[0];
+          if ($2) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      },
+    );
+  } else {
+    return false;
+  }
+}
+
+export function check_dependencies(skill, output_dir) {
+  return $list.filter_map(
+    skill.dependencies,
+    (dep) => {
+      let $ = dep.optional;
+      if ($) {
+        return new Error(undefined);
+      } else {
+        let $1 = dependency_exists(dep.name, output_dir);
+        if ($1) {
+          return new Error(undefined);
+        } else {
+          return new Ok(new MissingDependency(dep));
+        }
+      }
+    },
+  );
+}
+
+function merge_file_lists(shared, provider) {
+  let provider_paths = $set.from_list(
+    $list.map(provider, (f) => { return f.relative_path; }),
+  );
+  let filtered_shared = $list.filter(
+    shared,
+    (f) => { return !$set.contains(provider_paths, f.relative_path); },
+  );
+  return $list.append(filtered_shared, provider);
+}
+
+function collect_files(skill_dir, provider_str, category) {
+  let dir_name = file_category_to_string(category);
+  let shared_dir = (skill_dir + "/") + dir_name;
+  let provider_dir = (((skill_dir + "/providers/") + provider_str) + "/") + dir_name;
+  let _block;
+  let $ = $simplifile.get_files(shared_dir);
+  if ($ instanceof Ok) {
+    let files = $[0];
+    _block = $list.map(
+      files,
+      (f) => {
+        let relative = $string.replace(f, shared_dir + "/", "");
+        return new FileCopy(f, relative);
+      },
+    );
+  } else {
+    _block = toList([]);
+  }
+  let shared_files = _block;
+  let _block$1;
+  let $1 = $simplifile.get_files(provider_dir);
+  if ($1 instanceof Ok) {
+    let files = $1[0];
+    _block$1 = $list.map(
+      files,
+      (f) => {
+        let relative = $string.replace(f, provider_dir + "/", "");
+        return new FileCopy(f, relative);
+      },
+    );
+  } else {
+    _block$1 = toList([]);
+  }
+  let provider_files = _block$1;
+  return merge_file_lists(shared_files, provider_files);
+}
+
+function serialize_yaml_seq(items, indent) {
+  let prefix = $string.repeat(" ", indent);
+  let lines = $list.map(
+    items,
+    (item) => {
+      if (item instanceof $yay.NodeMap) {
+        let pairs = item[0];
+        let pair_lines = format_yaml_pairs(pairs, indent + 4, "");
+        if (pair_lines instanceof $Empty) {
+          return prefix + "- {}";
+        } else {
+          let first = pair_lines.head;
+          let rest = pair_lines.tail;
+          return ((prefix + "- ") + first) + $string.join(
+            $list.map(
+              rest,
+              (line) => { return (("\n" + prefix) + "  ") + line; },
+            ),
+            "",
+          );
+        }
+      } else {
+        return (prefix + "- ") + node_to_yaml_value(item, indent + 2);
+      }
+    },
+  );
+  return "\n" + $string.join(lines, "\n");
+}
+
+function format_yaml_pairs(pairs, indent, prefix) {
+  return $list.filter_map(
+    pairs,
+    (pair) => {
+      let $ = pair[0];
+      if ($ instanceof $yay.NodeStr) {
+        let value = pair[1];
+        let key = $[0];
+        let val = node_to_yaml_value(value, indent);
+        let $1 = $string.starts_with(val, "\n");
+        if ($1) {
+          return new Ok(((prefix + key) + ":") + val);
+        } else {
+          return new Ok(((prefix + key) + ": ") + val);
+        }
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+function node_to_yaml_value(node, indent) {
+  if (node instanceof $yay.NodeNil) {
+    return "null";
+  } else if (node instanceof $yay.NodeStr) {
+    let s = node[0];
+    return $yaml.quote_string(s);
+  } else if (node instanceof $yay.NodeBool) {
+    let $ = node[0];
+    if ($) {
+      return "true";
+    } else {
+      return "false";
+    }
+  } else if (node instanceof $yay.NodeInt) {
+    let i = node[0];
+    return $int.to_string(i);
+  } else if (node instanceof $yay.NodeFloat) {
+    let f = node[0];
+    return $float.to_string(f);
+  } else if (node instanceof $yay.NodeSeq) {
+    let items = node[0];
+    let $ = seq_is_simple(items);
+    if ($) {
+      return ("[" + $string.join(
+        $list.map(items, (i) => { return node_to_yaml_value(i, indent); }),
+        ", ",
+      )) + "]";
+    } else {
+      return serialize_yaml_seq(items, indent);
+    }
+  } else {
+    let pairs = node[0];
+    return serialize_yaml_map(pairs, indent);
+  }
+}
+
+function format_openclaw(skill, provider_meta, body) {
+  let $ = build_base_frontmatter(skill, provider_meta);
+  let base_lines;
+  let extra_pairs;
+  base_lines = $.lines;
+  extra_pairs = $.extra_pairs;
+  let _block;
+  let $1 = skill.license;
+  if ($1 instanceof Some) {
+    let l = $1[0];
+    _block = $list.append(base_lines, toList(["license: " + l]));
+  } else {
+    _block = base_lines;
+  }
+  let frontmatter_lines = _block;
+  let _block$1;
+  if (extra_pairs instanceof $Empty) {
+    _block$1 = extra_pairs;
+  } else {
+    let pairs = extra_pairs;
+    let openclaw_lines = format_yaml_pairs(pairs, 4, "  ");
+    _block$1 = listPrepend("metadata.openclaw:", openclaw_lines);
+  }
+  let meta_lines = _block$1;
+  let all_lines = $list.flatten(
+    toList([frontmatter_lines, meta_lines, toList(["---"])]),
+  );
+  return ($string.join(all_lines, "\n") + "\n\n") + body;
+}
+
+function format_claude_code(skill, provider_meta, body) {
+  let $ = build_base_frontmatter(skill, provider_meta);
+  let frontmatter_lines;
+  let extra_pairs;
+  frontmatter_lines = $.lines;
+  extra_pairs = $.extra_pairs;
+  let meta_lines = format_yaml_pairs(extra_pairs, 2, "");
+  let all_lines = $list.flatten(
+    toList([frontmatter_lines, meta_lines, toList(["---"])]),
+  );
+  return ($string.join(all_lines, "\n") + "\n\n") + body;
+}
+
+function format_skill_md(skill, provider, provider_meta, body) {
+  if (provider instanceof OpenClaw) {
+    return format_openclaw(skill, provider_meta, body);
+  } else if (provider instanceof ClaudeCode) {
+    return format_claude_code(skill, provider_meta, body);
+  } else {
+    return format_codex(skill, body);
+  }
+}
+
+function generate_codex_yaml(provider_meta) {
+  if (provider_meta instanceof $yay.NodeMap) {
+    let pairs = provider_meta[0];
+    let lines = format_yaml_pairs(pairs, 2, "");
+    return $string.join(lines, "\n") + "\n";
+  } else {
+    return "";
+  }
+}
+
+function compile_for_provider(skill_dir, provider, skill, instructions_content) {
+  let provider_str = $types.provider_to_string(provider);
+  return $result.try$(
+    $provider.validate_provider(skill_dir, provider),
+    (_) => {
+      let metadata_path = ((skill_dir + "/providers/") + provider_str) + "/metadata.yaml";
+      return $result.try$(
+        (() => {
+          let _pipe = $simplifile.read(metadata_path);
+          return map_file_error(_pipe, metadata_path);
+        })(),
+        (meta_content) => {
+          return $result.try$(
+            $parser.parse_metadata_yaml(meta_content, provider),
+            (provider_meta) => {
+              let _block;
+              let $ = $parser.has_frontmatter(instructions_content);
+              if ($) {
+                _block = toList([
+                  new FrontmatterInInstructions(skill_dir + "/INSTRUCTIONS.md"),
+                ]);
+              } else {
+                _block = toList([]);
+              }
+              let warnings = _block;
+              return $result.try$(
+                $template.render_template(
+                  instructions_content,
+                  provider,
+                  skill,
+                  provider_meta,
+                ),
+                (rendered_instructions) => {
+                  let provider_instructions_path = ((skill_dir + "/providers/") + provider_str) + "/instructions.md";
+                  return $result.try$(
+                    (() => {
+                      let $1 = $simplifile.read(provider_instructions_path);
+                      if ($1 instanceof Ok) {
+                        let provider_content = $1[0];
+                        return $result.try$(
+                          $template.render_template(
+                            provider_content,
+                            provider,
+                            skill,
+                            provider_meta,
+                          ),
+                          (rendered_provider) => {
+                            return new Ok(
+                              (rendered_instructions + "\n\n") + rendered_provider,
+                            );
+                          },
+                        );
+                      } else {
+                        return new Ok(rendered_instructions);
+                      }
+                    })(),
+                    (rendered_instructions) => {
+                      let skill_md = format_skill_md(
+                        skill,
+                        provider,
+                        provider_meta,
+                        rendered_instructions,
+                      );
+                      let scripts = collect_files(
+                        skill_dir,
+                        provider_str,
+                        new Scripts(),
+                      );
+                      let assets = collect_files(
+                        skill_dir,
+                        provider_str,
+                        new Assets(),
+                      );
+                      let _block$1;
+                      if (provider instanceof Codex) {
+                        _block$1 = new Some(generate_codex_yaml(provider_meta));
+                      } else {
+                        _block$1 = new None();
+                      }
+                      let codex_yaml = _block$1;
+                      return new Ok(
+                        new CompiledSkill(
+                          skill.name,
+                          provider,
+                          skill_md,
+                          scripts,
+                          assets,
+                          warnings,
+                          codex_yaml,
+                        ),
+                      );
+                    },
+                  );
+                },
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+function compile_single(skill_dir, provider) {
+  return $result.try$(
+    (() => {
+      let _pipe = $simplifile.read(skill_dir + "/skill.yaml");
+      return map_file_error(_pipe, skill_dir + "/skill.yaml");
+    })(),
+    (skill_content) => {
+      return $result.try$(
+        $parser.parse_skill_yaml(skill_content),
+        (skill) => {
+          return $result.try$(
+            (() => {
+              let _pipe = $simplifile.read(skill_dir + "/INSTRUCTIONS.md");
+              return map_file_error(_pipe, skill_dir + "/INSTRUCTIONS.md");
+            })(),
+            (instructions_content) => {
+              return compile_for_provider(
+                skill_dir,
+                provider,
+                skill,
+                instructions_content,
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+export function compile(skill_dir, provider_name) {
+  return $result.try$(
+    (() => {
+      let $ = $types.provider_from_string(provider_name);
+      if ($ instanceof Ok) {
+        return $;
+      } else {
+        return new Error(
+          new ProviderError(
+            provider_name,
+            ("Unknown provider '" + provider_name) + "'",
+          ),
+        );
+      }
+    })(),
+    (provider) => { return compile_single(skill_dir, provider); },
+  );
+}
+
+export function compile_all(skill_dir) {
+  return $result.try$(
+    $provider.discover_providers(skill_dir),
+    (providers) => {
+      if (providers instanceof $Empty) {
+        return new Error(
+          new ProviderError(
+            "none",
+            "No supported providers found in " + skill_dir,
+          ),
+        );
+      } else {
+        return $result.try$(
+          read_shared_inputs(skill_dir),
+          (_use0) => {
+            let skill;
+            let instructions_content;
+            skill = _use0[0];
+            instructions_content = _use0[1];
+            return $list.try_map(
+              providers,
+              (p) => {
+                return compile_for_provider(
+                  skill_dir,
+                  p,
+                  skill,
+                  instructions_content,
+                );
+              },
+            );
+          },
+        );
+      }
+    },
+  );
+}
+
+export function compile_providers(skill_dir, providers) {
+  return $result.try$(
+    $list.try_map(
+      providers,
+      (p) => {
+        let $ = $types.provider_from_string(p);
+        if ($ instanceof Ok) {
+          return $;
+        } else {
+          return new Error(
+            new ProviderError(p, ("Unknown provider '" + p) + "'"),
+          );
+        }
+      },
+    ),
+    (parsed_providers) => {
+      if (parsed_providers instanceof $Empty) {
+        return new Error(new ProviderError("none", "No providers specified"));
+      } else {
+        return $result.try$(
+          read_shared_inputs(skill_dir),
+          (_use0) => {
+            let skill;
+            let instructions_content;
+            skill = _use0[0];
+            instructions_content = _use0[1];
+            return $list.try_map(
+              parsed_providers,
+              (p) => {
+                return compile_for_provider(
+                  skill_dir,
+                  p,
+                  skill,
+                  instructions_content,
+                );
+              },
+            );
+          },
+        );
+      }
+    },
+  );
+}
+
+function serialize_yaml_map(pairs, indent) {
+  let prefix = $string.repeat(" ", indent);
+  let lines = format_yaml_pairs(pairs, indent + 2, prefix);
+  return "\n" + $string.join(lines, "\n");
+}