pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/android/analyzers/AndroidForbiddenLiteralsAnalyzer.js

@@ -0,0 +1,261 @@
+const { SyntaxKind } = require('../../ast-core');
+
+const FORBIDDEN_STRING_LITERALS = [
+    'unknown',
+    'null',
+    'undefined',
+    'any',
+    'void',
+    'never',
+];
+
+const FORBIDDEN_STATUS_LITERALS = [
+    'active',
+    'inactive',
+    'pending',
+    'completed',
+    'failed',
+    'success',
+    'error',
+];
+
+const MAGIC_NUMBERS = [0, 1];
+
+class AndroidForbiddenLiteralsAnalyzer {
+    analyze(sf, findings, pushFinding) {
+        if (!sf || typeof sf.getFilePath !== 'function') {
+            return;
+        }
+        const stringLiterals = sf.getDescendantsOfKind(SyntaxKind.StringLiteral);
+        const numericLiterals = sf.getDescendantsOfKind(SyntaxKind.NumericLiteral);
+        const asExpressions = sf.getDescendantsOfKind(SyntaxKind.AsExpression);
+        const nullishCoalescing = sf.getDescendantsOfKind(SyntaxKind.NullishCoalescingExpression);
+        const conditionalExpressions = sf.getDescendantsOfKind(SyntaxKind.ConditionalExpression);
+        const objectLiteralExpressions = sf.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression);
+
+        this.analyzeStringLiterals(stringLiterals, sf, findings, pushFinding);
+        this.analyzeNumericLiterals(numericLiterals, sf, findings, pushFinding);
+        this.analyzeTypeCasts(asExpressions, sf, findings, pushFinding);
+        this.analyzeNullishCoalescing(nullishCoalescing, sf, findings, pushFinding);
+        this.analyzeConditionalExpressions(conditionalExpressions, sf, findings, pushFinding);
+        this.analyzeObjectLiterals(objectLiteralExpressions, sf, findings, pushFinding);
+    }
+
+    analyzeStringLiterals(stringLiterals, sf, findings, pushFinding) {
+        stringLiterals.forEach((literal) => {
+            const value = literal.getLiteralValue();
+            const parent = literal.getParent();
+
+            if (!parent) return;
+
+            const isInTypeDefinition = parent.getKind && (
+                parent.getKind() === SyntaxKind.UnionType ||
+                parent.getKind() === SyntaxKind.TypeLiteral ||
+                parent.getKind() === SyntaxKind.PropertySignature
+            );
+
+            if (isInTypeDefinition) return;
+
+            const isInImport = parent.getKind && (
+                parent.getKind() === SyntaxKind.ImportDeclaration ||
+                parent.getKind() === SyntaxKind.ImportSpecifier
+            );
+
+            if (isInImport) return;
+
+            const isInComment = parent.getKind && parent.getKind() === SyntaxKind.JSDocComment;
+            if (isInComment) return;
+
+            const fullText = sf.getFullText();
+            const literalText = literal.getText();
+            const literalIndex = literal.getStart();
+            const lineStart = fullText.lastIndexOf('\n', literalIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', literalIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInStringTemplate = /`[^`]*${literalText}[^`]*`/.test(fullLine);
+            const isInConsoleLog = /console\.(log|error|warn|info)/i.test(fullLine);
+            const isInTestFile = /\.(spec|test)\.(kt|java)$/i.test(sf.getFilePath());
+
+            if (isInStringTemplate || isInConsoleLog || isInTestFile) return;
+
+            if (FORBIDDEN_STRING_LITERALS.includes(value)) {
+                pushFinding(
+                    'android.types.forbidden_literal',
+                    'critical',
+                    literal,
+                    sf,
+                    `Forbidden string literal '${value}' detected. Use enums, constants, or type-safe alternatives instead of magic strings.`,
+                    findings
+                );
+            }
+
+            const isStatusContext = /status|state|role|type|kind|category/i.test(fullLine) &&
+                !/enum|const|type|interface|Record<.*Status/i.test(fullLine);
+
+            if (isStatusContext && FORBIDDEN_STATUS_LITERALS.includes(value)) {
+                pushFinding(
+                    'android.types.forbidden_status_literal',
+                    'high',
+                    literal,
+                    sf,
+                    `Forbidden status literal '${value}' detected. Use enums or constants instead of string literals for status/state values.`,
+                    findings
+                );
+            }
+        });
+    }
+
+    analyzeNumericLiterals(numericLiterals, sf, findings, pushFinding) {
+        numericLiterals.forEach((literal) => {
+            const value = parseFloat(literal.getText());
+            const parent = literal.getParent();
+
+            if (!parent) return;
+
+            const isInTypeDefinition = parent.getKind && (
+                parent.getKind() === SyntaxKind.UnionType ||
+                parent.getKind() === SyntaxKind.TypeLiteral ||
+                parent.getKind() === SyntaxKind.PropertySignature
+            );
+
+            if (isInTypeDefinition) return;
+
+            const fullText = sf.getFullText();
+            const literalIndex = literal.getStart();
+            const lineStart = fullText.lastIndexOf('\n', literalIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', literalIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInArrayIndex = /\[\s*\d+\s*\]/.test(fullLine);
+            const isInTestFile = /\.(spec|test)\.(kt|java)$/i.test(sf.getFilePath());
+            const isInEnumValue = /=\s*\d+/.test(fullLine) && /enum/.test(fullText.substring(0, literalIndex));
+
+            if (isInArrayIndex || isInTestFile || isInEnumValue) return;
+
+            if (MAGIC_NUMBERS.includes(value) && !isInEnumValue) {
+                const context = fullLine.trim();
+                const isIncrement = /\+\+\s*$|=\s*\w+\s*\+\s*1|=\s*\w+\s*\+\s*\d+\s*\+/.test(context);
+                const isInitialization = /=\s*0\s*[,;]/.test(context);
+
+                if (isIncrement || isInitialization) {
+                    pushFinding(
+                        'android.types.magic_number',
+                        'high',
+                        literal,
+                        sf,
+                        `Magic number ${value} detected. Use named constants (e.g., INITIAL_COUNT, INCREMENT_VALUE) instead of magic numbers.`,
+                        findings
+                    );
+                }
+            }
+        });
+    }
+
+    analyzeTypeCasts(asExpressions, sf, findings, pushFinding) {
+        if (!sf || typeof sf.getFilePath !== 'function') return;
+        asExpressions.forEach((expr) => {
+            const fullText = sf.getFullText();
+            const exprIndex = expr.getStart();
+            const lineStart = fullText.lastIndexOf('\n', exprIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', exprIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInTestFile = /\.(spec|test)\.(kt|java)$/i.test(sf.getFilePath());
+            const isTypeAssertion = /as\s+(UserRole|OrderStatus|UserStatus|AlertStatus)/i.test(fullLine);
+
+            if (isInTestFile || isTypeAssertion) return;
+
+            pushFinding(
+                'android.types.forbidden_type_cast',
+                'high',
+                sf,
+                expr,
+                `Type casting with 'as' detected. Use type guards, mappers, or proper type narrowing instead of type assertions.`,
+                findings
+            );
+        });
+    }
+
+    analyzeNullishCoalescing(nullishCoalescing, sf, findings, pushFinding) {
+        nullishCoalescing.forEach((expr) => {
+            const fullText = sf.getFullText();
+            const exprIndex = expr.getStart();
+            const lineStart = fullText.lastIndexOf('\n', exprIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', exprIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInTestFile = /\.(spec|test)\.(kt|java)$/i.test(sf.getFilePath());
+            const hasNull = /null/.test(fullLine);
+            const hasUndefined = /undefined/.test(fullLine);
+
+            if (isInTestFile) return;
+
+            if (hasNull || hasUndefined) {
+                pushFinding(
+                    'android.types.forbidden_nullish_coalescing',
+                    'critical',
+                    expr,
+                    sf,
+                    `Nullish coalescing with null/undefined detected. Use optional properties (name?: String) instead of nullable types (name: String?). Eliminate null/undefined from codebase.`,
+                    findings
+                );
+            }
+        });
+    }
+
+    analyzeConditionalExpressions(conditionalExpressions, sf, findings, pushFinding) {
+        conditionalExpressions.forEach((expr) => {
+            const fullText = sf.getFullText();
+            const exprIndex = expr.getStart();
+            const lineStart = fullText.lastIndexOf('\n', exprIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', exprIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInTestFile = /\.(spec|test)\.(kt|java)$/i.test(sf.getFilePath());
+            const hasNull = /\?\s*null\s*:/.test(fullLine);
+            const hasUndefined = /\?\s*undefined\s*:/.test(fullLine);
+
+            if (isInTestFile) return;
+
+            if (hasNull || hasUndefined) {
+                pushFinding(
+                    'android.types.forbidden_ternary_null_undefined',
+                    'critical',
+                    expr,
+                    sf,
+                    `Ternary operator with null detected. Use optional properties (prop: String?) and conditional spread pattern. Only include properties when they have values. Use data class with optional parameters.`,
+                    findings
+                );
+            }
+        });
+    }
+
+    analyzeObjectLiterals(objectLiteralExpressions, sf, findings, pushFinding) {
+        objectLiteralExpressions.forEach((obj) => {
+            const fullText = sf.getFullText();
+            const objIndex = obj.getStart();
+            const lineStart = fullText.lastIndexOf('\n', objIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', objIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInTestFile = /\.(spec|test)\.(kt|java)$/i.test(sf.getFilePath());
+            const hasNullAssignment = /:\s*null/.test(fullLine);
+
+            if (isInTestFile) return;
+
+            if (hasNullAssignment) {
+                pushFinding(
+                    'android.types.forbidden_null_assignment',
+                    'critical',
+                    obj,
+                    sf,
+                    `Direct null assignment in object detected. Use optional properties and conditional spread pattern. Only include properties when they have values. Use data class with optional parameters (prop: String?).`,
+                    findings
+                );
+            }
+        });
+    }
+}
+
+module.exports = { AndroidForbiddenLiteralsAnalyzer };

package/scripts/hooks-system/infrastructure/ast/android/analyzers/AndroidSOLIDAnalyzer.js

@@ -0,0 +1,287 @@
+
+const path = require('path');
+const { pushFinding, SyntaxKind } = require(path.join(__dirname, '../../ast-core'));
+
+/**
+ * AndroidSOLIDAnalyzer
+ * Enterprise-grade SOLID principles analyzer for Android/Kotlin
+ * Uses TypeScript AST (ts-morph) for dynamic node-based analysis
+ *
+ * @class AndroidSOLIDAnalyzer
+ */
+class AndroidSOLIDAnalyzer {
+    constructor() {
+        this.findings = [];
+    }
+
+    /**
+     * Analyze source file for SOLID violations
+     * @param {SourceFile} sf - TypeScript morph source file
+     * @param {Array} findings - Global findings array
+     * @param {Function} pushFinding - Push finding function
+     */
+    analyze(sf, findings, pushFinding) {
+        if (!sf || typeof sf.getFilePath !== 'function') {
+            return;
+        }
+        this.findings = findings;
+        this.pushFinding = pushFinding;
+
+        this.analyzeOCP(sf);
+        this.analyzeDIP(sf);
+        this.analyzeSRP(sf);
+        this.analyzeISP(sf);
+    }
+
+
+    analyzeOCP(sf) {
+        const filePath = sf.getFilePath();
+        const fileName = filePath.split('/').pop() || 'unknown';
+
+        const functions = sf.getFunctions();
+        const arrowFunctions = sf.getVariableDeclarations().filter(vd => {
+            const init = vd.getInitializer();
+            return init && init.getKind() === SyntaxKind.ArrowFunction;
+        });
+
+        const classes = sf.getClasses();
+
+        const allNodes = [
+            ...functions.map(f => ({ type: 'function', node: f, name: f.getName() || 'anonymous' })),
+            ...arrowFunctions.map(af => ({ type: 'arrow', node: af, name: af.getName() || 'anonymous' })),
+            ...classes.map(c => ({ type: 'class', node: c, name: c.getName() || 'AnonymousClass' })),
+        ];
+
+        allNodes.forEach(({ type, node, name }) => {
+            this.analyzeNodeForOCP(node, name, fileName, sf);
+        });
+    }
+
+    analyzeNodeForOCP(node, nodeName, fileName, sf) {
+        let body;
+
+        if (node.getKind() === SyntaxKind.FunctionDeclaration ||
+            node.getKind() === SyntaxKind.FunctionExpression) {
+            body = node.getBody();
+        } else if (node.getKind() === SyntaxKind.VariableDeclaration) {
+            const init = node.getInitializer();
+            if (init && init.getKind() === SyntaxKind.ArrowFunction) {
+                body = init.getBody();
+            }
+        } else if (node.getKind() === SyntaxKind.ClassDeclaration) {
+            const methods = node.getMethods();
+            methods.forEach(method => {
+                const methodBody = method.getBody();
+                if (methodBody) {
+                    this.analyzeBodyForOCP(methodBody, `${nodeName}.${method.getName()}`, fileName, sf);
+                }
+            });
+            return;
+        } else {
+            return;
+        }
+
+        if (!body) return;
+        this.analyzeBodyForOCP(body, nodeName, fileName, sf);
+    }
+
+    analyzeBodyForOCP(body, nodeName, fileName, sf) {
+        const switches = body.getDescendantsOfKind(SyntaxKind.SwitchStatement);
+
+        switches.forEach(switchStmt => {
+            const switchExpr = switchStmt.getExpression();
+            const exprText = switchExpr.getText();
+            const cases = switchStmt.getCaseClauses();
+
+            if (cases.length >= 3) {
+                const isDomainValue = /status|type|priority|role|kind|category|state|mode/i.test(exprText);
+
+                if (isDomainValue) {
+                    const message = `OCP VIOLATION in ${fileName}::${nodeName}: switch on '${exprText}' with ${cases.length} cases - use Strategy/Map pattern with centralized constants`;
+                    this.pushFinding('solid.ocp.switch_statement', 'critical', sf, switchStmt, message, this.findings);
+                } else if (cases.length >= 5) {
+                    const message = `OCP VIOLATION in ${fileName}::${nodeName}: large switch (${cases.length} cases) on '${exprText}' - consider Strategy/Factory pattern`;
+                    this.pushFinding('solid.ocp.switch_statement', 'high', sf, switchStmt, message, this.findings);
+                }
+            }
+        });
+
+        const ifStatements = body.getDescendantsOfKind(SyntaxKind.IfStatement);
+        const typeIfChains = this.detectTypeIfChains(ifStatements);
+
+        if (typeIfChains.length >= 3) {
+            const chainVars = new Set(typeIfChains.map(chain => chain.variable));
+            if (chainVars.size === 1) {
+                const varName = Array.from(chainVars)[0];
+                const message = `OCP VIOLATION in ${fileName}::${nodeName}: ${typeIfChains.length} if-else checking '${varName}' - use Strategy pattern or polymorphism`;
+                this.pushFinding('solid.ocp.if_type_chain', 'critical', sf, typeIfChains[0].node, message, this.findings);
+            }
+        }
+
+        switches.forEach(switchStmt => {
+            const nestedSwitches = switchStmt.getDescendantsOfKind(SyntaxKind.SwitchStatement);
+            if (nestedSwitches.length > 0) {
+                const message = `OCP VIOLATION in ${fileName}::${nodeName}: nested switch statements - use Strategy/Map pattern with composition`;
+                this.pushFinding('solid.ocp.nested_switch', 'critical', sf, switchStmt, message, this.findings);
+            }
+        });
+    }
+
+    detectTypeIfChains(ifStatements) {
+        const chains = [];
+
+        ifStatements.forEach(ifStmt => {
+            const condition = ifStmt.getExpression();
+            const conditionText = condition.getText();
+
+            const typeCheckPattern = /(\w+)\s*(===|==|!==|!=)\s*['"]([\w\s]+)['"]|typeof\s+(\w+)|(\w+)\s+instanceof/i;
+            const match = conditionText.match(typeCheckPattern);
+
+            if (match) {
+                const variable = match[1] || match[4] || match[5];
+                chains.push({ variable, node: ifStmt });
+            }
+        });
+
+        return chains;
+    }
+
+
+    analyzeDIP(sf) {
+        const filePath = sf.getFilePath();
+        const fileName = filePath.split('/').pop() || 'unknown';
+
+        const isDomain = /\/domain\//i.test(filePath);
+
+        if (isDomain) {
+            const imports = sf.getImportDeclarations();
+
+            imports.forEach(imp => {
+                const importPath = imp.getModuleSpecifierValue();
+
+                if (/\/infrastructure\//i.test(importPath) ||
+                    /androidx|kotlinx|retrofit|room|hilt/i.test(importPath)) {
+                    const message = `DIP VIOLATION in ${fileName}: Domain layer importing from Infrastructure/Framework: ${importPath} - Domain should depend only on abstractions`;
+                    this.pushFinding('solid.dip.domain_depends_infrastructure', 'critical', sf, imp, message, this.findings);
+                }
+            });
+        }
+
+        const isPresentation = /\/presentation\//i.test(filePath);
+
+        if (isPresentation) {
+            const imports = sf.getImportDeclarations();
+
+            imports.forEach(imp => {
+                const importPath = imp.getModuleSpecifierValue();
+
+                if (/\/infrastructure\//i.test(importPath) &&
+                    !/\/infrastructure\/repositories\/|\/infrastructure\/config\//i.test(importPath)) {
+                    const message = `DIP VIOLATION in ${fileName}: Presentation layer importing from Infrastructure: ${importPath} - use repository interfaces or abstractions`;
+                    this.pushFinding('solid.dip.presentation_infrastructure', 'critical', sf, imp, message, this.findings);
+                }
+            });
+        }
+
+        const classes = sf.getClasses();
+        classes.forEach(cls => {
+            const className = cls.getName() || 'AnonymousClass';
+
+            if (/ViewModel|UseCase/i.test(className)) {
+                const imports = sf.getImportDeclarations();
+
+                imports.forEach(imp => {
+                    const importPath = imp.getModuleSpecifierValue();
+
+                    if (/Repository|Service|Client/i.test(importPath) &&
+                        !/interface|protocol|Repository.*Protocol/i.test(importPath)) {
+                        const message = `DIP VIOLATION in ${fileName}::${className}: depends on concrete implementation '${importPath}' - inject interface/abstraction`;
+                        this.pushFinding('solid.dip.concrete_dependency', 'critical', sf, imp, message, this.findings);
+                    }
+                });
+            }
+        });
+    }
+
+
+    analyzeSRP(sf) {
+        const filePath = sf.getFilePath();
+        const fileName = filePath.split('/').pop() || 'unknown';
+
+        const functions = sf.getFunctions();
+        const arrowFunctions = sf.getVariableDeclarations().filter(vd => {
+            const init = vd.getInitializer();
+            return init && init.getKind() === SyntaxKind.ArrowFunction;
+        });
+
+        [...functions, ...arrowFunctions].forEach(func => {
+            const funcName = func.getName?.() || 'anonymous';
+            const body = func.getBody?.() || func.getInitializer()?.getBody();
+
+            if (!body) return;
+
+            const statements = body.getStatements();
+            const ifStatements = body.getDescendantsOfKind(SyntaxKind.IfStatement);
+            const switchStatements = body.getDescendantsOfKind(SyntaxKind.SwitchStatement);
+            const loops = body.getDescendantsOfKind(SyntaxKind.ForStatement)
+                .concat(body.getDescendantsOfKind(SyntaxKind.ForInStatement))
+                .concat(body.getDescendantsOfKind(SyntaxKind.WhileStatement));
+
+            if (statements.length > 30 || ifStatements.length > 10 || switchStatements.length > 2 || loops.length > 5) {
+                const message = `SRP VIOLATION in ${fileName}::${funcName}: high complexity (${statements.length} statements, ${ifStatements.length} ifs, ${switchStatements.length} switches) - extract responsibilities`;
+                this.pushFinding('solid.srp.high_complexity', 'critical', sf, func, message, this.findings);
+            }
+        });
+
+        const classes = sf.getClasses();
+        classes.forEach(cls => {
+            const className = cls.getName() || 'AnonymousClass';
+            const methods = cls.getMethods();
+
+            if (methods.length > 20) {
+                const message = `SRP VIOLATION in ${fileName}::${className}: God class with ${methods.length} methods - split into focused classes`;
+                this.pushFinding('solid.srp.god_class', 'critical', sf, cls, message, this.findings);
+            }
+        });
+    }
+
+
+    analyzeISP(sf) {
+        const interfaces = sf.getInterfaces();
+
+        interfaces.forEach(iface => {
+            const interfaceName = iface.getName();
+            const properties = iface.getProperties();
+            const methods = iface.getMethods();
+
+            if (properties.length > 10) {
+                const message = `ISP VIOLATION: ${interfaceName} has ${properties.length} properties - split into focused interfaces`;
+                this.pushFinding('solid.isp.fat_interface', 'critical', sf, iface, message, this.findings);
+            }
+
+            if (methods.length > 0) {
+                const methodConcerns = methods.map(m => this.detectMethodConcern(m.getName()));
+                const uniqueConcerns = new Set(methodConcerns.filter(c => c !== 'unknown'));
+
+                if (uniqueConcerns.size >= 3) {
+                    const message = `ISP VIOLATION: ${interfaceName} mixes ${uniqueConcerns.size} concerns (${Array.from(uniqueConcerns).join(', ')}) - segregate into focused interfaces`;
+                    this.pushFinding('solid.isp.multiple_concerns', 'critical', sf, iface, message, this.findings);
+                }
+            }
+        });
+    }
+
+    detectMethodConcern(methodName) {
+        const name = methodName.toLowerCase();
+
+        if (/get|fetch|load|read|find|query/i.test(name)) return 'data-access';
+        if (/set|save|create|update|delete|remove/i.test(name)) return 'data-mutation';
+        if (/validate|check|verify/i.test(name)) return 'validation';
+        if (/format|parse|transform/i.test(name)) return 'transformation';
+        if (/render|display|show/i.test(name)) return 'rendering';
+
+        return 'unknown';
+    }
+}
+
+module.exports = { AndroidSOLIDAnalyzer };

package/scripts/hooks-system/infrastructure/ast/android/analyzers/__tests__/AndroidForbiddenLiteralsAnalyzer.spec.js

@@ -0,0 +1,58 @@
+const { AndroidForbiddenLiteralsAnalyzer } = require('../AndroidForbiddenLiteralsAnalyzer');
+
+describe('AndroidForbiddenLiteralsAnalyzer', () => {
+  let analyzer;
+
+  beforeEach(() => {
+    analyzer = new AndroidForbiddenLiteralsAnalyzer();
+  });
+
+  describe('analyze', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyze).toBe('function');
+    });
+  });
+
+  describe('analyzeStringLiterals', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeStringLiterals).toBe('function');
+    });
+  });
+
+  describe('analyzeNumericLiterals', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeNumericLiterals).toBe('function');
+    });
+  });
+
+  describe('analyzeTypeCasts', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeTypeCasts).toBe('function');
+    });
+  });
+
+  describe('analyzeNullishCoalescing', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeNullishCoalescing).toBe('function');
+    });
+  });
+
+  describe('analyzeConditionalExpressions', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeConditionalExpressions).toBe('function');
+    });
+  });
+
+  describe('analyzeObjectLiterals', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeObjectLiterals).toBe('function');
+    });
+  });
+
+  describe('exports', () => {
+    it('should export AndroidForbiddenLiteralsAnalyzer', () => {
+      const mod = require('../AndroidForbiddenLiteralsAnalyzer');
+      expect(mod.AndroidForbiddenLiteralsAnalyzer).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/android/analyzers/__tests__/AndroidSOLIDAnalyzer.spec.js

@@ -0,0 +1,84 @@
+const { AndroidSOLIDAnalyzer } = require('../AndroidSOLIDAnalyzer');
+
+describe('AndroidSOLIDAnalyzer', () => {
+  let analyzer;
+
+  beforeEach(() => {
+    analyzer = new AndroidSOLIDAnalyzer();
+  });
+
+  describe('constructor', () => {
+    it('should create instance', () => {
+      expect(analyzer).toBeInstanceOf(AndroidSOLIDAnalyzer);
+    });
+
+    it('should initialize findings array', () => {
+      expect(analyzer.findings).toEqual([]);
+    });
+  });
+
+  describe('analyze', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyze).toBe('function');
+    });
+  });
+
+  describe('analyzeOCP', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeOCP).toBe('function');
+    });
+  });
+
+  describe('analyzeDIP', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeDIP).toBe('function');
+    });
+  });
+
+  describe('analyzeSRP', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeSRP).toBe('function');
+    });
+  });
+
+  describe('analyzeISP', () => {
+    it('should be a method', () => {
+      expect(typeof analyzer.analyzeISP).toBe('function');
+    });
+  });
+
+  describe('detectMethodConcern', () => {
+    it('should detect data-access concern', () => {
+      expect(analyzer.detectMethodConcern('getUser')).toBe('data-access');
+      expect(analyzer.detectMethodConcern('fetchData')).toBe('data-access');
+    });
+
+    it('should detect data-mutation concern', () => {
+      expect(analyzer.detectMethodConcern('setUser')).toBe('data-mutation');
+      expect(analyzer.detectMethodConcern('deleteItem')).toBe('data-mutation');
+    });
+
+    it('should detect validation concern', () => {
+      expect(analyzer.detectMethodConcern('validateEmail')).toBe('validation');
+    });
+
+    it('should detect transformation concern', () => {
+      expect(analyzer.detectMethodConcern('formatDate')).toBe('transformation');
+    });
+
+    it('should detect rendering concern', () => {
+      expect(analyzer.detectMethodConcern('renderItem')).toBe('rendering');
+    });
+
+    it('should return unknown for unrecognized methods', () => {
+      expect(analyzer.detectMethodConcern('doSomething')).toBe('unknown');
+    });
+  });
+
+  describe('exports', () => {
+    it('should export AndroidSOLIDAnalyzer', () => {
+      const mod = require('../AndroidSOLIDAnalyzer');
+      expect(mod.AndroidSOLIDAnalyzer).toBeDefined();
+    });
+  });
+});