@su-record/vibe 0.1.0

package/mcp/dist/tools/browser/inspectNetworkRequests.js

@@ -0,0 +1,140 @@
+// Browser development tool - completely independent
+import puppeteer from 'puppeteer-core';
+import { getBrowserLaunchOptions } from './browserUtils.js';
+export const inspectNetworkRequestsDefinition = {
+    name: 'inspect_network_requests',
+    description: '네트워크|API 호출|요청 확인|network|API calls|check requests|network traffic - Inspect network requests',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'URL to inspect' },
+            filterType: { type: 'string', description: 'Request type filter', enum: ['all', 'xhr', 'fetch', 'websocket', 'failed'] },
+            includeHeaders: { type: 'boolean', description: 'Include request/response headers' }
+        },
+        required: ['url']
+    },
+    annotations: {
+        title: 'Inspect Network Requests',
+        audience: ['user', 'assistant']
+    }
+};
+export async function inspectNetworkRequests(args) {
+    const { url: inspectUrl, filterType = 'all', includeHeaders = false } = args;
+    try {
+        // Get browser launch options with proper executable path
+        const launchOptions = getBrowserLaunchOptions();
+        const browser = await puppeteer.launch(launchOptions);
+        const page = await browser.newPage();
+        const networkRequests = [];
+        let requestId = 0;
+        const requestTimings = new Map();
+        // Capture network requests
+        page.on('request', request => {
+            const startTime = Date.now();
+            const id = `req_${String(requestId++).padStart(3, '0')}`;
+            const requestUrl = request.url();
+            requestTimings.set(requestUrl, startTime);
+            networkRequests.push({
+                id,
+                url: requestUrl,
+                method: request.method(),
+                type: request.resourceType(),
+                responseTime: 0,
+                size: 0,
+                timestamp: new Date().toISOString(),
+                headers: includeHeaders ? {
+                    request: request.headers()
+                } : undefined
+            });
+        });
+        page.on('response', async (response) => {
+            const requestUrl = response.url();
+            const request = networkRequests.find(req => req.url === requestUrl);
+            const startTime = requestTimings.get(requestUrl);
+            if (request) {
+                request.status = response.status();
+                request.statusText = response.statusText();
+                request.responseTime = startTime ? Date.now() - startTime : 0;
+                request.failed = !response.ok();
+                if (includeHeaders && request.headers) {
+                    request.headers.response = response.headers();
+                }
+                // Estimate response size
+                try {
+                    const buffer = await response.buffer();
+                    request.size = buffer.length;
+                }
+                catch {
+                    request.size = 0;
+                }
+            }
+        });
+        page.on('requestfailed', request => {
+            const requestUrl = request.url();
+            const failedRequest = networkRequests.find(req => req.url === requestUrl);
+            if (failedRequest) {
+                failedRequest.failed = true;
+                failedRequest.status = 0;
+                failedRequest.statusText = request.failure()?.errorText || 'Failed';
+            }
+        });
+        // Navigate to URL and wait for network to be idle
+        await page.goto(inspectUrl, { waitUntil: 'networkidle0', timeout: 30000 });
+        // Wait a bit for any remaining requests
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        await browser.close();
+        const filteredRequests = networkRequests.filter(req => {
+            switch (filterType) {
+                case 'xhr':
+                    return req.type === 'xhr';
+                case 'fetch':
+                    return req.type === 'fetch';
+                case 'websocket':
+                    return req.type === 'websocket';
+                case 'failed':
+                    return req.failed || (req.status !== undefined && req.status >= 400);
+                default:
+                    return true;
+            }
+        });
+        const networkInspectionResult = {
+            action: 'inspect_network_requests',
+            url: inspectUrl,
+            filterType,
+            includeHeaders,
+            requests: filteredRequests,
+            summary: {
+                totalRequests: filteredRequests.length,
+                successful: filteredRequests.filter(r => r.status !== undefined && r.status >= 200 && r.status < 300).length,
+                failed: filteredRequests.filter(r => r.failed || (r.status !== undefined && r.status >= 400)).length,
+                averageResponseTime: filteredRequests.reduce((sum, r) => sum + r.responseTime, 0) / filteredRequests.length,
+                totalDataTransferred: filteredRequests.reduce((sum, r) => sum + r.size, 0),
+                requestTypes: {
+                    xhr: filteredRequests.filter(r => r.type === 'xhr').length,
+                    fetch: filteredRequests.filter(r => r.type === 'fetch').length,
+                    websocket: filteredRequests.filter(r => r.type === 'websocket').length
+                }
+            },
+            status: 'success'
+        };
+        // Compact summary format
+        const failed = filteredRequests.filter(r => r.failed || (r.status !== undefined && r.status >= 400));
+        const errorSummary = failed.length > 0
+            ? `\nErrors: ${failed.slice(0, 3).map(r => `${r.method} ${new URL(r.url).pathname} (${r.status})`).join(', ')}${failed.length > 3 ? ` +${failed.length - 3}` : ''}`
+            : '';
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${networkInspectionResult.summary.totalRequests} reqs | ${networkInspectionResult.summary.successful} OK, ${networkInspectionResult.summary.failed} fail | Avg: ${networkInspectionResult.summary.averageResponseTime.toFixed(0)}ms | ${(networkInspectionResult.summary.totalDataTransferred / 1024).toFixed(1)}KB${errorSummary}`
+                }]
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        const helpMessage = errorMessage.includes('Chrome') ?
+            '\n\nTroubleshooting:\n1. Install Chrome: https://www.google.com/chrome/\n2. Or set CHROME_PATH environment variable\n3. Or install puppeteer instead of puppeteer-core' : '';
+        return {
+            content: [{ type: 'text', text: `Error inspecting network requests: ${errorMessage}${helpMessage}` }]
+        };
+    }
+}

package/mcp/dist/tools/browser/monitorConsoleLogs.js

@@ -0,0 +1,97 @@
+// Browser development tool - completely independent
+import puppeteer from 'puppeteer-core';
+import { getBrowserLaunchOptions } from './browserUtils.js';
+export const monitorConsoleLogsDefinition = {
+    name: 'monitor_console_logs',
+    description: '콘솔 로그|에러 확인|로그 봐줘|console|check logs|debug output|console errors - Monitor browser console',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'URL to monitor' },
+            logLevel: { type: 'string', description: 'Log level to capture', enum: ['all', 'error', 'warn', 'info', 'debug'] },
+            duration: { type: 'number', description: 'Monitoring duration in seconds' }
+        },
+        required: ['url']
+    },
+    annotations: {
+        title: 'Monitor Console Logs',
+        audience: ['user', 'assistant']
+    }
+};
+export async function monitorConsoleLogs(args) {
+    const { url: monitorUrl, logLevel = 'all', duration = 30 } = args;
+    try {
+        // Get browser launch options with proper executable path
+        const launchOptions = getBrowserLaunchOptions();
+        const browser = await puppeteer.launch(launchOptions);
+        const page = await browser.newPage();
+        const logs = [];
+        // Capture console events
+        page.on('console', msg => {
+            const msgLevel = msg.type();
+            if (logLevel === 'all' || msgLevel === logLevel) {
+                logs.push({
+                    timestamp: new Date().toISOString(),
+                    level: msgLevel,
+                    message: msg.text(),
+                    source: msg.location()?.url || 'unknown'
+                });
+            }
+        });
+        // Capture page errors
+        page.on('pageerror', error => {
+            if (logLevel === 'all' || logLevel === 'error') {
+                logs.push({
+                    timestamp: new Date().toISOString(),
+                    level: 'error',
+                    message: error.message,
+                    source: error.stack?.split('\n')[0] || 'unknown'
+                });
+            }
+        });
+        // Navigate to URL and wait for specified duration
+        await page.goto(monitorUrl, { waitUntil: 'networkidle0', timeout: 30000 });
+        await new Promise(resolve => setTimeout(resolve, duration * 1000));
+        await browser.close();
+        const consoleMonitorResult = {
+            action: 'monitor_console_logs',
+            url: monitorUrl,
+            logLevel,
+            duration,
+            capturedLogs: logs,
+            summary: {
+                totalLogs: logs.length,
+                errors: logs.filter(l => l.level === 'error').length,
+                warnings: logs.filter(l => l.level === 'warn').length,
+                infos: logs.filter(l => l.level === 'info').length,
+                debugs: logs.filter(l => l.level === 'debug').length,
+                logs: logs.filter(l => l.level === 'log').length
+            },
+            monitoringStatus: 'completed',
+            status: 'success'
+        };
+        // Compact summary with errors only
+        const errors = logs.filter(l => l.level === 'error');
+        const warnings = logs.filter(l => l.level === 'warn');
+        const errorSummary = errors.length > 0
+            ? `\nErrors: ${errors.slice(0, 3).map(l => l.message.substring(0, 50)).join(', ')}${errors.length > 3 ? ` +${errors.length - 3}` : ''}`
+            : '';
+        const warnSummary = warnings.length > 0 && errors.length === 0
+            ? `\nWarnings: ${warnings.slice(0, 3).map(l => l.message.substring(0, 50)).join(', ')}${warnings.length > 3 ? ` +${warnings.length - 3}` : ''}`
+            : '';
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${logs.length} logs | ${consoleMonitorResult.summary.errors}E ${consoleMonitorResult.summary.warnings}W ${consoleMonitorResult.summary.infos}I | ${duration}s${errorSummary}${warnSummary}`
+                }]
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        const helpMessage = errorMessage.includes('Chrome') ?
+            '\n\nTroubleshooting:\n1. Install Chrome: https://www.google.com/chrome/\n2. Or set CHROME_PATH environment variable\n3. Or install puppeteer instead of puppeteer-core' : '';
+        return {
+            content: [{ type: 'text', text: `Error monitoring console logs: ${errorMessage}${helpMessage}` }]
+        };
+    }
+}

package/mcp/dist/tools/convention/analyzeComplexity.js

@@ -0,0 +1,248 @@
+// Convention management tool - completely independent
+import { Project, ScriptKind } from "ts-morph";
+import { PythonParser } from '../../lib/PythonParser.js';
+// Reusable in-memory project to avoid re-parsing standard lib every call
+const AST_PROJECT = new Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: { allowJs: true, skipLibCheck: true }
+});
+// Enhanced Software Engineering Metrics
+const CODE_QUALITY_METRICS = {
+    COMPLEXITY: {
+        maxCyclomaticComplexity: 10,
+        maxCognitiveComplexity: 15,
+        maxFunctionLines: 20,
+        maxNestingDepth: 3,
+        maxParameters: 5
+    },
+    COUPLING: {
+        maxDependencies: 7,
+        maxFanOut: 5,
+        preventCircularDeps: true
+    },
+    COHESION: {
+        singleResponsibility: true,
+        relatedFunctionsOnly: true
+    },
+    MAINTAINABILITY: {
+        noMagicNumbers: true,
+        consistentNaming: true,
+        properErrorHandling: true,
+        typesSafety: true
+    },
+    PERFORMANCE: {
+        memoizeExpensiveCalc: true,
+        lazyLoading: true,
+        batchOperations: true
+    }
+};
+export const analyzeComplexityDefinition = {
+    name: 'analyze_complexity',
+    description: '복잡도|복잡한지|complexity|how complex|난이도 - Analyze code complexity',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            code: { type: 'string', description: 'Code to analyze' },
+            metrics: { type: 'string', description: 'Metrics to calculate', enum: ['cyclomatic', 'cognitive', 'halstead', 'all'] }
+        },
+        required: ['code']
+    },
+    annotations: {
+        title: 'Analyze Complexity',
+        audience: ['user', 'assistant']
+    }
+};
+/**
+ * Calculate cognitive complexity (how hard code is to understand)
+ */
+function calculateCognitiveComplexity(code) {
+    const CONTROL_STRUCTURES = ['if', 'for', 'while'];
+    let cognitiveScore = 0;
+    const lines = code.split('\n');
+    let nestingLevel = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Increment for control structures
+        if (CONTROL_STRUCTURES.some(keyword => trimmed.includes(keyword))) {
+            cognitiveScore += 1 + nestingLevel;
+        }
+        // Increment for catch/switch
+        if (trimmed.includes('catch') || trimmed.includes('switch')) {
+            cognitiveScore += 1 + nestingLevel;
+        }
+        // Update nesting level
+        const openBraces = (line.match(/\{/g) || []).length;
+        const closeBraces = (line.match(/\}/g) || []).length;
+        nestingLevel = Math.max(0, nestingLevel + openBraces - closeBraces);
+    }
+    const threshold = CODE_QUALITY_METRICS.COMPLEXITY.maxCognitiveComplexity;
+    return {
+        value: cognitiveScore,
+        threshold,
+        status: cognitiveScore <= threshold ? 'pass' : 'fail',
+        description: 'How difficult the code is to understand'
+    };
+}
+/**
+ * Calculate AST-based cyclomatic complexity
+ */
+function calculateAstComplexity(code) {
+    const CONTROL_FLOW_NODES = [
+        'IfStatement', 'ForStatement', 'ForOfStatement', 'ForInStatement',
+        'WhileStatement', 'CaseClause', 'ConditionalExpression',
+        'DoStatement', 'CatchClause', 'BinaryExpression'
+    ];
+    let astCyclomatic = 1;
+    try {
+        const sourceFile = AST_PROJECT.createSourceFile('temp.ts', code, {
+            overwrite: true,
+            scriptKind: ScriptKind.TS
+        });
+        sourceFile.forEachDescendant((node) => {
+            if (CONTROL_FLOW_NODES.includes(node.getKindName())) {
+                astCyclomatic++;
+            }
+        });
+        const threshold = CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity;
+        return {
+            value: astCyclomatic,
+            threshold,
+            status: astCyclomatic <= threshold ? 'pass' : 'fail',
+            description: 'AST 기반 분기/조건문 수를 통한 cyclomatic complexity'
+        };
+    }
+    catch (e) {
+        return {
+            value: null,
+            status: 'error',
+            description: 'AST 분석 실패: ' + (e instanceof Error ? e.message : String(e))
+        };
+    }
+}
+/**
+ * Analyze Python code complexity
+ */
+async function analyzePythonComplexity(code) {
+    try {
+        const pythonComplexity = await PythonParser.analyzeComplexity(code);
+        const totalComplexity = pythonComplexity.cyclomaticComplexity;
+        const issues = [];
+        const MAX_COMPLEXITY = 10;
+        if (totalComplexity > MAX_COMPLEXITY) {
+            issues.push('High complexity');
+        }
+        pythonComplexity.functions.forEach(f => {
+            if (f.complexity > MAX_COMPLEXITY) {
+                issues.push(`Function ${f.name}: complexity ${f.complexity}`);
+            }
+        });
+        const issuesText = issues.length ? `\nIssues: ${issues.join(', ')}` : '';
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Python Complexity: ${totalComplexity}\nFunctions: ${pythonComplexity.functions.length}\nClasses: ${pythonComplexity.classes.length}${issuesText}`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Python analysis error: ${error instanceof Error ? error.message : 'Unknown error'}`
+                }]
+        };
+    }
+}
+export async function analyzeComplexity(args) {
+    const { code: complexityCode, metrics: complexityMetrics = 'all' } = args;
+    // Check if this is Python code
+    if (PythonParser.isPythonCode(complexityCode)) {
+        return analyzePythonComplexity(complexityCode);
+    }
+    const complexityAnalysis = {
+        action: 'analyze_complexity',
+        metrics: complexityMetrics,
+        results: {},
+        overallScore: 0,
+        issues: [],
+        recommendations: [],
+        status: 'pending'
+    };
+    // AST 기반 cyclomatic complexity 분석
+    complexityAnalysis.results.astCyclomaticComplexity = calculateAstComplexity(complexityCode);
+    if (complexityMetrics === 'cyclomatic' || complexityMetrics === 'all') {
+        const cyclomaticComplexityScore = (complexityCode.match(/\bif\b|\bfor\b|\bwhile\b|\bcase\b|\b&&\b|\b\|\|\b/g) || []).length + 1;
+        complexityAnalysis.results.cyclomaticComplexity = {
+            value: cyclomaticComplexityScore,
+            threshold: CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity,
+            status: cyclomaticComplexityScore <= CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity ? 'pass' : 'fail',
+            description: 'Number of linearly independent paths through the code'
+        };
+    }
+    if (complexityMetrics === 'cognitive' || complexityMetrics === 'all') {
+        complexityAnalysis.results.cognitiveComplexity = calculateCognitiveComplexity(complexityCode);
+    }
+    if (complexityMetrics === 'halstead' || complexityMetrics === 'all') {
+        // Halstead metrics calculation (simplified version)
+        const operators = (complexityCode.match(/[+\-*/=<>!&|%^~?:]/g) || []).length;
+        const operands = (complexityCode.match(/\b[a-zA-Z_]\w*\b/g) || []).length;
+        const uniqueOperators = new Set(complexityCode.match(/[+\-*/=<>!&|%^~?:]/g) || []).size;
+        const uniqueOperands = new Set(complexityCode.match(/\b[a-zA-Z_]\w*\b/g) || []).size;
+        const vocabulary = uniqueOperators + uniqueOperands;
+        const length = operators + operands;
+        const calculatedLength = vocabulary > 0 ? uniqueOperators * Math.log2(uniqueOperators) + uniqueOperands * Math.log2(uniqueOperands) : 0;
+        const volume = length * Math.log2(vocabulary);
+        const difficulty = vocabulary > 0 ? (uniqueOperators / 2) * (operands / uniqueOperands) : 0;
+        const effort = difficulty * volume;
+        complexityAnalysis.results.halsteadMetrics = {
+            vocabulary: vocabulary,
+            length: length,
+            calculatedLength: Math.round(calculatedLength),
+            volume: Math.round(volume),
+            difficulty: Math.round(difficulty * 100) / 100,
+            effort: Math.round(effort),
+            timeToProgram: Math.round(effort / 18), // Halstead's formula: effort / 18 seconds
+            bugsDelivered: Math.round(volume / 3000 * 100) / 100, // Halstead's formula: volume / 3000
+            description: 'Software science metrics measuring program complexity'
+        };
+    }
+    // Additional complexity metrics
+    if (complexityMetrics === 'all') {
+        const lines = complexityCode.split('\n');
+        const nonEmptyLines = lines.filter(line => line.trim().length > 0).length;
+        const comments = (complexityCode.match(/\/\*[\s\S]*?\*\/|\/\/.*$/gm) || []).length;
+        const functions = (complexityCode.match(/function\s+\w+|\w+\s*=\s*\(/g) || []).length;
+        const classes = (complexityCode.match(/class\s+\w+/g) || []).length;
+        complexityAnalysis.results.additionalMetrics = {
+            linesOfCode: nonEmptyLines,
+            comments: comments,
+            commentRatio: nonEmptyLines > 0 ? Math.round((comments / nonEmptyLines) * 100) / 100 : 0,
+            functions: functions,
+            classes: classes,
+            averageFunctionLength: functions > 0 ? Math.round(nonEmptyLines / functions) : 0
+        };
+    }
+    // Overall assessment
+    const issues = [];
+    let overallScore = 100;
+    if (complexityAnalysis.results.cyclomaticComplexity && complexityAnalysis.results.cyclomaticComplexity.status === 'fail') {
+        issues.push('High cyclomatic complexity detected');
+        overallScore -= 20;
+    }
+    if (complexityAnalysis.results.cognitiveComplexity && complexityAnalysis.results.cognitiveComplexity.status === 'fail') {
+        issues.push('High cognitive complexity detected');
+        overallScore -= 25;
+    }
+    if (complexityAnalysis.results.halsteadMetrics && complexityAnalysis.results.halsteadMetrics.difficulty > 10) {
+        issues.push('High Halstead difficulty detected');
+        overallScore -= 15;
+    }
+    complexityAnalysis.overallScore = Math.max(0, overallScore);
+    complexityAnalysis.issues = issues;
+    return {
+        content: [{
+                type: 'text',
+                text: `Complexity: ${complexityAnalysis.results.astCyclomaticComplexity?.value ?? 'N/A'}\nScore: ${complexityAnalysis.overallScore}${issues.length ? '\nIssues: ' + issues.join(', ') : ''}`
+            }]
+    };
+}

package/mcp/dist/tools/convention/applyQualityRules.js

@@ -0,0 +1,102 @@
+// Convention management tool - completely independent
+// Code Quality Standards
+const QUALITY_RULES = {
+    NAMING: {
+        variables: 'nouns (userList, userData)',
+        functions: 'verb+noun (fetchData, updateUser)',
+        events: 'handle prefix (handleClick, handleSubmit)',
+        booleans: 'is/has/can prefix (isLoading, hasError, canEdit)',
+        constants: 'UPPER_SNAKE_CASE (MAX_RETRY_COUNT, API_TIMEOUT)',
+        components: 'PascalCase (UserProfile, HeaderSection)',
+        hooks: 'use prefix (useUserData, useAuth)'
+    },
+    STRUCTURE: {
+        componentOrder: ['State & Refs', 'Custom Hooks', 'Event Handlers', 'Effects', 'Early returns', 'Main return JSX'],
+        functionMaxLines: 20,
+        componentMaxLines: 50,
+        maxNestingDepth: 3
+    },
+    ANTIPATTERNS: {
+        typescript: ['any type usage', '@ts-ignore usage', 'as any casting'],
+        react: ['dangerouslySetInnerHTML', 'props drilling (3+ levels)'],
+        javascript: ['var usage', '== instead of ===', 'eval() usage'],
+        css: ['!important abuse', 'inline style abuse']
+    },
+    ASYNC_STATES: ['data', 'isLoading', 'error'],
+    STATE_MANAGEMENT: {
+        simple: 'useState',
+        complex: 'useReducer',
+        globalUI: 'Context API',
+        globalApp: 'Zustand',
+        server: 'TanStack Query'
+    }
+};
+export const applyQualityRulesDefinition = {
+    name: 'apply_quality_rules',
+    description: '규칙 적용|표준 적용|apply rules|apply standards|follow conventions|적용해 - Apply quality rules',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            scope: { type: 'string', description: 'Application scope', enum: ['naming', 'structure', 'typescript', 'react', 'accessibility', 'all'] },
+            language: { type: 'string', description: 'Programming language context', enum: ['javascript', 'typescript', 'react', 'vue', 'general'] }
+        },
+        required: ['scope']
+    },
+    annotations: {
+        title: 'Apply Quality Rules',
+        audience: ['user', 'assistant']
+    }
+};
+export async function applyQualityRules(args) {
+    const { scope, language: contextLanguage = 'general' } = args;
+    const applicableRules = [];
+    if (scope === 'naming' || scope === 'all') {
+        applicableRules.push({
+            category: 'Naming Conventions',
+            rules: QUALITY_RULES.NAMING
+        });
+    }
+    if (scope === 'structure' || scope === 'all') {
+        applicableRules.push({
+            category: 'Code Structure',
+            rules: QUALITY_RULES.STRUCTURE
+        });
+    }
+    if (scope === 'typescript' || scope === 'all') {
+        applicableRules.push({
+            category: 'TypeScript Guidelines',
+            rules: QUALITY_RULES.ANTIPATTERNS.typescript
+        });
+    }
+    if (scope === 'react' || scope === 'all') {
+        applicableRules.push({
+            category: 'React Guidelines',
+            rules: QUALITY_RULES.ANTIPATTERNS.react
+        });
+    }
+    if (scope === 'accessibility' || scope === 'all') {
+        applicableRules.push({
+            category: 'Accessibility Guidelines',
+            rules: [
+                'Use semantic HTML elements',
+                'Provide alt text for images',
+                'Ensure keyboard navigation',
+                'Maintain color contrast ratios',
+                'Use ARIA labels when needed'
+            ]
+        });
+    }
+    const qualityRulesResult = {
+        action: 'apply_quality_rules',
+        scope,
+        language: contextLanguage,
+        rules: applicableRules,
+        asyncStates: QUALITY_RULES.ASYNC_STATES,
+        stateManagement: QUALITY_RULES.STATE_MANAGEMENT,
+        status: 'success'
+    };
+    const rulesSummary = applicableRules.map(r => `${r.category}: ${Array.isArray(r.rules) ? r.rules.length + ' rules' : Object.keys(r.rules).length + ' items'}`).join(', ');
+    return {
+        content: [{ type: 'text', text: `Scope: ${scope}\nLanguage: ${contextLanguage}\nRules Applied: ${rulesSummary}\n\nAsync States: ${QUALITY_RULES.ASYNC_STATES.join(', ')}\n\nState Mgmt:\n${Object.entries(QUALITY_RULES.STATE_MANAGEMENT).map(([k, v]) => `- ${k}: ${v}`).join('\n')}` }]
+    };
+}