Skip to content

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

background streams and various fixes

Dane Schneiderd67f7bf5803b
diff --git a/app/cli/api/methods.go b/app/cli/api/methods.go
index 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.Ap
return 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.Api
apiErr := 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, onStre
if 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, onSt
if 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) *s
if 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.go
index a5fa7de7..f75d2d6e 100644
--- a/app/cli/cmd/apply.go
+++ b/app/cli/cmd/apply.go
@@ -12,6 +12,7 @@ var autoConfirm bool
func 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.go
index 744f7c67..a201227f 100644
--- a/app/cli/cmd/build.go
+++ b/app/cli/cmd/build.go
@@ -22,7 +22,7 @@ var buildBg bool
var 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.go
new file mode 100644
index 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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 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")
+ 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.go
new file mode 100644
index 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.go
index 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.CurrentPlanFiles
planResByPath := currentPlanState.PlanResult.FileResultsByPath
diff --git a/app/cli/main.go b/app/cli/main.go
index 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 file
log.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.go
index 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.go
index 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.go
index 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 quit
select {}
diff --git a/app/cli/term/term.go b/app/cli/term/term.go
index 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.go
index 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.go
index 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 []*Branch
err := 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.go
index 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.go
index 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.go
index 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.OrgId
userId := params.UserId
planId := 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 timeout
if numRetry > 20 {
@@ -219,7 +225,7 @@ func lockRepo(params LockRepoParams, numRetry int) (string, error) {
return
default:
- _, 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.go
index 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 context
for {
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.go
index 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) *type
permissionsMap[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.go
index 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.go
index 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.go
index 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.go
index 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 error
ctx, 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.go
index 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, branc
if 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.go
index b3a23d24..16399f9a 100644
--- a/app/server/handlers/stream_helper.go
+++ b/app/server/handlers/stream_helper.go
@@ -2,28 +2,30 @@ package handlers
import (
"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 client
msg := 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.Ac
return
}
+ 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.Ac
func 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.go
index 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 *typ
InternalIp: 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 stream
log.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.go
index 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 state
var currentPlan *shared.CurrentPlanState
currentPlan, 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 = <-descErrCh
if 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.go
index 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.ChatCom
var content string
delta := 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.StreamedReplacements
err = 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.ChatCom
fileState.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.go
index 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.go
index 8568b7ca..a63fb511 100644
--- a/app/server/model/plan/stop.go
+++ b/app/server/model/plan/stop.go
@@ -3,9 +3,7 @@ package plan
import (
"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.go
index 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.go
index 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.ChatCompletionSt
errCh := 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.ChatCompletionSt
MadePlan: 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.ChatCompletionSt
description.Files = replyFiles
}
+ log.Println("Storing description")
err = db.StoreDescription(description)
if err != nil {
@@ -230,6 +235,9 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionSt
return
}
+ log.Println("Description stored")
+ spew.Dump(description)
+
errCh <- nil
}()
@@ -295,10 +303,24 @@ func (state *activeTellStreamState) listenStream(stream *openai.ChatCompletionSt
log.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.ChatCompletionSt
ReplyChunk: 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.ChatCompletionSt
return
}
+ 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.ChatCompletionSt
log.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, str
UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
ap.MessageNum = num
+ ap.StoredReplyIds = append(ap.StoredReplyIds, replyId)
})
return &assistantMsg, commitMsg, err
diff --git a/app/server/types/active_plan.go b/app/server/types/active_plan.go
index feb4b33c..27dc7239 100644
--- a/app/server/types/active_plan.go
+++ b/app/server/types/active_plan.go
@@ -3,8 +3,10 @@ package types
import (
"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 string
CurrentStreamingReplyId string
@@ -45,12 +56,14 @@ type ActivePlan struct {
RepliesFinished bool
StreamDoneCh chan *shared.ApiError
ModelStreamId string
- IsBackground bool
+ MissingFilePath string
MissingFileResponseCh chan shared.RespondMissingFileChoice
AllowOverwritePaths map[string]bool
SkippedPaths map[string]bool
+ StoredReplyIds []string
streamCh 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():
return
case 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.go
index 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.mod
index 0f2f656f..9d17a3f6 100644
--- a/app/shared/go.mod
+++ b/app/shared/go.mod
@@ -2,18 +2,15 @@ module shared
go 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.0
github.com/google/uuid v1.3.0 // indirect
github.com/olekukonko/tablewriter v0.0.5
github.com/sashabaranov/go-openai v1.19.4
diff --git a/app/shared/go.sum b/app/shared/go.sum
index 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+rkHYY13jYWTU97c
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0=
github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
-github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
@@ -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.go
index 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 []string
if 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.go
index 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.go
new file mode 100644
index 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.go
index 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 string
const (
diff --git a/app/shared/stream.go b/app/shared/stream.go
index 11ab7352..5a3dc2e1 100644
--- a/app/shared/stream.go
+++ b/app/shared/stream.go
@@ -12,6 +12,7 @@ type StreamMessageType string
const (
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"`
}