Gemini-Powered Stock Analysis: Parsing Financial News for Automated Trading Decisions

// Core components of the news analysis system
type Stream struct {
    feeds             []string
    client            *http.Client
    newsChan          chan *NewsItem
    stopChan          chan struct{}
    fetchedItems      map[string]bool
    vertexAiModelName string
    analysisEnabled   bool
    genaiClient       *genai.Client
}

type AIAnalysisService struct {
    engine    *engine.Engine
    longChan  chan *AIRecommendation
    shortChan chan *AIRecommendation
    stopChan  chan struct{}
}

func NewStream() *Stream {
    // Initialize NewsStream with default RSS feeds
    defaultNewsFeeds := []string{
        "https://news.teleborsa.it/NewsFeed.ashx",
        "https://investire.biz/feed/analisi/azioni",
    }
    // ... initialization code
}

// ExtractArticleFromHTML supports both Teleborsa and Investire.biz formats
func ExtractArticleFromHTML(htmlContent string) string {
    // First, try to extract from Investire.biz format
    if content := extractInvestireBizArticle(htmlContent); content != "" {
        return content
    }

    // If not found, try Teleborsa format
    if content := extractTeleborsaArticle(htmlContent); content != "" {
        return content
    }

    return ""
}

func extractTeleborsaArticle(htmlContent string) string {
    // Find the start of the article content
    startMarker := "(Teleborsa) - "
    startIndex := strings.Index(htmlContent, startMarker)
    if startIndex == -1 {
        return ""
    }

    // Extract and clean the content
    articleHTML := htmlContent[startIndex:endIndex]
    cleanText := RemoveHTMLTags(articleHTML)
    cleanText = html.UnescapeString(cleanText)
    cleanText = NormalizeWhitespace(cleanText)

    return cleanText
}

func (s *Stream) analyzeArticleWithGemini(articleText string) (*NewsAnalysis, error) {
    prompt := fmt.Sprintf(`Analyze the following news article and provide a JSON response with an array of stock analyses.
The article can be in Italian or English..
For each stock mentioned, include the ticker symbol (e.g., for "Stellantis" it should be "STLAM"), a suggested action (buy, sell, or hold), and a brief reason for the suggestion in English.
It's not mandatory to include all the stocks mentioned in the article, only the ones that are relevant to the article.
If there are no stocks mentioned in the article, return an empty array.
The suggested action should be based on the article content and the stock's performance. The suggested action will be used for day trading.

Article:
%s

IMPORTANT: 
- Your response must contain ONLY valid JSON, no explanatory text before or after
- Do not include any markdown formatting or code blocks
- Return exactly this JSON structure and nothing else:

{
  "items": [
    {
      "ticker": "STOCK_TICKER",
      "action": "buy|sell|hold", 
      "reason": "Brief explanation in English."
    }
  ]
}`, articleText)

    config := &genai.GenerateContentConfig{
        Temperature: genai.Ptr[float32](0.1),
    }

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    resp, err := s.genaiClient.Models.GenerateContent(ctx, s.vertexAiModelName, genai.Text(prompt), config)
    // ... error handling and JSON parsing
}

// Sample Italian article from Teleborsa
articleText := `(Teleborsa) - Seduta in ribasso per Stellantis, che mostra un calo dell'1,26%. A pesare sulle azioni è la notizia di un richiamo di oltre un milione di veicoli negli Stati Uniti per un difetto alla telecamera posteriore. Brilla invece Leonardo, che avanza del 2,5% grazie a nuove commesse nel settore della difesa.`

func (s *AIAnalysisService) Start() error {
    go func() {
        for {
            select {
            case newsItem := <-newsChan:
                if newsItem.Analysis == nil || len(newsItem.Analysis.Items) == 0 {
                    continue
                }

                for _, analysis := range newsItem.Analysis.Items {
                    // Generate ticker variations for different markets
                    allTickers := []string{analysis.Ticker}
                    
                    // Handle Italian stocks (.MI suffix)
                    if strings.Contains(analysis.Ticker, ".MI") {
                        miRemovedTicker := strings.Replace(analysis.Ticker, ".MI", "", 1)
                        allTickers = append(allTickers, miRemovedTicker)
                    }

                    // Lookup actual tradeable instruments
                    titles, err := s.engine.ListTitles(allTickers)
                    if err != nil {
                        continue
                    }

                    // Route to appropriate channels
                    for _, titleList := range titles {
                        for _, title := range titleList {
                            recommendation := &AIRecommendation{
                                Title:    title,
                                Analysis: analysis,
                                Source:   newsItem.Source,
                            }

                            switch analysis.Action {
                            case news.BuyAction:
                                s.longChan <- recommendation
                            case news.SellAction:
                                s.shortChan <- recommendation
                            }
                        }
                    }
                }
            }
        }
    }()
}

func (s *Stream) Start() {
    s.wg.Add(1)
    go func() {
        defer s.wg.Done()
        ticker := time.NewTicker(s.fetchInterval)
        defer ticker.Stop()

        for {
            select {
            case <-ticker.C:
                for _, feed := range s.feeds {
                    go s.fetchFeedWithRetry(feed)
                }
            case <-s.stopChan:
                return
            }
        }
    }()
}

func (s *Stream) fetchFeedWithRetry(feedURL string) error {
    var lastErr error
    delay := s.retryConfig.InitialDelay

    for attempt := 0; attempt <= s.retryConfig.MaxRetries; attempt++ {
        if attempt > 0 {
            time.Sleep(delay)
            delay = time.Duration(float64(delay) * s.retryConfig.BackoffFactor)
            if delay > s.retryConfig.MaxDelay {
                delay = s.retryConfig.MaxDelay
            }
        }

        if err := s.fetchFeed(feedURL); err != nil {
            lastErr = err
            continue
        }
        return nil
    }
    
    return fmt.Errorf("failed to fetch feed after %d attempts: %w", 
        s.retryConfig.MaxRetries+1, lastErr)
}

// Example: Trend following strategy with AI recommendations
longStocks, err := stockSelector.SelectStocksLong(strategy.SelectFromAll)
if err != nil {
    log.Error("Error starting SelectStocks: %s", err)
    return
}

// Process AI recommendations
go func() {
    for recommendation := range aiService.GetLongChannel() {
        // Create trend following strategy for recommended stock
        trendStrategy := strategy.NewTrendFollowing(
            tradingEngine, 
            recommendation.Title,
            strategy.LongDirection,
        )
        
        if err := trendStrategy.Start(); err != nil {
            log.Error("Failed to start trend strategy: %s", err)
            continue
        }
        
        log.Info("Started AI-recommended long strategy for %s: %s", 
            recommendation.Title.GetPriceCode(), 
            recommendation.Analysis.Reason)
    }
}()