Salt la conținutul principal
Română— Alege o limbă
Meniu

Fluxuri de lucru automate pentru cod

Lecția 12 din 14 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Automatizarea dezvoltării cu Codestral și un model de uz general
  2. Arhitectura unui flux de lucru pentru cod
  3. Pasul 1: Căutarea codului cu Codestral Embed
  4. Pasul 2: Generarea codului cu Codestral
  5. Pasul 3: Revizuirea codului cu Mistral Small 4
  6. Flux complet: de la tichet la PR
  7. Integrare CI/CD
  8. Variații comune în producție
  9. Puncte cheie

Lecție actualizată la 2 noiembrie 2026. Etapa de revizuire se baza anterior pe Devstral, care a fost eliminat din API la 31 iulie 2026. Acum utilizează Mistral Small 4 (mistral-small-2603). Sursă: Models.

Automatizarea dezvoltării cu Codestral și un model de uz general

Până acum, am prezentat fiecare instrument Mistral AI individual, operând în fața unui utilizator uman. Valoarea lor reală apare atunci când le înlănțuiți. Codestral Embed, Codestral și un model de uz general, cum ar fi Mistral Small 4, formează un flux de lucru de dezvoltare automatizat capabil să caute, să genereze și să revizuiască codul fără intervenție manuală la fiecare pas.

Arhitectura unui flux de lucru pentru cod

Un flux complet se descompune în trei etape, fiecare atribuită modelului care excelează în acea sarcină specifică.

  1. Căutare de cod — Găsirea codului relevant în baza de cod (Codestral Embed)
  2. Generare de cod — Generarea sau modificarea codului (Codestral)
  3. Revizuire de cod — Verificarea și validarea modificărilor (Mistral Small 4)

Citiți fluxul de date de sus în jos; fiecare bloc consumă ieșirea celui anterior.

User Request
    |
[Codestral Embed] -> Relevant Files
    |
[Codestral] -> Generated/Modified Code
    |
[Mistral Small 4] -> Automated Review
    |
Pull Request / Commit

Pasul 1: Căutarea codului cu Codestral Embed

Generarea de cod fără cunoașterea bazei de cod existente produce rezultate care nu seamănă deloc cu restul proiectului. Prin urmare, primul pas este localizarea fișierelor relevante folosind indexul de embedding construit în lecția anterioară. Funcția de mai jos convertește descrierea sarcinii într-un vector, o compară cu fiecare fișier indexat și returnează cele mai apropiate cinci corespondențe.

from mistralai.client import Mistral
import numpy as np

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def search_context(task_description: str, codebase_index: list) -> list:
    """Finds relevant files for a given task."""
    response = client.embeddings.create(
        model="codestral-embed-latest",
        inputs=[task_description],
    )
    vector = np.array(response.data[0].embedding)

    scores = []
    for file in codebase_index:
        file_vec = np.array(file["embedding"])
        score = np.dot(vector, file_vec) / (
            np.linalg.norm(vector) * np.linalg.norm(file_vec)
        )
        scores.append((file, score))

    scores.sort(key=lambda x: x[1], reverse=True)
    return [f for f, s in scores[:5]]

Pasul 2: Generarea codului cu Codestral

Odată ce aveți contextul, Codestral poate genera cod. Calitatea ieșirii depinde de modul în care prezentați acel context: concatenați fișierele recuperate în mesajul de sistem, însoțite de o instrucțiune explicită de a respecta convențiile existente. Setarea temperature=0.1 menține ieșirea aproape deterministă, ceea ce este de dorit atunci când codul generat trebuie să se integreze perfect într-un proiect, mai degrabă decât să își surprindă autorul.

def generate_code(task: str, context: list[dict]) -> str:
    """Generates code taking existing context into account."""
    context_files = "\n\n---\n\n".join([
        f"# {f['path']}\n{f['content']}"
        for f in context
    ])

    response = client.chat.complete(
        model="codestral-latest",
        messages=[
            {
                "role": "system",
                "content": f"""You are a senior developer. Here is the existing project code:

{context_files}

Respect existing code conventions (naming, style, patterns)."""
            },
            {
                "role": "user",
                "content": task
            }
        ],
        temperature=0.1,
        max_tokens=2000,
    )

    return response.choices[0].message.content

Pasul 3: Revizuirea codului cu Mistral Small 4

Controlul vine la final. Mistral Small 4 primește starea anterioară, starea ulterioară și descrierea sarcinii, apoi își emite verdictul într-un format JSON strict. Această alegere este critică: recenziile în proză liberă nu sunt utilizabile de codul din aval, în timp ce un câmp boolean approved vă permite să automatizați pașii următori. Categoriile solicitate separă deliberat problemele blocante, sugestiile de îmbunătățire și preocupările de securitate, deoarece acestea necesită o gestionare diferită.

def review_code(original_code: str, modified_code: str, description: str) -> dict:
    """Automated code review."""
    response = client.chat.complete(
        model="mistral-small-2603",
        messages=[
            {
                "role": "system",
                "content": """You are a senior code reviewer. Analyze the diff and return JSON:
{
    "approved": true/false,
    "issues": ["list of found issues"],
    "suggestions": ["list of possible improvements"],
    "security": ["potential security issues"]
}"""
            },
            {
                "role": "user",
                "content": f"Task: {description}\n\nOriginal code:\n{original_code}\n\nModified code:\n{modified_code}"
            }
        ],
        temperature=0,
    )

    return response.choices[0].message.content

Flux complet: de la tichet la PR

Puteți acum asambla aceste trei funcții într-un singur lanț care pornește de la un tichet și produce cod revizuit. Păstrați instrucțiunile print intercalate: într-un flux automatizat, jurnalizarea a ceea ce a fost găsit, generat și revizuit este singura modalitate de a înțelege ulterior de ce un rezultat v-a dezamăgit.

def ticket_to_code_pipeline(ticket: str, codebase_index: list) -> dict:
    """Complete pipeline: ticket -> code -> review."""

    # 1. Contextual search
    relevant_files = search_context(ticket, codebase_index)
    print(f"Files found: {[f['path'] for f in relevant_files]}")

    # 2. Code generation
    generated_code = generate_code(ticket, relevant_files)
    print(f"Generated code: {len(generated_code)} characters")

    # 3. Automated review
    review = review_code(
        original_code=relevant_files[0]["content"],
        modified_code=generated_code,
        description=ticket,
    )
    print(f"Review: {review}")

    return {
        "ticket": ticket,
        "modified_files": relevant_files,
        "code": generated_code,
        "review": review,
    }

Integrare CI/CD

Acest mecanism își atinge potențialul maxim atunci când este conectat la CI-ul dumneavoastră. Un flux de lucru GitHub Actions declanșat la fiecare deschidere și actualizare de pull request este suficient pentru a rula revizuirea asupra fiecărei modificări propuse, fără a fi necesară nicio intervenție umană.

name: AI Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run AI Review
        env:
          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
        run: |
          python scripts/ai_review.py --pr ${{ github.event.pull_request.number }}

Scriptul apelat preia diff-ul, transmite fiecare fișier modificat către review_code și adaugă comentarii la PR doar atunci când revizuirea nu aprobă modificarea. Această condiție este esențială: un bot care comentează totul devine un zgomot pe care echipa învață să îl ignore în câteva zile.

# scripts/ai_review.py
def review_pull_request(pr_number: int):
    """Automated PR review with Mistral Small 4."""
    # 1. Retrieve PR diff
    diff = get_pr_diff(pr_number)

    # 2. Analyze each modified file
    for file in diff.files:
        review = review_code(
            original_code=file.before,
            modified_code=file.after,
            description=diff.title,
        )

        # 3. Post comment on PR
        if not review["approved"]:
            post_pr_comment(pr_number, file.path, review)

Variații comune în producție

Echipele care adoptă acest model îl adaptează la mai multe cazuri de utilizare recurente. În primul rând, generarea automată de teste: pentru fiecare fișier nou, fluxul produce testele corespunzătoare, transferând sarcina fără a elimina revizuirea. Apoi, documentarea continuă, unde docstring-urile sunt generate și actualizate la fiecare commit, mai degrabă decât în timpul unui audit. În continuare, detectarea regresiei, unde modelul de revizuire analizează diff-urile pentru efecte secundare probabile. În final, migrarea codului, care automatizează conversia între framework-uri sau versiuni – aici economiile de timp sunt cele mai semnificative, deoarece transformarea este repetitivă, iar rezultatul este verificabil prin testele existente.

O singură rezervă se aplică tuturor celor patru: revizuirea automată nu înlocuiește revizuirea umană. Aceasta surprinde scăpările mecanice și lasă judecata asupra a ceea ce contează cu adevărat în seama dezvoltatorilor dumneavoastră.

Puncte cheie

  • Un flux de lucru AI pentru cod combină căutarea (Embed), generarea (Codestral) și revizuirea (Mistral Small 4)
  • Codestral Embed găsește contextul, Codestral generează, iar un model de uz general verifică
  • Integrarea CI/CD permite revizuiri automate și generarea de teste
  • Modelul căutare -> generare -> revizuire se aplică multor fluxuri de lucru
  • Revizuirea automată nu înlocuiește revizuirea umană; o completează