skill-universe 1.1.0

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

@@ -0,0 +1,701 @@
+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 $simplifile from "../../simplifile/simplifile.mjs";
+import { Ok, Error, toList, Empty as $Empty } from "../gleam.mjs";
+import * as $compiler from "../skillc/compiler.mjs";
+import * as $error from "../skillc/error.mjs";
+import { RegistryError, map_file_error } from "../skillc/error.mjs";
+import * as $parser from "../skillc/parser.mjs";
+import * as $path from "../skillc/path.mjs";
+import * as $platform from "../skillc/platform.mjs";
+import * as $semver from "../skillc/semver.mjs";
+import * as $shell from "../skillc/shell.mjs";
+import * as $types from "../skillc/types.mjs";
+import * as $version_constraint from "../skillc/version_constraint.mjs";
+
+export function parse_repo_url(url) {
+  let url$1 = $string.trim(url);
+  let _block;
+  let $ = $string.contains(url$1, "@");
+  if ($) {
+    let $1 = $string.split_once(url$1, ":");
+    if ($1 instanceof Ok) {
+      let path = $1[0][1];
+      _block = path;
+    } else {
+      _block = url$1;
+    }
+  } else {
+    _block = url$1;
+  }
+  let url$2 = _block;
+  let _block$1;
+  let $1 = $string.split(url$2, "github.com/");
+  if ($1 instanceof $Empty) {
+    _block$1 = url$2;
+  } else {
+    let $2 = $1.tail;
+    if ($2 instanceof $Empty) {
+      _block$1 = url$2;
+    } else {
+      let $3 = $2.tail;
+      if ($3 instanceof $Empty) {
+        let path = $2.head;
+        _block$1 = path;
+      } else {
+        _block$1 = url$2;
+      }
+    }
+  }
+  let url$3 = _block$1;
+  let _block$2;
+  let $2 = $string.ends_with(url$3, ".git");
+  if ($2) {
+    _block$2 = $string.drop_end(url$3, 4);
+  } else {
+    _block$2 = url$3;
+  }
+  let url$4 = _block$2;
+  let $3 = $string.ends_with(url$4, "/");
+  if ($3) {
+    return $string.drop_end(url$4, 1);
+  } else {
+    return url$4;
+  }
+}
+
+export function parse_install_spec(spec) {
+  let _block;
+  let $1 = $string.split_once(spec, "@");
+  if ($1 instanceof Ok) {
+    let p = $1[0][0];
+    let v = $1[0][1];
+    _block = [p, new Some(v)];
+  } else {
+    _block = [spec, new None()];
+  }
+  let $ = _block;
+  let path;
+  let version;
+  path = $[0];
+  version = $[1];
+  let segments = $string.split(path, "/");
+  if (segments instanceof $Empty) {
+    return [path, new None(), version];
+  } else {
+    let $2 = segments.tail;
+    if ($2 instanceof $Empty) {
+      return [path, new None(), version];
+    } else {
+      let $3 = $2.tail;
+      if ($3 instanceof $Empty) {
+        return [path, new None(), version];
+      } else {
+        let $4 = $3.tail;
+        if ($4 instanceof $Empty) {
+          let owner = segments.head;
+          let repo = $2.head;
+          let skill_name = $3.head;
+          return [(owner + "/") + repo, new Some(skill_name), version];
+        } else {
+          return [path, new None(), version];
+        }
+      }
+    }
+  }
+}
+
+function find_skill_dir(base_dir) {
+  let $ = $simplifile.is_file(base_dir + "/skill.yaml");
+  if ($ instanceof Ok) {
+    let $1 = $[0];
+    if ($1) {
+      return new Ok(base_dir);
+    } else {
+      let $2 = $simplifile.read_directory(base_dir);
+      if ($2 instanceof Ok) {
+        let entries = $2[0];
+        let found = $list.find(
+          entries,
+          (entry) => {
+            let $3 = $simplifile.is_file(
+              ((base_dir + "/") + entry) + "/skill.yaml",
+            );
+            if ($3 instanceof Ok) {
+              let $4 = $3[0];
+              if ($4) {
+                return true;
+              } else {
+                return false;
+              }
+            } else {
+              return false;
+            }
+          },
+        );
+        if (found instanceof Ok) {
+          let entry = found[0];
+          return new Ok((base_dir + "/") + entry);
+        } else {
+          return new Error(
+            new RegistryError("No skill.yaml found in extracted archive"),
+          );
+        }
+      } else {
+        return new Error(
+          new RegistryError("Failed to read extracted directory"),
+        );
+      }
+    }
+  } else {
+    let $1 = $simplifile.read_directory(base_dir);
+    if ($1 instanceof Ok) {
+      let entries = $1[0];
+      let found = $list.find(
+        entries,
+        (entry) => {
+          let $2 = $simplifile.is_file(
+            ((base_dir + "/") + entry) + "/skill.yaml",
+          );
+          if ($2 instanceof Ok) {
+            let $3 = $2[0];
+            if ($3) {
+              return true;
+            } else {
+              return false;
+            }
+          } else {
+            return false;
+          }
+        },
+      );
+      if (found instanceof Ok) {
+        let entry = found[0];
+        return new Ok((base_dir + "/") + entry);
+      } else {
+        return new Error(
+          new RegistryError("No skill.yaml found in extracted archive"),
+        );
+      }
+    } else {
+      return new Error(new RegistryError("Failed to read extracted directory"));
+    }
+  }
+}
+
+export function list_installed(output_dir) {
+  let $ = $simplifile.read_directory(output_dir);
+  if ($ instanceof Ok) {
+    let entries = $[0];
+    let skills = $list.flat_map(
+      entries,
+      (provider_dir) => {
+        let provider_path = (output_dir + "/") + provider_dir;
+        let $1 = $simplifile.read_directory(provider_path);
+        if ($1 instanceof Ok) {
+          let skill_entries = $1[0];
+          return $list.filter_map(
+            skill_entries,
+            (skill_name) => {
+              let skill_md_path = ((provider_path + "/") + skill_name) + "/SKILL.md";
+              let $2 = $simplifile.is_file(skill_md_path);
+              if ($2 instanceof Ok) {
+                let $3 = $2[0];
+                if ($3) {
+                  return new Ok(
+                    ((("  " + skill_name) + " (") + provider_dir) + ")",
+                  );
+                } else {
+                  return new Error(undefined);
+                }
+              } else {
+                return new Error(undefined);
+              }
+            },
+          );
+        } else {
+          return toList([]);
+        }
+      },
+    );
+    if (skills instanceof $Empty) {
+      return new Ok("No skills installed in " + output_dir);
+    } else {
+      return new Ok("Installed skills:\n" + $string.join(skills, "\n"));
+    }
+  } else {
+    return new Ok("No skills installed in " + output_dir);
+  }
+}
+
+function check_install_dependencies(skill_dir, output_dir) {
+  let $ = $simplifile.read(skill_dir + "/skill.yaml");
+  if ($ instanceof Ok) {
+    let content = $[0];
+    let $1 = $parser.parse_skill_yaml(content);
+    if ($1 instanceof Ok) {
+      let skill = $1[0];
+      let warnings = $compiler.check_dependencies(skill, output_dir);
+      if (warnings instanceof $Empty) {
+        return "";
+      } else {
+        let lines = $list.filter_map(
+          warnings,
+          (w) => {
+            if (w instanceof $types.MissingDependency) {
+              let dep = w.dependency;
+              return new Ok(
+                ((("\nWarning: missing dependency '" + dep.name) + "' (") + $version_constraint.to_string(
+                  dep.version,
+                )) + ")",
+              );
+            } else {
+              return new Error(undefined);
+            }
+          },
+        );
+        return $string.join(lines, "");
+      }
+    } else {
+      return "";
+    }
+  } else {
+    return "";
+  }
+}
+
+function require_gh() {
+  let _pipe = $shell.exec("gh --version");
+  let _pipe$1 = $result.map(_pipe, (_) => { return undefined; });
+  return $result.map_error(
+    _pipe$1,
+    (_) => {
+      return new RegistryError(
+        "GitHub CLI (gh) is not installed. Install it from https://cli.github.com",
+      );
+    },
+  );
+}
+
+function shell_quote(s) {
+  return $shell.quote(s);
+}
+
+export function publish(skill_dir, repo) {
+  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) => {
+          let version_str = $semver.to_string(skill.version);
+          let tag = (skill.name + "-v") + version_str;
+          let tarball_name = ((skill.name + "-") + version_str) + ".tar.gz";
+          let tarball_path = ($platform.tmpdir() + "/") + tarball_name;
+          let parent = $path.parent_dir(skill_dir);
+          let dirname = $path.basename(skill_dir);
+          return $result.try$(
+            (() => {
+              let _pipe = $shell.exec(
+                (((("tar czf " + tarball_path) + " -C ") + shell_quote(parent)) + " ") + shell_quote(
+                  dirname,
+                ),
+              );
+              return $result.map_error(
+                _pipe,
+                (e) => {
+                  return new RegistryError("Failed to create tarball: " + e);
+                },
+              );
+            })(),
+            (_) => {
+              return $result.try$(
+                (() => {
+                  let _pipe = $shell.exec("gh --version");
+                  return $result.map_error(
+                    _pipe,
+                    (_) => {
+                      return new RegistryError(
+                        "GitHub CLI (gh) is not installed. Install it from https://cli.github.com",
+                      );
+                    },
+                  );
+                })(),
+                (_) => {
+                  return $result.try$(
+                    (() => {
+                      let _pipe = $shell.exec(
+                        (((((((("gh release create " + shell_quote(tag)) + " ") + shell_quote(
+                          tarball_path,
+                        )) + " --repo ") + shell_quote(repo)) + " --title ") + shell_quote(
+                          (skill.name + " ") + tag,
+                        )) + " --notes ") + shell_quote("Published by skillc"),
+                      );
+                      return $result.map_error(
+                        _pipe,
+                        (e) => {
+                          return new RegistryError(
+                            "Failed to create release: " + e,
+                          );
+                        },
+                      );
+                    })(),
+                    (output) => {
+                      let $ = $simplifile.delete$(tarball_path);
+                      
+                      return new Ok(
+                        (((((("Published " + skill.name) + " ") + tag) + " to ") + repo) + "\n") + output,
+                      );
+                    },
+                  );
+                },
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+export function infer_repo(skill_dir) {
+  return $result.try$(
+    (() => {
+      let _pipe = $shell.exec(
+        ("git -C " + shell_quote(skill_dir)) + " remote get-url origin",
+      );
+      return $result.map_error(
+        _pipe,
+        (_) => {
+          return new RegistryError(
+            "Could not infer repository. Use --repo owner/repo or ensure a git remote is configured.",
+          );
+        },
+      );
+    })(),
+    (url) => { return new Ok(parse_repo_url(url)); },
+  );
+}
+
+export function search(query) {
+  return $result.try$(
+    require_gh(),
+    (_) => {
+      return $result.try$(
+        (() => {
+          let _pipe = $shell.exec(
+            ((("gh search repos --topic skill-universe " + shell_quote(query)) + " --json name,owner,description --jq ") + shell_quote(
+              ".[] | \"\\(.owner.login)/\\(.name) - \\(.description)\"",
+            )) + " --limit 20",
+          );
+          return $result.map_error(
+            _pipe,
+            (e) => { return new RegistryError("Search failed: " + e); },
+          );
+        })(),
+        (output) => {
+          let $ = $string.is_empty($string.trim(output));
+          if ($) {
+            return new Ok(("No skills found matching '" + query) + "'");
+          } else {
+            return new Ok(output);
+          }
+        },
+      );
+    },
+  );
+}
+
+function resolve_install_tag(repo, skill_name, version) {
+  if (skill_name instanceof Some) {
+    if (version instanceof Some) {
+      let name = skill_name[0];
+      let v = version[0];
+      return new Ok(" " + shell_quote((name + "-") + v));
+    } else {
+      let name = skill_name[0];
+      return $result.try$(
+        (() => {
+          let _pipe = $shell.exec(
+            (("gh release list --repo " + shell_quote(repo)) + " --json tagName --jq ") + shell_quote(
+              (".[] | select(.tagName | startswith(\"" + name) + "-v\")) | .tagName",
+            ),
+          );
+          return $result.map_error(
+            _pipe,
+            (e) => { return new RegistryError("Failed to list releases: " + e); },
+          );
+        })(),
+        (output) => {
+          let _block;
+          let _pipe = $string.split($string.trim(output), "\n");
+          _block = $list.filter(_pipe, (t) => { return !$string.is_empty(t); });
+          let tags = _block;
+          if (tags instanceof $Empty) {
+            return new Error(
+              new RegistryError(
+                (("No releases found for skill '" + name) + "' in ") + repo,
+              ),
+            );
+          } else {
+            let latest = tags.head;
+            return new Ok(" " + shell_quote(latest));
+          }
+        },
+      );
+    }
+  } else if (version instanceof Some) {
+    let v = version[0];
+    return new Ok(" " + shell_quote(v));
+  } else {
+    return new Ok(" --latest");
+  }
+}
+
+export function install(spec, target, output_dir) {
+  return $result.try$(
+    require_gh(),
+    (_) => {
+      let $ = parse_install_spec(spec);
+      let repo;
+      let skill_name;
+      let version;
+      repo = $[0];
+      skill_name = $[1];
+      version = $[2];
+      let tmp_dir = ($platform.tmpdir() + "/skillc-install-") + $string.replace(
+        repo,
+        "/",
+        "-",
+      );
+      let $1 = $simplifile.delete$(tmp_dir);
+      
+      return $result.try$(
+        (() => {
+          let _pipe = $simplifile.create_directory_all(tmp_dir);
+          return map_file_error(_pipe, tmp_dir);
+        })(),
+        (_) => {
+          return $result.try$(
+            resolve_install_tag(repo, skill_name, version),
+            (tag_flag) => {
+              return $result.try$(
+                (() => {
+                  let _pipe = $shell.exec(
+                    ((((("gh release download" + tag_flag) + " --repo ") + shell_quote(
+                      repo,
+                    )) + " --pattern '*.tar.gz'") + " --dir ") + shell_quote(
+                      tmp_dir,
+                    ),
+                  );
+                  return $result.map_error(
+                    _pipe,
+                    (e) => {
+                      return new RegistryError(
+                        "Failed to download release: " + e,
+                      );
+                    },
+                  );
+                })(),
+                (_) => {
+                  return $result.try$(
+                    (() => {
+                      let $2 = $simplifile.get_files(tmp_dir);
+                      if ($2 instanceof Ok) {
+                        let files = $2[0];
+                        let $3 = $list.find(
+                          files,
+                          (f) => { return $string.ends_with(f, ".tar.gz"); },
+                        );
+                        if ($3 instanceof Ok) {
+                          return $3;
+                        } else {
+                          return new Error(
+                            new RegistryError(
+                              "No tarball found in downloaded release",
+                            ),
+                          );
+                        }
+                      } else {
+                        return new Error(
+                          new RegistryError("Failed to read temp directory"),
+                        );
+                      }
+                    })(),
+                    (tarball) => {
+                      let extract_dir = tmp_dir + "/extracted";
+                      return $result.try$(
+                        (() => {
+                          let _pipe = $simplifile.create_directory_all(
+                            extract_dir,
+                          );
+                          return map_file_error(_pipe, extract_dir);
+                        })(),
+                        (_) => {
+                          return $result.try$(
+                            (() => {
+                              let _pipe = $shell.exec(
+                                (("tar xzf " + shell_quote(tarball)) + " -C ") + shell_quote(
+                                  extract_dir,
+                                ),
+                              );
+                              return $result.map_error(
+                                _pipe,
+                                (e) => {
+                                  return new RegistryError(
+                                    "Failed to extract tarball: " + e,
+                                  );
+                                },
+                              );
+                            })(),
+                            (_) => {
+                              return $result.try$(
+                                find_skill_dir(extract_dir),
+                                (skill_dir) => {
+                                  return $result.try$(
+                                    (() => {
+                                      if (target instanceof Some) {
+                                        let t = target[0];
+                                        return $result.try$(
+                                          $compiler.compile(skill_dir, t),
+                                          (compiled) => {
+                                            let name = compiled.name;
+                                            return $result.try$(
+                                              $compiler.emit(
+                                                compiled,
+                                                output_dir,
+                                                name,
+                                              ),
+                                              (_) => {
+                                                return new Ok(
+                                                  (((("Installed " + name) + " (") + t) + ") to ") + output_dir,
+                                                );
+                                              },
+                                            );
+                                          },
+                                        );
+                                      } else {
+                                        return $result.try$(
+                                          $compiler.compile_all(skill_dir),
+                                          (compiled_list) => {
+                                            return $result.try$(
+                                              $list.try_each(
+                                                compiled_list,
+                                                (compiled) => {
+                                                  let name = compiled.name;
+                                                  return $compiler.emit(
+                                                    compiled,
+                                                    output_dir,
+                                                    name,
+                                                  );
+                                                },
+                                              ),
+                                              (_) => {
+                                                let provider_names = $list.map(
+                                                  compiled_list,
+                                                  (c) => {
+                                                    return $types.provider_to_string(
+                                                      c.provider,
+                                                    );
+                                                  },
+                                                );
+                                                let _block;
+                                                if (
+                                                  compiled_list instanceof $Empty
+                                                ) {
+                                                  _block = "skill";
+                                                } else {
+                                                  let first = compiled_list.head;
+                                                  _block = first.name;
+                                                }
+                                                let name = _block;
+                                                return new Ok(
+                                                  (((("Installed " + name) + " (") + $string.join(
+                                                    provider_names,
+                                                    ", ",
+                                                  )) + ") to ") + output_dir,
+                                                );
+                                              },
+                                            );
+                                          },
+                                        );
+                                      }
+                                    })(),
+                                    (result_msg) => {
+                                      let dep_warnings = check_install_dependencies(
+                                        skill_dir,
+                                        output_dir,
+                                      );
+                                      let $2 = $simplifile.delete$(tmp_dir);
+                                      
+                                      return new Ok(result_msg + dep_warnings);
+                                    },
+                                  );
+                                },
+                              );
+                            },
+                          );
+                        },
+                      );
+                    },
+                  );
+                },
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+export function list_versions(repo, skill_name) {
+  return $result.try$(
+    require_gh(),
+    (_) => {
+      let _block;
+      if (skill_name instanceof Some) {
+        let name = skill_name[0];
+        _block = (".[] | select(.tagName | startswith(\"" + name) + "-v\")) | \"\\(.tagName)\\t\\(.publishedAt)\\(if .isLatest then \" (latest)\" else \"\" end)\"";
+      } else {
+        _block = ".[] | \"\\(.tagName)\\t\\(.publishedAt)\\(if .isLatest then \" (latest)\" else \"\" end)\"";
+      }
+      let jq_expr = _block;
+      return $result.try$(
+        (() => {
+          let _pipe = $shell.exec(
+            (("gh release list --repo " + shell_quote(repo)) + " --json tagName,publishedAt,isLatest --jq ") + shell_quote(
+              jq_expr,
+            ),
+          );
+          return $result.map_error(
+            _pipe,
+            (e) => { return new RegistryError("Failed to list versions: " + e); },
+          );
+        })(),
+        (output) => {
+          let _block$1;
+          if (skill_name instanceof Some) {
+            let name = skill_name[0];
+            _block$1 = (name + " in ") + repo;
+          } else {
+            _block$1 = repo;
+          }
+          let label = _block$1;
+          let $ = $string.is_empty($string.trim(output));
+          if ($) {
+            return new Ok("No releases found for " + label);
+          } else {
+            return new Ok(output);
+          }
+        },
+      );
+    },
+  );
+}