使用Golang构建一个支持IMAP同步的💌邮件编写工具

这是一个非常出色的项目！将IMAP同步与AI邮件撰写结合，解决了邮件处理中的实际痛点。以下是针对您技术实现的专业分析和代码示例：

IMAP客户端实现示例

package main

import (
    "crypto/tls"
    "fmt"
    "log"
    "time"

    "github.com/emersion/go-imap"
    "github.com/emersion/go-imap/client"
)

type IMAPClient struct {
    client *client.Client
    config *IMAPConfig
}

type IMAPConfig struct {
    Server   string
    Port     int
    Username string
    Password string
    UseTLS   bool
}

func NewIMAPClient(cfg *IMAPConfig) (*IMAPClient, error) {
    addr := fmt.Sprintf("%s:%d", cfg.Server, cfg.Port)
    
    var c *client.Client
    var err error
    
    if cfg.UseTLS {
        c, err = client.DialTLS(addr, &tls.Config{
            ServerName: cfg.Server,
        })
    } else {
        c, err = client.Dial(addr)
    }
    
    if err != nil {
        return nil, fmt.Errorf("连接失败: %v", err)
    }
    
    if err := c.Login(cfg.Username, cfg.Password); err != nil {
        return nil, fmt.Errorf("登录失败: %v", err)
    }
    
    return &IMAPClient{
        client: c,
        config: cfg,
    }, nil
}

func (ic *IMAPClient) FetchUnreadEmails() ([]*imap.Message, error) {
    mbox, err := ic.client.Select("INBOX", false)
    if err != nil {
        return nil, err
    }
    
    // 搜索未读邮件
    criteria := imap.NewSearchCriteria()
    criteria.WithoutFlags = []string{"\\Seen"}
    seqNums, err := ic.client.Search(criteria)
    if err != nil {
        return nil, err
    }
    
    if len(seqNums) == 0 {
        return []*imap.Message{}, nil
    }
    
    seqset := new(imap.SeqSet)
    seqset.AddNum(seqNums...)
    
    messages := make(chan *imap.Message, 10)
    done := make(chan error, 1)
    
    go func() {
        done <- ic.client.Fetch(seqset, []imap.FetchItem{
            imap.FetchEnvelope,
            imap.FetchBodyStructure,
            imap.FetchFlags,
            imap.FetchInternalDate,
            "BODY[]",
        }, messages)
    }()
    
    var fetchedMessages []*imap.Message
    for msg := range messages {
        fetchedMessages = append(fetchedMessages, msg)
    }
    
    if err := <-done; err != nil {
        return nil, err
    }
    
    return fetchedMessages, nil
}

func (ic *IMAPClient) SendEmailViaIMAP(msg *EmailMessage) error {
    mbox, err := ic.client.Select("Sent", true)
    if err != nil {
        // 如果Sent文件夹不存在，尝试创建
        err = ic.client.Create("Sent")
        if err != nil {
            return fmt.Errorf("创建Sent文件夹失败: %v", err)
        }
        mbox, err = ic.client.Select("Sent", true)
        if err != nil {
            return err
        }
    }
    
    // 构建MIME邮件
    emailBytes := buildMIMEMessage(msg)
    
    // 通过APPEND命令将邮件保存到Sent文件夹
    flags := []string{"\\Seen"}
    date := time.Now()
    
    err = ic.client.Append("Sent", flags, date, imap.Literal(emailBytes))
    if err != nil {
        return fmt.Errorf("保存到Sent文件夹失败: %v", err)
    }
    
    return nil
}

AI邮件生成服务示例

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "strings"
)

type LLMProvider interface {
    GenerateReply(ctx context.Context, emailContent string) (*EmailReplies, error)
}

type EmailReplies struct {
    PositiveReply string `json:"positive_reply"`
    NegativeReply string `json:"negative_reply"`
}

type MistralProvider struct {
    apiKey     string
    baseURL    string
    model      string
}

func NewMistralProvider(apiKey, model string) *MistralProvider {
    return &MistralProvider{
        apiKey:  apiKey,
        baseURL: "https://api.mistral.ai/v1",
        model:   model,
    }
}

func (m *MistralProvider) GenerateReply(ctx context.Context, emailContent string) (*EmailReplies, error) {
    prompt := fmt.Sprintf(`请基于以下邮件内容生成两种专业回复：

原始邮件：
%s

请生成：
1. 专业的肯定回复（表达同意、接受或积极回应）
2. 专业的否定回复（礼貌地拒绝或表达不同意见）

请以JSON格式返回：
{
    "positive_reply": "肯定回复内容",
    "negative_reply": "否定回复内容"
}`, emailContent)

    // 实际调用Mistral API
    req := MistralRequest{
        Model: m.model,
        Messages: []Message{
            {
                Role:    "user",
                Content: prompt,
            },
        },
        ResponseFormat: ResponseFormat{
            Type: "json_object",
        },
    }
    
    // 这里简化了API调用，实际需要实现HTTP请求
    response, err := m.callAPI(ctx, req)
    if err != nil {
        return nil, err
    }
    
    var replies EmailReplies
    if err := json.Unmarshal([]byte(response), &replies); err != nil {
        return nil, fmt.Errorf("解析AI回复失败: %v", err)
    }
    
    return &replies, nil
}

type GeminiProvider struct {
    apiKey  string
    model   string
}

func NewGeminiProvider(apiKey, model string) *GeminiProvider {
    return &GeminiProvider{
        apiKey: apiKey,
        model:  model,
    }
}

func (g *GeminiProvider) GenerateReply(ctx context.Context, emailContent string) (*EmailReplies, error) {
    // Gemini API实现
    // 可以根据需要热切换不同的LLM提供商
    return &EmailReplies{
        PositiveReply: "基于Gemini生成的肯定回复",
        NegativeReply: "基于Gemini生成的否定回复",
    }, nil
}

邮件处理工作流

package main

import (
    "context"
    "log"
    "sync"
    "time"
)

type EmailProcessor struct {
    imapClient   *IMAPClient
    llmProvider  LLMProvider
    checkInterval time.Duration
    mu           sync.RWMutex
    running      bool
}

func NewEmailProcessor(imapCfg *IMAPConfig, llm LLMProvider) *EmailProcessor {
    imapClient, err := NewIMAPClient(imapCfg)
    if err != nil {
        log.Fatalf("初始化IMAP客户端失败: %v", err)
    }
    
    return &EmailProcessor{
        imapClient:   imapClient,
        llmProvider:  llm,
        checkInterval: 30 * time.Second,
        running:      false,
    }
}

func (ep *EmailProcessor) Start(ctx context.Context) {
    ep.mu.Lock()
    if ep.running {
        ep.mu.Unlock()
        return
    }
    ep.running = true
    ep.mu.Unlock()
    
    ticker := time.NewTicker(ep.checkInterval)
    defer ticker.Stop()
    
    for {
        select {
        case <-ctx.Done():
            ep.mu.Lock()
            ep.running = false
            ep.mu.Unlock()
            return
            
        case <-ticker.C:
            ep.processNewEmails(ctx)
        }
    }
}

func (ep *EmailProcessor) processNewEmails(ctx context.Context) {
    messages, err := ep.imapClient.FetchUnreadEmails()
    if err != nil {
        log.Printf("获取未读邮件失败: %v", err)
        return
    }
    
    for _, msg := range messages {
        emailContent := extractEmailContent(msg)
        
        // 使用AI生成回复
        replies, err := ep.llmProvider.GenerateReply(ctx, emailContent)
        if err != nil {
            log.Printf("生成AI回复失败: %v", err)
            continue
        }
        
        // 将生成的回复存储到数据库或消息队列
        // 供前端界面展示和编辑
        ep.storeGeneratedReplies(msg, replies)
        
        // 标记邮件为已读
        ep.markAsRead(msg)
    }
}

func (ep *EmailProcessor) SendFinalReply(originalMsg *imap.Message, replyContent string, isPositive bool) error {
    // 构建回复邮件
    replyEmail := &EmailMessage{
        To:      []string{originalMsg.Envelope.From[0].Address()},
        Subject: "Re: " + originalMsg.Envelope.Subject,
        Body:    replyContent,
        Headers: map[string]string{
            "In-Reply-To": originalMsg.Envelope.MessageId,
            "References":  originalMsg.Envelope.MessageId,
        },
    }
    
    // 通过IMAP保存到Sent文件夹
    err := ep.imapClient.SendEmailViaIMAP(replyEmail)
    if err != nil {
        return fmt.Errorf("发送邮件失败: %v", err)
    }
    
    return nil
}

配置管理示例

package main

import (
    "os"
    
    "gopkg.in/yaml.v3"
)

type Config struct {
    IMAP struct {
        Server   string `yaml:"server"`
        Port     int    `yaml:"port"`
        Username string `yaml:"username"`
        Password string `yaml:"password"`
        UseTLS   bool   `yaml:"use_tls"`
    } `yaml:"imap"`
    
    LLM struct {
        Provider string `yaml:"provider"`
        APIKey   string `yaml:"api_key"`
        Model    string `yaml:"model"`
        Endpoint string `yaml:"endpoint,omitempty"`
    } `yaml:"llm"`
    
    Server struct {
        Port int    `yaml:"port"`
        Host string `yaml:"host"`
    } `yaml:"server"`
}

func LoadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, err
    }
    
    var cfg Config
    if err := yaml.Unmarshal(data, &cfg); err != nil {
        return nil, err
    }
    
    // 环境变量覆盖
    if apiKey := os.Getenv("LLM_API_KEY"); apiKey != "" {
        cfg.LLM.APIKey = apiKey
    }
    
    return &cfg, nil
}

这个架构设计允许您轻松切换不同的LLM提供商，同时保持IMAP同步的可靠性。使用Go的并发特性可以高效处理多个邮件账户的同步任务。