Sort conversationSlice

Dev to Master

.github/workflows/go.yml

@@ -0,0 +1,40 @@
+name: Go
+on: [push]
+jobs:
+  build:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest, windows-latest]
+    name: Build
+    runs-on: ${{ matrix.platform }}
+    steps:
+
+    - name: Set up Go 1.13
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.13
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v1
+
+    - name: Get dependencies
+      run: |
+        go get -v -t -d ./...
+        go get github.com/magefile/mage
+
+    - name: Build
+      run: go run build.go buildbeta
+    - name: Upload Artifact
+      if: matrix.platform != 'windows-latest'
+      uses: actions/upload-artifact@v1.0.0
+      with:
+        name: kbtui-${{ matrix.platform }}-buildbeta
+        path: kbtui
+    
+    - name: Upload Artifact
+      if: matrix.platform == 'windows-latest'
+      uses: actions/upload-artifact@v1.0.0
+      with:
+        name: kbtui-${{ matrix.platform }}-buildbeta
+        path: kbtui.exe

.gitignore

@@ -6,3 +6,4 @@ emojiList.go
 .idea/*
 .idea
 *.log
+.travis.yml

README.md

@@ -31,16 +31,9 @@ go get -u github.com/rudi9719/kbtui
 ```
 Or you can do the following:
 ```
-go get ./...
+go get github.com/magefile/mage/mage
-go run build.go
 go run build.go {build, buildBeta... etc}
 ./kbtui
 ```
-
+Mage is a requirement for building `kbtui` as it will automatically handle/manage imports as well as mage is used to generate the 
-You may see an error with `go get ./...` about PATHs, that may be safely ignored.
+file for emoji completion.
-
-If you see an error about a missing dependancy during a build, you'll want to resolve that.
-
-
-Occasionally when [@dxb](https://keybase.io/dxb) updates his API it will be necessary to run
-`go get -u ./...` or `go get -u samhofi.us/x/keybase`

cmdClean.go

@@ -15,6 +15,7 @@ func init() {
 
 func cmdClean(cmd []string) {
 	clearView("Chat")
+	clearView("List")
 	go populateChat()
-
+	go populateList()
 }

cmdConfig.go

@@ -0,0 +1,93 @@
+// +build !rm_basic_commands allcommands setcmd
+
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"github.com/pelletier/go-toml"
+)
+
+func init() {
+	command := Command{
+		Cmd:         []string{"config"},
+		Description: "Change various settings",
+		Help:        "",
+		Exec:        cmdConfig,
+	}
+
+	RegisterCommand(command)
+}
+
+func cmdConfig(cmd []string) {
+	var err error
+	switch {
+	case len(cmd) == 2:
+		if cmd[1] == "load" {
+			config, err = readConfig()
+			if err != nil {
+				printError(err.Error())
+				return
+			}
+			printInfoF("Config file loaded: $TEXT", config.Colors.Feed.File.stylize(config.filepath))
+			return
+		}
+	case len(cmd) > 2:
+		if cmd[1] == "load" {
+			config, err = readConfig(cmd[3])
+			if err != nil {
+				printError(err.Error())
+				return
+			}
+			printInfoF("Config file loaded: $TEXT", config.Colors.Feed.File.stylize(config.filepath))
+			return
+		}
+	}
+	printError("Must pass a valid command")
+}
+
+func readConfig(filepath ...string) (*Config, error) {
+	var result = new(Config)
+	var configFile, path string
+	var env bool
+
+	// Load default config first, this way any values missing from the provided config file will remain the default value
+	d := []byte(defaultConfig)
+	toml.Unmarshal(d, result)
+
+	switch len(filepath) {
+	case 0:
+		configFile, env = os.LookupEnv("KBTUI_CFG")
+		if !env {
+			path, env = os.LookupEnv("HOME")
+			if env {
+				configFile = path + "/.config/kbtui.toml"
+				if _, err := os.Stat(configFile); os.IsNotExist(err) {
+					configFile = "kbtui.toml"
+				}
+			} else {
+				configFile = "kbtui.toml"
+			}
+		}
+	default:
+		configFile = filepath[0]
+		if _, err := os.Stat(configFile); os.IsNotExist(err) {
+			return result, fmt.Errorf("Unable to load config: %s not found", configFile)
+		}
+	}
+
+	f, err := ioutil.ReadFile(configFile)
+	if err != nil {
+		f = []byte(defaultConfig)
+	}
+
+	err = toml.Unmarshal(f, result)
+	if err != nil {
+		return result, err
+	}
+
+	result.filepath = configFile
+	return result, nil
+}

cmdDelete.go

@@ -3,7 +3,6 @@
 package main
 
 import (
-	"fmt"
 	"strconv"
 )
 
@@ -28,7 +27,7 @@ func cmdDelete(cmd []string) {
 	chat := k.NewChat(channel)
 	_, err := chat.Delete(messageID)
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("There was an error deleting your message."))
+		printError("There was an error deleting your message.")
 	}
 
 }

cmdDownload.go

@@ -21,22 +21,22 @@ func init() {
 func cmdDownloadFile(cmd []string) {
 
 	if len(cmd) < 2 {
-		printToView("Feed", fmt.Sprintf("%s%s $messageId $fileName - Download a file to user's downloadpath", cmdPrefix, cmd[0]))
+		printInfo(fmt.Sprintf("%s%s $messageId $fileName - Download a file to user's downloadpath", config.Basics.CmdPrefix, cmd[0]))
 		return
 	}
 	messageID, err := strconv.Atoi(cmd[1])
 	if err != nil {
-		printToView("Feed", "There was an error converting your messageID to an int")
+		printError("There was an error converting your messageID to an int")
 		return
 	}
 	chat := k.NewChat(channel)
 	api, err := chat.ReadMessage(messageID)
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("There was an error pulling message %d", messageID))
+		printError(fmt.Sprintf("There was an error pulling message %d", messageID))
 		return
 	}
 	if api.Result.Messages[0].Msg.Content.Type != "attachment" {
-		printToView("Feed", "No attachment detected")
+		printError("No attachment detected")
 		return
 	}
 	var fileName string
@@ -46,10 +46,12 @@ func cmdDownloadFile(cmd []string) {
 		fileName = api.Result.Messages[0].Msg.Content.Attachment.Object.Filename
 	}
 
-	_, err = chat.Download(messageID, fmt.Sprintf("%s/%s", downloadPath, fileName))
+	_, err = chat.Download(messageID, fmt.Sprintf("%s/%s", config.Basics.DownloadPath, fileName))
+	channelName := config.Colors.Message.LinkKeybase.stylize(channel.Name)
+	fileNameStylizied := config.Colors.Feed.File.stylize(fileName)
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("There was an error downloading %s from %s", fileName, channel.Name))
+		printErrorF("There was an error downloading $TEXT from $TEXT", fileNameStylizied, channelName)
 	} else {
-		printToView("Feed", fmt.Sprintf("Downloaded %s from %s", fileName, channel.Name))
+		printInfoF("Downloaded $TEXT from $TEXT", fileNameStylizied, channelName)
 	}
 }

cmdEdit.go

@@ -26,22 +26,24 @@ func cmdEdit(cmd []string) {
 		if len(cmd) == 2 {
 			messageID, _ = strconv.Atoi(cmd[1])
 		} else if lastMessage.ID != 0 {
+			message, _ := chat.ReadMessage(lastMessage.ID)
+			lastMessage.Type = message.Result.Messages[0].Msg.Content.Type
 			if lastMessage.Type != "text" {
-				printToView("Feed", "Last message isn't editable (is it an edit?)")
+				printError("Last message isn't editable (is it an edit?)")
 				return
 			}
 			messageID = lastMessage.ID
 		} else {
-			printToView("Feed", "No message to edit")
+			printError("No message to edit")
 			return
 		}
 		origMessage, _ := chat.ReadMessage(messageID)
 		if origMessage.Result.Messages[0].Msg.Content.Type != "text" {
-			printToView("Feed", fmt.Sprintf("%+v", origMessage))
+			printInfo(fmt.Sprintf("%+v", origMessage))
 			return
 		}
 		if origMessage.Result.Messages[0].Msg.Sender.Username != k.Username {
-			printToView("Feed", "You cannot edit another user's messages.")
+			printError("You cannot edit another user's messages.")
 			return
 		}
 		editString := origMessage.Result.Messages[0].Msg.Content.Text.Body
@@ -53,14 +55,14 @@ func cmdEdit(cmd []string) {
 		return
 	}
 	if len(cmd) < 3 {
-		printToView("Feed", "Not enough options for Edit")
+		printError("Not enough options for Edit")
 		return
 	}
 	messageID, _ = strconv.Atoi(cmd[1])
 	newMessage := strings.Join(cmd[2:], " ")
 	_, err := chat.Edit(messageID, newMessage)
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("Error editing message %d, %+v", messageID, err))
+		printError(fmt.Sprintf("Error editing message %d, %+v", messageID, err))
 	}
 
 }

cmdExec.go

@@ -0,0 +1,55 @@
+// +build !rm_basic_commands allcommands execcmd
+
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func init() {
+	command := Command{
+		Cmd:         []string{"exec", "ex"},
+		Description: "$keybase args - executes keybase $args and returns the output",
+		Help:        "",
+		Exec:        cmdExec,
+	}
+	RegisterCommand(command)
+}
+
+func cmdExec(cmd []string) {
+	l := len(cmd)
+	switch {
+	case l >= 2:
+		if cmd[1] == "keybase" {
+			// if the user types /exec keybase wallet list
+			// only send ["wallet", "list"]
+			runKeybaseExec(cmd[2:])
+		} else {
+			// send everything except the command
+			runKeybaseExec(cmd[1:])
+		}
+	case l == 1:
+		fallthrough
+	default:
+		printExecHelp()
+	}
+}
+
+func runKeybaseExec(args []string) {
+	outputBytes, err := k.Exec(args...)
+	if err != nil {
+		printToView("Feed", fmt.Sprintf("Exec error: %+v", err))
+	} else {
+		channel.Name = ""
+		// unjoin the chat
+		clearView("Chat")
+		setViewTitle("Input", fmt.Sprintf(" /exec %s ", strings.Join(args, " ")))
+		output := string(outputBytes)
+		printToView("Chat", fmt.Sprintf("%s", output))
+	}
+}
+
+func printExecHelp() {
+	printInfo(fmt.Sprintf("To execute a keybase command use %sexec <keybase args>", config.Basics.CmdPrefix))
+}

cmdFollow.go

@@ -0,0 +1,34 @@
+// +build !rm_basic_commands allcommands followcmd
+
+package main
+
+import (
+	"fmt"
+)
+
+func init() {
+	command := Command{
+		Cmd:         []string{"follow"},
+		Description: "$username - Follows the given user",
+		Help:        "",
+		Exec:        cmdFollow,
+	}
+	RegisterCommand(command)
+}
+
+func cmdFollow(cmd []string) {
+	if len(cmd) == 2 {
+		go follow(cmd[1])
+	} else {
+		printFollowHelp()
+	}
+}
+func follow(username string) {
+	k.Exec("follow", username, "-y")
+	printInfoF("Now follows $TEXT", config.Colors.Message.LinkKeybase.stylize(username))
+	followedInSteps[username] = 1
+}
+
+func printFollowHelp() {
+	printInfo(fmt.Sprintf("To follow a user use %sfollow <username>", config.Basics.CmdPrefix))
+}

cmdHelp.go

@@ -25,7 +25,7 @@ func cmdHelp(cmd []string) {
 	if len(cmd) == 1 {
 		sort.Strings(baseCommands)
 		for _, c := range baseCommands {
-			helpText = fmt.Sprintf("%s%s%s\t\t%s\n", helpText, cmdPrefix, c, commands[c].Description)
+			helpText = fmt.Sprintf("%s%s%s\t\t%s\n", helpText, config.Basics.CmdPrefix, c, commands[c].Description)
 		}
 		if len(typeCommands) > 0 {
 			for c := range typeCommands {

cmdInspect.go

@@ -0,0 +1,135 @@
+// +build !rm_basic_commands allcommands inspectcmd
+
+package main
+
+import (
+	"fmt"
+	"regexp"
+	"samhofi.us/x/keybase"
+	"strconv"
+	"strings"
+)
+
+func init() {
+	command := Command{
+		Cmd:         []string{"inspect", "id"},
+		Description: "$identifier - shows info about $identifier ($identifier is either username, messageId or team)",
+		Help:        "",
+		Exec:        cmdInspect,
+	}
+
+	RegisterCommand(command)
+}
+
+func cmdInspect(cmd []string) {
+	if len(cmd) == 2 {
+		regexIsNumeric := regexp.MustCompile(`^\d+$`)
+		if regexIsNumeric.MatchString(cmd[1]) {
+			// Then it must be a message id
+			id, _ := strconv.Atoi(cmd[1])
+			go printMessage(id)
+
+		} else {
+			go printUser(strings.Replace(cmd[1], "@", "", -1))
+		}
+
+	} else {
+		printInfo(fmt.Sprintf("To inspect something use %sid <username/messageId>", config.Basics.CmdPrefix))
+	}
+
+}
+func printMessage(id int) {
+	chat := k.NewChat(channel)
+	messages, err := chat.ReadMessage(id)
+	if err == nil {
+		var response StyledString
+		if messages != nil && len((*messages).Result.Messages) > 0 {
+			message := (*messages).Result.Messages[0].Msg
+			var apiCast keybase.ChatAPI
+			apiCast.Msg = &message
+			response = formatOutput(apiCast)
+		} else {
+			response = config.Colors.Feed.Error.stylize("message not found")
+		}
+		printToView("Chat", response.string())
+	}
+}
+
+func formatProofs(userLookup keybase.UserAPI) StyledString {
+	messageColor := config.Colors.Message
+	message := basicStyle.stylize("")
+	for _, proof := range userLookup.Them[0].ProofsSummary.All {
+		style := config.Colors.Feed.Success
+		if proof.State != 1 {
+			style = config.Colors.Feed.Error
+		}
+		proofString := style.stylize("Proof [$NAME@$SITE]: $URL\n")
+		proofString = proofString.replace("$NAME", messageColor.SenderDefault.stylize(proof.Nametag))
+		proofString = proofString.replace("$SITE", messageColor.SenderDevice.stylize(proof.ProofType))
+		proofString = proofString.replace("$URL", messageColor.LinkURL.stylize(proof.HumanURL))
+		message = message.append(proofString)
+	}
+	return message.appendString("\n")
+}
+func formatProfile(userLookup keybase.UserAPI) StyledString {
+	messageColor := config.Colors.Message
+	user := userLookup.Them[0]
+	profileText := messageColor.Body.stylize("Name: $FNAME\nLocation: $LOC\nBio: $BIO\n")
+	profileText = profileText.replaceString("$FNAME", user.Profile.FullName)
+	profileText = profileText.replaceString("$LOC", user.Profile.Location)
+	profileText = profileText.replaceString("$BIO", user.Profile.Bio)
+
+	return profileText
+}
+
+func formatFollowState(userLookup keybase.UserAPI) StyledString {
+	username := userLookup.Them[0].Basics.Username
+	followSteps := followedInSteps[username]
+	if followSteps == 1 {
+		return config.Colors.Feed.Success.stylize("<Followed!>\n\n")
+	} else if followSteps > 1 {
+		var steps []string
+		for head := username; head != ""; head = trustTreeParent[head] {
+			steps = append(steps, fmt.Sprintf("[%s]", head))
+		}
+		trustLine := fmt.Sprintf("Indirect follow: <%s>\n\n", strings.Join(steps, " Followed by "))
+		return config.Colors.Message.Body.stylize(trustLine)
+	}
+
+	return basicStyle.stylize("")
+
+}
+
+func formatFollowerAndFollowedList(username string, listType string) StyledString {
+	messageColor := config.Colors.Message
+	response := basicStyle.stylize("")
+	bytes, _ := k.Exec("list-"+listType, username)
+	bigString := string(bytes)
+	lines := strings.Split(bigString, "\n")
+	response = response.appendString(fmt.Sprintf("%s (%d): ", listType, len(lines)-1))
+	for i, user := range lines[:len(lines)-1] {
+		if i != 0 {
+			response = response.appendString(", ")
+		}
+		response = response.append(messageColor.LinkKeybase.stylize(user))
+		response = response.append(getUserFlags(user))
+	}
+	return response.appendString("\n\n")
+}
+
+func printUser(username string) {
+	messageColor := config.Colors.Message
+
+	userLookup, _ := k.UserLookup(username)
+
+	response := messageColor.Header.stylize("[Inspecting `$USER`]\n")
+	response = response.replace("$USER", messageColor.SenderDefault.stylize(username))
+	response = response.append(formatProfile(userLookup))
+	response = response.append(formatFollowState(userLookup))
+
+	response = response.append(formatProofs(userLookup))
+	response = response.append(formatFollowerAndFollowedList(username, "followers"))
+	response = response.append(formatFollowerAndFollowedList(username, "following"))
+
+	printToView("Chat", response.string())
+}

cmdJoin.go

@@ -41,12 +41,14 @@ func cmdJoin(cmd []string) {
 			channel.TopicName = ""
 			channel.MembersType = keybase.USER
 		}
-		printToView("Feed", fmt.Sprintf("You are joining: %s", joinedName))
+		printInfoF("You are joining: $TEXT", config.Colors.Message.LinkKeybase.stylize(joinedName))
 		clearView("Chat")
 		setViewTitle("Input", fmt.Sprintf(" %s ", joinedName))
+		lastChat = joinedName
+		autoScrollView("Chat")
 		go populateChat()
 	default:
-		printToView("Feed", fmt.Sprintf("To join a team use %sjoin <team> <channel>", cmdPrefix))
+		printInfo(fmt.Sprintf("To join a team use %sjoin <team> <channel>", config.Basics.CmdPrefix))
-		printToView("Feed", fmt.Sprintf("To join a PM use %sjoin <user>", cmdPrefix))
+		printInfo(fmt.Sprintf("To join a PM use %sjoin <user>", config.Basics.CmdPrefix))
 	}
 }

cmdPost.go

@@ -29,8 +29,8 @@ func cmdPost(cmd []string) {
 	chat := k.NewChat(pubChan)
 	_, err := chat.Send(post)
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("There was an error with your post: %+v", err))
+		printError(fmt.Sprintf("There was an error with your post: %+v", err))
 	} else {
-		printToView("Feed", "You have publically posted to your wall, signed by your current device.")
+		printInfo("You have publically posted to your wall, signed by your current device.")
 	}
 }

cmdReact.go

@@ -38,6 +38,6 @@ func doReact(messageID int, reaction string) {
 	chat := k.NewChat(channel)
 	_, err := chat.React(messageID, reaction)
 	if err != nil {
-		printToView("Feed", "There was an error reacting to the message.")
+		printError("There was an error reacting to the message.")
 	}
 }

cmdReply.go

@@ -22,18 +22,17 @@ func init() {
 func cmdReply(cmd []string) {
 	chat := k.NewChat(channel)
 	if len(cmd) < 2 {
-		printToView("Feed", fmt.Sprintf("%s%s $ID - Reply to message $ID", cmdPrefix, cmd[0]))
+		printInfo(fmt.Sprintf("%s%s $ID - Reply to message $ID", config.Basics.CmdPrefix, cmd[0]))
 		return
 	}
 	messageID, err := strconv.Atoi(cmd[1])
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("There was an error determining message ID %s", cmd[1]))
+		printError(fmt.Sprintf("There was an error determining message ID %s", cmd[1]))
 		return
 	}
 	_, err = chat.Reply(messageID, strings.Join(cmd[2:], " "))
 	if err != nil {
-		printToView("Feed", "There was an error with your reply.")
+		printError("There was an error with your reply.")
 		return
 	}
-	return
 }

cmdSet.go

@@ -1,94 +0,0 @@
-// +build !rm_basic_commands allcommands setcmd
-
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/pelletier/go-toml"
-)
-
-func init() {
-	command := Command{
-		Cmd:         []string{"set", "config"},
-		Description: "Change various settings",
-		Help:        "",
-		Exec:        cmdSet,
-	}
-
-	RegisterCommand(command)
-}
-func printSetting(cmd []string) {
-	switch cmd[1] {
-	case "load":
-		loadFromToml()
-		printToView("Feed", fmt.Sprintf("Loading config from toml"))
-	case "downloadPath":
-		printToView("Feed", fmt.Sprintf("Setting for %s -> %s", cmd[1], downloadPath))
-	case "outputFormat":
-		printToView("Feed", fmt.Sprintf("Setting for %s -> %s", cmd[1], outputFormat))
-	case "dateFormat":
-		printToView("Feed", fmt.Sprintf("Setting for %s -> %s", cmd[1], dateFormat))
-	case "timeFormat":
-		printToView("Feed", fmt.Sprintf("Setting for %s -> %s", cmd[1], timeFormat))
-	case "cmdPrefix":
-		printToView("Feed", fmt.Sprintf("Setting for %s -> %s", cmd[1], cmdPrefix))
-	default:
-		printToView("Feed", fmt.Sprintf("Unknown config value %s", cmd[1]))
-	}
-
-	return
-}
-func cmdSet(cmd []string) {
-	if len(cmd) < 2 {
-		printToView("Feed", "No config value specified")
-		return
-	}
-	if len(cmd) < 3 {
-		printSetting(cmd)
-	}
-	switch cmd[1] {
-	case "downloadPath":
-		if len(cmd) != 3 {
-			printToView("Feed", "Invalid download path.")
-		}
-		downloadPath = cmd[2]
-	case "outputFormat":
-		outputFormat = strings.Join(cmd[1:], " ")
-	case "dateFormat":
-		dateFormat = strings.Join(cmd[1:], " ")
-	case "timeFormat":
-		timeFormat = strings.Join(cmd[1:], " ")
-	case "cmdPrefix":
-		cmdPrefix = cmd[2]
-	default:
-		printToView("Feed", fmt.Sprintf("Unknown config value %s", cmd[1]))
-	}
-
-}
-func loadFromToml() {
-	config, err := toml.LoadFile("kbtui.tml")
-	if err != nil {
-		printToView("Feed", fmt.Sprintf("Could not read config file: %+v", err))
-		return
-	}
-	if config.Has("Basics.colorless") {
-		colorless = config.Get("Basics.colorless").(bool)
-	}
-	if config.Has("Basics.downloadPath") {
-		downloadPath = config.Get("Basics.downloadPath").(string)
-	}
-	if config.Has("Basics.cmdPrefix") {
-		cmdPrefix = config.Get("Basics.cmdPrefix").(string)
-	}
-	if config.Has("Formatting.outputFormat") {
-		outputFormat = config.Get("Formatting.outputFormat").(string)
-	}
-	if config.Has("Formatting.dateFormat") {
-		dateFormat = config.Get("Formatting.dateFormat").(string)
-	}
-	if config.Has("Formatting.timeFormat") {
-		timeFormat = config.Get("Formatting.timeFormat").(string)
-	}
-}

cmdStream.go

@@ -2,6 +2,10 @@
 
 package main
 
+import (
+	"fmt"
+)
+
 func init() {
 	command := Command{
 		Cmd:         []string{"stream", "s"},
@@ -17,7 +21,7 @@ func cmdStream(cmd []string) {
 	stream = true
 	channel.Name = ""
 
-	printToView("Feed", "You are now viewing the formatted stream")
+	printInfo("You are now viewing the formatted stream")
-	setViewTitle("Input", " Stream - Not in a chat /j to join ")
+	setViewTitle("Input", fmt.Sprintf(" Stream - Not in a chat. %sj to join ", config.Basics.CmdPrefix))
 	clearView("Chat")
 }

cmdTags.go

@@ -0,0 +1,19 @@
+// +ignore
+// +build allcommands tagscmd
+
+package main
+
+func init() {
+	command := Command{
+		Cmd:         []string{"tags", "map"},
+		Description: "$- Create map of users following users, to populate $TAGS",
+		Help:        "",
+		Exec:        cmdTags,
+	}
+
+	RegisterCommand(command)
+}
+
+func cmdTags(cmd []string) {
+	go generateFollowersList()
+}

cmdUnfollow.go

@@ -0,0 +1,33 @@
+// +build !rm_basic_commands allcommands followcmd
+
+package main
+
+import (
+	"fmt"
+)
+
+func init() {
+	command := Command{
+		Cmd:         []string{"unfollow"},
+		Description: "$username - Unfollows the given user",
+		Help:        "",
+		Exec:        cmdUnfollow,
+	}
+	RegisterCommand(command)
+}
+
+func cmdUnfollow(cmd []string) {
+	if len(cmd) == 2 {
+		go unfollow(cmd[1])
+	} else {
+		printUnfollowHelp()
+	}
+}
+func unfollow(username string) {
+	k.Exec("unfollow", username)
+	printInfoF("Now unfollows $TEXT", config.Colors.Message.LinkKeybase.stylize(username))
+}
+
+func printUnfollowHelp() {
+	printInfo(fmt.Sprintf("To unfollow a user use %sunfollow <username>", config.Basics.CmdPrefix))
+}

cmdUploadFile.go

@@ -21,14 +21,14 @@ func init() {
 
 func cmdUploadFile(cmd []string) {
 	if len(cmd) < 2 {
-		printToView("Feed", fmt.Sprintf("%s%s $filePath $fileName - Upload file from absolute path with optional name", cmdPrefix, cmd[0]))
+		printInfo(fmt.Sprintf("%s%s $filePath $fileName - Upload file from absolute path with optional name", config.Basics.CmdPrefix, cmd[0]))
 		return
 	}
 	filePath := cmd[1]
 	if !strings.HasPrefix(filePath, "/") {
 		dir, err := os.Getwd()
 		if err != nil {
-			printToView("Feed", fmt.Sprintf("There was an error determining path %+v", err))
+			printError(fmt.Sprintf("There was an error determining path %+v", err))
 		}
 		filePath = fmt.Sprintf("%s/%s", dir, filePath)
 	}
@@ -40,9 +40,11 @@ func cmdUploadFile(cmd []string) {
 	}
 	chat := k.NewChat(channel)
 	_, err := chat.Upload(fileName, filePath)
+	channelName := config.Colors.Message.LinkKeybase.stylize(channel.Name)
+	fileNameStylized := config.Colors.Feed.File.stylize(filePath)
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("There was an error uploading %s to %s\n%+v", filePath, channel.Name, err))
+		printError(fmt.Sprintf("There was an error uploading %s to %s\n%+v", filePath, channel.Name, err))
 	} else {
-		printToView("Feed", fmt.Sprintf("Uploaded %s to %s", filePath, channel.Name))
+		printInfoF("Uploaded $TEXT to $TEXT", fileNameStylized, channelName)
 	}
 }

cmdWall.go

@@ -64,13 +64,14 @@ func cmdPopulateWall(cmd []string) {
 	if len(users) < 1 {
 		return
 	}
-	printToView("Feed", fmt.Sprintf("Displaying public messages for user %s", requestedUsers))
+
+	printInfoF("Displaying public messages for user $TEXT", config.Colors.Message.LinkKeybase.stylize(requestedUsers))
 	for _, chann := range users {
 		chat := k.NewChat(chann)
 		api, err := chat.Read()
 		if err != nil {
 			if len(users) < 6 {
-				printToView("Feed", fmt.Sprintf("There was an error for user %s: %+v", cleanChannelName(chann.Name), err))
+				printError(fmt.Sprintf("There was an error for user %s: %+v", cleanChannelName(chann.Name), err))
 				return
 			}
 		} else {
@@ -80,7 +81,7 @@ func cmdPopulateWall(cmd []string) {
 					apiCast.Msg = &api.Result.Messages[i].Msg
 					result[apiCast.Msg.SentAt] = apiCast
 					newMessage := formatOutput(apiCast)
-					printMe = append(printMe, newMessage)
+					printMe = append(printMe, newMessage.string())
 
 				}
 			}
@@ -95,7 +96,7 @@ func cmdPopulateWall(cmd []string) {
 	sort.Ints(keys)
 	time.Sleep(1 * time.Millisecond)
 	for _, k := range keys {
-		actuallyPrintMe += formatOutput(result[k]) + "\n"
+		actuallyPrintMe += formatOutput(result[k]).string() + "\n"
 	}
 	printToView("Chat", fmt.Sprintf("\n<Wall>\n\n%s\nYour wall query took %s\n</Wall>\n", actuallyPrintMe, time.Since(start)))
 }

cmdWallet.go

@@ -42,20 +42,20 @@ func cmdWallet(cmd []string) {
 		walletConfirmationCode = b.String()
 		walletConfirmationUser = cmd[1]
 		walletTransactionAmnt = cmd[2]
-		printToView("Feed", fmt.Sprintf("To confirm sending %s to %s, type /confirm %s %s", cmd[2], cmd[1], cmd[1], walletConfirmationCode))
+		printInfo(fmt.Sprintf("To confirm sending %s to %s, type /confirm %s %s", cmd[2], cmd[1], cmd[1], walletConfirmationCode))
 
 	} else if cmd[0] == "confirm" {
 		if cmd[1] == walletConfirmationUser && cmd[2] == walletConfirmationCode {
 			txWallet := k.NewWallet()
 			wAPI, err := txWallet.SendXLM(walletConfirmationUser, walletTransactionAmnt, "")
 			if err != nil {
-				printToView("Feed", fmt.Sprintf("There was an error with your wallet tx:\n\t%+v", err))
+				printError(fmt.Sprintf("There was an error with your wallet tx:\n\t%+v", err))
 			} else {
-				printToView("Feed", fmt.Sprintf("You have sent %sXLM to %s with tx ID: %s", wAPI.Result.Amount, wAPI.Result.ToUsername, wAPI.Result.TxID))
+				printInfo(fmt.Sprintf("You have sent %sXLM to %s with tx ID: %s", wAPI.Result.Amount, wAPI.Result.ToUsername, wAPI.Result.TxID))
 			}
 
 		} else {
-			printToView("Feed", "There was an error validating your confirmation. Your wallet has been untouched.")
+			printError("There was an error validating your confirmation. Your wallet has been untouched.")
 		}
 
 	}

colors.go

@@ -3,41 +3,226 @@ package main
 import (
 	"fmt"
 	"regexp"
+	"strings"
 )
 
-// TODO maybe datastructure
+const (
-// BASH-like PS1 variable equivalent (without colours)
+	black int = iota
-// TODO bold? cursive etc?
+	red
-func color(c int) string {
+	green
-	if colorless {
+	yellow
+	purple
+	magenta
+	cyan
+	grey
+	normal int = -1
+)
+
+var colorMapString = map[string]int{
+	"black":   black,
+	"red":     red,
+	"green":   green,
+	"yellow":  yellow,
+	"purple":  purple,
+	"magenta": magenta,
+	"cyan":    cyan,
+	"grey":    grey,
+	"normal":  normal,
+}
+
+var colorMapInt = map[int]string{
+	black:   "black",
+	red:     "red",
+	green:   "green",
+	yellow:  "yellow",
+	purple:  "purple",
+	magenta: "magenta",
+	cyan:    "cyan",
+	grey:    "grey",
+	normal:  "normal",
+}
+
+func colorFromString(color string) int {
+	var result int
+	color = strings.ToLower(color)
+	result, ok := colorMapString[color]
+	if !ok {
+		return normal
+	}
+	return result
+}
+
+func colorFromInt(color int) string {
+	var result string
+	result, ok := colorMapInt[color]
+	if !ok {
+		return "normal"
+	}
+	return result
+}
+
+var basicStyle = Style{
+	Foreground:    colorMapInt[normal],
+	Background:    colorMapInt[normal],
+	Italic:        false,
+	Bold:          false,
+	Underline:     false,
+	Strikethrough: false,
+	Inverse:       false,
+}
+
+func (s Style) withForeground(color int) Style {
+	s.Foreground = colorFromInt(color)
+	return s
+}
+func (s Style) withBackground(color int) Style {
+	s.Background = colorFromInt(color)
+	return s
+}
+
+func (s Style) withBold() Style {
+	s.Bold = true
+	return s
+}
+func (s Style) withInverse() Style {
+	s.Inverse = true
+	return s
+}
+func (s Style) withItalic() Style {
+	s.Italic = true
+	return s
+}
+func (s Style) withStrikethrough() Style {
+	s.Strikethrough = true
+	return s
+}
+func (s Style) withUnderline() Style {
+	s.Underline = true
+	return s
+}
+
+// TODO create both as `reset` (which it is now) as well as `append`
+//  which essentially just adds on top. that is relevant in the case of
+//  bold/italic etc - it should add style - not clear.
+func (s Style) toANSI() string {
+	if config.Basics.Colorless {
 		return ""
 	}
-	if c < 0 {
+	styleSlice := []string{"0"}
-		return "\033[0m"
+
-	} else {
+	if colorFromString(s.Foreground) != normal {
-		return fmt.Sprintf("\033[0;%dm", 29+c)
+		styleSlice = append(styleSlice, fmt.Sprintf("%d", 30+colorFromString(s.Foreground)))
 	}
-}
+	if colorFromString(s.Background) != normal {
-
+		styleSlice = append(styleSlice, fmt.Sprintf("%d", 40+colorFromString(s.Background)))
-// TODO maybe make the text into some datastructure which remembers the color
-func colorText(text string, color string, offColor string) string {
-	return fmt.Sprintf("%s%s%s", color, text, offColor)
-}
-
-func colorUsername(username string, offColor string) string {
-	var color = messageSenderDefaultColor
-	if username == k.Username {
-		color = mentionColor
 	}
-	return colorText(username, color, offColor)
+	if s.Bold {
-}
+		styleSlice = append(styleSlice, "1")
-func colorRegex(msg string, match string, color string, offColor string) string {
+	}
-	var re = regexp.MustCompile(match)
+	if s.Italic {
-	return re.ReplaceAllString(msg, colorText(`$1`, color, offColor))
+		styleSlice = append(styleSlice, "3")
+	}
+	if s.Underline {
+		styleSlice = append(styleSlice, "4")
+	}
+	if s.Inverse {
+		styleSlice = append(styleSlice, "7")
+	}
+	if s.Strikethrough {
+		styleSlice = append(styleSlice, "9")
+	}
+
+	return "\x1b[" + strings.Join(styleSlice, ";") + "m"
 }
 
-func colorReplaceMentionMe(msg string, offColor string) string {
+// End Colors
-	//var coloredOwnName = colorText(k.Username, mentionColor, offColor)
+// Begin StyledString
-	//return strings.Replace(msg, k.Username, coloredOwnName, -1)
+
-	return colorRegex(msg, "(@?"+k.Username+")", mentionColor, offColor)
+// StyledString is used to save a message with a style, which can then later be rendered to a string
+type StyledString struct {
+	message string
+	style   Style
+}
+
+func (ss StyledString) withStyle(style Style) StyledString {
+	return StyledString{ss.message, style}
+}
+
+// TODO change StyledString to have styles at start-end indexes.
+
+// TODO handle all formatting types
+func (s Style) sprintf(base string, parts ...StyledString) StyledString {
+	text := s.stylize(removeFormatting(base))
+	//TODO handle posibility to escape
+	re := regexp.MustCompile(`\$TEXT`)
+	for len(re.FindAllString(text.message, 1)) > 0 {
+		part := parts[0]
+		parts = parts[1:]
+		text = text.replaceN("$TEXT", part, 1)
+	}
+	return text
+}
+
+func (s Style) stylize(msg string) StyledString {
+	return StyledString{msg, s}
+}
+func (ss StyledString) stringFollowedByStyle(style Style) string {
+	return ss.style.toANSI() + ss.message + style.toANSI()
+}
+func (ss StyledString) string() string {
+	return ss.stringFollowedByStyle(basicStyle)
+}
+
+func (ss StyledString) replace(match string, value StyledString) StyledString {
+	return ss.replaceN(match, value, -1)
+}
+func (ss StyledString) replaceN(match string, value StyledString, n int) StyledString {
+	ss.message = strings.Replace(ss.message, match, value.stringFollowedByStyle(ss.style), n)
+	return ss
+}
+func (ss StyledString) replaceString(match string, value string) StyledString {
+	ss.message = strings.Replace(ss.message, match, value, -1)
+	return ss
+}
+
+// Overrides current formatting
+func (ss StyledString) colorRegex(match string, style Style) StyledString {
+	return ss.regexReplaceFunc(match, func(subString string) string {
+		return style.stylize(removeFormatting(subString)).stringFollowedByStyle(ss.style)
+	})
+}
+
+// Replacer function takes the current match as input and should return how the match should be preseneted instead
+func (ss StyledString) regexReplaceFunc(match string, replacer func(string) string) StyledString {
+	re := regexp.MustCompile(match)
+	locations := re.FindAllStringIndex(ss.message, -1)
+	var newMessage string
+	var prevIndex int
+	for _, loc := range locations {
+		newSubstring := replacer(ss.message[loc[0]:loc[1]])
+		newMessage += ss.message[prevIndex:loc[0]]
+		newMessage += newSubstring
+		prevIndex = loc[1]
+	}
+	// Append any string after the final match
+	newMessage += ss.message[prevIndex:len(ss.message)]
+	ss.message = newMessage
+	return ss
+}
+
+// Appends the other stylize at the end, but retains same style
+func (ss StyledString) append(other StyledString) StyledString {
+	ss.message = ss.message + other.stringFollowedByStyle(ss.style)
+	return ss
+}
+func (ss StyledString) appendString(other string) StyledString {
+	ss.message += other
+	return ss
+}
+
+// Begin Formatting
+
+func removeFormatting(s string) string {
+	reFormatting := regexp.MustCompile(`(?m)\x1b\[(\d*;?)*m`)
+	return reFormatting.ReplaceAllString(s, "")
 }

defaultConfig.go

@@ -0,0 +1,87 @@
+package main
+
+var defaultConfig = `
+[basics]
+download_path = "/tmp/"
+colorless = false
+unicode_emojis = true
+
+# The prefix before evaluating a command
+cmd_prefix = "/"
+
+[formatting]
+# BASH-like PS1 variable equivalent
+output_format = "┌──[$USER@$DEVICE$TAGS] [$ID] [$DATE - $TIME]\n└╼ $MSG"
+output_stream_format = "┌──[$USER@$DEVICE$TAGS] [$ID] [$DATE - $TIME]\n└╼ $MSG"
+output_mention_format = "┌──[$USER@$DEVICE$TAGS] [$ID] [$DATE - $TIME]\n└╼ $MSG"
+pm_format = "PM from $USER@$DEVICE: $MSG"
+
+# 02 = Day, Jan = Month, 06 = Year
+date_format = "02Jan06"
+
+# 15 = hours, 04 = minutes, 05 = seconds
+time_format = "15:04"
+
+icon_following_user = "[*]"
+icon_indirect_following_user = "[?]"
+
+[colors]
+    [colors.channels]
+        [colors.channels.basic]
+        foreground = "normal"
+        [colors.channels.header]
+        foreground = "magenta"
+        bold = true
+        [colors.channels.unread]
+        foreground = "green"
+        italic = true
+
+	 [colors.message]
+		  [colors.message.body]
+		  foreground = "normal"
+		  [colors.message.header]
+		  foreground = "grey"
+		  bold = true
+		  [colors.message.mention]
+		  foreground = "green"
+		  italic = true
+		  bold = true
+		  [colors.message.id]
+		  foreground = "yellow"
+		  bold = true
+		  [colors.message.time]
+		  foreground = "magenta"
+		  bold = true
+		  [colors.message.sender_default]
+		  foreground = "cyan"
+		  bold = true
+		  [colors.message.sender_device]
+		  foreground = "cyan"
+		  bold = true
+		  [colors.message.sender_tags]
+		  foreground = "yellow"
+		  [colors.message.attachment]
+		  foreground = "red"
+		  [colors.message.link_url]
+		  foreground = "yellow"
+		  [colors.message.link_keybase]
+		  foreground = "cyan"
+		  [colors.message.reaction]
+		  foreground = "magenta"
+		  bold = true
+        [colors.message.quote]
+        foreground = "green"
+		  [colors.message.code]
+		  foreground = "cyan"
+		  background = "grey"
+
+	 [colors.feed]
+		  [colors.feed.basic]
+		  foreground = "grey"
+		  [colors.feed.error]
+		  foreground = "red"
+		  [colors.feed.success]
+		  foreground = "green"
+        [colors.feed.file]
+        foreground = "yellow"
+`

kbtui.tml

@@ -1,30 +0,0 @@
-[Basics]
-downloadPath = "/tmp/"
-colorless = false
-# The prefix before evaluating a command
-cmdPrefix = "/"
-
-[Formatting]
-# BASH-like PS1 variable equivalent
-outputFormat = "┌──[$USER@$DEVICE] [$ID] [$DATE - $TIME]\n└╼ $MSG"
-
-# 02 = Day, Jan = Month, 06 = Year
-dateFormat = "02Jan06"
-
-# 15 = hours, 04 = minutes, 05 = seconds
-timeFormat = "15:04"
-
-
-[Colors]
-channelsColor = 8
-channelsHeaderColor = 6
-noColor = -1
-mentionColor = 3
-messageHeaderColor = 8
-messageIdColor = 7
-messageTimeColor = 6
-messageSenderDefaultColor = 8
-messageSenderDeviceColor = 8
-messageBodyColor = -1
-messageAttachmentColor = 2
-messageLinkColor = 4

kbtui.toml

@@ -0,0 +1,83 @@
+[basics]
+download_path = "/tmp/"
+colorless = false
+unicode_emojis = true
+
+# The prefix before evaluating a command
+cmd_prefix = "/"
+
+[formatting]
+# BASH-like PS1 variable equivalent
+output_format = "$REPL┌──[$USER@$DEVICE$TAGS] [$ID] [$DATE - $TIME]\n└╼ $MSG"
+output_stream_format = "┌──[$USER@$DEVICE$TAGS] [$ID] [$DATE - $TIME]\n└╼ $MSG"
+output_mention_format = "┌──[$USER@$DEVICE$TAGS] [$ID] [$DATE - $TIME]\n└╼ $MSG"
+pm_format = "PM from $USER@$DEVICE: $MSG"
+
+# 02 = Day, Jan = Month, 06 = Year
+date_format = "02Jan06"
+
+# 15 = hours, 04 = minutes, 05 = seconds
+time_format = "15:04"
+
+icon_following_user = "[*]"
+icon_indirect_following_user = "[?]"
+
+[colors]
+    [colors.channels]
+        [colors.channels.basic]
+        foreground = "normal"
+        [colors.channels.header]
+        foreground = "magenta"
+        bold = true
+        [colors.channels.unread]
+        foreground = "green"
+        italic = true
+
+	 [colors.message]
+		  [colors.message.body]
+		  foreground = "normal"
+		  [colors.message.header]
+		  foreground = "grey"
+		  bold = true
+		  [colors.message.mention]
+		  foreground = "green"
+		  italic = true
+		  bold = true
+		  [colors.message.id]
+		  foreground = "yellow"
+		  bold = true
+		  [colors.message.time]
+		  foreground = "magenta"
+		  bold = true
+		  [colors.message.sender_default]
+		  foreground = "cyan"
+		  bold = true
+		  [colors.message.sender_device]
+		  foreground = "cyan"
+		  bold = true
+		  [colors.message.sender_tags]
+		  foreground = "yellow"
+		  [colors.message.attachment]
+		  foreground = "red"
+		  [colors.message.link_url]
+		  foreground = "yellow"
+		  [colors.message.link_keybase]
+		  foreground = "cyan"
+		  [colors.message.reaction]
+		  foreground = "magenta"
+		  bold = true
+        [colors.message.quote]
+        foreground = "green"
+		  [colors.message.code]
+		  foreground = "cyan"
+		  background = "grey"
+
+	 [colors.feed]
+		  [colors.feed.basic]
+		  foreground = "grey"
+		  [colors.feed.error]
+		  foreground = "red"
+		  [colors.feed.success]
+		  foreground = "green"
+        [colors.feed.file]
+        foreground = "yellow"

mage.go

@@ -3,65 +3,13 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
-	"io/ioutil"
-	"net/http"
 	"os"
-	"strings"
 
 	"github.com/magefile/mage/mg"
 	"github.com/magefile/mage/sh"
 )
 
-// emoji related constants
-const emojiList = "https://raw.githubusercontent.com/CodeFreezr/emojo/master/db/v5/emoji-v5.json"
-const emojiFileName = "emojiList.go"
-
-// json parsing structure
-type emoji struct {
-	Num         int    `json:"No"`
-	Emoji       string `json:"Emoji"`
-	Category    string `json:"Category"`
-	SubCategory string `json:"SubCategory"`
-	Unicode     string `json:"Unicode"`
-	Name        string `json:"Name"`
-	Tags        string `json:"Tags"`
-	Shortcode   string `json:"Shortcode"`
-}
-
-// This func downloaded and parses the emojis from online into a slice of all shortnames
-// to be used as a lookup for tab completion for emojis
-// this way the pull from GitHub only has to be done at build time.
-func createEmojiSlice() ([]string, error) {
-	result, err := http.Get(emojiList)
-	if err != nil {
-		return nil, err
-	}
-	defer result.Body.Close()
-
-	emojiList, err := ioutil.ReadAll(result.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	var emojis []emoji
-	if err := json.Unmarshal(emojiList, &emojis); err != nil {
-		return nil, err
-	}
-
-	var emojiSlice []string
-
-	for _, emj := range emojis {
-		if len(emj.Shortcode) == 0 || strings.Contains(emj.Shortcode, "_tone") {
-			// dont add them
-			continue
-		}
-		emojiSlice = append(emojiSlice, emj.Shortcode)
-	}
-	return emojiSlice, nil
-}
-
 func getRemotePackages() error {
 	var packages = []string{
 		"samhofi.us/x/keybase",
@@ -87,28 +35,6 @@ func exit(err error) {
 	}
 }
 
-// Build kbtui with emoji lookup support
-func BuildEmoji() error {
-	mg.Deps(getRemotePackages)
-	emojis, err := createEmojiSlice()
-	if err != nil {
-		return err
-	}
-	f, err := os.Create(emojiFileName)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	fileContent := fmt.Sprintf("package main\n\nvar emojiSlice = %#v", emojis)
-	_, err = f.WriteString(fileContent)
-	if err != nil {
-		return err
-	}
-	f.Sync()
-	return nil
-}
-
 // Build kbtui with just the basic commands.
 func Build() {
 	mg.Deps(getRemotePackages)
@@ -157,7 +83,7 @@ func BuildAllCommands() {
 // Build kbtui with all Commands and TypeCommands enabled.
 func BuildAllCommandsT() {
 	mg.Deps(getRemotePackages)
-	if err := sh.Run("go", "build", "-tags", "type_commands,allcommands"); err != nil {
+	if err := sh.Run("go", "build", "-tags", "type_commands allcommands"); err != nil {
 		defer func() {
 			exit(err)
 		}()
@@ -167,8 +93,7 @@ func BuildAllCommandsT() {
 // Build kbtui with beta functionality
 func BuildBeta() {
 	mg.Deps(getRemotePackages)
-	mg.Deps(BuildEmoji)
+	if err := sh.Run("go", "build", "-tags", "allcommands showreactionscmd tabcompletion execcmd"); err != nil {
-	if err := sh.Run("go", "build", "-tags", "allcommands,showreactionscmd,emojiList,tabcompletion"); err != nil {
 		defer func() {
 			exit(err)
 		}()

main.go

@@ -4,11 +4,13 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"sort"
 	"strings"
 	"time"
 
 	"github.com/awesome-gocui/gocui"
 	"samhofi.us/x/keybase"
+	"unicode/utf8"
 )
 
 var (
@@ -22,9 +24,12 @@ var (
 	channels    []keybase.Channel
 	stream      = false
 	lastMessage keybase.ChatAPI
+	lastChat    = ""
 	g           *gocui.Gui
 )
 
+var config *Config
+
 func main() {
 	if !k.LoggedIn {
 		fmt.Println("You are not logged in.")
@@ -37,6 +42,7 @@ func main() {
 	}
 	defer g.Close()
 	g.SetManagerFunc(layout)
+	RunCommand("config", "load")
 	go populateList()
 	go updateChatWindow()
 	if len(os.Args) > 1 {
@@ -72,7 +78,7 @@ func layout(g *gocui.Gui) error {
 		feedView.Autoscroll = true
 		feedView.Wrap = true
 		feedView.Title = "Feed Window"
-		fmt.Fprintln(feedView, "Feed Window - If you are mentioned or receive a PM it will show here")
+		printInfo("Feed Window - If you are mentioned or receive a PM it will show here")
 	}
 	if chatView, err2 := g.SetView("Chat", maxX/2-maxX/3, maxY/5+1, maxX-1, maxY-5, 0); err2 != nil {
 		if !gocui.IsUnknownView(err2) {
@@ -80,7 +86,9 @@ func layout(g *gocui.Gui) error {
 		}
 		chatView.Autoscroll = true
 		chatView.Wrap = true
-		fmt.Fprintf(chatView, "Welcome %s!\n\nYour chats will appear here.\nSupported commands are as follows:\n\n", k.Username)
+		welcomeText := basicStyle.stylize("Welcome $USER!\n\nYour chats will appear here.\nSupported commands are as follows:\n")
+		welcomeText = welcomeText.replace("$USER", config.Colors.Message.Mention.stylize(k.Username))
+		fmt.Fprintln(chatView, welcomeText.string())
 		RunCommand("help")
 	}
 	if inputView, err3 := g.SetView("Input", maxX/2-maxX/3, maxY-4, maxX-1, maxY-1, 0); err3 != nil {
@@ -92,7 +100,7 @@ func layout(g *gocui.Gui) error {
 		}
 		inputView.Editable = true
 		inputView.Wrap = true
-		inputView.Title = fmt.Sprintf(" Not in a chat - write `%sj` to join", cmdPrefix)
+		inputView.Title = fmt.Sprintf(" Not in a chat - write `%sj` to join", config.Basics.CmdPrefix)
 		g.Cursor = true
 	}
 	if listView, err4 := g.SetView("List", 0, 0, maxX/2-maxX/3-1, maxY-1, 0); err4 != nil {
@@ -104,7 +112,68 @@ func layout(g *gocui.Gui) error {
 	}
 	return nil
 }
+func scrollViewUp(v *gocui.View) error {
+	scrollView(v, -1)
+	return nil
+}
+func scrollViewDown(v *gocui.View) error {
+	scrollView(v, 1)
+	return nil
+}
+func scrollView(v *gocui.View, delta int) error {
+	if v != nil {
+		_, y := v.Size()
+		ox, oy := v.Origin()
+		if oy+delta > strings.Count(v.ViewBuffer(), "\n")-y {
+			v.Autoscroll = true
+		} else {
+			v.Autoscroll = false
+			if err := v.SetOrigin(ox, oy+delta); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+func autoScrollView(vn string) error {
+	v, err := g.View(vn)
+	if err != nil {
+		return err
+	} else if v != nil {
+		v.Autoscroll = true
+	}
+	return nil
+}
 func initKeybindings() error {
+	if err := g.SetKeybinding("", gocui.KeyPgup, gocui.ModNone,
+		func(g *gocui.Gui, v *gocui.View) error {
+			cv, _ := g.View("Chat")
+			err := scrollViewUp(cv)
+			if err != nil {
+				return err
+			}
+			return nil
+		}); err != nil {
+		return err
+	}
+	if err := g.SetKeybinding("", gocui.KeyPgdn, gocui.ModNone,
+		func(g *gocui.Gui, v *gocui.View) error {
+			cv, _ := g.View("Chat")
+			err := scrollViewDown(cv)
+			if err != nil {
+				return err
+			}
+			return nil
+		}); err != nil {
+		return err
+	}
+	if err := g.SetKeybinding("", gocui.KeyEsc, gocui.ModNone,
+		func(g *gocui.Gui, v *gocui.View) error {
+			autoScrollView("Chat")
+			return nil
+		}); err != nil {
+		return err
+	}
 	if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone,
 		func(g *gocui.Gui, v *gocui.View) error {
 			input, err := getInputString("Input")
@@ -119,6 +188,13 @@ func initKeybindings() error {
 		}); err != nil {
 		return err
 	}
+	if err := g.SetKeybinding("", gocui.KeyCtrlZ, gocui.ModNone,
+		func(g *gocui.Gui, v *gocui.View) error {
+			cmdJoin([]string{"/join", lastChat})
+			return nil
+		}); err != nil {
+		return err
+	}
 	if err := g.SetKeybinding("Edit", gocui.KeyCtrlC, gocui.ModNone,
 		func(g *gocui.Gui, v *gocui.View) error {
 			popupView("Chat")
@@ -176,20 +252,19 @@ func getViewTitle(viewName string) string {
 	view, err := g.View(viewName)
 	if err != nil {
 		// in case there is active tab completion, filter that to just the view title and not the completion options.
-		printToView("Feed", fmt.Sprintf("Error getting view title: %s", err))
+		printError(fmt.Sprintf("Error getting view title: %s", err))
 		return ""
 	}
 	return strings.Split(view.Title, "||")[0]
-
 }
 func popupView(viewName string) {
 	_, err := g.SetCurrentView(viewName)
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("%+v", err))
+		printError(fmt.Sprintf("%+v", err))
 	}
 	_, err = g.SetViewOnTop(viewName)
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("%+v", err))
+		printError(fmt.Sprintf("%+v", err))
 	}
 	g.Update(func(g *gocui.Gui) error {
 		updatingView, err := g.View(viewName)
@@ -247,12 +322,37 @@ func writeToView(viewName string, message string) {
 		return nil
 	})
 }
+
+// this removes formatting
+func printError(message string) {
+	printErrorF(message)
+}
+func printErrorF(message string, parts ...StyledString) {
+	printToView("Feed", config.Colors.Feed.Error.sprintf(removeFormatting(message), parts...).string())
+}
+
+// this removes formatting
+func printInfo(message string) {
+	printInfoF(message)
+}
+func printInfoStyledString(message StyledString) {
+	printInfoF("$TEXT", message)
+}
+
+// this removes formatting
+func printInfoF(message string, parts ...StyledString) {
+	printToView("Feed", config.Colors.Feed.Basic.sprintf(removeFormatting(message), parts...).string())
+}
 func printToView(viewName string, message string) {
 	g.Update(func(g *gocui.Gui) error {
 		updatingView, err := g.View(viewName)
 		if err != nil {
 			return err
 		}
+
+		if config.Basics.UnicodeEmojis {
+			message = emojiUnicodeConvert(message)
+		}
 		fmt.Fprintf(updatingView, "%s\n", message)
 		return nil
 	})
@@ -277,7 +377,7 @@ func populateChat() {
 	chat := k.NewChat(channel)
 	maxX, _ := g.Size()
 	api, err := chat.Read(maxX / 2)
-	if err != nil {
+	if err != nil || api.Result == nil {
 		for _, testChan := range channels {
 			if channel.Name == testChan.Name {
 				channel = testChan
@@ -287,13 +387,12 @@ func populateChat() {
 		chat = k.NewChat(channel)
 		_, err2 := chat.Read(2)
 		if err2 != nil {
-			printToView("Feed", fmt.Sprintf("%+v", err))
+			printError(fmt.Sprintf("%+v", err))
 			return
 		}
 		go populateChat()
 		go generateChannelTabCompletionSlice()
 		return
-
 	}
 	var printMe []string
 	var actuallyPrintMe string
@@ -307,7 +406,7 @@ func populateChat() {
 			}
 			var apiCast keybase.ChatAPI
 			apiCast.Msg = &message.Msg
-			newMessage := formatOutput(apiCast)
+			newMessage := formatOutput(apiCast).string()
 			printMe = append(printMe, newMessage)
 		}
 	}
@@ -318,88 +417,180 @@ func populateChat() {
 		}
 	}
 	printToView("Chat", actuallyPrintMe)
-
+	go populateList()
 }
 func populateList() {
 	_, maxY := g.Size()
 	if testVar, err := k.ChatList(); err != nil {
 		log.Printf("%+v", err)
 	} else {
-
 		clearView("List")
-		var recentPMs = fmt.Sprintf("%s---[PMs]---%s\n", channelsHeaderColor, channelsColor)
+		conversationSlice := testVar.Result.Conversations
+		sort.SliceStable(conversationSlice, func(i, j int) bool {
+			return conversationSlice[i].ActiveAt > conversationSlice[j].ActiveAt
+		})
+		var textBase = config.Colors.Channels.Basic.stylize("")
+		var recentPMs = textBase.append(config.Colors.Channels.Header.stylize("---[PMs]---\n"))
 		var recentPMsCount = 0
-		var recentChannels = fmt.Sprintf("%s---[Teams]---%s\n", channelsHeaderColor, channelsColor)
+		var recentChannels = textBase.append(config.Colors.Channels.Header.stylize("---[Teams]---\n"))
 		var recentChannelsCount = 0
-		for _, s := range testVar.Result.Conversations {
+		for _, s := range conversationSlice {
 			channels = append(channels, s.Channel)
 			if s.Channel.MembersType == keybase.TEAM {
 				recentChannelsCount++
 				if recentChannelsCount <= ((maxY - 2) / 3) {
+					channel := fmt.Sprintf("%s\n\t#%s\n", s.Channel.Name, s.Channel.TopicName)
 					if s.Unread {
-						recentChannels += fmt.Sprintf("%s*", color(0))
+						recentChannels = recentChannels.append(config.Colors.Channels.Unread.stylize("*" + channel))
+					} else {
+						recentChannels = recentChannels.appendString(channel)
 					}
-					recentChannels += fmt.Sprintf("%s\n\t#%s\n%s", s.Channel.Name, s.Channel.TopicName, channelsColor)
 				}
 			} else {
 				recentPMsCount++
 				if recentPMsCount <= ((maxY - 2) / 3) {
+					pmName := fmt.Sprintf("%s\n", cleanChannelName(s.Channel.Name))
 					if s.Unread {
-						recentChannels += fmt.Sprintf("%s*", color(0))
+						recentPMs = recentPMs.append(config.Colors.Channels.Unread.stylize("*" + pmName))
+					} else {
+						recentPMs = recentPMs.appendString(pmName)
 					}
-					recentPMs += fmt.Sprintf("%s\n%s", cleanChannelName(s.Channel.Name), channelsColor)
 				}
 			}
 		}
 		time.Sleep(1 * time.Millisecond)
-		printToView("List", fmt.Sprintf("%s%s%s%s", channelsColor, recentPMs, recentChannels, noColor))
+		printToView("List", fmt.Sprintf("%s%s", recentPMs.string(), recentChannels.string()))
-		go generateRecentTabCompletionSlice()
+		generateRecentTabCompletionSlice()
 	}
 }
 
 // End update/populate views automatically
 
 // Formatting
+func formatMessageBody(body string) StyledString {
+	body = strings.Replace(body, "```", "\n<code>\n", -1)
+	message := config.Colors.Message.Body.stylize(body)
+
+	message = message.colorRegex(`@[\w_]*([\.#][\w_]+)*`, config.Colors.Message.LinkKeybase)
+	message = colorReplaceMentionMe(message)
+
+	// TODO when gocui actually fixes there shit with formatting, then un comment these lines
+	//  message = message.colorRegex(`_[^_]*_`, config.Colors.Message.Body.withItalic())
+	//  message = message.colorRegex(`~[^~]*~`, config.Colors.Message.Body.withStrikethrough())
+	message = message.colorRegex(`@[\w_]*([\.#][\w_]+)*`, config.Colors.Message.LinkKeybase)
+	// TODO change how bold, italic etc works, so it uses boldOn boldOff ([1m and [22m)
+	message = message.colorRegex(`\*[^\*]*\*`, config.Colors.Message.Body.withBold())
+	message = message.colorRegex("^>.*$", config.Colors.Message.Quote)
+	message = message.regexReplaceFunc("\n<code>(.*\n)*<code>\n", func(match string) string {
+		maxWidth, _ := g.Size()
+		output := ""
+		match = strings.Replace(strings.Replace(match, "```", "\n<code>\n", -1), "\t", "  ", -1)
+		match = removeFormatting(match)
+		lines := strings.Split(match, "\n")
+		for _, line := range lines {
+			maxLineLength := maxWidth/2 + maxWidth/3 - 2
+			spaces := maxLineLength - utf8.RuneCountInString(line)
+			for i := 1; spaces < 0; i++ {
+				spaces = i*maxLineLength - utf8.RuneCountInString(line)
+			}
+			output += line + strings.Repeat(" ", spaces) + "\n"
+		}
+		// TODO stylize should remove formatting - in general everything should
+
+		return config.Colors.Message.Code.stylize(output).stringFollowedByStyle(message.style)
+	})
+	message = message.colorRegex("`[^`]*`", config.Colors.Message.Code)
+	// mention URL
+	message = message.colorRegex(`(https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*))`, config.Colors.Message.LinkURL)
+	return message
+}
+
+// TODO use this more
+func formatChannel(ch keybase.Channel) StyledString {
+	return config.Colors.Message.LinkKeybase.stylize(fmt.Sprintf("@%s#%s", ch.Name, ch.TopicName))
+}
+
+func colorReplaceMentionMe(msg StyledString) StyledString {
+	return msg.colorRegex(`(@?\b`+k.Username+`\b)`, config.Colors.Message.Mention)
+}
+func colorUsername(username string) StyledString {
+	var color = config.Colors.Message.SenderDefault
+	if username == k.Username {
+		color = config.Colors.Message.Mention
+	}
+	return color.stylize(username)
+}
+
 func cleanChannelName(c string) string {
 	newChannelName := strings.Replace(c, fmt.Sprintf("%s,", k.Username), "", 1)
 	return strings.Replace(newChannelName, fmt.Sprintf(",%s", k.Username), "", 1)
 }
-func formatOutput(api keybase.ChatAPI) string {
+
-	ret := ""
+func formatMessage(api keybase.ChatAPI, formatString string) StyledString {
-	msgType := api.Msg.Content.Type
+	msg := api.Msg
+	ret := config.Colors.Message.Header.stylize("")
+	msgType := msg.Content.Type
 	switch msgType {
 	case "text", "attachment":
-		var c = messageHeaderColor
+		ret = config.Colors.Message.Header.stylize(formatString)
-		ret = colorText(outputFormat, c, noColor)
+		tm := time.Unix(int64(msg.SentAt), 0)
-		tm := time.Unix(int64(api.Msg.SentAt), 0)
+		var body = formatMessageBody(msg.Content.Text.Body)
-		var msg = api.Msg.Content.Text.Body
-		// mention teams or users
-		msg = colorRegex(msg, `(@\w*(\.\w+)*)`, messageLinkColor, messageBodyColor)
-		// mention URL
-		msg = colorRegex(msg, `(https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*))`, messageLinkColor, messageBodyColor)
-		msg = colorText(colorReplaceMentionMe(msg, messageBodyColor), messageBodyColor, c)
 		if msgType == "attachment" {
-			msg = fmt.Sprintf("%s\n%s", api.Msg.Content.Attachment.Object.Title, colorText(fmt.Sprintf("[Attachment: %s]", api.Msg.Content.Attachment.Object.Filename), messageAttachmentColor, c))
+			body = config.Colors.Message.Body.stylize("$TITLE\n$FILE")
+			attachment := msg.Content.Attachment
+			body = body.replaceString("$TITLE", attachment.Object.Title)
+			body = body.replace("$FILE", config.Colors.Message.Attachment.stylize(fmt.Sprintf("[Attachment: %s]", attachment.Object.Filename)))
 		}
-		user := colorUsername(api.Msg.Sender.Username, c)
+		reply := ""
-		device := colorText(api.Msg.Sender.DeviceName, messageSenderDeviceColor, c)
+		if msg.Content.Text.ReplyTo != 0 {
-		msgID := colorText(fmt.Sprintf("%d", api.Msg.ID), messageIdColor, c)
+			chat := k.NewChat(channel)
-		ts := colorText(tm.Format(timeFormat), messageTimeColor, c)
+			replyMsg, replErr := chat.ReadMessage(msg.Content.Text.ReplyTo)
-		ret = strings.Replace(ret, "$MSG", msg, 1)
+			if replErr == nil {
-		ret = strings.Replace(ret, "$USER", user, 1)
+				replyUser := replyMsg.Result.Messages[0].Msg.Sender.Username
-		ret = strings.Replace(ret, "$DEVICE", device, 1)
+				replyBody := ""
-		ret = strings.Replace(ret, "$ID", msgID, 1)
+				if replyMsg.Result.Messages[0].Msg.Content.Type == "text" {
-		ret = strings.Replace(ret, "$TIME", ts, 1)
+					replyBody = replyMsg.Result.Messages[0].Msg.Content.Text.Body
-		ret = strings.Replace(ret, "$DATE", colorText(tm.Format(dateFormat), messageTimeColor, c), 1)
+				}
-		ret = strings.Replace(ret, "```", fmt.Sprintf("\n<code>\n"), -1)
+				reply = fmt.Sprintf("\nReplyTo> %s: %s\n", replyUser, replyBody)
+			}
+		}
+
+		user := colorUsername(msg.Sender.Username)
+		device := config.Colors.Message.SenderDevice.stylize(msg.Sender.DeviceName)
+		msgID := config.Colors.Message.ID.stylize(fmt.Sprintf("%d", msg.ID))
+		date := config.Colors.Message.Time.stylize(tm.Format(config.Formatting.DateFormat))
+		msgTime := config.Colors.Message.Time.stylize(tm.Format(config.Formatting.TimeFormat))
+		c0ck := config.Colors.Message.Quote.stylize(reply)
+		channelName := config.Colors.Message.ID.stylize(fmt.Sprintf("@%s#%s", msg.Channel.Name, msg.Channel.TopicName))
+		ret = ret.replace("$REPL", c0ck)
+		ret = ret.replace("$MSG", body)
+		ret = ret.replace("$USER", user)
+		ret = ret.replace("$DEVICE", device)
+		ret = ret.replace("$ID", msgID)
+		ret = ret.replace("$TIME", msgTime)
+		ret = ret.replace("$DATE", date)
+		ret = ret.replace("$TEAM", channelName)
+		ret = ret.replace("$TAGS", getUserFlags(api.Msg.Sender.Username))
 	}
 	return ret
 }
 
+func formatOutput(api keybase.ChatAPI) StyledString {
+	format := config.Formatting.OutputFormat
+	if stream {
+		format = config.Formatting.OutputStreamFormat
+	}
+	return formatMessage(api, format)
+}
+
 // End formatting
 
 // Input handling
 func handleMessage(api keybase.ChatAPI) {
+	if api.ErrorListen != nil {
+		printError(fmt.Sprintf("%+v", api.ErrorListen))
+		return
+	}
 	if _, ok := typeCommands[api.Msg.Content.Type]; ok {
 		if api.Msg.Channel.MembersType == channel.MembersType && cleanChannelName(api.Msg.Channel.Name) == channel.Name {
 			if channel.MembersType == keybase.TEAM && channel.TopicName != api.Msg.Channel.TopicName {
@@ -410,9 +601,7 @@ func handleMessage(api keybase.ChatAPI) {
 	}
 	if api.Msg.Content.Type == "text" || api.Msg.Content.Type == "attachment" {
 		go populateList()
-		msgBody := api.Msg.Content.Text.Body
 		msgSender := api.Msg.Sender.Username
-		channelName := api.Msg.Channel.Name
 		if !stream {
 			if msgSender != k.Username {
 				if api.Msg.Channel.MembersType == keybase.TEAM {
@@ -421,7 +610,7 @@ func handleMessage(api keybase.ChatAPI) {
 						if m.Text == k.Username {
 							// We are in a team
 							if topicName != channel.TopicName {
-								printToView("Feed", fmt.Sprintf("[ %s#%s ] %s: %s", channelName, topicName, msgSender, msgBody))
+								printInfoStyledString(formatMessage(api, config.Formatting.OutputMentionFormat))
 								fmt.Print("\a")
 							}
 
@@ -430,7 +619,7 @@ func handleMessage(api keybase.ChatAPI) {
 					}
 				} else {
 					if msgSender != channel.Name {
-						printToView("Feed", fmt.Sprintf("PM from @%s: %s", cleanChannelName(channelName), msgBody))
+						printInfoStyledString(formatMessage(api, config.Formatting.PMFormat))
 						fmt.Print("\a")
 					}
 
@@ -438,7 +627,7 @@ func handleMessage(api keybase.ChatAPI) {
 			}
 			if api.Msg.Channel.MembersType == channel.MembersType && cleanChannelName(api.Msg.Channel.Name) == channel.Name {
 				if channel.MembersType == keybase.USER || channel.MembersType == keybase.TEAM && channel.TopicName == api.Msg.Channel.TopicName {
-					printToView("Chat", formatOutput(api))
+					printToView("Chat", formatOutput(api).string())
 					chat := k.NewChat(channel)
 					lastMessage.ID = api.Msg.ID
 					chat.Read(api.Msg.ID)
@@ -446,10 +635,9 @@ func handleMessage(api keybase.ChatAPI) {
 			}
 		} else {
 			if api.Msg.Channel.MembersType == keybase.TEAM {
-				topicName := api.Msg.Channel.TopicName
+				printToView("Chat", formatOutput(api).string())
-				printToView("Chat", fmt.Sprintf("@%s#%s [%s]: %s", channelName, topicName, msgSender, msgBody))
 			} else {
-				printToView("Chat", fmt.Sprintf("PM @%s [%s]: %s", cleanChannelName(channelName), msgSender, msgBody))
+				printToView("Chat", formatMessage(api, config.Formatting.PMFormat).string())
 			}
 		}
 	} else {
@@ -483,8 +671,8 @@ func handleInput(viewName string) error {
 	if inputString == "" {
 		return nil
 	}
-	if strings.HasPrefix(inputString, cmdPrefix) {
+	if strings.HasPrefix(inputString, config.Basics.CmdPrefix) {
-		cmd := deleteEmpty(strings.Split(inputString[len(cmdPrefix):], " "))
+		cmd := deleteEmpty(strings.Split(inputString[len(config.Basics.CmdPrefix):], " "))
 		if len(cmd) < 1 {
 			return nil
 		}
@@ -494,7 +682,7 @@ func handleInput(viewName string) error {
 		} else if cmd[0] == "q" || cmd[0] == "quit" {
 			return gocui.ErrQuit
 		} else {
-			printToView("Feed", fmt.Sprintf("Command '%s' not recognized", cmd[0]))
+			printError(fmt.Sprintf("Command '%s' not recognized", cmd[0]))
 			return nil
 		}
 	}
@@ -503,6 +691,7 @@ func handleInput(viewName string) error {
 		cmd[0] = inputString[:1]
 		RunCommand(cmd...)
 	} else {
+		inputString = resolveRootEmojis(inputString)
 		go sendChat(inputString)
 	}
 	// restore any tab completion view titles on input commit
@@ -514,10 +703,11 @@ func handleInput(viewName string) error {
 	return nil
 }
 func sendChat(message string) {
+	autoScrollView("Chat")
 	chat := k.NewChat(channel)
 	_, err := chat.Send(message)
 	if err != nil {
-		printToView("Feed", fmt.Sprintf("There was an error %+v", err))
+		printError(fmt.Sprintf("There was an error %+v", err))
 	}
 }
 

tabComplete.go

@@ -20,53 +20,54 @@ func handleTab(viewName string) error {
 	inputString, err := getInputString(viewName)
 	if err != nil {
 		return err
+	}
+	// if you successfully get an input string, grab the last word from the string
+	ss := regexp.MustCompile(`[ #]`).Split(inputString, -1)
+	s := ss[len(ss)-1]
+	// create a variable in which to store the result
+	var resultSlice []string
+	// if the word starts with a : its an emoji lookup
+	if strings.HasPrefix(s, ":") {
+		resultSlice = getEmojiTabCompletionSlice(s)
+	} else if strings.HasPrefix(s, "/") {
+		generateCommandTabCompletionSlice()
+		s = strings.Replace(s, "/", "", 1)
+		resultSlice = getCommandTabCompletionSlice(s)
 	} else {
-		// if you successfully get an input string, grab the last word from the string
+		if strings.HasPrefix(s, "@") {
-		ss := regexp.MustCompile(`[ #]`).Split(inputString, -1)
+			// now in case the word (s) is a mention @something, lets remove it to normalize
-		s := ss[len(ss)-1]
+			s = strings.Replace(s, "@", "", 1)
-		// create a variable in which to store the result
-		var resultSlice []string
-		// if the word starts with a : its an emoji lookup
-		if strings.HasPrefix(s, ":") {
-			resultSlice = getEmojiTabCompletionSlice(s)
-		} else if strings.HasPrefix(s, "/") {
-			generateCommandTabCompletionSlice()
-			s = strings.Replace(s, "/", "", 1)
-			resultSlice = getCommandTabCompletionSlice(s)
-		} else {
-			if strings.HasPrefix(s, "@") {
-				// now in case the word (s) is a mention @something, lets remove it to normalize
-				s = strings.Replace(s, "@", "", 1)
-			}
-			// now call get the list of all possible cantidates that have that as a prefix
-			resultSlice = getChannelTabCompletionSlice(s)
 		}
-		rLen := len(resultSlice)
+		// now call get the list of all possible cantidates that have that as a prefix
-		lcp := longestCommonPrefix(resultSlice)
+		resultSlice = getChannelTabCompletionSlice(s)
-		if lcp != "" {
+	}
-			originalViewTitle := getViewTitle("Input")
+	rLen := len(resultSlice)
-			newViewTitle := ""
+	lcp := longestCommonPrefix(resultSlice)
-			if rLen >= 1 && originalViewTitle != "" {
+	if lcp != "" {
-				if rLen == 1 {
+		originalViewTitle := getViewTitle("Input")
-					newViewTitle = originalViewTitle
+		newViewTitle := ""
-				} else if rLen <= 5 {
+		if rLen >= 1 && originalViewTitle != "" {
-					newViewTitle = fmt.Sprintf("%s|| %s", originalViewTitle, strings.Join(resultSlice, " "))
+			if rLen == 1 {
-				} else if rLen > 5 {
+				newViewTitle = originalViewTitle
-					newViewTitle = fmt.Sprintf("%s|| %s +%d more", originalViewTitle, strings.Join(resultSlice[:6], " "), rLen-5)
+			} else if rLen <= 5 {
-				}
+				newViewTitle = fmt.Sprintf("%s|| %s", originalViewTitle, strings.Join(resultSlice, " "))
-				setViewTitle(viewName, newViewTitle)
+			} else if rLen > 5 {
-				remainder := stringRemainder(s, lcp)
+				newViewTitle = fmt.Sprintf("%s|| %s +%d more", originalViewTitle, strings.Join(resultSlice[:6], " "), rLen-5)
-				writeToView(viewName, remainder)
 			}
+			setViewTitle(viewName, newViewTitle)
+			remainder := stringRemainder(s, lcp)
+			writeToView(viewName, remainder)
 		}
 	}
+
 	return nil
 }
 
 // Main tab completion functions
 func getEmojiTabCompletionSlice(inputWord string) []string {
 	// use the emojiSlice from emojiList.go and filter it for the input word
-	resultSlice := filterStringSlice(emojiSlice, inputWord)
+	//resultSlice := filterStringSlice(emojiSlice, inputWord)
+	resultSlice := filterEmojiMap(emojiMap, inputWord)
 	return resultSlice
 }
 func getChannelTabCompletionSlice(inputWord string) []string {
@@ -123,22 +124,23 @@ func getCurrentChannelMembership() []string {
 	var rs []string
 	if channel.Name != "" {
 		t := k.NewTeam(channel.Name)
-		if testVar, err := t.MemberList(); err != nil {
+		testVar, err := t.MemberList()
+		if err != nil {
 			return rs // then this isn't a team, its a PM or there was an error in the API call
-		} else {
-			for _, m := range testVar.Result.Members.Owners {
-				rs = append(rs, fmt.Sprintf("%+v", m.Username))
-			}
-			for _, m := range testVar.Result.Members.Admins {
-				rs = append(rs, fmt.Sprintf("%+v", m.Username))
-			}
-			for _, m := range testVar.Result.Members.Writers {
-				rs = append(rs, fmt.Sprintf("%+v", m.Username))
-			}
-			for _, m := range testVar.Result.Members.Readers {
-				rs = append(rs, fmt.Sprintf("%+v", m.Username))
-			}
 		}
+		for _, m := range testVar.Result.Members.Owners {
+			rs = append(rs, fmt.Sprintf("%+v", m.Username))
+		}
+		for _, m := range testVar.Result.Members.Admins {
+			rs = append(rs, fmt.Sprintf("%+v", m.Username))
+		}
+		for _, m := range testVar.Result.Members.Writers {
+			rs = append(rs, fmt.Sprintf("%+v", m.Username))
+		}
+		for _, m := range testVar.Result.Members.Readers {
+			rs = append(rs, fmt.Sprintf("%+v", m.Username))
+		}
+
 	}
 	return rs
 }
@@ -151,6 +153,15 @@ func filterStringSlice(ss []string, fv string) []string {
 	}
 	return rs
 }
+func filterEmojiMap(eMap map[string]emojiData, fv string) []string {
+	var rs []string
+	for k, _ := range eMap {
+		if strings.HasPrefix(k, fv) {
+			rs = append(rs, k)
+		}
+	}
+	return rs
+}
 func longestCommonPrefix(ss []string) string {
 	// cover the case where the slice has no or one members
 	switch len(ss) {

tcmdShowReactions.go

@@ -20,15 +20,17 @@ func init() {
 }
 
 func tcmdShowReactions(m keybase.ChatAPI) {
-	where := ""
 	team := false
+	user := colorUsername(m.Msg.Sender.Username)
+	id := config.Colors.Message.ID.stylize(fmt.Sprintf("%d", m.Msg.Content.Reaction.M))
+	reaction := config.Colors.Message.Reaction.stylize(m.Msg.Content.Reaction.B)
+	where := config.Colors.Message.LinkKeybase.stylize("a PM")
 	if m.Msg.Channel.MembersType == keybase.TEAM {
 		team = true
-		where = fmt.Sprintf("in @%s#%s", m.Msg.Channel.Name, m.Msg.Channel.TopicName)
+		where = formatChannel(m.Msg.Channel)
 	} else {
-		where = fmt.Sprintf("in a PM")
 	}
-	printToView("Feed", fmt.Sprintf("%s reacted to %d with %s %s", m.Msg.Sender.Username, m.Msg.Content.Reaction.M, m.Msg.Content.Reaction.B, where))
+	printInfoF("$TEXT reacted to [$TEXT] with $TEXT in $TEXT", user, id, reaction, where)
 	if channel.Name == m.Msg.Channel.Name {
 		if team {
 			if channel.TopicName == m.Msg.Channel.TopicName {

types.go

@@ -17,3 +17,83 @@ type TypeCommand struct {
 	Description string                // A short description of the command
 	Exec        func(keybase.ChatAPI) // A function that takes a raw chat message as input
 }
+
+// Config holds user-configurable values
+type Config struct {
+	filepath   string     `toml:"-"` // filepath is not stored in the config file, but is written to the Config struct so it's known where the config was loaded from
+	Basics     Basics     `toml:"basics"`
+	Formatting Formatting `toml:"formatting"`
+	Colors     Colors     `toml:"colors"`
+}
+
+// Basics holds the 'basics' section of the config file
+type Basics struct {
+	DownloadPath  string `toml:"download_path"`
+	Colorless     bool   `toml:"colorless"`
+	CmdPrefix     string `toml:"cmd_prefix"`
+	UnicodeEmojis bool   `toml:"unicode_emojis"`
+}
+
+// Formatting holds the 'formatting' section of the config file
+type Formatting struct {
+	OutputFormat           string `toml:"output_format"`
+	OutputStreamFormat     string `toml:"output_stream_format"`
+	OutputMentionFormat    string `toml:"output_mention_format"`
+	PMFormat               string `toml:"pm_format"`
+	DateFormat             string `toml:"date_format"`
+	TimeFormat             string `toml:"time_format"`
+	IconFollowingUser      string `toml:"icon_following_user"`
+	IconIndirectFollowUser string `toml:"icon_indirect_following_user"`
+}
+
+// Colors holds the 'colors' section of the config file
+type Colors struct {
+	Channels Channels `toml:"channels"`
+	Message  Message  `toml:"message"`
+	Feed     Feed     `toml:"feed"`
+}
+
+// Style holds basic style information
+type Style struct {
+	Foreground    string `toml:"foreground"`
+	Background    string `toml:"background"`
+	Italic        bool   `toml:"italic"`
+	Bold          bool   `toml:"bold"`
+	Underline     bool   `toml:"underline"`
+	Strikethrough bool   `toml:"strikethrough"`
+	Inverse       bool   `toml:"inverse"`
+}
+
+// Channels holds the style information for various elements of a channel
+type Channels struct {
+	Basic  Style `toml:"basic"`
+	Header Style `toml:"header"`
+	Unread Style `toml:"unread"`
+}
+
+// Message holds the style information for various elements of a message
+type Message struct {
+	Body          Style `toml:"body"`
+	Header        Style `toml:"header"`
+	Mention       Style `toml:"mention"`
+	ID            Style `toml:"id"`
+	Tags          Style `toml:"tags"`
+	Time          Style `toml:"time"`
+	SenderDefault Style `toml:"sender_default"`
+	SenderDevice  Style `toml:"sender_device"`
+	SenderTags    Style `toml:"sender_tags"`
+	Attachment    Style `toml:"attachment"`
+	LinkURL       Style `toml:"link_url"`
+	LinkKeybase   Style `toml:"link_keybase"`
+	Reaction      Style `toml:"reaction"`
+	Quote         Style `toml:"quote"`
+	Code          Style `toml:"code"`
+}
+
+// Feed holds the style information for various elements of the feed window
+type Feed struct {
+	Basic   Style `toml:"basic"`
+	Error   Style `toml:"error"`
+	File    Style `toml:"file"`
+	Success Style `toml:"success"`
+}

userConfigs.go

@@ -1,30 +0,0 @@
-package main
-
-// Path where Downloaded files will default to
-var downloadPath = "/tmp/"
-
-var colorless = false
-var channelsColor = color(8)
-var channelsHeaderColor = color(6)
-var noColor = color(-1)
-var mentionColor = color(3)
-var messageHeaderColor = color(8)
-var messageIdColor = color(7)
-var messageTimeColor = color(6)
-var messageSenderDefaultColor = color(8)
-var messageSenderDeviceColor = color(8)
-var messageBodyColor = noColor
-var messageAttachmentColor = color(2)
-var messageLinkColor = color(4)
-
-// BASH-like PS1 variable equivalent
-var outputFormat = "┌──[$USER@$DEVICE] [$ID] [$DATE - $TIME]\n└╼ $MSG"
-
-// 02 = Day, Jan = Month, 06 = Year
-var dateFormat = "02Jan06"
-
-// 15 = hours, 04 = minutes, 05 = seconds
-var timeFormat = "15:04"
-
-// The prefix before evaluating a command
-var cmdPrefix = "/"

userTags.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+var followedInSteps = make(map[string]int)
+var trustTreeParent = make(map[string]string)
+
+func clearFlagCache() {
+	followedInSteps = make(map[string]int)
+	trustTreeParent = make(map[string]string)
+}
+
+var maxDepth = 4
+
+func generateFollowersList() {
+	// Does a BFS of followedInSteps
+	queue := []string{k.Username}
+	printInfo("Generating Tree of Trust...")
+	lastDepth := 1
+	for len(queue) > 0 {
+		head := queue[0]
+		queue = queue[1:]
+		depth := followedInSteps[head] + 1
+		if depth > maxDepth {
+			continue
+		}
+		if depth > lastDepth {
+			printInfo(fmt.Sprintf("Trust generated at Level #%d", depth-1))
+			lastDepth = depth
+		}
+
+		bytes, _ := k.Exec("list-following", head)
+		bigString := string(bytes)
+		following := strings.Split(bigString, "\n")
+		for _, user := range following {
+			if followedInSteps[user] == 0 && user != k.Username {
+				followedInSteps[user] = depth
+				trustTreeParent[user] = head
+				queue = append(queue, user)
+			}
+		}
+	}
+	printInfo(fmt.Sprintf("Trust-level estabilished for %d users", len(followedInSteps)))
+}
+
+func getUserFlags(username string) StyledString {
+	tags := ""
+	followDepth := followedInSteps[username]
+	if followDepth == 1 {
+		tags += fmt.Sprintf(" %s", config.Formatting.IconFollowingUser)
+	} else if followDepth > 1 {
+		tags += fmt.Sprintf(" %s%d", config.Formatting.IconIndirectFollowUser, followDepth-1)
+	}
+	return config.Colors.Message.SenderTags.stylize(tags)
+}