Automatizzare lo sviluppo: integrare DeepSeek nel workflow GitHub Issues

La velocità di esecuzione è fondamentale, ma la qualità del codice resta il vero differenziatore. Molti di noi si trovano a dover gestire un delicato equilibrio: utilizzare la potenza dei modelli AI più recenti – come DeepSeek – mantenendo al contempo una struttura solida per il tracking delle attività su GitHub.

Spesso, il limite risiede nell’integrazione tra i portali di assistenza AI (come GitHub Copilot) e i modelli che preferiamo per le nostre architetture. Ma cosa succede se spostiamo il baricentro dell’automazione direttamente sul ciclo di vita del codice?

La soluzione: GitHub Actions come motore di orchestrazione

Invece di tentare di forzare modelli esterni in interfacce web rigide, la strategia più efficace è trasformare GitHub stesso nel motore di esecuzione, sfruttando le GitHub Actions.

Il workflow è lineare e potente:

1. Definizione del task: Una Issue su GitHub diventa l’input strutturato.
2. Trigger: Un evento di GitHub (es. l’apertura di una issue con un tag specifico) avvia automaticamente una GitHub Action dedicata.
3. Elaborazione: L’Action invoca via API il modello scelto (in questo caso, DeepSeek), passando il contesto della issue e il codice pertinente del repository.
4. Esecuzione: Il modello analizza il task, genera la soluzione e l’Action, tramite un bot o un commit automatico, prepara il terreno per la Pull Request.

I vantaggi di questo approccio:

• Indipendenza dai modelli: Non sei più vincolato ai modelli predefiniti del portale web. Puoi switchare tra DeepSeek, Claude o altre istanze locali (via Ollama) semplicemente aggiornando la configurazione della tua Action.
• Workflow “Docs-as-Code”: Il processo è tracciabile, riproducibile e versionato. Ogni automazione segue la logica del tuo repository.
• Focus sull’architettura: Questa soluzione ti permette di integrare l’AI non solo come un assistente alla scrittura, ma come un componente del tuo pipeline di CI/CD.

Per implementare l’automazione basata su GitHub Actions e DeepSeek, dobbiamo creare un sistema che “ascolti” le Issue e interagisca con le API. Ecco i passaggi tecnici e gli esempi di codice per costruire questo workflow.

1. Preparazione dell’ambiente

Assicurati di avere una API Key di DeepSeek valida. Aggiungila al tuo repository GitHub come Secret (vai in Settings > Secrets and variables > Actions > New repository secret):

• Nome: DEEPSEEK_API_KEY
• Valore: sk-xxxxxxxxxxxxxxxx

2. Creazione della GitHub Action

Crea il file .github/workflows/deepseek-issue-bot.yml nel tuo repository. Questo workflow scatterà ogni volta che apri una Issue.

name: DeepSeek Issue Bot
on:
  issues:
    types: [opened]

jobs:
  process-issue:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.10'

      - name: Install dependencies
        run: pip install requests

      - name: Run DeepSeek Processor
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_API_KEY }}
          ISSUE_TITLE: ${{ github.event.issue.title }}
          ISSUE_BODY: ${{ github.event.issue.body }}
        run: python scripts/process_issue.py

3. Script di elaborazione (scripts/process_issue.py)

Questo script interroga DeepSeek con il testo della tua issue e pubblica un commento con la soluzione.

import os
import requests
import json

def ask_deepseek(prompt):
    url = "https://api.deepseek.com/v1/chat/completions" # URL endpoint DeepSeek
    headers = {
        "Authorization": f"Bearer {os.environ['DEEPSEEK_API_KEY']}",
        "Content-Type": "application/json"
    }
    data = {
        "model": "deepseek-chat",
        "messages": [{"role": "user", "content": prompt}]
    }
    response = requests.post(url, headers=headers, json=data)
    return response.json()['choices'][0]['message']['content']

def post_comment(comment):
    issue_number = os.environ.get("GITHUB_EVENT_PATH") # O estrai via API context
    # Semplificato: stampa il commento (o usa l'API di GitHub per postarlo sulla issue)
    print(f"Soluzione generata: {comment}")

if __name__ == "__main__":
    title = os.environ.get("ISSUE_TITLE")
    body = os.environ.get("ISSUE_BODY")
    
    prompt = f"Analizza questa richiesta di codice:\nTitolo: {title}\nContesto: {body}\nGenera una proposta di implementazione."
    
    solution = ask_deepseek(prompt)
    post_comment(solution)

4. Flusso logico visivo

Per comprendere come interagiscono i componenti:

Note importanti per il tuo workflow .NET:

• Contesto del Codice: Se vuoi che DeepSeek scriva codice reale, modifica lo script Python per includere una lettura dei file del repository (open('progetto.cs', 'r').read()) prima di inviare il prompt.
• Sicurezza: Non includere mai la chiave API direttamente nel file YAML; usa sempre il sistema dei Secrets di GitHub.
• Filtraggio: Ti consiglio di aggiungere una condizione al trigger del workflow nello YAML, ad esempio eseguendolo solo se l’Issue ha un label specifico (es: label: 'ai-request'), per evitare di chiamare l’API per ogni tipo di segnalazione (come bug o domande generiche).

In un prossimo post vedremo l’implementazione di una soluzione piu’ “architetturale” che utilizzerà MCP server.