# Config MCP Server

An MCP (Model Context Protocol) server providing developer documentation search, configuration helpers, and settings search tools for AI assistants and development workflows.

## Features

### 🔍 Documentation Search
- **searchDocs**: Search markdown, MDX, and text files in your workspace
- Supports custom glob patterns for targeted searches
- Perfect for finding documentation, README files, and guides

### ⚙️ Configuration Management
- **getConfig**: Read configuration files (JSON/JSONC/YAML/TOML)
- **setConfig**: Update configuration files safely with dot-notation key paths
- **listConfigs**: Discover all configuration files in your workspace

### 🎛️ Settings Search
- **searchSettings**: Search through JSON/JSONC settings files
- Ideal for VS Code settings, application configs, and more
- Customizable file patterns for different types of settings

## Requirements

- Node.js 18.17+ (20+ recommended)
- MCP-compatible client (Claude Desktop, Continue.dev, etc.)

## Installation & Setup

### 1. Install Dependencies
```bash
npm install
```

### 2. Build the Server
```bash
npm run build
```

### 3. Install VS Code MCP Extension (Recommended)

For the best experience with GitHub Copilot, install the MCP extension for VS Code:

1. Open VS Code
2. Go to Extensions (Ctrl/Cmd + Shift + X)
3. Search for "Model Context Protocol" or "MCP"
4. Install the official MCP extension
5. Reload VS Code

### 4. Configure Your MCP Client

Add to your MCP client configuration:

**VS Code with GitHub Copilot** (`.vscode/settings.json`):
```json
{
  "mcp.servers": {
    "config-mcp-server": {
      "command": "node",
      "args": ["${workspaceFolder}/path/to/Config-MCP-Server/dist/index.js"],
      "cwd": "${workspaceFolder}",
      "env": {
        "NODE_ENV": "production"
      }
    }
  },
  "github.copilot.advanced": {
    "mcp.enabled": true,
    "mcp.servers": ["config-mcp-server"]
  }
}
```

**VS Code User Settings** (`settings.json`):
```json
{
  "mcp.global.servers": {
    "config-mcp-server": {
      "command": "node",
      "args": ["path/to/Config-MCP-Server/dist/index.js"],
      "autoStart": true,
      "workspaceRelative": true
    }
  }
}
```

**Claude Desktop** (`claude_desktop_config.json`):
```json
{
  "mcpServers": {
    "config-mcp-server": {
      "command": "node",
      "args": ["path/to/Config-MCP-Server/dist/index.js"],
      "cwd": "path/to/your/workspace"
    }
  }
}
```

**Continue.dev** (`.continue/config.json`):
```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "node",
          "args": ["path/to/Config-MCP-Server/dist/index.js"]
        }
      }
    ]
  }
}
```

## Development Scripts

- `npm run dev` — Start in watch mode (supports .ts imports)
- `npm run build` — Compile TypeScript to `dist/`
- `npm start` — Run compiled server
- `npm run lint` — Check code style
- `npm run format` — Format code with Prettier

## Tool Reference

### searchDocs
Search developer documentation and markdown files.
```typescript
// Parameters:
{
  query: string,           // Search term or phrase
  include?: string[]       // Custom glob patterns (optional)
}

// Example usage by AI:
// "Search for authentication setup instructions"
// Uses: searchDocs({ query: "authentication setup" })
```

### searchSettings
Search configuration and settings files for specific keys or values.
```typescript
// Parameters:
{
  query: string,           // Search term
  include?: string[]       // Custom patterns (optional)
}

// Example usage by AI:
// "Find VS Code Python interpreter settings"
// Uses: searchSettings({ query: "python.defaultInterpreterPath" })
```

### getConfig
Read and parse configuration files with optional key extraction.
```typescript
// Parameters:
{
  file: string,           // Path to config file
  key?: string           // Dot-separated key path (optional)
}

// Example usage by AI:
// "Get the database host from config.json"
// Uses: getConfig({ file: "config.json", key: "database.host" })
```

### setConfig
Update configuration files safely with automatic format detection.
```typescript
// Parameters:
{
  file: string,           // Path to config file
  key: string,           // Dot-separated key path
  value: string          // JSON-encoded value
}

// Example usage by AI:
// "Set the API timeout to 30000 in config.json"
// Uses: setConfig({ file: "config.json", key: "api.timeout", value: "30000" })
```

### listConfigs
Discover configuration files in the workspace.
```typescript
// Parameters:
{
  include?: string[]      // Glob patterns (default: common config files)
}

// Example usage by AI:
// "Show me all configuration files"
// Uses: listConfigs({})
```

## Supported File Formats

- **JSON** (`.json`) - Standard JSON files
- **JSONC** (`.jsonc`) - JSON with comments (VS Code style)
- **YAML** (`.yaml`, `.yml`) - YAML configuration files
- **TOML** (`.toml`) - TOML configuration files
- **Markdown** (`.md`, `.mdx`) - Documentation files
- **Text** (`.txt`) - Plain text files

## Error Handling

All tools include comprehensive error handling and return user-friendly error messages when:
- Files are not found or unreadable
- Invalid JSON/YAML/TOML syntax
- Permission issues
- Invalid key paths or values

## TypeScript Support

The server is built with TypeScript and supports:
- Import resolution with `.ts` extensions in development
- Path aliases (`@/lib/...`) for cleaner imports  
- Strict type checking for reliability
- Source maps for debugging

## GitHub Copilot Integration

### Enhanced Copilot Experience

With this MCP server, GitHub Copilot gains powerful workspace awareness:

- **Context-Aware Suggestions**: Copilot can reference your project's documentation and configuration
- **Smart Configuration**: Automatically suggests configuration changes based on your project setup
- **Workspace Understanding**: Better code completions using your project's README and docs

### VS Code Features

- **Workspace Integration**: Automatically detects when you're working in a configured workspace
- **Command Palette**: Access MCP tools via VS Code Command Palette (`Ctrl/Cmd + Shift + P`)
- **Status Bar**: Shows MCP server connection status
- **Output Panel**: View MCP server logs in VS Code Output panel

## Usage Examples

### In VS Code with GitHub Copilot

**Chat with Copilot**:
- *"@workspace Search for authentication setup in our docs"*
- *"Help me find where the API configuration is defined"*
- *"What's the current database timeout setting?"*
- *"Update the dev server port to 3001"*

### Command Palette Integration

1. Press `Ctrl/Cmd + Shift + P`
2. Type "MCP: Config" to see available commands:
   - `MCP: Search Documentation`
   - `MCP: Find Settings`
   - `MCP: Read Configuration`
   - `MCP: Update Configuration`
   - `MCP: List Config Files`

### Traditional Examples

### Finding Documentation
Ask your AI: *"Search for Docker setup instructions"*
→ Uses `searchDocs` to find relevant documentation

### Managing Configuration  
Ask your AI: *"Update the database port to 5433 in my config file"*
→ Uses `getConfig` to read current config, then `setConfig` to update it

### Exploring Settings
Ask your AI: *"Show me all my VS Code Python settings"*
→ Uses `searchSettings` to find Python-related configuration

## VS Code & Copilot Troubleshooting

### Common Issues

**MCP Server Not Starting**:
1. Check VS Code Output panel (`View > Output > Model Context Protocol`)
2. Verify Node.js is installed and accessible in PATH
3. Ensure the server path in settings.json is correct
4. Try reloading VS Code (`Ctrl/Cmd + Shift + P > Developer: Reload Window`)

**Copilot Not Using MCP Context**:
1. Verify GitHub Copilot extension is installed and active
2. Check that `github.copilot.advanced.mcp.enabled` is set to `true`
3. Restart VS Code after configuration changes
4. Use `@workspace` prefix in Copilot chat for explicit context

**Performance Optimization**:
1. Adjust `maxResults` in settings if searches are slow
2. Use more specific glob patterns in `include` parameters
3. Add common build directories to search exclusions

### VS Code Tips

- **Quick Access**: Use `Ctrl/Cmd + Shift + P` then type "MCP" to see all available commands
- **Status Monitoring**: Check the status bar for MCP connection indicators  
- **Workspace Templates**: Copy `.vscode/settings.json.template` to your project's `.vscode/settings.json`
- **Global vs Workspace**: Use User settings for global MCP config, Workspace settings for project-specific setup

### GitHub Copilot Best Practices

- Start questions with `@workspace` to engage MCP context
- Be specific about file types: "search TypeScript configs" vs "search configs"
- Use natural language: "What's my current database setup?" instead of technical queries
- Leverage context: Copilot will automatically use your project's documentation in suggestions

## Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run `npm run lint` and `npm run format`
5. Test with VS Code MCP integration
6. Submit a pull request

## License

MIT - See LICENSE file for details