linguclaw 0.4.0

package/dist/languages/python.js

@@ -0,0 +1,655 @@
+"use strict";
+/**
+ * Python Language Support for LinguClaw
+ * Advanced Python parser using AST analysis
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonLanguageSupport = exports.PythonAnalyzer = exports.PythonParser = void 0;
+class PythonParser {
+    source = '';
+    lines = [];
+    parse(source, filePath) {
+        this.source = source;
+        this.lines = source.split('\n');
+        try {
+            // Use Python's ast module via child process for accurate parsing
+            const ast = this.parseWithPythonAST(source);
+            return {
+                ast: this.convertToGenericAST(ast, filePath),
+                errors: [],
+                warnings: [],
+                tokens: [],
+                comments: this.extractComments(),
+            };
+        }
+        catch (error) {
+            // Fallback to regex-based parsing
+            return this.fallbackParse(filePath);
+        }
+    }
+    async *parseStream(source) {
+        const reader = source.getReader();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += value;
+            // Try to parse complete statements
+            const chunks = this.splitIntoChunks(buffer);
+            for (const chunk of chunks.complete) {
+                yield this.parse(chunk, '<stream>');
+            }
+            buffer = chunks.remaining;
+        }
+        // Parse remaining
+        if (buffer.trim()) {
+            yield this.parse(buffer, '<stream>');
+        }
+    }
+    parseWithPythonAST(source) {
+        // In real implementation, this would spawn Python process
+        // python -c "import ast; print(ast.dump(ast.parse(source)))"
+        return this.createMockPythonAST(source);
+    }
+    createMockPythonAST(source) {
+        // Simplified mock AST for demonstration
+        return {
+            type: 'Module',
+            body: this.extractPythonStructure(source),
+        };
+    }
+    extractPythonStructure(source) {
+        const nodes = [];
+        const lines = source.split('\n');
+        let currentIndent = 0;
+        let inClass = false;
+        let inFunction = false;
+        let className = '';
+        let functionName = '';
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const stripped = line.trim();
+            const indent = line.search(/\S/);
+            if (stripped.startsWith('class ')) {
+                const match = stripped.match(/class\s+(\w+)/);
+                if (match) {
+                    inClass = true;
+                    className = match[1];
+                    nodes.push({
+                        type: 'ClassDef',
+                        name: className,
+                        lineno: i + 1,
+                        col_offset: indent,
+                    });
+                }
+            }
+            else if (stripped.startsWith('def ')) {
+                const match = stripped.match(/def\s+(\w+)/);
+                if (match) {
+                    inFunction = true;
+                    functionName = match[1];
+                    nodes.push({
+                        type: 'FunctionDef',
+                        name: functionName,
+                        lineno: i + 1,
+                        col_offset: indent,
+                        parent_class: inClass && indent > 0 ? className : undefined,
+                    });
+                }
+            }
+            else if (stripped.startsWith('import ') || stripped.startsWith('from ')) {
+                nodes.push({
+                    type: 'Import',
+                    line: stripped,
+                    lineno: i + 1,
+                });
+            }
+            // Detect dedent
+            if (indent <= currentIndent && (inClass || inFunction)) {
+                if (indent === 0) {
+                    inClass = false;
+                    inFunction = false;
+                }
+            }
+            currentIndent = indent;
+        }
+        return nodes;
+    }
+    convertToGenericAST(pythonAST, filePath) {
+        const convertNode = (node, parent) => {
+            const generic = {
+                type: this.mapPythonNodeType(node.type),
+                id: `${filePath}:${node.lineno || 0}:${node.col_offset || 0}`,
+                location: {
+                    file: filePath,
+                    startLine: node.lineno || 0,
+                    startColumn: node.col_offset || 0,
+                    endLine: node.end_lineno || node.lineno || 0,
+                    endColumn: node.end_col_offset || 0,
+                    byteOffset: 0,
+                },
+                children: [],
+                parent,
+                metadata: { ...node },
+            };
+            // Convert children
+            if (node.body && Array.isArray(node.body)) {
+                generic.children = node.body.map((child) => convertNode(child, generic));
+            }
+            return generic;
+        };
+        return convertNode(pythonAST);
+    }
+    mapPythonNodeType(pythonType) {
+        const typeMap = {
+            'Module': 'Program',
+            'FunctionDef': 'FunctionDeclaration',
+            'AsyncFunctionDef': 'FunctionDeclaration',
+            'ClassDef': 'ClassDeclaration',
+            'Import': 'ImportDeclaration',
+            'ImportFrom': 'ImportDeclaration',
+            'Assign': 'VariableDeclaration',
+            'AnnAssign': 'VariableDeclaration',
+            'If': 'IfStatement',
+            'For': 'ForStatement',
+            'While': 'WhileStatement',
+            'Try': 'TryStatement',
+            'With': 'WithStatement',
+            'Return': 'ReturnStatement',
+            'Expr': 'ExpressionStatement',
+            'Call': 'CallExpression',
+            'Attribute': 'MemberExpression',
+            'Name': 'Identifier',
+            'Constant': 'Literal',
+            'List': 'ArrayExpression',
+            'Dict': 'ObjectExpression',
+        };
+        return typeMap[pythonType] || pythonType;
+    }
+    extractComments() {
+        const comments = [];
+        const lines = this.source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const hashIndex = line.indexOf('#');
+            if (hashIndex !== -1) {
+                comments.push({
+                    type: 'Line',
+                    value: line.substring(hashIndex + 1).trim(),
+                    line: i + 1,
+                });
+            }
+        }
+        return comments;
+    }
+    fallbackParse(filePath) {
+        // Basic regex-based fallback
+        const ast = {
+            type: 'Program',
+            id: `${filePath}:0:0`,
+            location: {
+                file: filePath,
+                startLine: 0,
+                startColumn: 0,
+                endLine: this.lines.length,
+                endColumn: 0,
+                byteOffset: 0,
+            },
+            children: this.extractPythonStructure(this.source).map(node => ({
+                type: this.mapPythonNodeType(node.type),
+                id: `${filePath}:${node.lineno || 0}:0`,
+                location: {
+                    file: filePath,
+                    startLine: node.lineno || 0,
+                    startColumn: node.col_offset || 0,
+                    endLine: node.lineno || 0,
+                    endColumn: 0,
+                    byteOffset: 0,
+                },
+                children: [],
+                metadata: node,
+            })),
+            metadata: {},
+        };
+        return {
+            ast,
+            errors: [],
+            warnings: [{ message: 'Using fallback parser' }],
+            tokens: [],
+            comments: this.extractComments(),
+        };
+    }
+    splitIntoChunks(buffer) {
+        // Split by blank lines or dedent
+        const lines = buffer.split('\n');
+        const chunks = [];
+        let currentChunk = [];
+        for (const line of lines) {
+            if (line.trim() === '' && currentChunk.length > 0) {
+                chunks.push(currentChunk.join('\n'));
+                currentChunk = [];
+            }
+            else {
+                currentChunk.push(line);
+            }
+        }
+        return {
+            complete: chunks,
+            remaining: currentChunk.join('\n'),
+        };
+    }
+}
+exports.PythonParser = PythonParser;
+class PythonAnalyzer {
+    analyze(ast, context) {
+        const symbolTable = this.buildSymbolTable(ast);
+        const metrics = this.calculateMetrics(ast);
+        const securityIssues = this.findSecurityIssues(ast);
+        return {
+            symbols: symbolTable,
+            callGraph: this.buildCallGraph(ast),
+            dataFlow: { definitions: new Map(), uses: new Map(), taintedSources: [], sinks: [] },
+            controlFlow: this.buildControlFlow(ast),
+            typeInference: new Map(),
+            metrics,
+            suggestions: this.generateSuggestions(ast, metrics, securityIssues),
+        };
+    }
+    buildSymbolTable(ast) {
+        const variables = new Map();
+        const functions = new Map();
+        const classes = new Map();
+        const traverse = (node) => {
+            switch (node.type) {
+                case 'FunctionDeclaration':
+                    functions.set(node.metadata.name, {
+                        name: node.metadata.name,
+                        signature: this.extractSignature(node),
+                        parameters: [],
+                        returnType: 'Any',
+                        async: false,
+                        pure: this.isPureFunction(node),
+                        recursive: this.isRecursive(node),
+                        complexity: this.calculateComplexity(node),
+                        callers: [],
+                        callees: this.findCallees(node),
+                    });
+                    break;
+                case 'ClassDeclaration':
+                    classes.set(node.metadata.name, {
+                        name: node.metadata.name,
+                        superClass: node.metadata.bases?.[0],
+                        interfaces: [],
+                        methods: [],
+                        properties: [],
+                        isAbstract: false,
+                        isFinal: false,
+                    });
+                    break;
+                case 'VariableDeclaration':
+                    const varName = this.extractVariableName(node);
+                    if (varName) {
+                        variables.set(varName, {
+                            name: varName,
+                            type: 'Any',
+                            mutable: true,
+                            scope: 'local',
+                            initialized: true,
+                            references: [],
+                        });
+                    }
+                    break;
+            }
+            node.children.forEach(traverse);
+        };
+        traverse(ast);
+        return {
+            variables,
+            functions,
+            classes,
+            modules: new Map(),
+            imports: this.extractImports(ast),
+            exports: [],
+        };
+    }
+    extractSignature(node) {
+        return `def ${node.metadata.name}(...)`;
+    }
+    isPureFunction(node) {
+        // Check for side effects
+        let hasSideEffects = false;
+        const checkSideEffects = (n) => {
+            if (n.type === 'CallExpression') {
+                const funcName = n.metadata.func?.name || '';
+                if (['print', 'open', 'write', 'exec', 'eval'].includes(funcName)) {
+                    hasSideEffects = true;
+                }
+            }
+            n.children.forEach(checkSideEffects);
+        };
+        checkSideEffects(node);
+        return !hasSideEffects;
+    }
+    isRecursive(node) {
+        const funcName = node.metadata.name;
+        let callsSelf = false;
+        const checkRecursion = (n) => {
+            if (n.type === 'CallExpression' && n.metadata.func?.name === funcName) {
+                callsSelf = true;
+            }
+            n.children.forEach(checkRecursion);
+        };
+        checkRecursion(node);
+        return callsSelf;
+    }
+    calculateComplexity(node) {
+        let branches = 0;
+        let nesting = 0;
+        let maxNesting = 0;
+        const traverse = (n, depth) => {
+            maxNesting = Math.max(maxNesting, depth);
+            if (['IfStatement', 'ForStatement', 'WhileStatement', 'TryStatement'].includes(n.type)) {
+                branches++;
+                nesting = depth;
+            }
+            n.children.forEach(child => traverse(child, depth + 1));
+        };
+        traverse(node, 0);
+        return {
+            cyclomatic: branches + 1,
+            cognitive: branches + maxNesting,
+            nestingDepth: maxNesting,
+            parameterCount: node.metadata.args?.length || 0,
+        };
+    }
+    findCallees(node) {
+        const callees = [];
+        const traverse = (n) => {
+            if (n.type === 'CallExpression' && n.metadata.func?.name) {
+                callees.push(n.metadata.func.name);
+            }
+            n.children.forEach(traverse);
+        };
+        traverse(node);
+        return callees;
+    }
+    extractVariableName(node) {
+        // Extract variable name from assignment
+        return node.metadata.targets?.[0]?.name || null;
+    }
+    extractImports(ast) {
+        const imports = [];
+        const traverse = (node) => {
+            if (node.type === 'ImportDeclaration') {
+                imports.push({
+                    source: node.metadata.module || node.metadata.line,
+                    names: node.metadata.names || [],
+                });
+            }
+            node.children.forEach(traverse);
+        };
+        traverse(ast);
+        return imports;
+    }
+    calculateMetrics(ast) {
+        let linesOfCode = 0;
+        let logicalLines = 0;
+        let commentLines = 0;
+        let blankLines = 0;
+        // This would need access to source
+        // Simplified calculation
+        const countNodes = (node) => {
+            return 1 + node.children.reduce((sum, child) => sum + countNodes(child), 0);
+        };
+        const totalNodes = countNodes(ast);
+        return {
+            linesOfCode: totalNodes * 3, // Rough estimate
+            logicalLines: Math.floor(totalNodes * 1.5),
+            commentLines: 0,
+            blankLines: 0,
+            cyclomaticComplexity: this.calculateCyclomatic(ast),
+            cognitiveComplexity: 0,
+            halsteadMetrics: this.calculateHalstead(ast),
+            maintainabilityIndex: 70,
+            duplicateRate: 0,
+        };
+    }
+    calculateCyclomatic(ast) {
+        let branches = 0;
+        const traverse = (node) => {
+            if (['IfStatement', 'ForStatement', 'WhileStatement', 'TryStatement', 'ConditionalExpression'].includes(node.type)) {
+                branches++;
+            }
+            node.children.forEach(traverse);
+        };
+        traverse(ast);
+        return branches + 1;
+    }
+    calculateHalstead(ast) {
+        // Simplified Halstead metrics
+        const operators = new Set();
+        const operands = new Set();
+        const traverse = (node) => {
+            if (node.type === 'BinaryExpression' || node.type === 'UnaryExpression') {
+                operators.add(node.metadata.op);
+            }
+            if (node.type === 'Identifier' || node.type === 'Literal') {
+                operands.add(node.metadata.name || node.metadata.value);
+            }
+            node.children.forEach(traverse);
+        };
+        traverse(ast);
+        const n1 = operators.size;
+        const n2 = operands.size;
+        const N1 = operators.size * 2; // Estimated
+        const N2 = operands.size * 2;
+        const vocabulary = n1 + n2;
+        const length = N1 + N2;
+        const volume = length * Math.log2(vocabulary || 1);
+        const difficulty = (n1 / 2) * (N2 / (n2 || 1));
+        const effort = difficulty * volume;
+        return {
+            operators: n1,
+            operands: n2,
+            uniqueOperators: n1,
+            uniqueOperands: n2,
+            volume: Math.round(volume),
+            difficulty: Math.round(difficulty),
+            effort: Math.round(effort),
+            timeToProgram: Math.round(effort / 18),
+            bugsDelivered: Math.round(volume / 3000),
+        };
+    }
+    findSecurityIssues(ast) {
+        const issues = [];
+        const traverse = (node) => {
+            // Check for dangerous functions
+            if (node.type === 'CallExpression') {
+                const funcName = node.metadata.func?.name || '';
+                const funcAttr = node.metadata.func?.attr || '';
+                // SQL Injection
+                if (['execute', 'executemany', 'raw'].includes(funcName)) {
+                    const hasStringConcat = this.hasStringConcat(node);
+                    if (hasStringConcat) {
+                        issues.push({
+                            id: 'PY001',
+                            severity: 'critical',
+                            category: 'sql-injection',
+                            location: node.location,
+                            description: 'Potential SQL injection via string concatenation',
+                            remediation: 'Use parameterized queries',
+                            falsePositiveLikelihood: 0.3,
+                        });
+                    }
+                }
+                // Command Injection
+                if (['os.system', 'subprocess.call', 'subprocess.run', 'subprocess.Popen'].includes(funcAttr)) {
+                    const hasUserInput = this.hasUserInput(node);
+                    if (hasUserInput) {
+                        issues.push({
+                            id: 'PY002',
+                            severity: 'critical',
+                            category: 'command-injection',
+                            location: node.location,
+                            description: 'Potential command injection',
+                            remediation: 'Use list arguments instead of shell=True',
+                            falsePositiveLikelihood: 0.2,
+                        });
+                    }
+                }
+                // eval/exec
+                if (['eval', 'exec', 'compile'].includes(funcName)) {
+                    issues.push({
+                        id: 'PY003',
+                        severity: 'high',
+                        category: 'insecure-deserialization',
+                        location: node.location,
+                        description: 'Dangerous use of eval/exec',
+                        remediation: 'Use ast.literal_eval for safe evaluation',
+                        falsePositiveLikelihood: 0.1,
+                    });
+                }
+                // Pickle
+                if (['pickle.load', 'pickle.loads', 'cPickle.load'].includes(funcAttr)) {
+                    issues.push({
+                        id: 'PY004',
+                        severity: 'high',
+                        category: 'insecure-deserialization',
+                        location: node.location,
+                        description: 'Unsafe deserialization with pickle',
+                        remediation: 'Use json or msgpack instead',
+                        falsePositiveLikelihood: 0.2,
+                    });
+                }
+                // Hardcoded secrets
+                if (funcName === 'password' || funcAttr?.includes('password')) {
+                    const args = node.metadata.args || [];
+                    for (const arg of args) {
+                        if (arg.type === 'Literal' && typeof arg.value === 'string' && arg.value.length > 0) {
+                            issues.push({
+                                id: 'PY005',
+                                severity: 'critical',
+                                category: 'sensitive-data-exposure',
+                                location: node.location,
+                                description: 'Potential hardcoded password',
+                                remediation: 'Use environment variables or secret management',
+                                falsePositiveLikelihood: 0.4,
+                            });
+                        }
+                    }
+                }
+            }
+            // Check for debug mode
+            if (node.type === 'Assignment' && node.metadata.name === 'DEBUG') {
+                if (node.metadata.value === true) {
+                    issues.push({
+                        id: 'PY006',
+                        severity: 'medium',
+                        category: 'sensitive-data-exposure',
+                        location: node.location,
+                        description: 'DEBUG mode enabled',
+                        remediation: 'Set DEBUG=False in production',
+                        falsePositiveLikelihood: 0.1,
+                    });
+                }
+            }
+            node.children.forEach(traverse);
+        };
+        traverse(ast);
+        return issues;
+    }
+    hasStringConcat(node) {
+        // Check for string concatenation or formatting
+        let found = false;
+        const traverse = (n) => {
+            if (n.type === 'BinaryExpression' && n.metadata.op === '+') {
+                found = true;
+            }
+            if (n.type === 'CallExpression' && ['format', 'f-string'].includes(n.metadata.func?.name)) {
+                found = true;
+            }
+            n.children.forEach(traverse);
+        };
+        traverse(node);
+        return found;
+    }
+    hasUserInput(node) {
+        // Check for user input sources
+        let found = false;
+        const traverse = (n) => {
+            if (n.type === 'CallExpression') {
+                const funcName = n.metadata.func?.name || '';
+                if (['input', 'request', 'argv'].includes(funcName)) {
+                    found = true;
+                }
+            }
+            n.children.forEach(traverse);
+        };
+        traverse(node);
+        return found;
+    }
+    buildCallGraph(ast) {
+        const nodes = [];
+        const edges = [];
+        const traverse = (node) => {
+            if (node.type === 'FunctionDeclaration') {
+                const funcName = node.metadata.name;
+                nodes.push(funcName);
+                // Find calls within this function
+                const findCalls = (n) => {
+                    if (n.type === 'CallExpression') {
+                        const callee = n.metadata.func?.name;
+                        if (callee) {
+                            edges.push({ from: funcName, to: callee });
+                        }
+                    }
+                    n.children.forEach(findCalls);
+                };
+                findCalls(node);
+            }
+            node.children.forEach(traverse);
+        };
+        traverse(ast);
+        return { nodes, edges, entryPoints: nodes.filter(n => !edges.some(e => e.to === n)), deadCode: [] };
+    }
+    buildControlFlow(ast) {
+        // Simplified control flow graph
+        return {
+            nodes: [],
+            edges: [],
+            loops: [],
+            branches: [],
+        };
+    }
+    generateSuggestions(ast, metrics, issues) {
+        const suggestions = [];
+        // Complexity suggestions
+        if (metrics.cyclomaticComplexity > 10) {
+            suggestions.push({
+                type: 'refactor',
+                message: 'Function is too complex. Consider breaking it down.',
+                severity: 'warning',
+            });
+        }
+        // Security suggestions
+        for (const issue of issues) {
+            suggestions.push({
+                type: 'security',
+                message: issue.description,
+                severity: issue.severity,
+                remediation: issue.remediation,
+            });
+        }
+        return suggestions;
+    }
+}
+exports.PythonAnalyzer = PythonAnalyzer;
+exports.PythonLanguageSupport = {
+    id: 'python',
+    name: 'Python',
+    extensions: ['.py', '.pyw', '.pyi'],
+    parser: new PythonParser(),
+    analyzer: new PythonAnalyzer(),
+};
+//# sourceMappingURL=python.js.map