Sequential Thinking Logic

Expertise : Raisonnement décomposé, validation logique, analyse étape par étape, pensée structurée pour architectures complexes.

Quick Start

Mental Model

Sequential Thinking Logic décompose les problèmes complexes en séquences logiques validées :

Analyse Background Script vs Content Script
Validation des flux de données
Identification des points de défaillance
Construction de chaînes de raisonnement robustes

Workflow obligatoire

Décomposition : Identifier les composants logiques principaux
Validation : Utiliser sequentialthinking_tools pour chaque étape
Chaînage : Connecter les étapes en une séquence cohérente
Test logique : Valider les hypothèses et points de rupture

Patterns d'utilisation

Pour architecture d'extension

# Décomposer l'architecture
sequentialthinking_tools decompose "Extension Chrome: Background <-> Content <-> API"

# Valider chaque composant
sequentialthinking_tools validate "Background script logic"
sequentialthinking_tools validate "Content script injection"
sequentialthinking_tools validate "API communication flow"

# Tester la séquence complète
sequentialthinking_tools test-sequence "user_action -> background -> content -> api -> response"

Pour logique métier complexe

# Analyser le flux métier
sequentialthinking_tools decompose "User authentication flow"

# Valider chaque étape
sequentialthinking_tools validate "Input validation"
sequentialthinking_tools validate "Credential verification"
sequentialthinking_tools validate "Session management"
sequentialthinking_tools validate "Error handling"

# Identifier les points de rupture
sequentialthinking_tools find-breakpoints "auth_flow"

Production-safe patterns

Validation systématique

Pour chaque composant logique :

# 1. Décomposition
sequentialthinking_tools decompose "[composant]"

# 2. Validation logique
sequentialthinking_tools validate "[sous-composant_1]"
sequentialthinking_tools validate "[sous-composant_2]"

# 3. Test de séquence
sequentialthinking_tools test-sequence "[flux_complet]"

Background vs Content Script

Pattern spécifique pour extensions web :

# Background Script Logic
sequentialthinking_tools validate-background "event_listeners"
sequentialthinking_tools validate-background "message_routing"
sequentialthinking_tools validate-background "storage_management"

# Content Script Logic
sequentialthinking_tools validate-content "dom_manipulation"
sequentialthinking_tools validate-content "user_interaction"
sequentialthinking_tools validate-content "message_communication"

# Cross-script communication
sequentialthinking_tools test-communication "background <-> content"

Gestion des erreurs logiques

# Identifier les points de défaillance
sequentialthinking_tools find-breakpoints "[flux]"

# Analyser les cas limites
sequentialthinking_tools edge-cases "[composant]"

# Valider la gestion d'erreurs
sequentialthinking_tools validate-error-handling "[flux]"

Common gotchas

Séquences incomplètes

Toujours valider le début ET la fin de chaque séquence
Les points de décision doivent avoir tous les cas couverts
Les boucles doivent avoir des conditions de sortie claires

Dépendances circulaires

# Détecter les circularités
sequentialthinking_tools detect-cycles "[architecture]"

# Résoudre les dépendances
sequentialthinking_tools resolve-dependencies "[composants]"

Background/Content contamination

Éviter de mélanger logique UI et logique métier
Isoler les communications entre scripts
Valider les contextes d'exécution séparément

API Reference

Commandes principales

sequentialthinking_tools decompose "<concept>" : Décompose en composants logiques
sequentialthinking_tools validate "<composant>" : Valide la logique d'un composant
sequentialthinking_tools test-sequence "<flux>" : Teste une séquence complète
sequentialthinking_tools find-breakpoints "<flux>" : Identifie les points de rupture
sequentialthinking_tools edge-cases "<composant>" : Analyse les cas limites

Commandes spécialisées

sequentialthinking_tools validate-background "<logique>" : Validation Background Script
sequentialthinking_tools validate-content "<logique>" : Validation Content Script
sequentialthinking_tools test-communication "<scripts>" : Test communication inter-scripts
sequentialthinking_tools detect-cycles "<architecture>" : Détection dépendances circulaires
sequentialthinking_tools resolve-dependencies "<composants>" : Résolution dépendances

Options avancées

--depth <n> : Profondeur d'analyse (1-5)
--verbose : Sortie détaillée du raisonnement
--export-logic : Exporte le modèle logique en JSON
--test-cases : Génère cas de test automatiquement

Debugging checklist

Confirmer que chaque étape a une entrée ET une sortie
Vérifier que les points de décision sont complets
Tester les cas limites et erreurs
Valider les communications entre composants
Contrôler l'absence de dépendances circulaires

When to use this skill

Architecture d'extensions : Chrome/Firefox Background/Content Scripts
Logique métier complexe : Flux multi-étapes avec validations
Systèmes distribués : Communication entre services
Algorithmes séquentiels : Traitement par étapes
Validation de design : Revue logique d'architectures
Debugging logique : Analyse de raisonnement défaillant

Integration patterns

Avec Shrimp Task Manager

Utilise après analyze_task pour valider la décomposition logique des tâches.

Avec Fast Filesystem

Utilise pour valider la logique avant les édition chirurgicales avec edit_file.

Avec JSON Query

Utilise json_query_jsonpath pour extraire les structures logiques des fichiers de configuration avant validation.

sequentialthinking-logic