mcp-consultant-tools 5.0.0 → 6.0.0

package/README.md

@@ -1,6 +1,6 @@
 # MCP Consultant Tools
 
-A Model Context Protocol (MCP) server providing intelligent access to PowerPlatform/Dataverse, Azure DevOps, and Figma through an AI-friendly interface.
+A Model Context Protocol (MCP) server providing intelligent access to PowerPlatform/Dataverse, Azure DevOps, Figma, and Azure Application Insights through an AI-friendly interface.
 
 ## Overview
 
@@ -15,10 +15,11 @@ This MCP server enables AI assistants to:
     - Publishing & validation
 - **Azure DevOps** (12 tools): Search wikis, manage work items, execute WIQL queries
 - **Figma** (2 tools): Extract design data in simplified, AI-friendly format
+- **Application Insights** (10 tools): Query telemetry, analyze exceptions, monitor performance, troubleshoot issues
 
 All integrations are **optional** - configure only the services you need.
 
-**Total: 86+ MCP tools** providing comprehensive access to your development lifecycle.
+**Total: 96+ MCP tools** providing comprehensive access to your development and operations lifecycle.
 
 ## Known limitations
 - Cannot create Model-Driven-Apps
@@ -71,7 +72,13 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
 
         "FIGMA_API_KEY": "your-figma-token",
         "FIGMA_OAUTH_TOKEN": "",
-        "FIGMA_USE_OAUTH": "false"
+        "FIGMA_USE_OAUTH": "false",
+
+        "APPINSIGHTS_AUTH_METHOD": "entra-id",
+        "APPINSIGHTS_TENANT_ID": "your-tenant-id",
+        "APPINSIGHTS_CLIENT_ID": "your-client-id",
+        "APPINSIGHTS_CLIENT_SECRET": "your-client-secret",
+        "APPINSIGHTS_RESOURCES": "[{\"id\":\"prod-api\",\"name\":\"Production API\",\"appId\":\"your-app-id\",\"active\":true}]"
       }
     }
   }
@@ -108,7 +115,13 @@ Create `.vscode/mcp.json` in your project:
 
         "FIGMA_API_KEY": "your-figma-token",
         "FIGMA_OAUTH_TOKEN": "",
-        "FIGMA_USE_OAUTH": "false"
+        "FIGMA_USE_OAUTH": "false",
+
+        "APPINSIGHTS_AUTH_METHOD": "entra-id",
+        "APPINSIGHTS_TENANT_ID": "your-tenant-id",
+        "APPINSIGHTS_CLIENT_ID": "your-client-id",
+        "APPINSIGHTS_CLIENT_SECRET": "your-client-secret",
+        "APPINSIGHTS_RESOURCES": "[{\"id\":\"prod-api\",\"name\":\"Production API\",\"appId\":\"your-app-id\",\"active\":true}]"
       }
     }
   }
@@ -239,9 +252,22 @@ Reload VS Code window after saving.
 - `get-figma-data` - Get design data (layout, text, styles, components)
 - `download-figma-images` - Download images (coming in v2)
 
+### Application Insights (10 tools)
+
+- `appinsights-list-resources` - List all configured Application Insights resources
+- `appinsights-get-metadata` - Get schema metadata (tables and columns)
+- `appinsights-execute-query` - Execute custom KQL queries
+- `appinsights-get-exceptions` - Get recent exceptions with details
+- `appinsights-get-slow-requests` - Get slow HTTP requests (configurable threshold)
+- `appinsights-get-operation-performance` - Get operation performance summary (count, avg, percentiles)
+- `appinsights-get-failed-dependencies` - Get failed external API/database calls
+- `appinsights-get-traces` - Get diagnostic traces filtered by severity
+- `appinsights-get-availability` - Get availability test results and uptime stats
+- `appinsights-get-custom-events` - Get custom application events
+
 ## Available Prompts
 
-The server includes **13 prompts** that provide formatted, context-rich output:
+The server includes **18 prompts** that provide formatted, context-rich output:
 
 **PowerPlatform:**
 - `entity-overview` - Comprehensive entity overview
@@ -260,10 +286,17 @@ The server includes **13 prompts** that provide formatted, context-rich output:
 - `work-item-summary` - Comprehensive work item summary
 - `work-items-query-report` - Formatted WIQL query results
 
+**Application Insights:**
+- `appinsights-exception-summary` - Exception summary report with insights
+- `appinsights-performance-report` - Performance analysis with recommendations
+- `appinsights-dependency-health` - Dependency health report with success rates
+- `appinsights-availability-report` - Availability and uptime report
+- `appinsights-troubleshooting-guide` - Comprehensive troubleshooting guide combining all telemetry
+
 ## Documentation
 
 - **[SETUP.md](SETUP.md)** - Complete setup guide with credentials, troubleshooting, and security
-- **[TOOLS.md](TOOLS.md)** - Full reference for all 86+ tools and 12 prompts
+- **[TOOLS.md](TOOLS.md)** - Full reference for all 96+ tools and 18 prompts
 - **[USAGE.md](USAGE.md)** - Examples and use cases for all integrations
 - **[CLAUDE.md](CLAUDE.md)** - Architecture details and development guide
 

package/build/ApplicationInsightsService.js

@@ -0,0 +1,323 @@
+import { ConfidentialClientApplication } from '@azure/msal-node';
+import axios from 'axios';
+export class ApplicationInsightsService {
+    config;
+    msalClient = null;
+    accessToken = null;
+    tokenExpirationTime = 0;
+    baseUrl = 'https://api.applicationinsights.io/v1';
+    constructor(config) {
+        this.config = config;
+        // Initialize MSAL client if using Entra ID auth
+        if (this.config.authMethod === 'entra-id') {
+            if (!this.config.tenantId || !this.config.clientId || !this.config.clientSecret) {
+                throw new Error('Entra ID authentication requires tenantId, clientId, and clientSecret');
+            }
+            this.msalClient = new ConfidentialClientApplication({
+                auth: {
+                    clientId: this.config.clientId,
+                    clientSecret: this.config.clientSecret,
+                    authority: `https://login.microsoftonline.com/${this.config.tenantId}`,
+                }
+            });
+        }
+    }
+    /**
+     * Get an access token for the Application Insights API (Entra ID auth)
+     */
+    async getAccessToken() {
+        if (this.config.authMethod !== 'entra-id' || !this.msalClient) {
+            throw new Error('Entra ID authentication not configured');
+        }
+        const currentTime = Date.now();
+        // Return cached token if still valid (with 5 minute buffer)
+        if (this.accessToken && this.tokenExpirationTime > currentTime) {
+            return this.accessToken;
+        }
+        try {
+            const result = await this.msalClient.acquireTokenByClientCredential({
+                scopes: ['https://api.applicationinsights.io/.default'],
+            });
+            if (!result || !result.accessToken) {
+                throw new Error('Failed to acquire access token');
+            }
+            this.accessToken = result.accessToken;
+            // Set expiration time (subtract 5 minutes to refresh early)
+            if (result.expiresOn) {
+                this.tokenExpirationTime = result.expiresOn.getTime() - (5 * 60 * 1000);
+            }
+            return this.accessToken;
+        }
+        catch (error) {
+            console.error('Error acquiring access token:', error);
+            throw new Error('Application Insights authentication failed');
+        }
+    }
+    /**
+     * Get authentication headers based on configuration
+     */
+    async getAuthHeaders(resourceId) {
+        const resource = this.getResourceById(resourceId);
+        if (this.config.authMethod === 'entra-id') {
+            const token = await this.getAccessToken();
+            return {
+                'Authorization': `Bearer ${token}`,
+                'Accept': 'application/json',
+            };
+        }
+        else {
+            // API Key authentication
+            if (!resource.apiKey) {
+                throw new Error(`API key not configured for resource '${resourceId}'`);
+            }
+            return {
+                'x-api-key': resource.apiKey,
+                'Accept': 'application/json',
+            };
+        }
+    }
+    /**
+     * Get active resources
+     */
+    getActiveResources() {
+        return this.config.resources.filter(r => r.active);
+    }
+    /**
+     * Get all resources (including inactive)
+     */
+    getAllResources() {
+        return this.config.resources;
+    }
+    /**
+     * Get resource by ID
+     */
+    getResourceById(resourceId) {
+        const resource = this.config.resources.find(r => r.id === resourceId);
+        if (!resource) {
+            throw new Error(`Application Insights resource '${resourceId}' not found`);
+        }
+        if (!resource.active) {
+            throw new Error(`Application Insights resource '${resourceId}' is inactive`);
+        }
+        return resource;
+    }
+    /**
+     * Execute a KQL query against an Application Insights resource
+     */
+    async executeQuery(resourceId, query, timespan) {
+        try {
+            const resource = this.getResourceById(resourceId);
+            const headers = await this.getAuthHeaders(resourceId);
+            const url = `${this.baseUrl}/apps/${resource.appId}/query`;
+            const params = { query };
+            if (timespan) {
+                params.timespan = timespan;
+            }
+            const response = await axios.get(url, {
+                headers,
+                params,
+                timeout: 30000, // 30 second timeout
+            });
+            return response.data;
+        }
+        catch (error) {
+            // Handle timeout
+            if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT') {
+                throw new Error('Application Insights query timed out after 30 seconds. ' +
+                    'Try reducing the time range or simplifying the query.');
+            }
+            // Handle network errors
+            if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
+                throw new Error('Network error: Unable to connect to Application Insights API. ' +
+                    'Check your internet connection and firewall settings.');
+            }
+            const errorDetails = error.response?.data?.error?.message || error.message;
+            console.error('Application Insights query failed:', {
+                resourceId,
+                query: query.substring(0, 100) + '...',
+                error: errorDetails,
+            });
+            // Provide user-friendly error messages
+            if (error.response?.status === 401) {
+                throw new Error('Application Insights authentication failed. Check credentials and permissions.');
+            }
+            if (error.response?.status === 403) {
+                throw new Error('Application Insights access denied. Ensure you have Reader role on the resource.');
+            }
+            if (error.response?.status === 429) {
+                const retryAfter = error.response.headers['retry-after'] || 60;
+                throw new Error(`Application Insights rate limit exceeded. ` +
+                    `Please retry after ${retryAfter} seconds. ` +
+                    `Current limits: ${this.config.authMethod === 'entra-id' ? '60 requests/minute' : '15 requests/minute'}`);
+            }
+            // Handle KQL syntax errors
+            if (error.response?.data?.error?.innererror?.code === 'SyntaxError') {
+                const syntaxError = error.response.data.error.innererror.message;
+                throw new Error(`KQL query syntax error: ${syntaxError}\n` +
+                    `Hint: Check table names, column names, and operator syntax`);
+            }
+            // Handle semantic errors
+            if (error.response?.data?.error?.innererror?.code === 'SemanticError') {
+                const semanticError = error.response.data.error.innererror.message;
+                throw new Error(`KQL query semantic error: ${semanticError}\n` +
+                    `Hint: Use appinsights-get-metadata to see available tables and columns`);
+            }
+            throw new Error(`Application Insights query failed: ${errorDetails}`);
+        }
+    }
+    /**
+     * Get metadata (schema) for an Application Insights resource
+     */
+    async getMetadata(resourceId) {
+        try {
+            const resource = this.getResourceById(resourceId);
+            const headers = await this.getAuthHeaders(resourceId);
+            const url = `${this.baseUrl}/apps/${resource.appId}/metadata`;
+            const response = await axios.get(url, {
+                headers,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            const errorDetails = error.response?.data?.error?.message || error.message;
+            console.error('Application Insights metadata request failed:', {
+                resourceId,
+                error: errorDetails,
+            });
+            throw new Error(`Application Insights metadata request failed: ${errorDetails}`);
+        }
+    }
+    /**
+     * Helper method: Get recent exceptions
+     */
+    async getRecentExceptions(resourceId, timespan = 'PT1H', limit = 50) {
+        const query = `
+      exceptions
+      | where timestamp > ago(${this.convertTimespanToKQL(timespan)})
+      | order by timestamp desc
+      | take ${limit}
+      | project timestamp, type, outerMessage, innermostMessage, operation_Name, operation_Id, cloud_RoleName
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Helper method: Get slow requests
+     */
+    async getSlowRequests(resourceId, durationThresholdMs = 5000, timespan = 'PT1H', limit = 50) {
+        const query = `
+      requests
+      | where timestamp > ago(${this.convertTimespanToKQL(timespan)})
+      | where duration > ${durationThresholdMs}
+      | order by duration desc
+      | take ${limit}
+      | project timestamp, name, duration, resultCode, success, operation_Id, cloud_RoleName
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Helper method: Get failed dependencies
+     */
+    async getFailedDependencies(resourceId, timespan = 'PT1H', limit = 50) {
+        const query = `
+      dependencies
+      | where timestamp > ago(${this.convertTimespanToKQL(timespan)})
+      | where success == false
+      | order by timestamp desc
+      | take ${limit}
+      | project timestamp, name, target, type, duration, resultCode, operation_Id, cloud_RoleName
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Helper method: Get operation performance summary
+     */
+    async getOperationPerformance(resourceId, timespan = 'PT1H') {
+        const query = `
+      requests
+      | where timestamp > ago(${this.convertTimespanToKQL(timespan)})
+      | summarize
+          RequestCount=count(),
+          AvgDuration=avg(duration),
+          P50Duration=percentile(duration, 50),
+          P95Duration=percentile(duration, 95),
+          P99Duration=percentile(duration, 99),
+          FailureCount=countif(success == false)
+        by operation_Name
+      | order by RequestCount desc
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Helper method: Get traces by severity
+     */
+    async getTracesBySeverity(resourceId, severityLevel = 2, // 0=Verbose, 1=Info, 2=Warning, 3=Error, 4=Critical
+    timespan = 'PT1H', limit = 100) {
+        const query = `
+      traces
+      | where timestamp > ago(${this.convertTimespanToKQL(timespan)})
+      | where severityLevel >= ${severityLevel}
+      | order by timestamp desc
+      | take ${limit}
+      | project timestamp, message, severityLevel, operation_Name, operation_Id, cloud_RoleName
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Helper method: Get availability test results
+     */
+    async getAvailabilityResults(resourceId, timespan = 'PT24H') {
+        const query = `
+      availabilityResults
+      | where timestamp > ago(${this.convertTimespanToKQL(timespan)})
+      | summarize
+          TotalTests=count(),
+          SuccessCount=countif(success == true),
+          FailureCount=countif(success == false),
+          AvgDuration=avg(duration)
+        by name
+      | extend SuccessRate=round(100.0 * SuccessCount / TotalTests, 2)
+      | order by FailureCount desc
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Helper method: Get custom events
+     */
+    async getCustomEvents(resourceId, eventName, timespan = 'PT1H', limit = 100) {
+        let query = `
+      customEvents
+      | where timestamp > ago(${this.convertTimespanToKQL(timespan)})
+    `;
+        if (eventName) {
+            query += `\n      | where name == "${eventName}"`;
+        }
+        query += `
+      | order by timestamp desc
+      | take ${limit}
+      | project timestamp, name, customDimensions, operation_Id, cloud_RoleName
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Convert ISO 8601 duration to KQL format
+     */
+    convertTimespanToKQL(timespan) {
+        // Convert ISO 8601 duration (PT1H, P1D) to KQL format (1h, 1d)
+        const match = timespan.match(/P(?:(\d+)D)?T?(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/);
+        if (!match) {
+            return timespan; // Return as-is if not recognized
+        }
+        const [, days, hours, minutes, seconds] = match;
+        const parts = [];
+        if (days)
+            parts.push(`${days}d`);
+        if (hours)
+            parts.push(`${hours}h`);
+        if (minutes)
+            parts.push(`${minutes}m`);
+        if (seconds)
+            parts.push(`${seconds}s`);
+        return parts.length > 0 ? parts.join('') : '1h';
+    }
+}

package/build/index.js

@@ -6,6 +6,8 @@ import { z } from "zod";
 import { PowerPlatformService } from "./PowerPlatformService.js";
 import { AzureDevOpsService } from "./AzureDevOpsService.js";
 import { FigmaService } from "./FigmaService.js";
+import { ApplicationInsightsService } from "./ApplicationInsightsService.js";
+import { formatTableAsMarkdown, analyzeExceptions, analyzePerformance, analyzeDependencies } from "./utils/appinsights-formatters.js";
 // Load environment variables from .env file (silent mode to not interfere with MCP)
 // Temporarily suppress stdout to prevent dotenv from corrupting the JSON protocol
 const originalStdoutWrite = process.stdout.write.bind(process.stdout);
@@ -39,6 +41,36 @@ const FIGMA_CONFIG = {
     oauthToken: process.env.FIGMA_OAUTH_TOKEN || "",
     useOAuth: process.env.FIGMA_USE_OAUTH === "true",
 };
+// Application Insights configuration
+const APPINSIGHTS_CONFIG = {
+    resources: [],
+    authMethod: (process.env.APPINSIGHTS_AUTH_METHOD || 'entra-id'),
+    tenantId: process.env.APPINSIGHTS_TENANT_ID || '',
+    clientId: process.env.APPINSIGHTS_CLIENT_ID || '',
+    clientSecret: process.env.APPINSIGHTS_CLIENT_SECRET || '',
+};
+// Parse resources configuration
+if (process.env.APPINSIGHTS_RESOURCES) {
+    try {
+        APPINSIGHTS_CONFIG.resources = JSON.parse(process.env.APPINSIGHTS_RESOURCES);
+    }
+    catch (error) {
+        console.error('Failed to parse APPINSIGHTS_RESOURCES:', error);
+    }
+}
+else if (process.env.APPINSIGHTS_APP_ID) {
+    // Fallback: single resource configuration
+    APPINSIGHTS_CONFIG.resources = [
+        {
+            id: 'default',
+            name: 'Default Application Insights',
+            appId: process.env.APPINSIGHTS_APP_ID,
+            active: true,
+            apiKey: process.env.APPINSIGHTS_API_KEY || '',
+            description: 'Default Application Insights resource',
+        },
+    ];
+}
 // Create server instance
 const server = new McpServer({
     name: "mcp-consultant-tools",
@@ -108,6 +140,33 @@ function getFigmaService() {
     }
     return figmaService;
 }
+let applicationInsightsService = null;
+// Function to initialize ApplicationInsightsService on demand
+function getApplicationInsightsService() {
+    if (!applicationInsightsService) {
+        // Check if configuration is complete
+        const missingConfig = [];
+        if (!APPINSIGHTS_CONFIG.resources || APPINSIGHTS_CONFIG.resources.length === 0) {
+            missingConfig.push('APPINSIGHTS_RESOURCES or APPINSIGHTS_APP_ID');
+        }
+        if (APPINSIGHTS_CONFIG.authMethod === 'entra-id') {
+            if (!APPINSIGHTS_CONFIG.tenantId)
+                missingConfig.push('APPINSIGHTS_TENANT_ID');
+            if (!APPINSIGHTS_CONFIG.clientId)
+                missingConfig.push('APPINSIGHTS_CLIENT_ID');
+            if (!APPINSIGHTS_CONFIG.clientSecret)
+                missingConfig.push('APPINSIGHTS_CLIENT_SECRET');
+        }
+        if (missingConfig.length > 0) {
+            throw new Error(`Missing Application Insights configuration: ${missingConfig.join(', ')}. ` +
+                `Set these in environment variables (APPINSIGHTS_*).`);
+        }
+        // Initialize service
+        applicationInsightsService = new ApplicationInsightsService(APPINSIGHTS_CONFIG);
+        console.error('Application Insights service initialized');
+    }
+    return applicationInsightsService;
+}
 // Pre-defined PowerPlatform Prompts
 const powerPlatformPrompts = {
     // Entity exploration prompts
@@ -1169,6 +1228,306 @@ server.prompt("work-items-query-report", "Execute a WIQL query and get formatted
         };
     }
 });
+/**
+ * Prompt: appinsights-exception-summary
+ * Generate an exception summary report for troubleshooting
+ */
+server.prompt("appinsights-exception-summary", "Generate a comprehensive exception summary report from Application Insights", {
+    resourceId: z.string().describe("Resource ID"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+}, async ({ resourceId, timespan }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const timespanValue = timespan || 'PT1H';
+        // Get recent exceptions
+        const exceptionsResult = await service.getRecentExceptions(resourceId, timespanValue, 50);
+        // Get exception type frequency
+        const exceptionTypesResult = await service.executeQuery(resourceId, `
+          exceptions
+          | where timestamp > ago(${timespanValue.replace(/^P(T)?/, '')})
+          | summarize Count=count() by type
+          | order by Count desc
+        `.trim(), timespanValue);
+        // Format results
+        const exceptionsList = formatTableAsMarkdown(exceptionsResult.tables[0]);
+        const exceptionTypes = formatTableAsMarkdown(exceptionTypesResult.tables[0]);
+        const insights = analyzeExceptions(exceptionsResult.tables[0]);
+        const report = `# Application Insights Exception Summary Report\n\n` +
+            `**Resource**: ${resourceId}\n` +
+            `**Time Range**: ${timespanValue}\n\n` +
+            `## Key Insights\n\n${insights}\n\n` +
+            `## Recent Exceptions\n\n${exceptionsList}\n\n` +
+            `## Exception Types (Frequency)\n\n${exceptionTypes}\n\n` +
+            `## Recommendations\n\n` +
+            `- Review the most frequent exception types to identify systemic issues\n` +
+            `- Investigate exceptions in critical operations first\n` +
+            `- Check for patterns in timestamps (e.g., deployment times, peak traffic)\n` +
+            `- Use operation_Id to correlate exceptions with requests and dependencies`;
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: report,
+                    },
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error generating exception summary:", error);
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: `Failed to generate exception summary: ${error.message}`,
+                    },
+                },
+            ],
+        };
+    }
+});
+/**
+ * Prompt: appinsights-performance-report
+ * Generate a comprehensive performance analysis report
+ */
+server.prompt("appinsights-performance-report", "Generate a comprehensive performance analysis report from Application Insights", {
+    resourceId: z.string().describe("Resource ID"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+}, async ({ resourceId, timespan }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const timespanValue = timespan || 'PT1H';
+        // Get operation performance
+        const performanceResult = await service.getOperationPerformance(resourceId, timespanValue);
+        // Get slow requests
+        const slowRequestsResult = await service.getSlowRequests(resourceId, 5000, timespanValue, 20);
+        // Format results
+        const performanceTable = formatTableAsMarkdown(performanceResult.tables[0]);
+        const slowRequestsTable = formatTableAsMarkdown(slowRequestsResult.tables[0]);
+        const insights = analyzePerformance(performanceResult.tables[0]);
+        const report = `# Application Insights Performance Report\n\n` +
+            `**Resource**: ${resourceId}\n` +
+            `**Time Range**: ${timespanValue}\n\n` +
+            `## Key Insights\n\n${insights}\n\n` +
+            `## Operation Performance Summary\n\n${performanceTable}\n\n` +
+            `## Slowest Requests (>5s)\n\n${slowRequestsTable}\n\n` +
+            `## Performance Recommendations\n\n` +
+            `- Focus optimization efforts on operations with high P95/P99 duration\n` +
+            `- Investigate operations with high failure counts\n` +
+            `- Monitor operations with high request counts for scalability issues\n` +
+            `- Use operation_Id to trace slow requests through dependencies`;
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: report,
+                    },
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error generating performance report:", error);
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: `Failed to generate performance report: ${error.message}`,
+                    },
+                },
+            ],
+        };
+    }
+});
+/**
+ * Prompt: appinsights-dependency-health
+ * Generate a dependency health report
+ */
+server.prompt("appinsights-dependency-health", "Generate a dependency health report showing external service issues", {
+    resourceId: z.string().describe("Resource ID"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+}, async ({ resourceId, timespan }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const timespanValue = timespan || 'PT1H';
+        // Get failed dependencies
+        const failedDepsResult = await service.getFailedDependencies(resourceId, timespanValue, 50);
+        // Get dependency success rates
+        const successRatesResult = await service.executeQuery(resourceId, `
+          dependencies
+          | where timestamp > ago(${timespanValue.replace(/^P(T)?/, '')})
+          | summarize Total=count(), Failed=countif(success == false), AvgDuration=avg(duration) by target, type
+          | extend SuccessRate=round(100.0 * (Total - Failed) / Total, 2)
+          | order by SuccessRate asc
+        `.trim(), timespanValue);
+        // Format results
+        const failedDepsTable = formatTableAsMarkdown(failedDepsResult.tables[0]);
+        const successRatesTable = formatTableAsMarkdown(successRatesResult.tables[0]);
+        const insights = analyzeDependencies(failedDepsResult.tables[0]);
+        const report = `# Application Insights Dependency Health Report\n\n` +
+            `**Resource**: ${resourceId}\n` +
+            `**Time Range**: ${timespanValue}\n\n` +
+            `## Key Insights\n\n${insights}\n\n` +
+            `## Failed Dependencies\n\n${failedDepsTable}\n\n` +
+            `## Dependency Success Rates\n\n${successRatesTable}\n\n` +
+            `## Recommendations\n\n` +
+            `- Investigate dependencies with success rates below 99%\n` +
+            `- Check if external service degradation matches known incidents\n` +
+            `- Review timeout configurations for slow dependencies\n` +
+            `- Consider implementing circuit breakers for unreliable dependencies`;
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: report,
+                    },
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error generating dependency health report:", error);
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: `Failed to generate dependency health report: ${error.message}`,
+                    },
+                },
+            ],
+        };
+    }
+});
+/**
+ * Prompt: appinsights-availability-report
+ * Generate an availability and uptime report
+ */
+server.prompt("appinsights-availability-report", "Generate an availability and uptime report from Application Insights", {
+    resourceId: z.string().describe("Resource ID"),
+    timespan: z.string().optional().describe("Time range (default: PT24H)"),
+}, async ({ resourceId, timespan }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const timespanValue = timespan || 'PT24H';
+        // Get availability results
+        const availabilityResult = await service.getAvailabilityResults(resourceId, timespanValue);
+        // Format results
+        const availabilityTable = formatTableAsMarkdown(availabilityResult.tables[0]);
+        const report = `# Application Insights Availability Report\n\n` +
+            `**Resource**: ${resourceId}\n` +
+            `**Time Range**: ${timespanValue}\n\n` +
+            `## Availability Test Results\n\n${availabilityTable}\n\n` +
+            `## Recommendations\n\n` +
+            `- Investigate any tests with success rates below 99.9%\n` +
+            `- Review failed tests for patterns (geographic, time-based)\n` +
+            `- Consider adding availability tests for critical endpoints if missing\n` +
+            `- Set up alerts for availability degradation`;
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: report,
+                    },
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error generating availability report:", error);
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: `Failed to generate availability report: ${error.message}`,
+                    },
+                },
+            ],
+        };
+    }
+});
+/**
+ * Prompt: appinsights-troubleshooting-guide
+ * Generate a comprehensive troubleshooting guide
+ */
+server.prompt("appinsights-troubleshooting-guide", "Generate a comprehensive troubleshooting guide combining exceptions, performance, and dependencies", {
+    resourceId: z.string().describe("Resource ID"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+}, async ({ resourceId, timespan }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const timespanValue = timespan || 'PT1H';
+        // Get data from multiple sources
+        const exceptionsResult = await service.getRecentExceptions(resourceId, timespanValue, 20);
+        const slowRequestsResult = await service.getSlowRequests(resourceId, 5000, timespanValue, 20);
+        const failedDepsResult = await service.getFailedDependencies(resourceId, timespanValue, 20);
+        const tracesResult = await service.getTracesBySeverity(resourceId, 3, timespanValue, 30); // Error level
+        // Format results
+        const exceptionsTable = formatTableAsMarkdown(exceptionsResult.tables[0]);
+        const slowRequestsTable = formatTableAsMarkdown(slowRequestsResult.tables[0]);
+        const failedDepsTable = formatTableAsMarkdown(failedDepsResult.tables[0]);
+        const tracesTable = formatTableAsMarkdown(tracesResult.tables[0]);
+        const report = `# Application Insights Troubleshooting Guide\n\n` +
+            `**Resource**: ${resourceId}\n` +
+            `**Time Range**: ${timespanValue}\n` +
+            `**Generated**: ${new Date().toISOString()}\n\n` +
+            `## 1. Recent Errors and Exceptions\n\n${exceptionsTable}\n\n` +
+            `## 2. Performance Issues\n\n${slowRequestsTable}\n\n` +
+            `## 3. Dependency Failures\n\n${failedDepsTable}\n\n` +
+            `## 4. Diagnostic Logs (Errors)\n\n${tracesTable}\n\n` +
+            `## 5. Investigation Steps\n\n` +
+            `1. **Identify the pattern**: Check if errors are isolated or widespread\n` +
+            `2. **Correlate events**: Use operation_Id to trace requests across services\n` +
+            `3. **Check timeline**: Look for correlation with deployments or external events\n` +
+            `4. **Review dependencies**: Verify external service health\n` +
+            `5. **Analyze traces**: Review detailed logs for error context\n\n` +
+            `## 6. Common Patterns and Root Causes\n\n` +
+            `- **High exception rate + dependency failures**: External service degradation\n` +
+            `- **Slow requests + high dependency duration**: Network or external API latency\n` +
+            `- **Exceptions in specific operations**: Code defect or invalid input\n` +
+            `- **Timeouts**: Insufficient resources or inefficient queries`;
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: report,
+                    },
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error generating troubleshooting guide:", error);
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: `Failed to generate troubleshooting guide: ${error.message}`,
+                    },
+                },
+            ],
+        };
+    }
+});
 // PowerPlatform entity metadata
 server.tool("get-entity-metadata", "Get metadata about a PowerPlatform entity", {
     entityName: z.string().describe("The logical name of the entity"),
@@ -4685,6 +5044,341 @@ server.tool("check-delete-eligibility", "Check if a component can be safely dele
         };
     }
 });
+/**
+ * Tool: appinsights-list-resources
+ * List all configured Application Insights resources
+ */
+server.tool("appinsights-list-resources", "List all configured Application Insights resources (active and inactive)", {}, async () => {
+    try {
+        const service = getApplicationInsightsService();
+        const resources = service.getAllResources();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(resources, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error listing Application Insights resources:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to list Application Insights resources: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
+/**
+ * Tool: appinsights-get-metadata
+ * Get schema metadata for an Application Insights resource
+ */
+server.tool("appinsights-get-metadata", "Get schema metadata (tables and columns) for an Application Insights resource", {
+    resourceId: z.string().describe("Resource ID (use appinsights-list-resources to find IDs)"),
+}, async ({ resourceId }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const metadata = await service.getMetadata(resourceId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(metadata, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error getting Application Insights metadata:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to get metadata: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
+/**
+ * Tool: appinsights-execute-query
+ * Execute a custom KQL query against an Application Insights resource
+ */
+server.tool("appinsights-execute-query", "Execute a KQL (Kusto Query Language) query against Application Insights", {
+    resourceId: z.string().describe("Resource ID"),
+    query: z.string().describe("KQL query string"),
+    timespan: z.string().optional().describe("Time range (e.g., 'PT1H' for 1 hour, 'P1D' for 1 day, 'PT12H' for 12 hours)"),
+}, async ({ resourceId, query, timespan }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const result = await service.executeQuery(resourceId, query, timespan);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error executing Application Insights query:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to execute query: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
+/**
+ * Tool: appinsights-get-exceptions
+ * Get recent exceptions from Application Insights
+ */
+server.tool("appinsights-get-exceptions", "Get recent exceptions from Application Insights with timestamps, types, and messages", {
+    resourceId: z.string().describe("Resource ID"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+    limit: z.number().optional().describe("Maximum number of results (default: 50)"),
+}, async ({ resourceId, timespan, limit }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const result = await service.getRecentExceptions(resourceId, timespan || 'PT1H', limit || 50);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error getting Application Insights exceptions:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to get exceptions: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
+/**
+ * Tool: appinsights-get-slow-requests
+ * Get slow HTTP requests from Application Insights
+ */
+server.tool("appinsights-get-slow-requests", "Get slow HTTP requests (above duration threshold) from Application Insights", {
+    resourceId: z.string().describe("Resource ID"),
+    durationThresholdMs: z.number().optional().describe("Duration threshold in milliseconds (default: 5000)"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+    limit: z.number().optional().describe("Maximum number of results (default: 50)"),
+}, async ({ resourceId, durationThresholdMs, timespan, limit }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const result = await service.getSlowRequests(resourceId, durationThresholdMs || 5000, timespan || 'PT1H', limit || 50);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error getting slow requests:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to get slow requests: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
+/**
+ * Tool: appinsights-get-operation-performance
+ * Get operation performance summary from Application Insights
+ */
+server.tool("appinsights-get-operation-performance", "Get performance summary by operation (request count, avg duration, percentiles)", {
+    resourceId: z.string().describe("Resource ID"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+}, async ({ resourceId, timespan }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const result = await service.getOperationPerformance(resourceId, timespan || 'PT1H');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error getting operation performance:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to get operation performance: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
+/**
+ * Tool: appinsights-get-failed-dependencies
+ * Get failed dependency calls from Application Insights
+ */
+server.tool("appinsights-get-failed-dependencies", "Get failed dependency calls (external APIs, databases, etc.) from Application Insights", {
+    resourceId: z.string().describe("Resource ID"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+    limit: z.number().optional().describe("Maximum number of results (default: 50)"),
+}, async ({ resourceId, timespan, limit }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const result = await service.getFailedDependencies(resourceId, timespan || 'PT1H', limit || 50);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error getting failed dependencies:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to get failed dependencies: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
+/**
+ * Tool: appinsights-get-traces
+ * Get diagnostic traces from Application Insights filtered by severity
+ */
+server.tool("appinsights-get-traces", "Get diagnostic traces/logs from Application Insights filtered by severity level", {
+    resourceId: z.string().describe("Resource ID"),
+    severityLevel: z.number().optional().describe("Minimum severity level (0=Verbose, 1=Info, 2=Warning, 3=Error, 4=Critical) (default: 2)"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+    limit: z.number().optional().describe("Maximum number of results (default: 100)"),
+}, async ({ resourceId, severityLevel, timespan, limit }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const result = await service.getTracesBySeverity(resourceId, severityLevel ?? 2, timespan || 'PT1H', limit || 100);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error getting traces:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to get traces: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
+/**
+ * Tool: appinsights-get-availability
+ * Get availability test results from Application Insights
+ */
+server.tool("appinsights-get-availability", "Get availability test results and uptime statistics from Application Insights", {
+    resourceId: z.string().describe("Resource ID"),
+    timespan: z.string().optional().describe("Time range (default: PT24H)"),
+}, async ({ resourceId, timespan }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const result = await service.getAvailabilityResults(resourceId, timespan || 'PT24H');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error getting availability results:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to get availability results: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
+/**
+ * Tool: appinsights-get-custom-events
+ * Get custom application events from Application Insights
+ */
+server.tool("appinsights-get-custom-events", "Get custom application events from Application Insights", {
+    resourceId: z.string().describe("Resource ID"),
+    eventName: z.string().optional().describe("Filter by specific event name"),
+    timespan: z.string().optional().describe("Time range (default: PT1H)"),
+    limit: z.number().optional().describe("Maximum number of results (default: 100)"),
+}, async ({ resourceId, eventName, timespan, limit }) => {
+    try {
+        const service = getApplicationInsightsService();
+        const result = await service.getCustomEvents(resourceId, eventName, timespan || 'PT1H', limit || 100);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error getting custom events:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to get custom events: ${error.message}`,
+                },
+            ],
+            isError: true
+        };
+    }
+});
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/build/utils/appinsights-formatters.js

@@ -0,0 +1,181 @@
+/**
+ * Utility functions for formatting Application Insights query results
+ */
+/**
+ * Format Application Insights table result as markdown table
+ */
+export function formatTableAsMarkdown(table) {
+    if (!table || !table.rows || table.rows.length === 0) {
+        return '*No results*';
+    }
+    // Create header row
+    const header = '| ' + table.columns.map(c => c.name).join(' | ') + ' |';
+    const separator = '| ' + table.columns.map(() => '---').join(' | ') + ' |';
+    // Create data rows
+    const rows = table.rows.map(row => {
+        return '| ' + row.map(cell => {
+            if (cell === null || cell === undefined)
+                return '';
+            if (typeof cell === 'object')
+                return JSON.stringify(cell);
+            return String(cell);
+        }).join(' | ') + ' |';
+    });
+    return [header, separator, ...rows].join('\n');
+}
+/**
+ * Convert Application Insights query result to CSV
+ */
+export function formatTableAsCSV(table) {
+    if (!table || !table.rows || table.rows.length === 0) {
+        return '';
+    }
+    // Create header row
+    const header = table.columns.map(c => c.name).join(',');
+    // Create data rows
+    const rows = table.rows.map(row => {
+        return row.map(cell => {
+            if (cell === null || cell === undefined)
+                return '';
+            if (typeof cell === 'object')
+                return JSON.stringify(cell);
+            const str = String(cell);
+            // Escape CSV values
+            if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+                return `"${str.replace(/"/g, '""')}"`;
+            }
+            return str;
+        }).join(',');
+    });
+    return [header, ...rows].join('\n');
+}
+/**
+ * Extract key insights from exception data
+ */
+export function analyzeExceptions(exceptionsTable) {
+    if (!exceptionsTable || !exceptionsTable.rows || exceptionsTable.rows.length === 0) {
+        return 'No exceptions found in the specified time range.';
+    }
+    const insights = [];
+    // Count unique exception types
+    const typeIndex = exceptionsTable.columns.findIndex((c) => c.name === 'type');
+    if (typeIndex >= 0) {
+        const types = new Set(exceptionsTable.rows.map((r) => r[typeIndex]));
+        insights.push(`- Found ${types.size} unique exception type(s)`);
+    }
+    // Count total exceptions
+    insights.push(`- Total exceptions: ${exceptionsTable.rows.length}`);
+    // Identify most common operation
+    const operationIndex = exceptionsTable.columns.findIndex((c) => c.name === 'operation_Name');
+    if (operationIndex >= 0) {
+        const operations = {};
+        exceptionsTable.rows.forEach((r) => {
+            const op = r[operationIndex];
+            operations[op] = (operations[op] || 0) + 1;
+        });
+        const mostCommon = Object.entries(operations).sort((a, b) => b[1] - a[1])[0];
+        if (mostCommon) {
+            insights.push(`- Most affected operation: ${mostCommon[0]} (${mostCommon[1]} exceptions)`);
+        }
+    }
+    return insights.join('\n');
+}
+/**
+ * Extract key insights from performance data
+ */
+export function analyzePerformance(performanceTable) {
+    if (!performanceTable || !performanceTable.rows || performanceTable.rows.length === 0) {
+        return 'No performance data found in the specified time range.';
+    }
+    const insights = [];
+    // Find slowest operation
+    const avgDurationIndex = performanceTable.columns.findIndex((c) => c.name === 'AvgDuration');
+    const operationIndex = performanceTable.columns.findIndex((c) => c.name === 'operation_Name');
+    if (avgDurationIndex >= 0 && operationIndex >= 0) {
+        const sorted = [...performanceTable.rows].sort((a, b) => b[avgDurationIndex] - a[avgDurationIndex]);
+        const slowest = sorted[0];
+        insights.push(`- Slowest operation: ${slowest[operationIndex]} (avg: ${Math.round(slowest[avgDurationIndex])}ms)`);
+    }
+    // Find operation with most failures
+    const failureIndex = performanceTable.columns.findIndex((c) => c.name === 'FailureCount');
+    if (failureIndex >= 0 && operationIndex >= 0) {
+        const sorted = [...performanceTable.rows].sort((a, b) => b[failureIndex] - a[failureIndex]);
+        const mostFailed = sorted[0];
+        if (mostFailed[failureIndex] > 0) {
+            insights.push(`- Operation with most failures: ${mostFailed[operationIndex]} (${mostFailed[failureIndex]} failures)`);
+        }
+    }
+    return insights.join('\n');
+}
+/**
+ * Extract key insights from dependency data
+ */
+export function analyzeDependencies(dependenciesTable) {
+    if (!dependenciesTable || !dependenciesTable.rows || dependenciesTable.rows.length === 0) {
+        return 'No dependency failures found in the specified time range.';
+    }
+    const insights = [];
+    // Count unique targets
+    const targetIndex = dependenciesTable.columns.findIndex((c) => c.name === 'target');
+    if (targetIndex >= 0) {
+        const targets = new Set(dependenciesTable.rows.map((r) => r[targetIndex]));
+        insights.push(`- Affected targets: ${targets.size}`);
+    }
+    // Count total failures
+    insights.push(`- Total failed dependency calls: ${dependenciesTable.rows.length}`);
+    // Identify most failing target
+    if (targetIndex >= 0) {
+        const targets = {};
+        dependenciesTable.rows.forEach((r) => {
+            const target = r[targetIndex];
+            targets[target] = (targets[target] || 0) + 1;
+        });
+        const mostFailing = Object.entries(targets).sort((a, b) => b[1] - a[1])[0];
+        if (mostFailing) {
+            insights.push(`- Most failing target: ${mostFailing[0]} (${mostFailing[1]} failures)`);
+        }
+    }
+    return insights.join('\n');
+}
+/**
+ * Sanitize error messages to remove sensitive information
+ */
+export function sanitizeErrorMessage(message) {
+    // Remove potential connection strings
+    message = message.replace(/Server=.+?;/gi, 'Server=***;');
+    message = message.replace(/Password=.+?;/gi, 'Password=***;');
+    message = message.replace(/ApiKey=.+?;/gi, 'ApiKey=***;');
+    // Remove potential API keys and tokens
+    message = message.replace(/Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi, 'Bearer ***');
+    message = message.replace(/[A-Za-z0-9]{32,}/g, '***'); // Remove long alphanumeric strings
+    return message;
+}
+/**
+ * Parse and validate ISO 8601 duration strings
+ */
+export function parseTimespan(timespan) {
+    const iso8601Pattern = /^P(?:(\d+)D)?T?(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$/;
+    const match = timespan.match(iso8601Pattern);
+    if (!match) {
+        return {
+            valid: false,
+            error: 'Invalid timespan format. Use ISO 8601 duration (e.g., PT1H, P1D, PT30M)',
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Get common timespan presets
+ */
+export function getTimespanPresets() {
+    return {
+        '15min': 'PT15M',
+        '30min': 'PT30M',
+        '1hour': 'PT1H',
+        '6hours': 'PT6H',
+        '12hours': 'PT12H',
+        '1day': 'P1D',
+        '7days': 'P7D',
+        '30days': 'P30D',
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-consultant-tools",
-  "version": "5.0.0",
-  "description": "MCP server providing access to PowerPlatform/Dataverse, Azure DevOps, and Figma through unified interface",
+  "version": "6.0.0",
+  "description": "MCP server providing access to PowerPlatform/Dataverse, Azure DevOps, Figma, and Azure Application Insights through unified interface",
   "main": "build/index.js",
   "bin": {
     "mcp-consultant-tools": "build/index.js"
@@ -22,6 +22,9 @@
     "dataverse",
     "azure-devops",
     "figma",
+    "application-insights",
+    "telemetry",
+    "monitoring",
     "design-tools",
     "devops"
   ],