gitcaddy-ai/go/gitcaddy-ai-client/client.go

// Copyright 2026 MarketAlly. All rights reserved.
// SPDX-License-Identifier: BSL-1.1

// Package gitcaddyai provides a Go client for the GitCaddy AI Service.
package gitcaddyai

import (
	"context"
	"io"

	pb "git.marketally.com/gitcaddy/gitcaddy-ai/go/gitcaddy-ai-client/proto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

// Client provides access to GitCaddy AI Service.
type Client struct {
	conn   *grpc.ClientConn
	client pb.GitCaddyAIClient
}

// NewClient creates a new GitCaddy AI client.
func NewClient(address string, opts ...grpc.DialOption) (*Client, error) {
	if len(opts) == 0 {
		opts = []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
	}

	conn, err := grpc.NewClient(address, opts...)
	if err != nil {
		return nil, err
	}

	return &Client{
		conn:   conn,
		client: pb.NewGitCaddyAIClient(conn),
	}, nil
}

// Close closes the client connection.
func (c *Client) Close() error {
	return c.conn.Close()
}

// ReviewPullRequest reviews a pull request and returns AI feedback.
func (c *Client) ReviewPullRequest(ctx context.Context, req *pb.ReviewPullRequestRequest) (*pb.ReviewPullRequestResponse, error) {
	return c.client.ReviewPullRequest(ctx, req)
}

// ReviewCommit reviews a single commit.
func (c *Client) ReviewCommit(ctx context.Context, req *pb.ReviewCommitRequest) (*pb.ReviewCommitResponse, error) {
	return c.client.ReviewCommit(ctx, req)
}

// SummarizeChanges summarizes code changes.
func (c *Client) SummarizeChanges(ctx context.Context, req *pb.SummarizeChangesRequest) (*pb.SummarizeChangesResponse, error) {
	return c.client.SummarizeChanges(ctx, req)
}

// ExplainCode explains a piece of code.
func (c *Client) ExplainCode(ctx context.Context, req *pb.ExplainCodeRequest) (*pb.ExplainCodeResponse, error) {
	return c.client.ExplainCode(ctx, req)
}

// SuggestFix suggests a fix for code with an error.
func (c *Client) SuggestFix(ctx context.Context, req *pb.SuggestFixRequest) (*pb.SuggestFixResponse, error) {
	return c.client.SuggestFix(ctx, req)
}

// TriageIssue triages an issue with priority and category.
func (c *Client) TriageIssue(ctx context.Context, req *pb.TriageIssueRequest) (*pb.TriageIssueResponse, error) {
	return c.client.TriageIssue(ctx, req)
}

// SuggestLabels suggests labels for an issue.
func (c *Client) SuggestLabels(ctx context.Context, req *pb.SuggestLabelsRequest) (*pb.SuggestLabelsResponse, error) {
	return c.client.SuggestLabels(ctx, req)
}

// GenerateIssueResponse generates a response to an issue.
func (c *Client) GenerateIssueResponse(ctx context.Context, req *pb.GenerateIssueResponseRequest) (*pb.GenerateIssueResponseResponse, error) {
	return c.client.GenerateIssueResponse(ctx, req)
}

// GenerateDocumentation generates documentation for code.
func (c *Client) GenerateDocumentation(ctx context.Context, req *pb.GenerateDocumentationRequest) (*pb.GenerateDocumentationResponse, error) {
	return c.client.GenerateDocumentation(ctx, req)
}

// GenerateCommitMessage generates a commit message from changes.
func (c *Client) GenerateCommitMessage(ctx context.Context, req *pb.GenerateCommitMessageRequest) (*pb.GenerateCommitMessageResponse, error) {
	return c.client.GenerateCommitMessage(ctx, req)
}

// ExecuteTask executes a single task.
func (c *Client) ExecuteTask(ctx context.Context, req *pb.ExecuteTaskRequest) (*pb.ExecuteTaskResponse, error) {
	return c.client.ExecuteTask(ctx, req)
}

// CheckHealth checks service health.
func (c *Client) CheckHealth(ctx context.Context) (*pb.HealthCheckResponse, error) {
	return c.client.CheckHealth(ctx, &pb.HealthCheckRequest{})
}

// ValidateLicense validates a license key.
func (c *Client) ValidateLicense(ctx context.Context, licenseKey string) (*pb.ValidateLicenseResponse, error) {
	return c.client.ValidateLicense(ctx, &pb.ValidateLicenseRequest{LicenseKey: licenseKey})
}

// WorkflowEventHandler handles workflow events from StartWorkflow.
type WorkflowEventHandler func(event *pb.WorkflowEvent) error

// StartWorkflow starts a workflow and calls the handler for each event.
func (c *Client) StartWorkflow(ctx context.Context, req *pb.StartWorkflowRequest, handler WorkflowEventHandler) error {
	stream, err := c.client.StartWorkflow(ctx, req)
	if err != nil {
		return err
	}

	for {
		event, err := stream.Recv()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			return err
		}

		if err := handler(event); err != nil {
			return err
		}
	}
}

// ChatSession represents an active chat session.
type ChatSession struct {
	stream pb.GitCaddyAI_ChatClient
}

// StartChat starts a new chat session.
func (c *Client) StartChat(ctx context.Context) (*ChatSession, error) {
	stream, err := c.client.Chat(ctx)
	if err != nil {
		return nil, err
	}
	return &ChatSession{stream: stream}, nil
}

// Send sends a message in the chat session.
func (s *ChatSession) Send(req *pb.ChatRequest) error {
	return s.stream.Send(req)
}

// Recv receives a response from the chat session.
func (s *ChatSession) Recv() (*pb.ChatResponse, error) {
	return s.stream.Recv()
}

// Close closes the chat session.
func (s *ChatSession) Close() error {
	return s.stream.CloseSend()
}