tideways-mcp-server 0.1.0

package/README.md

@@ -0,0 +1,447 @@
+# Tideways MCP Server
+
+A Model Context Protocol (MCP) server that enables AI assistants to query Tideways performance monitoring data and provide conversational performance insights for PHP applications.
+
+## 🚀 Features
+
+- **Conversational Performance Insights**: Get performance data in natural language format optimized for AI assistants
+- **AI Assistant Integration**: Works with Claude Desktop, Cursor, Claude Code, and other MCP-compatible tools
+- **Real-time Performance Metrics**: Query current performance data with intelligent caching
+- **Issue Analysis**: Retrieve and analyze errors, exceptions, and performance issues
+- **Rate Limiting & Caching**: Intelligent API management with respect for Tideways rate limits
+- **Robust Error Handling**: Comprehensive error handling with user-friendly messages
+
+## 📋 Prerequisites
+
+- Node.js 18.0 or higher
+- Valid Tideways API token with appropriate scopes (`metrics`, `issues`, `traces`)
+- Access to a Tideways organization and project
+
+## 🛠️ Installation
+
+### Option 1: Clone and Install
+
+```bash
+git clone https://github.com/abuhamza/mcp-tideways.git
+cd mcp-tideways
+npm install
+npm run build
+```
+
+### Option 2: Install from npm (coming soon)
+
+```bash
+npm install -g tideways-mcp-server
+```
+
+## ⚙️ Configuration
+
+Create a `.env` file in the project root:
+
+```env
+# Required Configuration
+TIDEWAYS_TOKEN=your_tideways_api_token
+TIDEWAYS_ORG=your_organization_name
+TIDEWAYS_PROJECT=your_project_name
+
+# Optional Configuration
+TIDEWAYS_BASE_URL=https://app.tideways.io/apps/api
+TIDEWAYS_MAX_RETRIES=3
+TIDEWAYS_REQUEST_TIMEOUT=30000
+SERVER_PORT=3000
+LOG_LEVEL=info
+```
+
+### Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `TIDEWAYS_TOKEN` | ✅ | - | Tideways API access token (see Security section) |
+| `TIDEWAYS_ORG` | ✅ | - | Tideways organization name |
+| `TIDEWAYS_PROJECT` | ✅ | - | Tideways project name |
+| `TIDEWAYS_BASE_URL` | ❌ | `https://app.tideways.io/apps/api` | Tideways API base URL |
+| `TIDEWAYS_MAX_RETRIES` | ❌ | `3` | Maximum API retry attempts |
+| `TIDEWAYS_REQUEST_TIMEOUT` | ❌ | `30000` | API request timeout (ms) |
+| `SERVER_PORT` | ❌ | `3000` | Server port |
+| `LOG_LEVEL` | ❌ | `info` | Log level (debug, info, warn, error) |
+
+## 🚀 Usage
+
+### Running the Server
+
+```bash
+# Development mode
+npm run dev
+
+# Production mode
+npm run start
+
+# Or run built version directly
+node dist/index.js
+```
+
+### Claude Desktop Integration
+
+Add to your Claude Desktop MCP configuration (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "tideways": {
+      "command": "node",
+      "args": ["/path/to/tideways-mcp-server/dist/index.js"],
+      "env": {
+        "TIDEWAYS_TOKEN": "your_token",
+        "TIDEWAYS_ORG": "your_org",
+        "TIDEWAYS_PROJECT": "your_project"
+      }
+    }
+  }
+}
+```
+
+### Using with AI Assistants
+
+Once configured, you can ask your AI assistant questions like:
+
+#### Basic Performance Queries
+- "What's the current performance of my application?"
+- "Show me recent errors in the last 24 hours"
+- "How is my API performing compared to yesterday?"
+- "What are the slowest transactions right now?"
+
+#### Advanced Trace Analysis & Optimization
+- "Analyze the `/api/users/{id}` endpoint and identify bottlenecks"
+- "Find the root cause of slow performance in my checkout process"
+- "Detect N+1 queries in my product listing endpoint and suggest fixes"
+- "Analyze traces for `/dashboard` and recommend code optimizations"
+- "Identify database query bottlenecks in my user authentication flow"
+- "Find memory leaks or inefficient code paths in my API endpoints"
+- "Analyze dependency injection overhead in my application"
+- "Detect redundant database calls and suggest caching strategies"
+
+#### Performance Optimization Suggestions
+- "Recommend performance improvements for my slowest endpoints"
+- "Analyze my SQL queries and suggest indexing strategies"
+- "Identify opportunities for query batching or lazy loading"
+- "Find inefficient loops or recursive calls in my traces"
+- "Suggest code refactoring based on performance bottlenecks"
+- "Analyze memory usage patterns and recommend optimizations"
+
+## 🛠️ Available MCP Tools
+
+All tools return structured JSON data for optimal AI assistant integration. The MCP server follows a "raw JSON approach" where tools return complete API responses without formatting, allowing AI assistants to analyze and present data flexibly.
+
+### `get_performance_metrics`
+
+Retrieve aggregate performance metrics and system-wide statistics.
+
+**Parameters:**
+- `ts` (optional): End timestamp in Y-m-d H:i format (e.g., "2025-08-12 18:30")
+- `m` (optional): Number of minutes backward from timestamp (e.g., 60 for 1 hour, 1440 for 24 hours)
+- `env` (optional): Filter by specific environment
+- `s` (optional): Filter by specific service name
+
+**Example Usage:**
+```
+Claude, get my performance metrics for the last 6 hours
+Claude, show me metrics for the API service in production
+```
+
+### `get_performance_summary`
+
+Retrieve time-series performance summary data in 15-minute intervals for trend analysis.
+
+**Parameters:**
+- `s` (optional): Service name to filter by (e.g., "web", "api", "worker"). Default: "web"
+
+**Example Usage:**
+```
+Claude, show me the performance summary trends
+Claude, get performance summary for the API service
+```
+
+### `get_issues`
+
+Retrieve and analyze recent errors, exceptions, and performance issues.
+
+**Parameters:**
+- `issue_type` (optional): "error", "slowsql", "deprecated", "all" (default: "all")
+- `status` (optional): "open", "new", "resolved", "not_error", "ignored", "all" (default: "open")
+- `page` (optional): Page number for pagination (default: 1)
+
+**Example Usage:**
+```
+Claude, show me all open errors
+Claude, get slow SQL queries from today
+```
+
+### `get_traces`
+
+Analyze individual trace samples for detailed bottleneck identification and performance debugging.
+
+**Parameters:**
+- `env` (optional): Environment name (e.g., "production", "staging")
+- `s` (optional): Service name (e.g., "web", "api", "worker")
+- `transaction_name` (optional): Filter by specific transaction/endpoint name
+- `has_callgraph` (optional): Only return traces with detailed callgraph data
+- `search` (optional): Word-based search on transaction_name, host, and URL
+- `min_date` (optional): Minimal date in YYYY-MM-DD HH:MM format (requires max_date)
+- `max_date` (optional): Maximal date in YYYY-MM-DD HH:MM format (requires min_date)
+- `min_response_time_ms` (optional): Minimum response time filter
+- `max_response_time_ms` (optional): Maximum response time filter
+- `sort_by` (optional): "response_time", "date", "memory" (default: "response_time")
+- `sort_order` (optional): "ASC", "DESC" (default: "DESC")
+
+**Example Usage:**
+```
+Claude, analyze traces for /api/products and find slow requests
+Claude, get traces with response time over 1000ms from the last hour
+Claude, find traces with callgraph data for the checkout endpoint
+```
+
+### `get_historical_data`
+
+Retrieve historical performance data for specific dates with configurable granularity.
+
+**Parameters:**
+- `date` (required): Date in YYYY-MM-DD format
+- `granularity` (optional): "day", "week", "month" (default: "day")
+
+**Example Usage:**
+```
+Claude, get historical data for 2025-08-01
+Claude, show me weekly performance data for last Monday
+```
+
+## 🧪 Development
+
+### Project Structure
+
+```
+├── src/
+│   ├── config/           # Configuration management
+│   ├── lib/              # Core libraries
+│   │   ├── errors.ts     # Error handling utilities  
+│   │   ├── logger.ts     # Structured logging
+│   │   └── tideways-client.ts  # Tideways API client
+│   ├── tools/            # MCP tool implementations
+│   │   ├── definitions.ts # Tool schema definitions
+│   │   ├── registry.ts   # Tool execution registry
+│   │   └── handlers/     # Individual tool handlers
+│   ├── types/            # TypeScript type definitions
+│   ├── utils/            # Utility functions
+│   ├── server.ts         # Main MCP server implementation
+│   └── index.ts          # Application entry point
+├── tests/                # Test suites
+└── dist/                 # Compiled JavaScript (generated)
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+npm test
+
+# Run tests with coverage
+npm run test:coverage
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run type checking
+npm run typecheck
+```
+
+### Building
+
+```bash
+# Build TypeScript to JavaScript
+npm run build
+
+# Clean build artifacts
+npm run clean
+```
+
+### Code Quality
+
+```bash
+# Run linter
+npm run lint
+
+# Fix linting issues
+npm run lint:fix
+
+# Format code
+npm run format
+```
+
+## 🏗️ Architecture
+
+### Core Components
+
+1. **MCP Server** (`src/server.ts`): Main server implementing MCP protocol, handles tool definitions and routing
+2. **Tideways API Client** (`src/lib/tideways-client.ts`): HTTP client with rate limiting, retry logic, and security measures
+3. **Tool Registry** (`src/tools/`): Modular tool system with individual handlers for each MCP tool
+4. **Error Handler** (`src/lib/errors.ts`): Centralized error handling with user-friendly messages
+5. **Logger** (`src/lib/logger.ts`): Structured JSON logging for monitoring and debugging
+6. **Configuration** (`src/config/index.ts`): Environment-based configuration management
+
+### Data Flow
+
+```
+AI Assistant → MCP Protocol → TidewaysMCPServer → TidewaysClient → Tideways API
+                                     ↓
+                              Raw JSON Response → AI Assistant
+```
+
+### Response Format Philosophy
+
+This server uses a **simplified raw JSON approach** for optimal performance:
+- **Direct API-to-LLM Pipeline**: Tools return `JSON.stringify(apiData, null, 2)` without formatting
+- **Zero Processing Overhead**: No complex formatting, caching, or interpretation logic  
+- **Complete Data Preservation**: LLM receives all available data for flexible analysis
+- **Modern LLM Optimized**: GPT-4/Claude excel at parsing structured JSON data
+- **Minimal Maintenance**: No formatter or caching logic to maintain or debug
+
+### Rate Limiting Strategy
+
+- **Rate Limiter**: Built-in rate limiting respects Tideways API constraints (900 requests/hour by default)
+- **Direct API Calls**: All requests go directly to Tideways API without caching layer
+- **Retry Logic**: Automatic retries for transient failures with exponential backoff
+- **YAGNI Principle**: No caching complexity until performance issues are observed
+
+## 🛡️ Security
+
+- API tokens stored securely in environment variables
+- Rate limiting to respect Tideways API constraints
+- Input validation on all MCP function parameters
+- No sensitive data logged or exposed in error messages
+
+## 📊 Monitoring
+
+The server provides structured JSON logs for monitoring:
+
+```json
+{
+  "timestamp": "2025-08-09T10:00:00.000Z",
+  "level": "info",
+  "message": "Tool called",
+  "context": {
+    "toolName": "get_performance_metrics",
+    "arguments": {"time_range": "24h"}
+  }
+}
+```
+
+## 🔧 Troubleshooting
+
+### Common Issues
+
+**Authentication Error**
+```
+Error: Authentication failed. Please check your API token.
+```
+- Verify `TIDEWAYS_TOKEN` is correct and has required scopes
+- Check token hasn't expired
+- Ensure organization and project names are correct
+
+**Rate Limit Exceeded**
+```
+Error: Rate limit exceeded. Please try again later.
+```
+- Wait for rate limit reset (shown in error message)
+- Reduce query frequency
+- Enable caching to minimize API calls
+
+**Connection Issues**
+```
+Error: Network error: Unable to connect to Tideways API.
+```
+- Check internet connection
+- Verify Tideways API is accessible
+- Check if corporate firewall blocks API access
+
+### Debug Mode
+
+Enable debug logging for detailed troubleshooting:
+
+```bash
+LOG_LEVEL=debug npm run dev
+```
+
+## 🚧 Roadmap
+
+### Phase 2 (Planned)
+- **MCP Prompts**: Pre-defined analysis templates and guided workflows for systematic performance investigation
+- **Streamable Responses**: Real-time streaming of large datasets for better user experience
+- **Advanced Trace Analysis**: Enhanced bottleneck detection with AI-powered recommendations
+- **Multi-project Support**: Manage performance across multiple applications
+- **Integration with Other APM Providers**: Support for New Relic, DataDog, Elastic APM
+
+### Phase 3 (Future)
+- **Real-time Performance Monitoring**: Live performance alerts and recommendations
+- **Custom Dashboard Generation**: AI-generated performance dashboards
+- **Performance Regression Detection**: Automatic detection of performance degradations in deployments
+- **Load Testing Integration**: Performance analysis under different load scenarios
+- **Security Performance Analysis**: Identification of security-related performance bottlenecks
+
+## 🔒 Security
+
+This MCP server implements several security measures to protect your Tideways API credentials:
+
+### Token Security
+- **Validation**: API tokens are validated to ensure they are set (any format accepted)
+- **Logging Protection**: Authorization headers are automatically redacted in debug logs as `Bearer [REDACTED]`
+- **Secure Storage**: Tokens should be stored in environment variables, never in code
+
+### Best Practices
+- Store your API token securely in environment variables or `.env` files
+- Never commit API tokens to version control
+- Use unique, strong tokens with minimal required permissions
+- Regularly rotate your API tokens
+- Monitor access logs for suspicious activity
+
+### Reporting Security Issues
+If you discover a security vulnerability, please report it responsibly through GitHub's security advisory feature.
+
+## 🤝 Contributing
+
+We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+### Development Setup
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/your-feature`
+3. Make changes and add tests
+4. Run tests: `npm test`
+5. Submit a pull request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🆘 Support
+
+- GitHub Issues: [Report bugs or request features](https://github.com/abuhamza/mcp-tideways/issues)
+- Documentation: [Project Wiki](https://github.com/abuhamza/mcp-tideways/wiki)
+
+## 📈 Performance
+
+- Average response time: <2 seconds for cached queries
+- Memory usage: <100MB with default cache settings
+- Supports concurrent AI assistant connections
+- Efficient rate limiting prevents API quota exhaustion
+
+## 🏷️ Version History
+
+- **v0.1.0** - Initial release with core MCP functionality
+- Foundation setup with performance metrics and issues analysis
+- Comprehensive error handling and caching
+
+---
+
+Add example for :
+DANGEROUSLY_OMIT_AUTH=true npx @modelcontextprotocol/inspector -e TIDEWAYS_TOKEN= -e TIDEWAYS_ORG=check24_hotel -e TIDEWAYS_PROJECT=api -e LOG_LEVEL=debug node /home/mouhammed/Work/tideways-mcp/dist/index.js
+
+Built with ❤️ for the PHP development community

package/bin/cli.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// Import compiled modules
+import { TidewaysMCPServer } from '../dist/server.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(
+  readFileSync(join(__dirname, '..', 'package.json'), 'utf8')
+);
+
+function showHelp() {
+  console.log(`
+${packageJson.name} v${packageJson.version}
+
+${packageJson.description}
+
+Usage:
+  npx ${packageJson.name} [options]
+
+Options:
+  --help, -h       Show this help message
+  --version, -v    Show version information
+  --stdio          Use stdio transport (default for MCP)
+  --http           Use HTTP transport (experimental)
+  --port <port>    HTTP port (default: 3000, requires --http)
+
+Environment Variables (required):
+  TIDEWAYS_TOKEN     Your Tideways API token
+  TIDEWAYS_ORG       Your Tideways organization name
+  TIDEWAYS_PROJECT   Your Tideways project name
+
+Examples:
+  # Start MCP server with stdio transport (default)
+  npx ${packageJson.name}
+  
+  # Start with HTTP transport on custom port
+  npx ${packageJson.name} --http --port 3001
+  
+  # Show version
+  npx ${packageJson.name} --version
+
+For more information, visit: ${packageJson.homepage}
+`);
+}
+
+function showVersion() {
+  console.log(`${packageJson.name} v${packageJson.version}`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  
+  // Parse command line arguments
+  let useHttp = false;
+  let port = 3000;
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    switch (arg) {
+      case '--help':
+      case '-h':
+        showHelp();
+        process.exit(0);
+        break;
+        
+      case '--version':
+      case '-v':
+        showVersion();
+        process.exit(0);
+        break;
+        
+      case '--stdio':
+        useHttp = false;
+        break;
+        
+      case '--http':
+        useHttp = true;
+        break;
+        
+      case '--port':
+        if (i + 1 >= args.length) {
+          console.error('Error: --port requires a value');
+          process.exit(1);
+        }
+        port = parseInt(args[++i], 10);
+        if (isNaN(port) || port < 1 || port > 65535) {
+          console.error('Error: Invalid port number');
+          process.exit(1);
+        }
+        break;
+        
+      default:
+        console.error(`Error: Unknown option '${arg}'`);
+        console.error('Use --help for usage information');
+        process.exit(1);
+    }
+  }
+  
+  // Validate required environment variables
+  const requiredEnvVars = ['TIDEWAYS_TOKEN', 'TIDEWAYS_ORG', 'TIDEWAYS_PROJECT'];
+  const missingVars = requiredEnvVars.filter(varName => !process.env[varName]);
+  
+  if (missingVars.length > 0) {
+    console.error('Error: Missing required environment variables:');
+    missingVars.forEach(varName => {
+      console.error(`  ${varName}`);
+    });
+    console.error('\nPlease set these environment variables and try again.');
+    console.error('Use --help for more information.');
+    process.exit(1);
+  }
+  
+  try {
+    // Create and start the MCP server
+    const server = new TidewaysMCPServer();
+    
+    if (useHttp) {
+      console.log(`Starting Tideways MCP Server on HTTP port ${port}...`);
+      console.log('Note: HTTP transport is experimental');
+      // HTTP transport would be implemented here when available
+      console.error('Error: HTTP transport is not yet implemented');
+      console.error('Please use stdio transport (default) for now');
+      process.exit(1);
+    } else {
+      console.log('Starting Tideways MCP Server with stdio transport...');
+      console.log('Server is ready to receive MCP requests');
+      
+      // Start the server with stdio transport
+      await server.start();
+    }
+  } catch (error) {
+    console.error('Error starting server:', error.message);
+    process.exit(1);
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\nShutting down Tideways MCP Server...');
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  console.log('\nShutting down Tideways MCP Server...');
+  process.exit(0);
+});
+
+main().catch(error => {
+  console.error('Fatal error:', error.message);
+  process.exit(1);
+});

package/dist/config/index.d.ts

@@ -0,0 +1,6 @@
+import { TidewaysConfig } from '../types/index.js';
+export interface ServerConfig extends TidewaysConfig {
+    port?: number;
+}
+export declare function loadConfig(): ServerConfig;
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAInD,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AASD,wBAAgB,UAAU,IAAI,YAAY,CAuBzC"}

package/dist/config/index.js

@@ -0,0 +1,55 @@
+import { config } from 'dotenv';
+config();
+const DEFAULT_CONFIG = {
+    baseUrl: 'https://app.tideways.io/apps/api',
+    maxRetries: 3,
+    requestTimeout: 30000,
+    port: 3000,
+};
+export function loadConfig() {
+    const config = {
+        token: process.env.TIDEWAYS_TOKEN || '',
+        organization: process.env.TIDEWAYS_ORG || '',
+        project: process.env.TIDEWAYS_PROJECT || '',
+        ...DEFAULT_CONFIG,
+    };
+    if (process.env.TIDEWAYS_BASE_URL) {
+        config.baseUrl = process.env.TIDEWAYS_BASE_URL;
+    }
+    if (process.env.TIDEWAYS_MAX_RETRIES) {
+        config.maxRetries = parseInt(process.env.TIDEWAYS_MAX_RETRIES, 10);
+    }
+    if (process.env.TIDEWAYS_REQUEST_TIMEOUT) {
+        config.requestTimeout = parseInt(process.env.TIDEWAYS_REQUEST_TIMEOUT, 10);
+    }
+    if (process.env.SERVER_PORT) {
+        config.port = parseInt(process.env.SERVER_PORT, 10);
+    }
+    validateConfig(config);
+    return config;
+}
+function validateConfig(config) {
+    const errors = [];
+    if (!config.token) {
+        errors.push('TIDEWAYS_TOKEN environment variable is required');
+    }
+    if (!config.organization) {
+        errors.push('TIDEWAYS_ORG environment variable is required');
+    }
+    if (!config.project) {
+        errors.push('TIDEWAYS_PROJECT environment variable is required');
+    }
+    if (config.maxRetries && (config.maxRetries < 0 || config.maxRetries > 10)) {
+        errors.push('maxRetries must be between 0 and 10');
+    }
+    if (config.requestTimeout && config.requestTimeout < 1000) {
+        errors.push('requestTimeout must be at least 1000ms');
+    }
+    if (config.port && (config.port < 1 || config.port > 65535)) {
+        errors.push('port must be between 1 and 65535');
+    }
+    if (errors.length > 0) {
+        throw new Error(`Configuration validation failed:\n${errors.join('\n')}`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,MAAM,EAAE,CAAC;AAMT,MAAM,cAAc,GAA0B;IAC5C,OAAO,EAAE,kCAAkC;IAC3C,UAAU,EAAE,CAAC;IACb,cAAc,EAAE,KAAK;IACrB,IAAI,EAAE,IAAI;CACX,CAAC;AAEF,MAAM,UAAU,UAAU;IACxB,MAAM,MAAM,GAAiB;QAC3B,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE;QACvC,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,EAAE;QAC5C,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,EAAE;QAC3C,GAAG,cAAc;KACF,CAAC;IAElB,IAAI,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC;QAClC,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC;IACjD,CAAC;IACD,IAAI,OAAO,CAAC,GAAG,CAAC,oBAAoB,EAAE,CAAC;QACrC,MAAM,CAAC,UAAU,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,EAAE,EAAE,CAAC,CAAC;IACrE,CAAC;IACD,IAAI,OAAO,CAAC,GAAG,CAAC,wBAAwB,EAAE,CAAC;QACzC,MAAM,CAAC,cAAc,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,EAAE,EAAE,CAAC,CAAC;IAC7E,CAAC;IACD,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;QAC5B,MAAM,CAAC,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IACtD,CAAC;IAED,cAAc,CAAC,MAAM,CAAC,CAAC;IACvB,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,cAAc,CAAC,MAAoB;IAC1C,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAClB,MAAM,CAAC,IAAI,CAAC,iDAAiD,CAAC,CAAC;IACjE,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QACzB,MAAM,CAAC,IAAI,CAAC,+CAA+C,CAAC,CAAC;IAC/D,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,CAAC,IAAI,CAAC,mDAAmD,CAAC,CAAC;IACnE,CAAC;IAED,IAAI,MAAM,CAAC,UAAU,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,CAAC,IAAI,MAAM,CAAC,UAAU,GAAG,EAAE,CAAC,EAAE,CAAC;QAC3E,MAAM,CAAC,IAAI,CAAC,qCAAqC,CAAC,CAAC;IACrD,CAAC;IACD,IAAI,MAAM,CAAC,cAAc,IAAI,MAAM,CAAC,cAAc,GAAG,IAAI,EAAE,CAAC;QAC1D,MAAM,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,IAAI,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,EAAE,CAAC;QAC5D,MAAM,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;IAClD,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,qCAAqC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5E,CAAC;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { TidewaysMCPServer } from './server.js';
+import { logger } from './lib/logger.js';
+async function main() {
+    try {
+        const server = new TidewaysMCPServer();
+        await server.start();
+    }
+    catch (error) {
+        logger.error('Failed to start Tideways MCP Server', error);
+        process.exit(1);
+    }
+}
+main().catch(error => {
+    logger.error('Unhandled error in main', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map