Skip to content

Open source AI coding agent. Designed for large projects and real world tasks.

versioned model settings, models/set-model commands

Dane Schneider263c9d2fbf8b
diff --git a/app/cli/api/methods.go b/app/cli/api/methods.go
index ce23b696..79048575 100644
--- a/app/cli/api/methods.go
+++ b/app/cli/api/methods.go
@@ -1556,23 +1556,23 @@ func (a *Api) GetSettings(planId, branch string) (*shared.PlanSettings, *shared.
return &settings, nil
}
-func (a *Api) UpdateSettings(planId, branch string, req shared.UpdateSettingsRequest) *shared.ApiError {
+func (a *Api) UpdateSettings(planId, branch string, req shared.UpdateSettingsRequest) (*shared.UpdateSettingsResponse, *shared.ApiError) {
serverUrl := fmt.Sprintf("%s/plans/%s/%s/settings", getApiHost(), planId, branch)
reqBytes, err := json.Marshal(req)
if err != nil {
- return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %s", err)}
+ return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %s", err)}
}
request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
if err != nil {
- return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %s", err)}
+ return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %s", err)}
}
request.Header.Set("Content-Type", "application/json")
resp, err := authenticatedFastClient.Do(request)
if err != nil {
- return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
+ return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
}
defer resp.Body.Close()
@@ -1584,9 +1584,15 @@ func (a *Api) UpdateSettings(planId, branch string, req shared.UpdateSettingsReq
if tokenRefreshed {
return a.UpdateSettings(planId, branch, req)
}
- return apiErr
+ return nil, apiErr
}
- return nil
+ var updateRes shared.UpdateSettingsResponse
+ err = json.NewDecoder(resp.Body).Decode(&updateRes)
+ if err != nil {
+ return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
+ }
+
+ return &updateRes, nil
}
diff --git a/app/cli/cmd/convo.go b/app/cli/cmd/convo.go
index 3a1afe98..e88be873 100644
--- a/app/cli/cmd/convo.go
+++ b/app/cli/cmd/convo.go
@@ -42,7 +42,7 @@ func convo(cmd *cobra.Command, args []string) {
return
}
- var convMarkdown []string
+ var convo string
var totalTokens int
for i, msg := range conversation {
var author string
@@ -69,25 +69,27 @@ func convo(cmd *cobra.Command, args []string) {
header := fmt.Sprintf("#### %d | %s | %s | %d πŸͺ™ ", i+1,
author, formattedTs, msg.Tokens)
- convMarkdown = append(convMarkdown, header, msg.Message, "")
+
+ // convMarkdown = append(convMarkdown, header, msg.Message, "")
+
+ md, err := term.GetMarkdown(header + "\n" + msg.Message + "\n\n")
+ if err != nil {
+ fmt.Fprintln(os.Stderr, "Error creating markdown representation:", err)
+ return
+ }
+ convo += md
if msg.Stopped {
- convMarkdown = append(convMarkdown, fmt.Sprintf("πŸ›‘ **%s**", stoppedEarlyMsg), "")
+ convo += fmt.Sprintf(" πŸ›‘ %s\n\n", color.New(color.Bold, color.FgHiWhite).Sprint(stoppedEarlyMsg))
}
totalTokens += msg.Tokens
}
- markdownString, err := term.GetMarkdown(strings.Join(convMarkdown, "\n"))
- if err != nil {
- fmt.Fprintln(os.Stderr, "Error creating markdown representation:", err)
- return
- }
-
- markdownString = strings.ReplaceAll(markdownString, stoppedEarlyMsg, color.New(color.FgHiRed).Sprint(stoppedEarlyMsg))
+ convo = strings.ReplaceAll(convo, stoppedEarlyMsg, color.New(color.FgHiRed).Sprint(stoppedEarlyMsg))
output :=
- fmt.Sprintf("\n%s", markdownString) +
+ fmt.Sprintf("\n%s", convo) +
term.GetDivisionLine() +
color.New(color.Bold, color.FgCyan).Sprint(" Conversation size β†’") + fmt.Sprintf(" %d πŸͺ™", totalTokens) + "\n\n"
diff --git a/app/cli/cmd/models.go b/app/cli/cmd/models.go
index 3072704f..3ee2c890 100644
--- a/app/cli/cmd/models.go
+++ b/app/cli/cmd/models.go
@@ -6,7 +6,9 @@ import (
"plandex/api"
"plandex/auth"
"plandex/lib"
+ "plandex/term"
+ "github.com/fatih/color"
"github.com/olekukonko/tablewriter"
"github.com/plandex/plandex/shared"
"github.com/spf13/cobra"
@@ -39,39 +41,65 @@ func models(cmd *cobra.Command, args []string) {
modelSet = &shared.DefaultModelSet
}
+ color.New(color.Bold, color.FgHiCyan).Println("πŸ€– Models")
table := tablewriter.NewWriter(os.Stdout)
table.SetAutoWrapText(false)
- table.SetHeader([]string{"Role", "Provider", "Model", "Max πŸͺ™", "Temperature", "Top P", "Other"})
+ table.SetHeader([]string{"Role", "Provider", "Model", "Temperature", "Top P"})
- addModelRow := func(role string, config shared.ModelRoleConfig, additionalConfig string) {
+ addModelRow := func(role string, config shared.ModelRoleConfig) {
table.Append([]string{
role,
string(config.BaseModelConfig.Provider),
config.BaseModelConfig.ModelName,
- fmt.Sprintf("%d", config.BaseModelConfig.MaxTokens),
fmt.Sprintf("%.1f", config.Temperature),
fmt.Sprintf("%.1f", config.TopP),
- additionalConfig,
})
}
- addModelRow(string(shared.ModelRolePlannerRole), modelSet.Planner.ModelRoleConfig, fmt.Sprintf("max-convo-tokens β†’ %d", modelSet.Planner.PlannerModelConfig.MaxConvoTokens))
- addModelRow(string(shared.ModelRolePlanSummaryRole), modelSet.PlanSummary, "")
- // Builder role
- builderAdditionalConfig := ""
- addModelRow(string(shared.ModelRoleBuilderRole), modelSet.Builder.ModelRoleConfig, builderAdditionalConfig)
-
- // Namer role
- namerAdditionalConfig := ""
- addModelRow(string(shared.ModelRoleNameRole), modelSet.Namer.ModelRoleConfig, namerAdditionalConfig)
+ addModelRow(string(shared.ModelRolePlanner), modelSet.Planner.ModelRoleConfig)
+ addModelRow(string(shared.ModelRolePlanSummary), modelSet.PlanSummary)
+ addModelRow(string(shared.ModelRoleBuilder), modelSet.Builder.ModelRoleConfig)
+ addModelRow(string(shared.ModelRoleName), modelSet.Namer.ModelRoleConfig)
+ addModelRow(string(shared.ModelRoleCommitMsg), modelSet.CommitMsg.ModelRoleConfig)
+ addModelRow(string(shared.ModelRoleExecStatus), modelSet.ExecStatus.ModelRoleConfig)
+ table.Render()
- // CommitMsg role
- commitMsgAdditionalConfig := ""
- addModelRow(string(shared.ModelRoleCommitMsgRole), modelSet.CommitMsg.ModelRoleConfig, commitMsgAdditionalConfig)
+ fmt.Println()
- // ExecStatus role
- execStatusAdditionalConfig := ""
- addModelRow(string(shared.ModelRoleExecStatusRole), modelSet.ExecStatus.ModelRoleConfig, execStatusAdditionalConfig)
+ color.New(color.Bold, color.FgHiCyan).Println("🧠 Planner Defaults")
+ table = tablewriter.NewWriter(os.Stdout)
+ table.SetAutoWrapText(false)
+ table.SetHeader([]string{"Max Tokens", "Max Convo Tokens", "Reserved Output Tokens"})
+ table.Append([]string{
+ fmt.Sprintf("%d", modelSet.Planner.BaseModelConfig.MaxTokens),
+ fmt.Sprintf("%d", modelSet.Planner.MaxConvoTokens),
+ fmt.Sprintf("%d", modelSet.Planner.ReservedOutputTokens),
+ })
+ table.Render()
+ fmt.Println()
+ color.New(color.Bold, color.FgHiCyan).Println("βš™οΈ Planner Overrides")
+ table = tablewriter.NewWriter(os.Stdout)
+ table.SetAutoWrapText(false)
+ table.SetHeader([]string{"Name", "Value"})
+ if settings.ModelOverrides.MaxTokens == nil {
+ table.Append([]string{"Max Tokens", "no override"})
+ } else {
+ table.Append([]string{"Max Tokens", fmt.Sprintf("%d", *settings.ModelOverrides.MaxTokens)})
+ }
+ if settings.ModelOverrides.MaxConvoTokens == nil {
+ table.Append([]string{"Max Convo Tokens", "no override"})
+ } else {
+ table.Append([]string{"Max Convo Tokens", fmt.Sprintf("%d", *settings.ModelOverrides.MaxConvoTokens)})
+ }
+ if settings.ModelOverrides.ReservedOutputTokens == nil {
+ table.Append([]string{"Reserved Output Tokens", "no override"})
+ } else {
+ table.Append([]string{"Reserved Output Tokens", fmt.Sprintf("%d", *settings.ModelOverrides.ReservedOutputTokens)})
+ }
table.Render()
+
+ fmt.Println()
+ term.PrintCmds("", "set-model")
+
}
diff --git a/app/cli/cmd/set_model.go b/app/cli/cmd/set_model.go
index ca3b54d0..3ac9963e 100644
--- a/app/cli/cmd/set_model.go
+++ b/app/cli/cmd/set_model.go
@@ -1,11 +1,16 @@
package cmd
import (
+ "encoding/json"
"fmt"
+ "log"
"plandex/api"
"plandex/auth"
"plandex/lib"
"plandex/term"
+ "reflect"
+ "strconv"
+ "strings"
"github.com/plandex/plandex/shared"
"github.com/spf13/cobra"
@@ -18,7 +23,7 @@ func init() {
var modelsSetCmd = &cobra.Command{
Use: "set-model [role-or-setting] [property-or-value] [value]",
Short: "Update model settings",
- Run: models,
+ Run: modelsSet,
Args: cobra.MaximumNArgs(3),
}
@@ -26,63 +31,341 @@ func modelsSet(cmd *cobra.Command, args []string) {
auth.MustResolveAuthWithOrg()
lib.MustResolveProject()
- settings, err := api.Client.GetSettings(lib.CurrentPlanId, lib.CurrentBranch)
+ originalSettings, apiErr := api.Client.GetSettings(lib.CurrentPlanId, lib.CurrentBranch)
+ if apiErr != nil {
+ fmt.Println("Error getting current settings:", apiErr)
+ return
+ }
+
+ // Marshal and unmarshal to make a deep copy of the settings
+ jsonBytes, err := json.Marshal(originalSettings)
if err != nil {
- fmt.Println("Error getting current settings:", err)
+ fmt.Println("Error marshalling settings:", err)
return
}
- var roleOrSetting, property, value string
- if len(args) == 0 {
+ var settings *shared.PlanSettings
+ err = json.Unmarshal(jsonBytes, &settings)
+ if err != nil {
+ fmt.Println("Error unmarshalling settings:", err)
+ return
+ }
+
+ var roleOrSetting, propertyCompact, value string
+ var role shared.ModelRole
+ var settingCompact string
+ var settingDasherized string
+ var selectedModel *shared.BaseModelConfig
+ var temperature *float64
+ var topP *float64
+
+ if len(args) > 0 {
+ roleOrSetting = args[0]
+ for _, r := range shared.AllModelRoles {
+ if strings.EqualFold(string(r), roleOrSetting) {
+ role = r
+ break
+ }
+ }
+ if role == "" {
+ for _, s := range shared.ModelOverridePropsDasherized {
+ compact := shared.Compact(s)
+ if strings.EqualFold(compact, shared.Compact(roleOrSetting)) {
+ settingCompact = compact
+ settingDasherized = s
+ break
+ }
+ }
+ }
+ }
+
+ if role == "" && settingCompact == "" {
// Prompt user to select between updating a top-level setting or a modelset role
- choices := []string{"maxConvoTokens", "maxTokens", "reserveOutputTokens", "ModelSet Role"}
- selection, err := term.SelectFromList("Select a setting or role to update:", choices)
+ opts := []string{}
+ for _, role := range shared.AllModelRoles {
+ label := fmt.Sprintf("πŸ€– role | %s β†’ %s", role, shared.ModelRoleDescriptions[role])
+ opts = append(opts, label)
+ }
+ for _, setting := range shared.ModelOverridePropsDasherized {
+ label := fmt.Sprintf("βš™οΈ override | %s β†’ %s", shared.Dasherize(setting), shared.SettingDescriptions[setting])
+ opts = append(opts, label)
+ }
+
+ selection, err := term.SelectFromList("Select a role or override to update:", opts)
if err != nil {
+ if err.Error() == "interrupt" {
+ return
+ }
+
fmt.Println("Error selecting setting or role:", err)
return
}
- if selection == "ModelSet Role" {
- // Prompt for modelset role selection
- roleChoices := []string{"core-planner", "summarizer", "builder", "names", "commit-messages", "auto-complete"}
- roleOrSetting, err = term.SelectFromList("Select a role:", roleChoices)
- if err != nil {
- fmt.Println("Error selecting role:", err)
- return
- }
- // Prompt for property of the modelset
- property, err = term.GetUserStringInput("Enter the property to update (e.g., Model, Max πŸͺ™, Temperature):")
- if err != nil {
- fmt.Println("Error getting property:", err)
- return
+
+ idx := 0
+ for i, opt := range opts {
+ if opt == selection {
+ idx = i
+ break
}
+ }
+
+ if idx < len(shared.AllModelRoles) {
+ role = shared.AllModelRoles[idx]
} else {
- roleOrSetting = selection
+ settingDasherized = shared.ModelOverridePropsDasherized[idx-len(shared.AllModelRoles)]
+ settingCompact = shared.Compact(settingDasherized)
+
+ log.Printf("Selected setting: %s", settingDasherized)
+ log.Printf("Selected setting compact: %s", settingCompact)
}
- } else {
- roleOrSetting = args[0]
}
if len(args) > 1 {
- property = args[1]
+ if role != "" {
+ propertyCompact = shared.Compact(args[1])
+ } else {
+ value = args[1]
+ }
}
+
if len(args) > 2 {
value = args[2]
}
- // Logic to update settings based on the roleOrSetting, property, and value
- if roleOrSetting == "maxConvoTokens" || roleOrSetting == "maxTokens" || roleOrSetting == "reserveOutputTokens" {
- updateTopLevelSetting(&settings, roleOrSetting, value)
- } else {
- updateModelSetProperty(&settings.ModelSet, roleOrSetting, property, value)
+ if settingCompact != "" {
+ if value == "" {
+ var err error
+ value, err = term.GetUserStringInput(fmt.Sprintf("Set %s (leave blank for no value)", settingDasherized))
+ if err != nil {
+ if err.Error() == "interrupt" {
+ return
+ }
+
+ fmt.Println("Error getting value:", err)
+ return
+ }
+ }
+
+ switch settingCompact {
+ case "maxconvotokens":
+ if value == "" {
+ settings.ModelOverrides.MaxConvoTokens = nil
+ } else {
+ n, err := strconv.Atoi(value)
+ if err != nil {
+ fmt.Println("Invalid value for max-convo-tokens:", value)
+ return
+ }
+ settings.ModelOverrides.MaxConvoTokens = &n
+ }
+ case "maxtokens":
+ if value == "" {
+ settings.ModelOverrides.MaxTokens = nil
+ } else {
+ n, err := strconv.Atoi(value)
+ if err != nil {
+ fmt.Println("Invalid value for max-tokens:", value)
+ return
+ }
+ settings.ModelOverrides.MaxTokens = &n
+ }
+ case "reservedoutputtokens":
+ if value == "" {
+ settings.ModelOverrides.ReservedOutputTokens = nil
+ } else {
+ n, err := strconv.Atoi(value)
+ if err != nil {
+ fmt.Println("Invalid value for reserved-output-tokens:", value)
+ return
+ }
+ settings.ModelOverrides.ReservedOutputTokens = &n
+ }
+ }
+ }
+
+ if role != "" {
+ if !(propertyCompact == "temperature" || propertyCompact == "topp") {
+ for _, m := range shared.AvailableModels {
+ if propertyCompact == m.ModelName {
+ selectedModel = &m
+ break
+ }
+ }
+ }
+
+ if selectedModel == nil && propertyCompact == "" {
+ opts := []string{
+ "Select a model",
+ "Set temperature",
+ "Set top-p",
+ }
+
+ selection, err := term.SelectFromList("Select a property to update:", opts)
+ if err != nil {
+ if err.Error() == "interrupt" {
+ return
+ }
+
+ fmt.Println("Error selecting property:", err)
+ return
+ }
+
+ if selection == "Select a model" {
+
+ var opts []string
+ for _, m := range shared.AvailableModels {
+ label := fmt.Sprintf("%s β†’ %s | max %d πŸͺ™", m.Provider, m.ModelName, m.MaxTokens)
+ opts = append(opts, label)
+ }
+
+ selection, err := term.SelectFromList("Select a model:", opts)
+
+ if err != nil {
+ if err.Error() == "interrupt" {
+ return
+ }
+
+ fmt.Println("Error selecting model:", err)
+ return
+ }
+
+ for i := range opts {
+ if opts[i] == selection {
+ selectedModel = &shared.AvailableModels[i]
+ break
+ }
+ }
+
+ } else if selection == "Set temperature" {
+ propertyCompact = "temperature"
+ } else if selection == "Set top-p" {
+ propertyCompact = "topp"
+ }
+ }
+
+ if selectedModel == nil {
+ if propertyCompact != "" {
+ if value == "" {
+ msg := "Set"
+ if propertyCompact == "temperature" {
+ msg += "temperature (-2.0 to 2.0)"
+ } else if propertyCompact == "topp" {
+ msg += "top-p (0.0 to 1.0)"
+ }
+ var err error
+ value, err = term.GetUserStringInput(msg)
+ if err != nil {
+ if err.Error() == "interrupt" {
+ return
+ }
+
+ fmt.Println("Error getting value:", err)
+ return
+ }
+ }
+
+ switch propertyCompact {
+ case "temperature":
+ f, err := strconv.ParseFloat(value, 32)
+ if err != nil || f < -2.0 || f > 2.0 {
+ fmt.Println("Invalid value for temperature:", value)
+ return
+ }
+ temperature = &f
+ case "topp":
+ f, err := strconv.ParseFloat(value, 32)
+ if err != nil || f < 0.0 || f > 1.0 {
+ fmt.Println("Invalid value for top-p:", value)
+ return
+ }
+ topP = &f
+ }
+ }
+ }
+
+ if settings.ModelSet == nil {
+ settings.ModelSet = &shared.DefaultModelSet
+ }
+
+ switch role {
+ case shared.ModelRolePlanner:
+ if selectedModel != nil {
+ settings.ModelSet.Planner.BaseModelConfig = *selectedModel
+ settings.ModelSet.Planner.PlannerModelConfig = shared.PlannerModelConfigByName[selectedModel.ModelName]
+ } else if temperature != nil {
+ settings.ModelSet.Planner.Temperature = float32(*temperature)
+ } else if topP != nil {
+ settings.ModelSet.Planner.TopP = float32(*topP)
+ }
+
+ case shared.ModelRolePlanSummary:
+ if selectedModel != nil {
+ settings.ModelSet.PlanSummary.BaseModelConfig = *selectedModel
+ } else if temperature != nil {
+ settings.ModelSet.PlanSummary.Temperature = float32(*temperature)
+ } else if topP != nil {
+ settings.ModelSet.PlanSummary.TopP = float32(*topP)
+ }
+
+ case shared.ModelRoleBuilder:
+ if selectedModel != nil {
+ settings.ModelSet.Builder.BaseModelConfig = *selectedModel
+ settings.ModelSet.Builder.TaskModelConfig = shared.TaskModelConfigByName[selectedModel.ModelName]
+ } else if temperature != nil {
+ settings.ModelSet.Builder.Temperature = float32(*temperature)
+ } else if topP != nil {
+ settings.ModelSet.Builder.TopP = float32(*topP)
+ }
+
+ case shared.ModelRoleName:
+ if selectedModel != nil {
+ settings.ModelSet.Namer.BaseModelConfig = *selectedModel
+ settings.ModelSet.Namer.TaskModelConfig = shared.TaskModelConfigByName[selectedModel.ModelName]
+ } else if temperature != nil {
+ settings.ModelSet.Namer.Temperature = float32(*temperature)
+ } else if topP != nil {
+ settings.ModelSet.Namer.TopP = float32(*topP)
+ }
+
+ case shared.ModelRoleCommitMsg:
+ if selectedModel != nil {
+ settings.ModelSet.CommitMsg.BaseModelConfig = *selectedModel
+ settings.ModelSet.CommitMsg.TaskModelConfig = shared.TaskModelConfigByName[selectedModel.ModelName]
+ } else if temperature != nil {
+ settings.ModelSet.CommitMsg.Temperature = float32(*temperature)
+ } else if topP != nil {
+ settings.ModelSet.CommitMsg.TopP = float32(*topP)
+ }
+
+ case shared.ModelRoleExecStatus:
+ if selectedModel != nil {
+ settings.ModelSet.ExecStatus.BaseModelConfig = *selectedModel
+ settings.ModelSet.ExecStatus.TaskModelConfig = shared.TaskModelConfigByName[selectedModel.ModelName]
+ } else if temperature != nil {
+ settings.ModelSet.ExecStatus.Temperature = float32(*temperature)
+ } else if topP != nil {
+ settings.ModelSet.ExecStatus.TopP = float32(*topP)
+ }
+ }
+ }
+
+ if reflect.DeepEqual(originalSettings, settings) {
+ fmt.Println("πŸ€·β€β™‚οΈ No model settings were updated")
+ return
}
- err = api.Client.UpdateSettings(lib.CurrentPlanId, lib.CurrentBranch, shared.UpdateSettingsRequest{
- Settings: settings,
- })
- if err != nil {
- fmt.Println("Error updating settings:", err)
+ res, apiErr := api.Client.UpdateSettings(
+ lib.CurrentPlanId,
+ lib.CurrentBranch,
+ shared.UpdateSettingsRequest{
+ Settings: settings,
+ })
+ if apiErr != nil {
+ fmt.Println("Error updating settings:", apiErr)
return
}
- fmt.Println("Settings updated successfully.")
+ fmt.Println(res.Msg)
+ fmt.Println()
+ term.PrintCmds("", "models", "log", "rewind")
}
diff --git a/app/cli/term/term.go b/app/cli/term/term.go
index 3e85dd51..bef5e93b 100644
--- a/app/cli/term/term.go
+++ b/app/cli/term/term.go
@@ -39,6 +39,8 @@ var CmdDesc = map[string][2]string{
"branches": {"br", "list plan branches"},
"checkout": {"co", "checkout or create a branch"},
"build": {"b", "build any pending changes"},
+ "models": {"", "show model settings"},
+ "set-model": {"", "update model settings"},
}
func PrintCmds(prefix string, cmds ...string) {
diff --git a/app/cli/types/api.go b/app/cli/types/api.go
index 54830026..6b91b690 100644
--- a/app/cli/types/api.go
+++ b/app/cli/types/api.go
@@ -80,5 +80,5 @@ type ApiClient interface {
CreateBranch(planId, branch string, req shared.CreateBranchRequest) *shared.ApiError
GetSettings(planId, branch string) (*shared.PlanSettings, *shared.ApiError)
- UpdateSettings(planId, branch string, req shared.UpdateSettingsRequest) *shared.ApiError
+ UpdateSettings(planId, branch string, req shared.UpdateSettingsRequest) (*shared.UpdateSettingsResponse, *shared.ApiError)
}
diff --git a/app/server/handlers/fs_helper.go b/app/server/handlers/fs_helper.go
index 88e477a8..85eb303a 100644
--- a/app/server/handlers/fs_helper.go
+++ b/app/server/handlers/fs_helper.go
@@ -7,6 +7,7 @@ import (
"net/http"
"plandex-server/db"
"plandex-server/types"
+ "runtime/debug"
"github.com/gorilla/mux"
)
@@ -35,6 +36,13 @@ func lockRepo(w http.ResponseWriter, r *http.Request, auth *types.ServerAuth, sc
}
fn := func(err error) {
+ if r := recover(); r != nil {
+ stackTrace := debug.Stack()
+ log.Printf("Recovered from panic: %v\n", r)
+ log.Printf("Stack trace: %s\n", stackTrace)
+ err = fmt.Errorf("server panic: %v", r)
+ http.Error(w, "Error locking repo: "+err.Error(), http.StatusInternalServerError)
+ }
err = RollbackRepoIfErr(auth.OrgId, planId, err)
if err != nil {
@@ -56,6 +64,8 @@ func RollbackRepoIfErr(orgId, planId string, err error) error {
return nil
}
+ log.Println("Rolling back repo due to error")
+
// if any errors, rollback repo
err = db.GitClearUncommittedChanges(orgId, planId)
diff --git a/app/server/handlers/settings.go b/app/server/handlers/settings.go
index 9de79d11..741cbbaa 100644
--- a/app/server/handlers/settings.go
+++ b/app/server/handlers/settings.go
@@ -8,7 +8,6 @@ import (
"net/http"
"plandex-server/db"
"reflect"
- "regexp"
"strings"
"github.com/gorilla/mux"
@@ -101,7 +100,7 @@ func UpdateSettingsHandler(w http.ResponseWriter, r *http.Request) {
defer (*unlockFn)(err)
}
- originalSettings, err := db.GetPlanSettings(plan, false)
+ originalSettings, err := db.GetPlanSettings(plan, true)
if err != nil {
log.Println("Error getting settings: ", err)
@@ -127,22 +126,55 @@ func UpdateSettingsHandler(w http.ResponseWriter, r *http.Request) {
return
}
+ res := shared.UpdateSettingsResponse{
+ Msg: commitMsg,
+ }
+ bytes, err := json.Marshal(res)
+
+ if err != nil {
+ log.Println("Error marshalling response: ", err)
+ http.Error(w, "Error marshalling response", http.StatusInternalServerError)
+ return
+ }
+
+ w.Write(bytes)
+
log.Println("UpdateSettingsHandler processed successfully")
}
func getUpdateCommitMsg(settings *shared.PlanSettings, originalSettings *shared.PlanSettings) string {
+ log.Println("Comparing settings")
+ // log.Println("Original:")
+ // spew.Dump(originalSettings)
+ // log.Println("New:")
+ // spew.Dump(settings)
+
var changes []string
- compareAny(settings, originalSettings, "settings", &changes)
+ compareAny(originalSettings, settings, "", &changes)
if len(changes) == 0 {
return "No changes to settings"
}
- return "Updated settings:\n" + strings.Join(changes, "\n")
+ log.Println("Changes to settings:", strings.Join(changes, "\n"))
+
+ s := "βš™οΈ Updated model settings:"
+
+ for _, change := range changes {
+ s += "\n" + " β€’ " + change
+ }
+
+ return s
}
func compareAny(a, b interface{}, path string, changes *[]string) {
+ // log.Println("Comparing", path)
+ if strings.HasSuffix(path, "updated-at") ||
+ strings.HasSuffix(path, "open-ai-response-format") {
+ return
+ }
+
if reflect.DeepEqual(a, b) {
return
}
@@ -155,40 +187,53 @@ func compareAny(a, b interface{}, path string, changes *[]string) {
bVal = bVal.Elem()
}
- // Handle nil for slices, maps, ptrs
- if a == nil || b == nil || (aVal.Kind() != bVal.Kind()) {
- change := fmt.Sprintf("- %s: %v -> %v", path, a, b)
- *changes = append(*changes, change)
- return
- }
+ // log.Println("Comparing", path, aVal.Kind(), bVal.Kind())
+ // log.Println("aVal", aVal)
+ // log.Println("bVal", bVal)
switch aVal.Kind() {
case reflect.Struct:
for i := 0; i < aVal.NumField(); i++ {
fieldName := aVal.Type().Field(i).Name
- matches := regexp.MustCompile("([A-Z[a-z0-9]*)").FindAllStringSubmatch(fieldName, -1)
- var parts []string
- for _, match := range matches {
- parts = append(parts, match[0])
+ dasherizedName := shared.Dasherize(fieldName)
+
+ updatedPath := path
+ if !(dasherizedName == "model-set" ||
+ dasherizedName == "model-role-config" ||
+ dasherizedName == "base-model-config" ||
+ dasherizedName == "planner-model-config" ||
+ dasherizedName == "task-model-config") {
+ if updatedPath != "" {
+ updatedPath = updatedPath + "." + dasherizedName
+ } else {
+ if dasherizedName == "model-overrides" {
+ dasherizedName = "overrides"
+ }
+
+ updatedPath = dasherizedName
+ }
}
- dasherizedName := strings.ToLower(strings.Join(parts, "-"))
+
compareAny(aVal.Field(i).Interface(), bVal.Field(i).Interface(),
- path+"."+dasherizedName, changes)
+ updatedPath, changes)
}
- case reflect.Slice, reflect.Array:
- if aVal.Len() != bVal.Len() {
- change := fmt.Sprintf("- %s: %v -> %v", path, aVal.Interface(),
- bVal.Interface())
- *changes = append(*changes, change)
- return
+ default:
+ var a string
+ var b string
+
+ if aVal.IsValid() {
+ a = fmt.Sprintf("%v", aVal.Interface())
+ } else {
+ a = "no override"
}
- for i := 0; i < aVal.Len(); i++ {
- compareAny(aVal.Index(i).Interface(), bVal.Index(i).Interface(),
- fmt.Sprintf("%s[%d]", path, i), changes)
+
+ if bVal.IsValid() {
+ b = fmt.Sprintf("%v", bVal.Interface())
+ } else {
+ b = "no override"
}
- default:
- change := fmt.Sprintf("- %s: %v -> %v", path, aVal.Interface(),
- bVal.Interface())
+
+ change := fmt.Sprintf("%s | %v β†’ %v", path, a, b)
*changes = append(*changes, change)
}
}
diff --git a/app/shared/ai_models.go b/app/shared/ai_models.go
index 8bee5c44..3f687a67 100644
--- a/app/shared/ai_models.go
+++ b/app/shared/ai_models.go
@@ -44,32 +44,32 @@ var AvailableModels = []BaseModelConfig{
var PlannerModelConfigByName = map[string]PlannerModelConfig{
openai.GPT4TurboPreview: {
- MaxConvoTokens: 10000,
- ReserveOutputTokens: 4096,
+ MaxConvoTokens: 10000,
+ ReservedOutputTokens: 4096,
},
openai.GPT4Turbo0125: {
- MaxConvoTokens: 10000,
- ReserveOutputTokens: 4096,
+ MaxConvoTokens: 10000,
+ ReservedOutputTokens: 4096,
},
openai.GPT4Turbo1106: {
- MaxConvoTokens: 10000,
- ReserveOutputTokens: 4096,
+ MaxConvoTokens: 10000,
+ ReservedOutputTokens: 4096,
},
openai.GPT4: {
- MaxConvoTokens: 2500,
- ReserveOutputTokens: 1000,
+ MaxConvoTokens: 2500,
+ ReservedOutputTokens: 1000,
},
openai.GPT3Dot5Turbo: {
- MaxConvoTokens: 5000,
- ReserveOutputTokens: 2000,
+ MaxConvoTokens: 5000,
+ ReservedOutputTokens: 2000,
},
openai.GPT3Dot5Turbo0125: {
- MaxConvoTokens: 5000,
- ReserveOutputTokens: 2000,
+ MaxConvoTokens: 5000,
+ ReservedOutputTokens: 2000,
},
openai.GPT3Dot5Turbo1106: {
- MaxConvoTokens: 5000,
- ReserveOutputTokens: 2000,
+ MaxConvoTokens: 5000,
+ ReservedOutputTokens: 2000,
},
}
@@ -108,7 +108,7 @@ func init() {
DefaultModelSet = ModelSet{
Planner: PlannerRoleConfig{
ModelRoleConfig: ModelRoleConfig{
- Role: ModelRolePlannerRole,
+ Role: ModelRolePlanner,
BaseModelConfig: AvailableModelsByName[openai.GPT4TurboPreview],
Temperature: 0.6,
TopP: 0.7,
@@ -116,14 +116,14 @@ func init() {
PlannerModelConfig: PlannerModelConfigByName[openai.GPT4TurboPreview],
},
PlanSummary: ModelRoleConfig{
- Role: ModelRolePlanSummaryRole,
+ Role: ModelRolePlanSummary,
BaseModelConfig: AvailableModelsByName[openai.GPT4TurboPreview],
Temperature: 0.3,
TopP: 0.5,
},
Builder: TaskRoleConfig{
ModelRoleConfig: ModelRoleConfig{
- Role: ModelRoleBuilderRole,
+ Role: ModelRoleBuilder,
BaseModelConfig: AvailableModelsByName[openai.GPT4TurboPreview],
Temperature: 0.3,
TopP: 0.1,
@@ -132,7 +132,7 @@ func init() {
},
Namer: TaskRoleConfig{
ModelRoleConfig: ModelRoleConfig{
- Role: ModelRoleNameRole,
+ Role: ModelRoleName,
BaseModelConfig: AvailableModelsByName[openai.GPT3Dot5Turbo],
Temperature: 1.0,
TopP: 0.5,
@@ -141,7 +141,7 @@ func init() {
},
CommitMsg: TaskRoleConfig{
ModelRoleConfig: ModelRoleConfig{
- Role: ModelRoleCommitMsgRole,
+ Role: ModelRoleCommitMsg,
BaseModelConfig: AvailableModelsByName[openai.GPT3Dot5Turbo],
Temperature: 1.0,
TopP: 0.5,
@@ -150,7 +150,7 @@ func init() {
},
ExecStatus: TaskRoleConfig{
ModelRoleConfig: ModelRoleConfig{
- Role: ModelRoleExecStatusRole,
+ Role: ModelRoleExecStatus,
BaseModelConfig: AvailableModelsByName[openai.GPT4TurboPreview],
Temperature: 0.1,
TopP: 0.1,
diff --git a/app/shared/data_models.go b/app/shared/data_models.go
index 0ec71a0b..561c2823 100644
--- a/app/shared/data_models.go
+++ b/app/shared/data_models.go
@@ -211,8 +211,8 @@ type BaseModelConfig struct {
}
type PlannerModelConfig struct {
- MaxConvoTokens int `json:"maxConvoTokens"`
- ReserveOutputTokens int `json:"maxOutputTokens"`
+ MaxConvoTokens int `json:"maxConvoTokens"`
+ ReservedOutputTokens int `json:"maxOutputTokens"`
}
type TaskModelConfig struct {
@@ -222,14 +222,29 @@ type TaskModelConfig struct {
type ModelRole string
const (
- ModelRolePlannerRole ModelRole = "core-planner"
- ModelRolePlanSummaryRole ModelRole = "summarizer"
- ModelRoleBuilderRole ModelRole = "builder"
- ModelRoleNameRole ModelRole = "names"
- ModelRoleCommitMsgRole ModelRole = "commit-messages"
- ModelRoleExecStatusRole ModelRole = "auto-complete"
+ ModelRolePlanner ModelRole = "planner"
+ ModelRolePlanSummary ModelRole = "summarizer"
+ ModelRoleBuilder ModelRole = "builder"
+ ModelRoleName ModelRole = "names"
+ ModelRoleCommitMsg ModelRole = "commit-messages"
+ ModelRoleExecStatus ModelRole = "auto-complete"
)
+var AllModelRoles = []ModelRole{ModelRolePlanner, ModelRolePlanSummary, ModelRoleBuilder, ModelRoleName, ModelRoleCommitMsg, ModelRoleExecStatus}
+var ModelRoleDescriptions = map[ModelRole]string{
+ ModelRolePlanner: "replies to prompts and makes plans",
+ ModelRolePlanSummary: "summarizes conversations exceeding max-convo-tokens",
+ ModelRoleBuilder: "builds a plan into file diffs",
+ ModelRoleName: "names plans",
+ ModelRoleCommitMsg: "writes commit messages",
+ ModelRoleExecStatus: "determines whether to auto-continue",
+}
+var SettingDescriptions = map[string]string{
+ "max-convo-tokens": "max conversation πŸͺ™ before summarization",
+ "max-tokens": "overall πŸͺ™ limit",
+ "reserved-output-tokens": "πŸͺ™ reserved for model output",
+}
+
type ModelRoleConfig struct {
Role ModelRole `json:"role"`
BaseModelConfig BaseModelConfig `json:"baseModelConfig"`
@@ -256,50 +271,56 @@ type ModelSet struct {
ExecStatus TaskRoleConfig `json:"execStatus"`
}
+type ModelOverrides struct {
+ MaxConvoTokens *int `json:"maxConvoTokens"`
+ MaxTokens *int `json:"maxContextTokens"`
+ ReservedOutputTokens *int `json:"maxOutputTokens"`
+}
+
type PlanSettings struct {
- MaxConvoTokens *int `json:"maxConvoTokens"`
- MaxTokens *int `json:"maxContextTokens"`
- ReserveOutputTokens *int `json:"maxOutputTokens"`
- ModelSet *ModelSet `json:"modelSet"`
- UpdatedAt time.Time `json:"updatedAt"`
+ ModelOverrides ModelOverrides `json:"modelOverrides"`
+ ModelSet *ModelSet `json:"modelSet"`
+ UpdatedAt time.Time `json:"updatedAt"`
}
+var ModelOverridePropsDasherized = []string{"max-convo-tokens", "max-tokens", "reserved-output-tokens"}
+
func (ps PlanSettings) GetPlannerMaxTokens() int {
- if ps.MaxTokens == nil {
+ if ps.ModelOverrides.MaxTokens == nil {
if ps.ModelSet == nil {
return DefaultModelSet.Planner.BaseModelConfig.MaxTokens
} else {
return ps.ModelSet.Planner.BaseModelConfig.MaxTokens
}
} else {
- return *ps.MaxTokens
+ return *ps.ModelOverrides.MaxTokens
}
}
func (ps PlanSettings) GetPlannerMaxConvoTokens() int {
- if ps.MaxConvoTokens == nil {
+ if ps.ModelOverrides.MaxConvoTokens == nil {
if ps.ModelSet == nil {
return DefaultModelSet.Planner.PlannerModelConfig.MaxConvoTokens
} else {
return ps.ModelSet.Planner.PlannerModelConfig.MaxConvoTokens
}
} else {
- return *ps.MaxConvoTokens
+ return *ps.ModelOverrides.MaxConvoTokens
}
}
-func (ps PlanSettings) GetPlannerReserveOutputTokens() int {
- if ps.ReserveOutputTokens == nil {
+func (ps PlanSettings) GetPlannerReservedOutputTokens() int {
+ if ps.ModelOverrides.ReservedOutputTokens == nil {
if ps.ModelSet == nil {
- return DefaultModelSet.Planner.PlannerModelConfig.ReserveOutputTokens
+ return DefaultModelSet.Planner.PlannerModelConfig.ReservedOutputTokens
} else {
- return ps.ModelSet.Planner.PlannerModelConfig.ReserveOutputTokens
+ return ps.ModelSet.Planner.PlannerModelConfig.ReservedOutputTokens
}
} else {
- return *ps.ReserveOutputTokens
+ return *ps.ModelOverrides.ReservedOutputTokens
}
}
func (ps PlanSettings) GetPlannerEffectiveMaxTokens() int {
- return ps.GetPlannerMaxTokens() - ps.GetPlannerReserveOutputTokens()
+ return ps.GetPlannerMaxTokens() - ps.GetPlannerReservedOutputTokens()
}
diff --git a/app/shared/go.mod b/app/shared/go.mod
index 8642d281..0f2f656f 100644
--- a/app/shared/go.mod
+++ b/app/shared/go.mod
@@ -4,10 +4,16 @@ go 1.21.3
require github.com/pkoukk/tiktoken-go v0.1.6
-require github.com/mattn/go-runewidth v0.0.9 // indirect
+require (
+ github.com/mattn/go-colorable v0.1.13 // indirect
+ github.com/mattn/go-isatty v0.0.20 // indirect
+ github.com/mattn/go-runewidth v0.0.9 // indirect
+ golang.org/x/sys v0.14.0 // indirect
+)
require (
github.com/dlclark/regexp2 v1.10.0 // indirect
+ github.com/fatih/color v1.16.0
github.com/google/uuid v1.3.0 // indirect
github.com/olekukonko/tablewriter v0.0.5
github.com/sashabaranov/go-openai v1.19.4
diff --git a/app/shared/go.sum b/app/shared/go.sum
index ef86e107..0f7fa300 100644
--- a/app/shared/go.sum
+++ b/app/shared/go.sum
@@ -2,8 +2,15 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0=
github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
@@ -16,5 +23,9 @@ github.com/sashabaranov/go-openai v1.19.4 h1:GbaDiqvgYCabyqzuIbcEeT6/ZX1nVfur+++
github.com/sashabaranov/go-openai v1.19.4/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=
+golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/app/shared/plan_result.go b/app/shared/plan_result.go
index c2c2cc25..aaeeeace 100644
--- a/app/shared/plan_result.go
+++ b/app/shared/plan_result.go
@@ -303,18 +303,19 @@ func (state *CurrentPlanState) PendingChangesSummary() string {
})
if len(pendingNewFiles) > 0 {
- newMsg := " πŸ“„ New files:\n"
+ newMsg := ""
for _, path := range pendingNewFiles {
- newMsg += fmt.Sprintf(" β€’ %s\n", path)
+ newMsg += fmt.Sprintf(" β€’ new file β†’ %s\n", path)
}
msgs = append(msgs, newMsg)
}
if len(pendingReplacementPaths) > 0 {
- updatesMsg := " ✏️ Edits:\n"
+ // updatesMsg := " ✏️ Edits:\n"
+ updatesMsg := ""
for _, path := range pendingReplacementPaths {
- updatesMsg += fmt.Sprintf(" β€’ %s\n", path)
+ updatesMsg += fmt.Sprintf(" β€’ edit β†’ %s\n", path)
replacements := pendingReplacementsByPath[path]
diff --git a/app/shared/req_res.go b/app/shared/req_res.go
index 16fa5399..a59c67fb 100644
--- a/app/shared/req_res.go
+++ b/app/shared/req_res.go
@@ -185,3 +185,7 @@ type CreateBranchRequest struct {
type UpdateSettingsRequest struct {
Settings *PlanSettings `json:"settings"`
}
+
+type UpdateSettingsResponse struct {
+ Msg string `json:"msg"`
+}
diff --git a/app/shared/utils.go b/app/shared/utils.go
index ad2aa233..5a31b584 100644
--- a/app/shared/utils.go
+++ b/app/shared/utils.go
@@ -2,6 +2,8 @@ package shared
import (
"crypto/rand"
+ "regexp"
+ "strings"
"time"
)
@@ -23,3 +25,34 @@ func GetRandomAlphanumeric(n int) ([]byte, error) {
}
return bytes, nil
}
+
+func Dasherize(s string) string {
+ regex := regexp.MustCompile("([A-Z][a-z0-9]*)")
+ indexes := regex.FindAllStringIndex(s, -1)
+ if indexes == nil {
+ return strings.ToLower(s)
+ }
+
+ var parts []string
+ lastStart := 0
+ for _, loc := range indexes {
+ if lastStart != loc[0] {
+ parts = append(parts, s[lastStart:loc[0]])
+ }
+ parts = append(parts, s[loc[0]:loc[1]])
+ lastStart = loc[1]
+ }
+ if lastStart < len(s) {
+ parts = append(parts, s[lastStart:])
+ }
+
+ s = strings.ToLower(strings.Join(parts, "-"))
+ s = strings.ReplaceAll(s, " ", "-")
+ s = strings.ReplaceAll(s, "_", "-")
+
+ return s
+}
+
+func Compact(s string) string {
+ return strings.ReplaceAll(Dasherize(s), "-", "")
+}