remove requests summary

tools/analyze_repos.ml

···
-open Eio.Std
-
-let src = Logs.Src.create "analyze_repos" ~doc:"Analyze HTTP client repos"
-module Log = (val Logs.src_log src : Logs.LOG)
-
-(* Helper to normalize language names for directory structure *)
-let normalize_language lang =
-  String.lowercase_ascii lang
-  |> String.map (function '/' -> '-' | c -> c)
-
-(* Helper to extract repo name from "owner/repo" format *)
-let extract_repo_name repo_path =
-  match String.rindex_opt repo_path '/' with
-  | Some idx -> String.sub repo_path (idx + 1) (String.length repo_path - idx - 1)
-  | None -> repo_path
-
-(* Parse resources.json to get list of repos *)
-let parse_resources_json json_path =
-  Log.info (fun m -> m "Parsing resources.json from %s" json_path);
-  let ic = open_in json_path in
-  let content = really_input_string ic (in_channel_length ic) in
-  close_in ic;
-
-  match Jsont_bytesrw.decode_string Jsont.json content with
-  | Ok json -> (
-      match json with
-      | Jsont.Object (fields, _) ->
-          List.fold_left (fun acc ((lang_name, _), lang_repos) ->
-            let lang_dir = normalize_language lang_name in
-            match lang_repos with
-            | Jsont.Array (repos, _) ->
-                List.fold_left (fun acc repo ->
-                  match repo with
-                  | Jsont.Object (repo_fields, _) -> (
-                      let repo_path_opt = List.assoc_opt ("repo", Jsont.Meta.none) repo_fields in
-                      match repo_path_opt with
-                      | Some (Jsont.String (repo_path, _)) ->
-                          let repo_name = extract_repo_name repo_path in
-                          let normalized_name = String.lowercase_ascii repo_name in
-                          (lang_name, lang_dir, normalized_name) :: acc
-                      | _ -> acc)
-                  | _ -> acc) acc repos
-            | _ -> acc) [] fields
-      | _ ->
-          Log.err (fun m -> m "Invalid JSON format in resources.json");
-          [])
-  | Error err ->
-      Log.err (fun m -> m "Failed to parse resources.json: %s" err);
-      []
-
-(* Check if analysis output already exists *)
-let analysis_exists repo_dir =
-  let output_path = Printf.sprintf "%s.json" repo_dir in
-  Sys.file_exists output_path
-
-(* JSON schema for recommendations *)
-let recommendation_schema =
-  let meta = Jsont.Meta.none in
-  let json_object fields = Jsont.Object (fields, meta) in
-  let json_string s = Jsont.String (s, meta) in
-  let json_array items = Jsont.Array (items, meta) in
-  let json_field name value = ((name, meta), value) in
-
-  json_object
-    [
-      json_field "type" (json_string "object");
-      json_field "properties"
-        (json_object
-           [
-             json_field "recommendations"
-               (json_object
-                  [
-                    json_field "type" (json_string "array");
-                    json_field "items"
-                      (json_object
-                         [
-                           json_field "type" (json_string "object");
-                           json_field "properties"
-                             (json_object
-                                [
-                                  json_field "source_repo"
-                                    (json_object
-                                       [ json_field "type" (json_string "string") ]);
-                                  json_field "source_language"
-                                    (json_object
-                                       [ json_field "type" (json_string "string") ]);
-                                  json_field "criticality"
-                                    (json_object
-                                       [ json_field "type" (json_string "string");
-                                         json_field "enum" (json_array [
-                                           json_string "high";
-                                           json_string "medium";
-                                           json_string "low"
-                                         ])
-                                       ]);
-                                  json_field "change_type"
-                                    (json_object
-                                       [ json_field "type" (json_string "string");
-                                         json_field "enum" (json_array [
-                                           json_string "bug";
-                                           json_string "security";
-                                           json_string "enhancement";
-                                           json_string "feature";
-                                           json_string "refactor"
-                                         ])
-                                       ]);
-                                  json_field "title"
-                                    (json_object
-                                       [ json_field "type" (json_string "string") ]);
-                                  json_field "description"
-                                    (json_object
-                                       [ json_field "type" (json_string "string") ]);
-                                  json_field "affected_files"
-                                    (json_object
-                                       [ json_field "type" (json_string "array");
-                                         json_field "items" (json_object
-                                           [ json_field "type" (json_string "string") ])
-                                       ]);
-                                  json_field "rationale"
-                                    (json_object
-                                       [ json_field "type" (json_string "string") ]);
-                                ]);
-                           json_field "required"
-                             (json_array
-                                [
-                                  json_string "source_repo";
-                                  json_string "source_language";
-                                  json_string "criticality";
-                                  json_string "change_type";
-                                  json_string "title";
-                                  json_string "description";
-                                  json_string "affected_files";
-                                  json_string "rationale";
-                                ]);
-                         ]);
-                  ]);
-           ]);
-      json_field "required" (json_array [ json_string "recommendations" ]);
-    ]
-
-(* Analyze a single repository by path *)
-let analyze_single_repo_with_env ~eio_env ~sw repo_path =
-  Log.info (fun m -> m "Analyzing repository at: %s" repo_path);
-
-  (* Check if directory exists *)
-  if not (Sys.file_exists repo_path && Sys.is_directory repo_path) then (
-    Log.warn (fun m -> m "Directory not found: %s" repo_path);
-    false
-  ) else
-
-  let output_path = Printf.sprintf "%s.json" repo_path in
-
-  Log.info (fun m -> m "Output will be saved to: %s" output_path);
-
-  (* Create Claude client with structured output *)
-  let output_format = Claude.Proto.Structured_output.of_json_schema recommendation_schema in
-  let options =
-    Claude.Options.default
-    |> Claude.Options.with_output_format output_format
-    |> Claude.Options.with_model `Sonnet_4_5
-  in
-
-  let client =
-    Claude.Client.create ~sw
-      ~process_mgr:(Eio.Stdenv.process_mgr eio_env)
-      ~clock:(Eio.Stdenv.clock eio_env)
-      ~options ()
-  in
-
-  (* Build the prompt *)
-  let prompt = Printf.sprintf
-    {|You are analyzing a HTTP client library to extract best practices and recommendations for an OCaml HTTP client library.
-
-# Your Task
-
-1. Analyze the repository at %s
-2. Compare it with the OCaml codebase provided in the current working directory (ignoring the third_party directory)
-3. Extract actionable recommendations for improving the OCaml library
-
-Focus on:
-- Error handling patterns
-- Authentication mechanisms
-- Retry/timeout strategies
-- Security best practices
-- API design and ergonomics
-- Testing approaches
-- Enhancements or missing features
-
-# Instructions
-
-Analyze the repository code and provide recommendations in the structured format requested. For each recommendation:
-- Specify criticality: high (critical bugs/security), medium (important improvements), low (nice-to-have)
-- Specify change_type: bug, security, enhancement, feature, or refactor
-- Provide specific file paths in the OCaml codebase that would be affected
-- Explain the rationale clearly
-
-Focus on practical, implementable recommendations that would meaningfully improve the OCaml library. Do not make recommendations based on specific language features in the third party library, but focus on the functionality unlocked by that feature when mapped onto the OCaml approaches used in this library.
-|}
-    repo_path
-  in
-
-  Claude.Client.query client prompt;
-
-  let responses = Claude.Client.receive_all client in
-
-  (* Extract structured output and save to file *)
-  let success = ref false in
-  List.iter (function
-    | Claude.Response.Complete result -> (
-        match Claude.Response.Complete.structured_output result with
-        | Some json ->
-            (* Write JSON directly using bytesrw-eio *)
-            let cwd = Eio.Stdenv.cwd eio_env in
-            let output_eio_path = Eio.Path.(cwd / output_path) in
-
-            (match Eio.Path.with_open_out output_eio_path
-              ~create:(`Or_truncate 0o644)
-              (fun flow ->
-                let buf_writer = Bytesrw_eio.bytes_writer_of_flow flow in
-                Jsont_bytesrw.encode ~format:Jsont.Indent Jsont.json json ~eod:true buf_writer) with
-            | Ok () ->
-                Log.info (fun m -> m "Saved recommendations to %s" output_path);
-                success := true
-            | Error err ->
-                Log.err (fun m -> m "Failed to write JSON: %s" err))
-        | None ->
-            Log.warn (fun m -> m "No structured output received"))
-    | _ -> ())
-    responses;
-
-  if !success then (
-    Log.info (fun m -> m "Analysis complete for %s" repo_path);
-    true
-  ) else (
-    Log.err (fun m -> m "Analysis failed for %s - no recommendations generated" repo_path);
-    false
-  )
-
-(* Wrapper for single repo analysis - for command line use *)
-let analyze_single_repo repo_path =
-  Eio_main.run @@ fun eio_env ->
-  Switch.run @@ fun sw ->
-  let success = analyze_single_repo_with_env ~eio_env ~sw repo_path in
-  if not success then exit 1
-
-(* Parallel analysis of multiple repos from resources.json *)
-let analyze_all_repos ?(max_parallel=8) () =
-  let resources_path = "tools/resources.json" in
-
-  if not (Sys.file_exists resources_path) then (
-    Log.err (fun m -> m "Resources file not found: %s" resources_path);
-    exit 1
-  );
-
-  let all_repos = parse_resources_json resources_path in
-  Log.info (fun m -> m "Found %d total repositories in resources.json" (List.length all_repos));
-
-  (* Filter to only repos that don't have analysis yet *)
-  let repos_to_analyze =
-    List.filter (fun (_lang_name, lang_dir, repo_name) ->
-      let repo_dir = Printf.sprintf "third_party/%s/%s" lang_dir repo_name in
-      let exists = analysis_exists repo_dir in
-      let dir_exists = Sys.file_exists repo_dir && Sys.is_directory repo_dir in
-      if exists then
-        Log.info (fun m -> m "Skipping %s (analysis already exists)" repo_dir)
-      else if not dir_exists then
-        Log.info (fun m -> m "Skipping %s (directory not found)" repo_dir)
-      else
-        Log.info (fun m -> m "Will analyze: %s" repo_dir);
-      (not exists) && dir_exists
-    ) all_repos
-  in
-
-  let count = List.length repos_to_analyze in
-  Log.info (fun m -> m "Will analyze %d repositories (max %d in parallel)" count max_parallel);
-
-  if count = 0 then (
-    Log.info (fun m -> m "No repositories need analysis. All done!");
-    exit 0
-  );
-
-  Eio_main.run @@ fun eio_env ->
-  Switch.run @@ fun _sw ->
-
-  (* Run analyses in parallel with max_fibers limiting *)
-  let final_results =
-    Fiber.List.map ~max_fibers:max_parallel (fun (_lang_name, lang_dir, repo_name) ->
-      let repo_dir = Printf.sprintf "third_party/%s/%s" lang_dir repo_name in
-      let result =
-        try
-          Switch.run @@ fun analysis_sw ->
-          analyze_single_repo_with_env ~eio_env ~sw:analysis_sw repo_dir
-        with exn ->
-          Log.err (fun m -> m "Exception analyzing %s: %s" repo_dir (Printexc.to_string exn));
-          false
-      in
-      (repo_dir, result)
-    ) repos_to_analyze
-  in
-
-  (* Report summary *)
-  let successful = List.filter snd final_results in
-  let failed = List.filter (fun (_, success) -> not success) final_results in
-
-  Log.info (fun m -> m "");
-  Log.info (fun m -> m "=== Analysis Summary ===");
-  Log.info (fun m -> m "Total: %d" count);
-  Log.info (fun m -> m "Successful: %d" (List.length successful));
-  Log.info (fun m -> m "Failed: %d" (List.length failed));
-
-  if List.length failed > 0 then (
-    Log.info (fun m -> m "");
-    Log.info (fun m -> m "Failed repositories:");
-    List.iter (fun (repo, _) -> Log.info (fun m -> m "  - %s" repo)) failed;
-    exit 1
-  )
-
-(* Command-line interface *)
-let repo_path_arg =
-  let doc = "Path to repository directory to analyze (e.g., third_party/rust/reqwest). \
-             Not required when using --all." in
-  Cmdliner.Arg.(value & pos 0 (some string) None & info [] ~docv:"REPO_PATH" ~doc)
-
-let all_flag =
-  let doc = "Analyze all repositories from tools/resources.json that don't have \
-             analysis output yet. Runs in parallel." in
-  Cmdliner.Arg.(value & flag & info ["all"; "a"] ~doc)
-
-let max_parallel_arg =
-  let doc = "Maximum number of parallel analysis sessions (default: 8). \
-             Only used with --all." in
-  Cmdliner.Arg.(value & opt int 8 & info ["max-parallel"; "j"] ~docv:"N" ~doc)
-
-let setup_log style_renderer level =
-  Fmt_tty.setup_std_outputs ?style_renderer ();
-  Logs.set_level level;
-  Logs.set_reporter (Logs_fmt.reporter ());
-  ()
-
-let setup_log_t =
-  Cmdliner.Term.(const setup_log $ Fmt_cli.style_renderer () $ Logs_cli.level ())
-
-let run all_mode max_parallel repo_path =
-  if all_mode then
-    analyze_all_repos ~max_parallel ()
-  else
-    match repo_path with
-    | Some path -> analyze_single_repo path
-    | None ->
-        prerr_endline "Error: REPO_PATH required unless --all is specified";
-        exit 1
-
-let () =
-  let combined_term = Cmdliner.Term.(const (fun () all max_parallel repo_path ->
-    run all max_parallel repo_path)
-    $ setup_log_t $ all_flag $ max_parallel_arg $ repo_path_arg) in
-  let combined_info = Cmdliner.Cmd.info "analyze_repos" ~version:"2.0"
-    ~doc:"Analyze HTTP client repositories and generate recommendations."
-    ~man:[
-      `S Cmdliner.Manpage.s_description;
-      `P "Analyzes HTTP client libraries from third_party/ and generates \
-          structured recommendations for improving the OCaml requests library.";
-      `P "Two modes are supported:";
-      `P "1. Single repository mode (default): Analyze one specific repository \
-          by providing its path as an argument.";
-      `P "2. Batch mode (--all): Analyze all repositories listed in \
-          tools/resources.json that don't have analysis output yet, \
-          running multiple analyses in parallel.";
-      `S Cmdliner.Manpage.s_examples;
-      `P "Analyze a single repository:";
-      `Pre "  $(b,analyze_repos) third_party/php/buzz";
-      `P "Analyze all repositories with default parallelism (8):";
-      `Pre "  $(b,analyze_repos) --all";
-      `P "Analyze all repositories with custom parallelism:";
-      `Pre "  $(b,analyze_repos) --all --max-parallel 4";
-    ] in
-  exit (Cmdliner.Cmd.eval (Cmdliner.Cmd.v combined_info combined_term))

tools/clone_repos.ml

···
-type library = {
-  language : string;
-  name : string;
-  repo : string;
-}
-
-let library_of_json language json =
-  let open Yojson.Basic.Util in
-  {
-    language;
-    name = json |> member "name" |> to_string;
-    repo = json |> member "repo" |> to_string;
-  }
-
-let libraries_from_resources json =
-  let open Yojson.Basic.Util in
-  to_assoc json
-  |> List.concat_map (fun (language, repos) ->
-      to_list repos
-      |> List.map (library_of_json language))
-
-let sanitize_name name =
-  (* Convert name to a safe directory name *)
-  let s = String.lowercase_ascii name in
-  (* Replace spaces and special chars with dashes *)
-  let s = Str.global_replace (Str.regexp "[^a-z0-9-]") "-" s in
-  (* Remove multiple consecutive dashes *)
-  Str.global_replace (Str.regexp "-+") "-" s
-
-(* Sanitize language name to handle special cases like "Bash/Shell" *)
-let sanitize_language lang =
-  let s = String.lowercase_ascii lang in
-  (* Replace / with - for languages like "Bash/Shell" *)
-  Str.global_replace (Str.regexp "/") "-" s
-
-let clone_repository env lib base_dir =
-  let lang_dir = sanitize_language lib.language in
-  let repo_name = sanitize_name lib.name in
-  let lang_path = Filename.concat base_dir lang_dir in
-  let repo_path = Filename.concat lang_path repo_name in
-
-  (* Check if repository already exists *)
-  let cwd = Eio.Stdenv.cwd env in
-  let repo_eio_path = Eio.Path.(cwd / repo_path) in
-
-  let exists =
-    try
-      Eio.Path.is_directory repo_eio_path
-    with Eio.Io (Eio.Fs.E Not_found _, _) -> false
-  in
-
-  if exists then (
-    Printf.printf "Skip: %s/%s (already exists)\n%!" lib.language lib.name
-  ) else (
-    let url = Printf.sprintf "https://github.com/%s.git" lib.repo in
-    Printf.printf "Cloning: %s/%s from %s\n%!" lib.language lib.name url;
-
-    (* Create language directory with parents *)
-    Eio.Path.mkdirs ~exists_ok:true ~perm:0o755 Eio.Path.(cwd / lang_path);
-
-    (* Clone with --depth 1 for shallow clone to save space and time *)
-    try
-      Eio.Process.run ~cwd
-        (Eio.Stdenv.process_mgr env)
-        ["git"; "clone"; "--depth"; "1"; url; repo_path];
-      Printf.printf "  ✓ Success: %s\n%!" lib.name
-    with ex ->
-      Printf.printf "  ✗ Failed: %s (%s)\n%!" lib.name (Printexc.to_string ex)
-  )
-
-let run env json_file =
-  let cwd = Eio.Stdenv.cwd env in
-  let json_str =
-    try
-      Eio.Path.load Eio.Path.(cwd / json_file)
-    with ex ->
-      Printf.eprintf "Error reading %s: %s\n" json_file (Printexc.to_string ex);
-      exit 1
-  in
-
-  (* Parse JSON *)
-  let json = Yojson.Basic.from_string json_str in
-  let libraries = libraries_from_resources json in
-
-  (* Get third_party directory *)
-  let third_party_dir = "third_party" in
-
-  (* Create third_party if it doesn't exist *)
-  Eio.Path.mkdirs ~exists_ok:true ~perm:0o755 Eio.Path.(cwd / third_party_dir);
-
-  (* Clone each repository *)
-  Printf.printf "Cloning %d repositories into %s/\n\n%!"
-    (List.length libraries) third_party_dir;
-
-  List.iter (fun lib -> clone_repository env lib third_party_dir) libraries;
-
-  Printf.printf "\nDone! Cloned repositories are in %s/\n%!" third_party_dir
-
-let () =
-  Eio_main.run @@ fun env ->
-  (* Read JSON from resources.json file *)
-  let json_file =
-    if Array.length Sys.argv > 1 then
-      Sys.argv.(1)
-    else
-      "tools/resources.json"
-  in
-  run env json_file

tools/dune

···
-(executables
- (names clone_repos analyze_repos summarise_recommendations)
- (libraries
-  eio
-  eio.unix
-  eio_main
-  yojson
-  str
-  claude
-  jsont
-  bytesrw
-  bytesrw-eio
-  cmdliner
-  logs
-  logs.cli
-  logs.fmt
-  fmt.tty
-  fmt.cli))
-
-(rule
- (targets resources.json.download)
- (action
-  (progn
-   (run curl -L -o resources.json.download
-    "https://raw.githubusercontent.com/easybase/awesome-http/refs/heads/main/resources.json"))))
-
-(rule
- (alias runtest)
- (action
-  (diff resources.json resources.json.download)))

tools/resources.json

···
-{
-    "JavaScript": [
-        {
-            "name": "Axios",
-            "repo": "axios/axios"
-        },
-        {
-            "name": "node-fetch",
-            "repo": "node-fetch/node-fetch"
-        },
-        {
-            "name": "Got",
-            "repo": "sindresorhus/got"
-        },
-        {
-            "name": "superagent",
-            "repo": "visionmedia/superagent"
-        },
-        {
-            "name": "Needle",
-            "repo": "tomas/needle"
-        }
-    ],
-    "Python": [
-        {
-            "name": "Requests",
-            "repo": "psf/requests"
-        },
-        {
-            "name": "urllib3",
-            "repo": "urllib3/urllib3"
-        },
-        {
-            "name": "httplib2",
-            "repo": "httplib2/httplib2"
-        },
-        {
-            "name": "GRequests",
-            "repo": "spyoungtech/grequests"
-        },
-        {
-            "name": "Uplink",
-            "repo": "prkumar/uplink"
-        }
-    ],
-    "Java": [
-        {
-            "name": "Eclipse Jetty",
-            "repo": "eclipse/jetty.project"
-        },
-        {
-            "name": "OkHttp",
-            "repo": "square/okhttp"
-        },
-        {
-            "name": "Heritrix",
-            "repo": "internetarchive/heritrix3"
-        },
-        {
-            "name": "Apache HttpClient",
-            "repo": "apache/httpcomponents-client"
-        },
-        {
-            "name": "Google HTTP Client Library",
-            "repo": "googleapis/google-http-java-client"
-        },
-        {
-            "name": "Http Request",
-            "repo": "kevinsawicki/http-request"
-        }
-    ],
-    "Rust": [
-        {
-            "name": "reqwest",
-            "repo": "seanmonstar/reqwest"
-        },
-        {
-            "name": "hyper",
-            "repo": "hyperium/hyper"
-        },
-        {
-            "name": "Isahc",
-            "repo": "sagebind/isahc"
-        },
-        {
-            "name": "Surf",
-            "repo": "http-rs/surf"
-        },
-        {
-            "name": "curl-rust",
-            "repo": "alexcrichton/curl-rust"
-        }
-    ],
-    "Swift": [
-        {
-            "name": "Alamofire",
-            "repo": "Alamofire/Alamofire"
-        },
-        {
-            "name": "SwiftHTTP",
-            "repo": "daltoniam/SwiftHTTP"
-        },
-        {
-            "name": "Net",
-            "repo": "nghialv/Net"
-        },
-        {
-            "name": "Moya",
-            "repo": "Moya/Moya"
-        },
-        {
-            "name": "Just",
-            "repo": "dduan/Just"
-        },
-        {
-            "name": "Kingfisher",
-            "repo": "onevcat/Kingfisher"
-        }
-    ],
-    "Haskell": [
-        {
-            "name": "Req",
-            "repo": "mrkkrp/req"
-        },
-        {
-            "name": "http-client",
-            "repo": "snoyberg/http-client"
-        },
-        {
-            "name": "servant-client",
-            "repo": "haskell-servant/servant"
-        },
-        {
-            "name": "http-streams",
-            "repo": "aesiniath/http-streams"
-        }
-    ],
-    "Go": [
-        {
-            "name": "Req",
-            "repo": "imroc/req"
-        },
-        {
-            "name": "Resty",
-            "repo": "go-resty/resty"
-        },
-        {
-            "name": "Sling",
-            "repo": "dghubble/sling"
-        },
-        {
-            "name": "requests",
-            "repo": "asmcos/requests"
-        }
-    ],
-    "C++": [
-        {
-            "name": "Apache Serf",
-            "repo": "apache/serf"
-        },
-        {
-            "name": "Curl for People",
-            "repo": "libcpr/cpr"
-        },
-        {
-            "name": "cpp-netlib",
-            "repo": "cpp-netlib/cpp-netlib"
-        },
-        {
-            "name": "Webcc",
-            "repo": "sprinfall/webcc"
-        },
-        {
-            "name": "Proxygen",
-            "repo": "facebook/proxygen"
-        },
-        {
-            "name": "cpp-httplib",
-            "repo": "yhirose/cpp-httplib"
-        },
-        {
-            "name": "NFHTTP",
-            "repo": "spotify/NFHTTP"
-        },
-        {
-            "name": "EasyHttp",
-            "repo": "sony/easyhttpcpp"
-        }
-    ],
-    "PHP": [
-        {
-            "name": "Guzzle",
-            "repo": "guzzle/guzzle"
-        },
-        {
-            "name": "HTTPlug",
-            "repo": "php-http/httplug"
-        },
-        {
-            "name": "HTTP Client",
-            "repo": "amphp/http-client"
-        },
-        {
-            "name": "SendGrid HTTP Client",
-            "repo": "sendgrid/php-http-client"
-        },
-        {
-            "name": "Buzz",
-            "repo": "kriswallsmith/Buzz"
-        }
-    ],
-    "Bash/Shell": [
-        {
-            "name": "HTTPie",
-            "repo": "httpie/httpie"
-        },
-        {
-            "name": "curl",
-            "repo": "curl/curl"
-        },
-        {
-            "name": "aria2",
-            "repo": "aria2/aria2"
-        },
-        {
-            "name": "HTTP Prompt",
-            "repo": "httpie/http-prompt"
-        },
-        {
-            "name": "Resty",
-            "repo": "micha/resty"
-        },
-        {
-            "name": "Ain",
-            "repo": "jonaslu/ain"
-        }
-    ]
-}

tools/summarise_recommendations.ml

···
-open Eio.Std
-
-let src = Logs.Src.create "summarise_recommendations" ~doc:"Summarise recommendations from analyzed repos"
-module Log = (val Logs.src_log src : Logs.LOG)
-
-(* JSON schema for the summary output *)
-let summary_schema =
-  let meta = Jsont.Meta.none in
-  let json_object fields = Jsont.Object (fields, meta) in
-  let json_string s = Jsont.String (s, meta) in
-  let json_array items = Jsont.Array (items, meta) in
-  let json_field name value = ((name, meta), value) in
-
-  json_object
-    [
-      json_field "type" (json_string "object");
-      json_field "properties"
-        (json_object
-           [
-             json_field "executive_summary"
-               (json_object [ json_field "type" (json_string "string") ]);
-             json_field "priority_features"
-               (json_object
-                  [
-                    json_field "type" (json_string "array");
-                    json_field "items"
-                      (json_object
-                         [
-                           json_field "type" (json_string "object");
-                           json_field "properties"
-                             (json_object
-                                [
-                                  json_field "priority_rank"
-                                    (json_object [ json_field "type" (json_string "integer") ]);
-                                  json_field "category"
-                                    (json_object
-                                       [ json_field "type" (json_string "string");
-                                         json_field "enum" (json_array [
-                                           json_string "Security & Spec Compliance";
-                                           json_string "Feature Enhancements";
-                                           json_string "Architectural Improvements"
-                                         ])
-                                       ]);
-                                  json_field "title"
-                                    (json_object [ json_field "type" (json_string "string") ]);
-                                  json_field "description"
-                                    (json_object [ json_field "type" (json_string "string") ]);
-                                  json_field "rfc_references"
-                                    (json_object
-                                       [ json_field "type" (json_string "array");
-                                         json_field "items" (json_object [ json_field "type" (json_string "string") ])
-                                       ]);
-                                  json_field "source_libraries"
-                                    (json_object
-                                       [ json_field "type" (json_string "array");
-                                         json_field "items" (json_object [ json_field "type" (json_string "string") ])
-                                       ]);
-                                  json_field "affected_files"
-                                    (json_object
-                                       [ json_field "type" (json_string "array");
-                                         json_field "items" (json_object [ json_field "type" (json_string "string") ])
-                                       ]);
-                                  json_field "implementation_notes"
-                                    (json_object [ json_field "type" (json_string "string") ]);
-                                  json_field "cross_language_consensus"
-                                    (json_object [ json_field "type" (json_string "integer") ]);
-                                ]);
-                           json_field "required"
-                             (json_array [
-                               json_string "priority_rank";
-                               json_string "category";
-                               json_string "title";
-                               json_string "description";
-                               json_string "rfc_references";
-                               json_string "source_libraries";
-                               json_string "affected_files";
-                               json_string "implementation_notes";
-                               json_string "cross_language_consensus";
-                             ]);
-                         ]);
-                  ]);
-           ]);
-      json_field "required" (json_array [
-        json_string "executive_summary";
-        json_string "priority_features"
-      ]);
-    ]
-
-(* Build markdown output from Claude's structured response *)
-let build_markdown_from_json json =
-  let buf = Buffer.create 4096 in
-
-  let add_line s = Buffer.add_string buf s; Buffer.add_char buf '\n' in
-  let add_lines lines = List.iter add_line lines in
-
-  add_lines [
-    "# OCaml HTTP Client Library - Priority Feature Recommendations";
-    "";
-    "> Auto-generated summary of recommendations from analyzing HTTP client libraries across multiple languages.";
-    "";
-  ];
-
-  match json with
-  | Jsont.Object (fields, _) ->
-      (* Executive summary *)
-      (match List.assoc_opt ("executive_summary", Jsont.Meta.none) fields with
-       | Some (Jsont.String (summary, _)) ->
-           add_lines [
-             "## Executive Summary";
-             "";
-             summary;
-             "";
-           ]
-       | _ -> ());
-
-      (* Priority features *)
-      (match List.assoc_opt ("priority_features", Jsont.Meta.none) fields with
-       | Some (Jsont.Array (features, _)) ->
-           let current_category = ref "" in
-           List.iter (fun feature ->
-             match feature with
-             | Jsont.Object (ffields, _) ->
-                 let get_string key =
-                   match List.assoc_opt (key, Jsont.Meta.none) ffields with
-                   | Some (Jsont.String (s, _)) -> s
-                   | _ -> ""
-                 in
-                 let get_int key =
-                   match List.assoc_opt (key, Jsont.Meta.none) ffields with
-                   | Some (Jsont.Number (n, _)) -> int_of_float n
-                   | _ -> 0
-                 in
-                 let get_string_list key =
-                   match List.assoc_opt (key, Jsont.Meta.none) ffields with
-                   | Some (Jsont.Array (items, _)) ->
-                       List.filter_map (function
-                         | Jsont.String (s, _) -> Some s
-                         | _ -> None) items
-                   | _ -> []
-                 in
-
-                 let category = get_string "category" in
-                 let title = get_string "title" in
-                 let description = get_string "description" in
-                 let rfc_refs = get_string_list "rfc_references" in
-                 let source_libs = get_string_list "source_libraries" in
-                 let affected = get_string_list "affected_files" in
-                 let impl_notes = get_string "implementation_notes" in
-                 let consensus = get_int "cross_language_consensus" in
-                 let rank = get_int "priority_rank" in
-
-                 (* Add category header if changed *)
-                 if category <> !current_category then begin
-                   current_category := category;
-                   add_lines [
-                     "";
-                     "---";
-                     "";
-                     Printf.sprintf "## %s" category;
-                     "";
-                   ]
-                 end;
-
-                 (* Feature entry *)
-                 add_line (Printf.sprintf "### %d. %s" rank title);
-                 add_line "";
-                 add_line description;
-                 add_line "";
-
-                 (* RFC references *)
-                 if List.length rfc_refs > 0 then begin
-                   add_line "**RFC References:**";
-                   List.iter (fun rfc ->
-                     add_line (Printf.sprintf "- %s" rfc)
-                   ) rfc_refs;
-                   add_line ""
-                 end;
-
-                 (* Source libraries *)
-                 if List.length source_libs > 0 then begin
-                   add_line (Printf.sprintf "**Cross-Language Consensus:** %d libraries" consensus);
-                   add_line (Printf.sprintf "**Source Libraries:** %s" (String.concat ", " source_libs));
-                   add_line ""
-                 end;
-
-                 (* Affected files *)
-                 if List.length affected > 0 then begin
-                   add_line "**Affected Files:**";
-                   List.iter (fun f -> add_line (Printf.sprintf "- `%s`" f)) affected;
-                   add_line ""
-                 end;
-
-                 (* Implementation notes *)
-                 if impl_notes <> "" then begin
-                   add_line "**Implementation Notes:**";
-                   add_line impl_notes;
-                   add_line ""
-                 end
-             | _ -> ()
-           ) features
-       | _ -> ());
-
-      Buffer.contents buf
-  | _ ->
-      add_line "Error: Invalid JSON structure received from Claude.";
-      Buffer.contents buf
-
-(* Main summarization function *)
-let summarise ~eio_env ~sw output_path =
-  Log.info (fun m -> m "Starting recommendation summarization...");
-
-
-  let prompt = Printf.sprintf {|You are analyzing recommendations for an OCaml HTTP client library. Your task is to synthesize ALL recommendations into a prioritized summary.
-
-CRITICAL: You MUST systematically process EVERY SINGLE recommendation listed below. Do not skip any. Read through all recommendations completely before synthesizing.
-
-# Available RFC Specifications
-
-Read these from the spec/ directory
-
-# COMPLETE LIST OF ALL RECOMMENDATIONS
-
-The third_party/ directory contains a COMPLETE list of recommendations extracted from third-party HTTP client libraries. You MUST consider EVERY recommendation when creating your summary. The structure is third_party/<language>/<library> for the sources, with the recommendation for that library in third_party/<language>/<library>.json.  Only those JSON files should be considered and not ones inside the third-party library sournes.
-
-# Your Task
-
-Systematically analyze ALL recommendations above and create a comprehensive summary of priority features to implement. You MUST:
-
-1. **Process ALL recommendations** - Do not skip any recommendation. Each one above must be considered and either grouped with similar ones or noted individually.
-
-2. **Prioritize by category** in this exact order:
-   - "Security & Spec Compliance" - Security vulnerabilities, RFC/spec violations, authentication issues, TLS/certificate handling
-   - "Feature Enhancements" - New functionality, missing features that multiple libraries implement
-   - "Architectural Improvements" - Code quality, patterns, refactoring, developer experience
-
-3. **Group similar recommendations** - Many libraries recommend the same features (e.g., multiple suggest "middleware/hooks", "circuit breakers", "response body size limits"). Identify ALL these patterns across all recommendations.
-
-4. **Reference specific RFC sections** where applicable using format like "RFC 9110 Section 10.2.3 (Retry-After)". Use the RFC specifications listed above.
-
-5. **Calculate cross-language consensus** - Count how many different languages/libraries recommend similar functionality. This should reflect the ACTUAL count from the recommendations above.
-
-6. **Provide implementation notes** - Briefly describe what implementing this would involve.
-
-Create 20-30 priority features that comprehensively cover ALL the recommendations above. For recommendations that don't fit into groups, include them as individual items if they are high or medium criticality.
-
-For each priority feature, ensure you:
-- Use the exact category names specified above
-- Include all RFC references that apply
-- List which source libraries (from the recommendations above) suggested similar functionality
-- Specify which OCaml files would need changes
-- Provide brief, actionable implementation guidance
-|}
-  in
-
-  (* Create Claude client *)
-  let output_format = Claude.Proto.Structured_output.of_json_schema summary_schema in
-  let options =
-    Claude.Options.default
-    |> Claude.Options.with_output_format output_format
-    |> Claude.Options.with_model (`Custom "claude-opus-4-5")
-  in
-
-  let client =
-    Claude.Client.create ~sw
-      ~process_mgr:(Eio.Stdenv.process_mgr eio_env)
-      ~clock:(Eio.Stdenv.clock eio_env)
-      ~options ()
-  in
-
-  Claude.Client.query client prompt;
-  let responses = Claude.Client.receive_all client in
-
-  (* Process response *)
-  let success = ref false in
-  List.iter (function
-    | Claude.Response.Complete result -> (
-        match Claude.Response.Complete.structured_output result with
-        | Some json ->
-            (* Build markdown from JSON *)
-            let markdown = build_markdown_from_json json in
-
-            (* Write markdown output *)
-            let cwd = Eio.Stdenv.cwd eio_env in
-            let md_path = Eio.Path.(cwd / output_path) in
-
-            Eio.Path.save ~create:(`Or_truncate 0o644) md_path markdown;
-            Log.info (fun m -> m "Saved summary to %s" output_path);
-
-            (* Also save the raw JSON *)
-            let json_output_path = (Filename.remove_extension output_path) ^ ".json" in
-            let json_path = Eio.Path.(cwd / json_output_path) in
-
-            (match Eio.Path.with_open_out json_path
-              ~create:(`Or_truncate 0o644)
-              (fun flow ->
-                let buf_writer = Bytesrw_eio.bytes_writer_of_flow flow in
-                Jsont_bytesrw.encode ~format:Jsont.Indent Jsont.json json ~eod:true buf_writer) with
-            | Ok () ->
-                Log.info (fun m -> m "Saved JSON to %s" json_output_path)
-            | Error err ->
-                Log.warn (fun m -> m "Failed to write JSON: %s" err));
-
-            success := true
-        | None ->
-            Log.warn (fun m -> m "No structured output received from Claude"))
-    | _ -> ())
-    responses;
-
-  if not !success then begin
-    Log.err (fun m -> m "Summarization failed - no output generated");
-    exit 1
-  end
-
-(* Command-line interface *)
-let output_path_arg =
-  let doc = "Output path for the summary markdown file (default: RECOMMENDATIONS.md)" in
-  Cmdliner.Arg.(value & opt string "RECOMMENDATIONS.md" & info ["o"; "output"] ~docv:"PATH" ~doc)
-
-let setup_log style_renderer level =
-  Fmt_tty.setup_std_outputs ?style_renderer ();
-  Logs.set_level level;
-  Logs.set_reporter (Logs_fmt.reporter ());
-  ()
-
-let setup_log_t =
-  Cmdliner.Term.(const setup_log $ Fmt_cli.style_renderer () $ Logs_cli.level ())
-
-let run output_path =
-  Eio_main.run @@ fun eio_env ->
-  Switch.run @@ fun sw ->
-  summarise ~eio_env ~sw output_path
-
-let () =
-  let combined_term = Cmdliner.Term.(const (fun () output_path ->
-    run output_path)
-    $ setup_log_t $ output_path_arg) in
-  let combined_info = Cmdliner.Cmd.info "summarise_recommendations" ~version:"1.0"
-    ~doc:"Summarise recommendations from analyzed HTTP client repositories."
-    ~man:[
-      `S Cmdliner.Manpage.s_description;
-      `P "Reads all recommendation JSON files from third_party/, analyzes them \
-          using Claude, and generates a prioritized summary markdown document.";
-      `P "The summary prioritizes recommendations in this order:";
-      `P "1. Security & Spec Compliance - Security issues and RFC violations";
-      `P "2. Feature Enhancements - New functionality with cross-language consensus";
-      `P "3. Architectural Improvements - Code quality and patterns";
-      `S Cmdliner.Manpage.s_examples;
-      `P "Generate summary with default output path:";
-      `Pre "  $(b,summarise_recommendations)";
-      `P "Generate summary to custom path:";
-      `Pre "  $(b,summarise_recommendations) -o docs/priorities.md";
-    ] in
-  exit (Cmdliner.Cmd.eval (Cmdliner.Cmd.v combined_info combined_term))