Open source AI coding agent. Designed for large projects and real world tasks.
Go aiai-agentsai-developer-toolsai-toolsclicommand-linedeveloper-toolsgitgolanggpt-4llmopenaipolyglot-programmingterminalterminal-basedterminal-ui
background streams and various fixes
Dane Schneiderd67f7bf5803b
diff --git a/app/cli/api/methods.go b/app/cli/api/methods.goindex 081646c7..86ea98b6 100644--- a/app/cli/api/methods.go+++ b/app/cli/api/methods.go@@ -232,13 +232,16 @@ func (a *Api) ListArchivedPlans(projectIds []string) ([]*shared.Plan, *shared.Apreturn plans, nil}-func (a *Api) ListPlansRunning(projectIds []string) ([]*shared.Plan, *shared.ApiError) {+func (a *Api) ListPlansRunning(projectIds []string, includeRecent bool) (*shared.ListPlansRunningResponse, *shared.ApiError) {serverUrl := fmt.Sprintf("%s/plans/ps?", getApiHost())parts := []string{}for _, projectId := range projectIds {parts = append(parts, fmt.Sprintf("projectId=%s", projectId))}serverUrl += strings.Join(parts, "&")+ if includeRecent {+ serverUrl += "&recent=true"+ }resp, err := authenticatedFastClient.Get(serverUrl)if err != nil {@@ -251,18 +254,18 @@ func (a *Api) ListPlansRunning(projectIds []string) ([]*shared.Plan, *shared.ApiapiErr := handleApiError(resp, errorBody)tokenRefreshed, apiErr := refreshTokenIfNeeded(apiErr)if tokenRefreshed {- return a.ListPlansRunning(projectIds)+ return a.ListPlansRunning(projectIds, includeRecent)}return nil, apiErr}- var plans []*shared.Plan- err = json.NewDecoder(resp.Body).Decode(&plans)+ var respBody *shared.ListPlansRunningResponse+ err = json.NewDecoder(resp.Body).Decode(&respBody)if err != nil {return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}}- return plans, nil+ return respBody, nil}func (a *Api) GetCurrentBranchByPlanId(projectId string, req shared.GetCurrentBranchByPlanIdRequest) (map[string]*shared.Branch, *shared.ApiError) {@@ -468,6 +471,9 @@ func (a *Api) TellPlan(planId, branch string, req shared.TellPlanRequest, onStreif req.ConnectStream {log.Println("Connecting stream")connectPlanRespStream(resp.Body, onStream)+ } else {+ // log.Println("Background exec - not connecting stream")+ resp.Body.Close()}return nil@@ -518,6 +524,9 @@ func (a *Api) BuildPlan(planId, branch string, req shared.BuildPlanRequest, onStif req.ConnectStream {log.Println("Connecting stream")connectPlanRespStream(resp.Body, onStream)+ } else {+ // log.Println("Background exec - not connecting stream")+ resp.Body.Close()}return nil@@ -570,7 +579,6 @@ func (a *Api) ConnectPlan(planId, branch string, onStream types.OnStreamPlan) *sif err != nil {return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}}- defer resp.Body.Close()if resp.StatusCode >= 400 {errorBody, _ := io.ReadAll(resp.Body)diff --git a/app/cli/cmd/apply.go b/app/cli/cmd/apply.goindex a5fa7de7..f75d2d6e 100644--- a/app/cli/cmd/apply.go+++ b/app/cli/cmd/apply.go@@ -12,6 +12,7 @@ var autoConfirm boolfunc init() {applyCmd.Flags().BoolVarP(&autoConfirm, "yes", "y", false, "Automatically confirm unless plan is outdated")+RootCmd.AddCommand(applyCmd)}diff --git a/app/cli/cmd/build.go b/app/cli/cmd/build.goindex 744f7c67..a201227f 100644--- a/app/cli/cmd/build.go+++ b/app/cli/cmd/build.go@@ -22,7 +22,7 @@ var buildBg boolvar buildCmd = &cobra.Command{Use: "build",Aliases: []string{"b"},- Short: "Send a prompt for the current plan.",+ Short: "Build pending changes",// Long: ``,Args: cobra.NoArgs,Run: build,@@ -30,7 +30,6 @@ var buildCmd = &cobra.Command{func init() {RootCmd.AddCommand(buildCmd)-buildCmd.Flags().BoolVar(&buildBg, "bg", false, "Execute autonomously in the background")}@@ -93,7 +92,7 @@ func build(cmd *cobra.Command, args []string) {}fmt.Println()- term.PrintCmds("", "changes", "log")+ term.PrintCmds("", "changes", "apply", "log")os.Exit(0)}()diff --git a/app/cli/cmd/connect.go b/app/cli/cmd/connect.gonew file mode 100644index 00000000..6fb60727--- /dev/null+++ b/app/cli/cmd/connect.go@@ -0,0 +1,69 @@+package cmd++import (+ "fmt"+ "log"+ "os"+ "plandex/api"+ "plandex/auth"+ "plandex/lib"+ "plandex/stream"+ streamtui "plandex/stream_tui"+ "plandex/term"++ "github.com/spf13/cobra"+)++var connectCmd = &cobra.Command{+ Use: "connect [stream-id-or-plan] [branch]",+ Aliases: []string{"conn"},+ Short: "Connect to an active stream",+ // Long: ``,+ Args: cobra.MaximumNArgs(2),+ Run: connect,+}++func init() {+ RootCmd.AddCommand(connectCmd)++}++func connect(cmd *cobra.Command, args []string) {+ auth.MustResolveAuthWithOrg()+ lib.MustResolveProject()++ if lib.CurrentPlanId == "" {+ fmt.Fprintln(os.Stderr, "No current plan")+ return+ }++ planId, branch, shouldContinue := lib.SelectActiveStream(args)++ if !shouldContinue {+ return+ }++ apiErr := api.Client.ConnectPlan(planId, branch, stream.OnStreamPlan)++ if apiErr != nil {+ fmt.Fprintln(os.Stderr, "Error connecting to stream:", apiErr.Msg)+ return+ }++ go func() {+ err := streamtui.StartStreamUI("", false)++ if err != nil {+ log.Printf("Error starting stream UI: %v\n", err)+ os.Exit(1)+ }++ fmt.Println()+ term.PrintCmds("", "changes", "apply", "log")++ os.Exit(0)+ }()++ // Wait for the stream to finish+ select {}+}diff --git a/app/cli/cmd/continue.go b/app/cli/cmd/continue.goindex f5a1274a..970a967d 100644--- a/app/cli/cmd/continue.go+++ b/app/cli/cmd/continue.go@@ -23,6 +23,7 @@ func init() {continueCmd.Flags().BoolVarP(&tellStop, "stop", "s", false, "Stop after a single reply")continueCmd.Flags().BoolVarP(&tellNoBuild, "no-build", "n", false, "Don't build files")+ continueCmd.Flags().BoolVar(&tellBg, "bg", false, "Execute autonomously in the background")}func doContinue(cmd *cobra.Command, args []string) {diff --git a/app/cli/cmd/ps.go b/app/cli/cmd/ps.gonew file mode 100644index 00000000..333429ae--- /dev/null+++ b/app/cli/cmd/ps.go@@ -0,0 +1,97 @@+package cmd++import (+ "fmt"+ "os"+ "plandex/api"+ "plandex/auth"+ "plandex/format"+ "plandex/lib"+ "plandex/term"++ "github.com/olekukonko/tablewriter"+ "github.com/plandex/plandex/shared"+ "github.com/spf13/cobra"+)++var psCmd = &cobra.Command{+ Use: "ps",+ Short: "List plans with active or recently finished streams",+ Run: ps,+}++func init() {+ RootCmd.AddCommand(psCmd)+}++func ps(cmd *cobra.Command, args []string) {+ auth.MustResolveAuthWithOrg()+ lib.MustResolveProject()++ if lib.CurrentPlanId == "" {+ fmt.Println("π€·ββοΈ No current plan")+ return+ }++ res, apiErr := api.Client.ListPlansRunning([]string{lib.CurrentProjectId}, true)++ if apiErr != nil {+ fmt.Println("Error getting running plans:", apiErr)+ return+ }++ if len(res.Branches) == 0 {+ fmt.Println("π€·ββοΈ No active or recently finished streams")+ return+ }++ table := tablewriter.NewWriter(os.Stdout)+ table.SetAutoWrapText(false)+ table.SetHeader([]string{"Pid", "Plan", "Branch", "Started", "Status"})++ for _, b := range res.Branches {+ id := res.StreamIdByBranchId[b.Id]+ plan := res.PlansById[b.PlanId]++ status := "Active"+ finishedAt := res.StreamFinishedAtByBranchId[b.Id]+ switch b.Status {+ case shared.PlanStatusFinished:+ status = "Finished " + format.Time(finishedAt)+ case shared.PlanStatusError:+ status = "Error " + format.Time(finishedAt)+ case shared.PlanStatusStopped:+ status = "Stopped " + format.Time(finishedAt)+ case shared.PlanStatusMissingFile:+ status = "Missing file"+ }++ row := []string{+ id[:4],+ plan.Name,+ b.Name,+ format.Time(res.StreamStartedAtByBranchId[b.Id]),+ status,+ }++ var style []tablewriter.Colors+ if b.Name == lib.CurrentPlanId {+ style = []tablewriter.Colors{+ {tablewriter.FgGreenColor, tablewriter.Bold},+ }+ } else {+ style = []tablewriter.Colors{+ {tablewriter.FgHiWhiteColor, tablewriter.Bold},+ {tablewriter.FgHiWhiteColor},+ }+ }++ table.Rich(row, style)++ }+ table.Render()++ fmt.Println()+ term.PrintCmds("", "connect", "stop")++}diff --git a/app/cli/cmd/stop.go b/app/cli/cmd/stop.gonew file mode 100644index 00000000..bf9de45a--- /dev/null+++ b/app/cli/cmd/stop.go@@ -0,0 +1,53 @@+package cmd++import (+ "fmt"+ "os"+ "plandex/api"+ "plandex/auth"+ "plandex/lib"+ "plandex/term"++ "github.com/spf13/cobra"+)++var stopCmd = &cobra.Command{+ Use: "stop [stream-id-or-plan] [branch]",+ Short: "Connect to an active stream",+ // Long: ``,+ Args: cobra.MaximumNArgs(2),+ Run: stop,+}++func init() {+ RootCmd.AddCommand(stopCmd)+}++func stop(cmd *cobra.Command, args []string) {+ auth.MustResolveAuthWithOrg()+ lib.MustResolveProject()++ if lib.CurrentPlanId == "" {+ fmt.Fprintln(os.Stderr, "No current plan")+ return+ }++ planId, branch, shouldContinue := lib.SelectActiveStream(args)++ if !shouldContinue {+ return+ }++ apiErr := api.Client.StopPlan(planId, branch)++ if apiErr != nil {+ fmt.Fprintln(os.Stderr, "Error stopping stream:", apiErr.Msg)+ return+ }++ fmt.Println("β Plan stream stopped")++ fmt.Println()+ term.PrintCmds("", "convo", "log")++}diff --git a/app/cli/cmd/tell.go b/app/cli/cmd/tell.goindex fce98527..0b1dae82 100644--- a/app/cli/cmd/tell.go+++ b/app/cli/cmd/tell.go@@ -36,9 +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") // Not implemented yettellCmd.Flags().BoolVarP(&tellStop, "stop", "s", false, "Stop after a single reply")tellCmd.Flags().BoolVarP(&tellNoBuild, "no-build", "n", false, "Don't build files")+ tellCmd.Flags().BoolVar(&tellBg, "bg", false, "Execute autonomously in the background")}func doTell(cmd *cobra.Command, args []string) {diff --git a/app/cli/lib/active_stream.go b/app/cli/lib/active_stream.gonew file mode 100644index 00000000..9074ef23--- /dev/null+++ b/app/cli/lib/active_stream.go@@ -0,0 +1,154 @@+package lib++import (+ "fmt"+ "os"+ "plandex/api"+ "plandex/term"++ "github.com/plandex/plandex/shared"+)++func SelectActiveStream(args []string) (string, string, bool) {+ res, apiErr := api.Client.ListPlansRunning([]string{CurrentProjectId}, false)++ if apiErr != nil {+ fmt.Println("Error getting running plans:", apiErr)+ return "", "", false+ }++ if len(res.Branches) == 0 {+ fmt.Println("π€·ββοΈ No active plan stream")+ fmt.Println()+ term.PrintCmds("", "ps")+ return "", "", false+ }++ var planId string+ var branch string+ var streamIdOrPlan string++ if len(args) > 0 {+ streamIdOrPlan = args[0]+ }++ if streamIdOrPlan != "" {+ for _, b := range res.Branches {+ id := res.StreamIdByBranchId[b.Id]+ plan := res.PlansById[b.PlanId]+ if id == streamIdOrPlan || plan.Name == streamIdOrPlan {+ planId = b.PlanId+ branch = b.Name+ break+ }+ }+ }++ if planId == "" {+ if len(res.PlansById) == 1 {+ for _, p := range res.PlansById {+ if p.Id == CurrentPlanId {+ planId = p.Id+ break+ }+ }+ }++ if planId == "" {+ var opts []string+ addedPlans := make(map[string]bool)++ for _, plan := range res.PlansById {+ if addedPlans[plan.Id] {+ continue+ }+ opts = append(opts, plan.Name)+ addedPlans[plan.Id] = true+ }++ selected, err := term.SelectFromList("Select an active plan", opts)++ if err != nil {+ fmt.Fprintln(os.Stderr, "Error selecting plan:", err)+ return "", "", false+ }++ for _, p := range res.PlansById {+ if p.Name == selected {+ planId = p.Id+ break+ }+ }+ }++ }++ if planId == "" {+ fmt.Println("π€·ββοΈ No active plan stream")+ fmt.Println()+ term.PrintCmds("", "ps")++ return "", "", false+ }++ var planBranches []*shared.Branch+ for _, b := range res.Branches {+ if b.PlanId == planId {+ planBranches = append(planBranches, b)+ }+ }++ if len(planBranches) == 0 {+ fmt.Println("π€·ββοΈ No active plan stream")+ fmt.Println()+ term.PrintCmds("", "ps")++ return "", "", false+ }++ if len(args) > 1 {+ maybeBranch := args[1]+ for _, b := range planBranches {+ if b.Name == maybeBranch {+ branch = maybeBranch+ break+ }+ }+ }++ if branch == "" {+ if len(planBranches) == 1 {+ name := planBranches[0].Name+ if name == CurrentBranch {+ branch = name+ }+ }++ if branch == "" {+ opts := make([]string, len(planBranches))++ for i, b := range planBranches {+ opts[i] = b.Name+ }++ selected, err := term.SelectFromList("Select a branch", opts)++ if err != nil {+ fmt.Fprintln(os.Stderr, "Error selecting branch:", err)+ return "", "", false+ }++ branch = selected+ }+ }++ if branch == "" {+ fmt.Println("π€·ββοΈ No active plan stream")+ fmt.Println()+ term.PrintCmds("", "ps")++ return "", "", false+ }++ return planId, branch, true+}diff --git a/app/cli/lib/apply.go b/app/cli/lib/apply.goindex a5ba8767..6622da2b 100644--- a/app/cli/lib/apply.go+++ b/app/cli/lib/apply.go@@ -23,6 +23,10 @@ func ApplyPlanWithOutput(planId, branch string, autoConfirm bool) error {return fmt.Errorf("error getting current plan state: %s", apiErr.Msg)}+ if currentPlanState.HasPendingBuilds() {++ }+currentPlanFiles := currentPlanState.CurrentPlanFilesplanResByPath := currentPlanState.PlanResult.FileResultsByPathdiff --git a/app/cli/main.go b/app/cli/main.goindex bbf5fcdc..dea909d9 100644--- a/app/cli/main.go+++ b/app/cli/main.go@@ -26,7 +26,7 @@ func init() {// Set the output of the logger to the filelog.SetOutput(file)- log.Println("Starting Plandex - logging initialized")+ // log.Println("Starting Plandex - logging initialized")}func main() {diff --git a/app/cli/stream/stream.go b/app/cli/stream/stream.goindex 98046e7e..8077cffa 100644--- a/app/cli/stream/stream.go+++ b/app/cli/stream/stream.go@@ -15,7 +15,7 @@ var OnStreamPlan types.OnStreamPlan = func(params types.OnStreamPlanParams) {}if params.Msg.Type == shared.StreamMessageStart {- log.Println("Stream started")+ // log.Println("Stream started")return}diff --git a/app/cli/stream_tui/update.go b/app/cli/stream_tui/update.goindex 4a761360..3c46f2c1 100644--- a/app/cli/stream_tui/update.go+++ b/app/cli/stream_tui/update.go@@ -218,30 +218,52 @@ func (m *streamUIModel) scrollEnd() {}func (m *streamUIModel) streamUpdate(msg *shared.StreamMessage) (tea.Model, tea.Cmd) {- // log.Println("streamUI received message:", msg.Type)- switch msg.Type {- case shared.StreamMessagePromptMissingFile:- m.promptingMissingFile = true- m.missingFilePath = msg.MissingFilePath-- bytes, err := os.ReadFile(m.missingFilePath)- if err != nil {- log.Println("failed to read file:", err)- m.err = fmt.Errorf("failed to read file: %w", err)- return m, nil+ checkMissingFileFn := func() {+ if msg.MissingFilePath != "" {+ m.promptingMissingFile = true+ m.missingFilePath = msg.MissingFilePath++ bytes, err := os.ReadFile(m.missingFilePath)+ if err != nil {+ log.Println("failed to read file:", err)+ m.err = fmt.Errorf("failed to read file: %w", err)+ return+ }+ m.missingFileContent = string(bytes)++ numTokens, err := shared.GetNumTokens(m.missingFileContent)++ if err != nil {+ log.Println("failed to get num tokens:", err)+ m.err = fmt.Errorf("failed to get num tokens: %w", err)+ return+ }++ m.missingFileTokens = numTokens}- m.missingFileContent = string(bytes)+ }- numTokens, err := shared.GetNumTokens(m.missingFileContent)+ // log.Println("streamUI received message:", msg.Type)+ switch msg.Type {- if err != nil {- log.Println("failed to get num tokens:", err)- m.err = fmt.Errorf("failed to get num tokens: %w", err)- return m, nil+ case shared.StreamMessageConnectActive:++ if msg.InitPrompt != "" {+ m.prompt = msg.InitPrompt+ }+ if msg.InitBuildOnly {+ m.buildOnly = true}+ if len(msg.InitReplies) > 0 {+ m.reply = strings.Join(msg.InitReplies, "\n\nπ ")+ }+ m.updateReplyDisplay()- m.missingFileTokens = numTokens+ checkMissingFileFn()++ case shared.StreamMessagePromptMissingFile:+ checkMissingFileFn()case shared.StreamMessageReply:if m.starting {diff --git a/app/cli/tell/tell.go b/app/cli/tell/tell.goindex 1c72a76c..cf5fbbed 100644--- a/app/cli/tell/tell.go+++ b/app/cli/tell/tell.go@@ -120,7 +120,9 @@ func TellPlan(prompt string, tellBg, tellStop, tellNoBuild, isUserContinue bool)}if tellBg {- fmt.Println("β Prompt sent")+ fmt.Println("β Plan is active in the background")+ fmt.Println()+ term.PrintCmds("", "ps", "connect", "stop")} else {// Wait for stream UI to quitselect {}diff --git a/app/cli/term/term.go b/app/cli/term/term.goindex bef5e93b..c428e088 100644--- a/app/cli/term/term.go+++ b/app/cli/term/term.go@@ -41,6 +41,9 @@ var CmdDesc = map[string][2]string{"build": {"b", "build any pending changes"},"models": {"", "show model settings"},"set-model": {"", "update model settings"},+ "ps": {"", "list active and recently finished plan streams"},+ "stop": {"", "stop an active plan stream"},+ "connect": {"conn", "connect to an active plan stream"},}func PrintCmds(prefix string, cmds ...string) {diff --git a/app/cli/types/api.go b/app/cli/types/api.goindex 6b91b690..69a8aa37 100644--- a/app/cli/types/api.go+++ b/app/cli/types/api.go@@ -42,7 +42,7 @@ type ApiClient interface {ListPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError)ListArchivedPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError)- ListPlansRunning(projectIds []string) ([]*shared.Plan, *shared.ApiError)+ ListPlansRunning(projectIds []string, includeRecent bool) (*shared.ListPlansRunningResponse, *shared.ApiError)GetCurrentBranchByPlanId(projectId string, req shared.GetCurrentBranchByPlanIdRequest) (map[string]*shared.Branch, *shared.ApiError)diff --git a/app/server/db/branch_helpers.go b/app/server/db/branch_helpers.goindex fc80e232..ca3e8e3e 100644--- a/app/server/db/branch_helpers.go+++ b/app/server/db/branch_helpers.go@@ -5,6 +5,7 @@ import ("fmt""log"+ "github.com/lib/pq""github.com/plandex/plandex/shared")@@ -114,7 +115,7 @@ func GetDbBranch(planId, name string) (*Branch, error) {return &branch, nil}-func ListBranches(orgId, planId string) ([]*Branch, error) {+func ListPlanBranches(orgId, planId string) ([]*Branch, error) {var branches []*Brancherr := Conn.Select(&branches, "SELECT * FROM branches WHERE plan_id = $1 ORDER BY created_at", planId)@@ -143,6 +144,17 @@ func ListBranches(orgId, planId string) ([]*Branch, error) {return res, nil}+func ListBranchesForPlans(orgId string, planIds []string) ([]*Branch, error) {+ var branches []*Branch+ err := Conn.Select(&branches, "SELECT * FROM branches WHERE plan_id = ANY($1) ORDER BY created_at", pq.Array(planIds))++ if err != nil {+ return nil, fmt.Errorf("error listing branches: %v", err)+ }++ return branches, nil+}+func DeleteBranch(orgId, planId, branch string) error {tx, err := Conn.Begin()diff --git a/app/server/db/context_helpers.go b/app/server/db/context_helpers.goindex a8732e7f..7268ac95 100644--- a/app/server/db/context_helpers.go+++ b/app/server/db/context_helpers.go@@ -313,6 +313,10 @@ func UpdateContexts(params UpdateContextsParams) (*shared.UpdateContextResponse,return nil, fmt.Errorf("error getting branch: %v", err)}+ if branch == nil {+ return nil, fmt.Errorf("branch not found")+ }+settings, err := GetPlanSettings(plan, true)if err != nil {return nil, fmt.Errorf("error getting settings: %v", err)diff --git a/app/server/db/data_models.go b/app/server/db/data_models.goindex 40ca14a4..4f3cf50c 100644--- a/app/server/db/data_models.go+++ b/app/server/db/data_models.go@@ -173,6 +173,7 @@ type Branch struct {func (branch *Branch) ToApi() *shared.Branch {return &shared.Branch{Id: branch.Id,+ PlanId: branch.PlanId,OwnerId: branch.OwnerId,ParentBranchId: branch.ParentBranchId,Name: branch.Name,diff --git a/app/server/db/locks.go b/app/server/db/locks.goindex 7d6185ef..2f7b709b 100644--- a/app/server/db/locks.go+++ b/app/server/db/locks.go@@ -6,6 +6,7 @@ import ("log""time"+ "github.com/davecgh/go-spew/spew""github.com/lib/pq")@@ -32,6 +33,9 @@ func LockRepo(params LockRepoParams) (string, error) {}func lockRepo(params LockRepoParams, numRetry int) (string, error) {+ log.Println("locking repo")+ spew.Dump(params)+orgId := params.OrgIduserId := params.UserIdplanId := params.PlanId@@ -136,6 +140,8 @@ func lockRepo(params LockRepoParams, numRetry int) (string, error) {}if !canAcquire {+ log.Println("can't acquire lock. canRetry:", canRetry, "numRetry:", numRetry)+if canRetry {// 10 second timeoutif numRetry > 20 {@@ -219,7 +225,7 @@ func lockRepo(params LockRepoParams, numRetry int) (string, error) {returndefault:- _, err := Conn.Exec("UPDATE repo_locks SET last_heartbeat_at = NOW() WHERE id = $1", newLock.Id)+ res, err := Conn.Exec("UPDATE repo_locks SET last_heartbeat_at = NOW() WHERE id = $1", newLock.Id)if err != nil {log.Printf("Error updating repo lock last heartbeat: %v\n", err)@@ -232,21 +238,40 @@ func lockRepo(params LockRepoParams, numRetry int) (string, error) {}}+ // check if 0 rows were updated+ rowsAffected, err := res.RowsAffected()+ if err != nil {+ log.Printf("Error getting rows affected: %v\n", err)+ cancelFn()+ return+ }++ if rowsAffected == 0 {+ log.Printf("Lock not found: %s | stopping heartbeat loop\n", newLock.Id)+ return+ }+time.Sleep(lockHeartbeatInterval)}}}()+ log.Println("repo locked. id:", newLock.Id)+return newLock.Id, nil}func UnlockRepo(id string) error {+ log.Println("unlocking repo:", id)+query := "DELETE FROM repo_locks WHERE id = $1"_, err := Conn.Exec(query, id)if err != nil {return fmt.Errorf("error removing lock: %v", err)}+ log.Println("repo unlocked successfully:", id)+return nil}diff --git a/app/server/db/stream_helpers.go b/app/server/db/stream_helpers.goindex 35ef0a21..ba85995d 100644--- a/app/server/db/stream_helpers.go+++ b/app/server/db/stream_helpers.go@@ -6,6 +6,9 @@ import ("fmt""log""time"++ "github.com/lib/pq"+ "github.com/plandex/plandex/shared")const modelStreamHeartbeatInterval = 1 * time.Second@@ -39,7 +42,6 @@ func StoreModelStream(stream *ModelStream, ctx context.Context, cancelFn contextfor {select {case <-ctx.Done():- // 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)@@ -104,6 +106,12 @@ func GetActiveModelStream(planId, branch string) (*ModelStream, error) {return nil, fmt.Errorf("error setting model stream finished: %v", err)}+ err = SetPlanStatus(planId, branch, shared.PlanStatusError, "Model stream has not sent a heartbeat in 5 seconds")++ if err != nil {+ return nil, fmt.Errorf("error setting plan status to error: %v", err)+ }+return nil, nil} else {log.Printf("Model stream %s sent heartbeat %d seconds ago\n", stream.Id, int(time.Since(stream.LastHeartbeatAt).Seconds()))@@ -112,6 +120,28 @@ func GetActiveModelStream(planId, branch string) (*ModelStream, error) {return &stream, nil}+func GetActiveOrRecentModelStreams(planIds []string) ([]*ModelStream, error) {+ var streams []*ModelStream+ err := Conn.Select(&streams, "SELECT * FROM model_streams WHERE plan_id = ANY($1) AND (finished_at IS NULL OR finished_at > NOW() - INTERVAL '1 hour') ORDER BY created_at", pq.Array(planIds))++ if err != nil {+ return nil, fmt.Errorf("error getting active or recent model streams: %v", err)+ }++ return streams, nil+}++func GetActiveModelStreams(planIds []string) ([]*ModelStream, error) {+ var streams []*ModelStream+ err := Conn.Select(&streams, "SELECT * FROM model_streams WHERE plan_id = ANY($1) AND finished_at IS NULL ORDER BY created_at", pq.Array(planIds))++ if err != nil {+ return nil, fmt.Errorf("error getting active model streams: %v", err)+ }++ return streams, nil+}+// func StoreModelStreamSubscription(subscription *ModelStreamSubscription) error {// query := `INSERT INTO model_stream_subscriptions (model_stream_id, org_id, plan_id, user_id, user_ip) VALUES (:model_stream_id, :org_id, :plan_id, :user_id, :user_ip) RETURNING id, created_at`diff --git a/app/server/handlers/auth_helpers.go b/app/server/handlers/auth_helpers.goindex d3b7007c..4dc34401 100644--- a/app/server/handlers/auth_helpers.go+++ b/app/server/handlers/auth_helpers.go@@ -136,6 +136,8 @@ func authenticate(w http.ResponseWriter, r *http.Request, requireOrg bool) *typepermissionsMap[types.Permission(permission)] = true}+ log.Printf("UserId: %s, Email: %s, OrgId: %s\n", authToken.UserId, user.Email, parsed.OrgId)+return &types.ServerAuth{AuthToken: authToken,User: user,diff --git a/app/server/handlers/branches.go b/app/server/handlers/branches.goindex 5611680c..34b39e1f 100644--- a/app/server/handlers/branches.go+++ b/app/server/handlers/branches.go@@ -39,7 +39,7 @@ func ListBranchesHandler(w http.ResponseWriter, r *http.Request) {defer (*unlockFn)(err)}- branches, err := db.ListBranches(auth.OrgId, planId)+ branches, err := db.ListPlanBranches(auth.OrgId, planId)if err != nil {log.Printf("Error getting branches: %v\n", err)diff --git a/app/server/handlers/plans_context.go b/app/server/handlers/plans_context.goindex 684b854b..ac3bab5a 100644--- a/app/server/handlers/plans_context.go+++ b/app/server/handlers/plans_context.go@@ -158,9 +158,10 @@ func UpdateContextHandler(w http.ResponseWriter, r *http.Request) {}updateRes, err := db.UpdateContexts(db.UpdateContextsParams{- Req: &requestBody,- OrgId: auth.OrgId,- Plan: plan,+ Req: &requestBody,+ OrgId: auth.OrgId,+ Plan: plan,+ BranchName: branchName,})if err != nil {diff --git a/app/server/handlers/plans_crud.go b/app/server/handlers/plans_crud.goindex 35b091ef..ecff54a3 100644--- a/app/server/handlers/plans_crud.go+++ b/app/server/handlers/plans_crud.go@@ -9,7 +9,9 @@ import ("os""plandex-server/db""plandex-server/types"+ "sort""strings"+ "time""github.com/gorilla/mux""github.com/plandex/plandex/shared"@@ -282,8 +284,8 @@ func ListPlansHandler(w http.ResponseWriter, r *http.Request) {plans, err := db.ListOwnedPlans(projectIds, auth.User.Id, false)if err != nil {- log.Printf("Error listing plan ids: %v\n", err)- http.Error(w, "Error listing plan ids: "+err.Error(), http.StatusInternalServerError)+ log.Printf("Error listing plans: %v\n", err)+ http.Error(w, "Error listing plans: "+err.Error(), http.StatusInternalServerError)return}@@ -295,8 +297,8 @@ func ListPlansHandler(w http.ResponseWriter, r *http.Request) {bytes, err := json.Marshal(apiPlans)if err != nil {- log.Printf("Error marshalling plan ids: %v\n", err)- http.Error(w, "Error marshalling plan ids: "+err.Error(), http.StatusInternalServerError)+ log.Printf("Error marshalling plans: %v\n", err)+ http.Error(w, "Error marshalling plans: "+err.Error(), http.StatusInternalServerError)return}@@ -359,6 +361,7 @@ func ListPlansRunningHandler(w http.ResponseWriter, r *http.Request) {}projectIds := r.URL.Query()["projectId"]+ includeRecent := r.URL.Query().Get("recent") == "true"log.Println("projectIds: ", projectIds)@@ -374,8 +377,138 @@ func ListPlansRunningHandler(w http.ResponseWriter, r *http.Request) {}}- // TODO: implement when status is figured out+ plans, err := db.ListOwnedPlans(projectIds, auth.User.Id, false)++ if err != nil {+ log.Printf("Error listing plans: %v\n", err)+ http.Error(w, "Error listing plans: "+err.Error(), http.StatusInternalServerError)+ return+ }++ var planIds []string+ for _, plan := range plans {+ planIds = append(planIds, plan.Id)+ }++ errCh := make(chan error)+ var streams []*db.ModelStream+ var branches []*db.Branch++ go func() {+ var err error+ if includeRecent {+ streams, err = db.GetActiveOrRecentModelStreams(planIds)+ } else {+ streams, err = db.GetActiveModelStreams(planIds)+ }+ if err != nil {+ errCh <- fmt.Errorf("error getting recent model streams: %v", err)+ return+ }+ errCh <- nil+ }()++ go func() {+ var err error+ branches, err = db.ListBranchesForPlans(auth.OrgId, planIds)+ if err != nil {+ errCh <- fmt.Errorf("error getting branches: %v", err)+ return+ }+ errCh <- nil+ }()++ for i := 0; i < 2; i++ {+ err := <-errCh+ if err != nil {+ log.Println(err)+ http.Error(w, err.Error(), http.StatusInternalServerError)+ return+ }+ }++ res := shared.ListPlansRunningResponse{+ Branches: []*shared.Branch{},+ StreamStartedAtByBranchId: map[string]time.Time{},+ StreamFinishedAtByBranchId: map[string]time.Time{},+ PlansById: map[string]*shared.Plan{},+ StreamIdByBranchId: map[string]string{},+ }++ var apiPlansById = make(map[string]*shared.Plan)+ for _, plan := range plans {+ apiPlan := plan.ToApi()+ apiPlansById[plan.Id] = apiPlan+ }++ var apiBranchesByComposite = make(map[string]*shared.Branch)+ for _, branch := range branches {+ apiBranch := branch.ToApi()+ apiBranchesByComposite[branch.PlanId+"|"+branch.Name] = apiBranch+ }++ addedBranches := make(map[string]bool)+ for _, stream := range streams {+ branchComposite := stream.PlanId + "|" + stream.Branch+ apiBranch, ok := apiBranchesByComposite[branchComposite]+ if !ok {+ log.Printf("Stream %s has no branch\n", stream.Id)+ http.Error(w, "Stream has no branch", http.StatusInternalServerError)+ return+ }++ apiPlan, ok := apiPlansById[stream.PlanId]+ if !ok {+ log.Printf("Stream %s has no plan\n", stream.Id)+ http.Error(w, "Stream has no plan", http.StatusInternalServerError)+ return+ }++ if !addedBranches[branchComposite] {+ res.Branches = append(res.Branches, apiBranch)+ addedBranches[branchComposite] = true+ }++ res.StreamStartedAtByBranchId[apiBranch.Id] = stream.CreatedAt+ if stream.FinishedAt != nil {+ res.StreamFinishedAtByBranchId[apiBranch.Id] = *stream.FinishedAt+ }+ res.StreamIdByBranchId[apiBranch.Id] = stream.Id++ res.PlansById[stream.PlanId] = apiPlan+ }++ sort.Slice(res.Branches, func(i, j int) bool {+ iComposite := res.Branches[i].PlanId + "|" + res.Branches[i].Name+ jComposite := res.Branches[j].PlanId + "|" + res.Branches[j].Name+ iFinishedAt, iOk := res.StreamFinishedAtByBranchId[iComposite]+ jFinishedAt, jOk := res.StreamFinishedAtByBranchId[jComposite]+ iCreatedAt := res.StreamStartedAtByBranchId[iComposite]+ jCreatedAt := res.StreamStartedAtByBranchId[jComposite]++ if iOk && jOk {+ return iFinishedAt.Before(jFinishedAt) // Sort finished streams by finishedAt in ascending order.+ }+ if iOk {+ return false // Place i after j if i is finished and j is not.+ }+ if jOk {+ return true // Place i before j if i is not finished and j is.+ }+ return iCreatedAt.Before(jCreatedAt) // Sort by createdAt in ascending order if both are unfinished.+ })+ bytes, err := json.Marshal(res)++ if err != nil {+ log.Printf("Error marshalling response: %v\n", err)+ http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)+ return+ }++ log.Println("Successfully processed ListPlansRunningHandler request")++ w.Write(bytes)}func GetCurrentBranchByPlanIdHandler(w http.ResponseWriter, r *http.Request) {@@ -404,8 +537,8 @@ func GetCurrentBranchByPlanIdHandler(w http.ResponseWriter, r *http.Request) {plans, err := db.ListOwnedPlans([]string{projectId}, auth.User.Id, false)if err != nil {- log.Printf("Error listing plan ids: %v\n", err)- http.Error(w, "Error listing plan ids: "+err.Error(), http.StatusInternalServerError)+ log.Printf("Error listing plans: %v\n", err)+ http.Error(w, "Error listing plans: "+err.Error(), http.StatusInternalServerError)return}diff --git a/app/server/handlers/plans_exec.go b/app/server/handlers/plans_exec.goindex ccf19ca1..c584813a 100644--- a/app/server/handlers/plans_exec.go+++ b/app/server/handlers/plans_exec.go@@ -11,6 +11,7 @@ import ("plandex-server/model"modelPlan "plandex-server/model/plan""plandex-server/types"+ "time""github.com/gorilla/mux""github.com/plandex/plandex/shared"@@ -95,11 +96,7 @@ func TellPlanHandler(w http.ResponseWriter, r *http.Request) {}if requestBody.ConnectStream {- active := modelPlan.GetActivePlan(planId, branch)- subscriptionId, ch := modelPlan.SubscribePlan(planId, branch)- startResponseStream(w, ch, active, func() {- modelPlan.UnsubscribePlan(planId, branch, subscriptionId)- })+ startResponseStream(w, auth, planId, branch, false)}log.Println("Successfully processed request for TellPlanHandler")@@ -162,11 +159,7 @@ func BuildPlanHandler(w http.ResponseWriter, r *http.Request) {}if requestBody.ConnectStream {- active := modelPlan.GetActivePlan(planId, branch)- subscriptionId, ch := modelPlan.SubscribePlan(planId, branch)- startResponseStream(w, ch, active, func() {- modelPlan.UnsubscribePlan(planId, branch, subscriptionId)- })+ startResponseStream(w, auth, planId, branch, false)}log.Println("Successfully processed request for BuildPlanHandler")@@ -174,20 +167,43 @@ func BuildPlanHandler(w http.ResponseWriter, r *http.Request) {func ConnectPlanHandler(w http.ResponseWriter, r *http.Request) {log.Println("Received request for ConnectPlanHandler")- auth := authenticate(w, r, true)- if auth == nil {- return- }vars := mux.Vars(r)planId := vars["planId"]-+ branch := vars["branch"]log.Println("planId: ", planId)+ log.Println("branch: ", branch)+ active := modelPlan.GetActivePlan(planId, branch)+ isProxy := r.URL.Query().Get("proxy") == "true"- if authorizePlan(w, planId, auth) == nil {+ if active == nil {+ if isProxy {+ log.Println("No active plan on proxied request")+ http.Error(w, "No active plan", http.StatusNotFound)+ return+ }++ log.Println("No active plan -- proxying request")++ proxyActivePlanMethod(w, r, planId, branch, "connect")return}+ auth := authenticate(w, r, true)+ if auth == nil {+ log.Println("No auth")+ return+ }++ plan := authorizePlan(w, planId, auth)+ if plan == nil {+ log.Println("No plan")+ return+ }++ startResponseStream(w, auth, planId, branch, true)++ log.Println("Successfully processed request for ConnectPlanHandler")}func StopPlanHandler(w http.ResponseWriter, r *http.Request) {@@ -199,8 +215,14 @@ func StopPlanHandler(w http.ResponseWriter, r *http.Request) {log.Println("planId: ", planId)log.Println("branch: ", branch)active := modelPlan.GetActivePlan(planId, branch)+ isProxy := r.URL.Query().Get("proxy") == "true"if active == nil {+ if isProxy {+ log.Println("No active plan on proxied request")+ http.Error(w, "No active plan", http.StatusNotFound)+ return+ }proxyActivePlanMethod(w, r, planId, branch, "stop")return}@@ -214,6 +236,16 @@ func StopPlanHandler(w http.ResponseWriter, r *http.Request) {return}+ log.Println("Sending stream aborted message to client")++ active.Stream(shared.StreamMessage{+ Type: shared.StreamMessageAborted,+ })++ // give some time for stream message to be processed before canceling+ log.Println("Sleeping for 100ms before canceling")+ time.Sleep(100 * time.Millisecond)+var err errorctx, cancel := context.WithCancel(context.Background())unlockFn := lockRepo(w, r, auth, db.LockScopeWrite, ctx, cancel)@@ -223,6 +255,7 @@ func StopPlanHandler(w http.ResponseWriter, r *http.Request) {defer (*unlockFn)(err)}+ log.Println("Stopping plan")err = modelPlan.Stop(planId, branch, auth.User.Id, auth.OrgId)if err != nil {@@ -242,9 +275,16 @@ func RespondMissingFileHandler(w http.ResponseWriter, r *http.Request) {branch := vars["branch"]log.Println("planId: ", planId)log.Println("branch: ", branch)+ isProxy := r.URL.Query().Get("proxy") == "true"active := modelPlan.GetActivePlan(planId, branch)if active == nil {+ if isProxy {+ log.Println("No active plan on proxied request")+ http.Error(w, "No active plan", http.StatusNotFound)+ return+ }+proxyActivePlanMethod(w, r, planId, branch, "respond_missing_file")return}diff --git a/app/server/handlers/proxy_helper.go b/app/server/handlers/proxy_helper.goindex 51b45c13..0c1d4f10 100644--- a/app/server/handlers/proxy_helper.go+++ b/app/server/handlers/proxy_helper.go@@ -8,6 +8,8 @@ import ("os""plandex-server/db""plandex-server/host"++ "github.com/plandex/plandex/shared")func proxyActivePlanMethod(w http.ResponseWriter, r *http.Request, planId, branch, method string) {@@ -27,13 +29,23 @@ func proxyActivePlanMethod(w http.ResponseWriter, r *http.Request, planId, brancif modelStream.InternalIp == host.Ip {// No active plan for this plan or else we wouldn't be calling proxyActivePlanMethod -- set the model stream to finished because something went wrong- db.SetModelStreamFinished(modelStream.Id)+ err := db.SetModelStreamFinished(modelStream.Id)+ if err != nil {+ log.Printf("Error setting model stream %s to finished: %v\n", modelStream.Id, err)+ }++ err = db.SetPlanStatus(planId, branch, shared.PlanStatusError, "No active stream for plan")+ if err != nil {+ log.Printf("Error setting plan %s status to error: %v\n", planId, err)+ }+log.Printf("No active plan for plan %s\n", planId)http.Error(w, "No active plan for plan", http.StatusNotFound)return} else {log.Printf("Forwarding request to %s\n", modelStream.InternalIp)proxyUrl := fmt.Sprintf("http://%s:%s/plans/%s/%s/%s", modelStream.InternalIp, os.Getenv("EXTERNAL_PORT"), planId, branch, method)+ proxyUrl += "?proxy=true"proxyRequest(w, r, proxyUrl)return}diff --git a/app/server/handlers/stream_helper.go b/app/server/handlers/stream_helper.goindex b3a23d24..16399f9a 100644--- a/app/server/handlers/stream_helper.go+++ b/app/server/handlers/stream_helper.go@@ -2,28 +2,30 @@ package handlersimport ("encoding/json"+ "fmt""log""net/http"+ "plandex-server/db"+ modelPlan "plandex-server/model/plan""plandex-server/types"+ "time""github.com/plandex/plandex/shared")-func startResponseStream(w http.ResponseWriter, ch chan string, active *types.ActivePlan, closeFn func()) {+func startResponseStream(w http.ResponseWriter, auth *types.ServerAuth, planId, branch string, isConnect bool) {log.Println("Response stream manager: starting plan stream")+ active := modelPlan.GetActivePlan(planId, branch)+w.Header().Set("Transfer-Encoding", "chunked")w.Header().Set("Content-Type", "text/plain; charset=utf-8")- defer func() {- log.Println("Response stream manager: plan stream done")- closeFn()- }()-// send initial message to clientmsg := shared.StreamMessage{Type: shared.StreamMessageStart,}+bytes, err := json.Marshal(msg)if err != nil {@@ -31,11 +33,35 @@ func startResponseStream(w http.ResponseWriter, ch chan string, active *types.Acreturn}+ log.Println("Response stream manager: sending initial message")err = sendStreamMessage(w, active, string(bytes))if err != nil {+ log.Println("Response stream manager: error sending initial message:", err)return}+ if isConnect {+ time.Sleep(100 * time.Millisecond)+ err = initConnectActive(auth, planId, branch, w)++ if err != nil {+ log.Println("Response stream manager: error initializing connection to active plan:", err)+ return+ }+ }++ subscriptionId, ch := modelPlan.SubscribePlan(planId, branch)+ defer func() {+ log.Println("Response stream manager: client stream closed")+ modelPlan.UnsubscribePlan(planId, branch, subscriptionId)+ }()++ if isConnect {+ time.Sleep(50 * time.Millisecond)+ } else {+ time.Sleep(100 * time.Millisecond)+ }+for {select {case <-active.Ctx.Done():@@ -54,16 +80,114 @@ func startResponseStream(w http.ResponseWriter, ch chan string, active *types.Acfunc sendStreamMessage(w http.ResponseWriter, active *types.ActivePlan, msg string) error {bytes := []byte(msg + shared.STREAM_MESSAGE_SEPARATOR)++ // log.Printf("Response stream manager: writing message to client: %s\n", msg)+_, err := w.Write(bytes)if err != nil {- log.Printf("Response stream mananger: error writing to client: %v\n", err)- if !active.IsBackground && active.NumSubscribers() == 1 {- active.CancelFn()- }+ log.Printf("Response stream manager: error writing to client: %v\n", err)return err- }- if flusher, ok := w.(http.Flusher); ok {+ } else if flusher, ok := w.(http.Flusher); ok {flusher.Flush()}return nil}++func initConnectActive(auth *types.ServerAuth, planId, branch string, w http.ResponseWriter) error {+ log.Println("Response stream manager: initializing connection to active plan")++ active := modelPlan.GetActivePlan(planId, branch)++ msg := shared.StreamMessage{+ Type: shared.StreamMessageConnectActive,+ }++ if active.Prompt != "" && !active.BuildOnly {+ msg.InitPrompt = active.Prompt+ }++ if active.BuildOnly {+ msg.InitBuildOnly = true+ }++ if len(active.StoredReplyIds) > 0 {+ convo, err := db.GetPlanConvo(auth.OrgId, active.Id)+ if err != nil {+ return fmt.Errorf("error getting plan convo: %v", err)+ }++ convoMsgById := map[string]*db.ConvoMessage{}+ for _, convoMsg := range convo {+ convoMsgById[convoMsg.Id] = convoMsg+ }++ for _, replyId := range active.StoredReplyIds {+ if convoMsg, ok := convoMsgById[replyId]; ok {+ msg.InitReplies = append(msg.InitReplies, convoMsg.Message)+ }+ }+ }++ if active.CurrentReplyContent != "" {+ msg.InitReplies = append(msg.InitReplies, active.CurrentReplyContent)+ }++ if active.MissingFilePath != "" {+ msg.MissingFilePath = active.MissingFilePath+ }++ bytes, err := json.Marshal(msg)++ if err != nil {+ return fmt.Errorf("error marshalling message: %v", err)+ }++ log.Println("Response stream manager: sending connect message")+ err = sendStreamMessage(w, active, string(bytes))++ if err != nil {+ return fmt.Errorf("error sending connect message: %v", err)+ }++ // if we're connecting to an active stream and there are active builds, send initial build info+ if len(active.BuildQueuesByPath) > 0 {++ for path, queue := range active.BuildQueuesByPath {+ buildInfo := shared.BuildInfo{Path: path}++ for _, build := range queue {+ if build.BuildFinished() {+ buildInfo.NumTokens = 0+ buildInfo.Finished = true+ } else {+ tokens, err := shared.GetNumTokens(build.Buffer)+ if err != nil {+ return fmt.Errorf("error getting tokens for build with ReplyId %s: %v", build.ReplyId, err)+ }+ buildInfo.Finished = false+ buildInfo.NumTokens += tokens+ }+ }++ msg := shared.StreamMessage{+ Type: shared.StreamMessageBuildInfo,+ BuildInfo: &buildInfo,+ }+ bytes, err := json.Marshal(msg)++ if err != nil {+ return fmt.Errorf("error marshalling message: %v", err)+ }++ err = sendStreamMessage(w, active, string(bytes))++ if err != nil {+ return fmt.Errorf("error sending message: %v", err)+ }++ }++ }++ return nil+}diff --git a/app/server/model/plan/activate.go b/app/server/model/plan/activate.goindex 44ab6343..d450ed24 100644--- a/app/server/model/plan/activate.go+++ b/app/server/model/plan/activate.go@@ -37,7 +37,7 @@ func activatePlan(client *openai.Client, plan *db.Plan, branch string, auth *typInternalIp: host.Ip,Branch: branch,}- err = db.StoreModelStream(modelStream, active.ModelStreamCtx, active.CancelModelStreamFn)+ err = db.StoreModelStream(modelStream, active.Ctx, active.CancelFn)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 streamlog.Printf("Error storing model stream: %v\n", err)diff --git a/app/server/model/plan/build_finish.go b/app/server/model/plan/build_finish.goindex 7e3d044a..7c5e9caa 100644--- a/app/server/model/plan/build_finish.go+++ b/app/server/model/plan/build_finish.go@@ -43,6 +43,8 @@ func (state *activeBuildStreamFileState) onFinishBuild() {return}+ log.Println("Locking repo for finished build")+repoLockId, err := db.LockRepo(db.LockRepoParams{OrgId: currentOrgId,@@ -96,6 +98,13 @@ func (state *activeBuildStreamFileState) onFinishBuild() {return fmt.Errorf("error getting pending build descriptions: %v", err)}+ var unbuiltDescs []*db.ConvoMessageDescription+ for _, desc := range planDescs {+ if !desc.DidBuild {+ unbuiltDescs = append(unbuiltDescs, desc)+ }+ }+// get fresh current plan statevar currentPlan *shared.CurrentPlanStatecurrentPlan, err = db.GetCurrentPlanState(db.CurrentPlanStateParams{@@ -109,7 +118,7 @@ func (state *activeBuildStreamFileState) onFinishBuild() {}descErrCh := make(chan error)- for _, desc := range planDescs {+ for _, desc := range unbuiltDescs {if len(desc.Files) > 0 {desc.DidBuild = true}@@ -126,7 +135,7 @@ func (state *activeBuildStreamFileState) onFinishBuild() {}(desc)}- for range planDescs {+ for range unbuiltDescs {err = <-descErrChif err != nil {log.Printf("Error storing description: %v\n", err)diff --git a/app/server/model/plan/build_stream.go b/app/server/model/plan/build_stream.goindex 8f2d545b..db7d033d 100644--- a/app/server/model/plan/build_stream.go+++ b/app/server/model/plan/build_stream.go@@ -95,32 +95,27 @@ func (fileState *activeBuildStreamFileState) listenStream(stream *openai.ChatComvar content stringdelta := response.Choices[0].Delta- if len(delta.ToolCalls) == 0 {- log.Println("Stream chunk missing function call. Response:")- spew.Dump(response)-- fileState.onBuildFileError(fmt.Errorf("stream chunk missing function call. Reason: %s, File: %s", choice.FinishReason, filePath))- return- }+ if len(delta.ToolCalls) > 0 {+ content = delta.ToolCalls[0].Function.Arguments- content = delta.ToolCalls[0].Function.Arguments- buildInfo := &shared.BuildInfo{- Path: filePath,- NumTokens: 1,- Finished: false,- }+ buildInfo := &shared.BuildInfo{+ Path: filePath,+ NumTokens: 1,+ Finished: false,+ }- // log.Printf("%s: %s", filePath, content)- activePlan.Stream(shared.StreamMessage{- Type: shared.StreamMessageBuildInfo,- BuildInfo: buildInfo,- })+ // log.Printf("%s: %s", filePath, content)+ activePlan.Stream(shared.StreamMessage{+ Type: shared.StreamMessageBuildInfo,+ BuildInfo: buildInfo,+ })- fileState.buffer += content+ fileState.buffer += content+ }var streamed types.StreamedReplacementserr = json.Unmarshal([]byte(fileState.buffer), &streamed)- if err == nil && len(streamed.Replacements) > 0 {+ if err == nil {log.Printf("File %s: Parsed streamed replacements\n", filePath)spew.Dump(streamed)@@ -163,6 +158,13 @@ func (fileState *activeBuildStreamFileState) listenStream(stream *openai.ChatComfileState.onFinishBuildFile(planFileResult)return+ } else if len(delta.ToolCalls) == 0 {+ log.Println("Stream chunk missing function call. Response:")+ spew.Dump(response)+ spew.Dump(fileState)++ fileState.onBuildFileError(fmt.Errorf("stream chunk missing function call. Reason: %s, File: %s", choice.FinishReason, filePath))+ return}}}diff --git a/app/server/model/plan/state.go b/app/server/model/plan/state.goindex 697280ac..adff1995 100644--- a/app/server/model/plan/state.go+++ b/app/server/model/plan/state.go@@ -88,16 +88,18 @@ func SubscribePlan(planId, branch string) (string, chan string) {}func UnsubscribePlan(planId, branch, subscriptionId string) {- log.Printf("Unsubscribing from plan %s\n", planId)+ log.Printf("UnsubscribePlan %s - %s - %s\n", planId, branch, subscriptionId)active := GetActivePlan(planId, branch)if active == nil {+ log.Printf("No active plan found for plan ID %s on branch %s\n", planId, branch)return}UpdateActivePlan(planId, branch, func(activePlan *types.ActivePlan) {activePlan.Unsubscribe(subscriptionId)+ log.Printf("Unsubscribed from plan %s - %s - %s\n", planId, branch, subscriptionId)})}diff --git a/app/server/model/plan/stop.go b/app/server/model/plan/stop.goindex 8568b7ca..a63fb511 100644--- a/app/server/model/plan/stop.go+++ b/app/server/model/plan/stop.go@@ -3,9 +3,7 @@ package planimport ("fmt""plandex-server/db"- "time"- "github.com/plandex/plandex/shared""github.com/sashabaranov/go-openai")@@ -16,13 +14,6 @@ func Stop(planId, branch, currentUserId, currentOrgId string) error {return fmt.Errorf("no active plan with id %s", planId)}- active.Stream(shared.StreamMessage{- Type: shared.StreamMessageAborted,- })-- // give some time for stream message to be processed before canceling- time.Sleep(100 * time.Millisecond)-active.CancelFn()if !active.BuildOnly && !active.RepliesFinished {diff --git a/app/server/model/plan/tell_load.go b/app/server/model/plan/tell_load.goindex e2f2ed24..06ec7653 100644--- a/app/server/model/plan/tell_load.go+++ b/app/server/model/plan/tell_load.go@@ -37,8 +37,8 @@ func (state *activeTellStreamState) loadTellPlan() error {PlanId: planId,Branch: branch,Scope: lockScope,- Ctx: active.ModelStreamCtx,- CancelFn: active.CancelModelStreamFn,+ Ctx: active.Ctx,+ CancelFn: active.CancelFn,},)@@ -144,6 +144,9 @@ func (state *activeTellStreamState) loadTellPlan() error {return}convo = res+ UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {+ ap.MessageNum = len(convo)+ })promptTokens, err := shared.GetNumTokens(req.Prompt)if err != nil {diff --git a/app/server/model/plan/tell_stream.go b/app/server/model/plan/tell_stream.goindex 15cf0e9a..05b45fcd 100644--- a/app/server/model/plan/tell_stream.go+++ b/app/server/model/plan/tell_stream.go@@ -10,6 +10,7 @@ import ("strings""time"+ "github.com/davecgh/go-spew/spew""github.com/plandex/plandex/shared""github.com/sashabaranov/go-openai")@@ -138,7 +139,7 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionSt})}- log.Println("Locking repo for assistant reply and description")+ log.Println("Locking repo to store assistant reply and description")repoLockId, err := db.LockRepo(db.LockRepoParams{@@ -200,6 +201,8 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionSterrCh := make(chan error, 2)go func() {+ log.Println("getting description for assistant message: ", assistantMsg.Id)+if len(replyFiles) == 0 {description = &db.ConvoMessageDescription{OrgId: currentOrgId,@@ -209,6 +212,7 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionStMadePlan: false,}} else {+ log.Println("Generating plan description")description, err = genPlanDescription(client, settings.ModelSet.CommitMsg, planId, branch, active.Ctx)if err != nil {state.onError(fmt.Errorf("failed to generate plan description: %v", err), true, assistantMsg.Id, convoCommitMsg)@@ -222,6 +226,7 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionStdescription.Files = replyFiles}+ log.Println("Storing description")err = db.StoreDescription(description)if err != nil {@@ -230,6 +235,9 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionStreturn}+ log.Println("Description stored")+ spew.Dump(description)+errCh <- nil}()@@ -295,10 +303,24 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionStlog.Printf("Won't continue plan. Build finished: %v\n", buildFinished)if buildFinished {+ log.Println("Plan is finished")active.Stream(shared.StreamMessage{Type: shared.StreamMessageFinished,})} else {+ log.Println("Plan is still building")+ log.Println("Updating status to building")+ err := db.SetPlanStatus(planId, branch, shared.PlanStatusBuilding, "")+ if err != nil {+ log.Printf("Error setting plan status to building: %v\n", err)+ active.StreamDoneCh <- &shared.ApiError{+ Type: shared.ApiErrorTypeOther,+ Status: http.StatusInternalServerError,+ Msg: "Error setting plan status to building",+ }+ return+ }+log.Println("Sending RepliesFinished stream message")active.Stream(shared.StreamMessage{Type: shared.StreamMessageRepliesFinished,@@ -341,8 +363,6 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionStReplyChunk: content,})- // log.Printf("content: %s\n", content)-replyParser.AddChunk(content, true)parserRes := replyParser.Read()files := parserRes.Files@@ -364,7 +384,7 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionSt// attempting to overwrite a file that isn't in context// we will stop the stream and ask the user what to do- err := db.SetPlanStatus(planId, branch, shared.PlanStatusPrompting, "")+ err := db.SetPlanStatus(planId, branch, shared.PlanStatusMissingFile, "")if err != nil {log.Printf("Error setting plan %s status to prompting: %v\n", planId, err)@@ -376,6 +396,10 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionStreturn}+ UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {+ ap.MissingFilePath = currentFile+ })+log.Printf("Prompting user for missing file: %s\n", currentFile)active.Stream(shared.StreamMessage{@@ -393,12 +417,22 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionStlog.Printf("Stopped stream for missing file: %s\n", currentFile)// wait for user response to come in- userChoice := <-active.MissingFileResponseCh+ var userChoice shared.RespondMissingFileChoice+ select {+ case <-active.Ctx.Done():+ log.Println("Context cancelled while waiting for missing file response")+ return+ case userChoice = <-active.MissingFileResponseCh:+ }log.Printf("User choice for missing file: %s\n", userChoice)active.ResetModelCtx()+ UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {+ ap.MissingFilePath = ""+ })+log.Println("Continuing stream")// continue plan@@ -502,6 +536,7 @@ func (state *activeTellStreamState) storeAssistantReply() (*db.ConvoMessage, strUpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {ap.MessageNum = num+ ap.StoredReplyIds = append(ap.StoredReplyIds, replyId)})return &assistantMsg, commitMsg, errdiff --git a/app/server/types/active_plan.go b/app/server/types/active_plan.goindex feb4b33c..27dc7239 100644--- a/app/server/types/active_plan.go+++ b/app/server/types/active_plan.go@@ -3,8 +3,10 @@ package typesimport ("context""encoding/json"+ "log""net/http""plandex-server/db"+ "sync""time""github.com/google/uuid"@@ -22,6 +24,15 @@ type ActiveBuild struct {Error error}+type subscription struct {+ ch chan string+ ctx context.Context+ cancelFn context.CancelFunc+ mu sync.Mutex // Protects the messageQueue+ messageQueue []string+ cond *sync.Cond // Used to wait for and signal new messages+}+type ActivePlan struct {Id stringCurrentStreamingReplyId string@@ -45,12 +56,14 @@ type ActivePlan struct {RepliesFinished boolStreamDoneCh chan *shared.ApiErrorModelStreamId string- IsBackground bool+ MissingFilePath stringMissingFileResponseCh chan shared.RespondMissingFileChoiceAllowOverwritePaths map[string]boolSkippedPaths map[string]bool+ StoredReplyIds []stringstreamCh chan string- subscriptions map[string]chan string+ subscriptions map[string]*subscription+ subscriptionMu sync.Mutex}func NewActivePlan(planId, branch, prompt string, buildOnly bool) *ActivePlan {@@ -78,18 +91,30 @@ func NewActivePlan(planId, branch, prompt string, buildOnly bool) *ActivePlan {AllowOverwritePaths: map[string]bool{},SkippedPaths: map[string]bool{},streamCh: make(chan string),- subscriptions: map[string]chan string{},+ subscriptions: map[string]*subscription{},+ subscriptionMu: sync.Mutex{},}go func() {+ defer func() {+ log.Println("ActivePlan stream manager returned")+ if r := recover(); r != nil {+ log.Printf("Recovered in send to subscriber: %v\n", r)+ }+ }()for {select {case <-active.Ctx.Done():returncase msg := <-active.streamCh:- for _, ch := range active.subscriptions {- ch <- msg+ var subscriptions map[string]*subscription+ active.subscriptionMu.Lock()+ subscriptions = active.subscriptions+ active.subscriptionMu.Unlock()+ for _, sub := range subscriptions {+ sub.enqueueMessage(msg)}+}}}()@@ -107,6 +132,9 @@ func (ap *ActivePlan) Stream(msg shared.StreamMessage) {}return}++ // log.Printf("ActivePlan: sending stream message: %s\n", string(msgJson))+ap.streamCh <- string(msgJson)if msg.Type == shared.StreamMessageFinished {@@ -139,20 +167,81 @@ func (ap *ActivePlan) PathFinished(path string) bool {}func (ap *ActivePlan) Subscribe() (string, chan string) {+ ap.subscriptionMu.Lock()+ defer ap.subscriptionMu.Unlock()id := uuid.New().String()- ch := make(chan string)- ap.subscriptions[id] = ch- return id, ch+ sub := newSubscription()+ ap.subscriptions[id] = sub+ return id, sub.ch}func (ap *ActivePlan) Unsubscribe(id string) {- delete(ap.subscriptions, id)+ ap.subscriptionMu.Lock()+ defer ap.subscriptionMu.Unlock()++ sub, ok := ap.subscriptions[id]++ if ok {+ sub.cancelFn()+ sub.cond.Signal()+ delete(ap.subscriptions, id)+ }}func (ap *ActivePlan) NumSubscribers() int {+ ap.subscriptionMu.Lock()+ defer ap.subscriptionMu.Unlock()return len(ap.subscriptions)}func (b *ActiveBuild) BuildFinished() bool {return b.Success || b.Error != nil}++func newSubscription() *subscription {+ ctx, cancel := context.WithCancel(context.Background())+ sub := &subscription{+ ch: make(chan string),+ ctx: ctx,+ cancelFn: cancel,+ messageQueue: make([]string, 0),+ }+ sub.mu = sync.Mutex{}+ sub.cond = sync.NewCond(&sub.mu)+ go sub.processMessages()+ return sub+}++func (sub *subscription) processMessages() {+ for {+ sub.mu.Lock()+ for len(sub.messageQueue) == 0 {+ sub.cond.Wait() // Automatically unlocks sub.mu and waits; re-locks sub.mu upon waking.+ if sub.ctx.Err() != nil { // Check if context is cancelled after waking up.+ sub.mu.Unlock()+ return+ }+ }+ // At this point, there is at least one message in the queue+ msg := sub.messageQueue[0]+ sub.messageQueue = sub.messageQueue[1:]+ sub.mu.Unlock()++ select {+ case <-sub.ctx.Done():+ log.Println("ActivePlan: subscription context done, aborting send")+ return+ case sub.ch <- msg:+ // Message sent, proceed to next+ }+ }+}++// Adding a message to the subscription's queue+func (sub *subscription) enqueueMessage(msg string) {+ // log.Printf("ActivePlan: enqueueing message: %s\n", msg)+ sub.mu.Lock()+ sub.messageQueue = append(sub.messageQueue, msg)+ sub.mu.Unlock()+ sub.cond.Signal() // Signal the waiting goroutine that a new message is available+}diff --git a/app/shared/data_models.go b/app/shared/data_models.goindex eb215ed4..aa88db5b 100644--- a/app/shared/data_models.go+++ b/app/shared/data_models.go@@ -39,19 +39,6 @@ type Project struct {LastActivePlanId string `json:"lastActivePlanId"`}-type PlanStatus string--const (- PlanStatusDraft PlanStatus = "draft"- PlanStatusReplying PlanStatus = "replying"- PlanStatusDescribing PlanStatus = "describing"- PlanStatusBuilding PlanStatus = "building"- PlanStatusPrompting PlanStatus = "prompting"- PlanStatusFinished PlanStatus = "finished"- PlanStatusStopped PlanStatus = "stopped"- PlanStatusError PlanStatus = "error"-)-type Plan struct {Id string `json:"id"`OwnerId string `json:"ownerId"`@@ -67,6 +54,7 @@ type Plan struct {type Branch struct {Id string `json:"id"`+ PlanId string `json:"planId"`OwnerId string `json:"ownerId"`ParentBranchId *string `json:"parentBranchId"`Name string `json:"name"`@@ -200,8 +188,6 @@ type OrgRole struct {Description string `json:"description"`}-type ModelProvider string-type BaseModelConfig struct {Provider ModelProvider `json:"provider"`BaseUrl string `json:"baseUrl"`@@ -218,8 +204,6 @@ type TaskModelConfig struct {OpenAIResponseFormat *openai.ChatCompletionResponseFormat `json:"openAIResponseFormat"`}-type ModelRole string-type ModelRoleConfig struct {Role ModelRole `json:"role"`BaseModelConfig BaseModelConfig `json:"baseModelConfig"`diff --git a/app/shared/go.mod b/app/shared/go.modindex 0f2f656f..9d17a3f6 100644--- a/app/shared/go.mod+++ b/app/shared/go.mod@@ -2,18 +2,15 @@ module sharedgo 1.21.3-require github.com/pkoukk/tiktoken-go v0.1.6-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+ github.com/davecgh/go-spew v1.1.1+ github.com/pkoukk/tiktoken-go v0.1.6)+require github.com/mattn/go-runewidth v0.0.9 // indirect+require (github.com/dlclark/regexp2 v1.10.0 // indirect- github.com/fatih/color v1.16.0github.com/google/uuid v1.3.0 // indirectgithub.com/olekukonko/tablewriter v0.0.5github.com/sashabaranov/go-openai v1.19.4diff --git a/app/shared/go.sum b/app/shared/go.sumindex 0f7fa300..ef86e107 100644--- a/app/shared/go.sum+++ b/app/shared/go.sum@@ -2,15 +2,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97cgithub.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=@@ -23,9 +16,5 @@ 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_pending_summary.go b/app/shared/plan_result_pending_summary.goindex 4a97c2d4..eca3c14e 100644--- a/app/shared/plan_result_pending_summary.go+++ b/app/shared/plan_result_pending_summary.go@@ -30,6 +30,9 @@ func (state *CurrentPlanState) PendingChangesSummary() string {byDescs := map[string]*changeset{}for _, result := range state.PlanResult.Results {+ // log.Println("result:")+ // spew.Dump(result)+convoIds := map[string]bool{}if descByConvoMessageId[result.ConvoMessageId] != nil {convoIds[result.ConvoMessageId] = true@@ -49,9 +52,11 @@ func (state *CurrentPlanState) PendingChangesSummary() string {ch := byDescs[composite]ch.results = append(byDescs[composite].results, result)+ // log.Println("uniqueConvoIds:", uniqueConvoIds)+for _, convoMessageId := range uniqueConvoIds {if desc, ok := descByConvoMessageId[convoMessageId]; ok {- if !ch.descsSet[convoMessageId] {+ if !ch.descsSet[convoMessageId] && !desc.DidBuild {ch.descs = append(ch.descs, desc)ch.descsSet[convoMessageId] = true}@@ -81,11 +86,14 @@ func (state *CurrentPlanState) PendingChangesSummary() string {var descMsgs []stringif len(ch.descs) == 0 {- descMsgs = append(descMsgs, " βοΈ Changes")- } else {- for _, desc := range ch.descs {- descMsgs = append(descMsgs, fmt.Sprintf(" βοΈ %s", desc.CommitMsg))- }+ // log.Println("Warning: no descriptions for changeset")+ // spew.Dump(ch)+ continue+ // descMsgs = append(descMsgs, " βοΈ Changes")+ }++ for _, desc := range ch.descs {+ descMsgs = append(descMsgs, fmt.Sprintf(" βοΈ %s", desc.CommitMsg))}pendingNewFilesSet := make(map[string]bool)diff --git a/app/shared/plan_settings.go b/app/shared/plan_settings.goindex c669912b..5a017a87 100644--- a/app/shared/plan_settings.go+++ b/app/shared/plan_settings.go@@ -1,7 +1,11 @@package shared+type ModelProvider string+const ModelProviderOpenAI ModelProvider = "openai"+type ModelRole string+const (ModelRolePlanner ModelRole = "planner"ModelRolePlanSummary ModelRole = "summarizer"diff --git a/app/shared/plan_status.go b/app/shared/plan_status.gonew file mode 100644index 00000000..fe002b24--- /dev/null+++ b/app/shared/plan_status.go@@ -0,0 +1,14 @@+package shared++type PlanStatus string++const (+ PlanStatusDraft PlanStatus = "draft"+ PlanStatusReplying PlanStatus = "replying"+ PlanStatusDescribing PlanStatus = "describing"+ PlanStatusBuilding PlanStatus = "building"+ PlanStatusMissingFile PlanStatus = "missingFile"+ PlanStatusFinished PlanStatus = "finished"+ PlanStatusStopped PlanStatus = "stopped"+ PlanStatusError PlanStatus = "error"+)diff --git a/app/shared/req_res.go b/app/shared/req_res.goindex a59c67fb..58bddbc6 100644--- a/app/shared/req_res.go+++ b/app/shared/req_res.go@@ -1,5 +1,7 @@package shared+import "time"+type StartTrialResponse struct {UserId string `json:"userId"`Token string `json:"token"`@@ -89,6 +91,14 @@ type GetCurrentBranchByPlanIdRequest struct {CurrentBranchByPlanId map[string]string `json:"currentBranchByPlanId"`}+type ListPlansRunningResponse struct {+ Branches []*Branch `json:"branches"`+ StreamStartedAtByBranchId map[string]time.Time `json:"streamStartedAtByBranchId"`+ StreamFinishedAtByBranchId map[string]time.Time `json:"streamFinishedAtByBranchId"`+ StreamIdByBranchId map[string]string `json:"streamIdByBranchId"`+ PlansById map[string]*Plan `json:"plansById"`+}+type BuildMode stringconst (diff --git a/app/shared/stream.go b/app/shared/stream.goindex 11ab7352..5a3dc2e1 100644--- a/app/shared/stream.go+++ b/app/shared/stream.go@@ -12,6 +12,7 @@ type StreamMessageType stringconst (StreamMessageStart StreamMessageType = "start"+ StreamMessageConnectActive StreamMessageType = "connectActive"StreamMessageReply StreamMessageType = "reply"StreamMessageDescribing StreamMessageType = "describing"StreamMessageRepliesFinished StreamMessageType = "repliesFinished"@@ -32,4 +33,8 @@ type StreamMessage struct {Error *ApiError `json:"error,omitempty"`MissingFilePath string `json:"missingFilePath,omitempty"`ModelStreamId string `json:"modelStreamId,omitempty"`++ InitPrompt string `json:"initPrompt,omitempty"`+ InitReplies []string `json:"initReplies,omitempty"`+ InitBuildOnly bool `json:"initBuildOnly,omitempty"`}