Skip to content

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

lots of work on stream UI and builds

Dane Schneider6c2fef242319
diff --git a/app/cli/api/errors.go b/app/cli/api/errors.go
index 9ce5ae62..04878c1b 100644
--- a/app/cli/api/errors.go
+++ b/app/cli/api/errors.go
@@ -5,6 +5,7 @@ import (
"log"
"net/http"
"plandex/auth"
+ "strings"
"github.com/plandex/plandex/shared"
)
@@ -15,7 +16,7 @@ func handleApiError(r *http.Response, errBody []byte) *shared.ApiError {
return &shared.ApiError{
Type: shared.ApiErrorTypeOther,
Status: r.StatusCode,
- Msg: string(errBody),
+ Msg: strings.TrimSpace(string(errBody)),
}
}
@@ -25,7 +26,7 @@ func handleApiError(r *http.Response, errBody []byte) *shared.ApiError {
return &shared.ApiError{
Type: shared.ApiErrorTypeOther,
Status: r.StatusCode,
- Msg: string(errBody),
+ Msg: strings.TrimSpace(string(errBody)),
}
}
diff --git a/app/cli/api/methods.go b/app/cli/api/methods.go
index 5eabc4bc..dfa398a8 100644
--- a/app/cli/api/methods.go
+++ b/app/cli/api/methods.go
@@ -457,6 +457,56 @@ func (a *Api) TellPlan(planId, branch string, req shared.TellPlanRequest, onStre
return nil
}
+func (a *Api) BuildPlan(planId, branch string, req shared.BuildPlanRequest, onStream types.OnStreamPlan) *shared.ApiError {
+
+ log.Println("Calling BuildPlan")
+
+ serverUrl := fmt.Sprintf("%s/plans/%s/%s/build", getApiHost(), planId, branch)
+ reqBytes, err := json.Marshal(req)
+ if err != nil {
+ return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+ }
+
+ request, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
+ if err != nil {
+ return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+ }
+ request.Header.Set("Content-Type", "application/json")
+
+ var client *http.Client
+ if req.ConnectStream {
+ client = authenticatedStreamingClient
+ } else {
+ client = authenticatedFastClient
+ }
+
+ resp, err := client.Do(request)
+ if err != nil {
+ return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+ }
+
+ if resp.StatusCode >= 400 {
+ log.Println("Error response from build plan", resp.StatusCode)
+
+ errorBody, _ := io.ReadAll(resp.Body)
+ apiErr := handleApiError(resp, errorBody)
+
+ didRefresh, apiErr := refreshTokenIfNeeded(apiErr)
+
+ if didRefresh {
+ return a.BuildPlan(planId, branch, req, onStream)
+ }
+ return apiErr
+ }
+
+ if req.ConnectStream {
+ log.Println("Connecting stream")
+ connectPlanRespStream(resp.Body, onStream)
+ }
+
+ return nil
+}
+
func (a *Api) RespondMissingFile(planId, branch string, req shared.RespondMissingFileRequest) *shared.ApiError {
serverUrl := fmt.Sprintf("%s/plans/%s/%s/respond_missing_file", getApiHost(), planId, branch)
diff --git a/app/cli/api/stream.go b/app/cli/api/stream.go
index cf0667e0..25415559 100644
--- a/app/cli/api/stream.go
+++ b/app/cli/api/stream.go
@@ -33,9 +33,15 @@ func connectPlanRespStream(body io.ReadCloser, onStream types.OnStreamPlan) {
return
}
- // log.Println("Received message:", msg)
+ log.Println("Received message:", msg)
onStream(types.OnStreamPlanParams{Msg: &msg, Err: nil})
+
+ if msg.Type == shared.StreamMessageFinished || msg.Type == shared.StreamMessageError || msg.Type == shared.StreamMessageAborted {
+ body.Close()
+ return
+ }
+
}
}()
}
diff --git a/app/cli/changes_tui/actions.go b/app/cli/changes_tui/actions.go
index a98da4ec..bd874b07 100644
--- a/app/cli/changes_tui/actions.go
+++ b/app/cli/changes_tui/actions.go
@@ -138,6 +138,26 @@ func (m *changesUIModel) pageDown() {
}
}
+func (m *changesUIModel) start() {
+ if m.selectionInfo.currentRep == nil && m.fileScrollable() {
+ m.fileViewport.GotoTop()
+ } else if m.selectedViewport == 0 && m.oldScrollable() {
+ m.changeOldViewport.GotoTop()
+ } else if m.newScrollable() {
+ m.changeNewViewport.GotoTop()
+ }
+}
+
+func (m *changesUIModel) end() {
+ if m.selectionInfo.currentRep == nil && m.fileScrollable() {
+ m.fileViewport.GotoBottom()
+ } else if m.selectedViewport == 0 && m.oldScrollable() {
+ m.changeOldViewport.GotoBottom()
+ } else if m.newScrollable() {
+ m.changeNewViewport.GotoBottom()
+ }
+}
+
func (m *changesUIModel) switchView() {
m.selectedViewport = 1 - m.selectedViewport
m.updateMainView(false)
diff --git a/app/cli/changes_tui/main_viewport.go b/app/cli/changes_tui/main_viewport.go
index ad830f9d..7a19eef8 100644
--- a/app/cli/changes_tui/main_viewport.go
+++ b/app/cli/changes_tui/main_viewport.go
@@ -132,13 +132,11 @@ func (m changesUIModel) renderScrollFooter() string {
var footer string
if m.selectedNewFile() || m.selectedFullFile() {
- footer = `(j/k) scroll down/up • (d/u) page down/up`
+ footer = `(j/k) scroll • (d/u) page • (g/G) start/end`
} else {
footer = ` (j/k) scroll`
if m.oldScrollable() && m.newScrollable() {
footer += ` • (tab) switch view`
- } else {
- footer += ` down/up`
}
}
diff --git a/app/cli/changes_tui/model.go b/app/cli/changes_tui/model.go
index 05038669..ab779788 100644
--- a/app/cli/changes_tui/model.go
+++ b/app/cli/changes_tui/model.go
@@ -40,6 +40,8 @@ type keymap = struct {
scrollDown,
pageUp,
pageDown,
+ start,
+ end,
switchView,
reject,
copy,
@@ -103,6 +105,16 @@ func initialModel() *changesUIModel {
bubbleKey.WithHelp("u", "page up"),
),
+ start: bubbleKey.NewBinding(
+ bubbleKey.WithKeys("g", "home"),
+ bubbleKey.WithHelp("g", "start"),
+ ),
+
+ end: bubbleKey.NewBinding(
+ bubbleKey.WithKeys("G", "end"),
+ bubbleKey.WithHelp("G", "end"),
+ ),
+
switchView: bubbleKey.NewBinding(
bubbleKey.WithKeys("tab"),
bubbleKey.WithHelp("tab", "switch view"),
diff --git a/app/cli/changes_tui/update.go b/app/cli/changes_tui/update.go
index 5a6ac545..e75e3085 100644
--- a/app/cli/changes_tui/update.go
+++ b/app/cli/changes_tui/update.go
@@ -54,6 +54,12 @@ func (m changesUIModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
case bubbleKey.Matches(msg, m.keymap.pageUp):
m.pageUp()
+ case bubbleKey.Matches(msg, m.keymap.start):
+ m.start()
+
+ case bubbleKey.Matches(msg, m.keymap.end):
+ m.end()
+
case bubbleKey.Matches(msg, m.keymap.switchView):
m.switchView()
diff --git a/app/cli/cmd/build.go b/app/cli/cmd/build.go
new file mode 100644
index 00000000..ee2d3036
--- /dev/null
+++ b/app/cli/cmd/build.go
@@ -0,0 +1,96 @@
+package cmd
+
+import (
+ "fmt"
+ "log"
+ "os"
+ "plandex/api"
+ "plandex/auth"
+ "plandex/fs"
+ "plandex/lib"
+ "plandex/stream"
+ streamtui "plandex/stream_tui"
+ "plandex/term"
+
+ "github.com/plandex/plandex/shared"
+ "github.com/spf13/cobra"
+)
+
+var buildBg bool
+
+var buildCmd = &cobra.Command{
+ Use: "build",
+ Aliases: []string{"b"},
+ Short: "Send a prompt for the current plan.",
+ // Long: ``,
+ Args: cobra.NoArgs,
+ Run: build,
+}
+
+func init() {
+ RootCmd.AddCommand(buildCmd)
+
+ buildCmd.Flags().BoolVar(&buildBg, "bg", false, "Execute autonomously in the background")
+}
+
+func build(cmd *cobra.Command, args []string) {
+ if os.Getenv("OPENAI_API_KEY") == "" {
+ term.OutputNoApiKeyMsg()
+ os.Exit(1)
+ }
+
+ auth.MustResolveAuthWithOrg()
+ lib.MustResolveProject()
+
+ if lib.CurrentPlanId == "" {
+ fmt.Fprintln(os.Stderr, "No current plan")
+ return
+ }
+
+ lib.MustCheckOutdatedContextWithOutput()
+
+ projectPaths, _, err := fs.GetProjectPaths()
+
+ if err != nil {
+ fmt.Fprintln(os.Stderr, "Error getting project paths:", err)
+ return
+ }
+
+ apiErr := api.Client.BuildPlan(lib.CurrentPlanId, lib.CurrentBranch, shared.BuildPlanRequest{
+ ConnectStream: !buildBg,
+ ProjectPaths: projectPaths,
+ ApiKey: os.Getenv("OPENAI_API_KEY"),
+ }, stream.OnStreamPlan)
+
+ if apiErr != nil {
+ if apiErr.Msg == shared.NoBuildsErr {
+ streamtui.Quit()
+ fmt.Println("🤷‍♂️ This plan has no pending changes to build")
+ return
+ }
+
+ fmt.Fprintln(os.Stderr, "Error building plan:", apiErr.Msg)
+ return
+ }
+
+ if buildBg {
+ fmt.Println("🏗️ Building plan in the background")
+ } else {
+ go func() {
+ err := streamtui.StartStreamUI("", true)
+
+ if err != nil {
+ log.Printf("Error starting stream UI: %v\n", err)
+ os.Exit(1)
+ }
+
+ fmt.Println()
+ term.PrintCmds("", "changes", "log")
+
+ os.Exit(0)
+ }()
+
+ // Wait for the stream to finish
+ select {}
+ }
+}
diff --git a/app/cli/cmd/continue.go b/app/cli/cmd/continue.go
index 4f20154e..f1498b31 100644
--- a/app/cli/cmd/continue.go
+++ b/app/cli/cmd/continue.go
@@ -25,8 +25,8 @@ var nextCmd = &cobra.Command{
func init() {
RootCmd.AddCommand(nextCmd)
- nextCmd.Flags().BoolVar(&tellBg, "bg", false, "Execute autonomously in the background")
- nextCmd.Flags().BoolVar(&tellStep, "step", false, "Pause after a single step or reply")
+ nextCmd.Flags().BoolVarP(&tellStop, "stop", "s", false, "Stop after a single reply")
+ nextCmd.Flags().BoolVarP(&tellNoBuild, "no-build", "n", false, "Don't build files")
}
func doContinue(cmd *cobra.Command, args []string) {
@@ -44,5 +44,5 @@ func doContinue(cmd *cobra.Command, args []string) {
return
}
- tell.TellPlan(continuePrompt, tellBg, tellStep)
+ tell.TellPlan(continuePrompt, tellBg, tellStop, tellNoBuild)
}
diff --git a/app/cli/cmd/tell.go b/app/cli/cmd/tell.go
index 17056f22..0f26a868 100644
--- a/app/cli/cmd/tell.go
+++ b/app/cli/cmd/tell.go
@@ -19,7 +19,8 @@ const defaultEditor = "vim"
var tellPromptFile string
var tellBg bool
-var tellStep bool
+var tellStop bool
+var tellNoBuild bool
// tellCmd represents the prompt command
var tellCmd = &cobra.Command{
@@ -35,8 +36,9 @@ func init() {
RootCmd.AddCommand(tellCmd)
tellCmd.Flags().StringVarP(&tellPromptFile, "file", "f", "", "File containing prompt")
- tellCmd.Flags().BoolVar(&tellBg, "bg", false, "Execute autonomously in the background")
- tellCmd.Flags().BoolVar(&tellStep, "step", false, "Pause after a single step or reply")
+ // tellCmd.Flags().BoolVar(&tellBg, "bg", false, "Execute autonomously in the background") // Not implemented yet
+ tellCmd.Flags().BoolVarP(&tellStop, "stop", "s", false, "Stop after a single reply")
+ tellCmd.Flags().BoolVarP(&tellNoBuild, "no-build", "n", false, "Don't build files")
}
func doTell(cmd *cobra.Command, args []string) {
@@ -113,16 +115,6 @@ func doTell(cmd *cobra.Command, args []string) {
prompt = strings.TrimPrefix(prompt, strings.TrimSpace(instructions))
prompt = strings.TrimSpace(prompt)
-
- if prompt != "" {
- fmt.Print("\n\n")
- fmt.Print(term.GetDivisionLine())
- fmt.Print("\n\n")
- fmt.Println(prompt)
- fmt.Print("\n\n")
- fmt.Print(term.GetDivisionLine())
- fmt.Print("\n\n")
- }
}
if prompt == "" {
@@ -132,7 +124,7 @@ func doTell(cmd *cobra.Command, args []string) {
lib.MustCheckOutdatedContextWithOutput()
- tell.TellPlan(prompt, tellBg, tellStep)
+ tell.TellPlan(prompt, tellBg, tellStop, tellNoBuild)
}
func prepareEditorCommand(editor string, filename string) *exec.Cmd {
diff --git a/app/cli/go.mod b/app/cli/go.mod
index 10195057..e5d2f7f9 100644
--- a/app/cli/go.mod
+++ b/app/cli/go.mod
@@ -11,7 +11,7 @@ require (
github.com/olekukonko/tablewriter v0.0.5
github.com/plandex-ai/survey/v2 v2.0.0-00010101000000-000000000000
github.com/spf13/cobra v1.8.0
- golang.org/x/term v0.14.0
+ golang.org/x/term v0.17.0
)
require (
@@ -41,7 +41,7 @@ require (
github.com/yuin/goldmark-emoji v1.0.2 // indirect
golang.org/x/net v0.18.0 // indirect
golang.org/x/sync v0.5.0 // indirect
- golang.org/x/sys v0.14.0 // indirect
+ golang.org/x/sys v0.17.0 // indirect
)
require (
@@ -60,6 +60,7 @@ require (
github.com/plandex/plandex/shared v0.0.0-00010101000000-000000000000
github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
github.com/spf13/pflag v1.0.5 // indirect
+ golang.org/x/crypto v0.19.0
golang.org/x/text v0.14.0 // indirect
)
diff --git a/app/cli/go.sum b/app/cli/go.sum
index af2a89c9..97bf9c1a 100644
--- a/app/cli/go.sum
+++ b/app/cli/go.sum
@@ -733,6 +733,8 @@ golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -968,12 +970,16 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.7.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=
+golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
golang.org/x/term v0.14.0 h1:LGK9IlZ8T9jvdy6cTdfKUCltatMFOehAQo9SRC46UQ8=
golang.org/x/term v0.14.0/go.mod h1:TySc+nGkYR6qt8km8wUhuFRTVSMIX3XPR58y2lC8vww=
+golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
diff --git a/app/cli/stream_tui/model.go b/app/cli/stream_tui/model.go
index e89d303d..f14decb2 100644
--- a/app/cli/stream_tui/model.go
+++ b/app/cli/stream_tui/model.go
@@ -28,12 +28,13 @@ var missingFileSelectOpts = []string{
}
type streamUIModel struct {
- keymap keymap
+ buildOnly bool
+ keymap keymap
- reply string
- replyDisplay string
+ reply string
+ mainDisplay string
- replyViewport viewport.Model
+ mainViewport viewport.Model
processing bool
starting bool
@@ -56,6 +57,11 @@ type streamUIModel struct {
missingFileContent string
missingFileTokens int
+ prompt string
+
+ stopped bool
+ finished bool
+
err error
apiErr *shared.ApiError
}
@@ -66,26 +72,36 @@ type keymap = struct {
scrollDown,
pageUp,
pageDown,
+ start,
+ end,
up,
down,
- enter,
- quit bubbleKey.Binding
+ quit,
+ enter bubbleKey.Binding
}
func (m streamUIModel) Init() tea.Cmd {
- m.replyViewport.MouseWheelEnabled = true
+ m.mainViewport.MouseWheelEnabled = true
// start spinner
return m.spinner.Tick
}
-func initialModel() *streamUIModel {
+func initialModel(prestartReply, prompt string, buildOnly bool) *streamUIModel {
s := spinner.New()
- s.Spinner = spinner.Dot
+ s.Spinner = spinner.Points
s.Style = lipgloss.NewStyle().Foreground(lipgloss.Color("205"))
initialState := streamUIModel{
+ buildOnly: buildOnly,
+ prompt: prompt,
+ reply: prestartReply,
keymap: keymap{
+ quit: bubbleKey.NewBinding(
+ bubbleKey.WithKeys("ctrl+c"),
+ bubbleKey.WithHelp("ctrl+c", "quit"),
+ ),
+
stop: bubbleKey.NewBinding(
bubbleKey.WithKeys("s"),
bubbleKey.WithHelp("s", "stop"),
@@ -102,16 +118,13 @@ func initialModel() *streamUIModel {
),
pageDown: bubbleKey.NewBinding(
- bubbleKey.WithKeys("J", "pageDown"),
- bubbleKey.WithHelp("J", "page down"),
+ bubbleKey.WithKeys("d", "pageDown"),
+ bubbleKey.WithHelp("d", "page down"),
),
pageUp: bubbleKey.NewBinding(
- bubbleKey.WithKeys("K", "pageUp"),
- bubbleKey.WithHelp("K", "page up"),
- ),
- quit: bubbleKey.NewBinding(
- bubbleKey.WithKeys("ctrl+c"),
+ bubbleKey.WithKeys("u", "pageUp"),
+ bubbleKey.WithHelp("u", "page up"),
),
up: bubbleKey.NewBinding(
@@ -128,6 +141,16 @@ func initialModel() *streamUIModel {
bubbleKey.WithKeys("enter"),
bubbleKey.WithHelp("enter", "select"),
),
+
+ start: bubbleKey.NewBinding(
+ bubbleKey.WithKeys("g", "home"),
+ bubbleKey.WithHelp("g", "start"),
+ ),
+
+ end: bubbleKey.NewBinding(
+ bubbleKey.WithKeys("G", "end"),
+ bubbleKey.WithHelp("G", "end"),
+ ),
},
tokensByPath: make(map[string]int),
diff --git a/app/cli/stream_tui/run.go b/app/cli/stream_tui/run.go
index 52f02d53..0fb06d40 100644
--- a/app/cli/stream_tui/run.go
+++ b/app/cli/stream_tui/run.go
@@ -6,14 +6,18 @@ import (
"sync"
tea "github.com/charmbracelet/bubbletea"
+ "github.com/fatih/color"
+ "github.com/plandex/plandex/shared"
)
var ui *tea.Program
var mu sync.Mutex
var wg sync.WaitGroup
-func StartStreamUI() error {
- initial := initialModel()
+var prestartReply string
+
+func StartStreamUI(prompt string, buildOnly bool) error {
+ initial := initialModel(prestartReply, prompt, buildOnly)
mu.Lock()
ui = tea.NewProgram(initial, tea.WithAltScreen())
@@ -24,11 +28,33 @@ func StartStreamUI() error {
wg.Done()
if err != nil {
- return fmt.Errorf("error running changes UI: %v", err)
+ return fmt.Errorf("error running stream UI: %v", err)
+ }
+
+ mod := m.(*streamUIModel)
+
+ fmt.Println()
+
+ if !mod.buildOnly {
+ fmt.Println(mod.mainDisplay)
+ }
+ fmt.Println(mod.renderStaticBuild())
+
+ if mod.err != nil {
+ fmt.Println()
+ color.New(color.FgHiRed, color.Bold).Printf("error in stream UI: %v\n", mod.err)
+ return fmt.Errorf("error in stream UI: %v", mod.err)
+ }
+
+ if mod.apiErr != nil {
+ fmt.Println()
+ color.New(color.FgHiRed, color.Bold).Printf("error in stream UI: %s\n", mod.apiErr.Msg)
+ return fmt.Errorf("error in stream UI: %v", mod.apiErr)
}
- if m.(streamUIModel).err != nil {
- return fmt.Errorf("error in changes UI: %v", m.(streamUIModel).err)
+ if mod.stopped {
+ color.New(color.BgBlack, color.Bold, color.FgHiRed).Print(" 🛑 stopped early by user ")
+ fmt.Println()
}
return nil
@@ -36,7 +62,7 @@ func StartStreamUI() error {
func Quit() {
if ui == nil {
- log.Println("stream ui is nil, can't quit")
+ log.Println("stream UI is nil, can't quit")
return
}
mu.Lock()
@@ -47,9 +73,10 @@ func Quit() {
}
-func Send(msg tea.Msg) {
+func Send(msg shared.StreamMessage) {
if ui == nil {
- log.Println("stream ui is nil")
+ // log.Println("stream ui is nil")
+ prestartReply += msg.ReplyChunk
return
}
mu.Lock()
diff --git a/app/cli/stream_tui/update.go b/app/cli/stream_tui/update.go
index 45d157a1..a472c0f5 100644
--- a/app/cli/stream_tui/update.go
+++ b/app/cli/stream_tui/update.go
@@ -15,6 +15,7 @@ import (
"github.com/charmbracelet/bubbles/viewport"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
+ "github.com/fatih/color"
"github.com/plandex/plandex/shared"
)
@@ -39,26 +40,28 @@ func (m streamUIModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
case delayFileRestartMsg:
m.finishedByPath[msg.path] = false
- case tea.MouseMsg:
- if !m.promptingMissingFile {
- if msg.Type == tea.MouseWheelUp {
- m.replyViewport.LineUp(3)
- } else if msg.Type == tea.MouseWheelDown {
- m.replyViewport.LineDown(3)
- }
- }
+ // Scroll wheel doesn't seem to work--not sure why
+ // case tea.MouseMsg:
+ // if !m.promptingMissingFile {
+ // if msg.Type == tea.MouseWheelUp {
+ // m.mainViewport.LineUp(3)
+ // } else if msg.Type == tea.MouseWheelDown {
+ // m.mainViewport.LineDown(3)
+ // }
+ // }
case tea.KeyMsg:
switch {
+
case bubbleKey.Matches(msg, m.keymap.quit):
- return m, tea.Quit
+ return &m, tea.Quit
case bubbleKey.Matches(msg, m.keymap.stop):
apiErr := api.Client.StopPlan(lib.CurrentPlanId, lib.CurrentBranch)
if apiErr != nil {
log.Println("stop plan api error:", apiErr)
m.apiErr = apiErr
- return m, nil
+ return &m, nil
}
case bubbleKey.Matches(msg, m.keymap.scrollDown) && !m.promptingMissingFile:
@@ -73,6 +76,10 @@ func (m streamUIModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.up()
case bubbleKey.Matches(msg, m.keymap.down):
m.down()
+ case bubbleKey.Matches(msg, m.keymap.start) && !m.promptingMissingFile:
+ m.scrollStart()
+ case bubbleKey.Matches(msg, m.keymap.end) && !m.promptingMissingFile:
+ m.scrollEnd()
case m.promptingMissingFile && bubbleKey.Matches(msg, m.keymap.enter):
m.selectedMissingFileOpt()
@@ -93,27 +100,44 @@ func (m *streamUIModel) windowResized(w, h int) {
if m.ready {
m.updateViewportDimensions()
} else {
- m.replyViewport = viewport.New(w, viewportHeight)
- m.replyViewport.Style = lipgloss.NewStyle().Padding(0, 1, 0, 1)
+ m.mainViewport = viewport.New(w, viewportHeight)
+ m.mainViewport.Style = lipgloss.NewStyle().Padding(0, 1, 0, 1)
+ m.updateReplyDisplay()
m.ready = true
}
}
func (m *streamUIModel) updateReplyDisplay() {
- md, _ := term.GetMarkdown(m.reply)
- m.replyDisplay = md
- m.replyViewport.SetContent(md)
+ if m.buildOnly {
+ return
+ }
+
+ promptTxt, _ := term.GetPlain(m.prompt)
+
+ s := color.New(color.BgGreen, color.Bold, color.FgHiWhite).Sprintf(" 💬 User prompt 👇 ")
+ s += "\n" + promptTxt
+
+ if m.reply != "" {
+ replyMd, _ := term.GetMarkdown(m.reply)
+ s += "\n\n" + color.New(color.BgBlue, color.Bold, color.FgHiWhite).Sprintf(" 🤖 Plandex reply 👇 ")
+ s += "\n" + strings.TrimSpace(replyMd) + "\n"
+ } else {
+ s += "\n"
+ }
+
+ m.mainDisplay = s
+ m.mainViewport.SetContent(s)
m.updateViewportDimensions()
if m.atScrollBottom {
- m.replyViewport.GotoBottom()
+ m.mainViewport.GotoBottom()
}
}
func (m *streamUIModel) updateViewportDimensions() {
w, h := m.getViewportDimensions()
- m.replyViewport.Width = w
- m.replyViewport.Height = h
+ m.mainViewport.Width = w
+ m.mainViewport.Height = h
}
func (m *streamUIModel) getViewportDimensions() (int, int) {
@@ -121,10 +145,19 @@ func (m *streamUIModel) getViewportDimensions() (int, int) {
h := m.height
helpHeight := lipgloss.Height(m.renderHelp())
- buildHeight := lipgloss.Height(m.renderBuild())
- processingHeight := lipgloss.Height(m.renderProcessing())
+
+ var buildHeight int
+ if m.building {
+ buildHeight = lipgloss.Height(m.renderBuild())
+ }
+
+ var processingHeight int
+ if m.starting || m.processing {
+ processingHeight = lipgloss.Height(m.renderProcessing())
+ }
+
maxViewportHeight := h - (helpHeight + processingHeight + buildHeight)
- viewportHeight := min(maxViewportHeight, lipgloss.Height(m.replyDisplay))
+ viewportHeight := min(maxViewportHeight, lipgloss.Height(m.mainDisplay))
viewportWidth := w
// log.Println("viewportWidth:", viewportWidth)
@@ -133,39 +166,53 @@ func (m *streamUIModel) getViewportDimensions() (int, int) {
}
func (m streamUIModel) replyScrollable() bool {
- return m.replyViewport.TotalLineCount() > m.replyViewport.VisibleLineCount()
+ return m.mainViewport.TotalLineCount() > m.mainViewport.VisibleLineCount()
}
func (m *streamUIModel) scrollDown() {
if m.replyScrollable() {
- m.replyViewport.LineDown(1)
+ m.mainViewport.LineDown(1)
}
- m.atScrollBottom = !m.replyScrollable() || m.replyViewport.AtBottom()
+ m.atScrollBottom = !m.replyScrollable() || m.mainViewport.AtBottom()
}
func (m *streamUIModel) scrollUp() {
if m.replyScrollable() {
- m.replyViewport.LineUp(1)
+ m.mainViewport.LineUp(1)
m.atScrollBottom = false
}
}
func (m *streamUIModel) pageDown() {
if m.replyScrollable() {
- m.replyViewport.ViewDown()
+ m.mainViewport.ViewDown()
}
- m.atScrollBottom = !m.replyScrollable() || m.replyViewport.AtBottom()
+ m.atScrollBottom = !m.replyScrollable() || m.mainViewport.AtBottom()
}
func (m *streamUIModel) pageUp() {
if m.replyScrollable() {
- m.replyViewport.ViewUp()
+ m.mainViewport.ViewUp()
+ m.atScrollBottom = false
+ }
+}
+
+func (m *streamUIModel) scrollStart() {
+ if m.replyScrollable() {
+ m.mainViewport.GotoTop()
m.atScrollBottom = false
}
}
+func (m *streamUIModel) scrollEnd() {
+ if m.replyScrollable() {
+ m.mainViewport.GotoBottom()
+ m.atScrollBottom = true
+ }
+}
+
func (m *streamUIModel) streamUpdate(msg *shared.StreamMessage) (tea.Model, tea.Cmd) {
// log.Println("streamUI received message:", msg.Type)
switch msg.Type {
@@ -212,6 +259,10 @@ func (m *streamUIModel) streamUpdate(msg *shared.StreamMessage) (tea.Model, tea.
m.updateReplyDisplay()
case shared.StreamMessageBuildInfo:
+ if m.starting {
+ m.starting = false
+ }
+
m.building = true
wasFinished := m.finishedByPath[msg.BuildInfo.Path]
nowFinished := msg.BuildInfo.Finished
@@ -237,10 +288,20 @@ func (m *streamUIModel) streamUpdate(msg *shared.StreamMessage) (tea.Model, tea.
return m, m.spinner.Tick
case shared.StreamMessageError:
+ m.apiErr = msg.Error
+ return m, tea.Quit
case shared.StreamMessageFinished:
+ m.finished = true
+ return m, tea.Quit
case shared.StreamMessageAborted:
+ m.stopped = true
+ return m, tea.Quit
+
+ case shared.StreamMessageRepliesFinished:
+ m.processing = false
+
}
return m, nil
diff --git a/app/cli/stream_tui/view.go b/app/cli/stream_tui/view.go
index eb8f1f28..69e5fef8 100644
--- a/app/cli/stream_tui/view.go
+++ b/app/cli/stream_tui/view.go
@@ -17,42 +17,77 @@ func (m streamUIModel) View() string {
return m.renderMissingFilePrompt()
}
- return lipgloss.JoinVertical(lipgloss.Left,
- m.renderMainView(),
- m.renderProcessing(),
- m.renderBuild(),
- m.renderHelp(),
- )
+ var views []string
+ if !m.buildOnly {
+ views = append(views, m.renderMainView())
+ }
+ if m.processing || m.starting {
+ views = append(views, m.renderProcessing())
+ }
+ if m.building {
+ views = append(views, m.renderBuild())
+ }
+ views = append(views, m.renderHelp())
+
+ return lipgloss.JoinVertical(lipgloss.Left, views...)
}
func (m streamUIModel) renderMainView() string {
- return m.replyViewport.View()
+ return m.mainViewport.View()
}
func (m streamUIModel) renderHelp() string {
style := lipgloss.NewStyle().Width(m.width).Foreground(lipgloss.Color(helpTextColor)).BorderStyle(lipgloss.NormalBorder()).BorderTop(true).BorderForeground(lipgloss.Color(borderColor))
- return style.Render(" (s)top")
+ if m.buildOnly {
+ return style.Render(" (s)top")
+ } else {
+ return style.Render(" (s)top • (j/k) scroll • (d/u) page • (g/G) start/end")
+ }
}
func (m streamUIModel) renderProcessing() string {
if m.starting || m.processing {
- style := lipgloss.NewStyle().Width(m.width).BorderStyle(lipgloss.NormalBorder()).BorderTop(true).BorderForeground(lipgloss.Color(borderColor))
-
- return style.Render(m.spinner.View())
+ return "\n " + m.spinner.View()
} else {
return ""
}
}
func (m streamUIModel) renderBuild() string {
- if !m.building {
+ return m.doRenderBuild(false)
+}
+
+func (m streamUIModel) renderStaticBuild() string {
+ return m.doRenderBuild(true)
+}
+
+func (m streamUIModel) doRenderBuild(outputStatic bool) string {
+ if !m.building && !outputStatic {
return ""
}
- style := lipgloss.NewStyle().Width(m.width).BorderStyle(lipgloss.NormalBorder()).BorderTop(true).BorderForeground(lipgloss.Color(borderColor))
+ if outputStatic && len(m.finishedByPath) == 0 {
+ return ""
+ }
+
+ if outputStatic && len(m.finishedByPath) != len(m.tokensByPath) {
+ return ""
+ }
+
+ var style lipgloss.Style
+ if m.buildOnly {
+ style = lipgloss.NewStyle().Width(m.width)
+ } else {
+ style = lipgloss.NewStyle().Width(m.width).BorderStyle(lipgloss.NormalBorder()).BorderTop(true).BorderForeground(lipgloss.Color(borderColor))
+ }
+
+ lbl := "Building plan "
+ if outputStatic {
+ lbl = "Built plan "
+ }
- head := color.New(color.BgGreen, color.FgHiWhite, color.Bold).Sprint(" 🏗 ") + color.New(color.BgGreen, color.FgHiWhite).Sprint("Building plan ")
+ head := color.New(color.BgGreen, color.FgHiWhite, color.Bold).Sprint(" 🏗 ") + color.New(color.BgGreen, color.FgHiWhite).Sprint(lbl)
filePaths := make([]string, 0, len(m.tokensByPath))
for filePath := range m.tokensByPath {
diff --git a/app/cli/tell/tell.go b/app/cli/tell/tell.go
index 6c0b7acb..063c8f77 100644
--- a/app/cli/tell/tell.go
+++ b/app/cli/tell/tell.go
@@ -2,6 +2,7 @@ package tell
import (
"fmt"
+ "log"
"os"
"plandex/api"
"plandex/auth"
@@ -14,7 +15,7 @@ import (
"github.com/plandex/plandex/shared"
)
-func TellPlan(prompt string, tellBg, tellStep bool) {
+func TellPlan(prompt string, tellBg, tellStop, tellNoBuild bool) {
projectPaths, _, err := fs.GetProjectPaths()
if err != nil {
@@ -22,36 +23,29 @@ func TellPlan(prompt string, tellBg, tellStep bool) {
return
}
- promptingTrialExceeded := false
+ log.Println("tellNoBuild:", tellNoBuild)
+
var fn func() bool
fn = func() bool {
- if !tellBg {
- go func() {
- err := streamtui.StartStreamUI()
- if err != nil {
- fmt.Fprintln(os.Stderr, "Error starting stream UI:", err)
- os.Exit(1)
- }
-
- if !promptingTrialExceeded {
- os.Exit(0)
- }
- }()
+ var buildMode shared.BuildMode
+ if tellNoBuild {
+ buildMode = shared.BuildModeNone
+ } else {
+ buildMode = shared.BuildModeAuto
}
apiErr := api.Client.TellPlan(lib.CurrentPlanId, lib.CurrentBranch, shared.TellPlanRequest{
Prompt: prompt,
ConnectStream: !tellBg,
- AutoContinue: !tellStep,
+ AutoContinue: !tellStop,
ProjectPaths: projectPaths,
+ BuildMode: buildMode,
ApiKey: os.Getenv("OPENAI_API_KEY"),
}, stream.OnStreamPlan)
if apiErr != nil {
if apiErr.Type == shared.ApiErrorTypeTrialMessagesExceeded {
- promptingTrialExceeded = true
streamtui.Quit()
- promptingTrialExceeded = false
fmt.Fprintf(os.Stderr, "\n🚨 You've reached the free trial limit of %d messages per plan\n", apiErr.TrialMessagesExceededError.MaxReplies)
@@ -78,6 +72,28 @@ func TellPlan(prompt string, tellBg, tellStep bool) {
return false
}
+ if !tellBg {
+ go func() {
+ err := streamtui.StartStreamUI(prompt, false)
+
+ if err != nil {
+ log.Printf("Error starting stream UI: %v\n", err)
+ os.Exit(1)
+ }
+
+ fmt.Println()
+
+ if tellStop {
+ term.PrintCmds("", "continue", "convo", "changes", "log", "rewind")
+ } else if tellNoBuild {
+ term.PrintCmds("", "build", "convo", "log", "rewind")
+ } else {
+ term.PrintCmds("", "changes", "log", "rewind")
+ }
+ os.Exit(0)
+ }()
+ }
+
return true
}
diff --git a/app/cli/term/format.go b/app/cli/term/format.go
new file mode 100644
index 00000000..89bd17ea
--- /dev/null
+++ b/app/cli/term/format.go
@@ -0,0 +1,57 @@
+package term
+
+import (
+ "os"
+ "strings"
+
+ "github.com/charmbracelet/glamour"
+ "github.com/charmbracelet/glow/utils"
+ "github.com/muesli/reflow/wordwrap"
+ "github.com/muesli/termenv"
+ "golang.org/x/term"
+)
+
+func GetMarkdown(input string) (string, error) {
+ width, _, err := term.GetSize(int(os.Stdin.Fd()))
+ if err != nil {
+ return "", err
+ }
+
+ inputBytes := utils.RemoveFrontmatter([]byte(input))
+
+ r, _ := glamour.NewTermRenderer(
+ // detect background color and pick either the default dark or light theme
+ glamour.WithAutoStyle(),
+ glamour.WithWordWrap(min(width, 80)),
+ )
+
+ out, err := r.RenderBytes(inputBytes)
+ if err != nil {
+ return "", err
+ }
+
+ return string(out), nil
+}
+
+func GetPlain(input string) (string, error) {
+ width, _, err := term.GetSize(int(os.Stdin.Fd()))
+ if err != nil {
+ return "", err
+ }
+
+ s := wordwrap.String(input, min(width-2, 80))
+
+ // add padding
+ lines := strings.Split(s, "\n")
+ for i := range lines {
+ lines[i] = " " + lines[i]
+ }
+ s = strings.Join(lines, "\n")
+
+ c := "234"
+ if termenv.HasDarkBackground() {
+ c = "251"
+ }
+
+ return termenv.String(s).Foreground(termenv.ANSI256.Color(c)).String(), nil
+}
diff --git a/app/cli/term/glow.go b/app/cli/term/glow.go
deleted file mode 100644
index 76c18be2..00000000
--- a/app/cli/term/glow.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package term
-
-import (
- "github.com/charmbracelet/glamour"
- "github.com/charmbracelet/glow/utils"
-)
-
-func GetMarkdown(input string) (string, error) {
- // Default values
- style := "dark"
-
- // Removing potential frontmatter
- inputBytes := utils.RemoveFrontmatter([]byte(input))
-
- // Render
- out, err := glamour.RenderBytes(inputBytes, style)
- if err != nil {
- return "", err
- }
-
- return string(out), nil
-}
diff --git a/app/cli/term/term.go b/app/cli/term/term.go
index b7dbc8a7..f0ec2c3e 100644
--- a/app/cli/term/term.go
+++ b/app/cli/term/term.go
@@ -20,12 +20,13 @@ var CmdDesc = map[string][2]string{
"cd": {"", "set current plan by name or index"},
"load": {"l", "load files, dirs, urls, notes or piped data into context"},
"tell": {"t", "describe a task, ask a question, or chat"},
+ "changes": {"ch", "show plan changes"},
// "diffs": {"d", "show diffs between plan and project files"},
// "preview": {"pv", "preview the plan in a branch"},
- "apply": {"ap", "apply the plan to your project files"},
- "continue": {"c", "continue the plan"},
- "status": {"s", "show status of the plan"},
- "rewind": {"rw", "rewind to a previous step or state"},
+ "apply": {"ap", "apply the plan to your project files"},
+ "continue": {"c", "continue the plan"},
+ // "status": {"s", "show status of the plan"},
+ "rewind": {"rw", "rewind to a previous state"},
"ls": {"", "list everything in context"},
"rm": {"", "remove context by name, index, or glob"},
"clear": {"", "remove all context"},
@@ -33,6 +34,7 @@ var CmdDesc = map[string][2]string{
"plans": {"pl", "list plans"},
"update": {"u", "update outdated context"},
"log": {"", "show log of plan updates"},
+ "convo": {"", "show plan conversation"},
"branches": {"br", "list plan branches"},
// "checkout": {"co", "checkout or create a branch"}, need to implement non-contiguous aliases
}
diff --git a/app/cli/types/api.go b/app/cli/types/api.go
index c267561d..a1e059e8 100644
--- a/app/cli/types/api.go
+++ b/app/cli/types/api.go
@@ -50,6 +50,7 @@ type ApiClient interface {
CreatePlan(projectId string, req shared.CreatePlanRequest) (*shared.CreatePlanResponse, *shared.ApiError)
TellPlan(planId, branch string, req shared.TellPlanRequest, onStreamPlan OnStreamPlan) *shared.ApiError
+ BuildPlan(planId, branch string, req shared.BuildPlanRequest, onStreamPlan OnStreamPlan) *shared.ApiError
RespondMissingFile(planId, branch string, req shared.RespondMissingFileRequest) *shared.ApiError
DeletePlan(planId string) *shared.ApiError
diff --git a/app/server/db/build_helpers.go b/app/server/db/build_helpers.go
index e5f35619..25990698 100644
--- a/app/server/db/build_helpers.go
+++ b/app/server/db/build_helpers.go
@@ -14,7 +14,6 @@ func StorePlanBuild(build *PlanBuild) error {
query := `INSERT INTO plan_builds (org_id, plan_id, convo_message_ids, file_path) VALUES (:org_id, :plan_id, :convo_message_ids, :file_path) RETURNING id, created_at, updated_at`
- // Wrap the ConvoMessageIds slice with pq.Array
args := map[string]interface{}{
"org_id": build.OrgId,
"plan_id": build.PlanId,
diff --git a/app/server/db/convo_helpers.go b/app/server/db/convo_helpers.go
index 391aa126..c9983d67 100644
--- a/app/server/db/convo_helpers.go
+++ b/app/server/db/convo_helpers.go
@@ -8,6 +8,7 @@ import (
"sort"
"time"
+ "github.com/fatih/color"
"github.com/google/uuid"
"github.com/sashabaranov/go-openai"
)
@@ -108,7 +109,7 @@ func StoreConvoMessage(message *ConvoMessage, currentUserId, branch string, comm
} else {
desc = "🤖 Plandex reply"
if message.Stopped {
- desc += " | 🛑 stopped early"
+ desc += " | 🛑 " + color.New(color.FgHiRed).Sprint("stopped")
}
}
diff --git a/app/server/db/git.go b/app/server/db/git.go
index fd4a08a3..b870fe34 100644
--- a/app/server/db/git.go
+++ b/app/server/db/git.go
@@ -48,30 +48,30 @@ func GitAddAndCommit(orgId, planId, branch, message string) error {
return nil
}
-func GitAddAndAmendCommit(orgId, planId, branch, addMessage string) error {
- dir := getPlanDir(orgId, planId)
-
- err := gitAdd(dir, ".")
- if err != nil {
- return fmt.Errorf("error adding files to git repository for dir: %s, err: %v", dir, err)
- }
-
- // Get the latest commit message
- _, latestCommitMsg, err := getLatestCommit(dir)
- if err != nil {
- return fmt.Errorf("error getting latest commit message for dir: %s, err: %v", dir, err)
- }
-
- // Amend the latest commit with the new message
- message := latestCommitMsg + "\n\n" + addMessage
- res, err := exec.Command("git", "-C", dir, "commit", "--amend", "-m", message).CombinedOutput()
-
- if err != nil {
- return fmt.Errorf("error amending commit for dir: %s, err: %v, output: %s", dir, err, string(res))
- }
-
- return nil
-}
+// func GitAddAndAmendCommit(orgId, planId, branch, addMessage string) error {
+// dir := getPlanDir(orgId, planId)
+
+// err := gitAdd(dir, ".")
+// if err != nil {
+// return fmt.Errorf("error adding files to git repository for dir: %s, err: %v", dir, err)
+// }
+
+// // Get the latest commit message
+// _, latestCommitMsg, err := getLatestCommit(dir)
+// if err != nil {
+// return fmt.Errorf("error getting latest commit message for dir: %s, err: %v", dir, err)
+// }
+
+// // Amend the latest commit with the new message
+// message := latestCommitMsg + "\n\n" + addMessage
+// res, err := exec.Command("git", "-C", dir, "commit", "--amend", "-m", message).CombinedOutput()
+
+// if err != nil {
+// return fmt.Errorf("error amending commit for dir: %s, err: %v, output: %s", dir, err, string(res))
+// }
+
+// return nil
+// }
func GitRewindToSha(orgId, planId, branch, sha string) error {
dir := getPlanDir(orgId, planId)
diff --git a/app/server/db/locks.go b/app/server/db/locks.go
index bff5fbc8..7d6185ef 100644
--- a/app/server/db/locks.go
+++ b/app/server/db/locks.go
@@ -211,7 +211,7 @@ func lockRepo(params LockRepoParams, numRetry int) (string, error) {
for {
select {
case <-ctx.Done():
- log.Printf("case <-stream.Ctx.Done(): %s\n", newLock.Id)
+ // log.Printf("case <-stream.Ctx.Done(): %s\n", newLock.Id)
err := UnlockRepo(newLock.Id)
if err != nil {
log.Printf("Error unlocking repo: %v\n", err)
diff --git a/app/server/db/models.go b/app/server/db/models.go
index eb4f4db8..58c9bba0 100644
--- a/app/server/db/models.go
+++ b/app/server/db/models.go
@@ -362,6 +362,7 @@ type ConvoMessageDescription struct {
CommitMsg string `json:"commitMsg"`
Files []string `json:"files"`
Error string `json:"error"`
+ DidBuild bool `json:"didBuild"`
AppliedAt *time.Time `json:"appliedAt,omitempty"`
CreatedAt time.Time `json:"createdAt"`
UpdatedAt time.Time `json:"updatedAt"`
@@ -375,6 +376,7 @@ func (desc *ConvoMessageDescription) ToApi() *shared.ConvoMessageDescription {
MadePlan: desc.MadePlan,
CommitMsg: desc.CommitMsg,
Files: desc.Files,
+ DidBuild: desc.DidBuild,
Error: desc.Error,
CreatedAt: desc.CreatedAt,
UpdatedAt: desc.UpdatedAt,
diff --git a/app/server/db/result_helpers.go b/app/server/db/result_helpers.go
index 94c46025..2ca7301e 100644
--- a/app/server/db/result_helpers.go
+++ b/app/server/db/result_helpers.go
@@ -191,6 +191,10 @@ func GetPlanFileResults(orgId, planId string) ([]*PlanFileResult, error) {
files, err := os.ReadDir(resultsDir)
if err != nil {
+ if os.IsNotExist(err) {
+ return results, nil
+ }
+
return nil, fmt.Errorf("error reading results dir: %v", err)
}
@@ -391,6 +395,10 @@ func RejectAllResults(orgId, planId string) error {
files, err := os.ReadDir(resultsDir)
if err != nil {
+ if os.IsNotExist(err) {
+ return nil
+ }
+
return fmt.Errorf("error reading results dir: %v", err)
}
diff --git a/app/server/db/stream_helpers.go b/app/server/db/stream_helpers.go
index 1fc07ac1..35ef0a21 100644
--- a/app/server/db/stream_helpers.go
+++ b/app/server/db/stream_helpers.go
@@ -39,7 +39,7 @@ func StoreModelStream(stream *ModelStream, ctx context.Context, cancelFn context
for {
select {
case <-ctx.Done():
- log.Printf("case <-stream.Ctx.Done(): %s\n", stream.Id)
+ // log.Printf("case <-stream.Ctx.Done(): %s\n", stream.Id)
err := SetModelStreamFinished(stream.Id)
if err != nil {
log.Printf("Error setting model stream %s finished: %v\n", stream.Id, err)
@@ -105,6 +105,8 @@ func GetActiveModelStream(planId, branch string) (*ModelStream, error) {
}
return nil, nil
+ } else {
+ log.Printf("Model stream %s sent heartbeat %d seconds ago\n", stream.Id, int(time.Since(stream.LastHeartbeatAt).Seconds()))
}
return &stream, nil
diff --git a/app/server/handlers/branches.go b/app/server/handlers/branches.go
index 72422ccc..5611680c 100644
--- a/app/server/handlers/branches.go
+++ b/app/server/handlers/branches.go
@@ -1,6 +1,7 @@
package handlers
import (
+ "context"
"encoding/json"
"io"
"log"
@@ -30,7 +31,8 @@ func ListBranchesHandler(w http.ResponseWriter, r *http.Request) {
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeRead)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeRead, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -103,7 +105,8 @@ func CreateBranchHandler(w http.ResponseWriter, r *http.Request) {
return
}
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -170,13 +173,16 @@ func DeleteBranchHandler(w http.ResponseWriter, r *http.Request) {
return
}
+ ctx, cancel := context.WithCancel(context.Background())
repoLockId, err := db.LockRepo(
db.LockRepoParams{
- OrgId: auth.OrgId,
- UserId: auth.User.Id,
- PlanId: planId,
- Branch: "main",
- Scope: db.LockScopeRead,
+ OrgId: auth.OrgId,
+ UserId: auth.User.Id,
+ PlanId: planId,
+ Branch: "main",
+ Scope: db.LockScopeRead,
+ Ctx: ctx,
+ CancelFn: cancel,
},
)
diff --git a/app/server/handlers/context_helper.go b/app/server/handlers/context_helper.go
index a2cb0f29..1247bbde 100644
--- a/app/server/handlers/context_helper.go
+++ b/app/server/handlers/context_helper.go
@@ -1,6 +1,7 @@
package handlers
import (
+ "context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
@@ -65,7 +66,8 @@ func loadContexts(w http.ResponseWriter, r *http.Request, auth *types.ServerAuth
return nil, nil
}
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return nil, nil
} else {
diff --git a/app/server/handlers/fs_helper.go b/app/server/handlers/fs_helper.go
index 5660a717..88e477a8 100644
--- a/app/server/handlers/fs_helper.go
+++ b/app/server/handlers/fs_helper.go
@@ -1,6 +1,7 @@
package handlers
import (
+ "context"
"fmt"
"log"
"net/http"
@@ -10,18 +11,20 @@ import (
"github.com/gorilla/mux"
)
-func lockRepo(w http.ResponseWriter, r *http.Request, auth *types.ServerAuth, scope db.LockScope) *func(err error) {
+func lockRepo(w http.ResponseWriter, r *http.Request, auth *types.ServerAuth, scope db.LockScope, ctx context.Context, cancelFn context.CancelFunc) *func(err error) {
vars := mux.Vars(r)
planId := vars["planId"]
branch := vars["branch"]
repoLockId, err := db.LockRepo(
db.LockRepoParams{
- OrgId: auth.OrgId,
- UserId: auth.User.Id,
- PlanId: planId,
- Branch: branch,
- Scope: scope,
+ OrgId: auth.OrgId,
+ UserId: auth.User.Id,
+ PlanId: planId,
+ Branch: branch,
+ Scope: scope,
+ Ctx: ctx,
+ CancelFn: cancelFn,
},
)
diff --git a/app/server/handlers/plans_changes.go b/app/server/handlers/plans_changes.go
index b3d6a6f1..bfc80397 100644
--- a/app/server/handlers/plans_changes.go
+++ b/app/server/handlers/plans_changes.go
@@ -1,6 +1,7 @@
package handlers
import (
+ "context"
"encoding/json"
"log"
"net/http"
@@ -29,7 +30,8 @@ func CurrentPlanHandler(w http.ResponseWriter, r *http.Request) {
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeRead)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeRead, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -78,7 +80,8 @@ func ApplyPlanHandler(w http.ResponseWriter, r *http.Request) {
}
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -113,7 +116,8 @@ func RejectAllChangesHandler(w http.ResponseWriter, r *http.Request) {
}
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -150,7 +154,8 @@ func RejectResultHandler(w http.ResponseWriter, r *http.Request) {
}
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -188,7 +193,8 @@ func RejectReplacementHandler(w http.ResponseWriter, r *http.Request) {
}
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return
} else {
diff --git a/app/server/handlers/plans_context.go b/app/server/handlers/plans_context.go
index 427d788a..5f89fddd 100644
--- a/app/server/handlers/plans_context.go
+++ b/app/server/handlers/plans_context.go
@@ -1,6 +1,7 @@
package handlers
import (
+ "context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
@@ -32,7 +33,8 @@ func ListContextHandler(w http.ResponseWriter, r *http.Request) {
}
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeRead)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeRead, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -243,7 +245,8 @@ func UpdateContextHandler(w http.ResponseWriter, r *http.Request) {
return
}
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -358,7 +361,8 @@ func DeleteContextHandler(w http.ResponseWriter, r *http.Request) {
return
}
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return
} else {
diff --git a/app/server/handlers/plans_convo.go b/app/server/handlers/plans_convo.go
index 9fe43c47..68b51c0a 100644
--- a/app/server/handlers/plans_convo.go
+++ b/app/server/handlers/plans_convo.go
@@ -1,6 +1,7 @@
package handlers
import (
+ "context"
"encoding/json"
"log"
"net/http"
@@ -26,7 +27,8 @@ func ListConvoHandler(w http.ResponseWriter, r *http.Request) {
}
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeRead)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeRead, ctx, cancel)
if unlockFn == nil {
return
} else {
diff --git a/app/server/handlers/plans_exec.go b/app/server/handlers/plans_exec.go
index ab61fd5f..cae7618e 100644
--- a/app/server/handlers/plans_exec.go
+++ b/app/server/handlers/plans_exec.go
@@ -1,6 +1,7 @@
package handlers
import (
+ "context"
"encoding/json"
"io"
"log"
@@ -31,18 +32,11 @@ func TellPlanHandler(w http.ResponseWriter, r *http.Request) {
log.Println("planId: ", planId)
- plan := authorizePlanUpdate(w, planId, auth)
-
+ plan := authorizePlanExecUpdate(w, planId, auth)
if plan == nil {
return
}
- if plan.OwnerId != auth.User.Id && !auth.HasPermission(types.PermissionUpdateAnyPlan) {
- log.Println("User does not have permission to update plan")
- http.Error(w, "User does not have permission to update plan", http.StatusForbidden)
- return
- }
-
body, err := io.ReadAll(r.Body)
if err != nil {
log.Printf("Error reading request body: %v\n", err)
@@ -118,13 +112,62 @@ func BuildPlanHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
planId := vars["planId"]
+ branch := vars["branch"]
log.Println("planId: ", planId)
+ plan := authorizePlanExecUpdate(w, planId, auth)
+ if plan == nil {
+ return
+ }
- if authorizePlan(w, planId, auth) == nil {
+ body, err := io.ReadAll(r.Body)
+ if err != nil {
+ log.Printf("Error reading request body: %v\n", err)
+ http.Error(w, "Error reading request body", http.StatusInternalServerError)
return
}
+ defer func() {
+ log.Println("Closing request body")
+ r.Body.Close()
+ }()
+ var requestBody shared.BuildPlanRequest
+ if err := json.Unmarshal(body, &requestBody); err != nil {
+ log.Printf("Error parsing request body: %v\n", err)
+ http.Error(w, "Error parsing request body", http.StatusBadRequest)
+ return
+ }
+
+ if requestBody.ApiKey == "" {
+ log.Println("API key is required")
+ http.Error(w, "API key is required", http.StatusBadRequest)
+ return
+ }
+
+ client := model.NewClient(requestBody.ApiKey)
+ numBuilds, err := modelPlan.Build(client, plan, branch, auth)
+
+ if err != nil {
+ log.Printf("Error building plan: %v\n", err)
+ http.Error(w, "Error building plan", http.StatusInternalServerError)
+ return
+ }
+
+ if numBuilds == 0 {
+ log.Println("No builds were executed")
+ http.Error(w, shared.NoBuildsErr, http.StatusNotFound)
+ return
+ }
+
+ if requestBody.ConnectStream {
+ active := modelPlan.GetActivePlan(planId, branch)
+ subscriptionId, ch := modelPlan.SubscribePlan(planId, branch)
+ startResponseStream(w, ch, active, func() {
+ modelPlan.UnsubscribePlan(planId, branch, subscriptionId)
+ })
+ }
+
+ log.Println("Successfully processed request for BuildPlanHandler")
}
func ConnectPlanHandler(w http.ResponseWriter, r *http.Request) {
@@ -170,7 +213,8 @@ func StopPlanHandler(w http.ResponseWriter, r *http.Request) {
}
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -257,3 +301,18 @@ func RespondMissingFileHandler(w http.ResponseWriter, r *http.Request) {
log.Println("Successfully processed request for RespondMissingFileHandler")
}
+
+func authorizePlanExecUpdate(w http.ResponseWriter, planId string, auth *types.ServerAuth) *db.Plan {
+ plan := authorizePlan(w, planId, auth)
+ if plan == nil {
+ return nil
+ }
+
+ if plan.OwnerId != auth.User.Id && !auth.HasPermission(types.PermissionUpdateAnyPlan) {
+ log.Println("User does not have permission to update plan")
+ http.Error(w, "User does not have permission to update plan", http.StatusForbidden)
+ return nil
+ }
+
+ return plan
+}
diff --git a/app/server/handlers/plans_versions.go b/app/server/handlers/plans_versions.go
index 5cfb0338..23d7ae3f 100644
--- a/app/server/handlers/plans_versions.go
+++ b/app/server/handlers/plans_versions.go
@@ -1,6 +1,7 @@
package handlers
import (
+ "context"
"encoding/json"
"io"
"log"
@@ -30,7 +31,8 @@ func ListLogsHandler(w http.ResponseWriter, r *http.Request) {
}
var err error
- unlockFn := lockRepo(w, r, auth, db.LockScopeRead)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeRead, ctx, cancel)
if unlockFn == nil {
return
} else {
@@ -97,7 +99,8 @@ func RewindPlanHandler(w http.ResponseWriter, r *http.Request) {
return
}
- unlockFn := lockRepo(w, r, auth, db.LockScopeWrite)
+ ctx, cancel := context.WithCancel(context.Background())
+ unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)
if unlockFn == nil {
return
} else {
diff --git a/app/server/model/plan/activate.go b/app/server/model/plan/activate.go
new file mode 100644
index 00000000..44ab6343
--- /dev/null
+++ b/app/server/model/plan/activate.go
@@ -0,0 +1,57 @@
+package plan
+
+import (
+ "fmt"
+ "log"
+ "plandex-server/db"
+ "plandex-server/host"
+ "plandex-server/types"
+
+ "github.com/plandex/plandex/shared"
+ "github.com/sashabaranov/go-openai"
+)
+
+func activatePlan(client *openai.Client, plan *db.Plan, branch string, auth *types.ServerAuth, prompt string, buildOnly bool) (*types.ActivePlan, error) {
+ active := GetActivePlan(plan.Id, branch)
+ if active != nil {
+ log.Printf("Tell: Active plan found for plan ID %s on branch %s\n", plan.Id, branch) // Log if an active plan is found
+ return nil, fmt.Errorf("plan %s branch %s already has an active stream on this host", plan.Id, branch)
+ }
+
+ modelStream, err := db.GetActiveModelStream(plan.Id, branch)
+ if err != nil {
+ log.Printf("Error getting active model stream: %v\n", err)
+ return nil, fmt.Errorf("error getting active model stream: %v", err)
+ }
+
+ if modelStream != nil {
+ log.Printf("Tell: Active model stream found for plan ID %s on branch %s on host %s\n", plan.Id, branch, modelStream.InternalIp) // Log if an active model stream is found
+ return nil, fmt.Errorf("plan %s branch %s already has an active stream on host %s", plan.Id, branch, modelStream.InternalIp)
+ }
+
+ active = CreateActivePlan(plan.Id, branch, prompt, buildOnly)
+
+ modelStream = &db.ModelStream{
+ OrgId: auth.OrgId,
+ PlanId: plan.Id,
+ InternalIp: host.Ip,
+ Branch: branch,
+ }
+ err = db.StoreModelStream(modelStream, active.ModelStreamCtx, active.CancelModelStreamFn)
+ if err != nil {
+ log.Printf("Tell: Error storing model stream for plan ID %s on branch %s: %v\n", plan.Id, branch, err) // Log error storing model stream
+ log.Printf("Error storing model stream: %v\n", err)
+ log.Printf("Tell: Error storing model stream: %v\n", err) // Log error storing model stream
+
+ active.StreamDoneCh <- &shared.ApiError{Msg: fmt.Sprintf("Error storing model stream: %v", err)}
+
+ return nil, fmt.Errorf("error storing model stream: %v", err)
+ }
+
+ active.ModelStreamId = modelStream.Id
+
+ log.Printf("Tell: Model stream stored with ID %s for plan ID %s on branch %s\n", modelStream.Id, plan.Id, branch) // Log successful storage of model stream
+ log.Println("Model stream id:", modelStream.Id)
+
+ return active, nil
+}
diff --git a/app/server/model/plan/build.go b/app/server/model/plan/build.go
index 2c31edb2..45208654 100644
--- a/app/server/model/plan/build.go
+++ b/app/server/model/plan/build.go
@@ -24,27 +24,145 @@ import (
const MaxRetries = 3
const MaxReplacementRetries = 1
-func QueueBuild(client *openai.Client, currentOrgId, currentUserId, planId, branch string, activeBuild *types.ActiveBuild) {
+func Build(client *openai.Client, plan *db.Plan, branch string, auth *types.ServerAuth) (int, error) {
+ log.Printf("Build: Called with plan ID %s on branch %s\n", plan.Id, branch)
+ log.Println("Build: Starting Build operation")
+
+ active, err := activatePlan(client, plan, branch, auth, "", true)
+
+ if err != nil {
+ log.Printf("Error activating plan: %v\n", err)
+ return 0, err
+ }
+
+ onErr := func(err error) (int, error) {
+ log.Printf("Build error: %v\n", err)
+ active.StreamDoneCh <- nil
+ return 0, err
+ }
+
+ repoLockId, err := db.LockRepo(
+ db.LockRepoParams{
+ OrgId: auth.OrgId,
+ UserId: auth.User.Id,
+ PlanId: plan.Id,
+ Branch: branch,
+ Scope: db.LockScopeRead,
+ Ctx: active.Ctx,
+ CancelFn: active.CancelFn,
+ },
+ )
+ if err != nil {
+ return onErr(fmt.Errorf("error locking repo for build: %v", err))
+ }
+
+ var modelContext []*db.Context
+ var pendingBuildsByPath map[string][]*types.ActiveBuild
+
+ err = func() error {
+ defer func() {
+ err := db.UnlockRepo(repoLockId)
+ if err != nil {
+ log.Printf("Error unlocking repo: %v\n", err)
+ }
+ }()
+
+ errCh := make(chan error)
+
+ go func() {
+ res, err := db.GetPlanContexts(auth.OrgId, plan.Id, true)
+ if err != nil {
+ log.Printf("Error getting plan modelContext: %v\n", err)
+ errCh <- fmt.Errorf("error getting plan modelContext: %v", err)
+ return
+ }
+ modelContext = res
+
+ errCh <- nil
+ }()
+
+ go func() {
+ res, err := active.PendingBuildsByPath(auth.OrgId, auth.User.Id, nil)
+
+ if err != nil {
+ log.Printf("Error getting pending builds by path: %v\n", err)
+ errCh <- fmt.Errorf("error getting pending builds by path: %v", err)
+ return
+ }
+
+ pendingBuildsByPath = res
+
+ errCh <- nil
+ }()
+
+ for i := 0; i < 2; i++ {
+ err = <-errCh
+ if err != nil {
+ log.Printf("Error getting plan data: %v\n", err)
+ return err
+ }
+ }
+ return nil
+ }()
+
+ if err != nil {
+ return onErr(err)
+ }
+
+ UpdateActivePlan(plan.Id, branch, func(ap *types.ActivePlan) {
+ ap.Contexts = modelContext
+ for _, context := range modelContext {
+ if context.FilePath != "" {
+ ap.ContextsByPath[context.FilePath] = context
+ }
+ }
+ })
+
+ if len(pendingBuildsByPath) == 0 {
+ log.Println("No pending builds")
+ active.StreamDoneCh <- nil
+ return 0, nil
+ }
+
+ err = db.SetPlanStatus(plan.Id, branch, shared.PlanStatusBuilding, "")
+
+ if err != nil {
+ log.Printf("Error setting plan status to building: %v\n", err)
+ return onErr(fmt.Errorf("error setting plan status to building: %v", err))
+ }
+
+ log.Printf("Starting %d builds\n", len(pendingBuildsByPath))
+
+ for _, pendingBuilds := range pendingBuildsByPath {
+ go execPlanBuild(client, auth.OrgId, auth.User.Id, branch, active, pendingBuilds)
+ }
+
+ return len(pendingBuildsByPath), nil
+}
+
+func queueBuilds(client *openai.Client, currentOrgId, currentUserId, planId, branch string, activeBuilds []*types.ActiveBuild) {
activePlan := GetActivePlan(planId, branch)
- filePath := activeBuild.Path
+ filePath := activeBuilds[0].Path
UpdateActivePlan(planId, branch, func(active *types.ActivePlan) {
- active.BuildQueuesByPath[filePath] = append(active.BuildQueuesByPath[filePath], activeBuild)
+ active.BuildQueuesByPath[filePath] = append(active.BuildQueuesByPath[filePath], activeBuilds...)
})
- log.Printf("Queued build for file %s\n", filePath)
- log.Printf("Queue:")
- spew.Dump(activePlan.BuildQueuesByPath[filePath])
+ log.Printf("Queued %d build(s) for file %s\n", len(activeBuilds), filePath)
+ // log.Printf("Queue:")
+ // spew.Dump(activePlan.BuildQueuesByPath[filePath])
if activePlan.IsBuildingByPath[filePath] {
log.Printf("Already building file %s\n", filePath)
return
} else {
log.Printf("Will process build queue for file %s\n", filePath)
- go execPlanBuild(client, currentOrgId, currentUserId, branch, activePlan, []*types.ActiveBuild{activeBuild})
+ go execPlanBuild(client, currentOrgId, currentUserId, branch, activePlan, activeBuilds)
}
}
func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch string, activePlan *types.ActivePlan, activeBuilds []*types.ActiveBuild) {
+ log.Printf("execPlanBuild for %d active builds\n", len(activeBuilds))
+
if len(activeBuilds) == 0 {
log.Println("No active builds")
return
@@ -57,9 +175,9 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
added := map[string]bool{}
for _, activeBuild := range activeBuilds {
- if !added[activeBuild.AssistantMessageId] {
- convoMessageIds = append(convoMessageIds, activeBuild.AssistantMessageId)
- added[activeBuild.AssistantMessageId] = true
+ if !added[activeBuild.ReplyId] {
+ convoMessageIds = append(convoMessageIds, activeBuild.ReplyId)
+ added[activeBuild.ReplyId] = true
}
}
@@ -77,90 +195,226 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
BuildInfo: buildInfo,
})
- errCh := make(chan error)
-
- var build *db.PlanBuild
- var currentPlan *shared.CurrentPlanState
+ build := &db.PlanBuild{
+ OrgId: currentOrgId,
+ PlanId: planId,
+ ConvoMessageIds: convoMessageIds,
+ FilePath: filePath,
+ }
+ err := db.StorePlanBuild(build)
- go func() {
- build = &db.PlanBuild{
- OrgId: currentOrgId,
- PlanId: planId,
- ConvoMessageIds: convoMessageIds,
- FilePath: filePath,
+ if err != nil {
+ log.Printf("Error storing plan build: %v\n", err)
+ UpdateActivePlan(activePlan.Id, activePlan.Branch, func(ap *types.ActivePlan) {
+ ap.IsBuildingByPath[filePath] = false
+ })
+ activePlan.StreamDoneCh <- &shared.ApiError{
+ Type: shared.ApiErrorTypeOther,
+ Status: http.StatusInternalServerError,
+ Msg: "Error storing plan build: " + err.Error(),
}
- err := db.StorePlanBuild(build)
+ return
+ }
- if err != nil {
- errCh <- fmt.Errorf("error storing plan build: %v", err)
- return
+ var currentPlan *shared.CurrentPlanState
+
+ repoLockId, err := db.LockRepo(
+ db.LockRepoParams{
+ OrgId: currentOrgId,
+ UserId: currentUserId,
+ PlanId: planId,
+ Branch: branch,
+ PlanBuildId: build.Id,
+ Scope: db.LockScopeRead,
+ Ctx: activePlan.Ctx,
+ CancelFn: activePlan.CancelFn,
+ },
+ )
+ if err != nil {
+ log.Printf("Error locking repo for build file: %v\n", err)
+ UpdateActivePlan(activePlan.Id, activePlan.Branch, func(ap *types.ActivePlan) {
+ ap.IsBuildingByPath[filePath] = false
+ })
+ activePlan.StreamDoneCh <- &shared.ApiError{
+ Type: shared.ApiErrorTypeOther,
+ Status: http.StatusInternalServerError,
+ Msg: "Error locking repo for build file: " + err.Error(),
}
+ return
+ }
- errCh <- nil
- }()
+ func() {
+ defer func() {
+ err := db.UnlockRepo(repoLockId)
+ if err != nil {
+ log.Printf("Error unlocking repo: %v\n", err)
+ }
+ }()
- go func() {
res, err := db.GetCurrentPlanState(db.CurrentPlanStateParams{
OrgId: currentOrgId,
PlanId: planId,
})
if err != nil {
- errCh <- fmt.Errorf("error getting current plan state: %v", err)
- return
- }
- currentPlan = res
- errCh <- nil
- }()
-
- for i := 0; i < 2; i++ {
- err := <-errCh
- if err != nil {
- log.Printf("Error building plan %s: %v\n", planId, err)
+ log.Printf("Error getting current plan state: %v\n", err)
UpdateActivePlan(activePlan.Id, activePlan.Branch, func(ap *types.ActivePlan) {
ap.IsBuildingByPath[filePath] = false
})
activePlan.StreamDoneCh <- &shared.ApiError{
Type: shared.ApiErrorTypeOther,
Status: http.StatusInternalServerError,
- Msg: err.Error(),
+ Msg: "Error getting current plan state: " + err.Error(),
}
return
}
- }
+ currentPlan = res
+
+ log.Println("Got current plan state")
+ spew.Dump(currentPlan)
+ }()
+
+ errCh := make(chan error)
onFinishBuild := func() {
log.Println("Build finished")
- // get fresh current plan state
- currentPlan, err := db.GetCurrentPlanState(db.CurrentPlanStateParams{
- OrgId: currentOrgId,
- PlanId: planId,
- })
- if err != nil {
- errCh <- fmt.Errorf("error getting current plan state: %v", err)
- return
+ // first check if any of the messages we're building hasen't finished streaming yet
+ stillStreaming := false
+ var doneCh chan bool
+ for _, convoMessageId := range convoMessageIds {
+ ap := GetActivePlan(planId, branch)
+ if ap.CurrentStreamingReplyId == convoMessageId {
+ stillStreaming = true
+ doneCh = ap.CurrentReplyDoneCh
+ break
+ }
+ }
+ if stillStreaming {
+ log.Println("Reply is still streaming, waiting for it to finish before finishing build")
+ <-doneCh
}
- err = db.GitAddAndAmendCommit(currentOrgId, planId, branch, currentPlan.PendingChangesSummary())
+ repoLockId, err := db.LockRepo(
+ db.LockRepoParams{
+ OrgId: currentOrgId,
+ UserId: currentUserId,
+ PlanId: planId,
+ Branch: branch,
+ PlanBuildId: build.Id,
+ Scope: db.LockScopeWrite,
+ Ctx: activePlan.Ctx,
+ CancelFn: activePlan.CancelFn,
+ },
+ )
if err != nil {
- log.Printf("Error committing plan build: %v\n", err)
+ log.Printf("Error locking repo for finished build: %v\n", err)
activePlan.StreamDoneCh <- &shared.ApiError{
Type: shared.ApiErrorTypeOther,
Status: http.StatusInternalServerError,
- Msg: "Error committing plan build: " + err.Error(),
+ Msg: "Error locking repo for finished build: " + err.Error(),
+ }
+ return
+ }
+
+ log.Println("Locked repo for finished build")
+
+ err = func() error {
+ var err error
+ defer func() {
+ if err != nil {
+ log.Printf("Finish build error: %v\n", err)
+ err = db.GitClearUncommittedChanges(currentOrgId, planId)
+ if err != nil {
+ log.Printf("Error clearing uncommitted changes: %v\n", err)
+ }
+ log.Println("Cleared uncommitted changes")
+ }
+
+ err := db.UnlockRepo(repoLockId)
+ if err != nil {
+ log.Printf("Error unlocking repo: %v\n", err)
+ }
+
+ log.Println("Unlocked repo")
+ }()
+
+ // get plan descriptions
+ planDescs, err := db.GetPendingBuildDescriptions(currentOrgId, planId)
+ if err != nil {
+ errCh <- fmt.Errorf("error getting pending build descriptions: %v", err)
+ return err
+ }
+
+ // get fresh current plan state
+ currentPlan, err := db.GetCurrentPlanState(db.CurrentPlanStateParams{
+ OrgId: currentOrgId,
+ PlanId: planId,
+ PendingBuildDescriptions: planDescs,
+ })
+ if err != nil {
+ errCh <- fmt.Errorf("error getting current plan state: %v", err)
+ return err
}
+
+ descErrCh := make(chan error)
+ for _, desc := range planDescs {
+ if len(desc.Files) > 0 {
+ desc.DidBuild = true
+ }
+
+ go func(desc *db.ConvoMessageDescription) {
+ err := db.StoreDescription(desc)
+
+ if err != nil {
+ descErrCh <- fmt.Errorf("error storing description: %v", err)
+ return
+ }
+
+ descErrCh <- nil
+ }(desc)
+ }
+
+ for range planDescs {
+ err = <-descErrCh
+ if err != nil {
+ errCh <- err
+ return err
+ }
+ }
+
+ err = db.GitAddAndCommit(currentOrgId, planId, branch, currentPlan.PendingChangesSummary())
+
+ if err != nil {
+ log.Printf("Error committing plan build: %v\n", err)
+ activePlan.StreamDoneCh <- &shared.ApiError{
+ Type: shared.ApiErrorTypeOther,
+ Status: http.StatusInternalServerError,
+ Msg: "Error committing plan build: " + err.Error(),
+ }
+ return err
+ }
+
+ log.Println("Plan build committed")
+
+ return nil
+
+ }()
+
+ if err != nil {
return
}
- if GetActivePlan(planId, branch).RepliesFinished {
+ active := GetActivePlan(planId, branch)
+
+ if active.RepliesFinished || active.BuildOnly {
activePlan.Stream(shared.StreamMessage{
Type: shared.StreamMessageFinished,
})
}
}
- onFinishBuildFile := func(filePath string, planRes *db.PlanFileResult) {
+ onFinishBuildFile := func(planRes *db.PlanFileResult) {
finished := false
log.Println("onFinishBuildFile: " + filePath)
@@ -172,6 +426,8 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
Branch: branch,
PlanBuildId: build.Id,
Scope: db.LockScopeWrite,
+ Ctx: activePlan.Ctx,
+ CancelFn: activePlan.CancelFn,
},
)
if err != nil {
@@ -260,7 +516,7 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
}
}
- onBuildFileError := func(filePath string, err error) {
+ onBuildFileError := func(err error) {
log.Printf("Error for file %s: %v\n", filePath, err)
for _, build := range activeBuilds {
@@ -333,7 +589,7 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
Path: filePath,
Content: activeBuilds[0].FileContent,
}
- onFinishBuildFile(filePath, planRes)
+ onFinishBuildFile(planRes)
return
}
@@ -375,13 +631,13 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
if numReplacementsRetry > 0 && res != nil {
bytes, err := json.Marshal(res.Replacements)
if err != nil {
- onBuildFileError(filePath, fmt.Errorf("error marshalling replacements: %v", err))
+ onBuildFileError(fmt.Errorf("error marshalling replacements: %v", err))
return
}
correctReplacementPrompt, err := prompts.GetCorrectReplacementPrompt(res.Replacements, currentState)
if err != nil {
- onBuildFileError(filePath, fmt.Errorf("error getting correct replacement prompt: %v", err))
+ onBuildFileError(fmt.Errorf("error getting correct replacement prompt: %v", err))
return
}
@@ -417,12 +673,12 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
log.Printf("Error creating plan file stream for path '%s': %v\n", filePath, err)
if numRetry >= MaxRetries {
- onBuildFileError(filePath, fmt.Errorf("failed to create plan file stream for path '%s' after %d retries: %v", filePath, numRetry, err))
+ onBuildFileError(fmt.Errorf("failed to create plan file stream for path '%s' after %d retries: %v", filePath, numRetry, err))
} else {
log.Println("Retrying build plan for file: " + filePath)
buildFile(filePath, numRetry+1, numReplacementsRetry, res)
if err != nil {
- onBuildFileError(filePath, fmt.Errorf("failed to retry build plan for file '%s': %v", filePath, err))
+ onBuildFileError(fmt.Errorf("failed to retry build plan for file '%s': %v", filePath, err))
}
}
return
@@ -444,7 +700,7 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
// in this case, we just want to ignore the error and continue
return true
} else if !isReplacementsRetry && numRetry >= MaxRetries {
- onBuildFileError(filePath, maxRetryErr)
+ onBuildFileError(maxRetryErr)
return false
} else {
if shouldSleep {
@@ -456,7 +712,7 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
buildFile(filePath, numRetry+1, numReplacementsRetry, res)
}
if err != nil {
- onBuildFileError(filePath, fmt.Errorf("failed to retry build plan for file '%s': %v", filePath, err))
+ onBuildFileError(fmt.Errorf("failed to retry build plan for file '%s': %v", filePath, err))
}
return false
}
@@ -583,8 +839,6 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
},
)
- // proposalId, filePath, currentState, contextPart, replacements.Replacements)
-
if !allSucceeded {
log.Println("Failed replacements:")
for _, replacement := range planFileResult.Replacements {
@@ -616,7 +870,7 @@ func execPlanBuild(client *openai.Client, currentOrgId, currentUserId, branch st
BuildInfo: buildInfo,
})
- onFinishBuildFile(filePath, planFileResult)
+ onFinishBuildFile(planFileResult)
return
}
}
diff --git a/app/server/model/plan/state.go b/app/server/model/plan/state.go
index 726dd1e4..697280ac 100644
--- a/app/server/model/plan/state.go
+++ b/app/server/model/plan/state.go
@@ -17,8 +17,8 @@ func GetActivePlan(planId, branch string) *types.ActivePlan {
return activePlans.Get(strings.Join([]string{planId, branch}, "|"))
}
-func CreateActivePlan(planId, branch, prompt string) *types.ActivePlan {
- activePlan := types.NewActivePlan(planId, branch, prompt)
+func CreateActivePlan(planId, branch, prompt string, buildOnly bool) *types.ActivePlan {
+ activePlan := types.NewActivePlan(planId, branch, prompt, buildOnly)
key := strings.Join([]string{planId, branch}, "|")
activePlans.Set(key, activePlan)
diff --git a/app/server/model/plan/stop.go b/app/server/model/plan/stop.go
index 165e7c93..2be341f2 100644
--- a/app/server/model/plan/stop.go
+++ b/app/server/model/plan/stop.go
@@ -3,7 +3,9 @@ package plan
import (
"fmt"
"plandex-server/db"
+ "time"
+ "github.com/plandex/plandex/shared"
"github.com/sashabaranov/go-openai"
)
@@ -14,23 +16,32 @@ func Stop(planId, branch, currentUserId, currentOrgId string) error {
return fmt.Errorf("no active plan with id %s", planId)
}
- active.CancelFn()
+ active.Stream(shared.StreamMessage{
+ Type: shared.StreamMessageAborted,
+ })
- userMsg := db.ConvoMessage{
- OrgId: currentOrgId,
- PlanId: planId,
- UserId: currentUserId,
- Role: openai.ChatMessageRoleAssistant,
- Tokens: active.NumTokens,
- Num: active.PromptMessageNum + 1,
- Stopped: true,
- Message: active.CurrentReplyContent,
- }
+ // give some time for stream message to be processed before canceling
+ time.Sleep(100 * time.Millisecond)
- _, err := db.StoreConvoMessage(&userMsg, currentUserId, branch, true)
+ active.CancelFn()
- if err != nil {
- return fmt.Errorf("error storing convo message: %v", err)
+ if !active.BuildOnly {
+ userMsg := db.ConvoMessage{
+ OrgId: currentOrgId,
+ PlanId: planId,
+ UserId: currentUserId,
+ Role: openai.ChatMessageRoleAssistant,
+ Tokens: active.NumTokens,
+ Num: active.PromptMessageNum + 1,
+ Stopped: true,
+ Message: active.CurrentReplyContent,
+ }
+
+ _, err := db.StoreConvoMessage(&userMsg, currentUserId, branch, true)
+
+ if err != nil {
+ return fmt.Errorf("error storing convo message: %v", err)
+ }
}
return nil
diff --git a/app/server/model/plan/tell.go b/app/server/model/plan/tell.go
index b64c7380..57507934 100644
--- a/app/server/model/plan/tell.go
+++ b/app/server/model/plan/tell.go
@@ -10,7 +10,6 @@ import (
"time"
"plandex-server/db"
- "plandex-server/host"
"plandex-server/model"
"plandex-server/model/lib"
"plandex-server/model/prompts"
@@ -23,69 +22,39 @@ import (
)
func Tell(client *openai.Client, plan *db.Plan, branch string, auth *types.ServerAuth, req *shared.TellPlanRequest) error {
- log.Printf("Tell: Called with plan ID %s on branch %s\n", plan.Id, branch) // Log the function call with plan ID and branch
- log.Println("Tell: Starting Tell operation") // Log start of Tell operation
- // goEnv := os.Getenv("GOENV") // Fetch the GOENV environment variable
-
- // log.Println("GOENV: " + goEnv)
- // if goEnv == "test" {
- // streamLoremIpsum(onStream)
- // return nil
- // }
+ log.Printf("Tell: Called with plan ID %s on branch %s\n", plan.Id, branch)
- active := GetActivePlan(plan.Id, branch)
- if active != nil {
- log.Printf("Tell: Active plan found for plan ID %s on branch %s\n", plan.Id, branch) // Log if an active plan is found
- return fmt.Errorf("plan %s branch %s already has an active stream on this host", plan.Id, branch)
- }
+ active, err := activatePlan(client, plan, branch, auth, req.Prompt, false)
- modelStream, err := db.GetActiveModelStream(plan.Id, branch)
if err != nil {
- log.Printf("Error getting active model stream: %v\n", err)
- return fmt.Errorf("error getting active model stream: %v", err)
- }
-
- if modelStream != nil {
- log.Printf("Tell: Active model stream found for plan ID %s on branch %s on host %s\n", plan.Id, branch, modelStream.InternalIp) // Log if an active model stream is found
- return fmt.Errorf("plan %s branch %s already has an active stream on host %s", plan.Id, branch, modelStream.InternalIp)
- }
-
- active = CreateActivePlan(plan.Id, branch, req.Prompt)
-
- modelStream = &db.ModelStream{
- OrgId: auth.OrgId,
- PlanId: plan.Id,
- InternalIp: host.Ip,
- Branch: branch,
- }
- err = db.StoreModelStream(modelStream, active.ModelStreamCtx, active.CancelModelStreamFn)
- if err != nil {
- log.Printf("Tell: Error storing model stream for plan ID %s on branch %s: %v\n", plan.Id, branch, err) // Log error storing model stream
- log.Printf("Error storing model stream: %v\n", err)
- log.Printf("Tell: Error storing model stream: %v\n", err) // Log error storing model stream
- return fmt.Errorf("error storing model stream: %v", err)
+ log.Printf("Error activating plan: %v\n", err)
+ return err
}
- active.ModelStreamId = modelStream.Id
-
- log.Printf("Tell: Model stream stored with ID %s for plan ID %s on branch %s\n", modelStream.Id, plan.Id, branch) // Log successful storage of model stream
- log.Println("Model stream id:", modelStream.Id)
-
- go execTellPlan(client, plan, branch, auth, req, active, 0, "")
+ go execTellPlan(
+ client,
+ plan,
+ branch,
+ auth,
+ req,
+ active,
+ 0,
+ "",
+ req.BuildMode == shared.BuildModeAuto,
+ )
- log.Printf("Tell: Tell operation completed successfully for plan ID %s on branch %s\n", plan.Id, branch) // Log successful completion of Tell operation
+ log.Printf("Tell: Tell operation completed successfully for plan ID %s on branch %s\n", plan.Id, branch)
return nil
}
-func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *types.ServerAuth, req *shared.TellPlanRequest, active *types.ActivePlan, iteration int, missingFileResponse shared.RespondMissingFileChoice) {
- log.Printf("execTellPlan: Called for plan ID %s on branch %s, iteration %d\n", plan.Id, branch, iteration) // Log the function call with plan ID, branch, and iteration
- log.Printf("execTellPlan: Starting execTellPlan operation, iteration: %d\n", iteration) // Log start of execTellPlan operation
+func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *types.ServerAuth, req *shared.TellPlanRequest, active *types.ActivePlan, iteration int, missingFileResponse shared.RespondMissingFileChoice, shouldBuildPending bool) {
+ log.Printf("execTellPlan: Called for plan ID %s on branch %s, iteration %d\n", plan.Id, branch, iteration)
currentUserId := auth.User.Id
currentOrgId := auth.OrgId
if os.Getenv("IS_CLOUD") != "" &&
missingFileResponse == "" {
- log.Println("execTellPlan: IS_CLOUD environment variable is set") // Log check for IS_CLOUD environment variable
+ log.Println("execTellPlan: IS_CLOUD environment variable is set")
if auth.User.IsTrial {
if plan.TotalReplies >= types.TrialMaxReplies {
active.StreamDoneCh <- &shared.ApiError{
@@ -111,7 +80,7 @@ func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *typ
Msg: "Error setting plan status to replying",
}
- log.Printf("execTellPlan: execTellPlan operation completed for plan ID %s on branch %s, iteration %d\n", plan.Id, branch, iteration) // Log completion of execTellPlan operation
+ log.Printf("execTellPlan: execTellPlan operation completed for plan ID %s on branch %s, iteration %d\n", plan.Id, branch, iteration)
return
}
@@ -121,16 +90,18 @@ func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *typ
}
repoLockId, err := db.LockRepo(
db.LockRepoParams{
- OrgId: auth.OrgId,
- UserId: auth.User.Id,
- PlanId: planId,
- Branch: branch,
- Scope: lockScope,
+ OrgId: auth.OrgId,
+ UserId: auth.User.Id,
+ PlanId: planId,
+ Branch: branch,
+ Scope: lockScope,
+ Ctx: active.ModelStreamCtx,
+ CancelFn: active.CancelModelStreamFn,
},
)
if err != nil {
- log.Printf("execTellPlan: Error locking repo for plan ID %s on branch %s: %v\n", plan.Id, branch, err) // Log error locking repo
+ log.Printf("execTellPlan: Error locking repo for plan ID %s on branch %s: %v\n", plan.Id, branch, err)
active.StreamDoneCh <- &shared.ApiError{
Type: shared.ApiErrorTypeOther,
Status: http.StatusInternalServerError,
@@ -666,6 +637,36 @@ func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *typ
return
}
+ if shouldBuildPending {
+ go func() {
+ pendingBuildsByPath, err := active.PendingBuildsByPath(auth.OrgId, auth.User.Id, convo)
+
+ if err != nil {
+ log.Printf("Error getting pending builds by path: %v\n", err)
+ active.StreamDoneCh <- &shared.ApiError{
+ Type: shared.ApiErrorTypeOther,
+ Status: http.StatusInternalServerError,
+ Msg: "Error getting pending builds by path",
+ }
+ return
+ }
+
+ if len(pendingBuildsByPath) == 0 {
+ log.Println("Tell plan: no pending builds")
+ return
+ }
+
+ for _, pendingBuilds := range pendingBuildsByPath {
+ queueBuilds(client, auth.OrgId, auth.User.Id, planId, branch, pendingBuilds)
+ }
+ }()
+ }
+
+ UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
+ ap.CurrentStreamingReplyId = replyId
+ ap.CurrentReplyDoneCh = make(chan bool)
+ })
+
storeAssistantReply := func() (*db.ConvoMessage, []string, string, error) {
num := len(convo) + 1
if iteration == 0 && missingFileResponse == "" {
@@ -842,7 +843,7 @@ func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *typ
err = func() error {
defer func() {
if err != nil {
- log.Printf("Error: %v\n", err)
+ log.Printf("Error storing reply and description: %v\n", err)
err = db.GitClearUncommittedChanges(auth.OrgId, planId)
if err != nil {
log.Printf("Error clearing uncommitted changes: %v\n", err)
@@ -923,6 +924,8 @@ func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *typ
}
}
+ log.Println("Comitting assistant message and description")
+
err = db.GitAddAndCommit(currentOrgId, planId, branch, convoCommitMsg)
if err != nil {
onError(fmt.Errorf("failed to commit: %v", err), false, assistantMsg.Id, convoCommitMsg)
@@ -936,22 +939,36 @@ func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *typ
return
}
+ active.CurrentReplyDoneCh <- true
+
+ UpdateActivePlan(planId, branch, func(active *types.ActivePlan) {
+ active.CurrentStreamingReplyId = ""
+ active.CurrentReplyDoneCh = nil
+ })
+
if req.AutoContinue && shouldContinue {
+ log.Println("Auto continue plan")
// continue plan
- execTellPlan(client, plan, branch, auth, req, active, iteration+1, "")
+ execTellPlan(client, plan, branch, auth, req, active, iteration+1, "", false)
} else {
- if GetActivePlan(planId, branch).BuildFinished() {
+ var buildFinished bool
+ UpdateActivePlan(planId, branch, func(active *types.ActivePlan) {
+ buildFinished = active.BuildFinished()
+ active.RepliesFinished = true
+ })
+
+ log.Printf("Won't continue plan. Build finished: %v\n", buildFinished)
+
+ if buildFinished {
active.Stream(shared.StreamMessage{
Type: shared.StreamMessageFinished,
})
} else {
- UpdateActivePlan(planId, branch, func(active *types.ActivePlan) {
- active.RepliesFinished = true
+ log.Println("Sending RepliesFinished stream message")
+ active.Stream(shared.StreamMessage{
+ Type: shared.StreamMessageRepliesFinished,
})
}
-
- // Wait briefly allow last stream message to be sent
- time.Sleep(100 * time.Millisecond)
}
return
@@ -978,6 +995,8 @@ func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *typ
replyNumTokens = res.TotalTokens
currentFile := res.CurrentFilePath
+ // Handle file that is present in project paths but not in context
+ // Prompt user for what to do on the client side, stop the stream, and wait for user response before proceeding
if currentFile != "" &&
active.ContextsByPath[currentFile] == nil &&
req.ProjectPaths[currentFile] && !active.AllowOverwritePaths[currentFile] {
@@ -1032,6 +1051,7 @@ func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *typ
active,
iteration, // keep the same iteration
userChoice,
+ false,
)
return
}
@@ -1040,13 +1060,15 @@ func execTellPlan(client *openai.Client, plan *db.Plan, branch string, auth *typ
log.Printf("Files: %v\n", files)
for i := len(files) - 1; i > len(replyFiles)-1; i-- {
file := files[i]
- log.Printf("Queuing build for %s\n", file)
- QueueBuild(client, currentOrgId, currentUserId, planId, branch, &types.ActiveBuild{
- AssistantMessageId: replyId,
- ReplyContent: active.CurrentReplyContent,
- FileContent: fileContents[i],
- Path: file,
- })
+ if req.BuildMode == shared.BuildModeAuto {
+ log.Printf("Queuing build for %s\n", file)
+ queueBuilds(client, currentOrgId, currentUserId, planId, branch, []*types.ActiveBuild{{
+ ReplyId: replyId,
+ ReplyContent: active.CurrentReplyContent,
+ FileContent: fileContents[i],
+ Path: file,
+ }})
+ }
replyFiles = append(replyFiles, file)
UpdateActivePlan(planId, branch, func(active *types.ActivePlan) {
active.Files = append(active.Files, file)
@@ -1069,8 +1091,8 @@ type summarizeConvoParams struct {
}
func summarizeConvo(client *openai.Client, params summarizeConvoParams) error {
- log.Printf("summarizeConvo: Called for plan ID %s on branch %s\n", params.planId, params.branch) // Log the function call with plan ID and branch
- log.Printf("summarizeConvo: Starting summarizeConvo for planId: %s\n", params.planId) // Log start of summarizeConvo
+ log.Printf("summarizeConvo: Called for plan ID %s on branch %s\n", params.planId, params.branch)
+ log.Printf("summarizeConvo: Starting summarizeConvo for planId: %s\n", params.planId)
planId := params.planId
branch := params.branch
convo := params.convo
@@ -1080,7 +1102,6 @@ func summarizeConvo(client *openai.Client, params summarizeConvoParams) error {
log.Println("Generating plan summary for planId:", planId)
- // log the parameters above
// log.Printf("planId: %s\n", planId)
// log.Printf("convo: ")
// spew.Dump(convo)
@@ -1145,12 +1166,11 @@ func summarizeConvo(client *openai.Client, params summarizeConvoParams) error {
})
if err != nil {
- log.Printf("summarizeConvo: Error generating summary for plan ID %s: %v\n", params.planId, err) // Log error generating summary
- log.Printf("summarizeConvo: Error generating plan summary for plan %s: %v\n", params.planId, err) // Log error generating plan summary
+ log.Printf("summarizeConvo: Error generating plan summary for plan %s: %v\n", params.planId, err)
return err
}
- log.Printf("summarizeConvo: Summary generated and stored for plan ID %s\n", params.planId) // Log successful generation and storage of summary
+ log.Printf("summarizeConvo: Summary generated and stored for plan %s\n", params.planId)
err = db.StoreSummary(summary)
diff --git a/app/server/types/active_plan.go b/app/server/types/active_plan.go
index c5fc714c..d75b1e74 100644
--- a/app/server/types/active_plan.go
+++ b/app/server/types/active_plan.go
@@ -3,58 +3,66 @@ package types
import (
"context"
"encoding/json"
+ "fmt"
+ "log"
"net/http"
"plandex-server/db"
+ "time"
+ "github.com/davecgh/go-spew/spew"
"github.com/google/uuid"
"github.com/plandex/plandex/shared"
)
type ActiveBuild struct {
- AssistantMessageId string
- ReplyContent string
- FileContent string
- Path string
- Buffer string
- Success bool
- Error error
+ ReplyId string
+ ReplyContent string
+ FileContent string
+ Path string
+ Buffer string
+ Success bool
+ Error error
}
type ActivePlan struct {
- Id string
- Branch string
- Prompt string
- Ctx context.Context
- CancelFn context.CancelFunc
- ModelStreamCtx context.Context
- CancelModelStreamFn context.CancelFunc
- Contexts []*db.Context
- ContextsByPath map[string]*db.Context
- Files []string
- BuiltFiles map[string]bool
- IsBuildingByPath map[string]bool
- CurrentReplyContent string
- NumTokens int
- PromptMessageNum int
- BuildQueuesByPath map[string][]*ActiveBuild
- RepliesFinished bool
- StreamDoneCh chan *shared.ApiError
- ModelStreamId string
- IsBackground bool
- MissingFileResponseCh chan shared.RespondMissingFileChoice
- AllowOverwritePaths map[string]bool
- SkippedPaths map[string]bool
- streamCh chan string
- subscriptions map[string]chan string
+ Id string
+ CurrentStreamingReplyId string
+ CurrentReplyDoneCh chan bool
+ Branch string
+ Prompt string
+ BuildOnly bool
+ Ctx context.Context
+ CancelFn context.CancelFunc
+ ModelStreamCtx context.Context
+ CancelModelStreamFn context.CancelFunc
+ Contexts []*db.Context
+ ContextsByPath map[string]*db.Context
+ Files []string
+ BuiltFiles map[string]bool
+ IsBuildingByPath map[string]bool
+ CurrentReplyContent string
+ NumTokens int
+ PromptMessageNum int
+ BuildQueuesByPath map[string][]*ActiveBuild
+ RepliesFinished bool
+ StreamDoneCh chan *shared.ApiError
+ ModelStreamId string
+ IsBackground bool
+ MissingFileResponseCh chan shared.RespondMissingFileChoice
+ AllowOverwritePaths map[string]bool
+ SkippedPaths map[string]bool
+ streamCh chan string
+ subscriptions map[string]chan string
}
-func NewActivePlan(planId, branch, prompt string) *ActivePlan {
+func NewActivePlan(planId, branch, prompt string, buildOnly bool) *ActivePlan {
ctx, cancel := context.WithCancel(context.Background())
// child context for model stream so we can cancel it separately if needed
modelStreamCtx, cancelModelStream := context.WithCancel(ctx)
active := ActivePlan{
Id: planId,
+ BuildOnly: buildOnly,
Branch: branch,
Prompt: prompt,
Ctx: ctx,
@@ -104,6 +112,8 @@ func (ap *ActivePlan) Stream(msg shared.StreamMessage) {
ap.streamCh <- string(msgJson)
if msg.Type == shared.StreamMessageFinished {
+ // Wait briefly allow last stream message to be sent
+ time.Sleep(100 * time.Millisecond)
ap.StreamDoneCh <- nil
}
}
@@ -148,3 +158,99 @@ func (ap *ActivePlan) NumSubscribers() int {
func (b *ActiveBuild) BuildFinished() bool {
return b.Success || b.Error != nil
}
+
+func (ap *ActivePlan) PendingBuildsByPath(orgId, userId string, convoMessagesArg []*db.ConvoMessage) (map[string][]*ActiveBuild, error) {
+ var planDescs []*db.ConvoMessageDescription
+ var currentPlan *shared.CurrentPlanState
+ var convoMessagesById map[string]*db.ConvoMessage
+
+ errCh := make(chan error)
+
+ go func() {
+ var err error
+ planDescs, err = db.GetPendingBuildDescriptions(orgId, ap.Id)
+ if err != nil {
+ errCh <- fmt.Errorf("error getting pending build descriptions: %v", err)
+ return
+ }
+
+ currentPlan, err = db.GetCurrentPlanState(db.CurrentPlanStateParams{
+ OrgId: orgId,
+ PlanId: ap.Id,
+ PendingBuildDescriptions: planDescs,
+ })
+ if err != nil {
+ errCh <- fmt.Errorf("error getting current plan state: %v", err)
+ return
+ }
+
+ errCh <- nil
+ }()
+
+ go func() {
+ var convoMessages []*db.ConvoMessage
+ if convoMessagesArg == nil {
+ var err error
+ convoMessages, err = db.GetPlanConvo(orgId, ap.Id)
+
+ if err != nil {
+ errCh <- fmt.Errorf("error getting plan convo: %v", err)
+ return
+ }
+ } else {
+ convoMessages = convoMessagesArg
+ }
+
+ convoMessagesById = map[string]*db.ConvoMessage{}
+ for _, msg := range convoMessages {
+ convoMessagesById[msg.Id] = msg
+ }
+
+ errCh <- nil
+ }()
+
+ for i := 0; i < 2; i++ {
+ err := <-errCh
+ if err != nil {
+ log.Printf("Error getting plan data: %v\n", err)
+ return nil, err
+ }
+ }
+
+ log.Println("planDescs:")
+ spew.Dump(planDescs)
+
+ activeBuildsByPath := map[string][]*ActiveBuild{}
+
+ for _, desc := range planDescs {
+ if !desc.DidBuild && len(desc.Files) > 0 {
+ if desc.ConvoMessageId == "" {
+ log.Printf("No convo message ID for description: %v\n", desc)
+ return nil, fmt.Errorf("no convo message ID for description: %v", desc)
+ }
+
+ if convoMessagesById[desc.ConvoMessageId] == nil {
+ log.Printf("No convo message for ID: %s\n", desc.ConvoMessageId)
+ return nil, fmt.Errorf("no convo message for ID: %s", desc.ConvoMessageId)
+ }
+
+ for _, file := range desc.Files {
+ if activeBuildsByPath[file] == nil {
+ activeBuildsByPath[file] = []*ActiveBuild{}
+ }
+
+ activeBuildsByPath[file] = append(activeBuildsByPath[file], &ActiveBuild{
+ ReplyId: desc.ConvoMessageId,
+ FileContent: currentPlan.CurrentPlanFiles.Files[file],
+ Path: file,
+ ReplyContent: convoMessagesById[desc.ConvoMessageId].Message,
+ })
+ }
+ }
+ }
+
+ log.Println("activeBuildsByPath:")
+ spew.Dump(activeBuildsByPath)
+
+ return activeBuildsByPath, nil
+}
diff --git a/app/shared/models.go b/app/shared/models.go
index 4906d1c8..062e5aec 100644
--- a/app/shared/models.go
+++ b/app/shared/models.go
@@ -41,6 +41,7 @@ const (
PlanStatusDraft PlanStatus = "draft"
PlanStatusReplying PlanStatus = "replying"
PlanStatusDescribing PlanStatus = "describing"
+ PlanStatusBuilding PlanStatus = "building"
PlanStatusPrompting PlanStatus = "prompting"
PlanStatusFinished PlanStatus = "finished"
PlanStatusStopped PlanStatus = "stopped"
@@ -125,6 +126,7 @@ type ConvoMessageDescription struct {
MadePlan bool `json:"madePlan"`
CommitMsg string `json:"commitMsg"`
Files []string `json:"files"`
+ DidBuild bool `json:"didBuild"`
Error string `json:"error"`
AppliedAt *time.Time `json:"appliedAt,omitempty"`
CreatedAt time.Time `json:"createdAt"`
diff --git a/app/shared/plan_result.go b/app/shared/plan_result.go
index 92ad9880..c2c2cc25 100644
--- a/app/shared/plan_result.go
+++ b/app/shared/plan_result.go
@@ -254,10 +254,10 @@ func (state *CurrentPlanState) PendingChangesSummary() string {
var descMsgs []string
if len(ch.descs) == 0 {
- descMsgs = append(descMsgs, "📝 Changes")
+ descMsgs = append(descMsgs, "🏗️ Changes")
} else {
for _, desc := range ch.descs {
- descMsgs = append(descMsgs, fmt.Sprintf("📝 %s", desc.CommitMsg))
+ descMsgs = append(descMsgs, fmt.Sprintf("🏗️ %s", desc.CommitMsg))
}
}
diff --git a/app/shared/req_res.go b/app/shared/req_res.go
index 85954638..4f37d37d 100644
--- a/app/shared/req_res.go
+++ b/app/shared/req_res.go
@@ -89,14 +89,30 @@ type GetCurrentBranchByPlanIdRequest struct {
CurrentBranchByPlanId map[string]string `json:"currentBranchByPlanId"`
}
+type BuildMode string
+
+const (
+ BuildModeAuto BuildMode = "auto"
+ BuildModeNone BuildMode = "none"
+)
+
type TellPlanRequest struct {
Prompt string `json:"prompt"`
+ BuildMode BuildMode `json:"buildMode"`
ConnectStream bool `json:"connectStream"`
AutoContinue bool `json:"autoContinue"`
ApiKey string `json:"apiKey"`
ProjectPaths map[string]bool `json:"projectPaths"`
}
+type BuildPlanRequest struct {
+ ConnectStream bool `json:"connectStream"`
+ ApiKey string `json:"apiKey"`
+ ProjectPaths map[string]bool `json:"projectPaths"`
+}
+
+const NoBuildsErr string = "No builds"
+
type RespondMissingFileChoice string
const (
diff --git a/app/shared/stream.go b/app/shared/stream.go
index 63167372..50e670ce 100644
--- a/app/shared/stream.go
+++ b/app/shared/stream.go
@@ -13,7 +13,7 @@ type StreamMessageType string
const (
StreamMessageReply StreamMessageType = "reply"
StreamMessageDescribing StreamMessageType = "describing"
- StreamMessageDescription StreamMessageType = "description"
+ StreamMessageRepliesFinished StreamMessageType = "repliesFinished"
StreamMessageBuildInfo StreamMessageType = "buildInfo"
StreamMessagePromptMissingFile StreamMessageType = "promptMissingFile"
StreamMessageAborted StreamMessageType = "aborted"