mcp-adr-analysis-server

Instructions

Implementation Reference

• src/tools/content-masking-tool.ts:886-1088 (handler)

  Main handler function that executes the tool logic. Scans the actual project structure, reads and includes truncated contents from key files (package.json, .env, configs, scripts), generates detailed AI prompts for custom pattern configuration, and returns MCP-formatted response with instructions and prompts for JSON output containing regex patterns, replacements, and recommendations.

  /**
   * Configure custom sensitive patterns for a project
   */
  export async function configureCustomPatterns(args: {
    projectPath: string;
    existingPatterns?: string[];
  }): Promise<any> {
    const { projectPath, existingPatterns } = args;
  
    try {
      // Use actual file operations to scan project structure
      const { scanProjectStructure } = await import('../utils/actual-file-operations.js');
  
      // Actually scan project structure
      const projectStructure = await scanProjectStructure(projectPath, {
        readContent: true,
        maxFileSize: 10000,
      });
  
      const customPatternPrompt = `
  # Custom Pattern Configuration Generation
  
  Based on actual project structure analysis, here are the findings:
  
  ## Project Structure
  - **Root Path**: ${projectStructure.rootPath}
  - **Total Files**: ${projectStructure.totalFiles}
  - **Directories**: ${projectStructure.directories.join(', ')}
  
  ## Package Management Files
  ${
    projectStructure.packageFiles.length > 0
      ? projectStructure.packageFiles
          .map(
            f => `
  ### ${f.filename}
  \`\`\`
  ${f.content.slice(0, 500)}${f.content.length > 500 ? '\n... (truncated)' : ''}
  \`\`\`
  `
          )
          .join('\n')
      : '- No package files found'
  }
  
  ## Environment Configuration Files
  ${
    projectStructure.environmentFiles.length > 0
      ? projectStructure.environmentFiles
          .map(
            f => `
  ### ${f.filename}
  \`\`\`
  ${f.content.slice(0, 300)}${f.content.length > 300 ? '\n... (truncated)' : ''}
  \`\`\`
  `
          )
          .join('\n')
      : '- No environment files found'
  }
  
  ## Configuration Files
  ${
    projectStructure.configFiles.length > 0
      ? projectStructure.configFiles
          .map(
            f => `
  ### ${f.filename}
  \`\`\`
  ${f.content.slice(0, 300)}${f.content.length > 300 ? '\n... (truncated)' : ''}
  \`\`\`
  `
          )
          .join('\n')
      : '- No config files found'
  }
  
  ## Script Files
  ${
    projectStructure.scriptFiles.length > 0
      ? projectStructure.scriptFiles
          .map(
            f => `
  ### ${f.filename}
  \`\`\`
  ${f.content.slice(0, 400)}${f.content.length > 400 ? '\n... (truncated)' : ''}
  \`\`\`
  `
          )
          .join('\n')
      : '- No script files found'
  }
  
  ## Existing Patterns Context
  
  ${
    existingPatterns
      ? `
  ### Current Patterns (${existingPatterns.length})
  ${existingPatterns
    .map(
      (pattern, index) => `
  #### ${index + 1}. ${pattern}
  `
    )
    .join('')}
  `
      : 'No existing patterns provided.'
  }
  
  ## Pattern Generation Requirements
  
  1. **Analyze project-specific content types** that need masking based on actual file content
  2. **Identify sensitive data patterns** in code and documentation shown above
  3. **Generate regex patterns** for consistent content masking
  4. **Create appropriate replacements** that maintain context
  5. **Ensure patterns don't conflict** with existing ones
  6. **Provide clear descriptions** for each pattern
  
  ## Required Output Format
  
  Please provide custom pattern configuration in JSON format:
  \`\`\`json
  {
    "patterns": [
      {
        "name": "pattern-name",
        "pattern": "regex-pattern",
        "replacement": "replacement-text",
        "description": "pattern-description",
        "category": "pattern-category"
      }
    ],
    "recommendations": ["list", "of", "recommendations"],
    "conflicts": ["any", "potential", "conflicts"]
  }
  \`\`\`
  `;
  
      const instructions = `
  # Custom Pattern Configuration Instructions
  
  This analysis provides **actual project file contents** for comprehensive pattern generation.
  
  ## Analysis Scope
  - **Project Path**: ${projectPath}
  - **Package Files**: ${projectStructure.packageFiles.length} found
  - **Environment Files**: ${projectStructure.environmentFiles.length} found
  - **Config Files**: ${projectStructure.configFiles.length} found
  - **Script Files**: ${projectStructure.scriptFiles.length} found
  - **Total Files Analyzed**: ${projectStructure.totalFiles}
  - **Existing Patterns**: ${existingPatterns?.length || 0} patterns
  
  ## Next Steps
  1. **Submit the configuration prompt** to an AI agent for pattern analysis
  2. **Parse the JSON response** to get custom patterns and recommendations
  3. **Review generated patterns** for accuracy and completeness
  4. **Implement patterns** in the content masking system
  
  ## Expected AI Response Format
  The AI will return a JSON object with:
  - \`patterns\`: Array of custom pattern configurations
  - \`recommendations\`: Best practices and implementation guidance
  - \`conflicts\`: Potential conflicts with existing patterns
  
  ## Usage Example
  \`\`\`typescript
  const result = await configureCustomPatterns({ projectPath, existingPatterns });
  // Submit result.configurationPrompt to AI agent
  // Parse AI response for custom pattern configuration
  \`\`\`
  `;
  
      const result = {
        configurationPrompt: customPatternPrompt,
        instructions,
        actualData: {
          projectStructure,
          summary: {
            totalFiles: projectStructure.totalFiles,
            packageFiles: projectStructure.packageFiles.length,
            environmentFiles: projectStructure.environmentFiles.length,
            configFiles: projectStructure.configFiles.length,
            scriptFiles: projectStructure.scriptFiles.length,
          },
        },
      };
  
      return {
        content: [
          {
            type: 'text',
            text: `# Custom Pattern Configuration\n\n${result.instructions}\n\n## AI Configuration Prompt\n\n${result.configurationPrompt}`,
          },
        ],
      };
    } catch (error) {
      throw new McpAdrError(
        `Failed to configure custom patterns: ${error instanceof Error ? error.message : String(error)}`,
        'CONFIGURATION_ERROR'
      );
    }
  }

• src/types/tool-arguments.ts:240-243 (schema)

  TypeScript interface defining the input arguments for the configure_custom_patterns tool: required projectPath and optional existingPatterns array.

  export interface ConfigureCustomPatternsArgs {
    projectPath: string;
    existingPatterns?: string[];
  }

• src/utils/server-context-generator.ts:222-223 (registration)

  Tool listed in the server context generator's hardcoded tool catalog under Content Security category, used for documentation and LLM awareness of available tools.

  name: 'configure_custom_patterns',
  description: 'Configure custom security patterns for content analysis',