@dcode-dev/dcode-cli 1.0.0

package/internal/ai/tools.go

@@ -0,0 +1,332 @@
+package ai
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+)
+
+// Tool represents a function/tool schema for Gemini
+type Tool struct {
+	FunctionDeclarations []FunctionDeclaration `json:"functionDeclarations"`
+}
+
+// FunctionDeclaration defines a function schema
+type FunctionDeclaration struct {
+	Name        string                 `json:"name"`
+	Description string                 `json:"description"`
+	Parameters  map[string]interface{} `json:"parameters"`
+}
+
+// FunctionCall represents a function call from the AI
+type FunctionCall struct {
+	Name string                 `json:"name"`
+	Args map[string]interface{} `json:"args"`
+}
+
+// FunctionResponse represents the result of a function call
+type FunctionResponse struct {
+	Name     string                 `json:"name"`
+	Response map[string]interface{} `json:"response"`
+}
+
+// ChatWithTools calls Gemini with function calling support
+func (c *Client) ChatWithTools(ctx context.Context, messages []Message, tools []Tool) (*ToolResponse, error) {
+	if c.Provider != ProviderGemini {
+		// Fallback for non-Gemini providers
+		resp, err := c.ChatWithContext(ctx, messages)
+		return &ToolResponse{
+			Text:          resp,
+			FunctionCalls: nil,
+		}, err
+	}
+
+	type Part struct {
+		Text         string        `json:"text,omitempty"`
+		FunctionCall *FunctionCall `json:"functionCall,omitempty"`
+	}
+
+	type Content struct {
+		Parts []Part `json:"parts"`
+		Role  string `json:"role,omitempty"`
+	}
+
+	type Request struct {
+		Contents          []Content `json:"contents"`
+		Tools             []Tool    `json:"tools,omitempty"`
+		SystemInstruction *Content  `json:"systemInstruction,omitempty"`
+	}
+
+	type Response struct {
+		Candidates []struct {
+			Content       Content `json:"content"`
+			FinishReason  string  `json:"finishReason,omitempty"`
+			SafetyRatings []struct {
+				Category    string `json:"category"`
+				Probability string `json:"probability"`
+			} `json:"safetyRatings,omitempty"`
+		} `json:"candidates"`
+	}
+
+	// Convert messages to Gemini format
+	var contents []Content
+	var systemInstruction *Content
+	
+	for _, msg := range messages {
+		role := msg.Role
+		if role == "system" {
+			// System messages go in systemInstruction field
+			systemInstruction = &Content{
+				Parts: []Part{{Text: msg.Content}},
+			}
+			continue
+		}
+		
+		if role == "assistant" {
+			role = "model"
+		} else if role == "tool" || role == "function" {
+			// Tool results become user role (Gemini doesn't accept "tool" or "function")
+			role = "user"
+		}
+		
+		contents = append(contents, Content{
+			Parts: []Part{{Text: msg.Content}},
+			Role:  role,
+		})
+	}
+
+	reqBody := Request{
+		Contents:          contents,
+		Tools:             tools,
+		SystemInstruction: systemInstruction,
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	url := fmt.Sprintf("https://generativelanguage.googleapis.com/v1beta/models/%s:generateContent?key=%s", c.Model, c.APIKey)
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: 90 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("API error (%d): %s", resp.StatusCode, string(body))
+	}
+
+	var response Response
+	if err := json.Unmarshal(body, &response); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+
+	if len(response.Candidates) == 0 {
+		return nil, fmt.Errorf("no response from API")
+	}
+
+	candidate := response.Candidates[0]
+	
+	// Extract text and function calls
+	var text string
+	var functionCalls []FunctionCall
+	
+	for _, part := range candidate.Content.Parts {
+		if part.Text != "" {
+			text += part.Text
+		}
+		if part.FunctionCall != nil {
+			functionCalls = append(functionCalls, *part.FunctionCall)
+		}
+	}
+
+	return &ToolResponse{
+		Text:          text,
+		FunctionCalls: functionCalls,
+		FinishReason:  candidate.FinishReason,
+	}, nil
+}
+
+// ToolResponse contains the response with potential function calls
+type ToolResponse struct {
+	Text          string
+	FunctionCalls []FunctionCall
+	FinishReason  string
+}
+
+// ChatWithToolsStream calls Gemini with streaming and function calling
+func (c *Client) ChatWithToolsStream(ctx context.Context, messages []Message, tools []Tool, onChunk func(string)) (*ToolResponse, error) {
+	if c.Provider != ProviderGemini {
+		// Fallback for non-Gemini providers
+		resp, err := c.ChatWithContext(ctx, messages)
+		if onChunk != nil && resp != "" {
+			onChunk(resp)
+		}
+		return &ToolResponse{
+			Text:          resp,
+			FunctionCalls: nil,
+		}, err
+	}
+
+	type Part struct {
+		Text         string        `json:"text,omitempty"`
+		FunctionCall *FunctionCall `json:"functionCall,omitempty"`
+	}
+
+	type Content struct {
+		Parts []Part `json:"parts"`
+		Role  string `json:"role,omitempty"`
+	}
+
+	type Request struct {
+		Contents          []Content `json:"contents"`
+		Tools             []Tool    `json:"tools,omitempty"`
+		SystemInstruction *Content  `json:"systemInstruction,omitempty"`
+	}
+
+	// Convert messages to Gemini format
+	var contents []Content
+	var systemInstruction *Content
+	
+	for _, msg := range messages {
+		role := msg.Role
+		if role == "system" {
+			// System messages go in systemInstruction field
+			systemInstruction = &Content{
+				Parts: []Part{{Text: msg.Content}},
+			}
+			continue
+		}
+		
+		if role == "assistant" {
+			role = "model"
+		} else if role == "tool" || role == "function" {
+			// Tool results become user role (Gemini doesn't accept "tool" or "function")
+			role = "user"
+		}
+		
+		contents = append(contents, Content{
+			Parts: []Part{{Text: msg.Content}},
+			Role:  role,
+		})
+	}
+
+	reqBody := Request{
+		Contents:          contents,
+		Tools:             tools,
+		SystemInstruction: systemInstruction,
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	// Use streaming endpoint
+	url := fmt.Sprintf("https://generativelanguage.googleapis.com/v1beta/models/%s:streamGenerateContent?key=%s&alt=sse", c.Model, c.APIKey)
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "text/event-stream")
+
+	client := &http.Client{Timeout: 120 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("API error (%d): %s", resp.StatusCode, string(body))
+	}
+
+	// Parse SSE stream
+	var fullText string
+	var functionCalls []FunctionCall
+	var finishReason string
+
+	scanner := bufio.NewScanner(resp.Body)
+	for scanner.Scan() {
+		line := scanner.Text()
+		
+		// Skip empty lines and comments
+		if line == "" || line[0] == ':' {
+			continue
+		}
+		
+		// Parse data: lines
+		if len(line) > 6 && line[:6] == "data: " {
+			data := line[6:]
+			
+			// Parse JSON chunk
+			var chunk struct {
+				Candidates []struct {
+					Content struct {
+						Parts []Part `json:"parts"`
+					} `json:"content"`
+					FinishReason string `json:"finishReason,omitempty"`
+				} `json:"candidates"`
+			}
+			
+			if err := json.Unmarshal([]byte(data), &chunk); err != nil {
+				continue
+			}
+			
+			if len(chunk.Candidates) == 0 {
+				continue
+			}
+			
+			candidate := chunk.Candidates[0]
+			
+			// Extract text and function calls
+			for _, part := range candidate.Content.Parts {
+				if part.Text != "" {
+					fullText += part.Text
+					if onChunk != nil {
+						onChunk(part.Text)
+					}
+				}
+				if part.FunctionCall != nil {
+					functionCalls = append(functionCalls, *part.FunctionCall)
+				}
+			}
+			
+			if candidate.FinishReason != "" {
+				finishReason = candidate.FinishReason
+			}
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("error reading stream: %w", err)
+	}
+
+	return &ToolResponse{
+		Text:          fullText,
+		FunctionCalls: functionCalls,
+		FinishReason:  finishReason,
+	}, nil
+}

package/internal/auth/adc.go

@@ -0,0 +1,108 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+
+	"cloud.google.com/go/compute/metadata"
+	"golang.org/x/oauth2/google"
+)
+
+// ADCAuth implements Application Default Credentials authentication
+type ADCAuth struct {
+	provider string
+	scopes   []string
+}
+
+// NewADCAuth creates a new ADC authenticator
+func NewADCAuth(provider string, scopes []string) *ADCAuth {
+	if len(scopes) == 0 {
+		scopes = []string{
+			"https://www.googleapis.com/auth/cloud-platform",
+		}
+	}
+	
+	return &ADCAuth{
+		provider: provider,
+		scopes:   scopes,
+	}
+}
+
+// GetToken returns a valid access token from ADC
+func (a *ADCAuth) GetToken(ctx context.Context) (string, error) {
+	// Try to get credentials from ADC
+	creds, err := google.FindDefaultCredentials(ctx, a.scopes...)
+	if err != nil {
+		return "", fmt.Errorf("failed to find default credentials: %w", err)
+	}
+	
+	// Get token
+	token, err := creds.TokenSource.Token()
+	if err != nil {
+		return "", fmt.Errorf("failed to get token: %w", err)
+	}
+	
+	return token.AccessToken, nil
+}
+
+// Refresh is handled automatically by the Google libraries
+func (a *ADCAuth) Refresh(ctx context.Context) error {
+	// ADC handles refresh automatically
+	return nil
+}
+
+// Validate checks if ADC credentials are available
+func (a *ADCAuth) Validate(ctx context.Context) error {
+	_, err := google.FindDefaultCredentials(ctx, a.scopes...)
+	if err != nil {
+		return fmt.Errorf("ADC not available: %w", err)
+	}
+	return nil
+}
+
+// GetType returns the auth type
+func (a *ADCAuth) GetType() AuthType {
+	return AuthTypeADC
+}
+
+// GetProvider returns the provider name
+func (a *ADCAuth) GetProvider() string {
+	return a.provider
+}
+
+// Revoke is not applicable for ADC
+func (a *ADCAuth) Revoke(ctx context.Context) error {
+	return fmt.Errorf("cannot revoke ADC credentials")
+}
+
+// GetTokenInfo returns token information
+func (a *ADCAuth) GetTokenInfo(ctx context.Context) (*TokenInfo, error) {
+	creds, err := google.FindDefaultCredentials(ctx, a.scopes...)
+	if err != nil {
+		return &TokenInfo{Valid: false, Provider: a.provider}, nil
+	}
+	
+	token, err := creds.TokenSource.Token()
+	if err != nil {
+		return &TokenInfo{Valid: false, Provider: a.provider}, nil
+	}
+	
+	// Try to get user info from metadata server (if on GCE)
+	var user string
+	if metadata.OnGCE() {
+		user, _ = metadata.Email("")
+	}
+	
+	return &TokenInfo{
+		Valid:     token.Valid(),
+		ExpiresAt: token.Expiry,
+		Provider:  a.provider,
+		User:      user,
+	}, nil
+}
+
+// IsAvailable checks if ADC is available in the current environment
+func IsADCAvailable(ctx context.Context) bool {
+	_, err := google.FindDefaultCredentials(ctx)
+	return err == nil
+}

package/internal/auth/apikey.go

@@ -0,0 +1,67 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// APIKeyAuth implements authentication using API keys
+type APIKeyAuth struct {
+	apiKey   string
+	provider string
+}
+
+// NewAPIKeyAuth creates a new API key authenticator
+func NewAPIKeyAuth(provider, apiKey string) *APIKeyAuth {
+	return &APIKeyAuth{
+		provider: provider,
+		apiKey:   apiKey,
+	}
+}
+
+// GetToken returns the API key
+func (a *APIKeyAuth) GetToken(ctx context.Context) (string, error) {
+	if a.apiKey == "" {
+		return "", fmt.Errorf("API key not set for provider: %s", a.provider)
+	}
+	return a.apiKey, nil
+}
+
+// Refresh is a no-op for API keys
+func (a *APIKeyAuth) Refresh(ctx context.Context) error {
+	return nil // API keys don't need refresh
+}
+
+// Validate checks if the API key is set
+func (a *APIKeyAuth) Validate(ctx context.Context) error {
+	if a.apiKey == "" {
+		return fmt.Errorf("API key not set")
+	}
+	return nil
+}
+
+// GetType returns the auth type
+func (a *APIKeyAuth) GetType() AuthType {
+	return AuthTypeAPIKey
+}
+
+// GetProvider returns the provider name
+func (a *APIKeyAuth) GetProvider() string {
+	return a.provider
+}
+
+// Revoke is a no-op for API keys
+func (a *APIKeyAuth) Revoke(ctx context.Context) error {
+	a.apiKey = ""
+	return nil
+}
+
+// GetTokenInfo returns token information
+func (a *APIKeyAuth) GetTokenInfo(ctx context.Context) (*TokenInfo, error) {
+	return &TokenInfo{
+		Valid:     a.apiKey != "",
+		Provider:  a.provider,
+		ExpiresAt: time.Time{}, // API keys don't expire
+	}, nil
+}

package/internal/auth/factory.go

@@ -0,0 +1,145 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/ddhanush1/dcode/internal/config"
+)
+
+// Factory creates authenticators based on configuration
+type Factory struct {
+	store CredentialStore
+}
+
+// NewFactory creates a new auth factory
+func NewFactory(store CredentialStore) *Factory {
+	if store == nil {
+		store = NewKeyringStore()
+	}
+	return &Factory{
+		store: store,
+	}
+}
+
+// CreateFromConfig creates an authenticator from config
+func (f *Factory) CreateFromConfig(cfg *config.Config) (Authenticator, error) {
+	authType := AuthType(cfg.Auth.Type)
+	provider := cfg.Auth.Provider
+	
+	switch authType {
+	case AuthTypeAPIKey:
+		apiKey := cfg.Auth.APIKey
+		if apiKey == "" {
+			// Try to get from environment
+			apiKey = getAPIKeyFromEnv(provider)
+		}
+		
+		if apiKey == "" {
+			return nil, fmt.Errorf("API key not found for provider: %s", provider)
+		}
+		
+		return NewAPIKeyAuth(provider, apiKey), nil
+		
+	case AuthTypeOAuth2:
+		// For OAuth2, we need client credentials
+		clientID := os.Getenv("GOOGLE_CLIENT_ID")
+		clientSecret := os.Getenv("GOOGLE_CLIENT_SECRET")
+		
+		if clientID == "" || clientSecret == "" {
+			return nil, fmt.Errorf("OAuth2 requires GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET")
+		}
+		
+		scopes := []string{
+			"https://www.googleapis.com/auth/userinfo.email",
+			"https://www.googleapis.com/auth/cloud-platform",
+		}
+		
+		return NewOAuth2Auth(provider, clientID, clientSecret, scopes, f.store), nil
+		
+	case AuthTypeADC:
+		scopes := []string{
+			"https://www.googleapis.com/auth/cloud-platform",
+		}
+		return NewADCAuth(provider, scopes), nil
+		
+	case AuthTypeVertexAI:
+		project := cfg.Auth.Project
+		if project == "" {
+			project = os.Getenv("GOOGLE_CLOUD_PROJECT")
+		}
+		
+		location := cfg.Auth.Location
+		if location == "" {
+			location = os.Getenv("GOOGLE_CLOUD_LOCATION")
+			if location == "" {
+				location = "us-central1"
+			}
+		}
+		
+		apiKey := os.Getenv("GOOGLE_API_KEY")
+		
+		return NewVertexAIAuth(provider, project, location, apiKey, f.store), nil
+		
+	default:
+		return nil, fmt.Errorf("unsupported auth type: %s", authType)
+	}
+}
+
+// CreateFromProvider creates an authenticator for a specific provider
+func (f *Factory) CreateFromProvider(provider string) (Authenticator, error) {
+	// Try to load existing credentials
+	creds, err := f.store.Load(provider)
+	if err == nil {
+		// Create authenticator based on stored credentials
+		switch creds.Type {
+		case AuthTypeAPIKey:
+			return NewAPIKeyAuth(provider, creds.Token), nil
+		case AuthTypeOAuth2:
+			// OAuth2 will load token from store
+			clientID := os.Getenv("GOOGLE_CLIENT_ID")
+			clientSecret := os.Getenv("GOOGLE_CLIENT_SECRET")
+			scopes := []string{"https://www.googleapis.com/auth/cloud-platform"}
+			return NewOAuth2Auth(provider, clientID, clientSecret, scopes, f.store), nil
+		}
+	}
+	
+	// Fall back to API key from environment
+	apiKey := getAPIKeyFromEnv(provider)
+	if apiKey != "" {
+		return NewAPIKeyAuth(provider, apiKey), nil
+	}
+	
+	// Try ADC
+	ctx := context.Background()
+	if IsADCAvailable(ctx) {
+		return NewADCAuth(provider, []string{"https://www.googleapis.com/auth/cloud-platform"}), nil
+	}
+	
+	return nil, fmt.Errorf("no credentials found for provider: %s", provider)
+}
+
+// getAPIKeyFromEnv gets API key from environment based on provider
+func getAPIKeyFromEnv(provider string) string {
+	switch provider {
+	case "openai":
+		return os.Getenv("OPENAI_API_KEY")
+	case "gemini":
+		key := os.Getenv("GEMINI_API_KEY")
+		if key == "" {
+			key = os.Getenv("GOOGLE_API_KEY")
+		}
+		return key
+	case "claude", "anthropic":
+		return os.Getenv("ANTHROPIC_API_KEY")
+	default:
+		return ""
+	}
+}
+
+// GetDefaultStore returns the default credential store
+func GetDefaultStore() CredentialStore {
+	// Try keyring first, fall back to file
+	return NewKeyringStore()
+}