@caretive/caret-cli 0.0.1

package/pkg/hostbridge/diff.go

@@ -0,0 +1,351 @@
+package hostbridge
+
+import (
+	"context"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	proto "github.com/cline/grpc-go/host"
+)
+
+// diffSession represents an in-memory diff editing session
+type diffSession struct {
+	originalPath    string   // File path from OpenDiff request
+	originalContent []byte   // Original file content (for comparison)
+	currentContent  []byte   // Current modified content
+	lines           []string // Current content split into lines
+	encoding        string   // File encoding (default: utf8)
+}
+
+// DiffService implements the proto.DiffServiceServer interface
+type DiffService struct {
+	proto.UnimplementedDiffServiceServer
+	verbose  bool
+	sessions *sync.Map // thread-safe: diffId -> *diffSession
+	counter  *int64    // atomic counter for unique IDs
+}
+
+// NewDiffService creates a new DiffService
+func NewDiffService(verbose bool) *DiffService {
+	counter := int64(0)
+	return &DiffService{
+		verbose:  verbose,
+		sessions: &sync.Map{},
+		counter:  &counter,
+	}
+}
+
+// generateDiffID creates a unique diff ID
+func (s *DiffService) generateDiffID() string {
+	id := atomic.AddInt64(s.counter, 1)
+	return fmt.Sprintf("diff_%d_%d", os.Getpid(), id)
+}
+
+// splitLines splits content into lines, preserving line ending information
+func splitLines(content string) []string {
+	if content == "" {
+		return []string{}
+	}
+
+	lines := []string{}
+	current := ""
+
+	for _, char := range content {
+		if char == '\n' {
+			lines = append(lines, current)
+			current = ""
+		} else if char != '\r' { // Skip \r characters, handle \r\n as \n
+			current += string(char)
+		}
+	}
+
+	// Add the last line if it doesn't end with newline
+	if current != "" {
+		lines = append(lines, current)
+	}
+
+	return lines
+}
+
+// joinLines joins lines back into content with newlines
+func joinLines(lines []string) string {
+	if len(lines) == 0 {
+		return ""
+	}
+	return strings.Join(lines, "\n")
+}
+
+// OpenDiff opens a diff view for the specified file
+func (s *DiffService) OpenDiff(ctx context.Context, req *proto.OpenDiffRequest) (*proto.OpenDiffResponse, error) {
+	if s.verbose {
+		log.Printf("OpenDiff called for path: %s", req.GetPath())
+	}
+
+	diffID := s.generateDiffID()
+
+	var originalContent []byte
+
+	// Check if file exists and read original content
+	if req.GetPath() != "" {
+		if _, err := os.Stat(req.GetPath()); err == nil {
+			// File exists, read its content
+			var readErr error
+			originalContent, readErr = ioutil.ReadFile(req.GetPath())
+			if readErr != nil {
+				return nil, fmt.Errorf("failed to read original file: %w", readErr)
+			}
+		} else {
+			// File doesn't exist, use empty content
+			originalContent = []byte{}
+		}
+	}
+
+	// Use provided content as the initial current content
+	currentContent := []byte(req.GetContent())
+
+	// Create the diff session
+	session := &diffSession{
+		originalPath:    req.GetPath(),
+		originalContent: originalContent,
+		currentContent:  currentContent,
+		lines:           splitLines(req.GetContent()),
+		encoding:        "utf8", // Default encoding
+	}
+
+	// Store the session
+	s.sessions.Store(diffID, session)
+
+	if s.verbose {
+		log.Printf("Created diff session: %s (original: %d bytes, current: %d bytes)",
+			diffID, len(originalContent), len(currentContent))
+	}
+
+	return &proto.OpenDiffResponse{
+		DiffId: &diffID,
+	}, nil
+}
+
+// GetDocumentText returns the current content of the diff document
+func (s *DiffService) GetDocumentText(ctx context.Context, req *proto.GetDocumentTextRequest) (*proto.GetDocumentTextResponse, error) {
+	if s.verbose {
+		log.Printf("GetDocumentText called for diff ID: %s", req.GetDiffId())
+	}
+
+	sessionInterface, exists := s.sessions.Load(req.GetDiffId())
+	if !exists {
+		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
+	}
+
+	session := sessionInterface.(*diffSession)
+	content := string(session.currentContent)
+
+	return &proto.GetDocumentTextResponse{
+		Content: &content,
+	}, nil
+}
+
+// ReplaceText replaces text in the diff document using line-based operations
+func (s *DiffService) ReplaceText(ctx context.Context, req *proto.ReplaceTextRequest) (*proto.ReplaceTextResponse, error) {
+	if s.verbose {
+		log.Printf("ReplaceText called for diff ID: %s, lines %d-%d",
+			req.GetDiffId(), req.GetStartLine(), req.GetEndLine())
+	}
+
+	sessionInterface, exists := s.sessions.Load(req.GetDiffId())
+	if !exists {
+		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
+	}
+
+	session := sessionInterface.(*diffSession)
+
+	startLine := int(req.GetStartLine())
+	endLine := int(req.GetEndLine())
+	newContent := req.GetContent()
+
+	// Validate line ranges
+	if startLine < 0 {
+		startLine = 0
+	}
+	if endLine < startLine {
+		endLine = startLine
+	}
+
+	// Split new content into lines
+	newLines := splitLines(newContent)
+
+	// Ensure we have enough lines in the current content
+	for len(session.lines) < endLine {
+		session.lines = append(session.lines, "")
+	}
+
+	// Replace the specified line range
+	if endLine > len(session.lines) {
+		// Extending beyond current content - append new lines
+		session.lines = append(session.lines[:startLine], newLines...)
+	} else {
+		// Replace within existing content
+		result := make([]string, 0, len(session.lines)-endLine+startLine+len(newLines))
+		result = append(result, session.lines[:startLine]...)
+		result = append(result, newLines...)
+		result = append(result, session.lines[endLine:]...)
+		session.lines = result
+	}
+
+	// Update current content
+	session.currentContent = []byte(joinLines(session.lines))
+
+	// Store the updated session
+	s.sessions.Store(req.GetDiffId(), session)
+
+	if s.verbose {
+		log.Printf("Updated diff session %s: %d lines, %d bytes",
+			req.GetDiffId(), len(session.lines), len(session.currentContent))
+	}
+
+	return &proto.ReplaceTextResponse{}, nil
+}
+
+// ScrollDiff scrolls the diff view to a specific line (no-op for CLI)
+func (s *DiffService) ScrollDiff(ctx context.Context, req *proto.ScrollDiffRequest) (*proto.ScrollDiffResponse, error) {
+	if s.verbose {
+		log.Printf("ScrollDiff called for diff ID: %s, line: %d", req.GetDiffId(), req.GetLine())
+	}
+
+	// Verify session exists
+	if _, exists := s.sessions.Load(req.GetDiffId()); !exists {
+		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
+	}
+
+	// In a CLI implementation, scrolling is a no-op
+	// In a GUI implementation, this would scroll the view to the specified line
+	return &proto.ScrollDiffResponse{}, nil
+}
+
+// TruncateDocument truncates the diff document at the specified line
+func (s *DiffService) TruncateDocument(ctx context.Context, req *proto.TruncateDocumentRequest) (*proto.TruncateDocumentResponse, error) {
+	if s.verbose {
+		log.Printf("TruncateDocument called for diff ID: %s, end line: %d", req.GetDiffId(), req.GetEndLine())
+	}
+
+	sessionInterface, exists := s.sessions.Load(req.GetDiffId())
+	if !exists {
+		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
+	}
+
+	session := sessionInterface.(*diffSession)
+	endLine := int(req.GetEndLine())
+
+	// Truncate lines at the specified position
+	if endLine >= 0 && endLine < len(session.lines) {
+		session.lines = session.lines[:endLine]
+		session.currentContent = []byte(joinLines(session.lines))
+
+		// Store the updated session
+		s.sessions.Store(req.GetDiffId(), session)
+
+		if s.verbose {
+			log.Printf("Truncated diff session %s to %d lines", req.GetDiffId(), len(session.lines))
+		}
+	}
+
+	return &proto.TruncateDocumentResponse{}, nil
+}
+
+// SaveDocument saves the diff document to the original file
+func (s *DiffService) SaveDocument(ctx context.Context, req *proto.SaveDocumentRequest) (*proto.SaveDocumentResponse, error) {
+	if s.verbose {
+		log.Printf("SaveDocument called for diff ID: %s", req.GetDiffId())
+	}
+
+	sessionInterface, exists := s.sessions.Load(req.GetDiffId())
+	if !exists {
+		return nil, fmt.Errorf("diff session not found: %s", req.GetDiffId())
+	}
+
+	session := sessionInterface.(*diffSession)
+
+	if session.originalPath == "" {
+		return nil, fmt.Errorf("no file path specified for diff session: %s", req.GetDiffId())
+	}
+
+	// Create parent directories if they don't exist
+	dir := filepath.Dir(session.originalPath)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create directories: %w", err)
+	}
+
+	// Write the current content to the original file
+	if err := ioutil.WriteFile(session.originalPath, session.currentContent, 0644); err != nil {
+		return nil, fmt.Errorf("failed to save file: %w", err)
+	}
+
+	if s.verbose {
+		log.Printf("Saved diff session %s to file: %s (%d bytes)",
+			req.GetDiffId(), session.originalPath, len(session.currentContent))
+	}
+
+	return &proto.SaveDocumentResponse{}, nil
+}
+
+// CloseAllDiffs closes all diff views and cleans up all sessions
+func (s *DiffService) CloseAllDiffs(ctx context.Context, req *proto.CloseAllDiffsRequest) (*proto.CloseAllDiffsResponse, error) {
+	if s.verbose {
+		log.Printf("CloseAllDiffs called")
+	}
+
+	var count int64
+
+	s.sessions.Range(func(key, value any) bool {
+		// Optional: attempt to close if the value supports it
+		if c, ok := value.(interface{ Close() error }); ok {
+			_ = c.Close() // best-effort; ignore error
+		}
+
+		s.sessions.Delete(key)
+		atomic.AddInt64(&count, 1)
+		return true
+	})
+
+	if s.verbose {
+		log.Printf("Closed %d diff sessions", count)
+	}
+
+	return &proto.CloseAllDiffsResponse{}, nil
+}
+
+// OpenMultiFileDiff displays a diff view comparing before/after states for multiple files
+func (s *DiffService) OpenMultiFileDiff(ctx context.Context, req *proto.OpenMultiFileDiffRequest) (*proto.OpenMultiFileDiffResponse, error) {
+	if s.verbose {
+		log.Printf("OpenMultiFileDiff called with title: %s, %d files", req.GetTitle(), len(req.GetDiffs()))
+	}
+
+	// In a CLI implementation, we could display the diffs to console
+	// For now, we'll just log the information
+	title := req.GetTitle()
+	if title == "" {
+		title = "Multi-file diff"
+	}
+
+	if s.verbose {
+		log.Printf("=== %s ===", title)
+		for i, diff := range req.GetDiffs() {
+			log.Printf("File %d: %s", i+1, diff.GetFilePath())
+			log.Printf("  Left content: %d bytes", len(diff.GetLeftContent()))
+			log.Printf("  Right content: %d bytes", len(diff.GetRightContent()))
+		}
+	}
+
+	// In a more sophisticated CLI implementation, we could:
+	// 1. Use a diff library to generate unified diffs
+	// 2. Display them with colors
+	// 3. Allow navigation between files
+	// For now, this is a no-op that just acknowledges the request
+
+	return &proto.OpenMultiFileDiffResponse{}, nil
+}

package/pkg/hostbridge/disabled/watch.go

@@ -0,0 +1,39 @@
+package hostbridge
+
+import (
+	"log"
+
+	"github.com/cline/grpc-go/host"
+)
+
+// WatchService implements the host.WatchServiceServer interface
+type WatchService struct {
+	host.UnimplementedWatchServiceServer
+	coreAddress string
+	verbose     bool
+}
+
+// NewWatchService creates a new WatchService
+func NewWatchService(coreAddress string, verbose bool) *WatchService {
+	return &WatchService{
+		coreAddress: coreAddress,
+		verbose:     verbose,
+	}
+}
+
+// SubscribeToFile subscribes to file change notifications
+func (s *WatchService) SubscribeToFile(req *host.SubscribeToFileRequest, stream host.WatchService_SubscribeToFileServer) error {
+	if s.verbose {
+		log.Printf("SubscribeToFile called for path: %s", req.GetPath())
+	}
+
+	// For console implementation, we'll just log that we would watch the file
+	// In a real implementation, we'd use fsnotify or similar to watch file changes
+	log.Printf("[Cline] Would watch file: %s", req.GetPath())
+
+	// Keep the stream open but don't send any events for now
+	// In a real implementation, we'd send FileChangeEvent messages when files change
+	<-stream.Context().Done()
+
+	return nil
+}

package/pkg/hostbridge/disabled/window.go

@@ -0,0 +1,63 @@
+package hostbridge
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	proto "github.com/cline/grpc-go/host"
+)
+
+// WindowService implements the proto.WindowServiceServer interface
+type WindowService struct {
+	proto.UnimplementedWindowServiceServer
+	coreAddress string
+	verbose     bool
+}
+
+// NewWindowService creates a new WindowService
+func NewWindowService(coreAddress string, verbose bool) *WindowService {
+	return &WindowService{
+		coreAddress: coreAddress,
+		verbose:     verbose,
+	}
+}
+
+// ShowTextDocument opens a text document for viewing/editing
+func (s *WindowService) ShowTextDocument(ctx context.Context, req *proto.ShowTextDocumentRequest) (*proto.TextEditorInfo, error) {
+	if s.verbose {
+		log.Printf("ShowTextDocument called for path: %s", req.GetPath())
+	}
+
+	// For console implementation, we'll just log that we would open the document
+	fmt.Printf("[Cline] Would open document: %s\n", req.GetPath())
+
+	return &proto.TextEditorInfo{
+		DocumentPath: req.GetPath(),
+		IsActive:     true,
+	}, nil
+}
+
+// ShowOpenDialogue shows a file open dialog
+func (s *WindowService) ShowOpenDialogue(ctx context.Context, req *proto.ShowOpenDialogueRequest) (*proto.SelectedResources, error) {
+	if s.verbose {
+		log.Printf("ShowOpenDialogue called")
+	}
+
+	// For console implementation, return empty list (user cancelled)
+	return &proto.SelectedResources{
+		Paths: []string{},
+	}, nil
+}
+
+// ShowMessage displays a message to the user
+func (s *WindowService) ShowMessage(ctx context.Context, req *proto.ShowMessageRequest) (*proto.SelectedResponse, error) {
+	if s.verbose {
+		log.Printf("ShowMessage called: %s", req.GetMessage())
+	}
+
+	// Display message to console
+	fmt.Printf("[Cline] %s\n", req.GetMessage())
+
+	return &proto.SelectedResponse{}, nil
+}

package/pkg/hostbridge/disabled/workspace.go

@@ -0,0 +1,66 @@
+package hostbridge
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"github.com/cline/grpc-go/host"
+)
+
+// WorkspaceService implements the host.WorkspaceServiceServer interface
+type WorkspaceService struct {
+	host.UnimplementedWorkspaceServiceServer
+	coreAddress string
+	verbose     bool
+}
+
+// NewWorkspaceService creates a new WorkspaceService
+func NewWorkspaceService(coreAddress string, verbose bool) *WorkspaceService {
+	return &WorkspaceService{
+		coreAddress: coreAddress,
+		verbose:     verbose,
+	}
+}
+
+// GetWorkspacePaths returns the workspace directory paths
+func (s *WorkspaceService) GetWorkspacePaths(ctx context.Context, req *host.GetWorkspacePathsRequest) (*host.GetWorkspacePathsResponse, error) {
+	if s.verbose {
+		log.Printf("GetWorkspacePaths called")
+	}
+
+	// Get current working directory as the workspace
+	cwd, err := os.Getwd()
+	if err != nil {
+		return nil, err
+	}
+
+	return &host.GetWorkspacePathsResponse{
+		Paths: []string{cwd},
+	}, nil
+}
+
+// SaveOpenDocumentIfDirty saves an open document if it has unsaved changes
+func (s *WorkspaceService) SaveOpenDocumentIfDirty(ctx context.Context, req *host.SaveOpenDocumentIfDirtyRequest) (*host.SaveOpenDocumentIfDirtyResponse, error) {
+	if s.verbose {
+		log.Printf("SaveOpenDocumentIfDirty called for path: %s", req.GetPath())
+	}
+
+	// For console implementation, we'll assume the document is already saved
+	// In a real implementation, we'd check if the file has unsaved changes
+	return &host.SaveOpenDocumentIfDirtyResponse{
+		WasSaved: false, // Assume no changes to save
+	}, nil
+}
+
+// GetDiagnostics returns diagnostic information for a file
+func (s *WorkspaceService) GetDiagnostics(ctx context.Context, req *host.GetDiagnosticsRequest) (*host.GetDiagnosticsResponse, error) {
+	if s.verbose {
+		log.Printf("GetDiagnostics called for path: %s", req.GetPath())
+	}
+
+	// For console implementation, return empty diagnostics
+	return &host.GetDiagnosticsResponse{
+		Diagnostics: []*host.Diagnostic{},
+	}, nil
+}

package/pkg/hostbridge/env.go

@@ -0,0 +1,166 @@
+package hostbridge
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"github.com/atotto/clipboard"
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/grpc-go/cline"
+	"github.com/cline/grpc-go/host"
+	"google.golang.org/protobuf/proto"
+)
+
+// Global shutdown channel - simple approach
+var globalShutdownCh chan struct{}
+
+func init() {
+	globalShutdownCh = make(chan struct{})
+}
+
+// EnvService implements the host.EnvServiceServer interface
+type EnvService struct {
+	host.UnimplementedEnvServiceServer
+	verbose bool
+}
+
+// NewEnvService creates a new EnvService
+func NewEnvService(verbose bool) *EnvService {
+	return &EnvService{
+		verbose: verbose,
+	}
+}
+
+// ClipboardWriteText writes text to the system clipboard
+func (s *EnvService) ClipboardWriteText(ctx context.Context, req *cline.StringRequest) (*cline.Empty, error) {
+	if s.verbose {
+		log.Printf("ClipboardWriteText called with text length: %d", len(req.GetValue()))
+	}
+
+	err := clipboard.WriteAll(req.GetValue())
+	if err != nil {
+		if s.verbose {
+			log.Printf("Failed to write to clipboard: %v", err)
+		}
+		// Don't fail if clipboard is not available (e.g., headless environment)
+	}
+
+	return &cline.Empty{}, nil
+}
+
+// ClipboardReadText reads text from the system clipboard
+func (s *EnvService) ClipboardReadText(ctx context.Context, req *cline.EmptyRequest) (*cline.String, error) {
+	if s.verbose {
+		log.Printf("ClipboardReadText called")
+	}
+
+	text, err := clipboard.ReadAll()
+	if err != nil {
+		if s.verbose {
+			log.Printf("Failed to read from clipboard: %v", err)
+		}
+		// Return empty string if clipboard is not available
+		text = ""
+	}
+
+	return &cline.String{
+		Value: text,
+	}, nil
+}
+
+// GetHostVersion returns the host platform name and version
+func (s *EnvService) GetHostVersion(ctx context.Context, req *cline.EmptyRequest) (*host.GetHostVersionResponse, error) {
+	if s.verbose {
+		log.Printf("GetHostVersion called")
+	}
+
+	return &host.GetHostVersionResponse{
+		Platform:     proto.String("Cline CLI"),
+		Version:      proto.String(""),
+		ClineType:    proto.String("CLI"),
+		ClineVersion: proto.String(global.CliVersion),
+	}, nil
+}
+
+// Shutdown initiates a graceful shutdown of the host bridge service
+func (s *EnvService) Shutdown(ctx context.Context, req *cline.EmptyRequest) (*cline.Empty, error) {
+	if s.verbose {
+		log.Printf("Shutdown requested via RPC")
+	}
+
+	// Trigger global shutdown signal
+	select {
+	case globalShutdownCh <- struct{}{}:
+		if s.verbose {
+			log.Printf("Shutdown signal sent successfully")
+		}
+	default:
+		if s.verbose {
+			log.Printf("Shutdown signal already pending")
+		}
+	}
+
+	return &cline.Empty{}, nil
+}
+
+// GetTelemetrySettings returns the telemetry settings for CLI mode
+func (s *EnvService) GetTelemetrySettings(ctx context.Context, req *cline.EmptyRequest) (*host.GetTelemetrySettingsResponse, error) {
+	if s.verbose {
+		log.Printf("GetTelemetrySettings called")
+	}
+
+	// In CLI mode, check the POSTHOG_TELEMETRY_ENABLED environment variable
+	telemetryEnabled := os.Getenv("POSTHOG_TELEMETRY_ENABLED") == "true"
+
+	var setting host.Setting
+	if telemetryEnabled {
+		setting = host.Setting_ENABLED
+	} else {
+		setting = host.Setting_DISABLED
+	}
+
+	return &host.GetTelemetrySettingsResponse{
+		IsEnabled: setting,
+	}, nil
+}
+
+// SubscribeToTelemetrySettings returns a stream of telemetry setting changes
+// In CLI mode, telemetry settings don't change at runtime, so we just send
+// the current state and keep the stream open
+func (s *EnvService) SubscribeToTelemetrySettings(req *cline.EmptyRequest, stream host.EnvService_SubscribeToTelemetrySettingsServer) error {
+	if s.verbose {
+		log.Printf("SubscribeToTelemetrySettings called")
+	}
+
+	// Send initial telemetry state
+	telemetryEnabled := os.Getenv("POSTHOG_TELEMETRY_ENABLED") == "true"
+
+	var setting host.Setting
+	if telemetryEnabled {
+		setting = host.Setting_ENABLED
+	} else {
+		setting = host.Setting_DISABLED
+	}
+
+	event := &host.TelemetrySettingsEvent{
+		IsEnabled: setting,
+	}
+
+	if err := stream.Send(event); err != nil {
+		if s.verbose {
+			log.Printf("Failed to send telemetry settings event: %v", err)
+		}
+		return err
+	}
+
+	// Keep stream open until context is cancelled
+	// (In CLI mode, settings don't change dynamically)
+	<-stream.Context().Done()
+
+	if s.verbose {
+		log.Printf("SubscribeToTelemetrySettings stream closed")
+	}
+
+	return nil
+}