mcp-with-ssh

Instructions

Implementation Reference

• src/server/tools/CoreTools.ts:180-280 (handler)

  The primary handler function for the 'initialize_memory_bank' MCP tool. It sets the custom path, calls MemoryBankManager.initialize(true), and returns success/error messages.
  export async function handleInitializeMemoryBank( memoryBankManager: MemoryBankManager, dirPath: string ) { try { // If dirPath is not provided, use the project path const basePath = dirPath || memoryBankManager.getProjectPath(); // Ensure the path is absolute const absolutePath = path.isAbsolute(basePath) ? basePath : path.resolve(process.cwd(), basePath); console.error('Using absolute path:', absolutePath); try { // Set the custom path first await memoryBankManager.setCustomPath(absolutePath); // Initialize the Memory Bank with createIfNotExists = true await memoryBankManager.initialize(true); // Get the Memory Bank directory const memoryBankDir = memoryBankManager.getMemoryBankDir(); return { content: [ { type: 'text', text: `Memory Bank initialized at ${memoryBankDir}`, }, ], }; } catch (initError) { // Check if the error is related to .clinerules files const errorMessage = String(initError); if (errorMessage.includes('.clinerules')) { console.warn('Warning: Error related to .clinerules files:', initError); console.warn('Continuing with Memory Bank initialization despite .clinerules issues.'); // Use the provided path directly as the memory bank directory const memoryBankDir = absolutePath; try { await FileUtils.ensureDirectory(memoryBankDir); memoryBankManager.setMemoryBankDir(memoryBankDir); return { content: [ { type: 'text', text: `Memory Bank initialized at ${memoryBankDir} (with warnings about .clinerules files)`, }, ], }; } catch (dirError) { console.error('Failed to create memory-bank directory:', dirError); // Try to use an existing memory-bank directory if it exists if (await FileUtils.fileExists(memoryBankDir) && await FileUtils.isDirectory(memoryBankDir)) { memoryBankManager.setMemoryBankDir(memoryBankDir); return { content: [ { type: 'text', text: `Memory Bank initialized at ${memoryBankDir} (with warnings)`, }, ], }; } // If we can't create or find a memory-bank directory, return an error return { content: [ { type: 'text', text: `Failed to initialize Memory Bank: ${dirError}`, }, ], }; } } // For other errors, return the error message return { content: [ { type: 'text', text: `Failed to initialize Memory Bank: ${initError}`, }, ], }; } } catch (error) { return { content: [ { type: 'text', text: `Error initializing Memory Bank: ${error}`, }, ], }; } }
• src/server/tools/CoreTools.ts:11-24 (schema)

  The tool schema definition including name, description, and input schema for 'path' parameter.
  { name: 'initialize_memory_bank', description: 'Initialize a Memory Bank in the specified directory', inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'Path where the Memory Bank will be initialized', }, }, required: ['path'], }, },
• src/server/tools/index.ts:70-77 (registration)

  Registration of the tool handler in the MCP server's CallToolRequestSchema switch statement, dispatching to handleInitializeMemoryBank.
  case 'initialize_memory_bank': { const { path: dirPath } = request.params.arguments as { path: string }; if (!dirPath) { throw new McpError(ErrorCode.InvalidParams, 'Path not specified'); } console.error('Initializing Memory Bank at path:', dirPath); return handleInitializeMemoryBank(memoryBankManager, dirPath); }
• src/server/tools/index.ts:30-38 (registration)

  Includes the coreTools (containing initialize_memory_bank schema) in the list of available tools for ListToolsRequest.
  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [ ...coreTools, ...progressTools, ...contextTools, ...decisionTools, ...modeTools, ], }));
• src/core/MemoryBankManager.ts:319-410 (helper)

  Core helper method in MemoryBankManager called by the handler to perform the actual Memory Bank initialization (create directory if needed, populate core template files).
  async initialize(createIfNotExists: boolean = true): Promise<string> { try { // Determine the Memory Bank path let memoryBankPath: string; if (this.isRemote) { // For remote: use folderName directly under remote path (don't need to append to remotePath) memoryBankPath = this.folderName; logger.debug('MemoryBankManager', `Initializing remote Memory Bank with path: ${memoryBankPath}`); } else if (this.customPath) { // Use the custom path if set (for local filesystem) memoryBankPath = path.join(this.customPath, this.folderName); } else if (this.projectPath) { // Use the project path if set (for local filesystem) memoryBankPath = path.join(this.projectPath, this.folderName); } else { // Use the current directory as a fallback (for local filesystem) const currentDir = process?.cwd() || '.'; memoryBankPath = path.join(currentDir, this.folderName); } // Create the Memory Bank directory if it doesn't exist if (createIfNotExists) { if (!this.fileSystem) { if (this.isRemote && this.remoteConfig) { // Create remote file system this.fileSystem = FileSystemFactory.createRemoteFileSystem( this.remoteConfig.remotePath, this.remoteConfig.sshKeyPath, this.remoteConfig.remoteUser, this.remoteConfig.remoteHost ); } else if (this.projectPath) { // Create local file system this.fileSystem = FileSystemFactory.createLocalFileSystem(this.projectPath); } else { throw new Error('File system cannot be initialized'); } } // Create the Memory Bank directory if it doesn't exist const exists = await this.fileSystem.fileExists(memoryBankPath); const isDir = exists ? await this.fileSystem.isDirectory(memoryBankPath) : false; if (!exists || !isDir) { logger.info('MemoryBankManager', `Creating Memory Bank directory at ${memoryBankPath}`); await this.fileSystem.ensureDirectory(memoryBankPath); } // Create core template files if they don't exist for (const template of coreTemplates) { const filePath = this.isRemote ? `${memoryBankPath}/${template.name}` : path.join(memoryBankPath, template.name); const fileExists = await this.fileSystem.fileExists(filePath); if (!fileExists) { logger.info('MemoryBankManager', `Creating ${template.name}`); await this.fileSystem.writeFile(filePath, template.content); } } } else { // Check if the Memory Bank directory exists if (!this.fileSystem) { throw new Error('File system not initialized'); } const exists = await this.fileSystem.fileExists(memoryBankPath); const isDir = exists ? await this.fileSystem.isDirectory(memoryBankPath) : false; if (!exists || !isDir) { throw new Error(`Memory Bank directory not found at ${memoryBankPath}`); } } // Set the memory bank directory this.setMemoryBankDir(memoryBankPath); // Initialize the progress tracker - ensure memoryBankPath is not null if (memoryBankPath) { this.progressTracker = new ProgressTracker(memoryBankPath, this.userId || undefined); } // Welcome message logger.info('MemoryBankManager', `Memory Bank initialized at ${memoryBankPath}`); return memoryBankPath; } catch (error) { logger.error('MemoryBankManager', `Failed to initialize Memory Bank: ${error}`); throw new Error(`Failed to initialize Memory Bank: ${error instanceof Error ? error.message : String(error)}`); } }
• src/core/MemoryBankManager.ts:560-571 (helper)

  Convenience helper method in MemoryBankManager that matches the tool name, wrapping setCustomPath and initialize.
  async initializeMemoryBank(dirPath: string): Promise<string> { try { // Set the custom path await this.setCustomPath(dirPath); // Initialize the Memory Bank return await this.initialize(true); } catch (error) { logger.error('MemoryBankManager', `Failed to initialize Memory Bank: ${error}`); throw new Error(`Failed to initialize Memory Bank: ${error instanceof Error ? error.message : String(error)}`); } }