skill-universe 1.1.0

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

@@ -0,0 +1,975 @@
+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 $string from "../../gleam_stdlib/gleam/string.mjs";
+import * as $simplifile from "../../simplifile/simplifile.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 { ImportError, map_file_error } from "../skillc/error.mjs";
+import * as $fs from "../skillc/fs.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 { ClaudeCode, Codex, FileCopy, OpenClaw } from "../skillc/types.mjs";
+import * as $yaml from "../skillc/yaml.mjs";
+
+export class FrontmatterPair extends $CustomType {
+  constructor(key, value) {
+    super();
+    this.key = key;
+    this.value = value;
+  }
+}
+export const FrontmatterPair$FrontmatterPair = (key, value) =>
+  new FrontmatterPair(key, value);
+export const FrontmatterPair$isFrontmatterPair = (value) =>
+  value instanceof FrontmatterPair;
+export const FrontmatterPair$FrontmatterPair$key = (value) => value.key;
+export const FrontmatterPair$FrontmatterPair$0 = (value) => value.key;
+export const FrontmatterPair$FrontmatterPair$value = (value) => value.value;
+export const FrontmatterPair$FrontmatterPair$1 = (value) => value.value;
+
+export class Frontmatter extends $CustomType {
+  constructor(pairs, body) {
+    super();
+    this.pairs = pairs;
+    this.body = body;
+  }
+}
+export const Frontmatter$Frontmatter = (pairs, body) =>
+  new Frontmatter(pairs, body);
+export const Frontmatter$isFrontmatter = (value) =>
+  value instanceof Frontmatter;
+export const Frontmatter$Frontmatter$pairs = (value) => value.pairs;
+export const Frontmatter$Frontmatter$0 = (value) => value.pairs;
+export const Frontmatter$Frontmatter$body = (value) => value.body;
+export const Frontmatter$Frontmatter$1 = (value) => value.body;
+
+export class UniversalFields extends $CustomType {
+  constructor(name, description, version, license) {
+    super();
+    this.name = name;
+    this.description = description;
+    this.version = version;
+    this.license = license;
+  }
+}
+export const UniversalFields$UniversalFields = (name, description, version, license) =>
+  new UniversalFields(name, description, version, license);
+export const UniversalFields$isUniversalFields = (value) =>
+  value instanceof UniversalFields;
+export const UniversalFields$UniversalFields$name = (value) => value.name;
+export const UniversalFields$UniversalFields$0 = (value) => value.name;
+export const UniversalFields$UniversalFields$description = (value) =>
+  value.description;
+export const UniversalFields$UniversalFields$1 = (value) => value.description;
+export const UniversalFields$UniversalFields$version = (value) => value.version;
+export const UniversalFields$UniversalFields$2 = (value) => value.version;
+export const UniversalFields$UniversalFields$license = (value) => value.license;
+export const UniversalFields$UniversalFields$3 = (value) => value.license;
+
+export class SeparatedFields extends $CustomType {
+  constructor(universal, provider) {
+    super();
+    this.universal = universal;
+    this.provider = provider;
+  }
+}
+export const SeparatedFields$SeparatedFields = (universal, provider) =>
+  new SeparatedFields(universal, provider);
+export const SeparatedFields$isSeparatedFields = (value) =>
+  value instanceof SeparatedFields;
+export const SeparatedFields$SeparatedFields$universal = (value) =>
+  value.universal;
+export const SeparatedFields$SeparatedFields$0 = (value) => value.universal;
+export const SeparatedFields$SeparatedFields$provider = (value) =>
+  value.provider;
+export const SeparatedFields$SeparatedFields$1 = (value) => value.provider;
+
+export class SourceDirectory extends $CustomType {
+  constructor(path) {
+    super();
+    this.path = path;
+  }
+}
+export const ResolvedSource$SourceDirectory = (path) =>
+  new SourceDirectory(path);
+export const ResolvedSource$isSourceDirectory = (value) =>
+  value instanceof SourceDirectory;
+export const ResolvedSource$SourceDirectory$path = (value) => value.path;
+export const ResolvedSource$SourceDirectory$0 = (value) => value.path;
+
+export class SourceFile extends $CustomType {
+  constructor(path, directory) {
+    super();
+    this.path = path;
+    this.directory = directory;
+  }
+}
+export const ResolvedSource$SourceFile = (path, directory) =>
+  new SourceFile(path, directory);
+export const ResolvedSource$isSourceFile = (value) =>
+  value instanceof SourceFile;
+export const ResolvedSource$SourceFile$path = (value) => value.path;
+export const ResolvedSource$SourceFile$0 = (value) => value.path;
+export const ResolvedSource$SourceFile$directory = (value) => value.directory;
+export const ResolvedSource$SourceFile$1 = (value) => value.directory;
+
+export const ResolvedSource$path = (value) => value.path;
+
+export class ImportResult extends $CustomType {
+  constructor(provider, skill_yaml, instructions_md, metadata_yaml, scripts, assets) {
+    super();
+    this.provider = provider;
+    this.skill_yaml = skill_yaml;
+    this.instructions_md = instructions_md;
+    this.metadata_yaml = metadata_yaml;
+    this.scripts = scripts;
+    this.assets = assets;
+  }
+}
+export const ImportResult$ImportResult = (provider, skill_yaml, instructions_md, metadata_yaml, scripts, assets) =>
+  new ImportResult(provider,
+  skill_yaml,
+  instructions_md,
+  metadata_yaml,
+  scripts,
+  assets);
+export const ImportResult$isImportResult = (value) =>
+  value instanceof ImportResult;
+export const ImportResult$ImportResult$provider = (value) => value.provider;
+export const ImportResult$ImportResult$0 = (value) => value.provider;
+export const ImportResult$ImportResult$skill_yaml = (value) => value.skill_yaml;
+export const ImportResult$ImportResult$1 = (value) => value.skill_yaml;
+export const ImportResult$ImportResult$instructions_md = (value) =>
+  value.instructions_md;
+export const ImportResult$ImportResult$2 = (value) => value.instructions_md;
+export const ImportResult$ImportResult$metadata_yaml = (value) =>
+  value.metadata_yaml;
+export const ImportResult$ImportResult$3 = (value) => value.metadata_yaml;
+export const ImportResult$ImportResult$scripts = (value) => value.scripts;
+export const ImportResult$ImportResult$4 = (value) => value.scripts;
+export const ImportResult$ImportResult$assets = (value) => value.assets;
+export const ImportResult$ImportResult$5 = (value) => value.assets;
+
+function find_closing_fence_loop(loop$lines, loop$acc) {
+  while (true) {
+    let lines = loop$lines;
+    let acc = loop$acc;
+    if (lines instanceof $Empty) {
+      return new Error(undefined);
+    } else {
+      let line = lines.head;
+      let rest = lines.tail;
+      let $ = $string.trim(line) === "---";
+      if ($) {
+        let yaml = $string.join($list.reverse(acc), "\n");
+        let _block;
+        if (rest instanceof $Empty) {
+          _block = "";
+        } else {
+          _block = $string.join(rest, "\n");
+        }
+        let body = _block;
+        let _block$1;
+        let $1 = $string.starts_with(body, "\n");
+        if ($1) {
+          _block$1 = $string.drop_start(body, 1);
+        } else {
+          _block$1 = body;
+        }
+        let body$1 = _block$1;
+        return new Ok([yaml, body$1]);
+      } else {
+        loop$lines = rest;
+        loop$acc = listPrepend(line, acc);
+      }
+    }
+  }
+}
+
+/**
+ * Find closing --- fence. Returns (yaml_content, body_after_fence).
+ * 
+ * @ignore
+ */
+function find_closing_fence(content) {
+  let lines = $string.split(content, "\n");
+  return find_closing_fence_loop(lines, toList([]));
+}
+
+function split_key_value(line) {
+  let $ = $string.split_once(line, ":");
+  if ($ instanceof Ok) {
+    let key = $[0][0];
+    let value = $[0][1];
+    return [$string.trim(key), value];
+  } else {
+    return [line, ""];
+  }
+}
+
+function collect_indented(loop$lines, loop$acc) {
+  while (true) {
+    let lines = loop$lines;
+    let acc = loop$acc;
+    if (lines instanceof $Empty) {
+      return [acc, toList([])];
+    } else {
+      let line = lines.head;
+      let rest = lines.tail;
+      let $ = $string.starts_with(line, " ") || $string.starts_with(line, "\t");
+      if ($) {
+        loop$lines = rest;
+        loop$acc = listPrepend(line, acc);
+      } else {
+        let $1 = $string.trim(line);
+        if ($1 === "") {
+          loop$lines = rest;
+          loop$acc = acc;
+        } else {
+          return [acc, listPrepend(line, rest)];
+        }
+      }
+    }
+  }
+}
+
+function parse_yaml_lines(loop$lines, loop$acc) {
+  while (true) {
+    let lines = loop$lines;
+    let acc = loop$acc;
+    if (lines instanceof $Empty) {
+      return $list.reverse(acc);
+    } else {
+      let line = lines.head;
+      let rest = lines.tail;
+      let $ = $string.trim(line);
+      if ($ === "") {
+        loop$lines = rest;
+        loop$acc = acc;
+      } else {
+        let $1 = $string.contains(line, ":") && !$string.starts_with(line, " ");
+        if ($1) {
+          let $2 = split_key_value(line);
+          let key;
+          let value;
+          key = $2[0];
+          value = $2[1];
+          let trimmed_value = $string.trim(value);
+          if (trimmed_value === "") {
+            let $3 = collect_indented(rest, toList([]));
+            let block_lines;
+            let remaining;
+            block_lines = $3[0];
+            remaining = $3[1];
+            let block_value = $string.join($list.reverse(block_lines), "\n");
+            loop$lines = remaining;
+            loop$acc = listPrepend(new FrontmatterPair(key, block_value), acc);
+          } else {
+            loop$lines = rest;
+            loop$acc = listPrepend(new FrontmatterPair(key, trimmed_value), acc);
+          }
+        } else {
+          loop$lines = rest;
+          loop$acc = acc;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Parse a YAML frontmatter block into key-value pairs.
+ * 
+ * @ignore
+ */
+function parse_yaml_pairs(yaml) {
+  let lines = $string.split(yaml, "\n");
+  return parse_yaml_lines(lines, toList([]));
+}
+
+/**
+ * Split a SKILL.md into YAML frontmatter key-value pairs and the body markdown.
+ */
+export function parse_frontmatter(content) {
+  let trimmed = $string.trim_start(content);
+  let $ = $string.starts_with(trimmed, "---");
+  if ($) {
+    let after_open = $string.drop_start(trimmed, 3);
+    let _block;
+    let $1 = $string.starts_with(after_open, "\n");
+    if ($1) {
+      _block = $string.drop_start(after_open, 1);
+    } else {
+      _block = after_open;
+    }
+    let after_open$1 = _block;
+    let $2 = find_closing_fence(after_open$1);
+    if ($2 instanceof Ok) {
+      let yaml_block = $2[0][0];
+      let body = $2[0][1];
+      let pairs = parse_yaml_pairs(yaml_block);
+      return new Ok(new Frontmatter(pairs, body));
+    } else {
+      return new Error(
+        new ImportError(
+          "SKILL.md",
+          "Unclosed YAML frontmatter (missing closing ---)",
+        ),
+      );
+    }
+  } else {
+    return new Error(
+      new ImportError(
+        "SKILL.md",
+        "No YAML frontmatter found (expected opening ---)",
+      ),
+    );
+  }
+}
+
+/**
+ * Heuristic provider auto-detection from frontmatter keys and directory.
+ */
+export function detect_provider(pairs, source_dir) {
+  let keys = $list.map(pairs, (pair) => { return pair.key; });
+  let has_openclaw = $list.any(
+    keys,
+    (k) => { return $string.starts_with(k, "metadata.openclaw"); },
+  );
+  if (has_openclaw) {
+    return new Ok(new OpenClaw());
+  } else {
+    let claude_code_keys = toList([
+      "user-invocable",
+      "allowed-tools",
+      "disable-model-invocation",
+    ]);
+    let has_claude_code = $list.any(
+      keys,
+      (k) => { return $list.contains(claude_code_keys, k); },
+    );
+    if (has_claude_code) {
+      return new Ok(new ClaudeCode());
+    } else {
+      let $ = $simplifile.is_file(source_dir + "/agents/openai.yaml");
+      if ($ instanceof Ok) {
+        let $1 = $[0];
+        if ($1) {
+          return new Ok(new Codex());
+        } else {
+          return new Error(
+            new ImportError(
+              "detect",
+              "Cannot auto-detect provider. Pass --provider openclaw|claude-code|codex",
+            ),
+          );
+        }
+      } else {
+        return new Error(
+          new ImportError(
+            "detect",
+            "Cannot auto-detect provider. Pass --provider openclaw|claude-code|codex",
+          ),
+        );
+      }
+    }
+  }
+}
+
+function find_pair_value(pairs, key) {
+  let $ = $list.find(pairs, (pair) => { return pair.key === key; });
+  if ($ instanceof Ok) {
+    let value = $[0].value;
+    return new Some(value);
+  } else {
+    return new None();
+  }
+}
+
+/**
+ * Require that an optional value is present and non-empty.
+ * 
+ * @ignore
+ */
+function require_non_empty(value, field) {
+  if (value instanceof Some) {
+    let s = value[0];
+    let $ = $string.trim(s);
+    if ($ === "") {
+      return new Error(
+        new ImportError(
+          field,
+          ("Required field '" + field) + "' must not be empty",
+        ),
+      );
+    } else {
+      return new Ok(s);
+    }
+  } else {
+    return new Error(
+      new ImportError(
+        field,
+        ("Required field '" + field) + "' is missing from frontmatter",
+      ),
+    );
+  }
+}
+
+/**
+ * Remove surrounding quotes from a YAML string value.
+ * 
+ * @ignore
+ */
+function unquote_yaml_string(s) {
+  let trimmed = $string.trim(s);
+  let $ = $string.starts_with(trimmed, "\"") && $string.ends_with(trimmed, "\"");
+  if ($) {
+    let _block;
+    let _pipe = trimmed;
+    let _pipe$1 = $string.drop_start(_pipe, 1);
+    _block = $string.drop_end(_pipe$1, 1);
+    let inner = _block;
+    let inner$1 = $string.replace(inner, "\\n", "\n");
+    let inner$2 = $string.replace(inner$1, "\\\"", "\"");
+    return $string.replace(inner$2, "\\\\", "\\");
+  } else {
+    let $1 = $string.starts_with(trimmed, "'") && $string.ends_with(
+      trimmed,
+      "'",
+    );
+    if ($1) {
+      let _pipe = trimmed;
+      let _pipe$1 = $string.drop_start(_pipe, 1);
+      return $string.drop_end(_pipe$1, 1);
+    } else {
+      return trimmed;
+    }
+  }
+}
+
+function collect_sub_indented(loop$lines, loop$base_indent, loop$acc) {
+  while (true) {
+    let lines = loop$lines;
+    let base_indent = loop$base_indent;
+    let acc = loop$acc;
+    if (lines instanceof $Empty) {
+      return [acc, toList([])];
+    } else {
+      let line = lines.head;
+      let rest = lines.tail;
+      let stripped = $string.trim_start(line);
+      let line_indent = $string.length(line) - $string.length(stripped);
+      let $ = $string.trim(line);
+      if ($ === "") {
+        loop$lines = rest;
+        loop$base_indent = base_indent;
+        loop$acc = acc;
+      } else {
+        let $1 = line_indent > base_indent;
+        if ($1) {
+          let trimmed_line = $string.drop_start(line, base_indent + 2);
+          loop$lines = rest;
+          loop$base_indent = base_indent;
+          loop$acc = listPrepend(trimmed_line, acc);
+        } else {
+          return [acc, listPrepend(line, rest)];
+        }
+      }
+    }
+  }
+}
+
+function parse_openclaw_lines(loop$lines, loop$acc) {
+  while (true) {
+    let lines = loop$lines;
+    let acc = loop$acc;
+    if (lines instanceof $Empty) {
+      return $list.reverse(acc);
+    } else {
+      let line = lines.head;
+      let rest = lines.tail;
+      let stripped = $string.trim_start(line);
+      let $ = $string.trim(stripped);
+      if ($ === "") {
+        loop$lines = rest;
+        loop$acc = acc;
+      } else {
+        let $1 = $string.contains(stripped, ":");
+        if ($1) {
+          let $2 = split_key_value(stripped);
+          let key;
+          let value;
+          key = $2[0];
+          value = $2[1];
+          let trimmed_value = $string.trim(value);
+          if (trimmed_value === "") {
+            let base_indent = $string.length(line) - $string.length(stripped);
+            let $3 = collect_sub_indented(rest, base_indent, toList([]));
+            let block_lines;
+            let remaining;
+            block_lines = $3[0];
+            remaining = $3[1];
+            let block_value = $string.join($list.reverse(block_lines), "\n");
+            loop$lines = remaining;
+            loop$acc = listPrepend(new FrontmatterPair(key, block_value), acc);
+          } else {
+            loop$lines = rest;
+            loop$acc = listPrepend(new FrontmatterPair(key, trimmed_value), acc);
+          }
+        } else {
+          loop$lines = rest;
+          loop$acc = acc;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Parse the indented block under metadata.openclaw: into key-value pairs.
+ * 
+ * @ignore
+ */
+function parse_openclaw_block(block) {
+  let lines = $string.split(block, "\n");
+  return parse_openclaw_lines(lines, toList([]));
+}
+
+/**
+ * Classify each frontmatter key as universal or provider-specific.
+ * Returns an error if required fields (name, description, version) are missing.
+ */
+export function separate_fields(pairs, provider) {
+  let universal_keys = toList(["name", "description", "version", "license"]);
+  return $result.try$(
+    (() => {
+      let _pipe = find_pair_value(pairs, "name");
+      let _pipe$1 = $option.map(_pipe, unquote_yaml_string);
+      return require_non_empty(_pipe$1, "name");
+    })(),
+    (name) => {
+      return $result.try$(
+        (() => {
+          let _pipe = find_pair_value(pairs, "description");
+          let _pipe$1 = $option.map(_pipe, unquote_yaml_string);
+          return require_non_empty(_pipe$1, "description");
+        })(),
+        (description) => {
+          return $result.try$(
+            (() => {
+              let _pipe = find_pair_value(pairs, "version");
+              let _pipe$1 = $option.map(_pipe, unquote_yaml_string);
+              return require_non_empty(_pipe$1, "version");
+            })(),
+            (version) => {
+              return $result.try$(
+                (() => {
+                  let _pipe = $semver.parse(version);
+                  return $result.map_error(
+                    _pipe,
+                    (_) => {
+                      return new ImportError(
+                        "version",
+                        "Invalid version format: " + version,
+                      );
+                    },
+                  );
+                })(),
+                (version) => {
+                  let _block;
+                  let _pipe = find_pair_value(pairs, "license");
+                  _block = $option.map(_pipe, unquote_yaml_string);
+                  let license = _block;
+                  let universal = new UniversalFields(
+                    name,
+                    description,
+                    version,
+                    license,
+                  );
+                  let _block$1;
+                  if (provider instanceof OpenClaw) {
+                    let $ = find_pair_value(pairs, "metadata.openclaw");
+                    if ($ instanceof Some) {
+                      let block = $[0];
+                      _block$1 = parse_openclaw_block(block);
+                    } else {
+                      _block$1 = $list.filter(
+                        pairs,
+                        (pair) => {
+                          return !$list.contains(universal_keys, pair.key) && !$string.starts_with(
+                            pair.key,
+                            "metadata.openclaw",
+                          );
+                        },
+                      );
+                    }
+                  } else {
+                    _block$1 = $list.filter(
+                      pairs,
+                      (pair) => {
+                        return !$list.contains(universal_keys, pair.key);
+                      },
+                    );
+                  }
+                  let provider_pairs = _block$1;
+                  return new Ok(new SeparatedFields(universal, provider_pairs));
+                },
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+/**
+ * Generate skill.yaml content from universal fields.
+ */
+export function generate_skill_yaml(fields) {
+  let lines = toList([
+    "name: " + $yaml.quote_string(fields.name),
+    "description: " + $yaml.quote_string(fields.description),
+    "version: " + $semver.to_string(fields.version),
+  ]);
+  let _block;
+  let $ = fields.license;
+  if ($ instanceof Some) {
+    let l = $[0];
+    _block = $list.append(lines, toList(["license: " + $yaml.quote_string(l)]));
+  } else {
+    _block = lines;
+  }
+  let lines$1 = _block;
+  return $string.join(lines$1, "\n") + "\n";
+}
+
+function indent_block(block, spaces) {
+  let prefix = $string.repeat(" ", spaces);
+  let lines = $string.split(block, "\n");
+  let _pipe = $list.map(
+    lines,
+    (line) => {
+      let $ = $string.trim(line);
+      if ($ === "") {
+        return $;
+      } else {
+        return prefix + line;
+      }
+    },
+  );
+  return $string.join(_pipe, "\n");
+}
+
+function format_pairs_as_yaml(pairs) {
+  if (pairs instanceof $Empty) {
+    return "";
+  } else {
+    let lines = $list.map(
+      pairs,
+      (pair) => {
+        let $ = $string.contains(pair.value, "\n");
+        if ($) {
+          return (pair.key + ":\n") + indent_block(pair.value, 2);
+        } else {
+          return (pair.key + ": ") + pair.value;
+        }
+      },
+    );
+    return $string.join(lines, "\n") + "\n";
+  }
+}
+
+/**
+ * Generate metadata.yaml content from provider-specific pairs.
+ * For Codex, uses pre-read agents/openai.yaml content if available.
+ */
+export function generate_metadata_yaml(provider_pairs, codex_yaml) {
+  if (codex_yaml instanceof Some) {
+    let content = codex_yaml[0];
+    return content;
+  } else {
+    return format_pairs_as_yaml(provider_pairs);
+  }
+}
+
+function resolve_local(source) {
+  let $ = $simplifile.is_file(source);
+  if ($ instanceof Ok) {
+    let $1 = $[0];
+    if ($1) {
+      return new Ok(new SourceFile(source, $path.parent_dir(source)));
+    } else {
+      return new Ok(new SourceDirectory(source));
+    }
+  } else {
+    return new Ok(new SourceDirectory(source));
+  }
+}
+
+/**
+ * Extract the directory path from a resolved source.
+ * 
+ * @ignore
+ */
+function resolved_directory(source) {
+  if (source instanceof SourceDirectory) {
+    let path = source.path;
+    return path;
+  } else {
+    let directory = source.directory;
+    return directory;
+  }
+}
+
+function do_emit_imported(import_result, output_dir) {
+  let provider_str = $types.provider_to_string(import_result.provider);
+  let provider_dir = (output_dir + "/providers/") + provider_str;
+  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(
+            output_dir + "/skill.yaml",
+            import_result.skill_yaml,
+          );
+          return map_file_error(_pipe, output_dir + "/skill.yaml");
+        })(),
+        (_) => {
+          return $result.try$(
+            (() => {
+              let _pipe = $simplifile.write(
+                output_dir + "/INSTRUCTIONS.md",
+                import_result.instructions_md,
+              );
+              return map_file_error(_pipe, output_dir + "/INSTRUCTIONS.md");
+            })(),
+            (_) => {
+              return $result.try$(
+                (() => {
+                  let _pipe = $simplifile.write(
+                    provider_dir + "/metadata.yaml",
+                    import_result.metadata_yaml,
+                  );
+                  return map_file_error(_pipe, provider_dir + "/metadata.yaml");
+                })(),
+                (_) => {
+                  return $result.try$(
+                    $fs.copy_file_list(
+                      import_result.scripts,
+                      provider_dir + "/scripts",
+                    ),
+                    (_) => {
+                      return $result.try$(
+                        $fs.copy_file_list(
+                          import_result.assets,
+                          provider_dir + "/assets",
+                        ),
+                        (_) => { return new Ok(undefined); },
+                      );
+                    },
+                  );
+                },
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}
+
+/**
+ * Write the unified directory structure to disk.
+ */
+export function emit_imported(import_result, output_dir) {
+  let $ = $simplifile.is_file(output_dir + "/skill.yaml");
+  if ($ instanceof Ok) {
+    let $1 = $[0];
+    if ($1) {
+      return new Error(
+        new ImportError("emit", "skill.yaml already exists in " + output_dir),
+      );
+    } else {
+      return do_emit_imported(import_result, output_dir);
+    }
+  } else {
+    return do_emit_imported(import_result, output_dir);
+  }
+}
+
+function collect_source_files(source_dir, subdir) {
+  let dir = (source_dir + "/") + subdir;
+  let $ = $simplifile.get_files(dir);
+  if ($ instanceof Ok) {
+    let files = $[0];
+    return $list.map(
+      files,
+      (f) => {
+        let relative = $string.replace(f, dir + "/", "");
+        return new FileCopy(f, relative);
+      },
+    );
+  } else {
+    return toList([]);
+  }
+}
+
+/**
+ * Simple string hash for temp directory naming.
+ * 
+ * @ignore
+ */
+function hash_string(s) {
+  let chars = $string.to_utf_codepoints(s);
+  let hash = $list.fold(
+    chars,
+    0,
+    (acc, cp) => {
+      let code = $string.utf_codepoint_to_int(cp);
+      return ((acc * 31 % 999_999_937) + code) % 999_999_937;
+    },
+  );
+  let $ = hash < 0;
+  if ($) {
+    return $int.to_string(- hash);
+  } else {
+    return $int.to_string(hash);
+  }
+}
+
+function fetch_remote(url) {
+  let tmp_dir = ($platform.tmpdir() + "/skillc-import-") + hash_string(url);
+  let $ = $simplifile.create_directory_all(tmp_dir);
+  if ($ instanceof Ok) {
+    let cmd = (("curl -sSfL -o " + $shell.quote(tmp_dir + "/SKILL.md")) + " ") + $shell.quote(
+      url,
+    );
+    let $1 = $shell.exec(cmd);
+    if ($1 instanceof Ok) {
+      return new Ok(new SourceDirectory(tmp_dir));
+    } else {
+      let msg = $1[0];
+      return new Error(new ImportError(url, "Failed to download: " + msg));
+    }
+  } else {
+    return new Error(new ImportError(url, "Failed to create temp directory"));
+  }
+}
+
+/**
+ * Resolve source: download URL to temp dir, or classify local path as
+ * file or directory.
+ */
+export function fetch_source(source) {
+  let $ = $string.starts_with(source, "http://") || $string.starts_with(
+    source,
+    "https://",
+  );
+  if ($) {
+    return fetch_remote(source);
+  } else {
+    return resolve_local(source);
+  }
+}
+
+/**
+ * Import a provider-specific skill into unified format.
+ */
+export function import_skill(source, provider_hint, output_dir) {
+  return $result.try$(
+    fetch_source(source),
+    (resolved) => {
+      let _block;
+      if (resolved instanceof SourceDirectory) {
+        let path = resolved.path;
+        _block = path + "/SKILL.md";
+      } else {
+        let path = resolved.path;
+        _block = path;
+      }
+      let skill_md_path = _block;
+      return $result.try$(
+        (() => {
+          let _pipe = $simplifile.read(skill_md_path);
+          return map_file_error(_pipe, skill_md_path);
+        })(),
+        (content) => {
+          return $result.try$(
+            parse_frontmatter(content),
+            (frontmatter) => {
+              let source_dir = resolved_directory(resolved);
+              return $result.try$(
+                (() => {
+                  if (provider_hint instanceof Some) {
+                    let p = provider_hint[0];
+                    return new Ok(p);
+                  } else {
+                    return detect_provider(frontmatter.pairs, source_dir);
+                  }
+                })(),
+                (provider) => {
+                  let _block$1;
+                  if (provider instanceof Codex) {
+                    let $ = $simplifile.read(source_dir + "/agents/openai.yaml");
+                    if ($ instanceof Ok) {
+                      let content$1 = $[0];
+                      _block$1 = new Some(content$1);
+                    } else {
+                      _block$1 = new None();
+                    }
+                  } else {
+                    _block$1 = new None();
+                  }
+                  let codex_yaml = _block$1;
+                  return $result.try$(
+                    separate_fields(frontmatter.pairs, provider),
+                    (separated) => {
+                      let skill_yaml = generate_skill_yaml(separated.universal);
+                      let metadata_yaml = generate_metadata_yaml(
+                        separated.provider,
+                        codex_yaml,
+                      );
+                      let instructions_md = $string.trim(frontmatter.body) + "\n";
+                      let scripts = collect_source_files(source_dir, "scripts");
+                      let assets = collect_source_files(source_dir, "assets");
+                      let import_result = new ImportResult(
+                        provider,
+                        skill_yaml,
+                        instructions_md,
+                        metadata_yaml,
+                        scripts,
+                        assets,
+                      );
+                      return $result.try$(
+                        emit_imported(import_result, output_dir),
+                        (_) => { return new Ok(import_result); },
+                      );
+                    },
+                  );
+                },
+              );
+            },
+          );
+        },
+      );
+    },
+  );
+}