Skip to content

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

working on smoother CWD handling

Dane Schneider999eff134e14
diff --git a/app/cli/api/methods.go b/app/cli/api/methods.go
index dfa398a8..a4c562c5 100644
--- a/app/cli/api/methods.go
+++ b/app/cli/api/methods.go
@@ -8,6 +8,7 @@ import (
"log"
"net/http"
"plandex/types"
+ "strings"
"github.com/plandex/plandex/shared"
)
@@ -163,8 +164,13 @@ func (a *Api) RenameProject(projectId string, req shared.RenameProjectRequest) *
return nil
}
-func (a *Api) ListPlans(projectId string) ([]*shared.Plan, *shared.ApiError) {
- serverUrl := fmt.Sprintf("%s/projects/%s/plans", getApiHost(), projectId)
+func (a *Api) ListPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError) {
+ serverUrl := fmt.Sprintf("%s/plans?", getApiHost())
+ parts := []string{}
+ for _, projectId := range projectIds {
+ parts = append(parts, fmt.Sprintf("projectId=%s", projectId))
+ }
+ serverUrl += strings.Join(parts, "&")
resp, err := authenticatedFastClient.Get(serverUrl)
if err != nil {
@@ -179,7 +185,7 @@ func (a *Api) ListPlans(projectId string) ([]*shared.Plan, *shared.ApiError) {
didRefresh, apiErr := refreshTokenIfNeeded(apiErr)
if didRefresh {
- return a.ListPlans(projectId)
+ return a.ListPlans(projectIds)
}
return nil, apiErr
}
@@ -193,52 +199,46 @@ func (a *Api) ListPlans(projectId string) ([]*shared.Plan, *shared.ApiError) {
return plans, nil
}
-func (a *Api) GetCurrentBranchByPlanId(projectId string, req shared.GetCurrentBranchByPlanIdRequest) (map[string]*shared.Branch, *shared.ApiError) {
- serverUrl := fmt.Sprintf("%s/projects/%s/plans/current_branches", getApiHost(), projectId)
-
- reqBytes, err := json.Marshal(req)
- if err != nil {
- return nil, &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
- }
-
- request, err := http.NewRequest(http.MethodPost, serverUrl, bytes.NewBuffer(reqBytes))
-
- if err != nil {
- return nil, &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+func (a *Api) ListArchivedPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError) {
+ serverUrl := fmt.Sprintf("%s/plans/archive?", getApiHost())
+ parts := []string{}
+ for _, projectId := range projectIds {
+ parts = append(parts, fmt.Sprintf("projectId=%s", projectId))
}
+ serverUrl += strings.Join(parts, "&")
- request.Header.Set("Content-Type", "application/json")
-
- resp, err := authenticatedFastClient.Do(request)
-
+ resp, err := authenticatedFastClient.Get(serverUrl)
if err != nil {
- return nil, &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+ return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
}
defer resp.Body.Close()
if resp.StatusCode >= 400 {
errorBody, _ := io.ReadAll(resp.Body)
-
apiErr := handleApiError(resp, errorBody)
-
- didRefresh, apiErr := refreshTokenIfNeeded(apiErr)
- if didRefresh {
- return a.GetCurrentBranchByPlanId(projectId, req)
+ tokenRefreshed, apiErr := refreshTokenIfNeeded(apiErr)
+ if tokenRefreshed {
+ return a.ListArchivedPlans(projectIds)
}
return nil, apiErr
}
- var respBody map[string]*shared.Branch
- err = json.NewDecoder(resp.Body).Decode(&respBody)
+ var plans []*shared.Plan
+ err = json.NewDecoder(resp.Body).Decode(&plans)
if err != nil {
- return nil, &shared.ApiError{Msg: fmt.Sprintf("error decoding response: %v", err)}
+ return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
}
- return respBody, nil
+ return plans, nil
}
-func (a *Api) ListArchivedPlans(projectId string) ([]*shared.Plan, *shared.ApiError) {
- serverUrl := fmt.Sprintf("%s/projects/%s/plans/archive", getApiHost(), projectId)
+func (a *Api) ListPlansRunning(projectIds []string) ([]*shared.Plan, *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, "&")
resp, err := authenticatedFastClient.Get(serverUrl)
if err != nil {
@@ -251,7 +251,7 @@ func (a *Api) ListArchivedPlans(projectId string) ([]*shared.Plan, *shared.ApiEr
apiErr := handleApiError(resp, errorBody)
tokenRefreshed, apiErr := refreshTokenIfNeeded(apiErr)
if tokenRefreshed {
- return a.ListArchivedPlans(projectId)
+ return a.ListPlansRunning(projectIds)
}
return nil, apiErr
}
@@ -265,32 +265,48 @@ func (a *Api) ListArchivedPlans(projectId string) ([]*shared.Plan, *shared.ApiEr
return plans, nil
}
-func (a *Api) ListPlansRunning(projectId string) ([]*shared.Plan, *shared.ApiError) {
- serverUrl := fmt.Sprintf("%s/projects/%s/plans/ps", getApiHost(), projectId)
+func (a *Api) GetCurrentBranchByPlanId(projectId string, req shared.GetCurrentBranchByPlanIdRequest) (map[string]*shared.Branch, *shared.ApiError) {
+ serverUrl := fmt.Sprintf("%s/projects/%s/plans/current_branches", getApiHost(), projectId)
- resp, err := authenticatedFastClient.Get(serverUrl)
+ reqBytes, err := json.Marshal(req)
if err != nil {
- return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+ return nil, &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+ }
+
+ request, err := http.NewRequest(http.MethodPost, serverUrl, bytes.NewBuffer(reqBytes))
+
+ if err != nil {
+ return nil, &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+ }
+
+ request.Header.Set("Content-Type", "application/json")
+
+ resp, err := authenticatedFastClient.Do(request)
+
+ if err != nil {
+ return nil, &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
}
defer resp.Body.Close()
if resp.StatusCode >= 400 {
errorBody, _ := io.ReadAll(resp.Body)
+
apiErr := handleApiError(resp, errorBody)
- tokenRefreshed, apiErr := refreshTokenIfNeeded(apiErr)
- if tokenRefreshed {
- return a.ListPlansRunning(projectId)
+
+ didRefresh, apiErr := refreshTokenIfNeeded(apiErr)
+ if didRefresh {
+ return a.GetCurrentBranchByPlanId(projectId, req)
}
return nil, apiErr
}
- var plans []*shared.Plan
- err = json.NewDecoder(resp.Body).Decode(&plans)
+ var respBody map[string]*shared.Branch
+ 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 nil, &shared.ApiError{Msg: fmt.Sprintf("error decoding response: %v", err)}
}
- return plans, nil
+ return respBody, nil
}
func (a *Api) CreatePlan(projectId string, req shared.CreatePlanRequest) (*shared.CreatePlanResponse, *shared.ApiError) {
diff --git a/app/cli/cmd/cd.go b/app/cli/cmd/cd.go
index 344a4170..2d4b3e4e 100644
--- a/app/cli/cmd/cd.go
+++ b/app/cli/cmd/cd.go
@@ -39,7 +39,7 @@ func cd(cmd *cobra.Command, args []string) {
var plan *shared.Plan
- plans, apiErr := api.Client.ListPlans(lib.CurrentProjectId)
+ plans, apiErr := api.Client.ListPlans([]string{lib.CurrentProjectId})
if apiErr != nil {
fmt.Fprintln(os.Stderr, "Error getting plans:", apiErr.Msg)
diff --git a/app/cli/cmd/delete_plan.go b/app/cli/cmd/delete_plan.go
index 9c8ee805..34887f7f 100644
--- a/app/cli/cmd/delete_plan.go
+++ b/app/cli/cmd/delete_plan.go
@@ -52,7 +52,7 @@ func del(cmd *cobra.Command, args []string) {
}
var plan *shared.Plan
- plans, apiErr := api.Client.ListPlans(lib.CurrentProjectId)
+ plans, apiErr := api.Client.ListPlans([]string{lib.CurrentProjectId})
if apiErr != nil {
fmt.Fprintln(os.Stderr, "Error getting plans:", apiErr.Msg)
diff --git a/app/cli/cmd/new.go b/app/cli/cmd/new.go
index 50b6f0f6..c141ab59 100644
--- a/app/cli/cmd/new.go
+++ b/app/cli/cmd/new.go
@@ -71,11 +71,11 @@ func new(cmd *cobra.Command, args []string) {
}
if name == "" {
- fmt.Println("✅ Started new plan")
- } else {
- fmt.Printf("✅ Started new plan: %s\n", color.New(color.Bold, color.FgHiWhite).Sprint(name))
+ name = "draft"
}
+ fmt.Printf("✅ Started new plan %s and set it to current plan\n", color.New(color.Bold, color.FgHiGreen).Sprint(name))
+
fmt.Println()
term.PrintCmds("", "load", "tell", "plans", "current")
diff --git a/app/cli/cmd/plans.go b/app/cli/cmd/plans.go
index 3160b10e..e157c556 100644
--- a/app/cli/cmd/plans.go
+++ b/app/cli/cmd/plans.go
@@ -33,7 +33,7 @@ func plans(cmd *cobra.Command, args []string) {
auth.MustResolveAuthWithOrg()
lib.MustResolveProject()
- plans, apiErr := api.Client.ListPlans(lib.CurrentProjectId)
+ plans, apiErr := api.Client.ListPlans([]string{lib.CurrentProjectId})
if apiErr != nil {
fmt.Fprintln(os.Stderr, "Error getting plans:", apiErr)
@@ -115,5 +115,6 @@ func plans(cmd *cobra.Command, args []string) {
}
table.Render()
fmt.Println()
+
term.PrintCmds("", "tell", "new", "cd", "delete-plan")
}
diff --git a/app/cli/types/api.go b/app/cli/types/api.go
index a1e059e8..a171db09 100644
--- a/app/cli/types/api.go
+++ b/app/cli/types/api.go
@@ -40,12 +40,12 @@ type ApiClient interface {
SetProjectPlan(projectId string, req shared.SetProjectPlanRequest) *shared.ApiError
RenameProject(projectId string, req shared.RenameProjectRequest) *shared.ApiError
- ListPlans(projectId string) ([]*shared.Plan, *shared.ApiError)
+ ListPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError)
+ ListArchivedPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError)
+ ListPlansRunning(projectIds []string) ([]*shared.Plan, *shared.ApiError)
GetCurrentBranchByPlanId(projectId string, req shared.GetCurrentBranchByPlanIdRequest) (map[string]*shared.Branch, *shared.ApiError)
- ListArchivedPlans(projectId string) ([]*shared.Plan, *shared.ApiError)
- ListPlansRunning(projectId string) ([]*shared.Plan, *shared.ApiError)
GetPlan(planId string) (*shared.Plan, *shared.ApiError)
CreatePlan(projectId string, req shared.CreatePlanRequest) (*shared.CreatePlanResponse, *shared.ApiError)
diff --git a/app/server/db/plan_helpers.go b/app/server/db/plan_helpers.go
index 89cae9aa..ee27e54e 100644
--- a/app/server/db/plan_helpers.go
+++ b/app/server/db/plan_helpers.go
@@ -10,6 +10,7 @@ import (
"time"
"github.com/google/uuid"
+ "github.com/lib/pq"
"github.com/plandex/plandex/shared"
"github.com/sashabaranov/go-openai"
)
@@ -83,9 +84,9 @@ func CreatePlan(orgId, projectId, userId, name string) (*Plan, error) {
return plan, nil
}
-func ListOwnedPlans(projectId, userId string, archived bool) ([]*Plan, error) {
- qs := "SELECT * FROM plans WHERE project_id = $1 AND owner_id = $2"
- qargs := []interface{}{projectId, userId}
+func ListOwnedPlans(projectIds []string, userId string, archived bool) ([]*Plan, error) {
+ qs := "SELECT * FROM plans WHERE project_id = ANY($1) AND owner_id = $2"
+ qargs := []interface{}{pq.Array(projectIds), userId}
if archived {
qs += " AND archived_at IS NOT NULL"
diff --git a/app/server/handlers/plans_crud.go b/app/server/handlers/plans_crud.go
index 83db9160..ee83654f 100644
--- a/app/server/handlers/plans_crud.go
+++ b/app/server/handlers/plans_crud.go
@@ -263,16 +263,23 @@ func ListPlansHandler(w http.ResponseWriter, r *http.Request) {
return
}
- vars := mux.Vars(r)
- projectId := vars["projectId"]
+ projectIds := r.URL.Query()["projectId"]
- log.Println("projectId: ", projectId)
+ log.Println("projectIds: ", projectIds)
- if !authorizeProject(w, projectId, auth) {
+ if len(projectIds) == 0 {
+ log.Println("No project ids provided")
+ http.Error(w, "No project ids provided", http.StatusBadRequest)
return
}
- plans, err := db.ListOwnedPlans(projectId, auth.User.Id, false)
+ for _, projectId := range projectIds {
+ if !authorizeProject(w, projectId, auth) {
+ return
+ }
+ }
+
+ plans, err := db.ListOwnedPlans(projectIds, auth.User.Id, false)
if err != nil {
log.Printf("Error listing plan ids: %v\n", err)
@@ -296,6 +303,81 @@ func ListPlansHandler(w http.ResponseWriter, r *http.Request) {
w.Write(bytes)
}
+func ListArchivedPlansHandler(w http.ResponseWriter, r *http.Request) {
+ log.Println("Received request for ListArchivedPlansHandler")
+ auth := authenticate(w, r, true)
+ if auth == nil {
+ return
+ }
+
+ projectIds := r.URL.Query()["projectId"]
+
+ log.Println("projectIds: ", projectIds)
+
+ if len(projectIds) == 0 {
+ log.Println("No project ids provided")
+ http.Error(w, "No project ids provided", http.StatusBadRequest)
+ return
+ }
+
+ for _, projectId := range projectIds {
+ if !authorizeProject(w, projectId, auth) {
+ return
+ }
+ }
+
+ plans, err := db.ListOwnedPlans(projectIds, "", true)
+
+ if err != nil {
+ log.Printf("Error listing plans: %v\n", err)
+ http.Error(w, "Error listing plans: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ var apiPlans []*shared.Plan
+ for _, plan := range plans {
+ apiPlans = append(apiPlans, plan.ToApi())
+ }
+
+ jsonBytes, err := json.Marshal(apiPlans)
+ if err != nil {
+ log.Printf("Error marshalling plans: %v\n", err)
+ http.Error(w, "Error marshalling plans: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ log.Println("Successfully processed ListArchivedPlansHandler request")
+
+ w.Write(jsonBytes)
+}
+
+func ListPlansRunningHandler(w http.ResponseWriter, r *http.Request) {
+ log.Println("Received request for ListPlansRunningHandler")
+ auth := authenticate(w, r, true)
+ if auth == nil {
+ return
+ }
+
+ projectIds := r.URL.Query()["projectId"]
+
+ log.Println("projectIds: ", projectIds)
+
+ if len(projectIds) == 0 {
+ log.Println("No project ids provided")
+ http.Error(w, "No project ids provided", http.StatusBadRequest)
+ return
+ }
+
+ for _, projectId := range projectIds {
+ if !authorizeProject(w, projectId, auth) {
+ return
+ }
+ }
+
+ // TODO: implement when status is figured out
+
+}
+
func GetCurrentBranchByPlanIdHandler(w http.ResponseWriter, r *http.Request) {
log.Println("Received request for CurrentBranchByPlanIdHandler")
auth := authenticate(w, r, true)
@@ -319,7 +401,7 @@ func GetCurrentBranchByPlanIdHandler(w http.ResponseWriter, r *http.Request) {
return
}
- plans, err := db.ListOwnedPlans(projectId, auth.User.Id, false)
+ plans, err := db.ListOwnedPlans([]string{projectId}, auth.User.Id, false)
if err != nil {
log.Printf("Error listing plan ids: %v\n", err)
@@ -373,64 +455,3 @@ func GetCurrentBranchByPlanIdHandler(w http.ResponseWriter, r *http.Request) {
w.Write(bytes)
}
-
-func ListArchivedPlansHandler(w http.ResponseWriter, r *http.Request) {
- log.Println("Received request for ListArchivedPlansHandler")
- auth := authenticate(w, r, true)
- if auth == nil {
- return
- }
-
- vars := mux.Vars(r)
- projectId := vars["projectId"]
-
- log.Println("projectId: ", projectId)
-
- if !authorizeProject(w, projectId, auth) {
- return
- }
-
- plans, err := db.ListOwnedPlans(projectId, "", true)
-
- if err != nil {
- log.Printf("Error listing plans: %v\n", err)
- http.Error(w, "Error listing plans: "+err.Error(), http.StatusInternalServerError)
- return
- }
-
- var apiPlans []*shared.Plan
- for _, plan := range plans {
- apiPlans = append(apiPlans, plan.ToApi())
- }
-
- jsonBytes, err := json.Marshal(apiPlans)
- if err != nil {
- log.Printf("Error marshalling plans: %v\n", err)
- http.Error(w, "Error marshalling plans: "+err.Error(), http.StatusInternalServerError)
- return
- }
-
- log.Println("Successfully processed ListArchivedPlansHandler request")
-
- w.Write(jsonBytes)
-}
-
-func ListPlansRunningHandler(w http.ResponseWriter, r *http.Request) {
- log.Println("Received request for ListPlansRunningHandler")
- auth := authenticate(w, r, true)
- if auth == nil {
- return
- }
-
- vars := mux.Vars(r)
- projectId := vars["projectId"]
-
- log.Println("projectId: ", projectId)
-
- if !authorizeProject(w, projectId, auth) {
- return
- }
-
- // TODO: implement when status is figured out
-
-}
diff --git a/app/server/routes.go b/app/server/routes.go
index 3c63deb0..89dec3fb 100644
--- a/app/server/routes.go
+++ b/app/server/routes.go
@@ -40,12 +40,11 @@ func routes() *mux.Router {
r.HandleFunc("/projects/{projectId}/set_plan", handlers.ProjectSetPlanHandler).Methods("PUT")
r.HandleFunc("/projects/{projectId}/rename", handlers.RenameProjectHandler).Methods("PUT")
- r.HandleFunc("/projects/{projectId}/plans", handlers.ListPlansHandler).Methods("GET")
-
r.HandleFunc("/projects/{projectId}/plans/current_branches", handlers.GetCurrentBranchByPlanIdHandler).Methods("POST")
- r.HandleFunc("/projects/{projectId}/plans/archive", handlers.ListArchivedPlansHandler).Methods("GET")
- r.HandleFunc("/projects/{projectId}/plans/ps", handlers.ListPlansRunningHandler).Methods("GET")
+ r.HandleFunc("/plans", handlers.ListPlansHandler).Methods("GET")
+ r.HandleFunc("/plans/archive", handlers.ListArchivedPlansHandler).Methods("GET")
+ r.HandleFunc("/plans/ps", handlers.ListPlansRunningHandler).Methods("GET")
r.HandleFunc("/projects/{projectId}/plans", handlers.CreatePlanHandler).Methods("POST")