@caretive/caret-cli 0.0.1

package/pkg/cli/config.go

@@ -0,0 +1,152 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/cline/cli/pkg/cli/config"
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/cli/pkg/cli/task"
+	"github.com/spf13/cobra"
+)
+
+var configManager *config.Manager
+
+func ensureConfigManager(ctx context.Context, address string) error {
+	if configManager == nil || (address != "" && configManager.GetCurrentInstance() != address) {
+		var err error
+		var instanceAddress string
+
+		if address != "" {
+			// Ensure instance exists at the specified address
+			if err := ensureInstanceAtAddress(ctx, address); err != nil {
+				return fmt.Errorf("failed to ensure instance at address %s: %w", address, err)
+			}
+			configManager, err = config.NewManager(ctx, address)
+			instanceAddress = address
+		} else {
+			// Ensure default instance exists
+			if err := global.EnsureDefaultInstance(ctx); err != nil {
+				return fmt.Errorf("failed to ensure default instance: %w", err)
+			}
+			configManager, err = config.NewManager(ctx, "")
+			if err == nil {
+				instanceAddress = configManager.GetCurrentInstance()
+			}
+		}
+
+		if err != nil {
+			return fmt.Errorf("failed to create config manager: %w", err)
+		}
+
+		// Always set the instance we're using as the default
+		registry := global.Clients.GetRegistry()
+		if err := registry.SetDefaultInstance(instanceAddress); err != nil {
+			// Log warning but don't fail - this is not critical
+			fmt.Printf("Warning: failed to set default instance: %v\n", err)
+		}
+	}
+	return nil
+}
+
+func NewConfigCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "config",
+		Aliases: []string{"c"},
+		Short:   "Manage Cline configuration",
+		Long:    `Set and manage global Cline configuration variables.`,
+	}
+
+	cmd.AddCommand(newConfigListCommand())
+	cmd.AddCommand(newConfigGetCommand())
+	cmd.AddCommand(setCommand())
+
+	return cmd
+}
+
+func newConfigGetCommand() *cobra.Command {
+	var address string
+
+	cmd := &cobra.Command{
+		Use:     "get <key>",
+		Aliases: []string{"g"},
+		Short:   "Get a specific configuration value",
+		Long:    `Get the value of a specific configuration setting. Supports nested keys using dot notation (e.g., auto-approval-settings.actions.read-files).`,
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+			key := args[0]
+
+			// Ensure config manager
+			if err := ensureConfigManager(ctx, address); err != nil {
+				return err
+			}
+
+			// Get the setting
+			return configManager.GetSetting(ctx, key)
+		},
+	}
+
+	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
+	return cmd
+}
+
+func newConfigListCommand() *cobra.Command {
+	var address string
+
+	cmd := &cobra.Command{
+		Use:     "list",
+		Aliases: []string{"l"},
+		Short:   "List all configuration settings",
+		Long:    `List all configuration settings from the Cline instance.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+
+			// Ensure config manager
+			if err := ensureConfigManager(ctx, address); err != nil {
+				return err
+			}
+
+			// List settings
+			return configManager.ListSettings(ctx)
+		},
+	}
+
+	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
+	return cmd
+}
+
+func setCommand() *cobra.Command {
+	var address string
+
+	cmd := &cobra.Command{
+		Use:     "set <key=value> [key=value...]",
+		Aliases: []string{"s"},
+		Short:   "Set configuration variables",
+		Long:    `Set one or more global configuration variables using key=value format.
+		
+This command merges the provided settings with existing values, preserving
+unspecified fields. Only the fields you explicitly set will be updated.`,
+		Args:    cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+
+			// Parse using existing task parser
+			settings, secrets, err := task.ParseTaskSettings(args)
+			if err != nil {
+				return fmt.Errorf("failed to parse settings: %w", err)
+			}
+
+			// Ensure config manager
+			if err := ensureConfigManager(ctx, address); err != nil {
+				return err
+			}
+
+			// Update settings (server-side merge handles preserving existing values)
+			return configManager.UpdateSettings(ctx, settings, secrets)
+		},
+	}
+
+	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
+	return cmd
+}

package/pkg/cli/display/ansi.go

@@ -0,0 +1,27 @@
+package display
+
+import (
+	"fmt"
+	"os"
+
+	"golang.org/x/term"
+)
+
+func isTTY() bool {
+	return term.IsTerminal(int(os.Stdout.Fd()))
+}
+
+func ClearLine() {
+	if !isTTY() {
+		return
+	}
+	fmt.Print("\r\033[K")
+}
+
+// ClearToEnd clears from cursor to end of screen
+func ClearToEnd() {
+	if !isTTY() {
+		return
+	}
+	fmt.Print("\033[J")
+}

package/pkg/cli/display/banner.go

@@ -0,0 +1,211 @@
+package display
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+// BannerInfo contains information to display in the session banner
+type BannerInfo struct {
+	Version    string
+	Provider   string
+	ModelID    string
+	Workdir    string
+	Mode       string
+}
+
+// RenderSessionBanner renders a nice banner showing version, model, and workspace info
+func RenderSessionBanner(info BannerInfo) string {
+	// Bright white for title
+	titleStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("15")). // Bright white
+		Bold(true)
+
+	// Dim gray for regular text (same as huh placeholder)
+	dimStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.AdaptiveColor{Light: "248", Dark: "238"})
+
+	// Border color matches mode
+	borderColor := lipgloss.Color("3") // Yellow for plan
+	if info.Mode == "act" {
+		borderColor = lipgloss.Color("39") // Blue for act
+	}
+
+	boxStyle := lipgloss.NewStyle().
+		Border(lipgloss.RoundedBorder()).
+		BorderForeground(borderColor).
+		Padding(1, 4)
+
+	var lines []string
+
+	// Format version with "v" prefix if it starts with a number
+	versionStr := info.Version
+	if len(versionStr) > 0 && versionStr[0] >= '0' && versionStr[0] <= '9' {
+		versionStr = "v" + versionStr
+	}
+
+	// First line: "cline cli vX.X.X" on left, "plan mode" on right
+	leftSide := titleStyle.Render("cline cli preview") + " " + dimStyle.Render(versionStr)
+
+	if info.Mode != "" {
+		modeColor := lipgloss.Color("3") // Yellow for plan
+		if info.Mode == "act" {
+			modeColor = lipgloss.Color("39") // Blue for act
+		}
+		modeStyle := lipgloss.NewStyle().Foreground(modeColor).Bold(true)
+		rightSide := modeStyle.Render(info.Mode + " mode")
+
+		// Calculate spacing to push mode to the right
+		// Assume a reasonable width (we'll adjust based on content)
+		lineWidth := 50
+		leftWidth := lipgloss.Width(leftSide)
+		rightWidth := lipgloss.Width(rightSide)
+		spacing := lineWidth - leftWidth - rightWidth
+
+		if spacing > 0 {
+			titleLine := leftSide + strings.Repeat(" ", spacing) + rightSide
+			lines = append(lines, titleLine)
+		} else {
+			// If too narrow, just put them on same line with a space
+			lines = append(lines, leftSide+" "+rightSide)
+		}
+	} else {
+		// No mode, just show title
+		lines = append(lines, leftSide)
+	}
+
+	// Model line - dim gray
+	if info.Provider != "" && info.ModelID != "" {
+		lines = append(lines, dimStyle.Render(info.Provider+"/"+shortenPath(info.ModelID, 30)))
+	}
+
+	// Workspace line - dim gray
+	if info.Workdir != "" {
+		lines = append(lines, dimStyle.Render(shortenPath(info.Workdir, 45)))
+	}
+
+	content := lipgloss.JoinVertical(lipgloss.Left, lines...)
+	return boxStyle.Render(content)
+}
+
+// shortenPath shortens a filesystem path to fit within maxLen
+func shortenPath(path string, maxLen int) string {
+	// Try to replace home directory with ~ (cross-platform)
+	if homeDir, err := os.UserHomeDir(); err == nil {
+		if strings.HasPrefix(path, homeDir) {
+			shortened := "~" + path[len(homeDir):]
+			// Always use ~ version if we can
+			path = shortened
+		}
+	}
+
+	if len(path) <= maxLen {
+		return path
+	}
+
+	// If still too long, show last few path components
+	if len(path) > maxLen {
+		parts := strings.Split(path, string(filepath.Separator))
+		if len(parts) > 2 {
+			// Show last 2-3 components
+			lastParts := parts[len(parts)-2:]
+			shortened := "..." + string(filepath.Separator) + strings.Join(lastParts, string(filepath.Separator))
+			if len(shortened) <= maxLen {
+				return shortened
+			}
+		}
+	}
+
+	// Last resort: truncate with ellipsis
+	if len(path) > maxLen {
+		return "..." + path[len(path)-maxLen+3:]
+	}
+
+	return path
+}
+
+// ExtractBannerInfoFromState extracts banner info from state JSON
+func ExtractBannerInfoFromState(stateJSON, version string) (BannerInfo, error) {
+	var state map[string]interface{}
+	if err := json.Unmarshal([]byte(stateJSON), &state); err != nil {
+		return BannerInfo{}, fmt.Errorf("failed to parse state JSON: %w", err)
+	}
+
+	info := BannerInfo{
+		Version: version,
+	}
+
+	// Extract mode
+	if mode, ok := state["mode"].(string); ok {
+		info.Mode = mode
+	}
+
+	// Extract workspace roots
+	if workspaceRoots, ok := state["workspaceRoots"].([]interface{}); ok && len(workspaceRoots) > 0 {
+		if root, ok := workspaceRoots[0].(map[string]interface{}); ok {
+			if path, ok := root["path"].(string); ok {
+				info.Workdir = path
+			}
+		}
+	}
+
+	// Extract API configuration to get provider/model
+	if apiConfig, ok := state["apiConfiguration"].(map[string]interface{}); ok {
+		// Try common keys for provider and model (both camelCase and lowercase variants)
+		providerKeys := []string{"apiProvider", "api_provider"}
+		modelKeys := []string{"apiModelId", "api_model_id"}
+
+		// Try to extract provider
+		for _, key := range providerKeys {
+			if provider, ok := apiConfig[key].(string); ok && provider != "" {
+				info.Provider = provider
+				break
+			}
+		}
+
+		// Try to extract model ID
+		for _, key := range modelKeys {
+			if modelID, ok := apiConfig[key].(string); ok && modelID != "" {
+				info.ModelID = shortenModelID(modelID)
+				break
+			}
+		}
+	}
+
+	return info, nil
+}
+
+// shortenModelID shortens long model IDs for display
+func shortenModelID(modelID string) string {
+	// Remove date suffixes only if they're at the end (e.g., -20241022)
+	// Check if the model ID ends with -YYYYMMDD pattern
+	if len(modelID) > 9 {
+		suffix := modelID[len(modelID)-9:] // Last 9 chars: -20241022
+		if suffix[0] == '-' &&
+		   (strings.HasPrefix(suffix[1:], "202") || strings.HasPrefix(suffix[1:], "201")) {
+			// Verify all remaining chars are digits
+			allDigits := true
+			for _, c := range suffix[1:] {
+				if c < '0' || c > '9' {
+					allDigits = false
+					break
+				}
+			}
+			if allDigits {
+				return modelID[:len(modelID)-9]
+			}
+		}
+	}
+
+	// If still too long, show first 40 chars
+	if len(modelID) > 40 {
+		return modelID[:37] + "..."
+	}
+
+	return modelID
+}

package/pkg/cli/display/deduplicator.go

@@ -0,0 +1,95 @@
+package display
+
+import (
+	"crypto/md5"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/cline/cli/pkg/cli/types"
+)
+
+// MessageDeduplicator handles message deduplication to prevent duplicate displays
+type MessageDeduplicator struct {
+	mu            sync.RWMutex
+	seenMessages  map[string]time.Time
+	maxAge        time.Duration
+	cleanupTicker *time.Ticker
+}
+
+// NewMessageDeduplicator creates a new message deduplicator
+func NewMessageDeduplicator() *MessageDeduplicator {
+	d := &MessageDeduplicator{
+		seenMessages:  make(map[string]time.Time),
+		maxAge:        5 * time.Minute,                 // Keep messages for 5 minutes
+		cleanupTicker: time.NewTicker(1 * time.Minute), // Cleanup every minute
+	}
+
+	// Start cleanup goroutine
+	go d.cleanup()
+
+	return d
+}
+
+// IsDuplicate checks if a message is a duplicate
+func (d *MessageDeduplicator) IsDuplicate(msg *types.ClineMessage) bool {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	// Create a hash of the message content
+	hash := d.hashMessage(msg)
+
+	// Check if we've seen this message recently
+	if lastSeen, exists := d.seenMessages[hash]; exists {
+		// If we've seen it within the last few seconds, it's a duplicate
+		if time.Since(lastSeen) < 2*time.Second {
+			return true
+		}
+	}
+
+	// Mark this message as seen
+	d.seenMessages[hash] = time.Now()
+	return false
+}
+
+// hashMessage creates a hash of the message for deduplication
+func (d *MessageDeduplicator) hashMessage(msg *types.ClineMessage) string {
+	// Create a hash based on message content, type, and timestamp
+	content := fmt.Sprintf("%s|%s|%s|%d",
+		string(msg.Type),
+		msg.Say,
+		msg.Ask,
+		msg.Timestamp)
+
+	// For partial messages, include the text content in the hash
+	if msg.Partial {
+		content += "|" + msg.Text
+	}
+
+	hash := md5.Sum([]byte(content))
+	return fmt.Sprintf("%x", hash)
+}
+
+// cleanup removes old entries from the seen messages map
+func (d *MessageDeduplicator) cleanup() {
+	for range d.cleanupTicker.C {
+		d.mu.Lock()
+		now := time.Now()
+
+		// Remove entries older than maxAge
+		for hash, timestamp := range d.seenMessages {
+			if now.Sub(timestamp) > d.maxAge {
+				delete(d.seenMessages, hash)
+			}
+		}
+
+		d.mu.Unlock()
+	}
+}
+
+// Stop stops the cleanup goroutine
+func (d *MessageDeduplicator) Stop() {
+	if d.cleanupTicker != nil {
+		d.cleanupTicker.Stop()
+	}
+}

package/pkg/cli/display/markdown_renderer.go

@@ -0,0 +1,139 @@
+package display
+
+import (
+	"os"
+	"strconv"
+	"strings"
+
+	"fmt"
+
+	"github.com/charmbracelet/glamour"
+	"golang.org/x/term"
+)
+
+type MarkdownRenderer struct {
+	renderer *glamour.TermRenderer
+	width    int
+}
+
+// i went back and forth on whether or not to enable word wrap
+// setting line width to 0 enables the terminal to handle wrapping
+// setting it to a terminal width enables glamour's word wrap
+// the thing is, glamour's nice indentation looks really good, and
+// won't work without glamour's word wrap - if you use the terminal's
+// word wrap, the indentation looks weird so you have to turn it off
+// and everything will be right next to the left margin
+// but if you DO use glamours word wrap, it also means if you resize the terminal,
+// it will scuff everything. but given that this is the case for the input anyway, 
+// i figure we just make things as beautiful as possible 
+// and if you resize the terminal, you'll learn real quick.
+// anyway, you can set this to true or false to experiment
+const USETERMINALWORDWRAP = true
+
+
+// seems like a reliable way to check for terminals
+// for now i'm keeping everything as auto
+// eventually we can define a custom glamour style for ghostty / iterm
+// https://github.com/charmbracelet/glamour/blob/master/styles/README.md)
+func detectTerminalTheme() string {
+	switch os.Getenv("TERM_PROGRAM") {
+	case "iTerm.app", "Ghostty":
+		return "dark"
+	}
+	if os.Getenv("GHOSTTY_VERSION") != "" {
+		return "dark"
+	}
+	return "dark"
+}
+
+func glamourStyleJSON(terminalWrap bool) string {
+	const tmpl = `{
+		"document": {
+			"block_prefix": "\n",
+			"block_suffix": "\n",
+			"color": "252",
+			"margin": %s
+		},
+		"code_block": {
+			"margin": 0
+		}
+	}`
+	if terminalWrap {
+		return fmt.Sprintf(tmpl, "0")
+	}
+	return fmt.Sprintf(tmpl, "2")
+}
+
+
+
+
+func NewMarkdownRenderer() (*MarkdownRenderer, error) {
+	var wordWrap int
+	if USETERMINALWORDWRAP {
+		// terminal handles wrapping -> disable glamour wrap
+		wordWrap = 0
+	} else {
+		// glamour handles wrapping -> set to current width
+		wordWrap = terminalWidthOr(0)
+	}
+
+	r, err := glamour.NewTermRenderer(
+		glamour.WithStandardStyle(detectTerminalTheme()),              	 					 // Load full auto style first
+		glamour.WithStylesFromJSONBytes([]byte(glamourStyleJSON(USETERMINALWORDWRAP))),  	 // Then override just margins
+		glamour.WithWordWrap(wordWrap),                        
+		glamour.WithPreservedNewLines(),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MarkdownRenderer{
+		renderer: r,
+		width:    0, // Unlimited width
+	}, nil
+}
+
+// terminalWidthOr returns the terminal width or the provided fallback.
+// It first tries term.GetSize, then falls back to $COLUMNS if set.
+func terminalWidthOr(fallback int) int {
+	if w, _, err := term.GetSize(int(os.Stdout.Fd())); err == nil && w > 0 {
+		return w
+	}
+	if cols := os.Getenv("COLUMNS"); cols != "" {
+		if n, err := strconv.Atoi(cols); err == nil && n > 0 {
+			return n
+		}
+	}
+	return fallback
+}
+
+// NewMarkdownRendererWithWidth creates a markdown renderer with a specific width.
+// Useful for tables and other content that should fit within terminal bounds.
+func NewMarkdownRendererWithWidth(width int) (*MarkdownRenderer, error) {
+	r, err := glamour.NewTermRenderer(
+		glamour.WithStandardStyle(detectTerminalTheme()),
+		glamour.WithStylesFromJSONBytes([]byte(glamourStyleJSON(false))),
+		glamour.WithWordWrap(width),
+		glamour.WithPreservedNewLines(),
+	)
+	if err != nil {
+		return nil, err
+	}
+	return &MarkdownRenderer{renderer: r, width: width}, nil
+}
+
+
+// NewMarkdownRendererForTerminal creates a markdown renderer using the actual terminal width.
+// Falls back to 120 if terminal width cannot be determined.
+func NewMarkdownRendererForTerminal() (*MarkdownRenderer, error) {
+	width := terminalWidthOr(120)
+	return NewMarkdownRendererWithWidth(width)
+}
+
+func (mr *MarkdownRenderer) Render(markdown string) (string, error) {
+	rendered, err := mr.renderer.Render(markdown)
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimLeft(strings.TrimRight(rendered, "\n"), "\n"), nil
+}