:sparkles: Suggest and run similar command if detected typo

CHANGELOG.md

···
 # Changelog
 
+## v1.2.0 - 2024-08-12
+
+- ✨ Birdie can now suggest and run the correct command if it can tell you've
+  made a typo.
+
 ## v1.1.8 - 2024-05-28
 
 - ⬆️ Update `stdlib` to `>= 0.39.0 and < 1.0.0`

gleam.toml

···
 filepath = ">= 1.0.0 and < 2.0.0"
 trie_again = ">= 1.1.2 and < 2.0.0"
 simplifile = ">= 2.0.1 and < 3.0.0"
+edit_distance = ">= 2.0.1 and < 3.0.0"
 
 [dev-dependencies]
 gleeunit = ">= 1.2.0 and < 2.0.0"

manifest.toml

···
 
 packages = [
   { name = "argv", version = "1.0.2", build_tools = ["gleam"], requirements = [], otp_app = "argv", source = "hex", outer_checksum = "BA1FF0929525DEBA1CE67256E5ADF77A7CDDFE729E3E3F57A5BDCAA031DED09D" },
+  { name = "edit_distance", version = "2.0.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "edit_distance", source = "hex", outer_checksum = "A1E485C69A70210223E46E63985FA1008B8B2DDA9848B7897469171B29020C05" },
   { name = "filepath", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "EFB6FF65C98B2A16378ABC3EE2B14124168C0CE5201553DE652E2644DCFDB594" },
   { name = "glance", version = "0.11.0", build_tools = ["gleam"], requirements = ["gleam_stdlib", "glexer"], otp_app = "glance", source = "hex", outer_checksum = "8F3314D27773B7C3B9FB58D8C02C634290422CE531988C0394FA0DF8676B964D" },
   { name = "gleam_community_ansi", version = "1.4.0", build_tools = ["gleam"], requirements = ["gleam_community_colour", "gleam_stdlib"], otp_app = "gleam_community_ansi", source = "hex", outer_checksum = "FE79E08BF97009729259B6357EC058315B6FBB916FAD1C2FF9355115FEB0D3A4" },
···
 
 [requirements]
 argv = { version = ">= 1.0.2 and < 2.0.0" }
+edit_distance = { version = ">= 2.0.1 and < 3.0.0" }
 filepath = { version = ">= 1.0.0 and < 2.0.0" }
 glance = { version = ">= 0.11.0 and < 1.0.0" }
 gleam_community_ansi = { version = ">= 1.4.0 and < 2.0.0" }

src/birdie.gleam

···
 import birdie/internal/diff.{type DiffLine, DiffLine}
 import birdie/internal/project
 import birdie/internal/titles
+import edit_distance/levenshtein
 import filepath
 import gleam/bool
 import gleam/erlang
···
 
 // --- CLI COMMAND -------------------------------------------------------------
 
+type Command {
+  Review
+  AcceptAll
+  RejectAll
+  Help
+}
+
+fn command_to_string(command: Command) -> String {
+  case command {
+    Review -> "review"
+    AcceptAll -> "accept-all"
+    RejectAll -> "reject-all"
+    Help -> "help"
+  }
+}
+
 /// Reviews the snapshots in the project's folder.
 /// This function will behave differently depending on the command line
 /// arguments provided to the program.
···
 /// > and checked with the vcs you're using.
 ///
 pub fn main() -> Nil {
-  case argv.load().arguments {
-    [] | ["review"] -> report_status(review())
-    ["accept-all"] | ["accept", "all"] -> report_status(accept_all())
-    ["reject-all"] | ["reject", "all"] -> report_status(reject_all())
-    ["help"] -> help()
-    [subcommand] -> unexpected_subcommand(subcommand)
-    subcommands -> more_than_one_command(subcommands)
+  let args = argv.load().arguments
+  case parse_command(args) {
+    Ok(command) -> run_command(command)
+    Error(_) ->
+      case args {
+        [subcommand] ->
+          case closest_command(subcommand) {
+            Ok(command) -> suggest_run_command(subcommand, command)
+            Error(Nil) -> unexpected_subcommand(subcommand)
+          }
+        subcommands -> more_than_one_command(subcommands)
+      }
+  }
+}
+
+fn parse_command(arguments: List(String)) {
+  case arguments {
+    [] | ["review"] -> Ok(Review)
+    ["accept-all"] | ["accept", "all"] -> Ok(AcceptAll)
+    ["reject-all"] | ["reject", "all"] -> Ok(RejectAll)
+    ["help"] -> Ok(Help)
+    _ -> Error(Nil)
+  }
+}
+
+fn run_command(command: Command) -> Nil {
+  case command {
+    Review -> report_status(review())
+    AcceptAll -> report_status(accept_all())
+    RejectAll -> report_status(reject_all())
+    Help -> help()
   }
+}
+
+fn suggest_run_command(invalid: String, command: Command) -> Nil {
+  let error_message =
+    ansi.bold("Error: ") <> "\"" <> invalid <> "\" isn't a valid subcommand."
+
+  io.println(ansi.red(error_message))
+  let msg =
+    "I think you misspelled `"
+    <> command_to_string(command)
+    <> "`, would you like me to run it instead? [Y/n] "
+
+  case erlang.get_line(msg) {
+    Error(_) -> Nil
+    Ok(line) ->
+      case string.lowercase(line) |> string.trim {
+        "yes" | "y" | "" -> run_command(command)
+        _ -> io.println("\n" <> help_text())
+      }
+  }
+}
+
+fn closest_command(to string: String) -> Result(Command, Nil) {
+  let distance = fn(c) { command_to_string(c) |> levenshtein.distance(string) }
+
+  [Review, AcceptAll, RejectAll, Help]
+  |> list.map(fn(command) { #(command, distance(command)) })
+  |> list.filter(keeping: fn(command) { command.1 <= 3 })
+  |> list.sort(fn(one, other) { int.compare(one.1, other.1) })
+  |> list.first
+  |> result.map(fn(pair) { pair.0 })
 }
 
 fn review() -> Result(Nil, Error) {

test/titles_test.gleam

···
   titles
 }
 
-fn pretty_titles(titles: titles.Titles) -> String {
+fn pretty_titles(ts: titles.Titles) -> String {
   let pretty = fn(title, info) {
     let titles.TestInfo(file: file, test_name: test_name) = info
     let title = string.pad_right(title, to: 40, with: " ")
···
   }
 
   let literals =
-    dict.to_list(titles.literals(titles))
+    dict.to_list(titles.literals(ts))
     |> list.map(fn(pair) { pretty(pair.0, pair.1) })
     |> string.join(with: "\n")
 
   let prefixes =
-    dict.to_list(titles.prefixes(titles))
+    dict.to_list(titles.prefixes(ts))
     |> list.map(fn(pair) { pretty(pair.0, pair.1) })
     |> string.join(with: "\n")