0Pricing
AI Agents · Leçon

Répertorier et gérer les problèmes

Récupérez, créez, étiquetez et clôturez des problèmes par programmation.

Répertorier et gérer les problèmes est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Récupérer les tickets d’un dépôt

Utilisez repo.get_issues() pour lister les tickets. Par défaut, cette méthode renvoie les tickets ouverts ; transmettez state='closed' ou state='all' pour obtenir les autres états. Le résultat est une PaginatedList : parcourez-la pour traiter chaque ticket.

from github import Github
import os

g = Github(token=os.environ['GITHUB_TOKEN'])
repo = g.get_repo('myorg/myrepo')

# Open issues (default)
open_issues = repo.get_issues(state='open')
print(f'Open issues: {open_issues.totalCount}')

# Process first 20
for issue in open_issues[:20]:
    print(f'#{issue.number}: {issue.title}')
    print(f'  Labels: {[l.name for l in issue.labels]}')
    print(f'  Assignee: {issue.assignee.login if issue.assignee else None}')
    print(f'  Created: {issue.created_at.date()}')

Filtrer les tickets

get_issues() prend en charge plusieurs paramètres de filtrage : state, labels, assignee, milestone, since et sort. Combinez-les pour obtenir exactement les tickets que votre agent doit traiter.

import datetime
from github import Github
import os

g = Github(token=os.environ['GITHUB_TOKEN'])
repo = g.get_repo('myorg/myrepo')

# Issues with the 'bug' label, sorted by newest
bug_issues = repo.get_issues(
    state='open',
    labels=['bug'],
    sort='created',
    direction='desc'
)

# Issues updated in the last 7 days
cutoff = datetime.datetime.now() - datetime.timedelta(days=7)
recent_issues = repo.get_issues(
    state='open',
    since=cutoff
)

# Issues assigned to a specific user
my_issues = repo.get_issues(
    state='open',
    assignee='username'
)

print(f'Bug issues: {bug_issues.totalCount}')
print(f'Recent issues: {recent_issues.totalCount}')

Accéder aux propriétés d’un ticket

Chaque objet Issue possède des propriétés détaillées : numéro, titre, corps, étiquettes, personnes assignées, jalon, état, nombre de commentaires et horodatages. Accédez-y sous forme d’attributs Python. Le corps est du texte Markdown brut.

from github import Github
import os

g = Github(token=os.environ['GITHUB_TOKEN'])
repo = g.get_repo('myorg/myrepo')
issue = repo.get_issue(42)  # get by number

print(f'Number: #{issue.number}')
print(f'Title: {issue.title}')
print(f'State: {issue.state}')        # 'open' or 'closed'
print(f'Author: {issue.user.login}')
print(f'Body length: {len(issue.body or "")}')
print(f'Labels: {[l.name for l in issue.labels]}')
print(f'Assignees: {[a.login for a in issue.assignees]}')
print(f'Milestone: {issue.milestone.title if issue.milestone else None}')
print(f'Comments: {issue.comments}')
print(f'Reactions: {issue.get_reactions().totalCount}')
print(f'URL: {issue.html_url}')

Créer de nouveaux tickets

Utilisez repo.create_issue() pour créer un ticket par programmation. Le seul champ obligatoire est title. Ajoutez body (Markdown), labels (qui doivent déjà exister), assignees (noms d’utilisateur GitHub) et milestone (objet jalon).

from github import Github
import os

g = Github(token=os.environ['GITHUB_TOKEN'])
repo = g.get_repo('myorg/myrepo')

# Create a bug report
bug_body = (
    '## Bug Report\n\n'
    '**Observed:** Login fails with 500 error\n'
    '**Expected:** Successful login\n'
    '**Steps to reproduce:**\n'
    '1. Navigate to /login\n'
    '2. Enter valid credentials\n'
    '3. Click Submit\n\n'
    '**Environment:** Production, v2.3.1'
)

issue = repo.create_issue(
    title='Login endpoint returns 500 for valid credentials',
    body=bug_body,
    labels=['bug', 'priority:high'],
    assignees=['alice'],       # must be repo collaborators
)

print(f'Created issue #{issue.number}: {issue.html_url}')

Modifier (mettre à jour) des tickets

Utilisez issue.edit() pour mettre à jour toute propriété d’un ticket existant. Vous pouvez modifier le titre, le corps, l’état, les étiquettes, les personnes assignées ou le jalon en un seul appel. Ne transmettez que les champs à modifier : les autres sont conservés.

from github import Github
import os

g = Github(token=os.environ['GITHUB_TOKEN'])
repo = g.get_repo('myorg/myrepo')
issue = repo.get_issue(42)

# Update title and add new labels
issue.edit(
    title='[URGENT] Login endpoint returns 500',
    labels=['bug', 'priority:critical', 'needs-hotfix']
)

# Close the issue
issue.edit(state='closed')
print(f'Issue #{issue.number} closed')

# Reopen it
issue.edit(state='open')

# Assign to a user
from github import NamedUser
issue.edit(assignees=['bob', 'carol'])

# Update the body
issue.edit(body=issue.body + '\n\n**Update:** Hotfix deployed to production.')

Gérer les étiquettes

Les étiquettes organisent les tickets. Récupérez toutes les étiquettes d’un dépôt avec repo.get_labels(), créez-en de nouvelles avec repo.create_label(), puis ajoutez ou retirez des étiquettes d’un ticket avec issue.add_to_labels() et issue.remove_from_labels().

from github import Github
import os

g = Github(token=os.environ['GITHUB_TOKEN'])
repo = g.get_repo('myorg/myrepo')

# List all labels
for label in repo.get_labels():
    print(f'{label.name}: #{label.color}')

# Create a new label if it doesn't exist
existing_names = {l.name for l in repo.get_labels()}
if 'agent-reviewed' not in existing_names:
    repo.create_label(
        name='agent-reviewed',
        color='0075ca',       # hex without #
        description='Reviewed by AI agent'
    )
    print('Created label: agent-reviewed')

# Add a label to an issue
issue = repo.get_issue(42)
issue.add_to_labels('agent-reviewed')

# Remove a label
issue.remove_from_labels('needs-triage')

Lire les commentaires d’un ticket

Utilisez issue.get_comments() pour récupérer tous les commentaires d’un ticket. Chaque commentaire possède un auteur (user.login), un texte et des horodatages. Parcourez-les dans l’ordre pour voir l’historique de la conversation.

from github import Github
import os

g = Github(token=os.environ['GITHUB_TOKEN'])
repo = g.get_repo('myorg/myrepo')
issue = repo.get_issue(42)

# Get all comments
comments = list(issue.get_comments())
print(f'Comments on #{issue.number}: {len(comments)}')

for comment in comments:
    print(f'\n{comment.user.login} ({comment.created_at.date()}):')
    print(comment.body[:200])

# Get only recent comments
for comment in issue.get_comments(since=cutoff):
    print(f'Recent: {comment.user.login}: {comment.body[:100]}')

Ajouter des commentaires aux tickets

Utilisez issue.create_comment(body) pour publier un commentaire. Le corps accepte le format Markdown. Les commentaires de l’agent doivent indiquer clairement qu’ils sont automatisés : ajoutez un en-tête « 🤖 Analyse automatisée » pour définir les attentes.

from github import Github
import os
import datetime

g = Github(token=os.environ['GITHUB_TOKEN'])
repo = g.get_repo('myorg/myrepo')
issue = repo.get_issue(42)

# Add an agent comment with clear attribution
agent_comment = (
    '**Automated Analysis** (via code-review agent)\n\n'
    '---\n'
    f'**Issue classified as:** Critical Bug\n'
    f'**Suggested priority:** P0\n'
    f'**Suggested assignee:** @backend-team\n\n'
    '**Analysis:**\n'
    'The login 500 error matches pattern #12 in our known issues database.\n'
    'Likely cause: database connection pool exhaustion during peak traffic.\n\n'
    '**Suggested fix:** Increase pool size in `db_config.py` or add circuit breaker.\n\n'
    f'_Generated at {datetime.datetime.now().strftime("%Y-%m-%d %H:%M UTC")}_'
)

comment = issue.create_comment(agent_comment)
print(f'Comment added: {comment.html_url}')

Agent de qualification groupée des tickets

Un agent de qualification traite automatiquement les nouveaux tickets : il lit le titre et le corps, les classe au moyen d’un LLM, ajoute les étiquettes appropriées, les attribue à la bonne équipe et publie un commentaire initial. Cela fait gagner des heures de travail manuel de qualification aux ingénieurs.

import anthropic
import json
import os
from github import Github

g = Github(token=os.environ['GITHUB_TOKEN'])
client = anthropic.Anthropic(api_key=os.environ['ANTHROPIC_API_KEY'])

def triage_issue(repo, issue):
    prompt = (
        'Classify this GitHub issue. Return JSON only:\n'
        '{"type": "bug|feature|question|docs", '
        '"priority": "critical|high|medium|low", '
        '"team": "backend|frontend|infra|ml", '
        '"summary": "one sentence"}\n\n'
        f'Title: {issue.title}\n'
        f'Body: {(issue.body or "")[:1000]}'
    )
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=200,
        messages=[{'role': 'user', 'content': prompt}]
    )
    try:
        return json.loads(response.content[0].text)
    except json.JSONDecodeError:
        return {'type': 'question', 'priority': 'medium', 'team': 'backend', 'summary': 'Needs manual review'}

Appliquer les résultats de qualification aux tickets

Appliquez la classification du LLM au ticket : définissez les étiquettes selon le type et la priorité, attribuez le ticket au responsable approprié de l’équipe et publiez un commentaire de qualification. Suivez les tickets déjà qualifiés au moyen d’une étiquette personnalisée afin d’éviter de les traiter à nouveau.

TEAM_ASSIGNEES = {
    'backend': 'alice',
    'frontend': 'bob',
    'infra': 'carol',
    'ml': 'dave'
}

def apply_triage(repo, issue, classification):
    issue_type = classification.get('type', 'question')
    priority = classification.get('priority', 'medium')
    team = classification.get('team', 'backend')
    summary = classification.get('summary', '')

    # Apply labels
    labels_to_add = [f'type:{issue_type}', f'priority:{priority}', 'agent-triaged']
    issue.edit(labels=labels_to_add)

    # Assign to team lead
    assignee = TEAM_ASSIGNEES.get(team, 'alice')
    issue.edit(assignees=[assignee])

    # Post triage comment
    comment = (
        f'**Automated Triage**\n\n'
        f'Type: `{issue_type}` | Priority: `{priority}` | Team: `{team}`\n'
        f'Summary: {summary}\n\n'
        f'Assigned to @{assignee} for follow-up.'
    )
    issue.create_comment(comment)
    print(f'Triaged #{issue.number}: {issue_type}/{priority} -> {assignee}')

# --- demo: minimal stand-in for a GitHub Issue object ---
class _FakeIssue:
    number = 501
    def edit(self, **kwargs):
        print(f'[github] issue.edit({kwargs})')
    def create_comment(self, body):
        print(f'[github] comment posted:\n{body}')

classification = {'type': 'bug', 'priority': 'high', 'team': 'backend',
                   'summary': 'Login fails with 500 when email has a plus sign'}
apply_triage('coddy-agents', _FakeIssue(), classification)

Fermer automatiquement les tickets inactifs

La gestion des tickets inactifs est une automatisation courante : recherchez les tickets ouverts sans activité depuis N jours, publiez un commentaire d’avertissement et fermez-les si aucune réponse n’arrive pendant un délai de grâce. Utilisez issue.updated_at pour vérifier l’activité et issue.edit(state='closed') pour fermer le ticket.

import datetime
from github import Github
import os

g = Github(token=os.environ['GITHUB_TOKEN'])
repo = g.get_repo('myorg/myrepo')

STALE_DAYS = 90
GRACE_DAYS = 14

now = datetime.datetime.utcnow()
stale_cutoff = now - datetime.timedelta(days=STALE_DAYS)

for issue in repo.get_issues(state='open'):
    last_updated = issue.updated_at.replace(tzinfo=None)
    if last_updated > stale_cutoff:
        continue

    # Check if stale warning already posted
    comments = list(issue.get_comments())
    stale_warned = any('stale' in c.body.lower() for c in comments)

    if not stale_warned:
        issue.create_comment(
            'This issue has been inactive for 90 days. '
            'It will be closed in 14 days unless there is activity.'
        )
        issue.add_to_labels('stale')
        print(f'Stale warning: #{issue.number}')

Vérification rapide : issue.edit() ou create_issue()

Testez votre compréhension de la gestion des tickets GitHub.

Récapitulatif de la gestion des tickets

Votre agent peut désormais gérer les tickets GitHub de bout en bout :

  • repo.get_issues(state, labels, assignee, since) — filtrer et lister les tickets
  • repo.get_issue(number) — récupérer un ticket précis par son numéro
  • repo.create_issue(title, body, labels, assignees) — ouvrir un nouveau ticket
  • issue.edit(state, title, labels, assignees) — mettre à jour n’importe quel champ
  • issue.create_comment(body) — ajouter un commentaire Markdown
  • repo.create_label() / issue.add_to_labels() — gérer les étiquettes
  • Identifiez toujours clairement les commentaires de l’agent afin de les distinguer de l’activité humaine
  • Utilisez les étiquettes 'agent-triaged' pour empêcher un nouveau traitement

Questions Fréquemment Posées

La leçon « Répertorier et gérer les problèmes » est-elle gratuite ?

Oui — le texte complet de « Répertorier et gérer les problèmes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Répertorier et gérer les problèmes » ?

Récupérez, créez, étiquetez et clôturez des problèmes par programmation. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Répertorier et gérer les problèmes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Présentation de l’API REST GitHub
  2. Répertorier et gérer les problèmes
  3. Commentaires automatisés de revue de PR
  4. Historique des commits et analyse des différences
← Retour à AI Agents