@jshookmcp/jshook 0.1.7 → 0.1.9

package/dist/modules/analyzer/QualityAnalyzer.js

@@ -1,433 +0,0 @@
-import * as parser from '@babel/parser';
-import traverse from '@babel/traverse';
-import * as t from '@babel/types';
-import { logger } from '../../utils/logger.js';
-export function calculateQualityScore(structure, securityRisks, aiAnalysis, complexityMetrics, antiPatterns) {
-    let score = 100;
-    let securityScore = 100;
-    securityRisks.forEach((risk) => {
-        if (risk.severity === 'critical')
-            securityScore -= 20;
-        else if (risk.severity === 'high')
-            securityScore -= 10;
-        else if (risk.severity === 'medium')
-            securityScore -= 5;
-        else
-            securityScore -= 2;
-    });
-    securityScore = Math.max(0, securityScore);
-    let complexityScore = 100;
-    if (complexityMetrics) {
-        if (complexityMetrics.cyclomaticComplexity > 20)
-            complexityScore -= 30;
-        else if (complexityMetrics.cyclomaticComplexity > 10)
-            complexityScore -= 15;
-        else if (complexityMetrics.cyclomaticComplexity > 5)
-            complexityScore -= 5;
-        if (complexityMetrics.cognitiveComplexity > 15)
-            complexityScore -= 20;
-        else if (complexityMetrics.cognitiveComplexity > 10)
-            complexityScore -= 10;
-    }
-    else {
-        const avgComplexity = structure.functions.reduce((sum, fn) => sum + fn.complexity, 0) /
-            (structure.functions.length || 1);
-        if (avgComplexity > 10)
-            complexityScore -= 20;
-        else if (avgComplexity > 5)
-            complexityScore -= 10;
-    }
-    complexityScore = Math.max(0, complexityScore);
-    let maintainabilityScore = complexityMetrics?.maintainabilityIndex || 70;
-    let codeSmellScore = 100;
-    if (antiPatterns) {
-        antiPatterns.forEach((pattern) => {
-            if (pattern.severity === 'high')
-                codeSmellScore -= 10;
-            else if (pattern.severity === 'medium')
-                codeSmellScore -= 5;
-            else
-                codeSmellScore -= 2;
-        });
-    }
-    codeSmellScore = Math.max(0, codeSmellScore);
-    let aiScore = 70;
-    if (typeof aiAnalysis.qualityScore === 'number') {
-        aiScore = aiAnalysis.qualityScore;
-    }
-    score =
-        securityScore * 0.4 +
-            complexityScore * 0.25 +
-            maintainabilityScore * 0.2 +
-            codeSmellScore * 0.15;
-    if (typeof aiAnalysis.qualityScore === 'number') {
-        score = (score + aiScore) / 2;
-    }
-    return Math.round(Math.max(0, Math.min(100, score)));
-}
-export function detectCodePatterns(code) {
-    const patterns = [];
-    const antiPatterns = [];
-    try {
-        const ast = parser.parse(code, {
-            sourceType: 'module',
-            plugins: ['jsx', 'typescript'],
-        });
-        traverse(ast, {
-            VariableDeclarator(path) {
-                const init = path.node.init;
-                if (t.isCallExpression(init) &&
-                    t.isFunctionExpression(init.callee) &&
-                    init.callee.body.body.some((stmt) => t.isReturnStatement(stmt) && t.isObjectExpression(stmt.argument))) {
-                    patterns.push({
-                        name: 'Singleton Pattern',
-                        location: path.node.loc?.start.line || 0,
-                        description: 'IIFE returning object (Singleton pattern)',
-                    });
-                }
-            },
-            ClassDeclaration(path) {
-                const methods = path.node.body.body.filter((m) => t.isClassMethod(m));
-                const methodNames = methods.map((m) => t.isClassMethod(m) && t.isIdentifier(m.key) ? m.key.name : '');
-                if (methodNames.includes('subscribe') &&
-                    methodNames.includes('unsubscribe') &&
-                    methodNames.includes('notify')) {
-                    patterns.push({
-                        name: 'Observer Pattern',
-                        location: path.node.loc?.start.line || 0,
-                        description: 'Class with subscribe/unsubscribe/notify methods',
-                    });
-                }
-            },
-            FunctionDeclaration(path) {
-                const loc = path.node.loc;
-                if (loc) {
-                    const lines = loc.end.line - loc.start.line;
-                    if (lines > 50) {
-                        antiPatterns.push({
-                            name: 'Long Function',
-                            location: loc.start.line,
-                            severity: 'medium',
-                            recommendation: `Function is ${lines} lines long. Consider breaking it into smaller functions (max 50 lines)`,
-                        });
-                    }
-                }
-            },
-            IfStatement(path) {
-                let depth = 0;
-                let current = path.parentPath;
-                while (current) {
-                    if (current.isIfStatement() || current.isForStatement() || current.isWhileStatement()) {
-                        depth++;
-                    }
-                    current = current.parentPath;
-                }
-                if (depth > 3) {
-                    antiPatterns.push({
-                        name: 'Deep Nesting',
-                        location: path.node.loc?.start.line || 0,
-                        severity: 'medium',
-                        recommendation: `Nesting depth is ${depth}. Consider extracting to separate functions or using early returns`,
-                    });
-                }
-            },
-            NumericLiteral(path) {
-                const value = path.node.value;
-                const parent = path.parent;
-                const commonNumbers = [0, 1, -1, 2, 10, 100, 1000];
-                if (commonNumbers.includes(value))
-                    return;
-                if (t.isMemberExpression(parent) && parent.property === path.node)
-                    return;
-                if (t.isAssignmentPattern(parent))
-                    return;
-                antiPatterns.push({
-                    name: 'Magic Number',
-                    location: path.node.loc?.start.line || 0,
-                    severity: 'low',
-                    recommendation: `Replace magic number ${value} with a named constant`,
-                });
-            },
-            CatchClause(path) {
-                const body = path.node.body.body;
-                if (body.length === 0) {
-                    antiPatterns.push({
-                        name: 'Empty Catch Block',
-                        location: path.node.loc?.start.line || 0,
-                        severity: 'high',
-                        recommendation: 'Empty catch block swallows errors. Add proper error handling or logging',
-                    });
-                }
-            },
-            VariableDeclaration(path) {
-                if (path.node.kind === 'var') {
-                    antiPatterns.push({
-                        name: 'Use of var',
-                        location: path.node.loc?.start.line || 0,
-                        severity: 'low',
-                        recommendation: 'Use let or const instead of var for better scoping',
-                    });
-                }
-            },
-        });
-        const duplicates = detectDuplicateCode(ast);
-        duplicates.forEach((dup) => {
-            antiPatterns.push({
-                name: 'Duplicate Code',
-                location: dup.location,
-                severity: 'medium',
-                recommendation: `Duplicate code found at lines ${dup.location} and ${dup.duplicateLocation}. Extract into a reusable function.`,
-            });
-        });
-    }
-    catch (error) {
-        logger.warn('Code pattern detection failed', error);
-    }
-    return { patterns, antiPatterns };
-}
-export function analyzeComplexityMetrics(code) {
-    let cyclomaticComplexity = 1;
-    let cognitiveComplexity = 0;
-    let operators = 0;
-    let operands = 0;
-    const uniqueOperators = new Set();
-    const uniqueOperands = new Set();
-    try {
-        const ast = parser.parse(code, {
-            sourceType: 'module',
-            plugins: ['jsx', 'typescript'],
-        });
-        let nestingLevel = 0;
-        traverse(ast, {
-            IfStatement() {
-                cyclomaticComplexity++;
-            },
-            SwitchCase() {
-                cyclomaticComplexity++;
-            },
-            ForStatement() {
-                cyclomaticComplexity++;
-            },
-            WhileStatement() {
-                cyclomaticComplexity++;
-            },
-            DoWhileStatement() {
-                cyclomaticComplexity++;
-            },
-            ConditionalExpression() {
-                cyclomaticComplexity++;
-            },
-            LogicalExpression(path) {
-                if (path.node.operator === '&&' || path.node.operator === '||') {
-                    cyclomaticComplexity++;
-                }
-            },
-            CatchClause() {
-                cyclomaticComplexity++;
-            },
-            'IfStatement|ForStatement|WhileStatement|DoWhileStatement': {
-                enter() {
-                    nestingLevel++;
-                    cognitiveComplexity += nestingLevel;
-                },
-                exit() {
-                    nestingLevel--;
-                },
-            },
-            BinaryExpression(path) {
-                operators++;
-                uniqueOperators.add(path.node.operator);
-            },
-            UnaryExpression(path) {
-                operators++;
-                uniqueOperators.add(path.node.operator);
-            },
-            Identifier(path) {
-                operands++;
-                uniqueOperands.add(path.node.name);
-            },
-            NumericLiteral(path) {
-                operands++;
-                uniqueOperands.add(String(path.node.value));
-            },
-            StringLiteral(path) {
-                operands++;
-                uniqueOperands.add(path.node.value);
-            },
-        });
-    }
-    catch (error) {
-        logger.warn('Complexity metrics calculation failed', error);
-    }
-    const n1 = uniqueOperators.size;
-    const n2 = uniqueOperands.size;
-    const N1 = operators;
-    const N2 = operands;
-    const vocabulary = n1 + n2;
-    const length = N1 + N2;
-    const difficulty = (n1 / 2) * (N2 / (n2 || 1));
-    const effort = difficulty * length;
-    const volume = length * Math.log2(vocabulary || 1);
-    const loc = code.split('\n').length;
-    const maintainabilityIndex = Math.max(0, 171 - 5.2 * Math.log(volume || 1) - 0.23 * cyclomaticComplexity - 16.2 * Math.log(loc));
-    return {
-        cyclomaticComplexity,
-        cognitiveComplexity,
-        maintainabilityIndex: Math.round(maintainabilityIndex),
-        halsteadMetrics: {
-            vocabulary,
-            length,
-            difficulty: Math.round(difficulty * 100) / 100,
-            effort: Math.round(effort),
-        },
-    };
-}
-export function detectDuplicateCode(ast) {
-    const duplicates = [];
-    const codeBlocks = [];
-    try {
-        traverse(ast, {
-            FunctionDeclaration(path) {
-                const hash = computeASTHash(path.node);
-                const normalized = normalizeCode(path.node);
-                codeBlocks.push({
-                    node: path.node,
-                    hash,
-                    location: path.node.loc?.start.line || 0,
-                    normalizedCode: normalized,
-                });
-            },
-            FunctionExpression(path) {
-                const hash = computeASTHash(path.node);
-                const normalized = normalizeCode(path.node);
-                codeBlocks.push({
-                    node: path.node,
-                    hash,
-                    location: path.node.loc?.start.line || 0,
-                    normalizedCode: normalized,
-                });
-            },
-            ArrowFunctionExpression(path) {
-                const hash = computeASTHash(path.node);
-                const normalized = normalizeCode(path.node);
-                codeBlocks.push({
-                    node: path.node,
-                    hash,
-                    location: path.node.loc?.start.line || 0,
-                    normalizedCode: normalized,
-                });
-            },
-            ClassMethod(path) {
-                const hash = computeASTHash(path.node);
-                const normalized = normalizeCode(path.node);
-                codeBlocks.push({
-                    node: path.node,
-                    hash,
-                    location: path.node.loc?.start.line || 0,
-                    normalizedCode: normalized,
-                });
-            },
-        });
-        for (let i = 0; i < codeBlocks.length; i++) {
-            for (let j = i + 1; j < codeBlocks.length; j++) {
-                const block1 = codeBlocks[i];
-                const block2 = codeBlocks[j];
-                if (block1.hash === block2.hash) {
-                    duplicates.push({
-                        location: block1.location,
-                        duplicateLocation: block2.location,
-                        similarity: 1.0,
-                    });
-                    continue;
-                }
-                const similarity = calculateCodeSimilarity(block1.normalizedCode, block2.normalizedCode);
-                if (similarity >= 0.85) {
-                    duplicates.push({
-                        location: block1.location,
-                        duplicateLocation: block2.location,
-                        similarity,
-                    });
-                }
-            }
-        }
-    }
-    catch (error) {
-        logger.debug('Duplicate code detection failed', error);
-    }
-    return duplicates;
-}
-export function computeASTHash(node) {
-    const normalized = JSON.stringify(node, (key, value) => {
-        if (['loc', 'start', 'end', 'range'].includes(key)) {
-            return undefined;
-        }
-        if (key === 'comments' || key === 'leadingComments' || key === 'trailingComments') {
-            return undefined;
-        }
-        return value;
-    });
-    let hash = 0;
-    for (let i = 0; i < normalized.length; i++) {
-        const char = normalized.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash;
-    }
-    return hash.toString(36);
-}
-export function normalizeCode(node) {
-    let identifierCounter = 0;
-    const identifierMap = new Map();
-    const clonedNode = t.cloneNode(node, true, false);
-    traverse(t.file(t.program([clonedNode])), {
-        Identifier(path) {
-            const name = path.node.name;
-            const reserved = [
-                'console',
-                'window',
-                'document',
-                'Math',
-                'JSON',
-                'Array',
-                'Object',
-                'String',
-                'Number',
-            ];
-            if (reserved.includes(name))
-                return;
-            if (!identifierMap.has(name)) {
-                identifierMap.set(name, `VAR_${identifierCounter++}`);
-            }
-            path.node.name = identifierMap.get(name);
-        },
-        StringLiteral(path) {
-            path.node.value = 'STRING';
-        },
-        NumericLiteral(path) {
-            path.node.value = 0;
-        },
-    });
-    return JSON.stringify(clonedNode);
-}
-export function calculateCodeSimilarity(code1, code2) {
-    const len1 = code1.length;
-    const len2 = code2.length;
-    if (Math.abs(len1 - len2) > Math.max(len1, len2) * 0.3) {
-        return 0;
-    }
-    const matrix = Array.from({ length: len1 + 1 }, () => Array.from({ length: len2 + 1 }, () => 0));
-    for (let i = 0; i <= len1; i++) {
-        matrix[i][0] = i;
-    }
-    for (let j = 0; j <= len2; j++) {
-        matrix[0][j] = j;
-    }
-    for (let i = 1; i <= len1; i++) {
-        for (let j = 1; j <= len2; j++) {
-            const cost = code1[i - 1] === code2[j - 1] ? 0 : 1;
-            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
-        }
-    }
-    const distance = matrix[len1][len2];
-    const maxLen = Math.max(len1, len2);
-    return 1 - distance / maxLen;
-}

package/dist/modules/browser/BrowserDiscovery.js

@@ -1,249 +0,0 @@
-import { ScriptLoader } from '../../native/ScriptLoader.js';
-export class BrowserDiscovery {
-    scriptLoader;
-    browserSignatures = new Map([
-        ['chrome', {
-                windowClasses: ['Chrome_WidgetWin_0', 'Chrome_WidgetWin_1', 'Chrome_WidgetWin_*'],
-                processNames: ['chrome.exe', 'chrome'],
-                mainWindowTitle: /.*- Google Chrome$/,
-                debugPorts: [9222, 9229, 9333],
-            }],
-        ['edge', {
-                windowClasses: ['Edge_WidgetWin_0', 'Edge_WidgetWin_1', 'Edge_WidgetWin_*'],
-                processNames: ['msedge.exe', 'msedge'],
-                mainWindowTitle: /.*- Microsoft Edge$/,
-                debugPorts: [9222, 9229],
-            }],
-        ['firefox', {
-                windowClasses: ['MozillaWindowClass'],
-                processNames: ['firefox.exe', 'firefox'],
-                mainWindowTitle: /.*- Mozilla Firefox$/,
-                debugPorts: [9222],
-            }],
-    ]);
-    constructor() {
-        this.scriptLoader = new ScriptLoader();
-    }
-    sanitizePsInput(value) {
-        return value.replace(/[`$"'{}();|<>@#%!\\\n\r]/g, '');
-    }
-    escapePowerShellSingleQuoted(value) {
-        return this.sanitizePsInput(value).replace(/'/g, "''");
-    }
-    async discoverBrowsers() {
-        const results = [];
-        for (const [type, signature] of this.browserSignatures) {
-            const browsers = await this.findBySignature(type, signature);
-            results.push(...browsers);
-        }
-        return results;
-    }
-    async findBySignature(type, signature) {
-        const results = [];
-        const seenPids = new Set();
-        for (const processName of signature.processNames) {
-            const processes = await this.findByProcessName(processName);
-            for (const proc of processes) {
-                if (!seenPids.has(proc.pid)) {
-                    seenPids.add(proc.pid);
-                    results.push({
-                        type: type,
-                        pid: proc.pid,
-                        hwnd: proc.hwnd,
-                        title: proc.title,
-                    });
-                }
-            }
-        }
-        for (const windowClass of signature.windowClasses) {
-            const windows = await this.findByWindowClass(windowClass);
-            for (const win of windows) {
-                if (!seenPids.has(win.pid)) {
-                    seenPids.add(win.pid);
-                    results.push({
-                        type: type,
-                        pid: win.pid,
-                        hwnd: win.hwnd,
-                        title: win.title,
-                    });
-                }
-            }
-        }
-        for (const browser of results) {
-            const debugPort = await this.detectDebugPort(browser.pid, signature.debugPorts);
-            if (debugPort) {
-                browser.debugPort = debugPort;
-            }
-        }
-        return results;
-    }
-    async findByWindowClass(classNamePattern) {
-        const scriptPath = this.scriptLoader.getScriptPath('enum-windows-by-class.ps1');
-        try {
-            const escapedPattern = this.escapePowerShellSingleQuoted(classNamePattern);
-            const { execFile } = await import('child_process');
-            const { promisify } = await import('util');
-            const execFileAsync = promisify(execFile);
-            const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', scriptPath, '-ClassPattern', escapedPattern], { maxBuffer: 1024 * 1024 * 10 });
-            return this.parseWindowsResult(stdout, classNamePattern);
-        }
-        catch (error) {
-            console.error(`Failed to find windows by class '${classNamePattern}':`, error);
-            return [];
-        }
-    }
-    async findByProcessName(name) {
-        try {
-            const escapedPattern = this.escapePowerShellSingleQuoted(name);
-            const psCommand = `$Pattern='${escapedPattern}'; Get-Process -Name "*$Pattern*" -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, Path, MainWindowTitle, MainWindowHandle, CPU, WorkingSet64 | ConvertTo-Json -Compress`;
-            const { execFile } = await import('child_process');
-            const { promisify } = await import('util');
-            const execFileAsync = promisify(execFile);
-            const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-Command', psCommand], { maxBuffer: 1024 * 1024 * 10 });
-            return this.parseProcessResult(stdout, name);
-        }
-        catch (error) {
-            console.error(`Failed to find process by name '${name}':`, error);
-            return [];
-        }
-    }
-    parseWindowsResult(stdout, _classNamePattern) {
-        const results = [];
-        if (!stdout.trim() || stdout.trim() === 'null') {
-            return results;
-        }
-        try {
-            const data = JSON.parse(stdout.trim());
-            const windows = Array.isArray(data) ? data : [data];
-            for (const win of windows) {
-                let type = 'unknown';
-                const title = win.Title || '';
-                for (const [browserType, signature] of this.browserSignatures) {
-                    if (signature.mainWindowTitle?.test(title)) {
-                        type = browserType;
-                        break;
-                    }
-                }
-                if (type === 'unknown') {
-                    for (const [browserType, signature] of this.browserSignatures) {
-                        for (const pattern of signature.windowClasses) {
-                            const regexPattern = pattern.replace(/\*/g, '.*');
-                            if (new RegExp(regexPattern).test(win.ClassName || '')) {
-                                type = browserType;
-                                break;
-                            }
-                        }
-                        if (type !== 'unknown')
-                            break;
-                    }
-                }
-                results.push({
-                    type,
-                    pid: win.ProcessId,
-                    hwnd: win.Handle,
-                    title: win.Title,
-                });
-            }
-        }
-        catch (error) {
-            console.error('Failed to parse windows result:', error);
-        }
-        return results;
-    }
-    parseProcessResult(stdout, _name) {
-        const results = [];
-        if (!stdout.trim() || stdout.trim() === 'null') {
-            return results;
-        }
-        try {
-            const data = JSON.parse(stdout.trim());
-            const processes = Array.isArray(data) ? data : [data];
-            for (const proc of processes) {
-                let type = 'unknown';
-                const procName = (proc.ProcessName || '').toLowerCase();
-                if (procName.includes('chrome')) {
-                    type = 'chrome';
-                }
-                else if (procName.includes('msedge') || procName.includes('edge')) {
-                    type = 'edge';
-                }
-                else if (procName.includes('firefox')) {
-                    type = 'firefox';
-                }
-                results.push({
-                    type,
-                    pid: proc.Id,
-                    hwnd: proc.MainWindowHandle?.toString(),
-                    title: proc.MainWindowTitle,
-                });
-            }
-        }
-        catch (error) {
-            console.error('Failed to parse process result:', error);
-        }
-        return results;
-    }
-    async detectDebugPort(pid, ports) {
-        const debugPortFromCmdline = await this.checkDebugPortFromCommandLine(pid);
-        if (debugPortFromCmdline) {
-            return debugPortFromCmdline;
-        }
-        for (const port of ports) {
-            if (await this.checkPort(pid, port)) {
-                return port;
-            }
-        }
-        return null;
-    }
-    async checkDebugPortFromCommandLine(pid) {
-        const { execFile } = await import('child_process');
-        const { promisify } = await import('util');
-        const execFileAsync = promisify(execFile);
-        try {
-            if (!Number.isFinite(pid) || pid <= 0) {
-                return null;
-            }
-            const psCommand = `Get-CimInstance Win32_Process -Filter "ProcessId = ${Math.trunc(pid)}" | Select-Object CommandLine, ParentProcessId | ConvertTo-Json -Compress`;
-            const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-Command', psCommand], { maxBuffer: 1024 * 1024 });
-            if (!stdout.trim() || stdout.trim() === 'null') {
-                return null;
-            }
-            const data = JSON.parse(stdout.trim());
-            const commandLine = data.CommandLine || '';
-            const match = commandLine.match(/--remote-debugging-port=(\d+)/);
-            if (match && match[1]) {
-                return parseInt(match[1], 10);
-            }
-            return null;
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    async checkPort(pid, port) {
-        const { execFile } = await import('child_process');
-        const { promisify } = await import('util');
-        const execFileAsync = promisify(execFile);
-        try {
-            if (!Number.isFinite(pid) || pid <= 0 || !Number.isFinite(port) || port <= 0) {
-                return false;
-            }
-            const psCommand = `Get-NetTCPConnection -OwningProcess ${Math.trunc(pid)} -State Listen -ErrorAction SilentlyContinue | Select-Object LocalPort | ConvertTo-Json -Compress`;
-            const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-Command', psCommand], { maxBuffer: 1024 * 1024 });
-            if (!stdout.trim() || stdout.trim() === 'null') {
-                return false;
-            }
-            const data = JSON.parse(stdout.trim());
-            const connections = Array.isArray(data) ? data : [data];
-            for (const conn of connections) {
-                if (conn.LocalPort === port) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-}