# ABAC Validation MCP Server

An MCP (Model Context Protocol) server that provides AI-assisted ABAC (Attribute-Based Access Control) code validation and review tools. This server integrates with Claude CLI or GitHub Copilot CLI to perform long-running validation operations with progress notifications.

## Features

- **Business Logic Validation**: Validate code against business requirements using AI
- **AI-Assisted Code Review**: Comprehensive code review covering quality, security, and performance
- **Batch Processing**: Validate multiple files with progress updates
- **Progress Notifications**: Long-running operations report progress to the client
- **CLI Integration**: Calls Claude/Copilot CLI for AI analysis (ready for integration)

## Installation

```bash
npm install
npm run build
```

## Usage

### Running Standalone

```bash
npm run dev
```

### VS Code Configuration

Add to your VS Code `settings.json` (`.vscode/settings.json` or user settings):

```json
{
  "mcp.servers": {
    "abac-validation": {
      "type": "stdio",
      "command": "node",
      "args": [
        "/absolute/path/to/abac-validation-mcp-server/dist/index.js"
      ]
    }
  }
}
```

Or use npx for easier distribution:

```json
{
  "mcp.servers": {
    "abac-validation": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "abac-validation-mcp-server"
      ]
    }
  }
}
```

### Claude Desktop Configuration

Add to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "abac-validation": {
      "command": "node",
      "args": [
        "/absolute/path/to/abac-validation-mcp-server/dist/index.js"
      ]
    }
  }
}
```

## Available Tools

### 1. validate_business_logic

Validate code against business requirements using AI.

**Parameters:**
- `code` (string, required): The code to validate
- `requirements` (string, required): Business requirements to validate against

**Example:**
```javascript
{
  "code": "function calculateDiscount(price, customerType) { ... }",
  "requirements": "Premium customers get 20% discount, regular customers get 10%"
}
```

### 2. ai_code_review

Perform comprehensive AI-assisted code review.

**Parameters:**
- `code` (string, required): The code to review
- `context` (string, optional): Additional context about the code
- `review_type` (string, optional): Type of review - "comprehensive", "security", "performance", or "style"

**Example:**
```javascript
{
  "code": "async function fetchUserData(userId) { ... }",
  "context": "This is part of a user authentication system",
  "review_type": "security"
}
```

### 3. batch_validate

Validate multiple files in batch with progress updates.

**Parameters:**
- `files` (array, required): Array of file objects with `path` and optional `requirements`

**Example:**
```javascript
{
  "files": [
    { "path": "src/auth.ts", "requirements": "Must use OAuth 2.0" },
    { "path": "src/payment.ts", "requirements": "PCI DSS compliant" }
  ]
}
```

## Integration with Claude/Copilot CLI

### Current Status

The server skeleton is ready with placeholder implementations. To integrate with actual CLIs:

### Option 1: Claude CLI

Replace the TODO sections in `src/index.ts` with:

```typescript
// Install: npm install -g @anthropic-ai/claude-cli
const result = await executeWithProgress('claude', [
  'analyze',
  '--prompt', prompt
], (msg) => {
  if (progressToken) {
    // Send progress notification
  }
});
```

### Option 2: GitHub Copilot CLI

```typescript
// Requires GitHub Copilot CLI access
const result = await executeWithProgress('gh', [
  'copilot',
  'explain',
  code
], (msg) => {
  if (progressToken) {
    // Send progress notification
  }
});
```

### Option 3: API Calls

For more control, use the Anthropic API directly:

```bash
npm install @anthropic-ai/sdk
```

```typescript
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY
});

// Use streaming for progress
const stream = await client.messages.create({
  model: 'claude-sonnet-4-5-20250929',
  messages: [{ role: 'user', content: prompt }],
  stream: true,
  max_tokens: 4096
});

for await (const event of stream) {
  // Send progress updates
}
```

## Development

### Build

```bash
npm run build
```

### Watch Mode

```bash
npm run watch
```

### Testing

Test the server with MCP Inspector:

```bash
npx @modelcontextprotocol/inspector node dist/index.js
```

## Next Steps

1. **Integrate CLI**: Choose your preferred AI CLI (Claude/Copilot) and implement in the TODO sections
2. **Add Progress Notifications**: Use MCP progress notification protocol for real-time updates
3. **File System Access**: Add file reading capabilities for batch validation
4. **Configuration**: Add config file for API keys, CLI paths, etc.
5. **Error Handling**: Improve error handling and retry logic
6. **Caching**: Add caching for repeated validations
7. **Custom Validators**: Add domain-specific validation rules

## Architecture

```
User (VS Code/Copilot/Claude)
    ↓
MCP Client
    ↓ (stdio)
Validation MCP Server
    ↓
Claude CLI / Copilot CLI / API
    ↓
AI Model (validation/review)
    ↓
Results with Progress
```

## License

MIT