@yalehwang/archguard 0.1.32 → 0.1.33

package/dist/core/rule-engine/rule-engine.js

@@ -0,0 +1,655 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { childrenOfType, nodeText } from './ast-node.js';
+const JAVA_PRIMITIVES = new Set([
+    'void',
+    'boolean',
+    'byte',
+    'char',
+    'short',
+    'int',
+    'long',
+    'float',
+    'double',
+    'Boolean',
+    'Byte',
+    'Character',
+    'Short',
+    'Integer',
+    'Long',
+    'Float',
+    'Double',
+    'String',
+    'Object',
+]);
+const JDK_COMMON_NAMES = new Set([
+    'List',
+    'Map',
+    'Set',
+    'Collection',
+    'Queue',
+    'Deque',
+    'Iterator',
+    'Iterable',
+    'Optional',
+    'Stream',
+    'Future',
+    'Callable',
+    'Runnable',
+    'Comparator',
+    'Exception',
+    'RuntimeException',
+    'Error',
+    'Throwable',
+    'Thread',
+    'Logger',
+    'Class',
+    'Enum',
+    'Number',
+    'Math',
+    'StringBuilder',
+    'StringBuffer',
+    'ByteBuffer',
+    'CharBuffer',
+    'IntBuffer',
+    'ShortBuffer',
+    'LongBuffer',
+    'FloatBuffer',
+    'DoubleBuffer',
+    'Path',
+    'File',
+    'URI',
+    'URL',
+    'InputStream',
+    'OutputStream',
+    'Reader',
+    'Writer',
+    'Closeable',
+    'AutoCloseable',
+    'Serializable',
+    'Comparable',
+    'Cloneable',
+    'Override',
+    'Deprecated',
+    'FunctionalInterface',
+    'SuppressWarnings',
+    'Builder',
+    'Response',
+    'Request',
+]);
+const JAVA_MODIFIERS = new Set([
+    'public',
+    'private',
+    'protected',
+    'static',
+    'final',
+    'abstract',
+    'synchronized',
+    'volatile',
+    'transient',
+    'native',
+    'strictfp',
+]);
+export class RuleEngine {
+    pack;
+    session;
+    options;
+    constructor(pack, session, options = {}) {
+        this.pack = pack;
+        this.session = session;
+        this.options = options;
+    }
+    parse(code) {
+        return this.session.parse(code);
+    }
+    analyzeFile(code, filePath, moduleIndex) {
+        const tree = this.session.parse(code);
+        try {
+            return this.extractFromTree(tree.rootNode, filePath, code, moduleIndex);
+        }
+        finally {
+            tree.dispose();
+        }
+    }
+    extractEntities(code, filePath) {
+        const tree = this.session.parse(code);
+        try {
+            return this.extractEntitiesFromTree(tree.rootNode, filePath, code);
+        }
+        finally {
+            tree.dispose();
+        }
+    }
+    extractRelations(code, filePath, moduleIndex) {
+        const tree = this.session.parse(code);
+        try {
+            return this.extractRelationsFromTree(tree.rootNode, filePath, code, moduleIndex);
+        }
+        finally {
+            tree.dispose();
+        }
+    }
+    extractImportRelations(code, filePath, moduleIndex) {
+        const sourceId = this.moduleIdFor(filePath);
+        if (!sourceId)
+            return [];
+        const relations = [];
+        const seen = new Set();
+        for (const pattern of this.pack.modules.importPatterns) {
+            let regex;
+            try {
+                regex = new RegExp(pattern.pattern, 'gm');
+            }
+            catch {
+                continue;
+            }
+            let match;
+            while ((match = regex.exec(code)) !== null) {
+                const modulePath = match[pattern.moduleGroup ?? 1];
+                if (!modulePath)
+                    continue;
+                const target = this.resolveImport(modulePath, moduleIndex);
+                if (!target || target === sourceId)
+                    continue;
+                const key = `dependency:${sourceId}:${target}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                relations.push({
+                    id: `${sourceId}_dependency_${target}`,
+                    type: 'dependency',
+                    source: sourceId,
+                    target,
+                    confidence: 1.0,
+                    inferenceSource: 'explicit',
+                });
+            }
+        }
+        return relations;
+    }
+    async detectFramework(projectRoot) {
+        for (const framework of this.pack.frameworks) {
+            for (const detect of framework.detect) {
+                if (detect.fileMatch && detect.contentContains) {
+                    const filePath = path.join(projectRoot, detect.fileMatch);
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        if (content.includes(detect.contentContains)) {
+                            return framework.name;
+                        }
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    moduleIdFor(filePath) {
+        if (this.pack.manifest.language === 'python') {
+            return this.pythonModuleId(filePath);
+        }
+        const base = path.basename(filePath).replace(/\.[^.]+$/, '');
+        return base || null;
+    }
+    extractFromTree(rootNode, filePath, code, moduleIndex) {
+        const entities = this.extractEntitiesFromTree(rootNode, filePath, code);
+        const relations = this.extractRelationsFromTree(rootNode, filePath, code, moduleIndex);
+        return { entities, relations };
+    }
+    extractEntitiesFromTree(rootNode, filePath, code) {
+        const entities = [];
+        const packageName = this.extractPackageName(rootNode, code);
+        for (const rule of this.pack.modules.entityNodes) {
+            for (const node of rootNode.namedChildren) {
+                const { target, outer } = this.unwrapDecorated(node);
+                if (target.type !== rule.nodeType)
+                    continue;
+                const entity = this.extractEntity(target, rule, packageName, filePath, code);
+                if (entity) {
+                    if (outer) {
+                        const outerDecorators = this.extractAnnotations(outer, code);
+                        if (outerDecorators.length > 0)
+                            entity.decorators = outerDecorators;
+                    }
+                    entities.push(entity);
+                }
+            }
+        }
+        return entities;
+    }
+    unwrapDecorated(node) {
+        if (node.type === 'decorated_definition') {
+            const definition = node.childForFieldName('definition');
+            if (definition)
+                return { target: definition, outer: node };
+        }
+        return { target: node };
+    }
+    extractEntity(node, rule, packageName, filePath, code) {
+        const nameNode = node.childForFieldName(rule.nameField);
+        if (!nameNode)
+            return undefined;
+        const name = nodeText(nameNode, code);
+        const modifiers = this.extractModifiers(node, code);
+        const annotations = this.extractAnnotations(node, code);
+        const isAbstract = modifiers.includes('abstract');
+        const extendsList = this.extractExtends(node, rule, code);
+        const implementsList = this.extractImplements(node, rule, code);
+        const members = this.extractMembers(node, rule, code);
+        return {
+            id: this.generateEntityId(packageName, name, filePath),
+            name,
+            type: isAbstract && rule.abstractEntityType ? rule.abstractEntityType : rule.entityType,
+            visibility: this.mapVisibility(name, modifiers),
+            members,
+            sourceLocation: {
+                file: filePath,
+                startLine: node.startPosition.row + 1,
+                endLine: node.endPosition.row + 1,
+            },
+            ...(annotations.length > 0 ? { decorators: annotations } : {}),
+            ...(isAbstract ? { isAbstract: true } : {}),
+            ...(extendsList.length > 0 ? { extends: extendsList } : {}),
+            ...(implementsList.length > 0 ? { implements: implementsList } : {}),
+        };
+    }
+    extractMembers(node, rule, code) {
+        const members = [];
+        const bodyNode = rule.bodyField ? node.childForFieldName(rule.bodyField) : undefined;
+        if (!bodyNode)
+            return members;
+        if (rule.methodNode) {
+            for (const child of childrenOfType(bodyNode, rule.methodNode)) {
+                const method = this.extractMethod(child, code);
+                if (method)
+                    members.push(method);
+            }
+        }
+        if (rule.fieldNode) {
+            for (const child of childrenOfType(bodyNode, rule.fieldNode)) {
+                members.push(...this.extractFields(child, code));
+            }
+        }
+        if (rule.constructorNode) {
+            for (const child of childrenOfType(bodyNode, rule.constructorNode)) {
+                const constructor = this.extractConstructor(child, code, node, rule);
+                if (constructor)
+                    members.push(constructor);
+            }
+        }
+        return members;
+    }
+    extractMethod(node, code) {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode)
+            return undefined;
+        const name = nodeText(nameNode, code);
+        const modifiers = this.extractModifiers(node, code);
+        const annotations = this.extractAnnotations(node, code);
+        const parameters = this.extractParameters(node, code);
+        let returnType;
+        const typeNode = node.childForFieldName('type');
+        if (typeNode) {
+            returnType = nodeText(typeNode, code);
+        }
+        else {
+            const returnTypeNode = node.childForFieldName('return_type');
+            returnType = returnTypeNode ? nodeText(returnTypeNode, code) : undefined;
+        }
+        const isAsync = this.isAsyncFunction(node, code);
+        return {
+            name,
+            type: 'method',
+            visibility: this.mapVisibility(name, modifiers),
+            ...(returnType ? { returnType } : {}),
+            parameters,
+            ...(modifiers.includes('static') ? { isStatic: true } : {}),
+            ...(modifiers.includes('abstract') ? { isAbstract: true } : {}),
+            ...(isAsync ? { isAsync: true } : {}),
+            ...(annotations.length > 0 ? { decorators: annotations } : {}),
+        };
+    }
+    extractFields(node, code) {
+        const members = [];
+        const modifiers = this.extractModifiers(node, code);
+        const annotations = this.extractAnnotations(node, code);
+        const typeNode = node.childForFieldName('type');
+        const type = typeNode ? nodeText(typeNode, code) : 'unknown';
+        for (const declarator of node.descendantsOfType('variable_declarator')) {
+            const nameNode = declarator.childForFieldName('name');
+            if (!nameNode)
+                continue;
+            members.push({
+                name: nodeText(nameNode, code),
+                type: 'field',
+                visibility: this.mapVisibility(nodeText(nameNode, code), modifiers),
+                fieldType: type,
+                ...(annotations.length > 0 ? { decorators: annotations } : {}),
+            });
+        }
+        return members;
+    }
+    extractConstructor(node, code, enclosing, rule) {
+        const enclosingNameNode = enclosing.childForFieldName(rule.nameField);
+        const name = enclosingNameNode ? nodeText(enclosingNameNode, code) : 'constructor';
+        const modifiers = this.extractModifiers(node, code);
+        const annotations = this.extractAnnotations(node, code);
+        const parameters = this.extractParameters(node, code);
+        return {
+            name,
+            type: 'constructor',
+            visibility: this.mapVisibility(name, modifiers),
+            parameters,
+            ...(annotations.length > 0 ? { decorators: annotations } : {}),
+        };
+    }
+    extractParameters(node, code) {
+        const parametersNode = node.childForFieldName('parameters');
+        if (!parametersNode)
+            return [];
+        const parameters = [];
+        if (this.pack.manifest.language === 'python') {
+            for (const param of parametersNode.namedChildren) {
+                const nameNode = param.childForFieldName('name') ?? this.firstIdentifier(param);
+                if (!nameNode)
+                    continue;
+                const name = nodeText(nameNode, code);
+                const typeNode = param.childForFieldName('type');
+                parameters.push({
+                    name,
+                    type: typeNode ? nodeText(typeNode, code) : 'any',
+                });
+            }
+            return parameters;
+        }
+        for (const param of parametersNode.descendantsOfType('formal_parameter')) {
+            const typeNode = param.childForFieldName('type');
+            const nameNode = param.childForFieldName('name');
+            if (!typeNode || !nameNode)
+                continue;
+            parameters.push({
+                name: nodeText(nameNode, code),
+                type: nodeText(typeNode, code),
+            });
+        }
+        return parameters;
+    }
+    firstIdentifier(node) {
+        for (const child of node.namedChildren) {
+            if (child.type === 'identifier')
+                return child;
+        }
+        return null;
+    }
+    extractRelationsFromTree(rootNode, filePath, code, moduleIndex) {
+        const relations = [];
+        const seen = new Set();
+        const packageName = this.extractPackageName(rootNode, code);
+        const emit = this.pack.modules.relations;
+        for (const rule of this.pack.modules.entityNodes) {
+            for (const node of rootNode.namedChildren) {
+                const { target: decl } = this.unwrapDecorated(node);
+                if (decl.type !== rule.nodeType)
+                    continue;
+                const nameNode = decl.childForFieldName(rule.nameField);
+                if (!nameNode)
+                    continue;
+                const name = nodeText(nameNode, code);
+                const sourceId = this.generateEntityId(packageName, name, filePath);
+                if (emit.inheritance) {
+                    for (const ext of this.extractExtends(decl, rule, code)) {
+                        const target = this.resolveTypeId(ext, packageName);
+                        this.pushRelation(relations, seen, 'inheritance', sourceId, target);
+                    }
+                }
+                if (emit.implementation) {
+                    for (const impl of this.extractImplements(decl, rule, code)) {
+                        const target = this.resolveTypeId(impl, packageName);
+                        this.pushRelation(relations, seen, 'implementation', sourceId, target);
+                    }
+                }
+                if (emit.fieldDependency) {
+                    const bodyNode = rule.bodyField ? decl.childForFieldName(rule.bodyField) : undefined;
+                    if (bodyNode && rule.fieldNode) {
+                        for (const fieldNode of childrenOfType(bodyNode, rule.fieldNode)) {
+                            const typeNode = fieldNode.childForFieldName('type');
+                            if (!typeNode)
+                                continue;
+                            const rawType = nodeText(typeNode, code);
+                            const baseType = this.extractTypeName(rawType);
+                            if (this.isUserDefinedType(baseType)) {
+                                this.pushRelation(relations, seen, 'dependency', sourceId, this.resolveTypeId(baseType, packageName));
+                            }
+                        }
+                    }
+                }
+                if (emit.parameterDependency) {
+                    const bodyNode = rule.bodyField ? decl.childForFieldName(rule.bodyField) : undefined;
+                    if (bodyNode && rule.methodNode) {
+                        for (const methodNode of childrenOfType(bodyNode, rule.methodNode)) {
+                            for (const param of this.extractParameters(methodNode, code)) {
+                                const baseType = this.extractTypeName(param.type);
+                                if (this.isUserDefinedType(baseType)) {
+                                    this.pushRelation(relations, seen, 'dependency', sourceId, this.resolveTypeId(baseType, packageName));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (emit.importDependency) {
+            relations.push(...this.extractImportRelations(code, filePath, moduleIndex));
+        }
+        return relations;
+    }
+    pushRelation(relations, seen, type, source, target) {
+        const key = `${type}:${source}:${target}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        relations.push({
+            id: `${source}_${type}_${target}`,
+            type,
+            source,
+            target,
+            confidence: 1.0,
+            inferenceSource: 'explicit',
+        });
+    }
+    extractPackageName(rootNode, code) {
+        if (this.pack.manifest.language !== 'java')
+            return '';
+        const packageDecl = rootNode.namedChildren.find((c) => c.type === 'package_declaration');
+        if (!packageDecl)
+            return '';
+        const scoped = packageDecl.descendantsOfType('scoped_identifier')[0];
+        if (scoped)
+            return nodeText(scoped, code);
+        const identifier = packageDecl.descendantsOfType('identifier')[0];
+        if (identifier)
+            return nodeText(identifier, code);
+        return '';
+    }
+    extractModifiers(node, _code) {
+        if (this.pack.manifest.language !== 'java')
+            return [];
+        const modifiers = [];
+        for (const child of node.children) {
+            if (child.type !== 'modifiers')
+                continue;
+            for (const mod of child.children) {
+                if (JAVA_MODIFIERS.has(mod.type))
+                    modifiers.push(mod.type);
+            }
+        }
+        return modifiers;
+    }
+    extractAnnotations(node, code) {
+        if (this.pack.manifest.language === 'python') {
+            const decorators = [];
+            for (const child of node.namedChildren) {
+                if (child.type === 'decorator') {
+                    const name = this.pythonDecoratorName(child, code);
+                    if (name)
+                        decorators.push({ name });
+                }
+            }
+            return decorators;
+        }
+        const decorators = [];
+        for (const child of node.children) {
+            if (child.type !== 'modifiers')
+                continue;
+            for (const mod of child.children) {
+                if (mod.type !== 'marker_annotation' && mod.type !== 'annotation')
+                    continue;
+                const nameNode = mod.childForFieldName('name');
+                if (!nameNode)
+                    continue;
+                const raw = nodeText(nameNode, code);
+                decorators.push({ name: raw.startsWith('@') ? raw.substring(1) : raw });
+            }
+        }
+        return decorators;
+    }
+    pythonDecoratorName(node, code) {
+        const call = node.namedChildren.find((c) => c.type === 'call');
+        if (call) {
+            const fn = call.childForFieldName('function');
+            if (fn)
+                return nodeText(fn, code).replace(/^@/, '');
+        }
+        const target = node.namedChildren.find((c) => c.type === 'identifier' || c.type === 'attribute');
+        if (target)
+            return nodeText(target, code).replace(/^@/, '');
+        return undefined;
+    }
+    extractExtends(node, rule, code) {
+        if (rule.baseClassField) {
+            return this.extractPythonBaseClasses(node, rule.baseClassField, code);
+        }
+        if (!rule.extendsField)
+            return [];
+        const extendsNode = node.childForFieldName(rule.extendsField);
+        if (!extendsNode)
+            return [];
+        const typeIds = rule.typeIdentifierNode
+            ? extendsNode.descendantsOfType(rule.typeIdentifierNode)
+            : extendsNode.descendantsOfType('identifier');
+        return [...new Set(typeIds.map((t) => nodeText(t, code)))];
+    }
+    extractImplements(node, rule, code) {
+        if (!rule.implementsField)
+            return [];
+        const implementsNode = node.childForFieldName(rule.implementsField);
+        if (!implementsNode)
+            return [];
+        const typeList = implementsNode.childForFieldName('type_list') ?? implementsNode;
+        const typeIds = rule.typeIdentifierNode
+            ? typeList.descendantsOfType(rule.typeIdentifierNode)
+            : typeList.descendantsOfType('identifier');
+        return [...new Set(typeIds.map((t) => nodeText(t, code)))];
+    }
+    extractPythonBaseClasses(node, field, code) {
+        const superNode = node.childForFieldName(field);
+        if (!superNode)
+            return [];
+        const argList = superNode.namedChildren.find((c) => c.type === 'argument_list') ?? superNode;
+        const attrs = argList.descendantsOfType('attribute');
+        if (attrs.length > 0) {
+            return [...new Set(attrs.map((a) => nodeText(a, code)))];
+        }
+        const ids = argList.descendantsOfType('identifier');
+        return [...new Set(ids.map((i) => nodeText(i, code)))];
+    }
+    isAsyncFunction(node, code) {
+        if (this.pack.manifest.language !== 'python')
+            return false;
+        const prefix = code.substring(node.startIndex, Math.min(node.startIndex + 8, node.endIndex));
+        return prefix.startsWith('async');
+    }
+    mapVisibility(name, modifiers) {
+        if (this.pack.manifest.language === 'python') {
+            return name.startsWith('_') ? 'private' : 'public';
+        }
+        if (modifiers.includes('private'))
+            return 'private';
+        if (modifiers.includes('protected'))
+            return 'protected';
+        return 'public';
+    }
+    generateEntityId(packageName, name, filePath) {
+        if (this.pack.manifest.language === 'python') {
+            const moduleId = this.pythonModuleId(filePath);
+            return moduleId ? `${moduleId}.${name}` : name;
+        }
+        return packageName ? `${packageName}.${name}` : name;
+    }
+    pythonModuleId(filePath) {
+        const root = this.options.workspaceRoot;
+        if (root) {
+            const rel = path.relative(root, filePath);
+            if (rel.startsWith('..'))
+                return this.basenameModuleId(filePath);
+            const withoutExt = rel.replace(/\.py$/, '');
+            const normalised = withoutExt.replace(/(\/|^)__init__$/, '');
+            const dotted = normalised.replace(/\//g, '.');
+            return dotted || null;
+        }
+        return this.basenameModuleId(filePath);
+    }
+    basenameModuleId(filePath) {
+        const base = path.basename(filePath).replace(/\.py$/, '');
+        if (base === '__init__')
+            return path.basename(path.dirname(filePath)) || null;
+        return base || null;
+    }
+    resolveTypeId(typeName, currentPackage) {
+        if (typeName.includes('.'))
+            return typeName;
+        return currentPackage ? `${currentPackage}.${typeName}` : typeName;
+    }
+    extractTypeName(type) {
+        const genericIndex = type.indexOf('<');
+        if (genericIndex > 0)
+            return type.substring(0, genericIndex);
+        const arrayIndex = type.indexOf('[');
+        if (arrayIndex > 0)
+            return type.substring(0, arrayIndex);
+        return type.trim();
+    }
+    isUserDefinedType(type) {
+        if (this.pack.manifest.language !== 'java')
+            return false;
+        if (JAVA_PRIMITIVES.has(type))
+            return false;
+        if (type.startsWith('java.'))
+            return false;
+        if (type.length === 1 && /[A-Z]/.test(type))
+            return false;
+        if (/^[A-Z][0-9]$/.test(type))
+            return false;
+        if (JDK_COMMON_NAMES.has(type))
+            return false;
+        return true;
+    }
+    resolveImport(modulePath, moduleIndex) {
+        if (modulePath.startsWith('.'))
+            return null;
+        if (!moduleIndex)
+            return modulePath;
+        const parts = modulePath.split('.');
+        for (let leftStrip = 0; leftStrip < parts.length; leftStrip++) {
+            const remaining = parts.slice(leftStrip);
+            for (let rightLen = remaining.length; rightLen > 0; rightLen--) {
+                const candidate = remaining.slice(0, rightLen).join('.');
+                if (moduleIndex.has(candidate))
+                    return candidate;
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=rule-engine.js.map