Flux de travail courants

Découvrez les flux de travail courants avec Qwen Code.

Chaque tâche de ce document inclut des instructions claires, des exemples de commandes et des bonnes pratiques pour vous aider à tirer le meilleur parti de Qwen Code.

Comprendre de nouvelles bases de code

Obtenir un aperçu rapide d’une base de code

Supposons que vous veniez de rejoindre un nouveau projet et que vous devez comprendre rapidement sa structure.

1. Accédez au répertoire racine du projet

cd /path/to/project

2. Démarrez Qwen Code

qwen

3. Demandez un aperçu général

donne-moi un aperçu de cette base de code

4. Approfondissez des composants spécifiques

explique les principaux modèles d'architecture utilisés ici

quels sont les modèles de données clés ?

comment l'authentification est-elle gérée ?

Trouver du code pertinent

Supposons que vous devez localiser le code lié à une fonctionnalité ou caractéristique spécifique.

1. Demander à Qwen Code de trouver les fichiers pertinents

trouver les fichiers qui gèrent l'authentification des utilisateurs

2. Obtenir le contexte sur la façon dont les composants interagissent

comment ces fichiers d'authentification fonctionnent-ils ensemble ?

3. Comprendre le flux d’exécution

tracer le processus de connexion depuis le front-end jusqu'à la base de données

Corriger les bugs efficacement

Supposons que vous avez rencontré un message d’erreur et que vous devez trouver et corriger sa source.

1. Partager l’erreur avec Qwen Code

J'obtiens une erreur quand j'exécute npm test

2. Demander des recommandations de correction

suggère plusieurs façons de corriger le @ts-ignore dans user.ts

3. Appliquer la correction

met à jour user.ts pour ajouter la vérification null que tu as suggérée

Refactoriser le code

Supposons que vous devez mettre à jour l’ancien code pour utiliser des modèles et des pratiques modernes.

1. Identifier le code hérité à refactoriser

trouver l'utilisation d'API dépréciées dans notre base de code

2. Obtenir des recommandations de refactorisation

suggérer comment refactoriser utils.js pour utiliser des fonctionnalités JavaScript modernes

3. Appliquer les changements en toute sécurité

refactoriser utils.js pour utiliser les fonctionnalités ES 2024 tout en conservant le même comportement

4. Vérifier la refactorisation

exécuter les tests pour le code refactorisé

Utiliser des sous-agents spécialisés

Supposons que vous souhaitiez utiliser des sous-agents IA spécialisés pour gérer des tâches spécifiques de manière plus efficace.

1. Voir les sous-agents disponibles

/agents

Cela affiche tous les sous-agents disponibles et vous permet d’en créer de nouveaux.

2. Utiliser automatiquement les sous-agents

Qwen Code délègue automatiquement les tâches appropriées aux sous-agents spécialisés :

review my recent code changes for security issues

run all tests and fix any failures

3. Demander explicitement des sous-agents spécifiques

use the code-reviewer subagent to check the auth module

have the debugger subagent investigate why users can't log in

4. Créer des sous-agents personnalisés pour votre flux de travail

/agents

Ensuite, sélectionnez « create » et suivez les invites pour définir :

• Un identifiant unique décrivant l’objectif du sous-agent (par exemple, code-reviewer, api-designer).
• Quand Qwen Code doit utiliser cet agent
• Quels outils il peut accéder
• Une invite système décrivant le rôle et le comportement de l’agent

Travailler avec les tests

Supposons que vous devez ajouter des tests pour du code non couvert.

1. Identifier le code non testé

trouver les fonctions dans NotificationsService.swift qui ne sont pas couvertes par des tests

2. Générer le squelette des tests

ajouter des tests pour le service de notification

3. Ajouter des cas de test significatifs

ajouter des cas de test pour les conditions limites dans le service de notification

4. Exécuter et vérifier les tests

exécuter les nouveaux tests et corriger les éventuels échecs

Qwen Code peut générer des tests qui suivent les modèles et conventions existants de votre projet. Lorsque vous demandez des tests, soyez précis sur le comportement que vous souhaitez vérifier. Qwen Code examine vos fichiers de test existants pour s’adapter au style, aux frameworks et aux modèles d’assertion déjà utilisés.

Pour une couverture complète, demandez à Qwen Code d’identifier les cas limites que vous pourriez avoir manqués. Qwen Code peut analyser vos chemins de code et suggérer des tests pour les conditions d’erreur, les valeurs limites et les entrées inattendues qui sont faciles à négliger.

Créer des pull requests

Supposons que vous devez créer une pull request bien documentée pour vos modifications.

1. Résumer vos changements

résumer les modifications que j'ai apportées au module d'authentification

2. Générer une pull request avec Qwen Code

créer une pr

3. Réviser et affiner

améliorer la description de la PR avec plus de contexte sur les améliorations de sécurité

4. Ajouter des détails sur les tests

ajouter des informations sur la manière dont ces changements ont été testés

Gérer la documentation

Supposons que vous devez ajouter ou mettre à jour la documentation de votre code.

1. Identifier le code non documenté

trouver les fonctions sans commentaires JSDoc appropriés dans le module d'authentification

2. Générer la documentation

ajouter des commentaires JSDoc aux fonctions non documentées dans auth.js

3. Réviser et améliorer

améliorer la documentation générée avec plus de contexte et d'exemples

4. Vérifier la documentation

vérifier si la documentation suit nos normes de projet

Référencer des fichiers et des répertoires

Utilisez @ pour inclure rapidement des fichiers ou des répertoires sans attendre que Qwen Code les lise.

1. Référencer un seul fichier

Explique la logique dans @src/utils/auth.js

Cela inclut le contenu complet du fichier dans la conversation.

2. Référencer un répertoire

Quelle est la structure de @src/components ?

Cela fournit une liste des fichiers du répertoire avec leurs informations.

3. Référencer des ressources MCP

Montre-moi les données de @github : repos/owner/repo/issues

Cela récupère les données depuis les serveurs MCP connectés en utilisant le format @serveur : ressource. Voir MCP pour plus de détails.

Reprendre les conversations précédentes

Supposons que vous ayez travaillé sur une tâche avec Qwen Code et que vous souhaitiez reprendre là où vous vous étiez arrêté lors d’une session ultérieure.

Qwen Code propose deux options pour reprendre les conversations précédentes :

• --continue pour reprendre automatiquement la conversation la plus récente
• --resume pour afficher un sélecteur de conversation

1. Reprendre la conversation la plus récente

qwen --continue

Cela reprend immédiatement votre conversation la plus récente sans aucune invite.

2. Reprendre en mode non interactif

qwen --continue --p "Continue with my task"

Utilisez --print avec --continue pour reprendre la conversation la plus récente en mode non interactif, idéal pour les scripts ou l’automatisation.

3. Afficher le sélecteur de conversation

qwen --resume

Cela affiche un sélecteur de conversation interactif avec une vue en liste claire montrant :

• Résumé de la session (ou invite initiale)
• Métadonnées : temps écoulé, nombre de messages et branche git

Utilisez les flèches pour naviguer et appuyez sur Entrée pour sélectionner une conversation. Appuyez sur Échap pour quitter.

# Reprendre la conversation la plus récente
qwen --continue
 
# Reprendre la conversation la plus récente avec une invite spécifique
qwen --continue --p "Montre-moi nos progrès"
 
# Afficher le sélecteur de conversation
qwen --resume
 
# Reprendre la conversation la plus récente en mode non interactif
qwen --continue --p "Exécute les tests à nouveau"

Exécuter des sessions Qwen Code parallèles avec des arborescences de travail Git

Supposons que vous deviez travailler sur plusieurs tâches simultanément avec une isolation complète du code entre les instances Qwen Code.

1. Comprendre les arborescences de travail Git

Les arborescences de travail Git vous permettent d’extraire plusieurs branches du même dépôt dans des répertoires distincts. Chaque arborescence de travail possède son propre répertoire de travail avec des fichiers isolés, tout en partageant le même historique Git. Pour en savoir plus, consultez la documentation officielle de Git worktree .

2. Créer une nouvelle arborescence de travail

 
# Créer une nouvelle arborescence de travail avec une nouvelle branche
git worktree add ../project-feature-a -b feature-a
 
# Ou créer une arborescence de travail avec une branche existante
git worktree add ../project-bugfix bugfix-123

Cela crée un nouveau répertoire avec une copie de travail séparée de votre dépôt.

3. Exécuter Qwen Code dans chaque arborescence de travail

 
# Naviguer vers votre arborescence de travail
cd ../project-feature-a
 
# Exécuter le code Qwen dans cet environnement isolé
qwen

4. Exécuter le code Qwen dans un autre arbre de travail

cd ../project-bugfix
qwen

5. Gérer vos arbres de travail

 
# Lister tous les arbres de travail
git worktree list
 
# Supprimer un worktree une fois terminé
git worktree remove ../project-feature-a

Utiliser Qwen Code comme un utilitaire de type Unix

Ajouter Qwen Code à votre processus de vérification

Supposons que vous souhaitiez utiliser Qwen Code comme un linter ou un outil de revue de code.

Ajoutez Qwen Code à votre script de build :

// package.json
{
    ...
    "scripts": {
        ...
        "lint:Qwen Code": "qwen -p 'you are a linter. please look at the changes vs. main and report any issues related to typos. report the filename and line number on one line, and a description of the issue on the second line. do not return any other text.'"
    }
}

Pipe d’entrée, pipe de sortie

Supposons que vous souhaitiez diriger des données vers Qwen Code et obtenir des données en sortie dans un format structuré.

Diriger des données via Qwen Code :

cat build-error.txt | qwen -p 'explique de manière concise la cause profonde de cette erreur de build' > output.txt

Contrôler le format de sortie

Supposons que vous ayez besoin que la sortie de Qwen Code soit dans un format spécifique, surtout lorsque vous intégrez Qwen Code dans des scripts ou d’autres outils.

1. Utiliser le format texte (par défaut)

cat data.txt | qwen -p 'résumer ces données' --output-format text > summary.txt

Cela affiche uniquement la réponse en texte brut de Qwen Code (comportement par défaut).

2. Utiliser le format JSON

cat code.py | qwen -p 'analyser ce code pour détecter des bogues' --output-format json > analysis.json

Cela affiche un tableau JSON de messages avec des métadonnées incluant le coût et la durée.

3. Utiliser le format JSON en flux continu

cat log.txt | qwen -p 'analyser ce fichier journal pour les erreurs' --output-format stream-json

Cela affiche une série d’objets JSON en temps réel pendant que Qwen Code traite la requête. Chaque message est un objet JSON valide, mais la totalité de la sortie n’est pas un JSON valide si elle est concaténée.

Poser des questions à Qwen Code sur ses capacités

Qwen Code dispose d’un accès intégré à sa documentation et peut répondre aux questions concernant ses propres fonctionnalités et limites.

Exemples de questions

Qwen Code peut-il créer des pull requests ?

Comment Qwen Code gère-t-il les autorisations ?

Quelles commandes slash sont disponibles ?

Comment utiliser MCP avec Qwen Code ?

Comment configurer Qwen Code pour Amazon Bedrock ?

Quelles sont les limites de Qwen Code ?