monopam / lib / opam_repo.ml

type error =
  | Multiple_versions of string * string list
  | No_dev_repo of string
  | Invalid_dev_repo of string * string
  | Not_git_remote of string * string
  | Parse_error of string * string
  | Io_error of string

let pp_error ppf = function
  | Multiple_versions (name, versions) ->
      Fmt.pf ppf "Package %s has multiple versions: %a" name
        Fmt.(list ~sep:comma string)
        versions
  | No_dev_repo name -> Fmt.pf ppf "Package %s has no dev-repo field" name
  | Invalid_dev_repo (name, url) ->
      Fmt.pf ppf "Package %s has invalid dev-repo: %s" name url
  | Not_git_remote (name, url) ->
      Fmt.pf ppf "Package %s dev-repo is not a git URL: %s" name url
  | Parse_error (path, msg) -> Fmt.pf ppf "Failed to parse %s: %s" path msg
  | Io_error msg -> Fmt.pf ppf "I/O error: %s" msg

let is_git_url url =
  String.starts_with ~prefix:"git+" url
  || String.starts_with ~prefix:"git://" url
  || String.starts_with ~prefix:"git@" url
  || String.ends_with ~suffix:".git" url

let normalize_git_url url =
  let url =
    match String.starts_with ~prefix:"git+" url with
    | true -> String.sub url 4 (String.length url - 4)
    | false -> url
  in
  Uri.of_string url

module OP = OpamParserTypes.FullPos

let extract_string_value (v : OP.value) : string option =
  match v.pelem with OP.String s -> Some s | _ -> None

let find_dev_repo (items : OP.opamfile_item list) : string option =
  List.find_map
    (fun (item : OP.opamfile_item) ->
      match item.pelem with
      | OP.Variable (name, value) when name.pelem = "dev-repo" ->
          extract_string_value value
      | _ -> None)
    items

(** Extract package name from a dependency formula value.
    Handles cases like:
    - "pkgname"
    - "pkgname" {>= "1.0"}
    - "pkgname" {with-test}
    Returns the package name if found. *)
let rec extract_dep_name (v : OP.value) : string option =
  match v.pelem with
  | OP.String s -> Some s
  | OP.Option (inner, _) -> extract_dep_name inner
  | _ -> None

(** Extract all dependency package names from a depends value. The depends field
    is a list of package formulas. *)
let extract_depends_list (v : OP.value) : string list =
  match v.pelem with
  | OP.List { pelem = items; _ } -> List.filter_map extract_dep_name items
  | _ -> ( match extract_dep_name v with Some s -> [ s ] | None -> [])

let find_depends (items : OP.opamfile_item list) : string list =
  List.find_map
    (fun (item : OP.opamfile_item) ->
      match item.pelem with
      | OP.Variable (name, value) when name.pelem = "depends" ->
          Some (extract_depends_list value)
      | _ -> None)
    items
  |> Option.value ~default:[]

let find_synopsis (items : OP.opamfile_item list) : string option =
  List.find_map
    (fun (item : OP.opamfile_item) ->
      match item.pelem with
      | OP.Variable (name, value) when name.pelem = "synopsis" ->
          extract_string_value value
      | _ -> None)
    items

let parse_package_path (path : Fpath.t) : (string * string) option =
  let segs = Fpath.segs path in
  let rec find_after_packages = function
    | [] -> None
    | "packages" :: name :: name_version :: _ -> (
        match String.split_on_char '.' name_version with
        | [ n; v ] when n = name -> Some (name, v)
        | n :: rest when n = name -> Some (name, String.concat "." rest)
        | _ -> None)
    | _ :: rest -> find_after_packages rest
  in
  find_after_packages segs

let load_package ~fs opam_file_path =
  let path_str = Fpath.to_string opam_file_path in
  match parse_package_path opam_file_path with
  | None ->
      Error (Parse_error (path_str, "Cannot determine package name/version"))
  | Some (name, version) -> (
      try
        let eio_path = Eio.Path.(fs / path_str) in
        let content = Eio.Path.load eio_path in
        let opamfile = OpamParser.FullPos.string content path_str in
        match find_dev_repo opamfile.file_contents with
        | None -> Error (No_dev_repo name)
        | Some url ->
            if not (is_git_url url) then Error (Not_git_remote (name, url))
            else
              let dev_repo = normalize_git_url url in
              let depends = find_depends opamfile.file_contents in
              let synopsis = find_synopsis opamfile.file_contents in
              Ok (Package.create ~name ~version ~dev_repo ~depends ?synopsis ())
      with
      | Eio.Io _ as e -> Error (Io_error (Printexc.to_string e))
      | exn -> Error (Parse_error (path_str, Printexc.to_string exn)))

let list_dirs ~fs path =
  let eio_path = Eio.Path.(fs / Fpath.to_string path) in
  try
    Eio.Path.read_dir eio_path
    |> List.filter (fun name ->
        let child = Eio.Path.(eio_path / name) in
        match Eio.Path.kind ~follow:false child with
        | `Directory -> true
        | _ -> false)
  with Eio.Io _ -> []

let scan_all ~fs repo_path =
  let packages_dir = Fpath.(repo_path / "packages") in
  let package_names = list_dirs ~fs packages_dir in
  let packages, errors =
    List.fold_left
      (fun (pkgs, errs) name ->
        let pkg_dir = Fpath.(packages_dir / name) in
        let versions = list_dirs ~fs pkg_dir in
        match versions with
        | [] -> (pkgs, errs)
        | [ version_dir ] -> (
            let opam_path = Fpath.(pkg_dir / version_dir / "opam") in
            match load_package ~fs opam_path with
            | Ok pkg -> (pkg :: pkgs, errs)
            | Error e -> (pkgs, e :: errs))
        | _ :: _ :: _ as vs -> (pkgs, Multiple_versions (name, vs) :: errs))
      ([], []) package_names
  in
  (List.rev packages, List.rev errors)

let scan ~fs repo_path =
  match scan_all ~fs repo_path with
  | pkgs, [] -> Ok pkgs
  | _, err :: _ -> Error err

let validate_repo ~fs repo_path =
  let _, errors = scan_all ~fs repo_path in
  errors

(** Scan a directory for .opam files and extract all dependencies. This is used
    to find dependencies from monorepo subtree directories, where multiple .opam
    files may exist that aren't in the opam overlay. *)
let scan_opam_files_for_deps ~fs dir_path =
  let eio_path = Eio.Path.(fs / Fpath.to_string dir_path) in
  try
    let files = Eio.Path.read_dir eio_path in
    let opam_files =
      List.filter (fun name -> Filename.check_suffix name ".opam") files
    in
    List.concat_map
      (fun opam_file ->
        let opam_path = Eio.Path.(eio_path / opam_file) in
        try
          let content = Eio.Path.load opam_path in
          let opamfile =
            OpamParser.FullPos.string content
              (Fpath.to_string dir_path ^ "/" ^ opam_file)
          in
          find_depends opamfile.file_contents
        with _ -> [])
      opam_files
  with Eio.Io _ -> []

(** Read the raw content of an opam file. *)
let read_opam_file ~fs opam_file_path =
  let eio_path = Eio.Path.(fs / Fpath.to_string opam_file_path) in
  try Ok (Eio.Path.load eio_path) with Eio.Io _ as e -> Error (Io_error (Printexc.to_string e))

(** Replace dev-repo line in content. Looks for 'dev-repo: "..."' and replaces the URL. *)
let replace_dev_repo_line content ~new_url =
  let lines = String.split_on_char '\n' content in
  let dev_repo_url =
    if String.starts_with ~prefix:"git@" new_url then "git+" ^ new_url
    else if String.starts_with ~prefix:"https://" new_url then "git+" ^ new_url
    else if String.starts_with ~prefix:"git+" new_url then new_url
    else "git+" ^ new_url
  in
  let lines =
    List.map
      (fun line ->
        let trimmed = String.trim line in
        if String.starts_with ~prefix:"dev-repo:" trimmed then
          Printf.sprintf {|dev-repo: "%s"|} dev_repo_url
        else line)
      lines
  in
  String.concat "\n" lines

(** Replace url { src: "..." } section in content. *)
let replace_url_section content ~new_url =
  let url_src =
    let base =
      if String.starts_with ~prefix:"git@" new_url then "git+" ^ new_url
      else if String.starts_with ~prefix:"https://" new_url then "git+" ^ new_url
      else if String.starts_with ~prefix:"git+" new_url then new_url
      else "git+" ^ new_url
    in
    base ^ "#main"
  in
  (* Simple state machine to find and replace url { src: "..." } block *)
  let lines = String.split_on_char '\n' content in
  let rec process lines in_url_block acc =
    match lines with
    | [] -> List.rev acc
    | line :: rest ->
        let trimmed = String.trim line in
        if in_url_block then
          (* We're inside url { ... }, skip until we see } *)
          if String.starts_with ~prefix:"}" trimmed then
            (* End of url block - output our replacement *)
            let replacement =
              [ "url {"; Printf.sprintf {|  src: "%s"|} url_src; "}" ]
            in
            process rest false (List.rev_append replacement acc)
          else
            (* Skip this line, it's part of the old url block *)
            process rest true acc
        else if trimmed = "url {" || String.starts_with ~prefix:"url {" trimmed then
          (* Start of url block *)
          if String.ends_with ~suffix:"}" trimmed then
            (* Single-line url block *)
            let replacement =
              [ "url {"; Printf.sprintf {|  src: "%s"|} url_src; "}" ]
            in
            process rest false (List.rev_append replacement acc)
          else process rest true acc
        else process rest false (line :: acc)
  in
  String.concat "\n" (process lines false [])

(** Replace the dev-repo and url fields in an opam file content with a new git URL.
    The new URL should be a plain git URL (e.g., "[e-mail]:user/repo.git"). *)
let replace_dev_repo_url content ~new_url =
  let content = replace_dev_repo_line content ~new_url in
  let content = replace_url_section content ~new_url in
  content

(** Write an opam package to the opam-repo overlay.
    Creates the directory structure: packages/<name>/<name.version>/opam *)
let write_package ~fs ~repo_path ~name ~version ~content =
  let pkg_dir = Fpath.(repo_path / "packages" / name / (name ^ "." ^ version)) in
  let opam_path = Fpath.(pkg_dir / "opam") in
  let eio_pkg_dir = Eio.Path.(fs / Fpath.to_string pkg_dir) in
  let eio_opam_path = Eio.Path.(fs / Fpath.to_string opam_path) in
  try
    (* Create directory structure *)
    Eio.Path.mkdirs ~perm:0o755 eio_pkg_dir;
    (* Write opam file *)
    Eio.Path.save ~create:(`Or_truncate 0o644) eio_opam_path content;
    Ok ()
  with Eio.Io _ as e -> Error (Io_error (Printexc.to_string e))

(** Check if a package exists in the opam-repo. *)
let package_exists ~fs ~repo_path ~name =
  let pkg_dir = Fpath.(repo_path / "packages" / name) in
  let eio_path = Eio.Path.(fs / Fpath.to_string pkg_dir) in
  match Eio.Path.kind ~follow:true eio_path with
  | `Directory -> true
  | _ -> false
  | exception _ -> false