[14] enhance basic debugger

.devcontainer/devcontainer.json

@@ -11,7 +11,8 @@
     "--platform=linux/amd64"
   ],
   "features": {
-    "ghcr.io/thediveo/devcontainer-features/lazygit": {}
+    "ghcr.io/thediveo/devcontainer-features/lazygit": {},
+    "ghcr.io/jsburckhardt/devcontainer-features/just:1": {}
   },
   "postCreateCommand": "bash .devcontainer/setup.sh",
   "customizations": {

README.md

@@ -2,6 +2,6 @@
 
 BinGo is a standalone visual concurrency debugger for Go that makes goroutines, channels, and synchronization behavior easy to understand. It captures detailed runtime events and turns them into clear, interactive visualizations, whether you’re running it as a terminal UI or inside editors like VS Code or Vim. With features like goroutine lifecycle tracking, channel and mutex inspection, timeline replay, and deadlock or leak detection, BinGo helps developers see how their concurrent programs actually behave and debug tricky issues that traditional tools miss. Its modular design keeps the core engine UI-agnostic, so new frontends and integrations can be built easily by the community.
 
-
 ## Documentation
+
 For detailed documentation, including client meeting minutes, existing solution comparision, project roadmap, installation instructions, usage guides, and API references, please read the [**Docs**](https://github.com/bingosuite/bingo/tree/main/docs).

cmd/bingo-client/main.go

@@ -0,0 +1,186 @@
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/bingosuite/bingo/config"
+	"github.com/bingosuite/bingo/pkg/client"
+	"github.com/peterh/liner"
+	"golang.org/x/term"
+)
+
+func main() {
+	cfg, err := config.Load("config/config.yml")
+	if err != nil {
+		log.Printf("Failed to load config: %v", err)
+	}
+
+	if cfg == nil {
+		cfg = config.Default()
+	}
+
+	defaultAddr := cfg.Server.Addr
+	if strings.HasPrefix(defaultAddr, ":") {
+		defaultAddr = "localhost" + defaultAddr
+	}
+
+	server := flag.String("server", defaultAddr, "WebSocket server host:port")
+	session := flag.String("session", "", "Existing session ID (optional)")
+	flag.Parse()
+
+	c := client.NewClient(*server, *session)
+	if err := c.Connect(); err != nil {
+		log.Fatalf("Failed to connect: %v", err)
+	}
+	if err := c.Run(); err != nil {
+		log.Fatalf("Failed to start client: %v", err)
+	}
+
+	log.Println("Connected. Commands: start <path>, stop, c=continue, s=step, b=<file> <line>, state, q=quit")
+
+	inputReader := bufio.NewReader(os.Stdin)
+	useRawInput := term.IsTerminal(int(os.Stdin.Fd()))
+	var lineEditor *liner.State
+	if useRawInput {
+		lineEditor = liner.NewLiner()
+		lineEditor.SetCtrlCAborts(true)
+		lineEditor.SetTabCompletionStyle(liner.TabPrints)
+		defer func() {
+			_ = lineEditor.Close()
+		}()
+	}
+
+	go func() {
+		if err := c.Wait(); err != nil {
+			log.Println("Server disconnected")
+			if lineEditor != nil {
+				_ = lineEditor.Close()
+			}
+			os.Exit(1)
+		}
+	}()
+
+	history := make([]string, 0, 64)
+
+	for {
+		prompt := ""
+		var rawLine string
+		var readErr error
+		if useRawInput {
+			rawLine, readErr = lineEditor.Prompt(prompt)
+		} else {
+			fmt.Print(prompt)
+			line, err := inputReader.ReadString('\n')
+			if err != nil {
+				if err != io.EOF {
+					log.Printf("Stdin error: %v", err)
+				}
+				break
+			}
+			rawLine = strings.TrimRight(line, "\r\n")
+		}
+		if readErr != nil {
+			if readErr == liner.ErrPromptAborted || readErr == io.EOF {
+				break
+			}
+			log.Printf("Stdin error: %v", readErr)
+			break
+		}
+
+		raw := strings.TrimSpace(rawLine)
+		if raw != "" {
+			if len(history) == 0 || history[len(history)-1] != rawLine {
+				history = append(history, rawLine)
+				if lineEditor != nil {
+					lineEditor.AppendHistory(rawLine)
+				}
+			}
+		}
+
+		input := strings.ToLower(raw)
+		fields := strings.Fields(raw)
+		var cmdErr error
+		switch input {
+		case "c", "continue":
+			cmdErr = c.Continue()
+			time.Sleep(100 * time.Millisecond)
+		case "s", "step", "stepover":
+			cmdErr = c.StepOver()
+			time.Sleep(100 * time.Millisecond)
+		case "state":
+			fmt.Printf("state=%s session=%s\n", c.State(), c.SessionID())
+		case "stop":
+			cmdErr = c.Stop()
+			time.Sleep(100 * time.Millisecond)
+		case "q", "quit", "exit":
+			_ = c.Close()
+			return
+		case "":
+			continue
+		default:
+			if len(fields) > 0 && strings.EqualFold(fields[0], "start") {
+				cmdErr = handleStartCommand(c, fields)
+				if cmdErr != nil {
+					fmt.Println(cmdErr.Error())
+					cmdErr = nil
+					break
+				}
+				// Give async state updates time to arrive before showing next prompt
+				time.Sleep(100 * time.Millisecond)
+				break
+			}
+			cmdErr = handleBreakpointCommand(c, raw)
+			if cmdErr != nil {
+				fmt.Println(cmdErr.Error())
+				cmdErr = nil
+			}
+		}
+		if cmdErr != nil {
+			log.Printf("Command error: %v", cmdErr)
+		}
+	}
+
+	_ = c.Close()
+}
+
+func handleBreakpointCommand(c *client.Client, raw string) error {
+	fields := strings.Fields(raw)
+	if len(fields) == 0 {
+		return nil
+	}
+	cmd := strings.ToLower(fields[0])
+	if cmd != "b" && cmd != "break" && cmd != "breakpoint" {
+		return fmt.Errorf("unknown command")
+	}
+	if len(fields) < 2 || len(fields) > 3 {
+		return fmt.Errorf("usage: b <line> or b <file> <line>")
+	}
+	filename := ""
+	lineStr := ""
+	if len(fields) == 2 {
+		lineStr = fields[1]
+	} else {
+		filename = fields[1]
+		lineStr = fields[2]
+	}
+	line, err := strconv.Atoi(lineStr)
+	if err != nil || line <= 0 {
+		return fmt.Errorf("invalid line number")
+	}
+	return c.SetBreakpoint(filename, line)
+}
+
+func handleStartCommand(c *client.Client, fields []string) error {
+	if len(fields) != 2 {
+		return fmt.Errorf("usage: start <path>")
+	}
+	return c.StartDebug(fields[1])
+}