Added tooling documentation

The new files in `docs/` explain:
1. How to get one's editor to play nice with HLS
   and the Gargantext project
2. To interact with the server/database from within GHCI

A reference to them has been added to the `README`.

README.md

@@ -188,6 +188,13 @@ When a devlopment is needed on libraries (for instance, the HAL crawler in https
 
 > Note: without `stack.yaml` we would have to only fix `cabal.project` -> `source-repository-package` commit id. Sha256 is there to make sure CI reruns the tests.
 
+### Tooling info
+
+Once you get Gargantext to compile and run on your machine, you will likely want
+the following:
+- Language support (intellisense) in your editor; see `docs/editor_setup.md`
+- Being able to send commands to the Gargantext server from GHCI; see `docs/running_commands.md`
+
 ## Use Cases <a name="use-cases"></a>
 
 ### Multi-User with Graphical User Interface (Server Mode)

docs/editor_setup.md

+Editor Setup
+=============
+
+This document tells you how to turn VSCodium into a Haskell integrated
+development environment (IDE). Hopefully, the process looks roughly the same
+with any editor that supports the language server protocol (LSP).
+
+1. Install [the VSCodium editor](https://vscodium.com/#install)
+2. Install [direnv](https://direnv.net/docs/installation.html) on your system
+3. Install [GHCup](https://www.haskell.org/ghcup/install/).
+   During the installation process, it will ask you whether to install
+   haskell-language-server (HLS); accept.
+4. Install the following VSCodium extensions using VSCodium's built-in
+   package manager (the "Extensions" tab on the left):
+   - [direnv](https://open-vsx.org/vscode/item?itemName=mkhl.direnv).
+     Warning: there are several extensions with that name; choose the one by `mkhl`
+   - [Haskell](https://open-vsx.org/vscode/item?itemName=haskell.haskell)
+
+Restart VSCodium, open the `haskell-gargantext` project. Wait a few seconds;
+you might get a popup telling you that GHCup needs to download some version
+of GHC; accept.
+
+Now *if everything went well*, you should have Haskell intellisense working
+in your editor: hover over a symbol to get its type and documentation,
+right-click a symbol and click "Jump to definition" to jump to its definition,
+etc.
+
+Sadly, there is a good chance that something did go wrong. To help you
+troubleshoot, here's a rundown of what should have happened under the hood when
+you opened the project — assuming I didn't misunderstand anything:
+1. The `direnv` extension sees the `.envrc` file at the root of the project,
+   and sets the environment variables accordingly (all `.envrc` actually says
+   is to use a Nix shell).
+2. The `haskell` extension looks up what version of GHC is needed and tells that
+   to GHCup.
+3. If needed, GHCup downloads the right version of GHC for the project and adds
+   it to its collection of GHC compilers in `~/.ghcup/ghc/`
+4. Now the `haskell` extension has everything it needs.
+
+Things to try if something goes wrong
+--------------------------------------
+
+- Make sure that you have compiled the project before.
+
+- The current HLS version might be too recent to work with your GHC version.
+  To check that and use an adequate HLS version:
+  - Check out the project's GHC version around the beginning of `cabal.project`;
+  - Look up the corresponding "Last supporting HLS version" in [this table](https://haskell-language-server.readthedocs.io/en/latest/support/ghc-version-support.html#current-ghc-version-support-status).
+    For instance, if the project's GHC version is 9.4.7, you need HLS v2.5.0.0 *at most*.
+  - Tell GHCup to compile the corresponding version of HLS based the corresponding version of GHC,
+    with the following command (again, using GHC 9.4.7 as an example):
+    ```shell
+    $ ghcup compile hls --version 2.5.0.0 --ghc 9.4.7
+    ```
+  Now in principle the VSCodium `haskell` extension should have everything
+  it needs to provide Intellisense.

docs/running_commands.md

+Running commands from the REPL
+===============================
+
+You can interact with the Gargantext server directly from GHCI, the Haskell REPL.
+This saves you the need to have the frontend running, and it allows you
+to interact directly using types and functions defined in the backend source.
+
+Launching and setting up the REPL
+----------------------------------
+
+**From within a Nix shell** (as indicated here by the `n$` prompt —
+don't type it!), run:
+```shell
+n$ cabal repl
+```
+
+Wait for the Gargantext modules to compile. You're now in GHCI.
+Import the custom prelude, as well as the `runCmdReplServantErr` function:
+```haskell
+ghci> import Gargantext.Prelude
+ghci> import Gargantext.API.Dev (runCmdReplServantErr)
+```
+> `runCmdReplServantErr` is a variant of the `runCmd` function (defined in
+> `Gargantext.Database.Prelude`) designed to be called directly from the REPL.
+
+You might miss some symbols not in the Gargantext prelude, such as `String`.
+If you need such symbols, you can of course just import them directly, like so:
+```haskell
+ghci> import GHC.Base (String)
+```
+
+Running commands
+-----------------
+
+Make sure that:
+- The database is up,
+- The Gargantext server is running locally.
+
+Write the command you want to run by defining a value of type
+`Cmd'' DevEnv ServerError a`, then apply `runCmdReplServantErr` to it and run
+the resulting action from within the REPL.
+
+The server should have run teh command and updated the database accordingly.
+
+Saving your REPL setup
+-----------------------
+
+To avoid typing all of that every time, and saving your own helper functions,
+you can define your own module somewhere in the hierarchy. For instance,
+you could write something like
+```haskell
+module Gargantext.ReplHelper where
+
+import Gargantext.Prelude
+import Gargantext.API.Dev (runCmdReplServantErr)
+import GHC.Base (String)
+
+runMyCustomCommand :: IO ()
+runMyCustomCommand = runCmdReplServantErr ... -- insert your command here
+```
+in `src/Gargantext/ReplHelper.hs`. You'll also need to edit `gargantext.cabal`
+to tell it about your new module:
+```cabal
+...
+library
+  import:
+    defaults
+  exposed-modules:
+      Gargantext.ReplHelper
+      Gargantext
+      Gargantext.API
+...
+```
+
+Once you have added/edited your REPL helper module, you can live-reload
+and import it from within GHCI:
+```haskell
+ghci> :r
+ghci> import Gargantext.ReplHelper
+```
+Alternatively, restarting GHCI will reload the module, but it will also recompile
+everything.