Skip to content

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

Refactors the model architecture by renaming the context-loader role to architect with expanded responsibilities for high-level planning and design, while also improving CLI functionality with enhanced plan deletion, diff viewing UI, and support for markdown file mapping.

Dane Schneidera579ba1c26bb
diff --git a/app/cli/cmd/delete_plan.go b/app/cli/cmd/delete_plan.go
index 398115ef..8f4e85e8 100644
--- a/app/cli/cmd/delete_plan.go
+++ b/app/cli/cmd/delete_plan.go
@@ -2,6 +2,7 @@ package cmd
import (
"fmt"
+ "path"
"strconv"
"strings"
@@ -31,35 +32,10 @@ var rmCmd = &cobra.Command{
Run: del,
}
-
-func parseIndices(indexRange string, maxIndex int) map[int]bool {
- indices := make(map[int]bool)
- parts := strings.Split(indexRange, "-")
-
- if len(parts) == 1 {
- // Single index
- idx, err := strconv.Atoi(parts[0])
- if err == nil && idx > 0 && idx <= maxIndex {
- indices[idx-1] = true
- }
- } else if len(parts) == 2 {
- // Range of indices
- start, err1 := strconv.Atoi(parts[0])
- end, err2 := strconv.Atoi(parts[1])
- if err1 == nil && err2 == nil && start > 0 && end <= maxIndex && start <= end {
- for i := start - 1; i < end; i++ {
- indices[i] = true
- }
- }
- }
-
- return indices
-}
-
func matchPlansByPattern(pattern string, plans []*shared.Plan) []*shared.Plan {
var matched []*shared.Plan
for _, plan := range plans {
- if matched, _ := path.Match(pattern, plan.Name); matched {
+ if isMatched, err := path.Match(pattern, plan.Name); err == nil && isMatched {
matched = append(matched, plan)
}
}
@@ -115,9 +91,13 @@ func del(cmd *cobra.Command, args []string) {
// Check if it's a range of indices
if strings.Contains(nameOrPattern, "-") {
- indices := parseIndices(nameOrPattern, len(plans))
+ // Create single-element slice with the range pattern
+ rangeArgs := []string{nameOrPattern}
+ indices := parseIndices(rangeArgs)
for idx := range indices {
- plansToDelete = append(plansToDelete, plans[idx])
+ if idx >= 0 && idx < len(plans) {
+ plansToDelete = append(plansToDelete, plans[idx])
+ }
}
} else if strings.Contains(nameOrPattern, "*") {
// Wildcard pattern matching
diff --git a/app/cli/cmd/diffs.go b/app/cli/cmd/diffs.go
index f3ad7caf..e57f6fa7 100644
--- a/app/cli/cmd/diffs.go
+++ b/app/cli/cmd/diffs.go
@@ -6,6 +6,7 @@ import (
"html/template"
"net"
"net/http"
+ "os"
"plandex/api"
"plandex/auth"
"plandex/lib"
@@ -52,66 +53,122 @@ func diffs(cmd *cobra.Command, args []string) {
}
if showDiffUi {
- outputFormat := "line-by-line"
- if diffUiSideBySide {
- outputFormat = "side-by-side"
- } else if diffUiLineByLine {
- outputFormat = "line-by-line"
+ getNewListener := func() net.Listener {
+ outputFormat := "line-by-line"
+ if diffUiSideBySide {
+ outputFormat = "side-by-side"
+ } else if diffUiLineByLine {
+ outputFormat = "line-by-line"
+ }
+
+ // Properly escape the diff content for JavaScript
+ diffJSON, err := json.Marshal(diffs)
+ if err != nil {
+ term.OutputErrorAndExit("Error encoding diff content: %v", err)
+ }
+
+ // Create template data
+ data := struct {
+ DiffContent template.JS
+ OutputFormat string
+ }{
+ DiffContent: template.JS(diffJSON),
+ OutputFormat: outputFormat,
+ }
+
+ // Parse and execute the template
+ tmpl, err := template.New("diff").Parse(htmlTemplate)
+ if err != nil {
+ term.OutputErrorAndExit("Error parsing template: %v", err)
+ }
+
+ // Use :0 to let the OS pick an available port
+ listener, err := net.Listen("tcp", ":0")
+ if err != nil {
+ term.OutputErrorAndExit("Error starting server: %v", err)
+ }
+
+ // Get the actual port chosen
+ port := listener.Addr().(*net.TCPAddr).Port
+
+ // Start web server
+ go func() {
+ http.HandleFunc("/"+outputFormat, func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ err := tmpl.Execute(w, data)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+ })
+ http.Serve(listener, nil)
+ }()
+
+ ui.OpenURL("Showing diffs in your default browser...", fmt.Sprintf("http://localhost:%d/%s", port, outputFormat))
+
+ fmt.Println()
+
+ return listener
}
- // Properly escape the diff content for JavaScript
- diffJSON, err := json.Marshal(diffs)
- if err != nil {
- term.OutputErrorAndExit("Error encoding diff content: %v", err)
- return
- }
-
- // Create template data
- data := struct {
- DiffContent template.JS
- OutputFormat string
- }{
- DiffContent: template.JS(diffJSON),
- OutputFormat: outputFormat,
- }
-
- // Parse and execute the template
- tmpl, err := template.New("diff").Parse(htmlTemplate)
- if err != nil {
- term.OutputErrorAndExit("Error parsing template: %v", err)
- return
- }
-
- // Use :0 to let the OS pick an available port
- listener, err := net.Listen("tcp", ":0")
- if err != nil {
- term.OutputErrorAndExit("Error starting server: %v", err)
- return
- }
+ listener := getNewListener()
defer listener.Close()
- // Get the actual port chosen
- port := listener.Addr().(*net.TCPAddr).Port
-
- // Start web server
- go func() {
- http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
- w.Header().Set("Content-Type", "text/html; charset=utf-8")
- err := tmpl.Execute(w, data)
+ var relaunch bool
+
+ for {
+ if relaunch {
+ listener.Close()
+ listener = getNewListener()
+ defer listener.Close()
+ relaunch = false
+ }
+
+ if diffUiLineByLine {
+ fmt.Printf("%s for side-by-side view\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(s)"))
+ } else {
+ fmt.Printf("%s for line-by-line view\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(l)"))
+ }
+
+ fmt.Printf("%s for git diff format\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(g)"))
+ fmt.Printf("%s to continue\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("Enter"))
+
+ color.New(term.ColorHiMagenta, color.Bold).Print("Press a hotkey or enter to continue πŸ‘‰ ")
+
+ char, key, err := term.GetUserKeyInput()
+ if err != nil {
+ term.OutputErrorAndExit("Error getting key: %v", err)
+ return
+ }
+ fmt.Println()
+
+ if string(char) == "g" {
+ _, err := lib.ExecPlandexCommandWithParams([]string{"diff"}, lib.ExecPlandexCommandParams{
+ DisableSuggestions: true,
+ })
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ term.OutputErrorAndExit("Error showing git diff: %v", err)
}
- })
- http.Serve(listener, nil)
- }()
-
- ui.OpenURL("Showing diffs in your default browser...", fmt.Sprintf("http://localhost:%d", port))
-
- fmt.Println()
- color.New(color.Bold).Println("Press enter to continue")
-
- // Wait for enter key
- fmt.Scanln()
+ } else if string(char) == "s" {
+ diffUiSideBySide = true
+ diffUiLineByLine = false
+ relaunch = true
+ } else if string(char) == "l" {
+ diffUiSideBySide = false
+ diffUiLineByLine = true
+ relaunch = true
+ } else if key == 13 || key == 10 || string(char) == "q" { // Check raw key codes for Enter/Return
+ if term.IsRepl {
+ fmt.Println()
+ os.Exit(0)
+ } else {
+ break
+ }
+ } else if string(char) == "\x03" { // Ctrl+C
+ os.Exit(0)
+ } else {
+ term.OutputErrorAndExit("Invalid command: %d | %s", key, string(char))
+ }
+ }
} else {
if plainTextOutput {
fmt.Println(diffs)
diff --git a/app/cli/cmd/model_packs.go b/app/cli/cmd/model_packs.go
index 9769d7a3..3ef7417f 100644
--- a/app/cli/cmd/model_packs.go
+++ b/app/cli/cmd/model_packs.go
@@ -203,8 +203,8 @@ func createModelPack(cmd *cobra.Command, args []string) {
// Selecting models for each role
mp.Planner = getPlannerRoleConfig(customModels)
- contextLoader := getModelRoleConfig(customModels, shared.ModelRoleContextLoader)
- mp.ContextLoader = &contextLoader
+ contextLoader := getModelRoleConfig(customModels, shared.ModelRoleArchitect)
+ mp.Architect = &contextLoader
coder := getModelRoleConfig(customModels, shared.ModelRoleCoder)
mp.Coder = &coder
diff --git a/app/cli/cmd/models.go b/app/cli/cmd/models.go
index eaed8588..da56ed00 100644
--- a/app/cli/cmd/models.go
+++ b/app/cli/cmd/models.go
@@ -481,7 +481,7 @@ func renderSettings(settings *shared.PlanSettings) {
})
}
- addModelRow(string(shared.ModelRoleContextLoader), modelPack.GetContextLoader())
+ addModelRow(string(shared.ModelRoleArchitect), modelPack.GetArchitect())
addModelRow(string(shared.ModelRoleCoder), modelPack.GetCoder())
addModelRow(string(shared.ModelRolePlanSummary), modelPack.PlanSummary)
addModelRow(string(shared.ModelRoleBuilder), modelPack.Builder)
diff --git a/app/cli/cmd/plans.go b/app/cli/cmd/plans.go
index db4ab8d8..ca205e49 100644
--- a/app/cli/cmd/plans.go
+++ b/app/cli/cmd/plans.go
@@ -168,6 +168,8 @@ func listActive() {
}
childProjectIdsWithPaths = childProjectIdsWithPathsFiltered
+ var b strings.Builder
+
if len(currentProjectPlanIds) > 0 {
currentBranchNamesByPlanId, err := lib.GetCurrentBranchNamesByPlanId(currentProjectPlanIds)
@@ -183,15 +185,15 @@ func listActive() {
term.OutputErrorAndExit("Error getting current branches: %v", apiErr)
}
- table := tablewriter.NewWriter(os.Stdout)
+ table := tablewriter.NewWriter(&b)
table.SetAutoWrapText(false)
table.SetHeader([]string{"#", "Name", "Updated" /*, "Created" /*"Branches",*/, "Branch", "Context", "Convo"})
currentProjectPlans := plansByProjectId[lib.CurrentProjectId]
if len(parentProjectIdsWithPaths) > 0 || len(childProjectIdsWithPaths) > 0 {
- color.New(color.Bold, term.ColorHiGreen).Print("Plans in current directory\n")
+ b.WriteString(color.New(color.Bold, term.ColorHiGreen).Sprint("Plans in current directory\n"))
} else {
- fmt.Println()
+ b.WriteString("\n")
}
for i, p := range currentProjectPlans {
num := strconv.Itoa(i + 1)
@@ -236,7 +238,7 @@ func listActive() {
table.Render()
} else {
- fmt.Println("πŸ€·β€β™‚οΈ No plans in current directory")
+ b.WriteString("πŸ€·β€β™‚οΈ No plans in current directory\n")
}
var addPathToTreeFn func(tree treeprint.Tree, basePath, localPath, projectId string, isParent bool)
@@ -300,10 +302,10 @@ func listActive() {
}
if len(parentProjectIdsWithPaths) > 0 {
- fmt.Println()
+ b.WriteString("\n")
- color.New(color.Bold).Println("Plans in parent directories")
- color.New(c).Println("cd into a directory to work on a plan in that directory")
+ b.WriteString(color.New(color.Bold).Sprint("Plans in parent directories\n"))
+ b.WriteString(color.New(c).Sprint("cd into a directory to work on a plan in that directory\n"))
parentTree := treeprint.NewWithRoot("~")
for i := len(parentProjectIdsWithPaths) - 1; i >= 0; i-- {
@@ -317,13 +319,13 @@ func listActive() {
addPathToTreeFn(parentTree, "", rel, p[1], true)
}
- fmt.Print(parentTree.String())
+ b.WriteString(parentTree.String())
}
if len(childProjectIdsWithPaths) > 0 {
- fmt.Println()
- color.New(color.Bold).Println("Plans in child directories")
- color.New(c).Println("cd into a directory to work on a plan in that directory")
+ b.WriteString("\n")
+ b.WriteString(color.New(color.Bold).Sprint("Plans in child directories\n"))
+ b.WriteString(color.New(c).Sprint("cd into a directory to work on a plan in that directory\n"))
childTree := treeprint.New()
for _, p := range childProjectIdsWithPaths {
rel, err := filepath.Rel(fs.Cwd, p[0])
@@ -334,11 +336,13 @@ func listActive() {
addPathToTreeFn(childTree, "", rel, p[1], false)
}
- fmt.Println(childTree.String())
+ b.WriteString(childTree.String())
} else {
- fmt.Println()
+ b.WriteString("\n")
}
+ term.PageOutput(b.String())
+
fmt.Println()
if len(currentProjectPlanIds) > 0 {
term.PrintCmds("", "new", "cd", "delete-plan", "plans --archived", "archive")
@@ -369,7 +373,8 @@ func listArchived() {
return
}
- table := tablewriter.NewWriter(os.Stdout)
+ var b strings.Builder
+ table := tablewriter.NewWriter(&b)
table.SetAutoWrapText(false)
table.SetHeader([]string{"#", "Name", "Updated"})
@@ -401,6 +406,8 @@ func listArchived() {
}
table.Render()
+ term.PageOutput(b.String())
+
fmt.Println()
term.PrintCmds("", "unarchive")
}
diff --git a/app/cli/cmd/set_model.go b/app/cli/cmd/set_model.go
index 77747a99..2b103fa6 100644
--- a/app/cli/cmd/set_model.go
+++ b/app/cli/cmd/set_model.go
@@ -459,13 +459,13 @@ func updateModelSettings(args []string, originalSettings *shared.PlanSettings) *
settings.ModelPack.Planner.ReservedOutputTokens = *reservedOutputTokens
}
- case shared.ModelRoleContextLoader:
+ case shared.ModelRoleArchitect:
if selectedModel != nil {
- settings.ModelPack.ContextLoader.BaseModelConfig = selectedModel.BaseModelConfig
+ settings.ModelPack.Architect.BaseModelConfig = selectedModel.BaseModelConfig
} else if temperature != nil {
- settings.ModelPack.ContextLoader.Temperature = float32(*temperature)
+ settings.ModelPack.Architect.Temperature = float32(*temperature)
} else if topP != nil {
- settings.ModelPack.ContextLoader.TopP = float32(*topP)
+ settings.ModelPack.Architect.TopP = float32(*topP)
}
case shared.ModelRoleCoder:
diff --git a/app/cli/go.mod b/app/cli/go.mod
index a571c723..0fa4e2f6 100644
--- a/app/cli/go.mod
+++ b/app/cli/go.mod
@@ -5,12 +5,11 @@ go 1.23.3
require (
github.com/atotto/clipboard v0.1.4
github.com/charmbracelet/lipgloss v1.0.0
- github.com/davecgh/go-spew v1.1.1
github.com/fatih/color v1.18.0
github.com/muesli/reflow v0.3.0
github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a
github.com/olekukonko/tablewriter v0.0.5
- github.com/plandex-ai/go-prompt v0.0.0-20250130142100-3d8d7ab8d071
+ github.com/plandex-ai/go-prompt v0.0.0-20250207121803-6be77f7193aa
github.com/plandex-ai/survey/v2 v2.3.7
github.com/sashabaranov/go-openai v1.35.6
github.com/shopspring/decimal v1.4.0
@@ -26,6 +25,7 @@ require (
github.com/charmbracelet/x/ansi v0.8.0 // indirect
github.com/charmbracelet/x/term v0.2.1 // indirect
github.com/cqroot/multichoose v0.1.1 // indirect
+ github.com/davecgh/go-spew v1.1.1 // indirect
github.com/dlclark/regexp2 v1.11.4 // indirect
github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
github.com/google/uuid v1.6.0 // indirect
@@ -75,5 +75,3 @@ require (
)
replace github.com/plandex/plandex/shared => ../shared
-
-replace github.com/plandex-ai/go-prompt => ../../../go-prompt
diff --git a/app/cli/go.sum b/app/cli/go.sum
index 32f605e8..54842f02 100644
--- a/app/cli/go.sum
+++ b/app/cli/go.sum
@@ -607,6 +607,8 @@ github.com/pkg/term v1.2.0-beta.2 h1:L3y/h2jkuBVFdWiJvNfYfKmzcCnILw7mJWm2JQuMppw
github.com/pkg/term v1.2.0-beta.2/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw=
github.com/pkoukk/tiktoken-go v0.1.7 h1:qOBHXX4PHtvIvmOtyg1EeKlwFRiMKAcoMp4Q+bLQDmw=
github.com/pkoukk/tiktoken-go v0.1.7/go.mod h1:9NiV+i9mJKGj1rYOT+njbv+ZwA/zJxYdewGl6qVatpg=
+github.com/plandex-ai/go-prompt v0.0.0-20250207121803-6be77f7193aa h1:kBelDvK3qBN8OQ6dtXCWKxtn7DR5H5QSFZbRon/OHRA=
+github.com/plandex-ai/go-prompt v0.0.0-20250207121803-6be77f7193aa/go.mod h1:SqEsJfsIr0GYUyLatvezDOBe6XsCw64E7v33QzeH5PM=
github.com/plandex-ai/survey/v2 v2.3.7 h1:u1o6bflbaBpW8i8krm+91Z2cOcvZcMVS+AjV+rgR8Rk=
github.com/plandex-ai/survey/v2 v2.3.7/go.mod h1:RiBOKRDB5fOQrOzsiAPAN57hYqFKPkCxgSK7twcDOys=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
diff --git a/app/cli/lib/repl.go b/app/cli/lib/repl.go
index deb87552..492979d0 100644
--- a/app/cli/lib/repl.go
+++ b/app/cli/lib/repl.go
@@ -139,6 +139,15 @@ func GetHistory() []string {
// ExecPlandexCommand spawns the same binary, wiring std streams directly so you
// don't have to capture output. Any os.Exit calls in the child won't kill your REPL.
func ExecPlandexCommand(args []string) (string, error) {
+ return ExecPlandexCommandWithParams(args, ExecPlandexCommandParams{})
+}
+
+type ExecPlandexCommandParams struct {
+ Args []string
+ DisableSuggestions bool
+}
+
+func ExecPlandexCommandWithParams(args []string, params ExecPlandexCommandParams) (string, error) {
// Create temp file
tmpFile, err := os.CreateTemp("", "plandex-output-*")
if err != nil {
@@ -148,25 +157,32 @@ func ExecPlandexCommand(args []string) (string, error) {
tmpFile.Close()
defer os.Remove(tmpPath)
- columns := term.GetTerminalWidth()
- hasDarkBackground := term.HasDarkBackground()
- streamForegroundColor := term.GetStreamForegroundColor()
+ var env []string = os.Environ()
+ if os.Getenv("PLANDEX_REPL") == "" {
+ columns := term.GetTerminalWidth()
+ hasDarkBackground := term.HasDarkBackground()
+ streamForegroundColor := term.GetStreamForegroundColor()
+
+ var glamourStyle string
+ if hasDarkBackground {
+ glamourStyle = "dark"
+ } else {
+ glamourStyle = "light"
+ }
- var glamourStyle string
- if hasDarkBackground {
- glamourStyle = "dark"
- } else {
- glamourStyle = "light"
+ // Set env vars
+ env = append(env,
+ "PLANDEX_REPL=1",
+ "PLANDEX_REPL_OUTPUT_FILE="+tmpPath,
+ "PLANDEX_COLUMNS="+strconv.Itoa(columns),
+ "PLANDEX_STREAM_FOREGROUND_COLOR="+streamForegroundColor.Sequence(false),
+ "GLAMOUR_STYLE="+glamourStyle,
+ )
}
- // Set env vars
- env := append(os.Environ(),
- "PLANDEX_REPL=1",
- "PLANDEX_REPL_OUTPUT_FILE="+tmpPath,
- "PLANDEX_COLUMNS="+strconv.Itoa(columns),
- "PLANDEX_STREAM_FOREGROUND_COLOR="+streamForegroundColor.Sequence(false),
- "GLAMOUR_STYLE="+glamourStyle,
- )
+ if params.DisableSuggestions {
+ env = append(env, "PLANDEX_DISABLE_SUGGESTIONS=1")
+ }
// Run command
cmd := exec.Command(os.Args[0], args...)
diff --git a/app/cli/plan_exec/tell.go b/app/cli/plan_exec/tell.go
index 15815415..84775754 100644
--- a/app/cli/plan_exec/tell.go
+++ b/app/cli/plan_exec/tell.go
@@ -7,19 +7,46 @@ import (
"plandex/api"
"plandex/auth"
"plandex/fs"
+ "plandex/lib"
"plandex/stream"
streamtui "plandex/stream_tui"
"plandex/term"
+ "strings"
+
+ "github.com/eiannone/keyboard"
"github.com/fatih/color"
+ "github.com/olekukonko/tablewriter"
"github.com/plandex/plandex/shared"
)
+type hotkeyOption struct {
+ key string
+ command string
+ description string
+ replOnly bool
+ terminalOnly bool
+}
+
+var allHotkeyOptions = []hotkeyOption{
+ {"d", "diff ui", "Review diffs in browser UI", false, false},
+ {"g", "git diff format", "Review diffs in git diff format", false, false},
+ {"a", "apply", "Apply all pending changes", false, false},
+ {"r", "reject", "Reject some or all pending changes", false, false},
+ {"f", "follow up", "Iterate with a follow up prompt", true, false},
+ {"q", "quit", "Back to terminal", false, true},
+ {"q", "quit", "Back to REPL", true, false},
+}
+
func TellPlan(
params ExecParams,
prompt string,
flags TellFlags,
) {
+ // showHotkeyMenu([]string{"a", "r"})
+ // handleHotkey([]string{"a", "r"}, params)
+ // return
+
tellBg := flags.TellBg
tellStop := flags.TellStop
tellNoBuild := flags.TellNoBuild
@@ -175,23 +202,28 @@ func TellPlan(
term.OutputErrorAndExit("Error starting stream UI: %v", err)
}
- diffs, apiErr := api.Client.GetPlanDiffs(params.CurrentPlanId, params.CurrentBranch, true)
+ diffs, apiErr := getDiffs(params)
+ numDiffs := len(diffs)
if apiErr != nil {
term.OutputErrorAndExit("Error getting plan diffs: %v", apiErr.Msg)
return
}
- hasDiffs := len(diffs) > 0
+ hasDiffs := numDiffs > 0
fmt.Println()
if tellStop && !isChatOnly && hasDiffs {
if hasDiffs {
- term.PrintCmds("", "continue", "diff", "diff --ui", "apply", "reject", "log")
+ // term.PrintCmds("", "continue", "diff", "diff --ui", "apply", "reject", "log")
+ showHotkeyMenu(diffs)
+ handleHotkey(diffs, params)
} else {
term.PrintCmds("", "continue", "log")
}
} else if !isDebugCmd && !isChatOnly && hasDiffs {
- term.PrintCmds("", "diff", "diff --ui", "apply", "reject", "log")
+ // term.PrintCmds("", "diff", "diff --ui", "apply", "reject", "log")
+ showHotkeyMenu(diffs)
+ handleHotkey(diffs, params)
} else if isChatOnly {
if !term.IsRepl {
term.PrintCmds("", "tell", "convo", "summary", "log")
@@ -219,3 +251,162 @@ func TellPlan(
<-done
}
}
+
+func showHotkeyMenu(diffs []string) {
+ numDiffs := len(diffs)
+ color.New(color.Bold, term.ColorHiGreen).Printf("🧐 %d files have pending changes\n", numDiffs)
+
+ // for _, diff := range diffs {
+ // fmt.Printf("β€’ %s\n", diff)
+ // }
+
+ fmt.Println()
+
+ var b strings.Builder
+ table := tablewriter.NewWriter(&b)
+ table.SetAutoWrapText(false)
+ table.SetHeaderLine(false)
+ table.SetAlignment(tablewriter.ALIGN_LEFT)
+
+ for _, opt := range allHotkeyOptions {
+ if (opt.terminalOnly && term.IsRepl) || (opt.replOnly && !term.IsRepl) {
+ continue
+ }
+
+ table.Append([]string{
+ color.New(term.ColorHiGreen, color.Bold).Sprintf("(%s)", opt.key),
+ opt.command,
+ opt.description,
+ })
+ }
+
+ table.Render()
+ fmt.Print(b.String())
+ color.New(term.ColorHiMagenta, color.Bold).Printf("Press a hotkey or press %s %s πŸ‘‰ ", color.New(color.FgHiWhite, color.Bold).Sprintf("↓"), color.New(term.ColorHiMagenta, color.Bold).Sprintf("to select"))
+}
+
+func handleHotkey(diffs []string, params ExecParams) {
+ char, key, err := term.GetUserKeyInput()
+ if err != nil {
+ fmt.Printf("\nError getting key: %v\n", err)
+ showHotkeyMenu(diffs)
+ handleHotkey(diffs, params)
+ }
+
+ if key == keyboard.KeyArrowDown {
+ options := []string{}
+ for _, opt := range allHotkeyOptions {
+ if (opt.terminalOnly && term.IsRepl) || (opt.replOnly && !term.IsRepl) {
+ continue
+ }
+
+ options = append(options, opt.description)
+ }
+
+ selected, err := term.SelectFromList(
+ "Select an action",
+ options,
+ )
+ if err != nil {
+ fmt.Printf("\nError selecting action: %v\n", err)
+ showHotkeyMenu(diffs)
+ handleHotkey(diffs, params)
+ }
+
+ if selected != "" {
+ var option hotkeyOption
+ for _, opt := range allHotkeyOptions {
+ if opt.description == selected {
+ if (opt.terminalOnly && term.IsRepl) || (opt.replOnly && !term.IsRepl) {
+ continue
+ }
+
+ option = opt
+ break
+ }
+ }
+
+ handleHotkeyOption(option, diffs, params)
+ }
+ }
+
+ handleHotkeyOption(hotkeyOption{key: string(char)}, diffs, params)
+}
+
+func handleHotkeyOption(option hotkeyOption, diffs []string, params ExecParams) {
+ exitUnlessDiffs := func() {
+ diffs, apiErr := getDiffs(params)
+ if apiErr != nil {
+ fmt.Printf("\nError getting plan diffs: %v\n", apiErr.Msg)
+ os.Exit(0)
+ }
+
+ if len(diffs) == 0 {
+ os.Exit(0)
+ }
+
+ showHotkeyMenu(diffs)
+ handleHotkey(diffs, params)
+ }
+
+ fmt.Println()
+
+ switch option.key {
+ case "d":
+ _, err := lib.ExecPlandexCommandWithParams([]string{"diffs", "--ui"}, lib.ExecPlandexCommandParams{
+ DisableSuggestions: true,
+ })
+ if err != nil {
+ fmt.Printf("\nError showing diffs: %v\n", err)
+ }
+
+ case "g":
+ _, err := lib.ExecPlandexCommandWithParams([]string{"diffs"}, lib.ExecPlandexCommandParams{
+ DisableSuggestions: true,
+ })
+ if err != nil {
+ fmt.Printf("\nError showing diffs: %v\n", err)
+ }
+
+ case "a":
+ _, err := lib.ExecPlandexCommand([]string{"apply"})
+ if err != nil {
+ fmt.Printf("\nError applying changes: %v\n", err)
+ }
+ exitUnlessDiffs()
+
+ case "r":
+ _, err := lib.ExecPlandexCommand([]string{"reject"})
+ if err != nil {
+ fmt.Printf("\nError rejecting changes: %v\n", err)
+ }
+ exitUnlessDiffs()
+
+ case "q":
+ os.Exit(0)
+
+ case "f":
+ if term.IsRepl {
+ color.New(color.Bold).Println("Write a prompt πŸ‘‡")
+ os.Exit(0)
+ } else {
+ term.PrintCmds("", "tell", "chat")
+ os.Exit(0)
+ }
+
+ default:
+ fmt.Println("\nInvalid command")
+ }
+
+ showHotkeyMenu(diffs)
+ handleHotkey(diffs, params)
+}
+
+func getDiffs(params ExecParams) ([]string, *shared.ApiError) {
+ currentPlan, apiErr := api.Client.GetCurrentPlanState(params.CurrentPlanId, params.CurrentBranch)
+ if apiErr != nil {
+ return nil, apiErr
+ }
+
+ return currentPlan.PlanResult.SortedPaths, nil
+}
diff --git a/app/cli/stream_tui/run.go b/app/cli/stream_tui/run.go
index 4b9e34e2..205cfc65 100644
--- a/app/cli/stream_tui/run.go
+++ b/app/cli/stream_tui/run.go
@@ -105,6 +105,7 @@ func StartStreamUI(prompt string, buildOnly bool) error {
log.Println("stream UI - error writing output to repl temp file: ", err)
}
}
+
return nil
}
@@ -120,7 +121,6 @@ func Quit() {
mu.Unlock()
wg.Wait() // Wait for the UI to fully terminate
-
}
func Send(msg shared.StreamMessage) {
diff --git a/app/cli/term/help.go b/app/cli/term/help.go
index 5e062cbc..013b84a8 100644
--- a/app/cli/term/help.go
+++ b/app/cli/term/help.go
@@ -37,6 +37,7 @@ var CliCommands = []CmdConfig{
{"rm", "", "remove context by index, range, name, or glob", true},
{"clear", "", "remove all context", true},
{"update", "u", "update outdated context", true},
+ {"show", "", "show current context by name or index", true},
{"changes", "", "review pending changes in a TUI", false},
{"diff", "", "review pending changes in 'git diff' format", true},
diff --git a/app/server/db/context_helpers.go b/app/server/db/context_helpers.go
index 857defec..3a02cfe9 100644
--- a/app/server/db/context_helpers.go
+++ b/app/server/db/context_helpers.go
@@ -469,7 +469,7 @@ func LoadContexts(ctx Ctx, params LoadContextsParams) (*shared.LoadContextRespon
}
plannerMaxTokens := settings.GetPlannerEffectiveMaxTokens()
- contextLoaderMaxTokens := settings.GetContextLoaderEffectiveMaxTokens()
+ contextLoaderMaxTokens := settings.GetArchitectEffectiveMaxTokens()
mapContextsByFilePath := make(map[string]Context)
@@ -728,7 +728,7 @@ func UpdateContexts(params UpdateContextsParams) (*shared.UpdateContextResponse,
}
plannerMaxTokens := settings.GetPlannerEffectiveMaxTokens()
- contextLoaderMaxTokens := settings.GetContextLoaderEffectiveMaxTokens()
+ contextLoaderMaxTokens := settings.GetArchitectEffectiveMaxTokens()
if planConfig.AutoLoadContext {
existingContexts, err := GetPlanContexts(orgId, planId, false, false)
diff --git a/app/server/db/data_models.go b/app/server/db/data_models.go
index 78165f1b..f5d4fb80 100644
--- a/app/server/db/data_models.go
+++ b/app/server/db/data_models.go
@@ -295,34 +295,34 @@ type repoLock struct {
}
type ModelPack struct {
- Id string `db:"id"`
- OrgId string `db:"org_id"`
- Name string `db:"name"`
- Description string `db:"description"`
- Planner shared.PlannerRoleConfig `db:"planner"`
- Coder *shared.ModelRoleConfig `db:"coder"`
- PlanSummary shared.ModelRoleConfig `db:"plan_summary"`
- Builder shared.ModelRoleConfig `db:"builder"`
- Namer shared.ModelRoleConfig `db:"namer"`
- CommitMsg shared.ModelRoleConfig `db:"commit_msg"`
- ExecStatus shared.ModelRoleConfig `db:"exec_status"`
- ContextLoader *shared.ModelRoleConfig `db:"context_loader"`
- CreatedAt time.Time `db:"created_at"`
+ Id string `db:"id"`
+ OrgId string `db:"org_id"`
+ Name string `db:"name"`
+ Description string `db:"description"`
+ Planner shared.PlannerRoleConfig `db:"planner"`
+ Coder *shared.ModelRoleConfig `db:"coder"`
+ PlanSummary shared.ModelRoleConfig `db:"plan_summary"`
+ Builder shared.ModelRoleConfig `db:"builder"`
+ Namer shared.ModelRoleConfig `db:"namer"`
+ CommitMsg shared.ModelRoleConfig `db:"commit_msg"`
+ ExecStatus shared.ModelRoleConfig `db:"exec_status"`
+ Architect *shared.ModelRoleConfig `db:"context_loader"`
+ CreatedAt time.Time `db:"created_at"`
}
func (modelPack *ModelPack) ToApi() *shared.ModelPack {
return &shared.ModelPack{
- Id: modelPack.Id,
- Name: modelPack.Name,
- Description: modelPack.Description,
- Planner: modelPack.Planner,
- ContextLoader: modelPack.ContextLoader,
- Coder: modelPack.Coder,
- PlanSummary: modelPack.PlanSummary,
- Builder: modelPack.Builder,
- Namer: modelPack.Namer,
- CommitMsg: modelPack.CommitMsg,
- ExecStatus: modelPack.ExecStatus,
+ Id: modelPack.Id,
+ Name: modelPack.Name,
+ Description: modelPack.Description,
+ Planner: modelPack.Planner,
+ Architect: modelPack.Architect,
+ Coder: modelPack.Coder,
+ PlanSummary: modelPack.PlanSummary,
+ Builder: modelPack.Builder,
+ Namer: modelPack.Namer,
+ CommitMsg: modelPack.CommitMsg,
+ ExecStatus: modelPack.ExecStatus,
}
}
diff --git a/app/server/db/models.go b/app/server/db/models.go
index 965a6a81..afbacf8f 100644
--- a/app/server/db/models.go
+++ b/app/server/db/models.go
@@ -46,7 +46,7 @@ func CreateModelPack(ms *ModelPack) error {
query := `INSERT INTO model_sets (org_id, name, description, planner, plan_summary, builder, namer, commit_msg, exec_status, context_loader, coder) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
RETURNING id, created_at`
- err := Conn.QueryRow(query, ms.OrgId, ms.Name, ms.Description, ms.Planner, ms.PlanSummary, ms.Builder, ms.Namer, ms.CommitMsg, ms.ExecStatus, ms.ContextLoader, ms.Coder).Scan(&ms.Id, &ms.CreatedAt)
+ err := Conn.QueryRow(query, ms.OrgId, ms.Name, ms.Description, ms.Planner, ms.PlanSummary, ms.Builder, ms.Namer, ms.CommitMsg, ms.ExecStatus, ms.Architect, ms.Coder).Scan(&ms.Id, &ms.CreatedAt)
if err != nil {
return fmt.Errorf("error inserting new model pack: %v", err)
diff --git a/app/server/handlers/client_helper.go b/app/server/handlers/client_helper.go
index fe4448d4..9661fb9d 100644
--- a/app/server/handlers/client_helper.go
+++ b/app/server/handlers/client_helper.go
@@ -102,8 +102,8 @@ func initClients(params initClientsParams) map[string]model.ClientInfo {
continue
}
- if planSettings.ModelPack.GetContextLoader().BaseModelConfig.ApiKeyEnvVar == envVar {
- endpointsByApiKeyEnvVar[envVar] = planSettings.ModelPack.GetContextLoader().BaseModelConfig.BaseUrl
+ if planSettings.ModelPack.GetArchitect().BaseModelConfig.ApiKeyEnvVar == envVar {
+ endpointsByApiKeyEnvVar[envVar] = planSettings.ModelPack.GetArchitect().BaseModelConfig.BaseUrl
continue
}
diff --git a/app/server/handlers/models.go b/app/server/handlers/models.go
index a902d3a2..1e3110e8 100644
--- a/app/server/handlers/models.go
+++ b/app/server/handlers/models.go
@@ -104,16 +104,16 @@ func CreateModelPackHandler(w http.ResponseWriter, r *http.Request) {
}
dbMs := &db.ModelPack{
- OrgId: auth.OrgId,
- Name: ms.Name,
- Description: ms.Description,
- PlanSummary: ms.PlanSummary,
- Builder: ms.Builder,
- Namer: ms.Namer,
- CommitMsg: ms.CommitMsg,
- ExecStatus: ms.ExecStatus,
- ContextLoader: ms.ContextLoader,
- Coder: ms.Coder,
+ OrgId: auth.OrgId,
+ Name: ms.Name,
+ Description: ms.Description,
+ PlanSummary: ms.PlanSummary,
+ Builder: ms.Builder,
+ Namer: ms.Namer,
+ CommitMsg: ms.CommitMsg,
+ ExecStatus: ms.ExecStatus,
+ Architect: ms.Architect,
+ Coder: ms.Coder,
}
if err := db.CreateModelPack(dbMs); err != nil {
diff --git a/app/server/model/plan/build_load.go b/app/server/model/plan/build_load.go
index 93c7c91a..866a07d2 100644
--- a/app/server/model/plan/build_load.go
+++ b/app/server/model/plan/build_load.go
@@ -4,7 +4,6 @@ import (
"fmt"
"log"
"net/http"
- "path/filepath"
"plandex-server/db"
"plandex-server/syntax"
"plandex-server/types"
@@ -134,8 +133,7 @@ func (state *activeBuildStreamFileState) loadBuildFile(activeBuild *types.Active
convoMessageId := activeBuild.ReplyId
- ext := filepath.Ext(filePath)
- parser, lang, fallbackParser, fallbackLang := syntax.GetParserForExt(ext)
+ parser, lang, fallbackParser, fallbackLang := syntax.GetParserForPath(filePath)
if parser != nil {
validationRes, err := syntax.ValidateWithParsers(activePlan.Ctx, lang, parser, fallbackLang, fallbackParser, state.preBuildState)
diff --git a/app/server/model/plan/build_state.go b/app/server/model/plan/build_state.go
index 1f0d295b..baf3e119 100644
--- a/app/server/model/plan/build_state.go
+++ b/app/server/model/plan/build_state.go
@@ -33,7 +33,7 @@ type activeBuildStreamFileState struct {
activeBuild *types.ActiveBuild
preBuildState string
parser *sitter.Parser
- language shared.TreeSitterLanguage
+ language shared.Language
syntaxCheckTimedOut bool
preBuildStateSyntaxInvalid bool
structuredEditNumRetry int
diff --git a/app/server/model/plan/tell_exec.go b/app/server/model/plan/tell_exec.go
index cd72a7a4..77745ec0 100644
--- a/app/server/model/plan/tell_exec.go
+++ b/app/server/model/plan/tell_exec.go
@@ -279,7 +279,7 @@ func execTellPlan(params execTellPlanParams) {
modelConfig = plannerConfig.ModelRoleConfig
if isContextStage {
log.Println("Tell plan - isContextStage - setting modelConfig to context loader")
- modelConfig = state.settings.ModelPack.GetContextLoader().GetRoleForInputTokens(requestTokens)
+ modelConfig = state.settings.ModelPack.GetArchitect().GetRoleForInputTokens(requestTokens)
}
} else if isImplementationStage {
modelConfig = state.settings.ModelPack.GetCoder().GetRoleForInputTokens(requestTokens)
diff --git a/app/server/model/prompts/context_load.go b/app/server/model/prompts/context_load.go
index f9721ee6..a9d164e4 100644
--- a/app/server/model/prompts/context_load.go
+++ b/app/server/model/prompts/context_load.go
@@ -1,6 +1,14 @@
package prompts
const AutoContextTellPreamble = `
+You are an expert architect. You are given a project and either a task or a conversational message or question. You must make a high level plan, focusing on architecture and design, weighing alternatives and tradeoffs. Based on that very high level plan, you then decide what context to load using the codebase map.
+
+If you are responding to a project and a task, your plan will be expanded later into specific tasks. For now, paint in broad strokes and focus more on consideration of different potential approached, important tradeoffs, and potential pitfalls/gaps/unforeseen complexities. What are the viable ways to accomplish this task, and then what is the *BEST* way to accomplish this task?
+
+Your high level plan should also be succint. Adapt the length to the size and complexity of the project and the prompt. For simple tasks, a few sentences are sufficient. For complex tasks, a few paragraphs are appropriate. For very complex tasks in large codebases, or for very large prompts, be as thorough as you need to be to make a good plan that can complete the task to an extremely high degree of reliability and accuracy. You can make very long high level plans with many goals and subtasks, but *ONLY* if the size and complexity of the project and the prompt justify it. Your DEFAULT should be *brevity* and *conciseness*. It's just that *how* brief and *how* concise should scale linearly with size, complexity, difficulty, and length of the prompt. If you can make a strong plan in very few words or sentences, do so.
+
+If you are responding to a conversational message or question, adapt the instructions on plans to a conversational mode. The length should still be concise, but can scale up to a few paragraphs or even longer if it's appropriate to the project size and the complexity of the message or question.
+
[CONTEXT INSTRUCTIONS:]
You are operating in 'auto-context mode' for implementation. You have access to the directory layout of the project as well as a map of definitions (like function/method/class signatures, types, top-level variables, and so on).
diff --git a/app/server/syntax/comments.go b/app/server/syntax/comments.go
index 8dd816e2..d2f4bfe7 100644
--- a/app/server/syntax/comments.go
+++ b/app/server/syntax/comments.go
@@ -3,7 +3,6 @@ package syntax
import (
"context"
"fmt"
- "path/filepath"
"sort"
"github.com/plandex/plandex/shared"
@@ -12,8 +11,7 @@ import (
// StripComments removes all comments from the given source code using the appropriate parser
func StripComments(ctx context.Context, path, source string) (string, error) {
- ext := filepath.Ext(path)
- parser, _, _, _ := GetParserForExt(ext)
+ parser, _, _, _ := GetParserForPath(path)
// If no parser is available, return the source as is
if parser == nil {
@@ -60,21 +58,21 @@ func findCommentNodes(node *tree_sitter.Node) []*tree_sitter.Node {
return commentNodes
}
-func GetCommentSymbols(lang shared.TreeSitterLanguage) (string, string) {
+func GetCommentSymbols(lang shared.Language) (string, string) {
switch lang {
- case shared.TreeSitterLanguageC, shared.TreeSitterLanguageCpp, shared.TreeSitterLanguageCsharp, shared.TreeSitterLanguageJava, shared.TreeSitterLanguageJavascript, shared.TreeSitterLanguageGo, shared.TreeSitterLanguageRust, shared.TreeSitterLanguageSwift, shared.TreeSitterLanguageKotlin, shared.TreeSitterLanguageGroovy, shared.TreeSitterLanguageScala, shared.TreeSitterLanguageTypescript, shared.TreeSitterLanguagePhp:
+ case shared.LanguageC, shared.LanguageCpp, shared.LanguageCsharp, shared.LanguageJava, shared.LanguageJavascript, shared.LanguageGo, shared.LanguageRust, shared.LanguageSwift, shared.LanguageKotlin, shared.LanguageGroovy, shared.LanguageScala, shared.LanguageTypescript, shared.LanguagePhp:
return "//", ""
- case shared.TreeSitterLanguageBash, shared.TreeSitterLanguageDockerfile, shared.TreeSitterLanguageElixir, shared.TreeSitterLanguageHcl, shared.TreeSitterLanguagePython, shared.TreeSitterLanguageRuby, shared.TreeSitterLanguageToml, shared.TreeSitterLanguageYaml:
+ case shared.LanguageBash, shared.LanguageDockerfile, shared.LanguageElixir, shared.LanguageHcl, shared.LanguagePython, shared.LanguageRuby, shared.LanguageToml, shared.LanguageYaml:
return "#", ""
- case shared.TreeSitterLanguageLua, shared.TreeSitterLanguageElm:
+ case shared.LanguageLua, shared.LanguageElm:
return "--", ""
- case shared.TreeSitterLanguageCss:
+ case shared.LanguageCss:
return "/*", "*/"
- case shared.TreeSitterLanguageHtml:
+ case shared.LanguageHtml:
return "<!--", "-->"
- case shared.TreeSitterLanguageOCaml:
+ case shared.LanguageOCaml:
return "(*", "*)"
- case shared.TreeSitterLanguageSvelte, shared.TreeSitterLanguageJsx, shared.TreeSitterLanguageTsx, shared.TreeSitterLanguageJson:
+ case shared.LanguageSvelte, shared.LanguageJsx, shared.LanguageTsx, shared.LanguageJson:
return "", "" // comments are either not allowed or correct symbols depend on the context
}
diff --git a/app/server/syntax/file_map/map.go b/app/server/syntax/file_map/map.go
index 05724160..f5bf1c3d 100644
--- a/app/server/syntax/file_map/map.go
+++ b/app/server/syntax/file_map/map.go
@@ -31,35 +31,45 @@ type Definition struct {
type Node struct {
Type string
- Lang shared.TreeSitterLanguage
+ Lang shared.Language
TsNode *tree_sitter.Node
Bytes []byte
}
func MapFile(ctx context.Context, filename string, content []byte) (*FileMap, error) {
- // Get appropriate parser
- var parser *tree_sitter.Parser
- var lang shared.TreeSitterLanguage
- var fallbackParser *tree_sitter.Parser
- var fallbackLang shared.TreeSitterLanguage
+ if !shared.HasFileMapSupport(filename) {
+ return nil, fmt.Errorf("unsupported file type: %s", filename)
+ }
- file := filepath.Base(filename)
- if strings.Contains(strings.ToLower(file), "dockerfile") {
- lang = shared.TreeSitterLanguageDockerfile
- parser = syntax.GetParserForLanguage(lang)
+ lang := syntax.GetLanguageForPath(filename)
+ ext := filepath.Ext(filename)
- if parser == nil {
- return nil, fmt.Errorf("no parser found for dockerfile")
- }
- } else {
- ext := filepath.Ext(filename)
- parser, lang, fallbackParser, fallbackLang = syntax.GetParserForExt(ext)
+ if lang == "" {
+ return nil, fmt.Errorf("unsupported file type: %s", ext)
+ }
- if parser == nil {
+ if !shared.IsTreeSitterLanguage(lang) {
+ switch lang {
+ case shared.LanguageMarkdown:
+ return &FileMap{
+ Definitions: mapMarkdownSimple(content),
+ }, nil
+ default:
return nil, fmt.Errorf("unsupported file type: %s", ext)
}
}
+ // Get appropriate parser
+ var parser *tree_sitter.Parser
+ var fallbackParser *tree_sitter.Parser
+ var fallbackLang shared.Language
+
+ parser, lang, fallbackParser, fallbackLang = syntax.GetParserForPath(filename)
+
+ if parser == nil {
+ return nil, fmt.Errorf("unsupported file type: %s", ext)
+ }
+
// Parse file
tree, err := parser.ParseCtx(ctx, nil, content)
if err != nil {
@@ -87,11 +97,11 @@ func MapFile(ctx context.Context, filename string, content []byte) (*FileMap, er
}
-func mapNode(node *tree_sitter.Node, content []byte, lang shared.TreeSitterLanguage) []Definition {
+func mapNode(node *tree_sitter.Node, content []byte, lang shared.Language) []Definition {
switch lang {
- case shared.TreeSitterLanguageHtml:
+ case shared.LanguageHtml:
return mapMarkup(content)
- case shared.TreeSitterLanguageSvelte:
+ case shared.LanguageSvelte:
return mapSvelte(content)
default:
return mapTraditional(Node{
@@ -396,3 +406,58 @@ func (m *FileMap) String() string {
return b.String()
}
+
+func mapMarkdownSimple(content []byte) []Definition {
+ var defs []Definition
+ lines := strings.Split(string(content), "\n")
+
+ for i, line := range lines {
+ // Check for ATX headings (# style)
+ if strings.HasPrefix(strings.TrimSpace(line), "#") {
+ heading := strings.TrimSpace(line)
+ level := 0
+ // Count heading level
+ for strings.HasPrefix(heading, "#") {
+ level++
+ heading = strings.TrimPrefix(heading, "#")
+ }
+ heading = strings.TrimSpace(heading)
+
+ defs = append(defs, Definition{
+ Type: fmt.Sprintf("h%d", level),
+ Signature: heading,
+ Line: i + 1,
+ })
+ continue
+ }
+
+ // Check for Setext headings (=== or --- style)
+ if i > 0 && len(strings.TrimSpace(line)) > 0 {
+ trimmed := strings.TrimSpace(line)
+ // Check if line consists entirely of = or -
+ isAllEquals := strings.TrimSpace(strings.ReplaceAll(trimmed, "=", "")) == ""
+ isAllDashes := strings.TrimSpace(strings.ReplaceAll(trimmed, "-", "")) == ""
+
+ // Must have at least 2 characters and previous line must not be empty
+ if len(trimmed) >= 2 && strings.TrimSpace(lines[i-1]) != "" {
+ if isAllEquals {
+ // Level 1 heading
+ defs = append(defs, Definition{
+ Type: "h1",
+ Signature: strings.TrimSpace(lines[i-1]),
+ Line: i,
+ })
+ } else if isAllDashes {
+ // Level 2 heading
+ defs = append(defs, Definition{
+ Type: "h2",
+ Signature: strings.TrimSpace(lines[i-1]),
+ Line: i,
+ })
+ }
+ }
+ }
+ }
+
+ return defs
+}
diff --git a/app/server/syntax/file_map/multi.go b/app/server/syntax/file_map/multi.go
index ecadcc61..d9c0357c 100644
--- a/app/server/syntax/file_map/multi.go
+++ b/app/server/syntax/file_map/multi.go
@@ -81,13 +81,12 @@ func ProcessMapTrees(ctx context.Context, inputs map[string]string) (MapTrees, e
var parser *tree_sitter.Parser
file := filepath.Base(path)
if strings.Contains(strings.ToLower(file), "dockerfile") {
- parser = syntax.GetParserForLanguage(shared.TreeSitterLanguageDockerfile)
+ parser = syntax.GetParserForLanguage(shared.LanguageDockerfile)
} else {
- ext := filepath.Ext(path)
- parser, _, _, _ = syntax.GetParserForExt(ext)
+ parser, _, _, _ = syntax.GetParserForPath(path)
if parser == nil {
- errCh <- fmt.Errorf("unsupported file type: %s", ext)
+ errCh <- fmt.Errorf("unsupported file type: %s", path)
return
}
}
diff --git a/app/server/syntax/file_map/nodes_config.go b/app/server/syntax/file_map/nodes_config.go
index 1d13f333..3e8fce53 100644
--- a/app/server/syntax/file_map/nodes_config.go
+++ b/app/server/syntax/file_map/nodes_config.go
@@ -12,7 +12,7 @@ const (
matchTypeSuffix matchType = "suffix"
)
-type langSet map[shared.TreeSitterLanguage]bool
+type langSet map[shared.Language]bool
type nodeConfig struct {
nodeMatch matchType
@@ -47,206 +47,206 @@ var assignmentNodeMap = nodeMap{
"const_spec": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageGo: true,
+ shared.LanguageGo: true,
},
},
"var_spec": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageGo: true,
+ shared.LanguageGo: true,
},
},
"lexical_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageJavascript: true,
- shared.TreeSitterLanguageTypescript: true,
- shared.TreeSitterLanguageJsx: true,
- shared.TreeSitterLanguageTsx: true,
+ shared.LanguageJavascript: true,
+ shared.LanguageTypescript: true,
+ shared.LanguageJsx: true,
+ shared.LanguageTsx: true,
},
},
"field_definition": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageJavascript: true,
- shared.TreeSitterLanguageTypescript: true,
- shared.TreeSitterLanguageJsx: true,
- shared.TreeSitterLanguageTsx: true,
+ shared.LanguageJavascript: true,
+ shared.LanguageTypescript: true,
+ shared.LanguageJsx: true,
+ shared.LanguageTsx: true,
},
},
"interface_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageTypescript: true,
- shared.TreeSitterLanguageTsx: true,
- shared.TreeSitterLanguagePhp: true,
+ shared.LanguageTypescript: true,
+ shared.LanguageTsx: true,
+ shared.LanguagePhp: true,
},
},
"trait_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguagePhp: true,
+ shared.LanguagePhp: true,
},
},
"enum_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguagePhp: true,
- shared.TreeSitterLanguageCsharp: true,
+ shared.LanguagePhp: true,
+ shared.LanguageCsharp: true,
},
},
"global_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguagePhp: true,
+ shared.LanguagePhp: true,
},
},
"static_variable_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguagePhp: true,
+ shared.LanguagePhp: true,
},
},
"type_alias_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageTypescript: true,
- shared.TreeSitterLanguageTsx: true,
- shared.TreeSitterLanguageElm: true,
+ shared.LanguageTypescript: true,
+ shared.LanguageTsx: true,
+ shared.LanguageElm: true,
},
},
"assignment_statement": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguagePython: true,
+ shared.LanguagePython: true,
},
},
"class_variable_assignment": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
+ shared.LanguageRuby: true,
},
},
"assignment": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
+ shared.LanguageRuby: true,
},
},
"let_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRust: true,
+ shared.LanguageRust: true,
},
},
"const_item": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRust: true,
+ shared.LanguageRust: true,
},
},
"static_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageJava: true,
- shared.TreeSitterLanguageCsharp: true,
+ shared.LanguageJava: true,
+ shared.LanguageCsharp: true,
},
},
"member_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageJava: true,
- shared.TreeSitterLanguageCsharp: true,
+ shared.LanguageJava: true,
+ shared.LanguageCsharp: true,
},
},
"field_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageJava: true,
- shared.TreeSitterLanguageCsharp: true,
+ shared.LanguageJava: true,
+ shared.LanguageCsharp: true,
},
},
"property_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageKotlin: true,
- shared.TreeSitterLanguageScala: true,
- shared.TreeSitterLanguagePhp: true,
- shared.TreeSitterLanguageSwift: true,
+ shared.LanguageKotlin: true,
+ shared.LanguageScala: true,
+ shared.LanguagePhp: true,
+ shared.LanguageSwift: true,
},
},
"let_binding": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageOCaml: true,
+ shared.LanguageOCaml: true,
},
},
"value_binding": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageOCaml: true,
+ shared.LanguageOCaml: true,
},
},
"unary_operator": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageElixir: true,
+ shared.LanguageElixir: true,
},
},
"value_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageElm: true,
+ shared.LanguageElm: true,
},
},
"declaration_command": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageBash: true,
+ shared.LanguageBash: true,
},
},
"type_item": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRust: true,
+ shared.LanguageRust: true,
},
},
"val_definition": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageScala: true,
+ shared.LanguageScala: true,
},
},
"type_definition": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageScala: true,
+ shared.LanguageScala: true,
},
},
"typealias_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageSwift: true,
+ shared.LanguageSwift: true,
},
},
}
@@ -294,98 +294,98 @@ var definitionNodeMap = nodeMap{
"def": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
+ shared.LanguageRuby: true,
},
},
"method": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
+ shared.LanguageRuby: true,
},
},
"defmodule": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageElixir: true,
+ shared.LanguageElixir: true,
},
},
"defmacro": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageElixir: true,
+ shared.LanguageElixir: true,
},
},
"port": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageElm: true,
+ shared.LanguageElm: true,
},
},
"functor": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageOCaml: true,
+ shared.LanguageOCaml: true,
},
},
"_def": {
nodeMatch: matchTypeSuffix,
languages: langSet{
- shared.TreeSitterLanguageC: true,
- shared.TreeSitterLanguageCpp: true,
+ shared.LanguageC: true,
+ shared.LanguageCpp: true,
},
},
"type_annotation": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageElm: true,
+ shared.LanguageElm: true,
},
},
"function_statement": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageLua: true,
+ shared.LanguageLua: true,
},
},
"rule_set": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageCss: true,
+ shared.LanguageCss: true,
},
},
"from_instruction": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageDockerfile: true,
+ shared.LanguageDockerfile: true,
},
},
"entrypoint_instruction": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageDockerfile: true,
+ shared.LanguageDockerfile: true,
},
},
"cmd_instruction": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageDockerfile: true,
+ shared.LanguageDockerfile: true,
},
},
"expose_instruction": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageDockerfile: true,
+ shared.LanguageDockerfile: true,
},
},
"copy_instruction": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageDockerfile: true,
+ shared.LanguageDockerfile: true,
},
},
"env_instruction": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageDockerfile: true,
+ shared.LanguageDockerfile: true,
},
},
@@ -429,14 +429,14 @@ var definitionNodeMap = nodeMap{
nodeMatch: matchTypeSuffix,
ignore: true,
languages: langSet{
- shared.TreeSitterLanguageC: true,
- shared.TreeSitterLanguageCpp: true,
+ shared.LanguageC: true,
+ shared.LanguageCpp: true,
},
},
"_item": {
nodeMatch: matchTypeSuffix,
languages: langSet{
- shared.TreeSitterLanguageRust: true,
+ shared.LanguageRust: true,
},
},
}
@@ -460,122 +460,122 @@ var parentNodeMap = nodeMap{
"object": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageScala: true,
+ shared.LanguageScala: true,
},
},
"object_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageKotlin: true,
+ shared.LanguageKotlin: true,
},
},
"protocol": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageSwift: true,
+ shared.LanguageSwift: true,
},
},
"protocol_": {
nodeMatch: matchTypePrefix,
languages: langSet{
- shared.TreeSitterLanguageElixir: true,
+ shared.LanguageElixir: true,
},
},
"extension": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageSwift: true,
+ shared.LanguageSwift: true,
},
},
"const_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageGo: true,
+ shared.LanguageGo: true,
},
},
"var_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageGo: true,
+ shared.LanguageGo: true,
},
},
"template_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageCpp: true,
+ shared.LanguageCpp: true,
},
},
"module": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
+ shared.LanguageRuby: true,
},
},
"class": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
+ shared.LanguageRuby: true,
},
},
"singleton_class": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
+ shared.LanguageRuby: true,
},
},
"enum_entry": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageKotlin: true,
+ shared.LanguageKotlin: true,
},
},
"closure": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageGroovy: true,
+ shared.LanguageGroovy: true,
},
},
"impl_item": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRust: true,
+ shared.LanguageRust: true,
},
},
"trait_item": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRust: true,
+ shared.LanguageRust: true,
},
},
"trait_definition": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageScala: true,
+ shared.LanguageScala: true,
},
},
"object_definition": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageScala: true,
+ shared.LanguageScala: true,
},
},
"function_statement": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageLua: true,
+ shared.LanguageLua: true,
},
onlyChildren: map[nodeType]bool{
"function_statement": true,
@@ -589,8 +589,8 @@ var implBoundaryNodeMap = nodeMap{
nodeMatch: matchTypeEqual,
all: true,
except: langSet{
- shared.TreeSitterLanguageRuby: true,
- shared.TreeSitterLanguageElixir: true,
+ shared.LanguageRuby: true,
+ shared.LanguageElixir: true,
},
},
"body": {
@@ -610,95 +610,95 @@ var implBoundaryNodeMap = nodeMap{
"do_block": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
- shared.TreeSitterLanguageElixir: true,
+ shared.LanguageRuby: true,
+ shared.LanguageElixir: true,
},
},
"body_statement": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
+ shared.LanguageRuby: true,
},
},
"field_declaration_list": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageGo: true,
- shared.TreeSitterLanguageC: true,
- shared.TreeSitterLanguageCpp: true,
+ shared.LanguageGo: true,
+ shared.LanguageC: true,
+ shared.LanguageCpp: true,
},
},
"property_accessors": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageCsharp: true,
- shared.TreeSitterLanguageSwift: true,
+ shared.LanguageCsharp: true,
+ shared.LanguageSwift: true,
},
},
"const_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageGo: true,
+ shared.LanguageGo: true,
},
},
"var_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageGo: true,
+ shared.LanguageGo: true,
},
},
"method_elem": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageGo: true,
+ shared.LanguageGo: true,
},
},
"preproc_arg": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageC: true,
- shared.TreeSitterLanguageCpp: true,
+ shared.LanguageC: true,
+ shared.LanguageCpp: true,
},
},
"statement_block": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageJavascript: true,
- shared.TreeSitterLanguageTypescript: true,
- shared.TreeSitterLanguageJsx: true,
- shared.TreeSitterLanguageTsx: true,
+ shared.LanguageJavascript: true,
+ shared.LanguageTypescript: true,
+ shared.LanguageJsx: true,
+ shared.LanguageTsx: true,
},
},
"declaration_list": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguagePhp: true,
- shared.TreeSitterLanguageCsharp: true,
- shared.TreeSitterLanguageRust: true,
+ shared.LanguagePhp: true,
+ shared.LanguageCsharp: true,
+ shared.LanguageRust: true,
},
},
"_declaration_list": {
nodeMatch: matchTypeSuffix,
languages: langSet{
- shared.TreeSitterLanguageRust: true,
+ shared.LanguageRust: true,
},
},
"enum_variant_list": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRust: true,
+ shared.LanguageRust: true,
},
},
"=": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageScala: true,
+ shared.LanguageScala: true,
},
},
}
@@ -723,46 +723,46 @@ var assignmentBoundaryNodeMap = nodeMap{
"interface_body": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageTypescript: true,
- shared.TreeSitterLanguageTsx: true,
+ shared.LanguageTypescript: true,
+ shared.LanguageTsx: true,
},
},
"declaration_list": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguagePhp: true,
- shared.TreeSitterLanguageCsharp: true,
+ shared.LanguagePhp: true,
+ shared.LanguageCsharp: true,
},
},
"_declaration_list": {
nodeMatch: matchTypeSuffix,
languages: langSet{
- shared.TreeSitterLanguagePhp: true,
- shared.TreeSitterLanguageCsharp: true,
+ shared.LanguagePhp: true,
+ shared.LanguageCsharp: true,
},
},
"lambda_literal": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageKotlin: true,
+ shared.LanguageKotlin: true,
},
},
"arguments": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageElixir: true,
+ shared.LanguageElixir: true,
},
},
"eq": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageElm: true,
+ shared.LanguageElm: true,
},
},
"statements": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageSwift: true,
+ shared.LanguageSwift: true,
},
},
}
@@ -782,20 +782,20 @@ var identifierNodeMap = nodeMap{
"constant": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageRuby: true,
+ shared.LanguageRuby: true,
},
},
"name": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguagePhp: true,
+ shared.LanguagePhp: true,
},
},
"bare_key": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageToml: true,
- shared.TreeSitterLanguageYaml: true,
+ shared.LanguageToml: true,
+ shared.LanguageYaml: true,
},
},
}
@@ -804,7 +804,7 @@ var passThroughParentNodeMap = nodeMap{
"template_declaration": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageCpp: true,
+ shared.LanguageCpp: true,
},
},
}
@@ -813,7 +813,7 @@ var includeAndContinueNodeMap = nodeMap{
"template_parameter_list": {
nodeMatch: matchTypeEqual,
languages: langSet{
- shared.TreeSitterLanguageCpp: true,
+ shared.LanguageCpp: true,
},
},
}
diff --git a/app/server/syntax/file_map/nodes_find.go b/app/server/syntax/file_map/nodes_find.go
index 44d52ee2..99db58f9 100644
--- a/app/server/syntax/file_map/nodes_find.go
+++ b/app/server/syntax/file_map/nodes_find.go
@@ -99,7 +99,7 @@ func isIncludeAndContinueNode(node Node) bool {
return !config.ignore
}
-func (m nodeMap) getConfig(t string, lang shared.TreeSitterLanguage) *nodeConfig {
+func (m nodeMap) getConfig(t string, lang shared.Language) *nodeConfig {
// first look for exact match
config, ok := m[nodeType(t)]
if ok {
@@ -258,7 +258,7 @@ func findAssignmentBoundary(node Node) *Node {
}
func setNodeType(node *Node) {
- if node.Lang == shared.TreeSitterLanguageElixir && node.Type == "call" {
+ if node.Lang == shared.LanguageElixir && node.Type == "call" {
content := node.TsNode.Content(node.Bytes)
switch {
diff --git a/app/server/syntax/file_map/svelte.go b/app/server/syntax/file_map/svelte.go
index 171b8885..255144e9 100644
--- a/app/server/syntax/file_map/svelte.go
+++ b/app/server/syntax/file_map/svelte.go
@@ -17,11 +17,11 @@ func mapSvelte(content []byte) []Definition {
defs := []Definition{}
if scriptContent != "" {
- var lang shared.TreeSitterLanguage
+ var lang shared.Language
if scriptLang == "ts" {
- lang = shared.TreeSitterLanguageTypescript
+ lang = shared.LanguageTypescript
} else {
- lang = shared.TreeSitterLanguageJavascript
+ lang = shared.LanguageJavascript
}
parser := syntax.GetParserForLanguage(lang)
@@ -47,7 +47,7 @@ func mapSvelte(content []byte) []Definition {
defs = append(defs, mapMarkup(content)...)
if styleContent != "" {
- parser := syntax.GetParserForLanguage(shared.TreeSitterLanguageCss)
+ parser := syntax.GetParserForLanguage(shared.LanguageCss)
tree, err := parser.ParseCtx(context.Background(), nil, []byte(styleContent))
if err != nil {
log.Printf("mapSvelte - error parsing style content: %v\n", err)
@@ -58,7 +58,7 @@ func mapSvelte(content []byte) []Definition {
Type: "svelte-style",
Signature: "<style>",
Children: mapTraditional(Node{
- Lang: shared.TreeSitterLanguageCss,
+ Lang: shared.LanguageCss,
TsNode: tree.RootNode(),
Bytes: []byte(styleContent),
}, nil),
diff --git a/app/server/syntax/parsers.go b/app/server/syntax/parsers.go
index 8d7f45b2..fd186606 100644
--- a/app/server/syntax/parsers.go
+++ b/app/server/syntax/parsers.go
@@ -1,6 +1,9 @@
package syntax
import (
+ "path/filepath"
+ "strings"
+
tree_sitter "github.com/smacker/go-tree-sitter"
"github.com/smacker/go-tree-sitter/bash"
"github.com/smacker/go-tree-sitter/c"
@@ -36,15 +39,48 @@ import (
"github.com/plandex/plandex/shared"
)
-func GetParserForExt(ext string) (*tree_sitter.Parser, shared.TreeSitterLanguage, *tree_sitter.Parser, shared.TreeSitterLanguage) {
- lang, ok := shared.TreeSitterLanguageByExtension[ext]
+func GetLanguageForPath(path string) shared.Language {
+ ext := filepath.Ext(path)
+ lang, ok := shared.LanguageByExtension[ext]
if !ok {
+ if strings.Contains(strings.ToLower(path), "dockerfile") {
+ return shared.LanguageDockerfile
+ }
+ if strings.Contains(strings.ToLower(path), "rakefile") {
+ return shared.LanguageRuby
+ }
+
+ if strings.Contains(strings.ToLower(path), "gemfile") {
+ return shared.LanguageRuby
+ }
+
+ if strings.Contains(strings.ToLower(path), "gemfile.lock") {
+ return shared.LanguageRuby
+ }
+
+ if strings.Contains(strings.ToLower(path), "gemspec") {
+ return shared.LanguageRuby
+ }
+
+ if strings.Contains(strings.ToLower(path), "guardfile") {
+ return shared.LanguageRuby
+ }
+
+ return ""
+ }
+ return lang
+}
+
+func GetParserForPath(path string) (*tree_sitter.Parser, shared.Language, *tree_sitter.Parser, shared.Language) {
+ lang := GetLanguageForPath(path)
+ if lang == "" {
return nil, "", nil, ""
}
parser := GetParserForLanguage(lang)
- fallback := shared.TreeSitterLanguageFallbackByExtension[ext]
+ ext := filepath.Ext(path)
+ fallback := shared.LanguageFallbackByExtension[ext]
var fallbackParser *tree_sitter.Parser
if fallback != "" {
fallbackParser = GetParserForLanguage(fallback)
@@ -53,68 +89,68 @@ func GetParserForExt(ext string) (*tree_sitter.Parser, shared.TreeSitterLanguage
return parser, lang, fallbackParser, fallback
}
-func GetParserForLanguage(lang shared.TreeSitterLanguage) *tree_sitter.Parser {
+func GetParserForLanguage(lang shared.Language) *tree_sitter.Parser {
parser := tree_sitter.NewParser()
switch lang {
- case shared.TreeSitterLanguageBash:
+ case shared.LanguageBash:
parser.SetLanguage(bash.GetLanguage())
- case shared.TreeSitterLanguageC:
+ case shared.LanguageC:
parser.SetLanguage(c.GetLanguage())
- case shared.TreeSitterLanguageCpp:
+ case shared.LanguageCpp:
parser.SetLanguage(cpp.GetLanguage())
- case shared.TreeSitterLanguageCsharp:
+ case shared.LanguageCsharp:
parser.SetLanguage(csharp.GetLanguage())
- case shared.TreeSitterLanguageCss:
+ case shared.LanguageCss:
parser.SetLanguage(css.GetLanguage())
- case shared.TreeSitterLanguageCue:
+ case shared.LanguageCue:
parser.SetLanguage(cue.GetLanguage())
- case shared.TreeSitterLanguageDockerfile:
+ case shared.LanguageDockerfile:
parser.SetLanguage(dockerfile.GetLanguage())
- case shared.TreeSitterLanguageElixir:
+ case shared.LanguageElixir:
parser.SetLanguage(elixir.GetLanguage())
- case shared.TreeSitterLanguageElm:
+ case shared.LanguageElm:
parser.SetLanguage(elm.GetLanguage())
- case shared.TreeSitterLanguageGo:
+ case shared.LanguageGo:
parser.SetLanguage(golang.GetLanguage())
- case shared.TreeSitterLanguageGroovy:
+ case shared.LanguageGroovy:
parser.SetLanguage(groovy.GetLanguage())
- case shared.TreeSitterLanguageHcl:
+ case shared.LanguageHcl:
parser.SetLanguage(hcl.GetLanguage())
- case shared.TreeSitterLanguageHtml:
+ case shared.LanguageHtml:
parser.SetLanguage(html.GetLanguage())
- case shared.TreeSitterLanguageJava:
+ case shared.LanguageJava:
parser.SetLanguage(java.GetLanguage())
- case shared.TreeSitterLanguageJavascript, shared.TreeSitterLanguageJson:
+ case shared.LanguageJavascript, shared.LanguageJson:
parser.SetLanguage(javascript.GetLanguage())
- case shared.TreeSitterLanguageKotlin:
+ case shared.LanguageKotlin:
parser.SetLanguage(kotlin.GetLanguage())
- case shared.TreeSitterLanguageLua:
+ case shared.LanguageLua:
parser.SetLanguage(lua.GetLanguage())
- case shared.TreeSitterLanguageOCaml:
+ case shared.LanguageOCaml:
parser.SetLanguage(ocaml.GetLanguage())
- case shared.TreeSitterLanguagePhp:
+ case shared.LanguagePhp:
parser.SetLanguage(php.GetLanguage())
- case shared.TreeSitterLanguageProtobuf:
+ case shared.LanguageProtobuf:
parser.SetLanguage(protobuf.GetLanguage())
- case shared.TreeSitterLanguagePython:
+ case shared.LanguagePython:
parser.SetLanguage(python.GetLanguage())
- case shared.TreeSitterLanguageRuby:
+ case shared.LanguageRuby:
parser.SetLanguage(ruby.GetLanguage())
- case shared.TreeSitterLanguageRust:
+ case shared.LanguageRust:
parser.SetLanguage(rust.GetLanguage())
- case shared.TreeSitterLanguageScala:
+ case shared.LanguageScala:
parser.SetLanguage(scala.GetLanguage())
- case shared.TreeSitterLanguageSvelte:
+ case shared.LanguageSvelte:
parser.SetLanguage(svelte.GetLanguage())
- case shared.TreeSitterLanguageSwift:
+ case shared.LanguageSwift:
parser.SetLanguage(swift.GetLanguage())
- case shared.TreeSitterLanguageToml:
+ case shared.LanguageToml:
parser.SetLanguage(toml.GetLanguage())
- case shared.TreeSitterLanguageTypescript:
+ case shared.LanguageTypescript:
parser.SetLanguage(typescript.GetLanguage())
- case shared.TreeSitterLanguageJsx, shared.TreeSitterLanguageTsx:
+ case shared.LanguageJsx, shared.LanguageTsx:
parser.SetLanguage(tsx.GetLanguage())
- case shared.TreeSitterLanguageYaml:
+ case shared.LanguageYaml:
parser.SetLanguage(yaml.GetLanguage())
default:
return nil
diff --git a/app/server/syntax/structured_edits_apply.go b/app/server/syntax/structured_edits_apply.go
index 4a4b8cd9..1dacc019 100644
--- a/app/server/syntax/structured_edits_apply.go
+++ b/app/server/syntax/structured_edits_apply.go
@@ -61,7 +61,7 @@ func ApplyChanges(
desc string,
addMissingStartEndRefs bool,
parser *sitter.Parser,
- language shared.TreeSitterLanguage,
+ language shared.Language,
ctx context.Context,
) *ApplyChangesResult {
proposedInitial := proposed
diff --git a/app/server/syntax/structured_edits_test.go b/app/server/syntax/structured_edits_test.go
index c13b37a6..701d757c 100644
--- a/app/server/syntax/structured_edits_test.go
+++ b/app/server/syntax/structured_edits_test.go
@@ -1342,7 +1342,7 @@ func TestStructuredReplacements(t *testing.T) {
desc = "Type: add"
}
- parser, lang, _, _ := GetParserForExt("." + tt.ext)
+ parser, lang, _, _ := GetParserForPath("file." + tt.ext)
res := ApplyChanges(
tt.original,
diff --git a/app/server/syntax/structured_edits_tree_sitter.go b/app/server/syntax/structured_edits_tree_sitter.go
index 02983b82..b8693956 100644
--- a/app/server/syntax/structured_edits_tree_sitter.go
+++ b/app/server/syntax/structured_edits_tree_sitter.go
@@ -20,7 +20,7 @@ type execApplyTreeSitterParams struct {
references []Reference
removals []Removal
anchorLines map[int]int
- language shared.TreeSitterLanguage
+ language shared.Language
parser *tree_sitter.Parser
ctx context.Context
}
diff --git a/app/server/syntax/validate.go b/app/server/syntax/validate.go
index 8da1b020..ec9e4d5d 100644
--- a/app/server/syntax/validate.go
+++ b/app/server/syntax/validate.go
@@ -1,7 +1,6 @@
package syntax
import (
- "path/filepath"
"strings"
"time"
@@ -15,7 +14,7 @@ import (
const parserTimeout = 500 * time.Millisecond
type ValidationRes = struct {
- Lang shared.TreeSitterLanguage
+ Lang shared.Language
Parser *tree_sitter.Parser
TimedOut bool
Valid bool
@@ -23,9 +22,7 @@ type ValidationRes = struct {
}
func ValidateFile(ctx context.Context, path string, file string) (*ValidationRes, error) {
- ext := filepath.Ext(path)
-
- parser, lang, fallbackParser, fallbackLang := GetParserForExt(ext)
+ parser, lang, fallbackParser, fallbackLang := GetParserForPath(path)
if parser == nil {
return &ValidationRes{Lang: lang, Parser: nil}, nil
@@ -34,7 +31,7 @@ func ValidateFile(ctx context.Context, path string, file string) (*ValidationRes
return ValidateWithParsers(ctx, lang, parser, fallbackLang, fallbackParser, file)
}
-func ValidateWithParsers(ctx context.Context, lang shared.TreeSitterLanguage, parser *tree_sitter.Parser, fallbackLang shared.TreeSitterLanguage, fallbackParser *tree_sitter.Parser, file string) (*ValidationRes, error) {
+func ValidateWithParsers(ctx context.Context, lang shared.Language, parser *tree_sitter.Parser, fallbackLang shared.Language, fallbackParser *tree_sitter.Parser, file string) (*ValidationRes, error) {
if file == "" {
return &ValidationRes{Lang: lang, Parser: parser, Valid: true}, nil
}
diff --git a/app/shared/ai_models_config.go b/app/shared/ai_models_config.go
index 74b69da0..b0f7c78a 100644
--- a/app/shared/ai_models_config.go
+++ b/app/shared/ai_models_config.go
@@ -15,7 +15,7 @@ var DefaultConfigByRole = map[ModelRole]ModelRoleConfig{
Temperature: 0.3,
TopP: 0.3,
},
- ModelRoleContextLoader: {
+ ModelRoleArchitect: {
Temperature: 0.3,
TopP: 0.3,
},
diff --git a/app/shared/ai_models_data_models.go b/app/shared/ai_models_data_models.go
index 03caecee..892fb81d 100644
--- a/app/shared/ai_models_data_models.go
+++ b/app/shared/ai_models_data_models.go
@@ -263,7 +263,7 @@ type ModelPack struct {
Namer ModelRoleConfig `json:"namer"`
CommitMsg ModelRoleConfig `json:"commitMsg"`
ExecStatus ModelRoleConfig `json:"execStatus"`
- ContextLoader *ModelRoleConfig `json:"contextLoader"`
+ Architect *ModelRoleConfig `json:"contextLoader"`
}
func (m *ModelPack) GetCoder() ModelRoleConfig {
@@ -280,11 +280,11 @@ func (m *ModelPack) GetWholeFileBuilder() ModelRoleConfig {
return *m.WholeFileBuilder
}
-func (m *ModelPack) GetContextLoader() ModelRoleConfig {
- if m.ContextLoader == nil {
+func (m *ModelPack) GetArchitect() ModelRoleConfig {
+ if m.Architect == nil {
return m.Planner.ModelRoleConfig
}
- return *m.ContextLoader
+ return *m.Architect
}
type ModelOverrides struct {
diff --git a/app/shared/ai_models_packs.go b/app/shared/ai_models_packs.go
index 99fddba5..e6f5cccf 100644
--- a/app/shared/ai_models_packs.go
+++ b/app/shared/ai_models_packs.go
@@ -32,8 +32,8 @@ func init() {
},
},
Coder: claude35sonnet(ModelRoleCoder, nil),
- ContextLoader: claude35sonnet(ModelRoleContextLoader, &modelConfigFallbacks{
- largeContextFallback: gemini15pro(ModelRoleContextLoader, nil),
+ Architect: claude35sonnet(ModelRoleArchitect, &modelConfigFallbacks{
+ largeContextFallback: gemini15pro(ModelRoleArchitect, nil),
}),
PlanSummary: *openaio3mini(ModelRolePlanSummary, ReasoningEffortLow, nil),
Builder: *openaio3mini(ModelRoleBuilder, ReasoningEffortMedium, nil),
diff --git a/app/shared/ai_models_roles.go b/app/shared/ai_models_roles.go
index f8c4e967..1cbea471 100644
--- a/app/shared/ai_models_roles.go
+++ b/app/shared/ai_models_roles.go
@@ -5,7 +5,7 @@ type ModelRole string
const (
ModelRolePlanner ModelRole = "planner"
ModelRoleCoder ModelRole = "coder"
- ModelRoleContextLoader ModelRole = "context-loader"
+ ModelRoleArchitect ModelRole = "architect"
ModelRolePlanSummary ModelRole = "summarizer"
ModelRoleBuilder ModelRole = "builder"
ModelRoleWholeFileBuilder ModelRole = "whole-file-builder"
@@ -14,7 +14,7 @@ const (
ModelRoleExecStatus ModelRole = "auto-continue"
)
-var AllModelRoles = []ModelRole{ModelRolePlanner, ModelRoleCoder, ModelRoleContextLoader, ModelRolePlanSummary, ModelRoleBuilder, ModelRoleWholeFileBuilder, ModelRoleName, ModelRoleCommitMsg, ModelRoleExecStatus}
+var AllModelRoles = []ModelRole{ModelRolePlanner, ModelRoleCoder, ModelRoleArchitect, ModelRolePlanSummary, ModelRoleBuilder, ModelRoleWholeFileBuilder, ModelRoleName, ModelRoleCommitMsg, ModelRoleExecStatus}
var ModelRoleDescriptions = map[ModelRole]string{
ModelRolePlanner: "replies to prompts and makes plans",
@@ -25,5 +25,5 @@ var ModelRoleDescriptions = map[ModelRole]string{
ModelRoleName: "names plans",
ModelRoleCommitMsg: "writes commit messages",
ModelRoleExecStatus: "determines whether to auto-continue",
- ModelRoleContextLoader: "decides what context to load using codebase map",
+ ModelRoleArchitect: "makes high level plan and decides what context to load using codebase map",
}
diff --git a/app/shared/plan_model_settings.go b/app/shared/plan_model_settings.go
index b31d0b29..cb995560 100644
--- a/app/shared/plan_model_settings.go
+++ b/app/shared/plan_model_settings.go
@@ -36,13 +36,13 @@ func (ps PlanSettings) GetPlannerMaxReservedOutputTokens() int {
}
}
-func (ps PlanSettings) GetContextLoaderMaxTokens() int {
+func (ps PlanSettings) GetArchitectMaxTokens() int {
if ps.ModelOverrides.MaxTokens == nil {
if ps.ModelPack == nil {
- defaultLoader := DefaultModelPack.GetContextLoader()
+ defaultLoader := DefaultModelPack.GetArchitect()
return defaultLoader.GetFinalLargeContextFallback().BaseModelConfig.MaxTokens
} else {
- loader := ps.ModelPack.GetContextLoader()
+ loader := ps.ModelPack.GetArchitect()
return loader.GetFinalLargeContextFallback().BaseModelConfig.MaxTokens
}
} else {
@@ -50,13 +50,13 @@ func (ps PlanSettings) GetContextLoaderMaxTokens() int {
}
}
-func (ps PlanSettings) GetContextLoaderMaxReservedOutputTokens() int {
+func (ps PlanSettings) GetArchitectMaxReservedOutputTokens() int {
if ps.ModelOverrides.MaxTokens == nil {
if ps.ModelPack == nil {
- defaultLoader := DefaultModelPack.GetContextLoader()
+ defaultLoader := DefaultModelPack.GetArchitect()
return defaultLoader.GetFinalLargeContextFallback().GetReservedOutputTokens()
} else {
- loader := ps.ModelPack.GetContextLoader()
+ loader := ps.ModelPack.GetArchitect()
return loader.GetFinalLargeContextFallback().GetReservedOutputTokens()
}
} else {
@@ -113,11 +113,11 @@ func (ps PlanSettings) GetPlannerEffectiveMaxTokens() int {
return maxPlannerTokens - maxReservedOutputTokens
}
-func (ps PlanSettings) GetContextLoaderEffectiveMaxTokens() int {
- maxContextLoaderTokens := ps.GetContextLoaderMaxTokens()
- maxReservedOutputTokens := ps.GetContextLoaderMaxReservedOutputTokens()
+func (ps PlanSettings) GetArchitectEffectiveMaxTokens() int {
+ maxArchitectTokens := ps.GetArchitectMaxTokens()
+ maxReservedOutputTokens := ps.GetArchitectMaxReservedOutputTokens()
- return maxContextLoaderTokens - maxReservedOutputTokens
+ return maxArchitectTokens - maxReservedOutputTokens
}
func (ps PlanSettings) GetWholeFileBuilderEffectiveMaxTokens() int {
@@ -142,7 +142,7 @@ func (ps PlanSettings) GetRequiredEnvVars() map[string]bool {
envVars[ms.Namer.BaseModelConfig.ApiKeyEnvVar] = true
envVars[ms.CommitMsg.BaseModelConfig.ApiKeyEnvVar] = true
envVars[ms.ExecStatus.BaseModelConfig.ApiKeyEnvVar] = true
- envVars[ms.ContextLoader.BaseModelConfig.ApiKeyEnvVar] = true
+ envVars[ms.Architect.BaseModelConfig.ApiKeyEnvVar] = true
envVars[ms.Coder.BaseModelConfig.ApiKeyEnvVar] = true
// for backward compatibility with <= 0.8.4 server versions
diff --git a/app/shared/syntax.go b/app/shared/syntax.go
index ee2caa72..bc1cc196 100644
--- a/app/shared/syntax.go
+++ b/app/shared/syntax.go
@@ -5,165 +5,171 @@ import (
"strings"
)
-type TreeSitterLanguage string
+type Language string
const (
- TreeSitterLanguageBash TreeSitterLanguage = "bash"
- TreeSitterLanguageC TreeSitterLanguage = "c"
- TreeSitterLanguageCpp TreeSitterLanguage = "cpp"
- TreeSitterLanguageCsharp TreeSitterLanguage = "csharp"
- TreeSitterLanguageCss TreeSitterLanguage = "css"
- TreeSitterLanguageCue TreeSitterLanguage = "cue"
- TreeSitterLanguageDockerfile TreeSitterLanguage = "dockerfile"
- TreeSitterLanguageElixir TreeSitterLanguage = "elixir"
- TreeSitterLanguageElm TreeSitterLanguage = "elm"
- TreeSitterLanguageGo TreeSitterLanguage = "go"
- TreeSitterLanguageGroovy TreeSitterLanguage = "groovy"
- TreeSitterLanguageHcl TreeSitterLanguage = "hcl"
- TreeSitterLanguageHtml TreeSitterLanguage = "html"
- TreeSitterLanguageJava TreeSitterLanguage = "java"
- TreeSitterLanguageJavascript TreeSitterLanguage = "javascript"
- TreeSitterLanguageJson TreeSitterLanguage = "json"
- TreeSitterLanguageKotlin TreeSitterLanguage = "kotlin"
- TreeSitterLanguageLua TreeSitterLanguage = "lua"
- TreeSitterLanguageOCaml TreeSitterLanguage = "ocaml"
- TreeSitterLanguagePhp TreeSitterLanguage = "php"
- TreeSitterLanguageProtobuf TreeSitterLanguage = "protobuf"
- TreeSitterLanguagePython TreeSitterLanguage = "python"
- TreeSitterLanguageRuby TreeSitterLanguage = "ruby"
- TreeSitterLanguageRust TreeSitterLanguage = "rust"
- TreeSitterLanguageScala TreeSitterLanguage = "scala"
- TreeSitterLanguageSvelte TreeSitterLanguage = "svelte"
- TreeSitterLanguageSwift TreeSitterLanguage = "swift"
- TreeSitterLanguageToml TreeSitterLanguage = "toml"
- TreeSitterLanguageTypescript TreeSitterLanguage = "typescript"
- TreeSitterLanguageJsx TreeSitterLanguage = "jsx"
- TreeSitterLanguageTsx TreeSitterLanguage = "tsx"
- TreeSitterLanguageYaml TreeSitterLanguage = "yaml"
+ LanguageBash Language = "bash"
+ LanguageC Language = "c"
+ LanguageCpp Language = "cpp"
+ LanguageCsharp Language = "csharp"
+ LanguageCss Language = "css"
+ LanguageCue Language = "cue"
+ LanguageDockerfile Language = "dockerfile"
+ LanguageElixir Language = "elixir"
+ LanguageElm Language = "elm"
+ LanguageGo Language = "go"
+ LanguageGroovy Language = "groovy"
+ LanguageHcl Language = "hcl"
+ LanguageHtml Language = "html"
+ LanguageJava Language = "java"
+ LanguageJavascript Language = "javascript"
+ LanguageJson Language = "json"
+ LanguageKotlin Language = "kotlin"
+ LanguageLua Language = "lua"
+ LanguageOCaml Language = "ocaml"
+ LanguagePhp Language = "php"
+ LanguageProtobuf Language = "protobuf"
+ LanguagePython Language = "python"
+ LanguageRuby Language = "ruby"
+ LanguageRust Language = "rust"
+ LanguageScala Language = "scala"
+ LanguageSvelte Language = "svelte"
+ LanguageSwift Language = "swift"
+ LanguageToml Language = "toml"
+ LanguageTypescript Language = "typescript"
+ LanguageJsx Language = "jsx"
+ LanguageTsx Language = "tsx"
+ LanguageYaml Language = "yaml"
+ LanguageMarkdown Language = "markdown"
)
-var TreeSitterLanguages = []TreeSitterLanguage{
- TreeSitterLanguageBash,
- TreeSitterLanguageC,
- TreeSitterLanguageCpp,
- TreeSitterLanguageCsharp,
- TreeSitterLanguageCss,
- TreeSitterLanguageCue,
- TreeSitterLanguageDockerfile,
- TreeSitterLanguageElixir,
- TreeSitterLanguageElm,
- TreeSitterLanguageGo,
- TreeSitterLanguageGroovy,
- TreeSitterLanguageHcl,
- TreeSitterLanguageHtml,
- TreeSitterLanguageJava,
- TreeSitterLanguageJavascript,
- TreeSitterLanguageJson,
- TreeSitterLanguageKotlin,
- TreeSitterLanguageLua,
- TreeSitterLanguageOCaml,
- TreeSitterLanguagePhp,
- TreeSitterLanguageProtobuf,
- TreeSitterLanguagePython,
- TreeSitterLanguageRuby,
- TreeSitterLanguageRust,
- TreeSitterLanguageScala,
- TreeSitterLanguageSvelte,
- TreeSitterLanguageSwift,
- TreeSitterLanguageToml,
- TreeSitterLanguageTypescript,
- TreeSitterLanguageJsx,
- TreeSitterLanguageTsx,
- TreeSitterLanguageYaml,
+var Languages = []Language{
+ LanguageBash,
+ LanguageC,
+ LanguageCpp,
+ LanguageCsharp,
+ LanguageCss,
+ LanguageCue,
+ LanguageDockerfile,
+ LanguageElixir,
+ LanguageElm,
+ LanguageGo,
+ LanguageGroovy,
+ LanguageHcl,
+ LanguageHtml,
+ LanguageJava,
+ LanguageJavascript,
+ LanguageJson,
+ LanguageKotlin,
+ LanguageLua,
+ LanguageOCaml,
+ LanguagePhp,
+ LanguageProtobuf,
+ LanguagePython,
+ LanguageRuby,
+ LanguageRust,
+ LanguageScala,
+ LanguageSvelte,
+ LanguageSwift,
+ LanguageToml,
+ LanguageTypescript,
+ LanguageJsx,
+ LanguageTsx,
+ LanguageYaml,
}
-var lacksFileMapSupport = []TreeSitterLanguage{
+var lacksFileMapSupport = []Language{
// config languages aren't mapped, model decides whether to load them based on file name
- TreeSitterLanguageHcl,
- TreeSitterLanguageYaml,
- TreeSitterLanguageToml,
- TreeSitterLanguageCue,
- TreeSitterLanguageJson,
- TreeSitterLanguageProtobuf,
+ LanguageHcl,
+ LanguageYaml,
+ LanguageToml,
+ LanguageCue,
+ LanguageJson,
+ LanguageProtobuf,
// these just need more work for mapping
- TreeSitterLanguageGroovy,
- TreeSitterLanguageOCaml,
+ LanguageGroovy,
+ LanguageOCaml,
}
-var TreeSitterLanguageSet = map[TreeSitterLanguage]bool{}
+var SkipTreeSitter = map[Language]bool{
+ LanguageMarkdown: true,
+}
+
+var LanguageSet = map[Language]bool{}
-var TreeSitterFileMapSupportSet = map[TreeSitterLanguage]bool{}
+var FileMapSupportSet = map[Language]bool{}
func init() {
- for _, lang := range TreeSitterLanguages {
- TreeSitterLanguageSet[lang] = true
- TreeSitterFileMapSupportSet[lang] = true
+ for _, lang := range Languages {
+ LanguageSet[lang] = true
+ FileMapSupportSet[lang] = true
}
for _, lang := range lacksFileMapSupport {
- TreeSitterFileMapSupportSet[lang] = false
+ FileMapSupportSet[lang] = false
}
}
-func IsTreeSitterLanguage(lang TreeSitterLanguage) bool {
- return TreeSitterLanguageSet[lang]
+func IsTreeSitterLanguage(lang Language) bool {
+ return LanguageSet[lang] && !SkipTreeSitter[lang]
}
func HasTreeSitterSupport(path string) bool {
base := filepath.Base(path)
ext := filepath.Ext(base)
isDockerfile := strings.Contains(strings.ToLower(base), "dockerfile")
- return isDockerfile || TreeSitterLanguageByExtension[ext] != ""
+ return (isDockerfile || LanguageByExtension[ext] != "") && IsTreeSitterLanguage(LanguageByExtension[ext])
}
func HasFileMapSupport(path string) bool {
base := filepath.Base(path)
ext := filepath.Ext(base)
isDockerfile := strings.Contains(strings.ToLower(base), "dockerfile")
- lang := TreeSitterLanguageByExtension[ext]
- return isDockerfile || (lang != "" && TreeSitterFileMapSupportSet[lang])
+ lang := LanguageByExtension[ext]
+ return isDockerfile || (lang != "" && FileMapSupportSet[lang])
}
-var TreeSitterLanguageByExtension = map[string]TreeSitterLanguage{
- ".sh": TreeSitterLanguageBash,
- ".bash": TreeSitterLanguageBash,
- ".c": TreeSitterLanguageC,
- ".h": TreeSitterLanguageC,
- ".cpp": TreeSitterLanguageCpp,
- ".cc": TreeSitterLanguageCpp,
- ".cs": TreeSitterLanguageCsharp,
- ".css": TreeSitterLanguageCss,
- ".cue": TreeSitterLanguageCue,
- ".ex": TreeSitterLanguageElixir,
- ".exs": TreeSitterLanguageElixir,
- ".elm": TreeSitterLanguageElm,
- ".go": TreeSitterLanguageGo,
- ".groovy": TreeSitterLanguageGroovy,
- ".hcl": TreeSitterLanguageHcl,
- ".html": TreeSitterLanguageHtml,
- ".java": TreeSitterLanguageJava,
- ".js": TreeSitterLanguageJavascript,
- ".json": TreeSitterLanguageJson,
- ".jsx": TreeSitterLanguageTsx,
- ".kt": TreeSitterLanguageKotlin,
- ".lua": TreeSitterLanguageLua,
- ".ml": TreeSitterLanguageOCaml,
- ".php": TreeSitterLanguagePhp,
- ".proto": TreeSitterLanguageProtobuf,
- ".py": TreeSitterLanguagePython,
- ".rb": TreeSitterLanguageRuby,
- ".rs": TreeSitterLanguageRust,
- ".scala": TreeSitterLanguageScala,
- ".svelte": TreeSitterLanguageSvelte,
- ".swift": TreeSitterLanguageSwift,
- ".toml": TreeSitterLanguageToml,
- ".ts": TreeSitterLanguageTypescript,
- ".tsx": TreeSitterLanguageTsx,
- ".yaml": TreeSitterLanguageYaml,
- ".yml": TreeSitterLanguageYaml,
+var LanguageByExtension = map[string]Language{
+ ".sh": LanguageBash,
+ ".bash": LanguageBash,
+ ".c": LanguageC,
+ ".h": LanguageC,
+ ".cpp": LanguageCpp,
+ ".cc": LanguageCpp,
+ ".cs": LanguageCsharp,
+ ".css": LanguageCss,
+ ".cue": LanguageCue,
+ ".ex": LanguageElixir,
+ ".exs": LanguageElixir,
+ ".elm": LanguageElm,
+ ".go": LanguageGo,
+ ".groovy": LanguageGroovy,
+ ".hcl": LanguageHcl,
+ ".html": LanguageHtml,
+ ".java": LanguageJava,
+ ".js": LanguageJavascript,
+ ".json": LanguageJson,
+ ".jsx": LanguageTsx,
+ ".kt": LanguageKotlin,
+ ".lua": LanguageLua,
+ ".ml": LanguageOCaml,
+ ".php": LanguagePhp,
+ ".proto": LanguageProtobuf,
+ ".py": LanguagePython,
+ ".rb": LanguageRuby,
+ ".rs": LanguageRust,
+ ".scala": LanguageScala,
+ ".svelte": LanguageSvelte,
+ ".swift": LanguageSwift,
+ ".toml": LanguageToml,
+ ".ts": LanguageTypescript,
+ ".tsx": LanguageTsx,
+ ".yaml": LanguageYaml,
+ ".yml": LanguageYaml,
+ ".md": LanguageMarkdown,
}
-var TreeSitterLanguageFallbackByExtension = map[string]TreeSitterLanguage{
- ".ts": TreeSitterLanguageTsx,
- ".js": TreeSitterLanguageTsx,
+var LanguageFallbackByExtension = map[string]Language{
+ ".ts": LanguageTsx,
+ ".js": LanguageTsx,
}
diff --git a/test/plan_deletion_test.sh b/test/plan_deletion_test.sh
index 854a3fd2..ccc0e103 100755
--- a/test/plan_deletion_test.sh
+++ b/test/plan_deletion_test.sh
@@ -1,7 +1,11 @@
+# Plandex hasn't been able to get this working yet
#!/bin/bash
set -e
+# Enable debug output
+set -x
+
# Helper function to check if a plan exists
check_plan_exists() {
local plan_name=$1
@@ -10,22 +14,38 @@ check_plan_exists() {
# Helper function to count total plans
count_plans() {
- pdxd plans | grep -v "^[[:space:]]*$" | grep -v "^[[:space:]]*\\.*" | grep -v "^[[:space:]]*+" | grep -v "^[[:space:]]*\\.*" | grep -v "^[[:space:]]*$" | wc -l
+ # Add sleep to ensure plan list is updated
+ sleep 1
+ # Strip ANSI codes, skip help text and header, then count only the test plans
+ pdxd plans | sed 's/\x1B\[[0-9;]*[mK]//g' | grep -A 1000 "^+----+" | tail -n +3 | head -n 5 | grep -E '\| (plan-config-[123]|other-plan-[12])(\.[0-9]+)? \|' | wc -l
}
-# Create test plans
+# Clean up any existing test plans before starting
+echo "Cleaning up any existing test plans..."
+echo "y" | pdxd dp "plan-config-*" || true
+echo "y" | pdxd dp "other-plan-*" || true
+sleep 2
+
+# Create test plans with verification
echo "Creating test plans..."
-pdxd new -n "plan-config-1"
-pdxd new -n "plan-config-2"
-pdxd new -n "plan-config-3"
-pdxd new -n "other-plan-1"
-pdxd new -n "other-plan-2"
+for plan in "plan-config-1" "plan-config-2" "plan-config-3" "other-plan-1" "other-plan-2"; do
+ pdxd new -n "$plan"
+ if ! check_plan_exists "$plan"; then
+ echo "❌ Failed to create plan '$plan'"
+ exit 1
+ fi
+ # Add sleep to ensure plan creation is complete
+ sleep 1
+done
# Verify initial plans were created
echo "Verifying plans were created..."
initial_count=$(count_plans)
+echo "Found $initial_count plans"
+
if [ "$initial_count" -ne 5 ]; then
echo "❌ Expected 5 plans, but found $initial_count"
+ pdxd plans
exit 1
fi
@@ -38,12 +58,16 @@ done
# Test wildcard deletion
echo "Testing wildcard deletion..."
-pdxd dp "plan-config-*" <<< "y"
+echo "y" | pdxd dp "plan-config-*"
+sleep 1
# Verify wildcard deletion worked
remaining_count=$(count_plans)
+echo "Found $remaining_count plans after wildcard deletion"
+
if [ "$remaining_count" -ne 2 ]; then
echo "❌ Expected 2 plans after wildcard deletion, but found $remaining_count"
+ pdxd plans
exit 1
fi
@@ -55,24 +79,44 @@ for plan in "plan-config-1" "plan-config-2" "plan-config-3"; do
done
# Create more plans for range deletion test
-pdxd new -n "range-test-1"
-pdxd new -n "range-test-2"
-pdxd new -n "range-test-3"
+echo "Creating plans for range deletion test..."
+for plan in "range-test-1" "range-test-2" "range-test-3"; do
+ pdxd new -n "$plan"
+ if ! check_plan_exists "$plan"; then
+ echo "❌ Failed to create plan '$plan'"
+ exit 1
+ fi
+ sleep 1
+done
# Test range deletion (should delete first 3 plans)
echo "Testing range deletion..."
-pdxd dp "1-3" <<< "y"
+echo "y" | pdxd dp "1-3"
+sleep 1
# Verify range deletion worked
final_count=$(count_plans)
+echo "Found $final_count plans after range deletion"
+
if [ "$final_count" -ne 2 ]; then
echo "❌ Expected 2 plans after range deletion, but found $final_count"
+ pdxd plans
exit 1
fi
-# Clean up any remaining plans
-echo "Cleaning up remaining plans..."
-pdxd dp --all <<< "y"
+# Clean up any remaining test plans
+echo "Cleaning up remaining test plans..."
+echo "y" | pdxd dp "plan-config-*" || true
+echo "y" | pdxd dp "other-plan-*" || true
+echo "y" | pdxd dp "range-test-*" || true
+sleep 2
-echo "βœ… All tests passed!"
+# Verify all plans were cleaned up
+cleanup_count=$(count_plans)
+if [ "$cleanup_count" -ne 0 ]; then
+ echo "❌ Expected 0 plans after cleanup, but found $cleanup_count"
+ pdxd plans
+ exit 1
+fi
+echo "βœ… All tests passed!"