smart-thinking-mcp/build/thought-graph.d.ts

Un serveur MCP avancé pour le raisonnement multi-dimensionnel, adaptatif et collaboratif

import { ThoughtNode, ThoughtType, Connection, ConnectionType, ThoughtMetrics, NextStepSuggestion, Hyperlink, ConnectionAttributes } from './types';
import { EmbeddingService } from './embedding-service';
import { QualityEvaluator } from './quality-evaluator';
/**
 * Classe qui gère le graphe de pensées et ses opérations
 */
export declare class ThoughtGraph {
    private nodes;
    private hyperlinks;
    private sessionId;
    private embeddingService?;
    private qualityEvaluator?;
    private eventEmitter;
    constructor(sessionId?: string, embeddingService?: EmbeddingService, qualityEvaluator?: QualityEvaluator);
    /**
     * Configure les écouteurs d'événements pour la vérification continue
     */
    private setupEventListeners;
    /**
     * Vérifie les calculs dans une pensée et les annote si nécessaire
     *
     * @param thoughtId L'identifiant de la pensée à vérifier
     * @param content Le contenu de la pensée
     */
    private checkForCalculationsAndVerify;
    /**
     * Permet d'enregistrer un écouteur d'événement externe
     *
     * @param event Le nom de l'événement
     * @param listener La fonction de rappel à exécuter
     */
    on(event: string, listener: (...args: any[]) => void): void;
    /**
     * Génère un identifiant unique
     */
    private generateUniqueId;
    /**
     * Ajoute une nouvelle pensée au graphe
     *
     * @param content Le contenu de la pensée
     * @param type Le type de pensée
     * @param connections Les connexions à d'autres pensées
     * @returns L'identifiant de la pensée ajoutée
     */
    addThought(content: string, type?: ThoughtType, connections?: Connection[]): string;
    /**
     * Met à jour les métriques pour une pensée spécifique (maintenant asynchrone)
     * @param thoughtId L'ID de la pensée
     */
    updateMetricsForThought(thoughtId: string): Promise<void>;
    /**
     * Établit des connexions bidirectionnelles entre les pensées
     *
     * @param sourceId L'identifiant de la pensée source
     * @param connections Les connexions à établir
     */
    private establishConnections;
    /**
     * Détermine le type de connexion réciproque
     *
     * @param type Le type de connexion original
     * @returns Le type de connexion réciproque
     */
    private getReciprocalConnectionType;
    /**
     * Récupère une pensée par son identifiant
     *
     * @param id L'identifiant de la pensée
     * @returns La pensée ou undefined si non trouvée
     */
    getThought(id: string): ThoughtNode | undefined;
    /**
     * Met à jour les métriques d'une pensée
     *
     * @param id L'identifiant de la pensée
     * @param metrics Les nouvelles métriques
     * @returns true si la mise à jour a réussi, false sinon
     */
    updateThoughtMetrics(id: string, metrics: Partial<ThoughtMetrics>): boolean;
    /**
     * Récupère toutes les pensées
     *
     * @param sessionId L'identifiant de session facultatif pour filtrer les pensées
     * @returns Un tableau de toutes les pensées (filtrées par session si sessionId est fourni)
     */
    getAllThoughts(sessionId?: string): ThoughtNode[];
    /**
     * Récupère les pensées les plus récentes
     *
     * @param limit Le nombre maximum de pensées à récupérer
     * @param sessionId L'identifiant de session facultatif pour filtrer les pensées
     * @returns Un tableau des pensées les plus récentes (filtrées par session)
     */
    getRecentThoughts(limit?: number, sessionId?: string): ThoughtNode[];
    /**
     * Récupère les pensées connectées à une pensée spécifique
     *
     * @param thoughtId L'identifiant de la pensée
     * @returns Un tableau des pensées connectées
     */
    getConnectedThoughts(thoughtId: string): ThoughtNode[];
    /**
     * Récupère les pensées les plus pertinentes pour un contexte donné
     *
     * @param context Le contexte pour lequel chercher des pensées pertinentes
     * @param limit Le nombre maximum de pensées à récupérer
     * @param sessionId L'identifiant de session facultatif pour filtrer les pensées
     * @returns Un tableau des pensées les plus pertinentes (filtrées par session)
     */
    getRelevantThoughts(context: string, limit?: number, sessionId?: string): Promise<ThoughtNode[]>;
    /**
     * Implémentation de secours basée sur les mots-clés
     *
     * @param context Le contexte pour lequel chercher des pensées pertinentes
     * @param limit Le nombre maximum de pensées à récupérer
     * @returns Un tableau des pensées les plus pertinentes
     */
    private getRelevantThoughtsWithKeywords;
    /**
     * Crée un hyperlien entre plusieurs pensées
     *
     * @param nodeIds Les identifiants des pensées à connecter
     * @param type Le type de connexion
     * @param label Une étiquette descriptive facultative
     * @param attributes Attributs sémantiques facultatifs
     * @param strength La force de la connexion (0 à 1)
     * @returns L'identifiant de l'hyperlien créé
     */
    createHyperlink(nodeIds: string[], type: ConnectionType, label?: string, attributes?: ConnectionAttributes, strength?: number): string;
    /**
     * Récupère un hyperlien par son identifiant
     *
     * @param id L'identifiant de l'hyperlien
     * @returns L'hyperlien ou undefined si non trouvé
     */
    getHyperlink(id: string): Hyperlink | undefined;
    /**
     * Récupère tous les hyperliens
     *
     * @param sessionId L'identifiant de session facultatif pour filtrer les hyperliens
     * @returns Un tableau de tous les hyperliens (filtrés par session)
     */
    getAllHyperlinks(sessionId?: string): Hyperlink[];
    /**
     * Récupère les hyperliens impliquant une pensée spécifique
     *
     * @param thoughtId L'identifiant de la pensée
     * @param sessionId L'identifiant de session facultatif pour filtrer les hyperliens
     * @returns Un tableau des hyperliens impliquant cette pensée (filtrés par session)
     */
    getHyperlinksForThought(thoughtId: string, sessionId?: string): Hyperlink[];
    /**
     * Infère des relations entre pensées basées sur l'analyse de contenu et de contexte
     *
     * @param confidenceThreshold Seuil de confiance minimum pour les relations inférées (0 à 1)
     * @returns Le nombre de nouvelles relations inférées
     */
    inferRelations(confidenceThreshold?: number): Promise<number>;
    /**
     * Infère des relations basées sur la similarité sémantique
     *
     * @param thoughts Les pensées à analyser
     * @param confidenceThreshold Seuil de confiance minimum
     * @returns Le nombre de nouvelles relations inférées
     */
    private inferRelationsBySimilarity;
    /**
     * Infère des relations basées sur la transitivité
     *
     * @param confidenceThreshold Seuil de confiance minimum
     * @returns Le nombre de nouvelles relations inférées
     */
    private inferRelationsByTransitivity;
    /**
     * Infère des relations basées sur des patterns dans le graphe
     *
     * @param confidenceThreshold Seuil de confiance minimum
     * @returns Le nombre de nouvelles relations inférées
     */
    private inferRelationsByPatterns;
    /**
     * Détecte des clusters (groupes) de pensées fortement connectées
     *
     * @returns Un tableau de clusters détectés
     */
    private detectClusters;
    /**
     * Explore une communauté connectée à partir d'un nœud de départ
     *
     * @param startNodeId ID du nœud de départ
     * @param visited Ensemble des nœuds déjà visités
     * @returns Un cluster de nœuds connectés
     */
    private exploreCommunity;
    /**
     * Infère le type de connexion approprié entre deux pensées
     *
     * @param sourceThought La pensée source
     * @param targetThought La pensée cible
     * @returns Le type de connexion inféré
     */
    private inferConnectionType;
    /**
     * Ajoute une connexion inférée entre deux pensées
     *
     * @param sourceId ID de la pensée source
     * @param targetId ID de la pensée cible
     * @param type Type de connexion
     * @param confidence Niveau de confiance dans l'inférence
     * @returns true si l'ajout a réussi, false sinon
     */
    private addInferredConnection;
    /**
     * Détermine si une connexion réciproque doit être créée
     *
     * @param type Le type de connexion
     * @returns true si une connexion réciproque doit être créée
     */
    private shouldCreateReciprocalConnection;
    /**
     * Convertit un niveau de confiance en niveau de certitude
     *
     * @param confidence Le niveau de confiance (0 à 1)
     * @returns Le niveau de certitude correspondant
     */
    private mapConfidenceToCertainty;
    /**
     * Enrichit une pensée existante avec des attributs sémantiques pour ses connexions
     *
     * @param thoughtId L'ID de la pensée à enrichir
     * @returns Le nombre de connexions enrichies
     */
    enrichThoughtConnections(thoughtId: string): number;
    /**
     * Infère des attributs sémantiques pour une connexion
     *
     * @param sourceThought La pensée source
     * @param targetThought La pensée cible
     * @param type Le type de connexion
     * @returns Les attributs sémantiques inférés
     */
    private inferConnectionAttributes;
    /**
     * Suggère les prochaines étapes de raisonnement, potentiellement en utilisant le LLM.
     *
     * @param limit Le nombre maximum de suggestions
     * @param sessionId L'identifiant de session facultatif pour filtrer le contexte
     * @returns Une promesse résolvant vers un tableau de suggestions pour les prochaines étapes
     */
    suggestNextSteps(limit?: number, sessionId?: string): Promise<NextStepSuggestion[]>;
    /**
     * Méthode heuristique originale pour suggérer les prochaines étapes (filtrée par session).
     */
    private suggestNextStepsHeuristic;
    /**
     * Vérifie si un texte contient l'un des termes donnés
     *
     * @param text Le texte à vérifier
     * @param terms Les termes à rechercher
     * @returns true si le texte contient au moins un des termes, false sinon
     */
    private containsAny;
    /**
     * Met à jour le contenu d'une pensée existante
     *
     * @param id L'identifiant de la pensée à mettre à jour
     * @param newContent Le nouveau contenu de la pensée
     * @returns true si la mise à jour a réussi, false sinon
     */
    updateThoughtContent(id: string, newContent: string): boolean;
    /**
     * Efface toutes les pensées du graphe
     */
    clear(): void;
    /**
     * Exporte le graphe de pensées sous forme de JSON
     *
     * @returns Une représentation JSON du graphe
     */
    exportToJson(): string;
    /**
     * Exporte le graphe enrichi (nœuds et hyperliens) sous forme de JSON
     *
     * @returns Une représentation JSON du graphe enrichi
     */
    exportEnrichedGraph(): string;
    /**
     * Importe un graphe de pensées depuis un JSON
     *
     * @param json Le JSON à importer
     * @returns true si l'importation a réussi, false sinon
     */
    importFromJson(json: string): boolean;
    /**
     * Importe un graphe enrichi depuis un JSON
     *
     * @param json Le JSON à importer
     * @returns true si l'importation a réussi, false sinon
     */
    importEnrichedGraph(json: string): boolean;
}