@dcode-dev/dcode-cli 1.0.0

package/internal/ai/client.go

@@ -0,0 +1,634 @@
+package ai
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+type Provider string
+
+const (
+	ProviderOpenAI  Provider = "openai"
+	ProviderGemini  Provider = "gemini"
+	ProviderClaude  Provider = "claude"
+	ProviderGitHub  Provider = "github"
+	ProviderCopilot Provider = "copilot"
+)
+
+type Message struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type ImageInput struct {
+	Mime       string `json:"mime"`
+	DataBase64 string `json:"data_base64"` // may be raw base64 or data-url
+}
+
+type Client struct {
+	Provider Provider
+	Model    string
+	APIKey   string
+}
+
+func NewClient() (*Client, error) {
+	provider := os.Getenv("AI_PROVIDER")
+	if provider == "" {
+		provider = "openai" // Default to OpenAI
+	}
+
+	var apiKey string
+	var model string
+
+	switch Provider(provider) {
+	case ProviderOpenAI:
+		apiKey = os.Getenv("OPENAI_API_KEY")
+		model = os.Getenv("AI_MODEL")
+		if model == "" {
+			model = "gpt-5-mini" // Latest fast model
+		}
+	case ProviderGemini:
+		apiKey = os.Getenv("GEMINI_API_KEY")
+		model = os.Getenv("AI_MODEL")
+		if model == "" {
+			model = "gemini-3-flash-preview" // Latest fast model
+		}
+	case ProviderClaude:
+		apiKey = os.Getenv("CLAUDE_API_KEY")
+		model = os.Getenv("AI_MODEL")
+		if model == "" {
+			model = "claude-3-5-sonnet-20241022" // Latest model
+		}
+	case ProviderGitHub:
+		// Get GitHub token from gh CLI
+		apiKey = os.Getenv("GITHUB_TOKEN")
+		if apiKey == "" {
+			// Try to get token from gh CLI
+			apiKey = getGitHubToken()
+		}
+		model = os.Getenv("AI_MODEL")
+		if model == "" {
+			model = "gpt-4o" // Default GitHub Models model
+		}
+	case ProviderCopilot:
+		// Get Copilot token from config
+		apiKey = os.Getenv("COPILOT_TOKEN")
+		if apiKey == "" {
+			// Try to get token from Copilot CLI config
+			apiKey = GetCopilotToken()
+		}
+		model = os.Getenv("AI_MODEL")
+		if model == "" {
+			model = "claude-sonnet-4.5" // Default Copilot model
+		}
+	default:
+		return nil, fmt.Errorf("unsupported provider: %s", provider)
+	}
+
+	if apiKey == "" {
+		return nil, fmt.Errorf("API key not found for provider %s", provider)
+	}
+
+	return &Client{
+		Provider: Provider(provider),
+		Model:    model,
+		APIKey:   apiKey,
+	}, nil
+}
+
+func (c *Client) Chat(messages []Message) (string, error) {
+	switch c.Provider {
+	case ProviderOpenAI:
+		return c.chatOpenAI(context.Background(), messages)
+	case ProviderGemini:
+		return c.chatGemini(messages)
+	case ProviderClaude:
+		return c.chatClaude(messages)
+	default:
+		return "", fmt.Errorf("unsupported provider: %s", c.Provider)
+	}
+}
+
+// ChatWithContext is the preferred entrypoint for new code (supports context).
+func (c *Client) ChatWithContext(ctx context.Context, messages []Message) (string, error) {
+	switch c.Provider {
+	case ProviderOpenAI:
+		return c.chatOpenAI(ctx, messages)
+	case ProviderGemini:
+		return c.chatGemini(messages)
+	case ProviderClaude:
+		return c.chatClaude(messages)
+	case ProviderGitHub:
+		return c.chatGitHub(ctx, messages)
+	case ProviderCopilot:
+		return c.chatCopilot(ctx, messages)
+	default:
+		return "", fmt.Errorf("unsupported provider: %s", c.Provider)
+	}
+}
+
+// ChatWithImages supports OpenAI multimodal chat by attaching images to the last user message.
+func (c *Client) ChatWithImages(ctx context.Context, messages []Message, images []ImageInput) (string, error) {
+	if c.Provider != ProviderOpenAI {
+		// other providers not yet wired for multimodal; fallback to text.
+		return c.ChatWithContext(ctx, messages)
+	}
+	return c.chatOpenAIWithImages(ctx, messages, images)
+}
+
+func (c *Client) chatOpenAI(ctx context.Context, messages []Message) (string, error) {
+	type Request struct {
+		Model    string    `json:"model"`
+		Messages []Message `json:"messages"`
+	}
+
+	type Response struct {
+		Choices []struct {
+			Message Message `json:"message"`
+		} `json:"choices"`
+	}
+
+	reqBody := Request{
+		Model:    c.Model,
+		Messages: messages,
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return "", err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", "https://api.openai.com/v1/chat/completions", bytes.NewBuffer(jsonData))
+	if err != nil {
+		return "", err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+c.APIKey)
+
+	client := &http.Client{Timeout: 60 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("API error (%d): %s", resp.StatusCode, string(body))
+	}
+
+	var response Response
+	if err := json.Unmarshal(body, &response); err != nil {
+		return "", err
+	}
+
+	if len(response.Choices) == 0 {
+		return "", fmt.Errorf("no response from API")
+	}
+
+	return response.Choices[0].Message.Content, nil
+}
+
+func (c *Client) chatOpenAIWithImages(ctx context.Context, messages []Message, images []ImageInput) (string, error) {
+	// Use chat.completions multimodal format: message.content as array.
+	// We attach images to the last user message (or create a new one if none).
+	type imageURL struct {
+		URL string `json:"url"`
+	}
+	type contentPart struct {
+		Type     string    `json:"type"`
+		Text     string    `json:"text,omitempty"`
+		ImageURL *imageURL `json:"image_url,omitempty"`
+	}
+	type mmMessage struct {
+		Role    string        `json:"role"`
+		Content []contentPart `json:"content"`
+	}
+	type request struct {
+		Model    string      `json:"model"`
+		Messages []mmMessage `json:"messages"`
+	}
+	type response struct {
+		Choices []struct {
+			Message struct {
+				Content string `json:"content"`
+			} `json:"message"`
+		} `json:"choices"`
+	}
+
+	mm := make([]mmMessage, 0, len(messages))
+	for _, m := range messages {
+		mm = append(mm, mmMessage{Role: m.Role, Content: []contentPart{{Type: "text", Text: m.Content}}})
+	}
+	idx := -1
+	for i := len(mm) - 1; i >= 0; i-- {
+		if mm[i].Role == "user" {
+			idx = i
+			break
+		}
+	}
+	if idx == -1 {
+		mm = append(mm, mmMessage{Role: "user", Content: []contentPart{{Type: "text", Text: "(image attached)"}}})
+		idx = len(mm) - 1
+	}
+
+	for _, img := range images {
+		mime := img.Mime
+		if mime == "" {
+			mime = "image/png"
+		}
+		url := img.DataBase64
+		// Allow raw base64 (convert to data-url)
+		if !strings.HasPrefix(url, "data:") {
+			url = fmt.Sprintf("data:%s;base64,%s", mime, url)
+		}
+		mm[idx].Content = append(mm[idx].Content, contentPart{Type: "image_url", ImageURL: &imageURL{URL: url}})
+	}
+
+	reqBody := request{Model: c.Model, Messages: mm}
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return "", err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", "https://api.openai.com/v1/chat/completions", bytes.NewBuffer(jsonData))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+c.APIKey)
+
+	client := &http.Client{Timeout: 120 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("API error (%d): %s", resp.StatusCode, string(body))
+	}
+
+	var decoded response
+	if err := json.Unmarshal(body, &decoded); err != nil {
+		return "", err
+	}
+	if len(decoded.Choices) == 0 {
+		return "", fmt.Errorf("no response from API")
+	}
+	return decoded.Choices[0].Message.Content, nil
+}
+
+func (c *Client) chatGemini(messages []Message) (string, error) {
+	type Content struct {
+		Parts []struct {
+			Text string `json:"text"`
+		} `json:"parts"`
+		Role string `json:"role,omitempty"`
+	}
+
+	type Request struct {
+		Contents []Content `json:"contents"`
+	}
+
+	type Response struct {
+		Candidates []struct {
+			Content Content `json:"content"`
+		} `json:"candidates"`
+	}
+
+	// Convert messages to Gemini format
+	var contents []Content
+	for _, msg := range messages {
+		role := msg.Role
+		if role == "assistant" {
+			role = "model"
+		}
+		contents = append(contents, Content{
+			Parts: []struct {
+				Text string `json:"text"`
+			}{{Text: msg.Content}},
+			Role: role,
+		})
+	}
+
+	reqBody := Request{
+		Contents: contents,
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return "", err
+	}
+
+	url := fmt.Sprintf("https://generativelanguage.googleapis.com/v1beta/models/%s:generateContent?key=%s", c.Model, c.APIKey)
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return "", err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: 60 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("API error (%d): %s", resp.StatusCode, string(body))
+	}
+
+	var response Response
+	if err := json.Unmarshal(body, &response); err != nil {
+		return "", err
+	}
+
+	if len(response.Candidates) == 0 || len(response.Candidates[0].Content.Parts) == 0 {
+		return "", fmt.Errorf("no response from API")
+	}
+
+	return response.Candidates[0].Content.Parts[0].Text, nil
+}
+
+func (c *Client) chatClaude(messages []Message) (string, error) {
+	type Request struct {
+		Model     string    `json:"model"`
+		MaxTokens int       `json:"max_tokens"`
+		Messages  []Message `json:"messages"`
+	}
+
+	type Response struct {
+		Content []struct {
+			Text string `json:"text"`
+		} `json:"content"`
+	}
+
+	reqBody := Request{
+		Model:     c.Model,
+		MaxTokens: 4096,
+		Messages:  messages,
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return "", err
+	}
+
+	req, err := http.NewRequest("POST", "https://api.anthropic.com/v1/messages", bytes.NewBuffer(jsonData))
+	if err != nil {
+		return "", err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("x-api-key", c.APIKey)
+	req.Header.Set("anthropic-version", "2023-06-01")
+
+	client := &http.Client{Timeout: 60 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("API error (%d): %s", resp.StatusCode, string(body))
+	}
+
+	var response Response
+	if err := json.Unmarshal(body, &response); err != nil {
+		return "", err
+	}
+
+	if len(response.Content) == 0 {
+		return "", fmt.Errorf("no response from API")
+	}
+
+	return response.Content[0].Text, nil
+}
+
+// GenerateText is a simple text generation method for agents
+func (c *Client) GenerateText(ctx context.Context, prompt string) (string, error) {
+	messages := []Message{
+		{
+			Role:    "user",
+			Content: prompt,
+		},
+	}
+	return c.ChatWithContext(ctx, messages)
+}
+
+// getGitHubToken retrieves the GitHub token from gh CLI
+func getGitHubToken() string {
+cmd := exec.Command("gh", "auth", "token")
+output, err := cmd.Output()
+if err != nil {
+return ""
+}
+return strings.TrimSpace(string(output))
+}
+
+// chatGitHub calls GitHub Models API
+func (c *Client) chatGitHub(ctx context.Context, messages []Message) (string, error) {
+type Request struct {
+Model    string    `json:"model"`
+Messages []Message `json:"messages"`
+}
+
+type Response struct {
+Choices []struct {
+Message Message `json:"message"`
+} `json:"choices"`
+Error *struct {
+Message string `json:"message"`
+Type    string `json:"type"`
+} `json:"error,omitempty"`
+}
+
+reqBody := Request{
+Model:    c.Model,
+Messages: messages,
+}
+
+jsonData, err := json.Marshal(reqBody)
+if err != nil {
+return "", err
+}
+
+// GitHub Models API endpoint
+apiURL := "https://models.inference.ai.azure.com/chat/completions"
+
+req, err := http.NewRequestWithContext(ctx, "POST", apiURL, bytes.NewBuffer(jsonData))
+if err != nil {
+return "", err
+}
+
+req.Header.Set("Content-Type", "application/json")
+req.Header.Set("Authorization", "Bearer "+c.APIKey)
+
+client := &http.Client{Timeout: 120 * time.Second}
+resp, err := client.Do(req)
+if err != nil {
+return "", fmt.Errorf("GitHub API request failed: %w", err)
+}
+defer resp.Body.Close()
+
+body, err := io.ReadAll(resp.Body)
+if err != nil {
+return "", fmt.Errorf("failed to read GitHub API response: %w", err)
+}
+
+if resp.StatusCode != http.StatusOK {
+return "", fmt.Errorf("GitHub API error (%d): %s", resp.StatusCode, string(body))
+}
+
+var response Response
+if err := json.Unmarshal(body, &response); err != nil {
+return "", fmt.Errorf("failed to parse GitHub API response: %w", err)
+}
+
+if response.Error != nil {
+return "", fmt.Errorf("GitHub API error: %s", response.Error.Message)
+}
+
+if len(response.Choices) == 0 {
+return "", fmt.Errorf("no response from GitHub API")
+}
+
+return response.Choices[0].Message.Content, nil
+}
+
+// GetCopilotToken retrieves the Copilot token from ~/.copilot/config.json
+func GetCopilotToken() string {
+homeDir, err := os.UserHomeDir()
+if err != nil {
+return ""
+}
+
+configPath := homeDir + "/.copilot/config.json"
+data, err := os.ReadFile(configPath)
+if err != nil {
+return ""
+}
+
+var config map[string]interface{}
+if err := json.Unmarshal(data, &config); err != nil {
+return ""
+}
+
+copilotTokens, ok := config["copilot_tokens"].(map[string]interface{})
+if !ok {
+return ""
+}
+
+// Get token for github.com
+for key, value := range copilotTokens {
+if strings.Contains(key, "github.com") {
+if token, ok := value.(string); ok {
+return token
+}
+}
+}
+
+return ""
+}
+
+// chatCopilot calls GitHub Copilot Premium API
+func (c *Client) chatCopilot(ctx context.Context, messages []Message) (string, error) {
+type Request struct {
+Model    string    `json:"model"`
+Messages []Message `json:"messages"`
+Stream   bool      `json:"stream"`
+}
+
+type Response struct {
+Choices []struct {
+Message Message `json:"message"`
+} `json:"choices"`
+Error *struct {
+Message string `json:"message"`
+Type    string `json:"type"`
+} `json:"error,omitempty"`
+}
+
+reqBody := Request{
+Model:    c.Model,
+Messages: messages,
+Stream:   false,
+}
+
+jsonData, err := json.Marshal(reqBody)
+if err != nil {
+return "", err
+}
+
+// GitHub Copilot Premium API endpoint
+apiURL := "https://api.githubcopilot.com/chat/completions"
+
+req, err := http.NewRequestWithContext(ctx, "POST", apiURL, bytes.NewBuffer(jsonData))
+if err != nil {
+return "", err
+}
+
+req.Header.Set("Content-Type", "application/json")
+req.Header.Set("Authorization", "Bearer "+c.APIKey)
+
+client := &http.Client{Timeout: 120 * time.Second}
+resp, err := client.Do(req)
+if err != nil {
+return "", fmt.Errorf("Copilot API request failed: %w", err)
+}
+defer resp.Body.Close()
+
+body, err := io.ReadAll(resp.Body)
+if err != nil {
+return "", fmt.Errorf("failed to read Copilot API response: %w", err)
+}
+
+if resp.StatusCode != http.StatusOK {
+return "", fmt.Errorf("Copilot API error (%d): %s", resp.StatusCode, string(body))
+}
+
+var response Response
+if err := json.Unmarshal(body, &response); err != nil {
+return "", fmt.Errorf("failed to parse Copilot API response: %w", err)
+}
+
+if response.Error != nil {
+return "", fmt.Errorf("Copilot API error: %s", response.Error.Message)
+}
+
+if len(response.Choices) == 0 {
+return "", fmt.Errorf("no response from Copilot API")
+}
+
+return response.Choices[0].Message.Content, nil
+}