remove diagnostic monitors for loop debug feature

Author: MarcoWang3

packages/amazonq/src/lsp/autoDebug/diagnostics/diagnosticsMonitor.ts

@@ -4,8 +4,6 @@
  */
 
 import * as vscode from 'vscode'
-import { getLogger } from 'aws-core-vscode/shared'
-import { ToolkitError } from 'aws-core-vscode/shared'
 
 export interface DiagnosticCollection {
     readonly diagnostics: [vscode.Uri, vscode.Diagnostic[]][]
@@ -22,178 +20,3 @@ export interface FileDiagnostics {
     readonly uri: vscode.Uri
     readonly diagnostics: vscode.Diagnostic[]
 }
-
-/**
- * Monitors IDE diagnostic changes in real-time using language server protocols.
- * Implements smart filtering and debounced event handling to avoid excessive API calls.
- */
-export class DiagnosticsMonitor implements vscode.Disposable {
-    private readonly logger = getLogger()
-    private readonly diagnosticsChangeEmitter = new vscode.EventEmitter<DiagnosticCollection>()
-    private readonly disposables: vscode.Disposable[] = []
-    private debounceTimer: NodeJS.Timeout | undefined
-    private readonly debounceDelayMs = 500
-
-    public readonly onDiagnosticsChanged = this.diagnosticsChangeEmitter.event
-
-    constructor() {
-        this.disposables.push(
-            vscode.languages.onDidChangeDiagnostics((event) => {
-                this.handleDiagnosticChange(event)
-            })
-        )
-
-        this.disposables.push(this.diagnosticsChangeEmitter)
-    }
-
-    /**
-     * Gets current diagnostics with optional waiting for changes
-     */
-    public async getCurrentDiagnostics(shouldWaitForChanges: boolean = false): Promise<DiagnosticCollection> {
-        const currentDiagnostics = this.collectAllDiagnostics()
-
-        if (!shouldWaitForChanges) {
-            return currentDiagnostics
-        }
-
-        // Wait for diagnostic updates with timeout
-        return this.waitForUpdatedDiagnostics(5000) // 5 second timeout
-    }
-
-    /**
-     * Filters diagnostics by source (TypeScript, ESLint, etc.)
-     */
-    public filterBySource(diagnostics: DiagnosticCollection, sources: string[]): DiagnosticCollection {
-        const filteredDiagnostics: [vscode.Uri, vscode.Diagnostic[]][] = []
-
-        for (const [uri, fileDiagnostics] of diagnostics.diagnostics) {
-            const filtered = fileDiagnostics.filter(
-                (diagnostic) => !diagnostic.source || sources.includes(diagnostic.source)
-            )
-
-            if (filtered.length > 0) {
-                filteredDiagnostics.push([uri, filtered])
-            }
-        }
-
-        return {
-            diagnostics: filteredDiagnostics,
-            timestamp: diagnostics.timestamp,
-        }
-    }
-
-    /**
-     * Filters diagnostics by severity level
-     */
-    public filterBySeverity(
-        diagnostics: DiagnosticCollection,
-        severities: vscode.DiagnosticSeverity[]
-    ): DiagnosticCollection {
-        const filteredDiagnostics: [vscode.Uri, vscode.Diagnostic[]][] = []
-
-        for (const [uri, fileDiagnostics] of diagnostics.diagnostics) {
-            const filtered = fileDiagnostics.filter((diagnostic) => severities.includes(diagnostic.severity))
-
-            if (filtered.length > 0) {
-                filteredDiagnostics.push([uri, filtered])
-            }
-        }
-
-        return {
-            diagnostics: filteredDiagnostics,
-            timestamp: diagnostics.timestamp,
-        }
-    }
-
-    /**
-     * Captures a baseline snapshot of current diagnostics
-     */
-    public async captureBaseline(): Promise<DiagnosticSnapshot> {
-        const diagnostics = await this.getCurrentDiagnostics(false)
-        const snapshot: DiagnosticSnapshot = {
-            diagnostics,
-            captureTime: Date.now(),
-            id: this.generateSnapshotId(),
-        }
-        return snapshot
-    }
-
-    /**
-     * Gets only error-level diagnostics for critical issue detection
-     */
-    public getErrorDiagnostics(diagnostics: DiagnosticCollection): DiagnosticCollection {
-        return this.filterBySeverity(diagnostics, [vscode.DiagnosticSeverity.Error])
-    }
-
-    /**
-     * Gets warning-level diagnostics
-     */
-    public getWarningDiagnostics(diagnostics: DiagnosticCollection): DiagnosticCollection {
-        return this.filterBySeverity(diagnostics, [vscode.DiagnosticSeverity.Warning])
-    }
-
-    private handleDiagnosticChange(event: vscode.DiagnosticChangeEvent): void {
-        // Debounce diagnostic changes to avoid excessive processing
-        if (this.debounceTimer) {
-            clearTimeout(this.debounceTimer)
-        }
-
-        this.debounceTimer = setTimeout(() => {
-            this.processDiagnosticChange(event)
-        }, this.debounceDelayMs)
-    }
-
-    private processDiagnosticChange(event: vscode.DiagnosticChangeEvent): void {
-        try {
-        } catch (error) {
-            this.logger.error('DiagnosticsMonitor: Error processing diagnostic change: %s', error)
-        }
-    }
-
-    private collectAllDiagnostics(): DiagnosticCollection {
-        const allDiagnostics: [vscode.Uri, vscode.Diagnostic[]][] = []
-
-        // Get diagnostics from all sources
-        for (const [uri, diagnostics] of vscode.languages.getDiagnostics()) {
-            if (diagnostics.length > 0) {
-                allDiagnostics.push([uri, diagnostics])
-            }
-        }
-
-        return {
-            diagnostics: allDiagnostics,
-            timestamp: Date.now(),
-        }
-    }
-
-    private async waitForUpdatedDiagnostics(timeoutMs: number): Promise<DiagnosticCollection> {
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                disposable.dispose()
-                reject(
-                    new ToolkitError('Timeout waiting for diagnostic updates', {
-                        code: 'DiagnosticTimeout',
-                        details: { timeoutMs },
-                    })
-                )
-            }, timeoutMs)
-
-            const disposable = this.onDiagnosticsChanged((diagnostics) => {
-                clearTimeout(timeout)
-                disposable.dispose()
-                resolve(diagnostics)
-            })
-        })
-    }
-    private generateSnapshotId(): string {
-        return `snapshot_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-    }
-
-    public dispose(): void {
-        if (this.debounceTimer) {
-            clearTimeout(this.debounceTimer)
-        }
-
-        vscode.Disposable.from(...this.disposables).dispose()
-    }
-}

packages/amazonq/src/lsp/autoDebug/diagnostics/errorContext.ts

@@ -5,7 +5,6 @@
 
 import * as vscode from 'vscode'
 import * as path from 'path'
-import { getLogger } from 'aws-core-vscode/shared'
 import { Problem } from './problemDetector'
 
 export interface ErrorContext {
@@ -35,84 +34,6 @@ export interface FormattedErrorReport {
  * Formats diagnostic errors into contextual information for AI debugging assistance.
  */
 export class ErrorContextFormatter {
-    private readonly logger = getLogger()
-    /**
-     * Converts a Problem to detailed ErrorContext
-     */
-    public async createErrorContext(problem: Problem): Promise<ErrorContext> {
-        const surroundingCode = await this.extractSurroundingCode(problem.uri, problem.diagnostic.range)
-
-        const context: ErrorContext = {
-            source: problem.source,
-            severity: problem.severity,
-            location: {
-                file: path.relative(vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || '', problem.uri.fsPath),
-                line: problem.diagnostic.range.start.line + 1, // Convert from 0-indexed
-                column: problem.diagnostic.range.start.character + 1, // Convert from 0-indexed
-                range: problem.diagnostic.range,
-            },
-            message: problem.diagnostic.message,
-            code: problem.diagnostic.code?.toString(),
-            relatedInformation: problem.diagnostic.relatedInformation,
-            surroundingCode,
-        }
-        return context
-    }
-
-    /**
-     * Formats multiple error contexts into a comprehensive report
-     */
-    public formatErrorReport(contexts: ErrorContext[]): FormattedErrorReport {
-        const summary = this.createSummary(contexts)
-        const details = this.createDetails(contexts)
-        const contextualCode = this.createContextualCode(contexts)
-        const suggestions = this.createSuggestions(contexts)
-
-        return {
-            summary,
-            details,
-            contextualCode,
-            suggestions,
-        }
-    }
-
-    /**
-     * Formats a single error context for display
-     */
-    public formatSingleError(context: ErrorContext): string {
-        const parts = [
-            `**${context.severity.toUpperCase()}** in ${context.location.file}`,
-            `Line ${context.location.line}, Column ${context.location.column}`,
-            `Source: ${context.source}`,
-            context.code ? `Code: ${context.code}` : undefined,
-            '',
-            `**Message:** ${context.message}`,
-            '',
-        ].filter(Boolean)
-
-        if (context.surroundingCode) {
-            parts.push('**Code Context:**')
-            parts.push('```typescript')
-            parts.push(context.surroundingCode)
-            parts.push('```')
-            parts.push('')
-        }
-
-        if (context.relatedInformation && context.relatedInformation.length > 0) {
-            parts.push('**Related Information:**')
-            for (const info of context.relatedInformation) {
-                const relativeFile = path.relative(
-                    vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || '',
-                    info.location.uri.fsPath
-                )
-                parts.push(`- ${relativeFile}:${info.location.range.start.line + 1} - ${info.message}`)
-            }
-            parts.push('')
-        }
-
-        return parts.join('\n')
-    }
-
     /**
      * Creates a problems string with Markdown formatting for better readability
      */
@@ -138,105 +59,6 @@ export class ErrorContextFormatter {
         return result.trim()
     }
 
-    /**
-     * Extracts code context around a diagnostic range
-     */
-    private async extractSurroundingCode(uri: vscode.Uri, range: vscode.Range): Promise<string | undefined> {
-        try {
-            const document = await vscode.workspace.openTextDocument(uri)
-            const startLine = Math.max(0, range.start.line - 3)
-            const endLine = Math.min(document.lineCount - 1, range.end.line + 3)
-
-            const lines: string[] = []
-            for (let i = startLine; i <= endLine; i++) {
-                const lineText = document.lineAt(i).text
-                const lineNumber = (i + 1).toString().padStart(3, ' ')
-                const marker = i >= range.start.line && i <= range.end.line ? '>' : ' '
-                lines.push(`${lineNumber}${marker} ${lineText}`)
-            }
-
-            return lines.join('\n')
-        } catch (error) {
-            this.logger.warn('ErrorContextFormatter: Failed to extract surrounding code: %s', error)
-            return undefined
-        }
-    }
-
-    private createSummary(contexts: ErrorContext[]): string {
-        const errorCount = contexts.filter((c) => c.severity === 'error').length
-        const warningCount = contexts.filter((c) => c.severity === 'warning').length
-
-        const parts = []
-        if (errorCount > 0) {
-            parts.push(`${errorCount} error${errorCount !== 1 ? 's' : ''}`)
-        }
-        if (warningCount > 0) {
-            parts.push(`${warningCount} warning${warningCount !== 1 ? 's' : ''}`)
-        }
-
-        return `Found ${parts.join(' and ')} in your code`
-    }
-
-    private createDetails(contexts: ErrorContext[]): string {
-        return contexts.map((context) => this.formatSingleError(context)).join('\n---\n\n')
-    }
-
-    private createContextualCode(contexts: ErrorContext[]): string {
-        const codeBlocks = contexts
-            .filter((context) => context.surroundingCode)
-            .map((context) => `**${context.location.file}:**\n\`\`\`typescript\n${context.surroundingCode}\n\`\`\``)
-
-        return codeBlocks.join('\n\n')
-    }
-
-    private createSuggestions(contexts: ErrorContext[]): string {
-        const suggestions = []
-
-        // Group by error type for better suggestions
-        const errorTypes = new Map<string, ErrorContext[]>()
-        for (const context of contexts) {
-            const key = context.source || 'unknown'
-            if (!errorTypes.has(key)) {
-                errorTypes.set(key, [])
-            }
-            errorTypes.get(key)!.push(context)
-        }
-
-        for (const [source, sourceContexts] of errorTypes) {
-            suggestions.push(`**${source} Issues (${sourceContexts.length}):**`)
-            suggestions.push(this.generateSourceSpecificSuggestions(source, sourceContexts))
-        }
-
-        return suggestions.join('\n\n')
-    }
-
-    private generateSourceSpecificSuggestions(source: string, contexts: ErrorContext[]): string {
-        // Basic suggestions based on common error patterns
-        const suggestions = []
-
-        if (source.includes('typescript') || source.includes('ts')) {
-            suggestions.push('- Check type definitions and imports')
-            suggestions.push('- Verify function signatures and return types')
-        }
-
-        if (source.includes('eslint')) {
-            suggestions.push('- Review code style and formatting')
-            suggestions.push('- Check for unused variables and imports')
-        }
-
-        if (contexts.some((c) => c.message.includes('Cannot find module'))) {
-            suggestions.push('- Verify module installation: npm install or yarn install')
-            suggestions.push('- Check import paths and module names')
-        }
-
-        if (contexts.some((c) => c.message.includes('is not assignable'))) {
-            suggestions.push('- Review type compatibility')
-            suggestions.push('- Consider type assertions or interface updates')
-        }
-
-        return suggestions.length > 0 ? suggestions.join('\n') : '- Review the specific error messages above'
-    }
-
     private groupProblemsByFile(problems: Problem[]): Map<string, Problem[]> {
         const groups = new Map<string, Problem[]>()