smart-thinking-mcp
Version:
Un serveur MCP avancé pour le raisonnement multi-dimensionnel, adaptatif et collaboratif
238 lines • 9.04 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.PathUtils = void 0;
/**
* Utilitaires pour gérer les chemins de fichiers de manière cross-plateforme
* Compatible avec Windows, Mac et Linux
*/
const path = __importStar(require("path"));
const os_1 = require("os");
const fs = __importStar(require("fs"));
// Constante pour contrôler l'affichage des logs de débogage
const DEBUG_MODE = false;
/**
* Classe d'utilitaires pour gérer les chemins de fichiers de manière cross-plateforme
*/
class PathUtils {
static isWindows = (0, os_1.platform)() === 'win32';
static isMac = (0, os_1.platform)() === 'darwin';
static isLinux = (0, os_1.platform)() === 'linux';
/**
* Fonction de log pour le débogage uniquement
* @param message Message à logger
*/
static debugLog(message) {
if (DEBUG_MODE) {
console.error(`Smart-Thinking Debug: ${message}`);
}
}
/**
* Normalise un chemin pour qu'il soit compatible avec la plateforme actuelle
* @param inputPath Chemin d'entrée
* @returns Chemin normalisé
*/
static normalizePath(inputPath) {
if (!inputPath)
return inputPath;
// Normaliser le chemin selon la plateforme
let normalizedPath = path.normalize(inputPath);
if (this.isWindows) {
// Convertir tous les backslashes en forward slashes pour être cohérent
normalizedPath = normalizedPath.replace(/\\/g, '/');
// Gérer les chemins UNC Windows (commençant par \\)
if (normalizedPath.startsWith('//')) {
return normalizedPath;
}
// Gérer les chemins de style WSL comme /mnt/c/...
if (normalizedPath.startsWith('/mnt/')) {
const driveLetter = normalizedPath.charAt(5);
if (/[a-z]/i.test(driveLetter)) {
return `${driveLetter.toUpperCase()}:${normalizedPath.slice(6)}`;
}
}
}
return normalizedPath;
}
/**
* Obtient le chemin absolu d'un fichier
* @param relativePath Chemin relatif
* @returns Chemin absolu
*/
static getAbsolutePath(relativePath) {
return path.resolve(relativePath);
}
/**
* Obtient un chemin absolu pour le home directory de l'utilisateur
* @returns Chemin absolu du home directory
*/
static getHomeDirectory() {
// Garantir un chemin valide même si HOME/USERPROFILE n'est pas défini
let homeDir = '';
if (this.isWindows) {
const userProfile = process.env.USERPROFILE;
const homeDrive = process.env.HOMEDRIVE || '';
const homePath = process.env.HOMEPATH || '';
if (userProfile) {
homeDir = userProfile;
}
else if (homeDrive && homePath) {
homeDir = homeDrive + homePath;
}
else {
homeDir = 'C:\\Users\\Default';
}
}
else {
homeDir = process.env.HOME || '/tmp';
}
return homeDir;
}
/**
* Obtient le répertoire de données du serveur
* @returns Chemin absolu du répertoire de données
*/
static getDataDirectory() {
// Toujours utiliser des chemins absolus
const homeDir = this.getHomeDirectory();
let dataDir;
if (this.isWindows) {
// Sur Windows, utiliser AppData\Roaming ou Documents
const appData = process.env.APPDATA;
if (appData) {
dataDir = path.join(appData, 'Smart-Thinking', 'data');
}
else {
dataDir = path.join(homeDir, 'Documents', 'Smart-Thinking', 'data');
}
}
else if (this.isMac) {
// Sur Mac, utiliser ~/Library/Application Support
dataDir = path.join(homeDir, 'Library', 'Application Support', 'Smart-Thinking', 'data');
}
else {
// Sur Linux et autres, utiliser ~/.smart-thinking
dataDir = path.join(homeDir, '.smart-thinking', 'data');
}
this.debugLog(`Répertoire de données configuré: ${dataDir}`);
return dataDir;
}
/**
* Obtient le répertoire de configuration selon la plateforme
* @returns Chemin du répertoire de configuration
*/
static getConfigDirectory() {
const homeDir = this.getHomeDirectory();
if (this.isWindows) {
const appData = process.env.APPDATA;
if (appData) {
return path.join(appData, 'Smart-Thinking');
}
else {
return path.join(homeDir, 'AppData', 'Roaming', 'Smart-Thinking');
}
}
else if (this.isMac) {
return path.join(homeDir, 'Library', 'Application Support', 'Smart-Thinking');
}
else {
return path.join(homeDir, '.smart-thinking');
}
}
/**
* Vérifie si un chemin est absolu
* @param filePath Chemin à vérifier
* @returns true si le chemin est absolu
*/
static isAbsolutePath(filePath) {
return path.isAbsolute(filePath);
}
/**
* Crée un répertoire et ses parents s'ils n'existent pas déjà
* @param dirPath Chemin du répertoire à créer
* @returns Promise qui se résout quand le répertoire existe
*/
static async ensureDirectoryExists(dirPath) {
// S'assurer que le chemin est absolu
if (!path.isAbsolute(dirPath)) {
dirPath = path.resolve(dirPath);
}
try {
// Créer récursivement tous les répertoires parents
await fs.promises.mkdir(dirPath, { recursive: true, mode: 0o755 });
this.debugLog(`Répertoire créé ou confirmé: ${dirPath}`);
}
catch (error) {
// Log d'erreur important - garder
console.error(`Smart-Thinking: Erreur lors de la création du répertoire: ${dirPath}`, error);
// Essayer un répertoire alternatif en cas d'échec
try {
const homeDir = this.getHomeDirectory();
const tempDir = this.isWindows ?
path.join(homeDir, 'AppData', 'Local', 'Temp', 'Smart-Thinking') :
path.join('/tmp', 'Smart-Thinking');
await fs.promises.mkdir(tempDir, { recursive: true, mode: 0o777 });
this.debugLog(`Utilisation du répertoire temporaire: ${tempDir}`);
return;
}
catch (fallbackError) {
throw new Error(`Impossible de créer de répertoire de données, même dans le dossier temporaire: ${fallbackError}`);
}
}
}
/**
* Obtient le répertoire temporaire spécifique à la plateforme
* @returns Chemin du répertoire temporaire
*/
static getTempDirectory() {
const tempBase = this.isWindows ?
process.env.TEMP || process.env.TMP || 'C:\\Temp' :
'/tmp';
return path.join(tempBase, 'Smart-Thinking');
}
/**
* Obtient le chemin d'installation de Node.js
* Utile pour les configurations spécifiques à NVM
* @returns Chemin d'installation de Node.js
*/
static getNodeInstallPath() {
// Obtenir le chemin du processus Node en cours d'exécution
const nodePath = process.execPath;
this.debugLog(`Chemin Node.js détecté: ${nodePath}`);
return nodePath;
}
}
exports.PathUtils = PathUtils;
//# sourceMappingURL=path-utils.js.map