@liangshanli/mcp-server-project-standards 1.0.0

package/src/utils/get_project_structure.js

@@ -0,0 +1,139 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Project structure tool - get, set or delete project structure
+ * @param {Object} params - Parameters
+ * @param {string} params.action - Action to perform ('get', 'set', or 'delete')
+ * @param {Array} params.structure - Array of structure items with path and description (required for 'set' action)
+ * @param {string} params.path - Path to delete when action is 'delete'
+ * @param {Object} config - Server configuration
+ * @param {Function} saveConfig - Function to save configuration (required for 'set' and 'delete' actions)
+ * @returns {Array|Object} Project structure array or update result
+ */
+async function project_structure(params, config, saveConfig) {
+  const { action, structure, path: deletePath } = params || {};
+  
+  if (!action) {
+    throw new Error('Missing action parameter. Must be "get", "set", or "delete"');
+  }
+  
+  if (action === 'get') {
+    try {
+      // 从配置文件的 project_structure 字段中获取结构，如果没有则使用默认值
+      const projectStructure = config?.project_structure || [];
+
+      return projectStructure;
+    } catch (err) {
+      throw new Error(`Failed to get project structure: ${err.message}`);
+    }
+  } else if (action === 'set') {
+    if (!Array.isArray(structure)) {
+      throw new Error('Structure must be an array for set action');
+    }
+    
+    if (!saveConfig) {
+      throw new Error('saveConfig function is required for set action');
+    }
+    
+    try {
+      // 获取当前结构
+      let currentStructure = config?.project_structure || [];
+      
+      // 创建新结构数组
+      const newStructure = [];
+      
+      // 循环处理每个新结构项
+      for (const item of structure) {
+        if (!item.path || !item.description) {
+          throw new Error('Each structure item must have "path" and "description" properties');
+        }
+        
+        // 检查路径是否已存在
+        const existingIndex = currentStructure.findIndex(existing => existing.path === item.path);
+        
+        if (existingIndex !== -1) {
+          // 路径存在，替换
+          currentStructure[existingIndex] = {
+            path: item.path,
+            description: item.description
+          };
+        } else {
+          // 路径不存在，添加到新结构
+          newStructure.push({
+            path: item.path,
+            description: item.description
+          });
+        }
+      }
+      
+      // 将新结构附加到现有结构
+      const updatedStructure = [...currentStructure, ...newStructure];
+      
+      // 更新配置
+      if (!config.project_structure) {
+        config.project_structure = [];
+      }
+      config.project_structure = updatedStructure;
+      
+      // 保存配置
+      const saved = saveConfig(config);
+      if (!saved) {
+        throw new Error('Failed to save configuration');
+      }
+      
+      return {
+        success: true,
+        message: `Successfully updated project structure`,
+        updatedCount: structure.length,
+        newItemsCount: newStructure.length,
+        totalItems: updatedStructure.length,
+        timestamp: new Date().toISOString()
+      };
+    } catch (err) {
+      throw new Error(`Failed to update project structure: ${err.message}`);
+    }
+  } else if (action === 'delete') {
+    if (!deletePath) {
+      throw new Error('Missing path parameter for delete action');
+    }
+    
+    if (!saveConfig) {
+      throw new Error('saveConfig function is required for delete action');
+    }
+    
+    try {
+      // 确保 config.project_structure 存在
+      if (!config.project_structure) {
+        config.project_structure = [];
+      }
+      
+      // 查找并删除指定的路径
+      const pathIndex = config.project_structure.findIndex(item => item.path === deletePath);
+      if (pathIndex !== -1) {
+        const deletedItem = config.project_structure.splice(pathIndex, 1)[0];
+        
+        // 保存配置
+        const saved = saveConfig(config);
+        if (!saved) {
+          throw new Error('Failed to save configuration');
+        }
+        
+        return {
+          success: true,
+          message: `Successfully deleted structure item: ${deletePath}`,
+          deletedItem: deletedItem,
+          timestamp: new Date().toISOString()
+        };
+      } else {
+        throw new Error(`Path '${deletePath}' not found`);
+      }
+    } catch (err) {
+      throw new Error(`Failed to delete structure item: ${err.message}`);
+    }
+  } else {
+    throw new Error('Invalid action. Must be "get", "set", or "delete"');
+  }
+}
+
+module.exports = project_structure;

package/src/utils/list_custom_tools.js

@@ -0,0 +1,15 @@
+/**
+ * List all custom tools
+ * @param {Object} params - Parameters
+ * @param {Object} config - Server configuration
+ * @returns {Object} List of custom tools
+ */
+async function list_custom_tools(params, config) {
+  return {
+    tools: config.customTools || [],
+    count: (config.customTools || []).length,
+    timestamp: new Date().toISOString()
+  };
+}
+
+module.exports = list_custom_tools;

package/src/utils/update_config.js

@@ -0,0 +1,36 @@
+/**
+ * Update server configuration
+ * @param {Object} params - Parameters
+ * @param {Object} params.config - Configuration object to update
+ * @param {Object} currentConfig - Current server configuration
+ * @param {Function} saveConfig - Function to save configuration
+ * @returns {Object} Result of configuration update
+ */
+async function update_config(params, currentConfig, saveConfig) {
+  const { config } = params || {};
+  
+  if (!config || typeof config !== 'object') {
+    throw new Error('Invalid config parameter');
+  }
+
+  try {
+    // Merge with existing config
+    const updatedConfig = { ...currentConfig, ...config };
+    
+    // Save to file
+    const saved = saveConfig(updatedConfig);
+    if (!saved) {
+      throw new Error('Failed to save configuration');
+    }
+
+    return {
+      success: true,
+      config: updatedConfig,
+      message: 'Configuration updated successfully'
+    };
+  } catch (err) {
+    throw new Error(`Failed to update configuration: ${err.message}`);
+  }
+}
+
+module.exports = update_config;

package/start-server.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+class ServerManager {
+  constructor() {
+    this.serverProcess = null;
+    this.restartCount = 0;
+    this.maxRestarts = 10;
+    this.restartDelay = 5000; // 5 seconds
+    this.serverPath = path.resolve(__dirname, 'src/server-final.js');
+  }
+
+  start() {
+    console.log('Starting MCP Project Standards server...');
+    this.spawnServer();
+  }
+
+  spawnServer() {
+    // Set environment variables
+    const env = {
+      ...process.env,
+      // Only pass CONFIG_PATH if specified
+      ...(process.env.CONFIG_PATH && { CONFIG_PATH: process.env.CONFIG_PATH })
+    };
+
+    this.serverProcess = spawn('node', [this.serverPath], {
+      stdio: ['inherit', 'inherit', 'inherit'],
+      env: env
+    });
+
+    console.log(`Server process started, PID: ${this.serverProcess.pid}`);
+
+    this.serverProcess.on('close', (code) => {
+      console.log(`Server process exited, exit code: ${code}`);
+      this.handleServerExit(code);
+    });
+
+    this.serverProcess.on('error', (err) => {
+      console.error('Server process error:', err.message);
+      this.handleServerError(err);
+    });
+
+    // Handle process signals
+    process.on('SIGTERM', () => {
+      console.log('Received SIGTERM signal, shutting down server...');
+      this.shutdown();
+    });
+
+    process.on('SIGINT', () => {
+      console.log('Received SIGINT signal, shutting down server...');
+      this.shutdown();
+    });
+  }
+
+  handleServerExit(code) {
+    if (code === 0) {
+      console.log('Server exited normally');
+      process.exit(0);
+    } else {
+      console.error(`Server exited abnormally, exit code: ${code}`);
+      this.restartServer();
+    }
+  }
+
+  handleServerError(err) {
+    console.error('Server process error:', err.message);
+    this.restartServer();
+  }
+
+  restartServer() {
+    if (this.restartCount < this.maxRestarts) {
+      this.restartCount++;
+      console.log(`Restarting server... (${this.restartCount}/${this.maxRestarts})`);
+      
+      setTimeout(() => {
+        this.spawnServer();
+      }, this.restartDelay);
+    } else {
+      console.error(`Reached maximum restart count (${this.maxRestarts}), stopping restarts`);
+      process.exit(1);
+    }
+  }
+
+  shutdown() {
+    if (this.serverProcess) {
+      console.log('Sending SIGTERM signal to server process...');
+      this.serverProcess.kill('SIGTERM');
+      
+      // Wait 5 seconds then force exit
+      setTimeout(() => {
+        if (this.serverProcess) {
+          console.log('Force killing server process...');
+          this.serverProcess.kill('SIGKILL');
+        }
+        process.exit(0);
+      }, 5000);
+    } else {
+      process.exit(0);
+    }
+  }
+}
+
+// Start server manager
+const manager = new ServerManager();
+manager.start();