update readme, install info, error mesages, minor fix, minor score tweak

Author: curusarn

Makefile

@@ -8,10 +8,8 @@ GOFLAGS=-ldflags "-X main.version=${VERSION} -X main.commit=${REVISION}"
 build: submodules bin/resh-session-init bin/resh-collect bin/resh-postcollect bin/resh-daemon\
  bin/resh-evaluate bin/resh-sanitize bin/resh-control bin/resh-config bin/resh-inspect bin/resh-cli
 
-install: build conf/config-dev.toml
+install: build
 	scripts/install.sh
-	# Dev config
-	# cp -f conf/config-dev.toml ~/.config/resh.toml
 
 test_go:
 	# Running tests

README.md

@@ -59,17 +59,18 @@ Imagine being able to search your shell history based on both the command itself
   - :heavy_check_mark: search by keywords
   - :heavy_check_mark: relevant results show up first based on context (host, directory, git, exit status)
   - :heavy_check_mark: allow searching completely without context ("raw" mode)
-  - :white_check_mark: include a help page with keybindings and onboarding in the app
-  - :x: import and search history from before RESH was installed
+  - :heavy_check_mark: import and search history from before RESH was installed
+  - :white_check_mark: include a help with keybindings
   - :x: allow listing details for individual commands
   - :x: allow explicitly searching by metadata
 
 - :white_check_mark: Provide bindings for arrow keys
-  - :heavy_check_mark: imitate default behaviour
-  - :heavy_check_mark: save additional metadata (e.g. command was recalled using arrow keys)
+  - :heavy_check_mark: imitate default behaviour (serve recent history)
+  - :heavy_check_mark: built-in prefix search 
+  - :heavy_check_mark: serve fully dedupicated history
   - :x: use arrow down for easy sequence repeating
   - :heavy_check_mark: zsh
-  - :white_check_mark: bash *(performance issues)*
+  - :white_check_mark: bash *(off by deafult because of bash performance issues)*
 
 - :heavy_check_mark: Provide a `reshctl` utility to control and interact with the project
   - :heavy_check_mark: turn on/off resh key bindings
@@ -125,47 +126,47 @@ Check for updates and update
 reshctl update
 ```
 
-### RESH CLI tool
+### RESH SEARCH application
 
-RESH CLI searches your history by commands. It uses host, directories, git remote, and exit status to show you relevant results first.  
+RESH SEARCH app searches your history by commands. It uses host, directories, git remote, and exit status to show you relevant results first.  
 
-All this context is not in the regular shell history. RESH CLI will only search shell history that was recorded after you install this project. 
+All this context is not in the regular shell history. RESH records shell history with context to use it when searching.
 
-*I use RESH CLI everyday but please remember that it is still a prototype.*
+At first, the search application will look something like this. Some history with context and most of it without. As you can see, you can still search the history just fine.
 
-![resh cli](img/screen-resh-cli-v2-6.png)
+![resh search app](img/screen-resh-cli-v2-7-init.png)
 
-Without query, RESH CLI shows you the latest history based on the current context (host, directory, git).
+Eventually most of your history will have context and RESH SEARCH app will get more useful.
 
-![resh cli](img/screen-resh-cli-v2-6-no-query.png)
+![resh search app](img/screen-resh-cli-v2-7.png)
 
-RESH CLI tool can be bound to ctrl+R (recommended) or executed directly.
+Without a query, RESH SEARCH app shows you the latest history based on the current context (host, directory, git).
 
-Enable/disable ctrl+R binding for THIS shell session:
+![resh search app](img/screen-resh-cli-v2-7-no-query.png)
 
-```sh
-reshctl enable ctrl_r_binding
-reshctl disable ctrl_r_binding
-```
+RESH SEARCH app replaces the standard reverse search - launch it using Ctrl+R.
 
-Enable/disable for FUTURE shell sessions:
+Enable/disable the Ctrl+R keybinding:
 
 ```sh
-reshctl enable ctrl_r_binding_global
-reshctl disable ctrl_r_binding_global
+reshctl enable ctrl_r_binding
+reshctl disable ctrl_r_binding
 ```
 
-Run the RESH CLI tool as a one-off:
+You can also run the RESH SEARCH app directly as a one-off:
 
 ```sh
 resh
 ```
 
+NOTE: One feature is not available when running RESH SEARCH app directly  - arrow right won't paste the selected command onto the command line for editing.
+
 ### Arrow key bindings
 
 Resh provides arrow key bindings.
 
-These bindings do regular stepping through history and prefix search.
+These bindings provide regular stepping through history and prefix search.
+They also fully deduplicate the served history.
 
 They allow resh to record bindings usage metadata.
 
@@ -175,22 +176,14 @@ They allow resh to record bindings usage metadata.
 
 Arrow key bindings are enabled by default in zsh and they are disabled by default in bash because there are some performance issues.
 
-Enable/disable arrow key bindings for THIS shell session:
+Enable/disable arrow key bindings:
 
 ```sh
 reshctl enable arrow_key_bindings
 
 reshctl disable arrow_key_bindings
 ```
 
-Enable/disable for FUTURE shell sessions:
-
-```sh
-reshctl enable arrow_key_bindings_global
-
-reshctl disable arrow_key_bindings_global
-```
-
 See what your current setting is:
 
 ```sh

cmd/cli/item.go

@@ -267,7 +267,7 @@ func properMatch(str, term, padChar string) bool {
 func newItemFromRecordForQuery(record records.CliRecord, query query, debug bool) (item, error) {
 	// Use numbers that won't add up to same score for any number of query words
 	const hitScore = 1.307
-	const properMatchScore = 0.603
+	const properMatchScore = 0.503
 	const hitScoreConsecutive = 0.002
 
 	// Host penalty

cmd/cli/main.go

@@ -378,9 +378,9 @@ func (m manager) Layout(g *gocui.Gui) error {
 	v.Editable = true
 	v.Editor = m
 	if m.s.rawMode {
-		v.Title = " RESH CLI - NON-CONTEXTUAL \"RAW\" MODE - (CTRL+R to switch BACK) "
+		v.Title = " RESH SEARCH - NON-CONTEXTUAL \"RAW\" MODE - (CTRL+R to switch BACK) "
 	} else {
-		v.Title = " RESH CLI - CONTEXTUAL MODE - (CTRL+R to switch to RAW MODE) "
+		v.Title = " RESH SEARCH - CONTEXTUAL MODE - (CTRL+R to switch to RAW MODE) "
 	}
 
 	g.SetCurrentView("input")
@@ -488,11 +488,12 @@ func (m manager) normalMode(g *gocui.Gui, v *gocui.View) error {
 	realLineLength := maxX - 2
 	printedLineLength := maxX - 4
 	statusLine := m.s.data[m.s.highlightedItem].drawStatusLine(compactRenderingMode, printedLineLength, realLineLength)
-	var statusLineHeight int = len(statusLine) + 1 // help line
+	var statusLineHeight int = len(statusLine)
 
 	helpLineHeight := 1
 	const helpLine = "HELP: type to search, UP/DOWN to select, RIGHT to edit, ENTER to execute, CTRL+G to abort, CTRL+C/D to quit; " +
-		"TIP: when resh-cli is launched command line is used as initial search query"
+		"FLAGS: G = this git repo, E# = exit status #"
+		// "TIP: when resh-cli is launched command line is used as initial search query"
 
 	mainViewHeight := maxY - topBoxHeight - statusLineHeight - helpLineHeight
 	m.s.displayedItemsCount = mainViewHeight
@@ -605,7 +606,7 @@ func SendCliMsg(m msg.CliMsg, port string) msg.CliResponse {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	if err != nil {
-		log.Fatal("resh-daemon is not running :(")
+		log.Fatal("resh-daemon is not running - try restarting this terminal")
 	}
 
 	defer resp.Body.Close()

cmd/control/cmd/enable.go

@@ -21,36 +21,26 @@ var enableCmd = &cobra.Command{
 
 var enableArrowKeyBindingsCmd = &cobra.Command{
 	Use:   "arrow_key_bindings",
-	Short: "enable bindings for arrow keys (up/down) FOR THIS SHELL SESSION",
-	Run: func(cmd *cobra.Command, args []string) {
-		exitCode = status.EnableArrowKeyBindings
-	},
-}
-
-var enableArrowKeyBindingsGlobalCmd = &cobra.Command{
-	Use:   "arrow_key_bindings_global",
-	Short: "enable bindings for arrow keys (up/down) FOR FUTURE SHELL SESSIONS",
-	Long: "Enable bindings for arrow keys (up/down) FOR FUTURE SHELL SESSIONS.\n" +
+	Short: "enable bindings for arrow keys (up/down)",
+	Long: "Enable bindings for arrow keys (up/down)\n" +
 		"Note that this only affects sessions of the same shell.\n" +
-		"(e.g. running this in zsh will only affect future zsh sessions)",
+		"(e.g. running this in zsh will only enable the keybinding in zsh)",
 	Run: func(cmd *cobra.Command, args []string) {
 		exitCode = enableDisableArrowKeyBindingsGlobally(true)
+		if exitCode == status.Success {
+			exitCode = status.EnableArrowKeyBindings
+		}
 	},
 }
 
 var enableControlRBindingCmd = &cobra.Command{
 	Use:   "ctrl_r_binding",
-	Short: "enable binding for control+R FOR THIS SHELL SESSION",
-	Run: func(cmd *cobra.Command, args []string) {
-		exitCode = status.EnableControlRBinding
-	},
-}
-
-var enableControlRBindingGlobalCmd = &cobra.Command{
-	Use:   "ctrl_r_binding_global",
-	Short: "enable bindings for control+R FOR FUTURE SHELL SESSIONS",
+	Short: "enable RESH-CLI binding for Ctrl+R",
 	Run: func(cmd *cobra.Command, args []string) {
 		exitCode = enableDisableControlRBindingGlobally(true)
+		if exitCode == status.Success {
+			exitCode = status.EnableControlRBinding
+		}
 	},
 }
 
@@ -63,36 +53,26 @@ var disableCmd = &cobra.Command{
 
 var disableArrowKeyBindingsCmd = &cobra.Command{
 	Use:   "arrow_key_bindings",
-	Short: "disable bindings for arrow keys (up/down) FOR THIS SHELL SESSION",
-	Run: func(cmd *cobra.Command, args []string) {
-		exitCode = status.DisableArrowKeyBindings
-	},
-}
-
-var disableArrowKeyBindingsGlobalCmd = &cobra.Command{
-	Use:   "arrow_key_bindings_global",
-	Short: "disable bindings for arrow keys (up/down) FOR FUTURE SHELL SESSIONS",
-	Long: "Disable bindings for arrow keys (up/down) FOR FUTURE SHELL SESSIONS.\n" +
+	Short: "disable bindings for arrow keys (up/down)",
+	Long: "Disable bindings for arrow keys (up/down)\n" +
 		"Note that this only affects sessions of the same shell.\n" +
-		"(e.g. running this in zsh will only affect future zsh sessions)",
+		"(e.g. running this in zsh will only enable the keybinding in zsh)",
 	Run: func(cmd *cobra.Command, args []string) {
 		exitCode = enableDisableArrowKeyBindingsGlobally(false)
+		if exitCode == status.Success {
+			exitCode = status.DisableArrowKeyBindings
+		}
 	},
 }
 
 var disableControlRBindingCmd = &cobra.Command{
 	Use:   "ctrl_r_binding",
-	Short: "disable binding for control+R FOR THIS SHELL SESSION",
-	Run: func(cmd *cobra.Command, args []string) {
-		exitCode = status.DisableControlRBinding
-	},
-}
-
-var disableControlRBindingGlobalCmd = &cobra.Command{
-	Use:   "ctrl_r_binding_global",
-	Short: "disable bindings for control+R FOR FUTURE SHELL SESSIONS",
+	Short: "disable RESH-CLI binding for Ctrl+R",
 	Run: func(cmd *cobra.Command, args []string) {
 		exitCode = enableDisableControlRBindingGlobally(false)
+		if exitCode == status.Success {
+			exitCode = status.DisableControlRBinding
+		}
 	},
 }
 
@@ -131,37 +111,24 @@ func enableDisableArrowKeyBindingsGlobally(value bool) status.Code {
 // I don't like the interface this function has - passing both config structure and a part of it feels wrong
 // 		It's ugly and could lead to future errors
 func setConfigBindArrowKey(configPath string, config *cfg.Config, configField *bool, shell string, value bool) error {
-	if *configField == value {
-		if value {
-			fmt.Println("The RESH arrow key bindings are ALREADY GLOBALLY ENABLED for all future " + shell + " sessions - nothing to do - exiting.")
-		} else {
-			fmt.Println("The RESH arrow key bindings are ALREADY GLOBALLY DISABLED for all future " + shell + " sessions - nothing to do - exiting.")
-		}
-		return nil
-	}
-	if value {
-		fmt.Println("ENABLING the RESH arrow key bindings GLOBALLY (in " + shell + ") ...")
-	} else {
-		fmt.Println("DISABLING the RESH arrow key bindings GLOBALLY (in " + shell + ") ...")
-	}
-	*configField = value
+	if *configField != value {
+		*configField = value
 
-	f, err := os.Create(configPath)
-	if err != nil {
-		fmt.Println("Error: Failed to create/open file:", configPath, "; error:", err)
-		return err
-	}
-	defer f.Close()
-	if err := toml.NewEncoder(f).Encode(config); err != nil {
-		fmt.Println("Error: Failed to encode and write the config values to hdd. error:", err)
-		return err
+		f, err := os.Create(configPath)
+		if err != nil {
+			fmt.Println("Error: Failed to create/open file:", configPath, "; error:", err)
+			return err
+		}
+		defer f.Close()
+		if err := toml.NewEncoder(f).Encode(config); err != nil {
+			fmt.Println("Error: Failed to encode and write the config values to hdd. error:", err)
+			return err
+		}
 	}
 	if value {
-		fmt.Println("SUCCESSFULLY ENABLED the RESH arrow key bindings GLOBALLY (in " + shell + ") " +
-			"- every new (" + shell + ") session will start with enabled RESH arrow key bindings!")
+		fmt.Println("RESH arrow key bindings: ENABLED (in " + shell + ")")
 	} else {
-		fmt.Println("SUCCESSFULLY DISABLED the RESH arrow key bindings GLOBALLY (in " + shell + ") " +
-			"- every new (" + shell + ") session will start with " + shell + " default arrow key bindings!")
+		fmt.Println("RESH arrow key bindings: DISABLED (in " + shell + ")")
 	}
 	return nil
 }
@@ -175,37 +142,24 @@ func enableDisableControlRBindingGlobally(value bool) status.Code {
 		fmt.Println("Error reading config", err)
 		return status.Fail
 	}
-	if config.BindControlR == value {
-		if value {
-			fmt.Println("The RESH control+R binding is ALREADY GLOBALLY ENABLED for all future shell sessions - nothing to do - exiting.")
-		} else {
-			fmt.Println("The RESH control+R binding is ALREADY GLOBALLY DISABLED for all future shell sessions - nothing to do - exiting.")
-		}
-		return status.Fail
-	}
-	if value {
-		fmt.Println("ENABLING the RESH arrow key bindings GLOBALLY ...")
-	} else {
-		fmt.Println("DISABLING the RESH arrow key bindings GLOBALLY ...")
-	}
-	config.BindControlR = value
+	if config.BindControlR != value {
+		config.BindControlR = value
 
-	f, err := os.Create(configPath)
-	if err != nil {
-		fmt.Println("Error: Failed to create/open file:", configPath, "; error:", err)
-		return status.Fail
-	}
-	defer f.Close()
-	if err := toml.NewEncoder(f).Encode(config); err != nil {
-		fmt.Println("Error: Failed to encode and write the config values to hdd. error:", err)
-		return status.Fail
+		f, err := os.Create(configPath)
+		if err != nil {
+			fmt.Println("Error: Failed to create/open file:", configPath, "; error:", err)
+			return status.Fail
+		}
+		defer f.Close()
+		if err := toml.NewEncoder(f).Encode(config); err != nil {
+			fmt.Println("Error: Failed to encode and write the config values to hdd. error:", err)
+			return status.Fail
+		}
 	}
 	if value {
-		fmt.Println("SUCCESSFULLY ENABLED the RESH arrow key bindings GLOBALLY " +
-			"- every new shell session will start with enabled RESH CLI control+R binding!")
+		fmt.Println("RESH SEARCH app Ctrl+R binding: ENABLED")
 	} else {
-		fmt.Println("SUCCESSFULLY DISABLED the RESH arrow key bindings GLOBALLY " +
-			"- every new shell session will start with your orignal control+R key binding!")
+		fmt.Println("RESH SEARCH app Ctrl+R binding: DISABLED")
 	}
 	return status.Success
 }

cmd/control/cmd/root.go

@@ -43,15 +43,11 @@ func Execute(ver, com string) status.Code {
 
 	rootCmd.AddCommand(enableCmd)
 	enableCmd.AddCommand(enableArrowKeyBindingsCmd)
-	enableCmd.AddCommand(enableArrowKeyBindingsGlobalCmd)
 	enableCmd.AddCommand(enableControlRBindingCmd)
-	enableCmd.AddCommand(enableControlRBindingGlobalCmd)
 
 	rootCmd.AddCommand(disableCmd)
 	disableCmd.AddCommand(disableArrowKeyBindingsCmd)
-	disableCmd.AddCommand(disableArrowKeyBindingsGlobalCmd)
 	disableCmd.AddCommand(disableControlRBindingCmd)
-	disableCmd.AddCommand(disableControlRBindingGlobalCmd)
 
 	rootCmd.AddCommand(completionCmd)
 	completionCmd.AddCommand(completionBashCmd)

cmd/inspect/main.go

@@ -66,7 +66,7 @@ func SendInspectMsg(m msg.InspectMsg, port string) msg.MultiResponse {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	if err != nil {
-		log.Fatal("resh-daemon is not running :(")
+		log.Fatal("resh-daemon is not running - try restarting this terminal")
 	}
 
 	defer resp.Body.Close()