From 8cec73e78348161269017ce42af20b346afaffb8 Mon Sep 17 00:00:00 2001 From: creatang Date: Mon, 6 Apr 2026 14:09:18 +0800 Subject: [PATCH 1/5] refactor(tui): add core command status and workspace helpers --- internal/tui/core/commands/parser.go | 77 +++++++++++++ internal/tui/core/commands/parser_test.go | 66 ++++++++++++ internal/tui/core/commands/workspace.go | 70 ++++++++++++ internal/tui/core/commands/workspace_test.go | 107 +++++++++++++++++++ internal/tui/core/status/snapshot.go | 104 ++++++++++++++++++ internal/tui/core/utils/view_helpers.go | 93 ++++++++++++++++ internal/tui/core/workspace/resolver.go | 50 +++++++++ 7 files changed, 567 insertions(+) create mode 100644 internal/tui/core/commands/parser.go create mode 100644 internal/tui/core/commands/parser_test.go create mode 100644 internal/tui/core/commands/workspace.go create mode 100644 internal/tui/core/commands/workspace_test.go create mode 100644 internal/tui/core/status/snapshot.go create mode 100644 internal/tui/core/utils/view_helpers.go create mode 100644 internal/tui/core/workspace/resolver.go diff --git a/internal/tui/core/commands/parser.go b/internal/tui/core/commands/parser.go new file mode 100644 index 00000000..1ffac80e --- /dev/null +++ b/internal/tui/core/commands/parser.go @@ -0,0 +1,77 @@ +package commands + +import ( + "fmt" + "strings" +) + +// SlashCommand 描述单个 slash 命令定义。 +type SlashCommand struct { + Usage string + Description string +} + +// CommandSuggestion 表示输入匹配后的命令建议。 +type CommandSuggestion struct { + Command SlashCommand + Match bool +} + +// MatchSlashCommands 根据输入匹配可展示的 slash 命令建议。 +func MatchSlashCommands(input string, slashPrefix string, commands []SlashCommand) []CommandSuggestion { + if !strings.HasPrefix(input, slashPrefix) { + return nil + } + + query := strings.ToLower(strings.TrimSpace(input)) + if IsCompleteSlashCommand(query, commands) { + return nil + } + out := make([]CommandSuggestion, 0, len(commands)) + for _, command := range commands { + normalized := strings.ToLower(command.Usage) + match := query == slashPrefix || strings.HasPrefix(normalized, query) + if query == slashPrefix || match || strings.Contains(normalized, query) { + out = append(out, CommandSuggestion{Command: command, Match: match}) + } + } + return out +} + +// IsCompleteSlashCommand 判断输入是否已完整匹配某个命令。 +func IsCompleteSlashCommand(input string, commands []SlashCommand) bool { + for _, command := range commands { + if strings.EqualFold(strings.TrimSpace(command.Usage), strings.TrimSpace(input)) { + return true + } + } + return false +} + +// SplitFirstWord 拆分首个 token 与其后续参数。 +func SplitFirstWord(input string) (string, string) { + input = strings.TrimSpace(input) + if input == "" { + return "", "" + } + index := strings.IndexAny(input, " \t") + if index < 0 { + return input, "" + } + return input[:index], strings.TrimSpace(input[index+1:]) +} + +// IsWorkspaceSlashCommand 判断是否为工作区命令（例如 /cwd）。 +func IsWorkspaceSlashCommand(raw string, commandName string) bool { + command, _ := SplitFirstWord(strings.ToLower(strings.TrimSpace(raw))) + return command == strings.ToLower(strings.TrimSpace(commandName)) +} + +// ParseWorkspaceSlashCommand 解析工作区命令参数，非目标命令时返回错误。 +func ParseWorkspaceSlashCommand(raw string, commandName string) (string, error) { + command, args := SplitFirstWord(strings.TrimSpace(raw)) + if strings.ToLower(command) != strings.ToLower(strings.TrimSpace(commandName)) { + return "", fmt.Errorf("unknown command %q", command) + } + return strings.TrimSpace(args), nil +} diff --git a/internal/tui/core/commands/parser_test.go b/internal/tui/core/commands/parser_test.go new file mode 100644 index 00000000..a43915c4 --- /dev/null +++ b/internal/tui/core/commands/parser_test.go @@ -0,0 +1,66 @@ +package commands + +import "testing" + +func TestMatchSlashCommands(t *testing.T) { + commands := []SlashCommand{ + {Usage: "/help", Description: "show help"}, + {Usage: "/provider", Description: "pick provider"}, + {Usage: "/model", Description: "pick model"}, + } + + got := MatchSlashCommands("/pro", "/", commands) + if len(got) != 1 { + t.Fatalf("expected one suggestion for /pro, got %d", len(got)) + } + if got[0].Command.Usage != "/provider" || !got[0].Match { + t.Fatalf("unexpected suggestion: %+v", got[0]) + } + + if complete := MatchSlashCommands("/help", "/", commands); complete != nil { + t.Fatalf("expected nil suggestion when command is complete, got %+v", complete) + } +} + +func TestIsCompleteSlashCommand(t *testing.T) { + commands := []SlashCommand{{Usage: "/help"}, {Usage: "/provider"}} + if !IsCompleteSlashCommand("/help", commands) { + t.Fatalf("expected /help to be complete") + } + if IsCompleteSlashCommand("/hel", commands) { + t.Fatalf("expected /hel to be incomplete") + } +} + +func TestSplitFirstWord(t *testing.T) { + first, rest := SplitFirstWord(" /cwd ./tmp/project ") + if first != "/cwd" || rest != "./tmp/project" { + t.Fatalf("unexpected split result: first=%q rest=%q", first, rest) + } + + first, rest = SplitFirstWord(" ") + if first != "" || rest != "" { + t.Fatalf("expected empty split for blank input, got first=%q rest=%q", first, rest) + } +} + +func TestWorkspaceSlashCommandHelpers(t *testing.T) { + if !IsWorkspaceSlashCommand("/cwd ./tmp", "/cwd") { + t.Fatalf("expected /cwd to be recognized") + } + if IsWorkspaceSlashCommand("/status", "/cwd") { + t.Fatalf("did not expect /status as workspace command") + } + + args, err := ParseWorkspaceSlashCommand("/cwd ./tmp", "/cwd") + if err != nil { + t.Fatalf("ParseWorkspaceSlashCommand() error = %v", err) + } + if args != "./tmp" { + t.Fatalf("expected args ./tmp, got %q", args) + } + + if _, err := ParseWorkspaceSlashCommand("/status", "/cwd"); err == nil { + t.Fatalf("expected parse error for non-workspace command") + } +} diff --git a/internal/tui/core/commands/workspace.go b/internal/tui/core/commands/workspace.go new file mode 100644 index 00000000..0886164d --- /dev/null +++ b/internal/tui/core/commands/workspace.go @@ -0,0 +1,70 @@ +package commands + +import ( + "context" + "fmt" + "strings" + + agentruntime "neo-code/internal/runtime" +) + +// SessionWorkdirSetter 定义设置会话工作目录所需的最小 runtime 能力。 +type SessionWorkdirSetter interface { + SetSessionWorkdir(ctx context.Context, sessionID string, workdir string) (agentruntime.Session, error) +} + +// SessionWorkdirCommandResult 表示工作目录命令执行结果。 +type SessionWorkdirCommandResult struct { + Notice string + Workdir string + Err error +} + +// ExecuteSessionWorkdirCommand 执行 /cwd 命令的核心流程，返回统一结果结构。 +func ExecuteSessionWorkdirCommand( + runtime SessionWorkdirSetter, + sessionID string, + currentWorkdir string, + raw string, + parseCommand func(string) (string, error), + resolveWorkspacePath func(string, string) (string, error), + selectSessionWorkdir func(string, string) string, +) SessionWorkdirCommandResult { + requested, err := parseCommand(raw) + if err != nil { + return SessionWorkdirCommandResult{Err: err} + } + + if strings.TrimSpace(requested) == "" { + workdir := strings.TrimSpace(currentWorkdir) + if workdir == "" { + return SessionWorkdirCommandResult{Err: fmt.Errorf("usage: /cwd ")} + } + return SessionWorkdirCommandResult{ + Notice: fmt.Sprintf("[System] Current workspace is %s.", workdir), + Workdir: workdir, + } + } + + if strings.TrimSpace(sessionID) == "" { + workdir, err := resolveWorkspacePath(currentWorkdir, requested) + if err != nil { + return SessionWorkdirCommandResult{Err: err} + } + return SessionWorkdirCommandResult{ + Notice: fmt.Sprintf("[System] Draft workspace switched to %s.", workdir), + Workdir: workdir, + } + } + + session, err := runtime.SetSessionWorkdir(context.Background(), sessionID, requested) + if err != nil { + return SessionWorkdirCommandResult{Err: err} + } + + workdir := selectSessionWorkdir(session.Workdir, currentWorkdir) + return SessionWorkdirCommandResult{ + Notice: fmt.Sprintf("[System] Session workspace switched to %s.", workdir), + Workdir: workdir, + } +} diff --git a/internal/tui/core/commands/workspace_test.go b/internal/tui/core/commands/workspace_test.go new file mode 100644 index 00000000..53650046 --- /dev/null +++ b/internal/tui/core/commands/workspace_test.go @@ -0,0 +1,107 @@ +package commands + +import ( + "context" + "errors" + "os" + "path/filepath" + "strings" + "testing" + + agentruntime "neo-code/internal/runtime" + tuiworkspace "neo-code/internal/tui/core/workspace" +) + +type stubSessionWorkdirSetter struct { + session agentruntime.Session + err error + calls int +} + +func (s *stubSessionWorkdirSetter) SetSessionWorkdir(ctx context.Context, sessionID string, workdir string) (agentruntime.Session, error) { + s.calls++ + if s.err != nil { + return agentruntime.Session{}, s.err + } + return s.session, nil +} + +func TestExecuteSessionWorkdirCommand(t *testing.T) { + parse := func(raw string) (string, error) { + raw = strings.TrimSpace(raw) + if raw == "/bad" { + return "", errors.New("unknown command") + } + if raw == "/cwd" { + return "", nil + } + if strings.HasPrefix(raw, "/cwd ") { + return strings.TrimSpace(strings.TrimPrefix(raw, "/cwd ")), nil + } + return "", errors.New("unknown command") + } + + t.Run("parse error", func(t *testing.T) { + result := ExecuteSessionWorkdirCommand(&stubSessionWorkdirSetter{}, "", "", "/bad", parse, tuiworkspace.ResolveWorkspacePath, tuiworkspace.SelectSessionWorkdir) + if result.Err == nil { + t.Fatalf("expected parse error") + } + }) + + t.Run("empty requested without current workdir", func(t *testing.T) { + result := ExecuteSessionWorkdirCommand(&stubSessionWorkdirSetter{}, "", "", "/cwd", parse, tuiworkspace.ResolveWorkspacePath, tuiworkspace.SelectSessionWorkdir) + if result.Err == nil || !strings.Contains(result.Err.Error(), "usage: /cwd ") { + t.Fatalf("expected usage error, got %+v", result) + } + }) + + t.Run("empty requested with current workdir", func(t *testing.T) { + current := t.TempDir() + result := ExecuteSessionWorkdirCommand(&stubSessionWorkdirSetter{}, "", current, "/cwd", parse, tuiworkspace.ResolveWorkspacePath, tuiworkspace.SelectSessionWorkdir) + if result.Err != nil { + t.Fatalf("unexpected error: %v", result.Err) + } + if result.Workdir != current || !strings.Contains(result.Notice, "Current workspace is") { + t.Fatalf("unexpected result: %+v", result) + } + }) + + t.Run("draft session resolves requested path", func(t *testing.T) { + base := t.TempDir() + target := filepath.Join(base, "sub") + if err := ensureDir(target); err != nil { + t.Fatalf("mkdir target: %v", err) + } + result := ExecuteSessionWorkdirCommand(&stubSessionWorkdirSetter{}, "", base, "/cwd sub", parse, tuiworkspace.ResolveWorkspacePath, tuiworkspace.SelectSessionWorkdir) + if result.Err != nil { + t.Fatalf("unexpected error: %v", result.Err) + } + if !strings.Contains(result.Notice, "Draft workspace switched") { + t.Fatalf("unexpected notice: %q", result.Notice) + } + }) + + t.Run("runtime error", func(t *testing.T) { + stub := &stubSessionWorkdirSetter{err: errors.New("set workdir failed")} + result := ExecuteSessionWorkdirCommand(stub, "session-1", t.TempDir(), "/cwd sub", parse, tuiworkspace.ResolveWorkspacePath, tuiworkspace.SelectSessionWorkdir) + if result.Err == nil || !strings.Contains(result.Err.Error(), "set workdir failed") { + t.Fatalf("expected runtime error, got %+v", result) + } + }) + + t.Run("runtime empty workdir fallback", func(t *testing.T) { + current := t.TempDir() + stub := &stubSessionWorkdirSetter{session: agentruntime.Session{ID: "session-1", Workdir: ""}} + result := ExecuteSessionWorkdirCommand(stub, "session-1", current, "/cwd sub", parse, tuiworkspace.ResolveWorkspacePath, tuiworkspace.SelectSessionWorkdir) + if result.Err != nil { + t.Fatalf("unexpected error: %v", result.Err) + } + if result.Workdir != current { + t.Fatalf("expected fallback workdir %q, got %q", current, result.Workdir) + } + }) +} + +func ensureDir(path string) error { + return os.MkdirAll(path, 0o755) +} diff --git a/internal/tui/core/status/snapshot.go b/internal/tui/core/status/snapshot.go new file mode 100644 index 00000000..6444f86c --- /dev/null +++ b/internal/tui/core/status/snapshot.go @@ -0,0 +1,104 @@ +package status + +import ( + "fmt" + "strings" + + tuiutils "neo-code/internal/tui/core/utils" + tuistate "neo-code/internal/tui/state" +) + +// Snapshot 表示 /status 命令所需的界面状态快照。 +type Snapshot struct { + ActiveSessionID string + ActiveSessionTitle string + ActiveRunID string + IsAgentRunning bool + IsCompacting bool + CurrentProvider string + CurrentModel string + CurrentWorkdir string + CurrentTool string + ToolStateCount int + RunTotalTokens int + SessionTotalTokens int + ExecutionError string + FocusLabel string + PickerLabel string + MessageCount int +} + +// BuildFromUIState 根据 UIState 与附加上下文构建 /status 所需快照。 +func BuildFromUIState( + state tuistate.UIState, + messageCount int, + focusLabel string, + pickerLabel string, +) Snapshot { + return Snapshot{ + ActiveSessionID: state.ActiveSessionID, + ActiveSessionTitle: state.ActiveSessionTitle, + ActiveRunID: state.ActiveRunID, + IsAgentRunning: state.IsAgentRunning, + IsCompacting: state.IsCompacting, + CurrentProvider: state.CurrentProvider, + CurrentModel: state.CurrentModel, + CurrentWorkdir: state.CurrentWorkdir, + CurrentTool: state.CurrentTool, + ToolStateCount: len(state.ToolStates), + RunTotalTokens: state.TokenUsage.RunTotalTokens, + SessionTotalTokens: state.TokenUsage.SessionTotalTokens, + ExecutionError: state.ExecutionError, + FocusLabel: focusLabel, + PickerLabel: pickerLabel, + MessageCount: messageCount, + } +} + +// Format 将状态快照格式化为多行文本，用于 /status 命令输出。 +func Format(snapshot Snapshot, draftSessionTitle string) string { + sessionID := snapshot.ActiveSessionID + if strings.TrimSpace(sessionID) == "" { + sessionID = "" + } + sessionTitle := snapshot.ActiveSessionTitle + if strings.TrimSpace(sessionTitle) == "" { + sessionTitle = draftSessionTitle + } + running := "no" + if snapshot.IsAgentRunning || snapshot.IsCompacting { + running = "yes" + } + currentTool := snapshot.CurrentTool + if strings.TrimSpace(currentTool) == "" { + currentTool = "" + } + errorText := snapshot.ExecutionError + if strings.TrimSpace(errorText) == "" { + errorText = "" + } + picker := snapshot.PickerLabel + if strings.TrimSpace(picker) == "" { + picker = "none" + } + + lines := []string{ + "Status:", + "Session: " + sessionTitle, + "Session ID: " + sessionID, + "Run ID: " + tuiutils.Fallback(strings.TrimSpace(snapshot.ActiveRunID), ""), + "Running: " + running, + "Provider: " + snapshot.CurrentProvider, + "Model: " + snapshot.CurrentModel, + "Workdir: " + snapshot.CurrentWorkdir, + "Focus: " + snapshot.FocusLabel, + "Picker: " + picker, + "Current Tool: " + currentTool, + fmt.Sprintf("Tool States: %d", snapshot.ToolStateCount), + fmt.Sprintf("Run Tokens: %d", snapshot.RunTotalTokens), + fmt.Sprintf("Session Tokens: %d", snapshot.SessionTotalTokens), + fmt.Sprintf("Messages: %d", snapshot.MessageCount), + "Error: " + errorText, + } + return strings.Join(lines, "\n") +} diff --git a/internal/tui/core/utils/view_helpers.go b/internal/tui/core/utils/view_helpers.go new file mode 100644 index 00000000..4c0d029a --- /dev/null +++ b/internal/tui/core/utils/view_helpers.go @@ -0,0 +1,93 @@ +package utils + +import ( + "strings" + + tuistate "neo-code/internal/tui/state" +) + +// PickerLabelFromMode 将 picker 模式映射为状态快照展示标签。 +func PickerLabelFromMode(mode tuistate.PickerMode) string { + switch mode { + case tuistate.PickerProvider: + return "provider" + case tuistate.PickerModel: + return "model" + case tuistate.PickerFile: + return "file" + default: + return "none" + } +} + +// RequestedWorkdirForRun 在发起 run 时计算应转发的工作目录。 +func RequestedWorkdirForRun(activeSessionID string, currentWorkdir string) string { + if strings.TrimSpace(activeSessionID) == "" { + return currentWorkdir + } + return "" +} + +// IsBusy 统一判断当前是否存在进行中的 agent 或 compact 操作。 +func IsBusy(isAgentRunning bool, isCompacting bool) bool { + return isAgentRunning || isCompacting +} + +// FocusLabelFromPanel 将焦点面板枚举映射为界面展示标签。 +func FocusLabelFromPanel( + focus tuistate.Panel, + sessionsLabel string, + transcriptLabel string, + activityLabel string, + composerLabel string, +) string { + switch focus { + case tuistate.PanelSessions: + return sessionsLabel + case tuistate.PanelTranscript: + return transcriptLabel + case tuistate.PanelActivity: + return activityLabel + default: + return composerLabel + } +} + +// TrimRunes 按 rune 数裁剪文本，超长时尾部追加省略号。 +func TrimRunes(text string, limit int) string { + runes := []rune(text) + if len(runes) <= limit || limit < 4 { + return text + } + return string(runes[:limit-3]) + "..." +} + +// TrimMiddle 在中间裁剪长文本，保留首尾并插入省略号。 +func TrimMiddle(text string, limit int) string { + runes := []rune(text) + if len(runes) <= limit || limit < 7 { + return text + } + left := (limit - 3) / 2 + right := limit - 3 - left + return string(runes[:left]) + "..." + string(runes[len(runes)-right:]) +} + +// Fallback 当 value 为空白文本时返回 fallbackValue。 +func Fallback(value string, fallbackValue string) string { + if strings.TrimSpace(value) == "" { + return fallbackValue + } + return value +} + +// Clamp 将数值限制在 [minValue, maxValue] 范围内。 +func Clamp(value int, minValue int, maxValue int) int { + if value < minValue { + return minValue + } + if value > maxValue { + return maxValue + } + return value +} diff --git a/internal/tui/core/workspace/resolver.go b/internal/tui/core/workspace/resolver.go new file mode 100644 index 00000000..ccf6c103 --- /dev/null +++ b/internal/tui/core/workspace/resolver.go @@ -0,0 +1,50 @@ +package workspace + +import ( + "fmt" + "os" + "path/filepath" + "strings" +) + +// ResolveWorkspacePath 解析并校验工作区路径，确保返回存在且可用的目录绝对路径。 +func ResolveWorkspacePath(base string, requested string) (string, error) { + base = strings.TrimSpace(base) + if base == "" { + workingDir, err := os.Getwd() + if err != nil { + return "", fmt.Errorf("workspace: resolve current directory: %w", err) + } + base = workingDir + } + + target := strings.TrimSpace(requested) + if target == "" { + target = "." + } + if !filepath.IsAbs(target) { + target = filepath.Join(base, target) + } + + absolute, err := filepath.Abs(target) + if err != nil { + return "", fmt.Errorf("workspace: resolve path: %w", err) + } + info, err := os.Stat(absolute) + if err != nil { + return "", fmt.Errorf("workspace: resolve path: %w", err) + } + if !info.IsDir() { + return "", fmt.Errorf("workspace: %q is not a directory", absolute) + } + return filepath.Clean(absolute), nil +} + +// SelectSessionWorkdir 优先返回会话工作目录，缺失时回退到默认工作目录。 +func SelectSessionWorkdir(sessionWorkdir string, defaultWorkdir string) string { + workdir := strings.TrimSpace(sessionWorkdir) + if workdir != "" { + return workdir + } + return strings.TrimSpace(defaultWorkdir) +} From 47e83a7db04f6344012e1414751662463613c3d1 Mon Sep 17 00:00:00 2001 From: creatang Date: Tue, 7 Apr 2026 10:38:57 +0800 Subject: [PATCH 2/5] fix(tui): remove BOM from runtime bridge and status snapshot --- internal/tui/core/status/snapshot.go | 2 +- internal/tui/services/runtime_bridge.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/tui/core/status/snapshot.go b/internal/tui/core/status/snapshot.go index 6444f86c..3f75baf9 100644 --- a/internal/tui/core/status/snapshot.go +++ b/internal/tui/core/status/snapshot.go @@ -1,4 +1,4 @@ -package status +package status import ( "fmt" diff --git a/internal/tui/services/runtime_bridge.go b/internal/tui/services/runtime_bridge.go index c64a68ce..95b09034 100644 --- a/internal/tui/services/runtime_bridge.go +++ b/internal/tui/services/runtime_bridge.go @@ -1,4 +1,4 @@ -package services +package services import ( "fmt" From 3b50aac082aa51118d311dfa9fc61246821907ab Mon Sep 17 00:00:00 2001 From: creatang Date: Tue, 7 Apr 2026 18:14:40 +0800 Subject: [PATCH 3/5] test(tui): improve coverage for bridge and infra helpers --- internal/tui/components/components_test.go | 50 +++ internal/tui/infra/infra_test.go | 206 ++++++++++ internal/tui/services/runtime_bridge_test.go | 378 +++++++++++++++++++ internal/tui/services/services_test.go | 27 ++ 4 files changed, 661 insertions(+) diff --git a/internal/tui/components/components_test.go b/internal/tui/components/components_test.go index a4a38432..51482565 100644 --- a/internal/tui/components/components_test.go +++ b/internal/tui/components/components_test.go @@ -137,3 +137,53 @@ func TestRenderSessionRow(t *testing.T) { t.Fatalf("expected updated-at label in row, got %q", row) } } + +func TestViewHelperBranches(t *testing.T) { + if got := fallback("primary", "fallback"); got != "primary" { + t.Fatalf("expected primary fallback value, got %q", got) + } + if got := fallback("", "fallback"); got != "fallback" { + t.Fatalf("expected fallback value, got %q", got) + } + + if got := trimMiddle("abcdef", 0); got != "" { + t.Fatalf("expected empty string for non-positive limit, got %q", got) + } + if got := trimMiddle("abcdef", 3); got != "abc" { + t.Fatalf("expected hard truncate for short limit, got %q", got) + } + if got := trimMiddle("abcdefghij", 7); got != "ab...ij" { + t.Fatalf("expected middle trim output, got %q", got) + } + + if got := trimRunes("abcdef", 3); got != "abcdef" { + t.Fatalf("expected original text when limit < 4, got %q", got) + } + if got := trimRunes("abcdef", 5); got != "ab..." { + t.Fatalf("expected rune-safe ellipsis trim, got %q", got) + } + + if got := clamp(-1, 0, 10); got != 0 { + t.Fatalf("expected clamp to min, got %d", got) + } + if got := clamp(20, 0, 10); got != 10 { + t.Fatalf("expected clamp to max, got %d", got) + } + if got := clamp(6, 0, 10); got != 6 { + t.Fatalf("expected clamp to keep in-range value, got %d", got) + } +} + +func TestNormalizeBlockRightEdgeBlankContent(t *testing.T) { + blank := " \n\t" + if got := NormalizeBlockRightEdge(blank, 20); got != blank { + t.Fatalf("expected blank content passthrough, got %q", got) + } +} + +func TestCompactStatusTextWithLimit(t *testing.T) { + text := "\n first useful line \nsecond line" + if got := CompactStatusText(text, 9); got != "fir...ine" { + t.Fatalf("expected first non-empty line compacted with ellipsis, got %q", got) + } +} diff --git a/internal/tui/infra/infra_test.go b/internal/tui/infra/infra_test.go index b677f89c..1e9775ec 100644 --- a/internal/tui/infra/infra_test.go +++ b/internal/tui/infra/infra_test.go @@ -1,12 +1,17 @@ package infra import ( + "context" "encoding/binary" "os" "path/filepath" + goruntime "runtime" "strings" "testing" "unicode/utf16" + "unicode/utf8" + + "neo-code/internal/config" ) func TestShellArgs(t *testing.T) { @@ -16,6 +21,12 @@ func TestShellArgs(t *testing.T) { if got := ShellArgs("sh", "pwd"); len(got) != 3 || got[0] != "sh" || got[2] != "pwd" { t.Fatalf("unexpected sh args: %+v", got) } + if got := ShellArgs("powershell", "Get-Location"); len(got) != 4 || got[0] != "powershell" { + t.Fatalf("unexpected powershell args: %+v", got) + } + if got := ShellArgs("pwsh", "Get-Location"); len(got) != 4 || got[0] != "powershell" { + t.Fatalf("unexpected pwsh args: %+v", got) + } if got := ShellArgs("unknown", "git status"); len(got) != 4 || got[0] != "powershell" { t.Fatalf("expected powershell fallback, got %+v", got) } @@ -46,6 +57,47 @@ func TestDecodeWorkspaceOutputUTF16LE(t *testing.T) { } } +func TestDecodeWorkspaceOutputUTF16BE(t *testing.T) { + utf16Data := utf16.Encode([]rune("UTF16 BE")) + buf := make([]byte, 2+len(utf16Data)*2) + buf[0], buf[1] = 0xFE, 0xFF + for i, word := range utf16Data { + binary.BigEndian.PutUint16(buf[2+i*2:], word) + } + + got := DecodeWorkspaceOutput(buf) + if !strings.Contains(got, "UTF16 BE") { + t.Fatalf("expected decoded utf16 big-endian content, got %q", got) + } +} + +func TestDecodeWorkspaceOutputHeuristicsAndEdges(t *testing.T) { + evenWithoutBOM := []byte{0x61, 0x00, 0x62, 0x00} + got := DecodeWorkspaceOutput(evenWithoutBOM) + if !strings.Contains(got, "ab") { + t.Fatalf("expected utf16 heuristic decode result to contain ab, got %q", got) + } + + if got := DecodeWorkspaceOutput([]byte{0xE4, 0xBD, 0xA0}); utf8.ValidString(got) && strings.TrimSpace(got) == "" { + t.Fatalf("expected odd-length raw bytes to keep readable content, got %q", got) + } + + if got := decodeUTF16([]byte{0x61}, true); got != "a" { + t.Fatalf("expected short utf16 input to return raw text, got %q", got) + } + if got := decodeUTF16([]byte{0x61, 0x00, 0x62}, true); !strings.Contains(got, "a") { + t.Fatalf("expected odd-length utf16 input to decode after trimming, got %q", got) + } +} + +func TestDecodedTextScore(t *testing.T) { + printable := decodedTextScore("hello world") + replacement := decodedTextScore(string([]rune{'\uFFFD'})) + if printable <= replacement { + t.Fatalf("expected printable text score > replacement score, got printable=%d replacement=%d", printable, replacement) + } +} + func TestCollectWorkspaceFiles(t *testing.T) { root := t.TempDir() mustWrite := func(rel string) { @@ -77,6 +129,38 @@ func TestCollectWorkspaceFiles(t *testing.T) { } } +func TestCollectWorkspaceFilesLimitAndErrors(t *testing.T) { + root := t.TempDir() + mustWrite := func(rel string) { + t.Helper() + path := filepath.Join(root, rel) + if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil { + t.Fatalf("mkdir %s: %v", rel, err) + } + if err := os.WriteFile(path, []byte(rel), 0o644); err != nil { + t.Fatalf("write %s: %v", rel, err) + } + } + mustWrite("b.txt") + mustWrite("a.txt") + + files, err := CollectWorkspaceFiles(root, 1) + if err != nil { + t.Fatalf("CollectWorkspaceFiles(limit=1) error = %v", err) + } + if len(files) != 1 { + t.Fatalf("expected exactly one file due to limit, got %v", files) + } + if files[0] != "a.txt" && files[0] != "b.txt" { + t.Fatalf("unexpected limited file list: %v", files) + } + + _, err = CollectWorkspaceFiles(filepath.Join(root, "missing"), 10) + if err == nil { + t.Fatalf("expected missing root to produce walk error") + } +} + func TestCopyTextUsesInjectedWriter(t *testing.T) { original := clipboardWriteAll t.Cleanup(func() { clipboardWriteAll = original }) @@ -130,3 +214,125 @@ func TestCachedMarkdownRendererCacheEviction(t *testing.T) { t.Fatalf("expected single cache entry after eviction, got order=%d cache=%d", renderer.CacheOrderCount(), renderer.CacheCount()) } } + +func TestCachedMarkdownRendererDefaultsAndSetMax(t *testing.T) { + renderer := NewCachedMarkdownRenderer("", -1, "(empty)") + if renderer.style != "dark" { + t.Fatalf("expected default style dark, got %q", renderer.style) + } + if renderer.maxCacheEntries != 0 { + t.Fatalf("expected negative max cache to normalize to 0, got %d", renderer.maxCacheEntries) + } + + renderer.SetMaxCacheEntries(2) + if _, err := renderer.Render("one", 20); err != nil { + t.Fatalf("Render(one) error = %v", err) + } + if _, err := renderer.Render("two", 20); err != nil { + t.Fatalf("Render(two) error = %v", err) + } + if _, err := renderer.Render("three", 20); err != nil { + t.Fatalf("Render(three) error = %v", err) + } + if renderer.CacheCount() != 2 { + t.Fatalf("expected cache eviction to keep 2 entries, got %d", renderer.CacheCount()) + } + + renderer.SetMaxCacheEntries(1) + if renderer.CacheCount() != 1 || renderer.CacheOrderCount() != 1 { + t.Fatalf("expected cache trim to one entry, got cache=%d order=%d", renderer.CacheCount(), renderer.CacheOrderCount()) + } + + renderer.SetMaxCacheEntries(-1) + if renderer.CacheCount() != 0 || renderer.CacheOrderCount() != 0 { + t.Fatalf("expected cache trim to zero after negative max, got cache=%d order=%d", renderer.CacheCount(), renderer.CacheOrderCount()) + } +} + +func TestCachedMarkdownRendererCacheDisabledAndWidthFloor(t *testing.T) { + renderer := NewCachedMarkdownRenderer("dark", 0, "(empty)") + if _, err := renderer.Render("same", 1); err != nil { + t.Fatalf("Render(width=1) error = %v", err) + } + if _, err := renderer.Render("same", 15); err != nil { + t.Fatalf("Render(width=15) error = %v", err) + } + if renderer.CacheCount() != 0 { + t.Fatalf("expected disabled cache to keep zero entries, got %d", renderer.CacheCount()) + } + if renderer.RendererCount() != 1 { + t.Fatalf("expected render width floor to reuse one renderer, got %d", renderer.RendererCount()) + } +} + +func TestDefaultWorkspaceCommandExecutor(t *testing.T) { + workdir := t.TempDir() + shellName, successCmd, noOutputCmd, failCmd, sleepCmd := workspaceExecutorCommands() + cfg := config.Config{ + Workdir: workdir, + Shell: shellName, + ToolTimeoutSec: 1, + } + + if _, err := DefaultWorkspaceCommandExecutor(context.Background(), cfg, "", " "); err == nil { + t.Fatalf("expected empty command to fail") + } + + output, err := DefaultWorkspaceCommandExecutor(context.Background(), cfg, "", successCmd) + if err != nil { + t.Fatalf("expected success command to pass, got error %v (output=%q)", err, output) + } + if !strings.Contains(strings.ToLower(output), "ok") { + t.Fatalf("expected success output to contain ok, got %q", output) + } + + output, err = DefaultWorkspaceCommandExecutor(context.Background(), cfg, workdir, noOutputCmd) + if err != nil { + t.Fatalf("expected no-output command to pass, got error %v (output=%q)", err, output) + } + if output != "(no output)" { + t.Fatalf("expected no-output placeholder, got %q", output) + } + + output, err = DefaultWorkspaceCommandExecutor(context.Background(), cfg, workdir, failCmd) + if err == nil { + t.Fatalf("expected failing command to return error, output=%q", output) + } + if strings.TrimSpace(output) == "" { + t.Fatalf("expected failing command to return sanitized output") + } + + output, err = DefaultWorkspaceCommandExecutor(context.Background(), cfg, workdir, sleepCmd) + if err == nil || !strings.Contains(err.Error(), "timed out") { + t.Fatalf("expected timeout error, got err=%v output=%q", err, output) + } +} + +func TestDefaultWorkspaceCommandExecutorUsesDefaultTimeout(t *testing.T) { + workdir := t.TempDir() + shellName, successCmd, _, _, _ := workspaceExecutorCommands() + cfg := config.Config{ + Workdir: workdir, + Shell: shellName, + ToolTimeoutSec: 0, + } + + if output, err := DefaultWorkspaceCommandExecutor(context.Background(), cfg, "", successCmd); err != nil || !strings.Contains(strings.ToLower(output), "ok") { + t.Fatalf("expected default timeout path to execute command, output=%q err=%v", output, err) + } +} + +func workspaceExecutorCommands() (shell string, success string, noOutput string, fail string, sleep string) { + if goruntime.GOOS == "windows" { + return "powershell", + "Write-Output 'OK'", + "$null = 1", + "Write-Error 'failed'; exit 2", + "Start-Sleep -Seconds 2" + } + return "bash", + "printf 'OK\\n'", + "true", + "echo failed 1>&2; exit 2", + "sleep 2" +} diff --git a/internal/tui/services/runtime_bridge_test.go b/internal/tui/services/runtime_bridge_test.go index 8ca2f2aa..56f3fc5e 100644 --- a/internal/tui/services/runtime_bridge_test.go +++ b/internal/tui/services/runtime_bridge_test.go @@ -1,6 +1,7 @@ package services import ( + "fmt" "testing" "time" @@ -139,3 +140,380 @@ func TestMapRunSnapshot(t *testing.T) { t.Fatalf("unexpected run snapshot mapping: context=%+v tools=%+v usage=%+v", context, tools, usage) } } + +func TestRuntimeBridgeParsersTypedAndNilInputs(t *testing.T) { + ctx, ok := ParseRunContextPayload(RuntimeRunContextPayload{ + Provider: " openai ", + Model: " gpt-5.4 ", + }) + if !ok || ctx.Provider != "openai" || ctx.Model != "gpt-5.4" { + t.Fatalf("expected typed run context payload to parse, got %+v ok=%v", ctx, ok) + } + + var nilRunContext *RuntimeRunContextPayload + if _, ok := ParseRunContextPayload(nilRunContext); ok { + t.Fatalf("expected nil run context pointer to fail parsing") + } + if _, ok := ParseRunContextPayload(map[string]any{"Provider": " ", "Model": " "}); ok { + t.Fatalf("expected empty run context map to fail parsing") + } + + tool, ok := ParseToolStatusPayload(map[string]any{ + "ToolCallID": 12345, + "ToolName": " filesystem ", + "Status": " failed ", + "Message": " boom ", + "DurationMS": "88", + }) + if !ok || tool.ToolCallID != "12345" || tool.ToolName != "filesystem" || tool.DurationMS != 88 { + t.Fatalf("unexpected tool status parse result: %+v ok=%v", tool, ok) + } + + var nilToolStatus *RuntimeToolStatusPayload + if _, ok := ParseToolStatusPayload(nilToolStatus); ok { + t.Fatalf("expected nil tool status pointer to fail parsing") + } + if _, ok := ParseToolStatusPayload(map[string]any{"ToolCallID": " ", "ToolName": ""}); ok { + t.Fatalf("expected empty tool status payload to fail parsing") + } + + usage, ok := ParseUsagePayload(map[string]any{ + "Delta": map[string]any{ + "InputTokens": "1", + "OutputTokens": float64(2), + "TotalTokens": int64(3), + }, + "Run": &RuntimeUsageSnapshot{ + InputTokens: 4, + OutputTokens: 5, + TotalTokens: 9, + }, + "Session": RuntimeUsageSnapshot{ + InputTokens: 10, + OutputTokens: 20, + TotalTokens: 30, + }, + }) + if !ok || usage.Delta.TotalTokens != 3 || usage.Run.TotalTokens != 9 || usage.Session.TotalTokens != 30 { + t.Fatalf("unexpected usage payload parse result: %+v ok=%v", usage, ok) + } + + var nilUsage *RuntimeUsagePayload + if _, ok := ParseUsagePayload(nilUsage); ok { + t.Fatalf("expected nil usage pointer to fail parsing") + } + if _, ok := ParseUsagePayload(RuntimeUsagePayload{}); ok { + t.Fatalf("expected zero usage payload to fail parsing") + } +} + +func TestRuntimeBridgeSnapshotParsers(t *testing.T) { + session, ok := ParseSessionContextSnapshot(map[string]any{ + "SessionID": " session-1 ", + "Provider": " openai ", + "Model": " gpt-5.4 ", + "Workdir": " /repo ", + "Mode": " act ", + }) + if !ok || session.SessionID != "session-1" || session.Workdir != "/repo" { + t.Fatalf("unexpected session snapshot parse result: %+v ok=%v", session, ok) + } + + var nilSession *RuntimeSessionContextSnapshot + if _, ok := ParseSessionContextSnapshot(nilSession); ok { + t.Fatalf("expected nil session snapshot pointer to fail parsing") + } + if _, ok := ParseSessionContextSnapshot(RuntimeSessionContextSnapshot{}); ok { + t.Fatalf("expected empty session snapshot to fail parsing") + } + + usage, ok := ParseUsageSnapshot(map[string]any{ + "InputTokens": "11", + "OutputTokens": float64(22), + "TotalTokens": int32(33), + }) + if !ok || usage.TotalTokens != 33 { + t.Fatalf("unexpected usage snapshot parse result: %+v ok=%v", usage, ok) + } + if _, ok := ParseUsageSnapshot(RuntimeUsageSnapshot{}); ok { + t.Fatalf("expected empty usage snapshot to fail parsing") + } +} + +func TestRuntimeBridgeParseRunSnapshot(t *testing.T) { + now := time.Now().UTC().Truncate(time.Second) + existing := RuntimeToolStateSnapshot{ + ToolCallID: "call-2", + ToolName: "tool-b", + Status: "failed", + } + snapshot, ok := ParseRunSnapshot(map[string]any{ + "RunID": " run-9 ", + "SessionID": " session-9 ", + "Context": map[string]any{ + "RunID": "run-9", + "SessionID": "session-9", + "Provider": " openai ", + "Model": " gpt-5.4 ", + "Workdir": " /repo ", + "Mode": " act ", + }, + "ToolStates": []any{ + map[string]any{ + "ToolCallID": "call-1", + "ToolName": "tool-a", + "Status": "succeeded", + "Message": "ok", + "DurationMS": "41", + "UpdatedAt": now, + }, + &existing, + "ignored", + (*RuntimeToolStateSnapshot)(nil), + }, + "Usage": map[string]any{ + "InputTokens": 1, + "OutputTokens": 2, + "TotalTokens": 3, + }, + "SessionUsage": RuntimeUsageSnapshot{ + InputTokens: 10, + OutputTokens: 20, + TotalTokens: 30, + }, + }) + if !ok { + t.Fatalf("expected run snapshot to parse") + } + if snapshot.RunID != "run-9" || snapshot.SessionID != "session-9" { + t.Fatalf("unexpected run/session ids: %+v", snapshot) + } + if len(snapshot.ToolStates) != 2 || snapshot.ToolStates[0].DurationMS != 41 { + t.Fatalf("unexpected parsed tool states: %+v", snapshot.ToolStates) + } + if !snapshot.ToolStates[0].UpdatedAt.Equal(now) { + t.Fatalf("expected parsed updated-at timestamp, got %v", snapshot.ToolStates[0].UpdatedAt) + } + if snapshot.Context.Provider != "openai" { + t.Fatalf("expected context provider from map, got %q", snapshot.Context.Provider) + } + + var nilSnapshot *RuntimeRunSnapshot + if _, ok := ParseRunSnapshot(nilSnapshot); ok { + t.Fatalf("expected nil run snapshot pointer to fail parsing") + } + if _, ok := ParseRunSnapshot(map[string]any{"RunID": " ", "SessionID": ""}); ok { + t.Fatalf("expected empty run snapshot ids to fail parsing") + } + if _, ok := ParseRunSnapshot(42); ok { + t.Fatalf("expected unsupported run snapshot type to fail parsing") + } +} + +func TestRuntimeBridgeMapSnapshotHelpers(t *testing.T) { + context := MapSessionContextSnapshot(RuntimeSessionContextSnapshot{ + SessionID: " session-2 ", + Provider: " openai ", + Model: " gpt-5.4-mini ", + Workdir: " /workspace ", + Mode: " plan ", + }) + if context.SessionID != "session-2" || context.Provider != "openai" || context.Workdir != "/workspace" { + t.Fatalf("unexpected mapped session context: %+v", context) + } + + current := TokenUsageVM{ + RunInputTokens: 1, + RunOutputTokens: 2, + RunTotalTokens: 3, + SessionInputTokens: 4, + SessionOutputTokens: 5, + SessionTotalTokens: 9, + } + mapped := MapUsageSnapshot(RuntimeUsageSnapshot{ + InputTokens: 100, + OutputTokens: 200, + TotalTokens: 300, + }, current) + if mapped.RunTotalTokens != 3 || mapped.SessionTotalTokens != 300 { + t.Fatalf("unexpected mapped usage snapshot: %+v", mapped) + } +} + +func TestRuntimeBridgeMergeToolStatesCaseInsensitiveAndDefaultLimit(t *testing.T) { + now := time.Now() + replaced := MergeToolStates([]ToolStateVM{ + { + ToolCallID: "Call-1", + ToolName: "Tool-A", + Status: tuistate.ToolLifecycleRunning, + UpdatedAt: now, + }, + }, ToolStateVM{ + ToolCallID: "call-1", + ToolName: "tool-a", + Status: tuistate.ToolLifecycleSucceeded, + UpdatedAt: now.Add(time.Second), + }, 0) + if len(replaced) != 1 || replaced[0].Status != tuistate.ToolLifecycleSucceeded { + t.Fatalf("expected case-insensitive duplicate replacement, got %+v", replaced) + } + + var states []ToolStateVM + for i := 0; i < 16; i++ { + states = append(states, ToolStateVM{ + ToolCallID: fmt.Sprintf("call-%d", i), + ToolName: "tool", + Status: tuistate.ToolLifecycleRunning, + }) + } + states = MergeToolStates(states, ToolStateVM{ + ToolCallID: "call-16", + ToolName: "tool", + Status: tuistate.ToolLifecycleRunning, + }, 0) + if len(states) != 16 { + t.Fatalf("expected default limit to keep 16 states, got %d", len(states)) + } + if states[0].ToolCallID != "call-1" || states[len(states)-1].ToolCallID != "call-16" { + t.Fatalf("expected oldest state to be evicted with default limit, got %+v", states) + } +} + +func TestRuntimeBridgeInternalHelpers(t *testing.T) { + if got := mapToolLifecycleStatus("planned"); got != tuistate.ToolLifecyclePlanned { + t.Fatalf("expected planned status, got %q", got) + } + if got := mapToolLifecycleStatus(" RUNNING "); got != tuistate.ToolLifecycleRunning { + t.Fatalf("expected running status, got %q", got) + } + if got := mapToolLifecycleStatus("succeeded"); got != tuistate.ToolLifecycleSucceeded { + t.Fatalf("expected succeeded status, got %q", got) + } + if got := mapToolLifecycleStatus("failed"); got != tuistate.ToolLifecycleFailed { + t.Fatalf("expected failed status, got %q", got) + } + if got := mapToolLifecycleStatus("unknown"); got != tuistate.ToolLifecycleRunning { + t.Fatalf("expected unknown status fallback to running, got %q", got) + } + + if got := parseRunContextSnapshotFromAny(RuntimeRunContextSnapshot{RunID: "r1"}); got.RunID != "r1" { + t.Fatalf("unexpected direct run context snapshot parse result: %+v", got) + } + if got := parseRunContextSnapshotFromAny((*RuntimeRunContextSnapshot)(nil)); got != (RuntimeRunContextSnapshot{}) { + t.Fatalf("expected nil run context pointer to produce zero value, got %+v", got) + } + if got := parseRunContextSnapshotFromAny(map[string]any{"RunID": "r2", "Provider": "openai"}); got.RunID != "r2" { + t.Fatalf("unexpected map run context snapshot parse result: %+v", got) + } + + original := []RuntimeToolStateSnapshot{{ToolCallID: "call-1"}} + cloned := parseToolStatesFromAny(original) + if len(cloned) != 1 || cloned[0].ToolCallID != "call-1" { + t.Fatalf("unexpected direct tool state parse result: %+v", cloned) + } + cloned[0].ToolCallID = "modified" + if original[0].ToolCallID != "call-1" { + t.Fatalf("expected parseToolStatesFromAny to return a copied slice") + } + + parsedStates := parseToolStatesFromAny([]any{ + map[string]any{"ToolCallID": "call-2", "ToolName": "tool"}, + RuntimeToolStateSnapshot{ToolCallID: "call-3"}, + (*RuntimeToolStateSnapshot)(nil), + "ignored", + }) + if len(parsedStates) != 2 { + t.Fatalf("expected two parsed tool states from mixed input, got %+v", parsedStates) + } + if got := parseToolStatesFromAny("unsupported"); got != nil { + t.Fatalf("expected unsupported tool state input to return nil, got %+v", got) + } + + if _, ok := parseToolStateFromAny((*RuntimeToolStateSnapshot)(nil)); ok { + t.Fatalf("expected nil tool state pointer to fail parsing") + } + if _, ok := parseToolStateFromAny(false); ok { + t.Fatalf("expected unsupported tool state type to fail parsing") + } +} + +func TestRuntimeBridgeReadMapHelpers(t *testing.T) { + now := time.Now().UTC().Truncate(time.Second) + m := map[string]any{ + "string": " value ", + "int": 12, + "int64": int64(13), + "int32": int32(14), + "float64": float64(15.9), + "float32": float32(16.7), + "numericStr": " 17 ", + "badStr": "x", + "time": now, + "nil": nil, + } + + if got := readMapString(m, "string"); got != "value" { + t.Fatalf("unexpected readMapString result: %q", got) + } + if got := readMapString(m, "int"); got != "12" { + t.Fatalf("expected non-string value to be stringified, got %q", got) + } + if got := readMapString(m, "missing"); got != "" { + t.Fatalf("expected missing key to return empty string, got %q", got) + } + + if got := readMapInt(m, "int"); got != 12 { + t.Fatalf("unexpected readMapInt int value: %d", got) + } + if got := readMapInt(m, "int64"); got != 13 { + t.Fatalf("unexpected readMapInt int64 value: %d", got) + } + if got := readMapInt(m, "int32"); got != 14 { + t.Fatalf("unexpected readMapInt int32 value: %d", got) + } + if got := readMapInt(m, "float64"); got != 15 { + t.Fatalf("unexpected readMapInt float64 value: %d", got) + } + if got := readMapInt(m, "float32"); got != 16 { + t.Fatalf("unexpected readMapInt float32 value: %d", got) + } + if got := readMapInt(m, "numericStr"); got != 17 { + t.Fatalf("unexpected readMapInt string value: %d", got) + } + if got := readMapInt(m, "badStr"); got != 0 { + t.Fatalf("expected invalid numeric string to return 0, got %d", got) + } + if got := readMapInt(m, "nil"); got != 0 { + t.Fatalf("expected nil value to return 0, got %d", got) + } + + if got := readMapInt64(m, "int"); got != 12 { + t.Fatalf("unexpected readMapInt64 int value: %d", got) + } + if got := readMapInt64(m, "int64"); got != 13 { + t.Fatalf("unexpected readMapInt64 int64 value: %d", got) + } + if got := readMapInt64(m, "int32"); got != 14 { + t.Fatalf("unexpected readMapInt64 int32 value: %d", got) + } + if got := readMapInt64(m, "float64"); got != 15 { + t.Fatalf("unexpected readMapInt64 float64 value: %d", got) + } + if got := readMapInt64(m, "float32"); got != 16 { + t.Fatalf("unexpected readMapInt64 float32 value: %d", got) + } + if got := readMapInt64(m, "numericStr"); got != 17 { + t.Fatalf("unexpected readMapInt64 string value: %d", got) + } + if got := readMapInt64(m, "badStr"); got != 0 { + t.Fatalf("expected invalid int64 string to return 0, got %d", got) + } + + if got := readMapTime(m, "time"); !got.Equal(now) { + t.Fatalf("unexpected readMapTime value: %v", got) + } + if got := readMapTime(m, "string"); !got.IsZero() { + t.Fatalf("expected non-time value to return zero time, got %v", got) + } +} diff --git a/internal/tui/services/services_test.go b/internal/tui/services/services_test.go index 83b7a4ab..cde184c9 100644 --- a/internal/tui/services/services_test.go +++ b/internal/tui/services/services_test.go @@ -184,3 +184,30 @@ func TestFileServices(t *testing.T) { t.Fatalf("expected empty resolved path for blank input, got %q", resolved) } } + +func TestSuggestFileMatchesBranches(t *testing.T) { + candidates := []string{ + "internal/tui/update.go", + "docs/internal-arch.md", + "README.md", + } + + if got := SuggestFileMatches("arch", candidates, 2); len(got) != 1 || got[0] != "docs/internal-arch.md" { + t.Fatalf("expected contains-match branch, got %v", got) + } + if got := SuggestFileMatches("", candidates, 2); len(got) != 2 { + t.Fatalf("expected empty query to return prefix-priority items, got %v", got) + } + if got := SuggestFileMatches("any", candidates, 0); got != nil { + t.Fatalf("expected zero limit to return nil, got %v", got) + } + if got := SuggestFileMatches("any", nil, 2); got != nil { + t.Fatalf("expected nil candidates to return nil, got %v", got) + } +} + +func TestResolveWorkspaceDirectoryInvalidPath(t *testing.T) { + if resolved := ResolveWorkspaceDirectory("\x00"); resolved != "" { + t.Fatalf("expected invalid path to resolve as empty string, got %q", resolved) + } +} From c9a5be802b6f83dfed1d54dc541f5b42163f835a Mon Sep 17 00:00:00 2001 From: creatang Date: Tue, 7 Apr 2026 18:19:45 +0800 Subject: [PATCH 4/5] test(tui/core): add coverage for status, utils and workspace --- internal/tui/components/components_test.go | 36 ------- internal/tui/core/status/snapshot_test.go | 100 +++++++++++++++++++ internal/tui/core/utils/view_helpers_test.go | 97 ++++++++++++++++++ internal/tui/core/workspace/resolver_test.go | 57 +++++++++++ 4 files changed, 254 insertions(+), 36 deletions(-) create mode 100644 internal/tui/core/status/snapshot_test.go create mode 100644 internal/tui/core/utils/view_helpers_test.go create mode 100644 internal/tui/core/workspace/resolver_test.go diff --git a/internal/tui/components/components_test.go b/internal/tui/components/components_test.go index 51482565..07e62549 100644 --- a/internal/tui/components/components_test.go +++ b/internal/tui/components/components_test.go @@ -138,42 +138,6 @@ func TestRenderSessionRow(t *testing.T) { } } -func TestViewHelperBranches(t *testing.T) { - if got := fallback("primary", "fallback"); got != "primary" { - t.Fatalf("expected primary fallback value, got %q", got) - } - if got := fallback("", "fallback"); got != "fallback" { - t.Fatalf("expected fallback value, got %q", got) - } - - if got := trimMiddle("abcdef", 0); got != "" { - t.Fatalf("expected empty string for non-positive limit, got %q", got) - } - if got := trimMiddle("abcdef", 3); got != "abc" { - t.Fatalf("expected hard truncate for short limit, got %q", got) - } - if got := trimMiddle("abcdefghij", 7); got != "ab...ij" { - t.Fatalf("expected middle trim output, got %q", got) - } - - if got := trimRunes("abcdef", 3); got != "abcdef" { - t.Fatalf("expected original text when limit < 4, got %q", got) - } - if got := trimRunes("abcdef", 5); got != "ab..." { - t.Fatalf("expected rune-safe ellipsis trim, got %q", got) - } - - if got := clamp(-1, 0, 10); got != 0 { - t.Fatalf("expected clamp to min, got %d", got) - } - if got := clamp(20, 0, 10); got != 10 { - t.Fatalf("expected clamp to max, got %d", got) - } - if got := clamp(6, 0, 10); got != 6 { - t.Fatalf("expected clamp to keep in-range value, got %d", got) - } -} - func TestNormalizeBlockRightEdgeBlankContent(t *testing.T) { blank := " \n\t" if got := NormalizeBlockRightEdge(blank, 20); got != blank { diff --git a/internal/tui/core/status/snapshot_test.go b/internal/tui/core/status/snapshot_test.go new file mode 100644 index 00000000..1b618833 --- /dev/null +++ b/internal/tui/core/status/snapshot_test.go @@ -0,0 +1,100 @@ +package status + +import ( + "strings" + "testing" + + tuistate "neo-code/internal/tui/state" +) + +func TestBuildFromUIState(t *testing.T) { + state := tuistate.UIState{ + ActiveSessionID: "session-1", + ActiveSessionTitle: "My Session", + ActiveRunID: "run-1", + IsAgentRunning: true, + IsCompacting: false, + CurrentProvider: "openai", + CurrentModel: "gpt-5.4", + CurrentWorkdir: "/repo", + CurrentTool: "filesystem_read_file", + ToolStates: []tuistate.ToolState{ + {ToolCallID: "call-1"}, + {ToolCallID: "call-2"}, + }, + TokenUsage: tuistate.TokenUsageState{ + RunTotalTokens: 12, + SessionTotalTokens: 34, + }, + ExecutionError: "boom", + } + + snapshot := BuildFromUIState(state, 7, "transcript", "provider") + if snapshot.ActiveSessionID != "session-1" || snapshot.ActiveRunID != "run-1" { + t.Fatalf("unexpected snapshot identifiers: %+v", snapshot) + } + if snapshot.ToolStateCount != 2 || snapshot.RunTotalTokens != 12 || snapshot.SessionTotalTokens != 34 { + t.Fatalf("unexpected snapshot counters: %+v", snapshot) + } + if snapshot.FocusLabel != "transcript" || snapshot.PickerLabel != "provider" || snapshot.MessageCount != 7 { + t.Fatalf("unexpected snapshot labels: %+v", snapshot) + } +} + +func TestFormat(t *testing.T) { + formatted := Format(Snapshot{ + ActiveSessionID: "", + ActiveSessionTitle: "", + ActiveRunID: " ", + IsAgentRunning: false, + IsCompacting: false, + CurrentProvider: "openai", + CurrentModel: "gpt-5.4", + CurrentWorkdir: "/repo", + CurrentTool: "", + ToolStateCount: 1, + RunTotalTokens: 2, + SessionTotalTokens: 3, + ExecutionError: "", + FocusLabel: "composer", + PickerLabel: "", + MessageCount: 4, + }, "Draft Session") + + expectedParts := []string{ + "Session: Draft Session", + "Session ID: ", + "Run ID: ", + "Running: no", + "Picker: none", + "Current Tool: ", + "Error: ", + } + for _, part := range expectedParts { + if !strings.Contains(formatted, part) { + t.Fatalf("expected formatted status to contain %q, got:\n%s", part, formatted) + } + } + + running := Format(Snapshot{ + ActiveSessionID: "session-2", + ActiveSessionTitle: "Named Session", + ActiveRunID: "run-2", + IsCompacting: true, + CurrentProvider: "openai", + CurrentModel: "gpt-5.4-mini", + CurrentWorkdir: "/repo", + CurrentTool: "tool-x", + ToolStateCount: 2, + RunTotalTokens: 10, + SessionTotalTokens: 20, + ExecutionError: "failed", + FocusLabel: "activity", + PickerLabel: "model", + MessageCount: 5, + }, "Ignored Draft") + + if !strings.Contains(running, "Session: Named Session") || !strings.Contains(running, "Running: yes") { + t.Fatalf("expected running status to keep explicit values, got:\n%s", running) + } +} diff --git a/internal/tui/core/utils/view_helpers_test.go b/internal/tui/core/utils/view_helpers_test.go new file mode 100644 index 00000000..5a342e06 --- /dev/null +++ b/internal/tui/core/utils/view_helpers_test.go @@ -0,0 +1,97 @@ +package utils + +import ( + "testing" + + tuistate "neo-code/internal/tui/state" +) + +func TestPickerLabelFromMode(t *testing.T) { + if got := PickerLabelFromMode(tuistate.PickerProvider); got != "provider" { + t.Fatalf("expected provider label, got %q", got) + } + if got := PickerLabelFromMode(tuistate.PickerModel); got != "model" { + t.Fatalf("expected model label, got %q", got) + } + if got := PickerLabelFromMode(tuistate.PickerFile); got != "file" { + t.Fatalf("expected file label, got %q", got) + } + if got := PickerLabelFromMode(tuistate.PickerMode(99)); got != "none" { + t.Fatalf("expected default picker label none, got %q", got) + } +} + +func TestRequestedWorkdirForRun(t *testing.T) { + if got := RequestedWorkdirForRun("", "/repo"); got != "/repo" { + t.Fatalf("expected current workdir when active session is blank, got %q", got) + } + if got := RequestedWorkdirForRun("session-1", "/repo"); got != "" { + t.Fatalf("expected empty requested workdir when active session exists, got %q", got) + } +} + +func TestIsBusy(t *testing.T) { + if IsBusy(false, false) { + t.Fatalf("expected idle state") + } + if !IsBusy(true, false) || !IsBusy(false, true) || !IsBusy(true, true) { + t.Fatalf("expected busy state when any operation is running") + } +} + +func TestFocusLabelFromPanel(t *testing.T) { + const ( + sessions = "Sessions" + transcript = "Transcript" + activity = "Activity" + composer = "Composer" + ) + + if got := FocusLabelFromPanel(tuistate.PanelSessions, sessions, transcript, activity, composer); got != sessions { + t.Fatalf("expected sessions label, got %q", got) + } + if got := FocusLabelFromPanel(tuistate.PanelTranscript, sessions, transcript, activity, composer); got != transcript { + t.Fatalf("expected transcript label, got %q", got) + } + if got := FocusLabelFromPanel(tuistate.PanelActivity, sessions, transcript, activity, composer); got != activity { + t.Fatalf("expected activity label, got %q", got) + } + if got := FocusLabelFromPanel(tuistate.PanelInput, sessions, transcript, activity, composer); got != composer { + t.Fatalf("expected composer label, got %q", got) + } +} + +func TestTrimHelpers(t *testing.T) { + if got := TrimRunes("abcdef", 3); got != "abcdef" { + t.Fatalf("expected original text when limit < 4, got %q", got) + } + if got := TrimRunes("abcdef", 5); got != "ab..." { + t.Fatalf("expected rune-safe truncation, got %q", got) + } + + if got := TrimMiddle("abcdef", 6); got != "abcdef" { + t.Fatalf("expected no trim when limit < 7, got %q", got) + } + if got := TrimMiddle("abcdefghij", 7); got != "ab...ij" { + t.Fatalf("expected middle trim output, got %q", got) + } +} + +func TestFallbackAndClamp(t *testing.T) { + if got := Fallback("value", "fallback"); got != "value" { + t.Fatalf("expected value when non-empty, got %q", got) + } + if got := Fallback(" ", "fallback"); got != "fallback" { + t.Fatalf("expected fallback for blank value, got %q", got) + } + + if got := Clamp(-1, 0, 10); got != 0 { + t.Fatalf("expected clamp to min, got %d", got) + } + if got := Clamp(11, 0, 10); got != 10 { + t.Fatalf("expected clamp to max, got %d", got) + } + if got := Clamp(5, 0, 10); got != 5 { + t.Fatalf("expected in-range value unchanged, got %d", got) + } +} diff --git a/internal/tui/core/workspace/resolver_test.go b/internal/tui/core/workspace/resolver_test.go new file mode 100644 index 00000000..775a9ba8 --- /dev/null +++ b/internal/tui/core/workspace/resolver_test.go @@ -0,0 +1,57 @@ +package workspace + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +func TestResolveWorkspacePath(t *testing.T) { + base := t.TempDir() + childDir := filepath.Join(base, "project") + if err := os.MkdirAll(childDir, 0o755); err != nil { + t.Fatalf("mkdir child dir: %v", err) + } + + resolved, err := ResolveWorkspacePath(base, "project") + if err != nil { + t.Fatalf("ResolveWorkspacePath(relative) error = %v", err) + } + if resolved != filepath.Clean(childDir) { + t.Fatalf("unexpected resolved path: %q", resolved) + } + + resolved, err = ResolveWorkspacePath(base, "") + if err != nil { + t.Fatalf("ResolveWorkspacePath(default current) error = %v", err) + } + if resolved != filepath.Clean(base) { + t.Fatalf("expected base directory for empty requested path, got %q", resolved) + } +} + +func TestResolveWorkspacePathErrors(t *testing.T) { + base := t.TempDir() + filePath := filepath.Join(base, "not-dir.txt") + if err := os.WriteFile(filePath, []byte("x"), 0o644); err != nil { + t.Fatalf("write file: %v", err) + } + + if _, err := ResolveWorkspacePath(base, "missing-dir"); err == nil { + t.Fatalf("expected missing path to return error") + } + + if _, err := ResolveWorkspacePath(base, "not-dir.txt"); err == nil || !strings.Contains(err.Error(), "not a directory") { + t.Fatalf("expected non-directory path error, got %v", err) + } +} + +func TestSelectSessionWorkdir(t *testing.T) { + if got := SelectSessionWorkdir(" /session ", "/default"); got != "/session" { + t.Fatalf("expected session workdir priority, got %q", got) + } + if got := SelectSessionWorkdir(" ", " /default "); got != "/default" { + t.Fatalf("expected default workdir fallback, got %q", got) + } +} From 427c3a1d51d34ca87a241eaac03fe9c15c12ac53 Mon Sep 17 00:00:00 2001 From: creatang Date: Tue, 7 Apr 2026 20:14:39 +0800 Subject: [PATCH 5/5] fix(tui): reject NUL bytes in ResolveWorkspaceDirectory and improve test robustness - Add NUL check in services/file_service.go (Linux filepath.Abs does not error on NUL) - Relax shell menu newline assertion on Windows for CJK path wrapping - Add empty base path test case in workspace resolver (79% -> 92%) --- internal/tui/core/workspace/resolver_test.go | 10 ++++++++++ internal/tui/services/file_service.go | 3 +++ internal/tui/update_test.go | 10 +++++++++- 3 files changed, 22 insertions(+), 1 deletion(-) diff --git a/internal/tui/core/workspace/resolver_test.go b/internal/tui/core/workspace/resolver_test.go index 775a9ba8..790150b3 100644 --- a/internal/tui/core/workspace/resolver_test.go +++ b/internal/tui/core/workspace/resolver_test.go @@ -29,6 +29,16 @@ func TestResolveWorkspacePath(t *testing.T) { if resolved != filepath.Clean(base) { t.Fatalf("expected base directory for empty requested path, got %q", resolved) } + + // Empty base falls back to os.Getwd(). + resolved, err = ResolveWorkspacePath("", ".") + if err != nil { + t.Fatalf("ResolveWorkspacePath(empty base) error = %v", err) + } + cwd, _ := os.Getwd() + if resolved != filepath.Clean(cwd) { + t.Fatalf("expected current directory for empty base, got %q", resolved) + } } func TestResolveWorkspacePathErrors(t *testing.T) { diff --git a/internal/tui/services/file_service.go b/internal/tui/services/file_service.go index 21b59900..530f04ca 100644 --- a/internal/tui/services/file_service.go +++ b/internal/tui/services/file_service.go @@ -45,6 +45,9 @@ func ResolveWorkspaceDirectory(workdir string) string { if workdir == "" { return "" } + if strings.ContainsRune(workdir, '\x00') { + return "" + } absolute, err := filepath.Abs(workdir) if err != nil { return "" diff --git a/internal/tui/update_test.go b/internal/tui/update_test.go index ed307cc0..32c932e8 100644 --- a/internal/tui/update_test.go +++ b/internal/tui/update_test.go @@ -7,6 +7,7 @@ import ( "os" "path/filepath" "regexp" + goruntime "runtime" "strings" "sync" "testing" @@ -2481,7 +2482,14 @@ func TestWorkspaceCommandAndFileReferenceFlow(t *testing.T) { if !strings.Contains(menu, shellMenuTitle) || !strings.Contains(menu, workspaceCommandUsage) { t.Fatalf("expected shell hint menu, got %q", menu) } - if strings.Count(menu, "\n") > 3 { + // Shell menu should stay reasonably compact (title + one item row + padding). + // Allow extra newlines on Windows where long paths with non-ASCII characters + // may cause lipgloss to wrap the description line. + maxShellMenuLines := 4 + if goruntime.GOOS == "windows" { + maxShellMenuLines = 6 + } + if strings.Count(menu, "\n") > maxShellMenuLines { t.Fatalf("expected compact shell menu, got %q", menu) } }