Add cmd subcommand

Author: chand1012

cmd/ask.go

@@ -112,7 +112,7 @@ Requires a path to a repository or file as a positional argument.`,
 			os.Exit(1)
 		}
 
-		fmt.Println(resp)
+		fmt.Println("Answer:", resp)
 	},
 }
 

cmd/cmd.go

@@ -0,0 +1,74 @@
+/*
+Copyright © 2023 Chandler <chandler@chand1012.dev>
+*/
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/chand1012/ottodocs/pkg/ai"
+	"github.com/chand1012/ottodocs/pkg/config"
+	"github.com/chand1012/ottodocs/pkg/shell"
+)
+
+// cmdCmd represents the cmd command
+var cmdCmd = &cobra.Command{
+	Use:   "cmd",
+	Short: "Browses Bash",
+	Long: `A longer description that spans multiple lines and likely contains examples
+and usage of using your command. For example:
+
+Cobra is a CLI library for Go that empowers applications.
+This application is a tool to generate the needed files
+to quickly create a Cobra application.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		conf, err := config.Load()
+		if err != nil || conf.APIKey == "" {
+			// if the API key is not set, prompt the user to login
+			log.Error("Please login first.")
+			log.Error("Run `ottodocs login` to login.")
+			os.Exit(1)
+		}
+
+		if chatPrompt == "" {
+			chatPrompt = "What command do you recommend I use next?"
+		}
+
+		log.Info("Thinking....")
+
+		history, err := shell.GetHistory(100)
+		if err != nil {
+			log.Error("This command is only supported on MacOS and Linux using Bash or Zsh. Windows and other shells coming soon!")
+			log.Error(err)
+			os.Exit(1)
+		}
+
+		// fmt.Println("History:", history)
+
+		resp, err := ai.CmdQuestion(history, chatPrompt, conf.APIKey, conf.Model)
+
+		if err != nil {
+			log.Error(err)
+			os.Exit(1)
+		}
+
+		fmt.Println("Answer:", resp)
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(cmdCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// cmdCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// cmdCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}

pkg/ai/cmd_question.go

@@ -0,0 +1,73 @@
+package ai
+
+import (
+	"fmt"
+
+	gopenai "github.com/CasualCodersProjects/gopenai"
+	ai_types "github.com/CasualCodersProjects/gopenai/types"
+	"github.com/chand1012/ottodocs/pkg/calc"
+	"github.com/chand1012/ottodocs/pkg/constants"
+)
+
+func CmdQuestion(history []string, chatPrompt, APIKey, model string) (string, error) {
+	openai := gopenai.NewOpenAI(&gopenai.OpenAIOpts{
+		APIKey: APIKey,
+	})
+
+	questionNoHistory := "\nQuestion: " + chatPrompt + "\n\nAnswer:"
+	historyQuestion := "Shell History:\n"
+
+	qTokens := calc.EstimateTokens(questionNoHistory)
+	commandPromptTokens := calc.EstimateTokens(constants.COMMAND_QUESTION_PROMPT)
+
+	// loop backwards through history to find the most recent question
+	for i := len(history) - 1; i >= 0; i-- {
+		newHistory := history[i] + "\n"
+		tokens := calc.EstimateTokens(newHistory) + qTokens + calc.EstimateTokens(historyQuestion) + commandPromptTokens
+		if tokens < constants.OPENAI_MAX_TOKENS {
+			historyQuestion += newHistory
+		} else {
+			break
+		}
+	}
+
+	question := historyQuestion + questionNoHistory
+
+	// fmt.Println(question)
+
+	messages := []ai_types.ChatMessage{
+		{
+			Content: constants.COMMAND_QUESTION_PROMPT,
+			Role:    "system",
+		},
+		{
+			Content: question,
+			Role:    "user",
+		},
+	}
+
+	tokens := calc.EstimateTokens(messages[0].Content, messages[1].Content)
+
+	maxTokens := constants.OPENAI_MAX_TOKENS - tokens
+
+	if maxTokens < 0 {
+		return "", fmt.Errorf("the prompt is too long. max length is %d. Got %d", constants.OPENAI_MAX_TOKENS, tokens)
+	}
+
+	req := ai_types.NewDefaultChatRequest("")
+	req.Messages = messages
+	req.MaxTokens = maxTokens
+	req.Model = model
+	// lower the temperature to make the model more deterministic
+	// req.Temperature = 0.3
+
+	resp, err := openai.CreateChat(req)
+	if err != nil {
+		fmt.Printf("Error: %s", err)
+		return "", err
+	}
+
+	message := resp.Choices[0].Message.Content
+
+	return message, nil
+}

pkg/constants/prompts.go

@@ -23,3 +23,9 @@ var QUESTION_PROMPT string = `You are a helpful assistant who answers questions
 - The answer must be in English.
 - If there is no way to answer the question, you should say so.
 - The answer must be AT LEAST one sentence long.`
+
+var COMMAND_QUESTION_PROMPT string = `You are a helpful assistant who answers questions about shell commands. The answer doesn't have to be extremely verbose, but it should be enough to help a new developer understand the code. You must answer the question with the following rules:
+- The answer must be relevant to the question and the given shell commands.
+- The answer must be in English.
+- If there is no way to answer the question, you should say so.
+- The answer must be AT LEAST one sentence long.`

pkg/shell/shell.go

@@ -0,0 +1,98 @@
+package shell
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/chand1012/ottodocs/pkg/utils"
+)
+
+const ZSH_HISTORY_PATH = ".zsh_history"
+const BASH_HISTORY_PATH = ".bash_history"
+
+// for now we only support bash and zsh for unix
+// we will support more in the future if demand is there
+// windows is on the roadmap
+
+// GetShellHistory gets the most recently used command from the shell history
+// file. It will attempt to open all of them, only getting the most recently
+// modified one. Only get n lines. If the history file is zsh, it will just get
+// the command and not the metadata.
+func GetHistory(n int) ([]string, error) {
+	shellHistories := []string{ZSH_HISTORY_PATH, BASH_HISTORY_PATH}
+	var mostRecentHistory string
+	var mostRecentTime int64
+	var shellUsed string
+	for _, history := range shellHistories {
+		// get the home directory
+		homeDir, err := os.UserHomeDir()
+		if err != nil {
+			return nil, err
+		}
+		// get the history file path
+		historyPath := filepath.Join(homeDir, history)
+		// get the file info
+		info, err := os.Stat(historyPath)
+		if err != nil {
+			continue
+		}
+		// check if the file is newer than the current most recent
+		if info.ModTime().Unix() > mostRecentTime {
+			mostRecentTime = info.ModTime().Unix()
+			mostRecentHistory = historyPath
+			shellUsed = history
+		}
+	}
+
+	// if we didn't find a history file, return an error
+	if mostRecentHistory == "" {
+		return nil, os.ErrNotExist
+	}
+
+	// open the file
+	contents, err := os.ReadFile(mostRecentHistory)
+	if err != nil {
+		return nil, err
+	}
+
+	// fmt.Println("shell used: ", shellUsed)
+	// fmt.Println("contents: ", string(contents))
+
+	var finalLines []string
+	if shellUsed == ZSH_HISTORY_PATH {
+		// split the file by newlines
+		lines := strings.Split(string(contents), "\n")
+		// reverse the lines
+		utils.ReverseSlice(lines)
+		for _, line := range lines {
+			// get just the command. Split each line after the first semicolon
+			// and get the first element
+			split_command := strings.SplitN(line, ";", 2)
+			if len(split_command) < 2 {
+				continue
+			}
+
+			command := split_command[1]
+			// if the command is empty, skip it
+			if command == "" {
+				continue
+			}
+			// add the command to the final lines
+			finalLines = append(finalLines, command)
+			if len(finalLines) >= n {
+				break
+			}
+		}
+	}
+
+	if shellUsed == BASH_HISTORY_PATH {
+		// just get the last 100 lines
+		finalLines = strings.Split(string(contents), "\n")
+		if len(finalLines) > n {
+			finalLines = finalLines[len(finalLines)-100:]
+		}
+	}
+
+	return finalLines, nil
+}

pkg/utils/reverse.go

@@ -0,0 +1,7 @@
+package utils
+
+func ReverseSlice[T any](s []T) {
+	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+		s[i], s[j] = s[j], s[i]
+	}
+}