@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/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);
-    const 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/src/modules/analyzer/SecurityCodeAnalyzer.d.ts

@@ -1,5 +0,0 @@
-import * as t from '@babel/types';
-import type { SecurityRisk } from '../../types/index.js';
-export declare function getMemberExpressionName(node: t.MemberExpression): string;
-export declare function checkSanitizer(node: t.CallExpression, sanitizers: Set<string>): boolean;
-export declare function identifySecurityRisks(code: string, aiAnalysis: Record<string, unknown>): SecurityRisk[];

package/dist/src/modules/analyzer/SecurityCodeAnalyzer.js

@@ -1,186 +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 getMemberExpressionName(node) {
-    const parts = [];
-    let current = node;
-    while (t.isMemberExpression(current)) {
-        if (t.isIdentifier(current.property)) {
-            parts.unshift(current.property.name);
-        }
-        current = current.object;
-    }
-    if (t.isIdentifier(current)) {
-        parts.unshift(current.name);
-    }
-    return parts.join('.');
-}
-export function checkSanitizer(node, sanitizers) {
-    const { callee } = node;
-    if (t.isIdentifier(callee)) {
-        return sanitizers.has(callee.name);
-    }
-    if (t.isMemberExpression(callee)) {
-        const fullName = getMemberExpressionName(callee);
-        return sanitizers.has(fullName);
-    }
-    return false;
-}
-export function identifySecurityRisks(code, aiAnalysis) {
-    const risks = [];
-    if (Array.isArray(aiAnalysis.securityRisks)) {
-        aiAnalysis.securityRisks.forEach((risk) => {
-            if (typeof risk === 'object' && risk !== null) {
-                const r = risk;
-                risks.push({
-                    type: r.type || 'other',
-                    severity: r.severity || 'low',
-                    location: { file: 'current', line: r.location?.line || 0 },
-                    description: r.description || '',
-                    recommendation: r.recommendation || '',
-                });
-            }
-        });
-    }
-    try {
-        const ast = parser.parse(code, {
-            sourceType: 'module',
-            plugins: ['jsx', 'typescript'],
-        });
-        traverse(ast, {
-            AssignmentExpression(path) {
-                const left = path.node.left;
-                const line = path.node.loc?.start.line || 0;
-                if (t.isMemberExpression(left) && t.isIdentifier(left.property)) {
-                    const propName = left.property.name;
-                    if (['innerHTML', 'outerHTML', 'insertAdjacentHTML'].includes(propName)) {
-                        risks.push({
-                            type: 'xss',
-                            severity: 'high',
-                            location: { file: 'current', line },
-                            description: `Potential XSS vulnerability: Direct assignment to ${propName} without sanitization`,
-                            recommendation: 'Use textContent for plain text, or DOMPurify.sanitize() for HTML content',
-                        });
-                    }
-                    if (propName === 'write' &&
-                        t.isIdentifier(left.object) &&
-                        left.object.name === 'document') {
-                        risks.push({
-                            type: 'xss',
-                            severity: 'high',
-                            location: { file: 'current', line },
-                            description: 'Dangerous use of document.write() which can lead to XSS',
-                            recommendation: 'Use modern DOM manipulation methods instead',
-                        });
-                    }
-                }
-            },
-            CallExpression(path) {
-                const callee = path.node.callee;
-                const line = path.node.loc?.start.line || 0;
-                if (t.isIdentifier(callee)) {
-                    if (callee.name === 'eval') {
-                        risks.push({
-                            type: 'other',
-                            severity: 'critical',
-                            location: { file: 'current', line },
-                            description: 'Critical: Use of eval() allows arbitrary code execution',
-                            recommendation: 'Refactor to avoid eval(). Use JSON.parse() for data, or proper function calls',
-                        });
-                    }
-                    if (callee.name === 'Function') {
-                        risks.push({
-                            type: 'other',
-                            severity: 'critical',
-                            location: { file: 'current', line },
-                            description: 'Critical: Function constructor allows code injection',
-                            recommendation: 'Use regular function declarations or arrow functions',
-                        });
-                    }
-                    if (['setTimeout', 'setInterval'].includes(callee.name)) {
-                        const firstArg = path.node.arguments[0];
-                        if (t.isStringLiteral(firstArg) ||
-                            (t.isIdentifier(firstArg) && firstArg.name !== 'function')) {
-                            risks.push({
-                                type: 'other',
-                                severity: 'medium',
-                                location: { file: 'current', line },
-                                description: `${callee.name}() with string argument can lead to code injection`,
-                                recommendation: `Use ${callee.name}() with function reference instead of string`,
-                            });
-                        }
-                    }
-                }
-                if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
-                    const methodName = callee.property.name;
-                    if (['query', 'execute', 'exec', 'run'].includes(methodName)) {
-                        const firstArg = path.node.arguments[0];
-                        if (t.isBinaryExpression(firstArg) || t.isTemplateLiteral(firstArg)) {
-                            risks.push({
-                                type: 'sql-injection',
-                                severity: 'critical',
-                                location: { file: 'current', line },
-                                description: 'Potential SQL injection: Query built with string concatenation',
-                                recommendation: 'Use parameterized queries or prepared statements',
-                            });
-                        }
-                    }
-                }
-            },
-            MemberExpression(path) {
-                const obj = path.node.object;
-                const prop = path.node.property;
-                const line = path.node.loc?.start.line || 0;
-                if (t.isIdentifier(obj) &&
-                    obj.name === 'Math' &&
-                    t.isIdentifier(prop) &&
-                    prop.name === 'random') {
-                    const parent = path.parent;
-                    if (t.isCallExpression(parent) || t.isBinaryExpression(parent)) {
-                        risks.push({
-                            type: 'other',
-                            severity: 'medium',
-                            location: { file: 'current', line },
-                            description: 'Math.random() is not cryptographically secure',
-                            recommendation: 'Use crypto.getRandomValues() or crypto.randomBytes() for security-sensitive operations',
-                        });
-                    }
-                }
-            },
-            VariableDeclarator(path) {
-                const id = path.node.id;
-                const init = path.node.init;
-                const line = path.node.loc?.start.line || 0;
-                if (t.isIdentifier(id) && t.isStringLiteral(init)) {
-                    const varName = id.name.toLowerCase();
-                    const value = init.value;
-                    const sensitivePatterns = [
-                        { pattern: /(password|passwd|pwd)/i, type: 'password' },
-                        { pattern: /(api[_-]?key|apikey)/i, type: 'API key' },
-                        { pattern: /(secret|token|auth)/i, type: 'secret' },
-                        { pattern: /(private[_-]?key|privatekey)/i, type: 'private key' },
-                    ];
-                    for (const { pattern, type } of sensitivePatterns) {
-                        if (pattern.test(varName) && value.length > 8) {
-                            risks.push({
-                                type: 'other',
-                                severity: 'critical',
-                                location: { file: 'current', line },
-                                description: `Hardcoded ${type} detected in source code`,
-                                recommendation: `Store ${type} in environment variables or secure configuration`,
-                            });
-                            break;
-                        }
-                    }
-                }
-            },
-        });
-    }
-    catch (error) {
-        logger.warn('Static security analysis failed', error);
-    }
-    const uniqueRisks = risks.filter((risk, index, self) => index ===
-        self.findIndex((r) => r.type === risk.type && r.location.line === risk.location.line));
-    return uniqueRisks;
-}

package/dist/src/modules/browser/BrowserDiscovery.d.ts

@@ -1,30 +0,0 @@
-import { ScriptLoader } from '../../native/ScriptLoader.js';
-export interface BrowserInfo {
-    type: 'chrome' | 'edge' | 'firefox' | 'unknown';
-    pid: number;
-    hwnd?: string;
-    title?: string;
-    debugPort?: number;
-}
-export interface BrowserSignature {
-    windowClasses: string[];
-    processNames: string[];
-    mainWindowTitle?: RegExp;
-    debugPorts: number[];
-}
-export declare class BrowserDiscovery {
-    protected scriptLoader: ScriptLoader;
-    protected browserSignatures: Map<string, BrowserSignature>;
-    constructor();
-    protected sanitizePsInput(value: string): string;
-    private escapePowerShellSingleQuoted;
-    discoverBrowsers(): Promise<BrowserInfo[]>;
-    protected findBySignature(type: string, signature: BrowserSignature): Promise<BrowserInfo[]>;
-    findByWindowClass(classNamePattern: string): Promise<BrowserInfo[]>;
-    findByProcessName(name: string): Promise<BrowserInfo[]>;
-    protected parseWindowsResult(stdout: string, _classNamePattern: string): BrowserInfo[];
-    private parseProcessResult;
-    detectDebugPort(pid: number, ports: number[]): Promise<number | null>;
-    private checkDebugPortFromCommandLine;
-    private checkPort;
-}