Comprehensive Code Review for ACE Engine

Quick Start

Perform comprehensive code review analysis directly with AI:

"Review the code in frameworks/core/components_ng for memory management issues"

"Analyze this pull request focusing on security vulnerabilities"

"Check path/to/code.cpp for ACE Engine architecture compliance"

Review Workflow

Phase 1: Code Analysis

AI will analyze code across all relevant dimensions based on:

1. Reading the code files - Understanding implementation details
2. Applying reference standards - Using criteria from references/ directory
3. Checking against ACE Engine patterns - Validating project-specific conventions

Phase 2: Dimension-Based Review

Review code across 19+ dimensions. See DIMENSIONS.md for complete coverage.

High-Priority Dimensions:

• Security (CRITICAL) - Input validation, command injection, buffer overflows
• Memory (CRITICAL) - Smart pointers, leaks, ownership semantics
• Threading (HIGH) - Data races, deadlocks, callback safety
• Stability (HIGH) - Error handling, boundary conditions

Medium-Priority Dimensions:

• Performance - Algorithm complexity, optimization opportunities
• SOLID Principles - Single responsibility, Open/Closed, etc.
• Code Smells - Long methods, large classes, duplicate code
• Testability - Dependency injection, decoupling

Phase 3: Report Generation

AI generates comprehensive review report including:

• Executive Summary - Issue counts by severity
• Critical Issues (🔴) - Must fix before merge
• High Priority Issues (🟠) - Should fix before merge
• Medium Priority Issues (🟡) - Fix soon
• Low Priority Issues (🟢) - Nice to have
• Dimension Breakdown - Issues grouped by category
• File-by-File Details - Specific line numbers and code snippets
• Recommendations - Prioritized action items with before/after examples
• Review Checklist - Pre-merge verification

Dimension Reference

Quick reference to all dimensions:

Dimension	Focus	Severity Levels	Reference
Stability	Error handling, boundaries	🔴🟠🟡🟢	STABILITY.md
Performance	Algorithms, optimization	🔴🟠🟡🟢	DIMENSIONS.md
Threading	Concurrency, synchronization	🔴🟠🟡	DIMENSIONS.md
Security	Input validation, vulnerabilities	🔴🟠🟡	SECURITY.md
Memory	Smart pointers, leaks	🔴🟠🟡	MEMORY.md
Modern C++	C++11/14/17/20 features	🟠🟡	DIMENSIONS.md
Effective C++	RAII, Rule of Five	🟠🟡	DIMENSIONS.md
Code Smells	22 types of smells	🟠🟡	CODE_SMELLS.md
SOLID	Design principles	🟠🟡	SOLID.md
Design Patterns	Pattern usage	🟡🟢	DIMENSIONS.md
Robustness	Fault tolerance	🟠🟡	DIMENSIONS.md
Testability	Dependency injection	🟠🟡	DIMENSIONS.md
Maintainability	Code complexity	🟡🟢	DIMENSIONS.md
Observability	Logging, monitoring	🟡🟢	DIMENSIONS.md
API Design	Interface quality	🟠🟡	DIMENSIONS.md
Technical Debt	TODO/FIXME tracking	🟡🟢	DIMENSIONS.md
Backward Compatibility	API stability	🟠🟡	DIMENSIONS.md
Architecture	ACE Engine compliance	🔴🟠🟡	ACE_ENGINE_SPECIFIC.md

ACE Engine Specific Checks

Architecture Validation

Four-Layer Architecture:

Frontend Bridge Layer
    ↓
Component Framework Layer (Pattern/Model/Property)
    ↓
Layout/Render Layer
    ↓
Platform Adapter Layer (OHOS/Preview)

Check:

• No violations of layer boundaries
• Proper use of Pattern/Model/Property separation
• No direct platform calls from framework layer

Component Structure

components_ng/pattern/<component>/
├── *_pattern.h/cpp         # Business logic & lifecycle
├── *_model.h/cpp           # Data model interface
├── *_layout_property.h/cpp # Layout properties
├── *_paint_property.h/cpp  # Render properties
└── *_event_hub.h/cpp       # Event handling

RefPtr Usage

// ✅ Creation
auto node = AceType::MakeRefPtr<FrameNode>();

// ✅ Type-safe casting
auto pattern = AceType::DynamicCast<MenuPattern>(node->GetPattern());
if (!pattern) {
    LOGE("Failed to get pattern");
    return false;
}

// ✅ Breaking cycles with WeakPtr
class Child {
    WeakPtr<Parent> parent_;  // Use weak, not strong
};

// ✅ Safe callbacks
auto weak = AceType::WeakClaim(this);
PostTask([weak]() {
    auto pattern = AceType::DynamicCast<MenuPattern>(weak.Upgrade());
    if (pattern) pattern->Update();
});

Naming Conventions

class MenuPattern {           // PascalCase
public:
    void OnModifyDone();      // PascalCase
    int GetWidth() const;     // Get prefix

private:
    int width_;               // snake_case_ with trailing underscore
    std::string component_id_;  // Abbreviations lowercase
};

constexpr int MAX_MENU_ITEMS = 100;  // UPPER_CASE

Severity Levels

🔴 CRITICAL - Must fix before merge

• Security vulnerabilities (command injection, buffer overflow)
• Memory leaks in long-running processes
• Use-after-free, double-free
• Data races
• Crashes / undefined behavior
• Architecture violations

🟠 HIGH - Should fix before merge

• Performance degradation
• API violations
• SOLID principle violations
• Major code smells (Large Class, Shotgun Surgery)
• Improper RefPtr usage
• Unsafe callback captures

🟡 MEDIUM - Fix soon

• Minor performance issues
• Code smells (Long Method, Duplicate Code)
• Style violations
• Missing error handling in non-critical paths

🟢 LOW - Nice to have

• Missing comments
• Minor style issues
• Optimization opportunities
• Code documentation improvements

Common Issue Patterns

Pattern	Dimension	Severity	Detection
Raw pointer instead of RefPtr	Memory	HIGH	new T() without RefPtr
Command injection	Security	CRITICAL	system(user_input)
Buffer overflow	Security	CRITICAL	strcpy(), sprintf()
Unsafe this capture	Threading	HIGH	[this] in PostTask
Long method (>50 lines)	Code Smell	MEDIUM	Function length
Large class (>500 lines)	Code Smell	HIGH	Class size
Missing null check	Stability	HIGH	Pointer use without validation
static_cast instead of DynamicCast	Memory	MEDIUM	static_cast<T*>

Usage Examples

Review a Pull Request

"Review the changes in this PR with focus on memory management and threading safety"

AI will:

• Analyze all changed files
• Check memory management (RefPtr, WeakPtr, raw pointers)
• Verify threading safety (callback captures, PostTask usage)
• Report issues with line numbers and severity

Security Audit

"Perform a security audit of path/to/code, focusing on input validation and potential vulnerabilities"

AI will check for:

• Command injection risks (system() calls)
• Buffer overflow vulnerabilities (strcpy, sprintf)
• Unvalidated user input
• Unsafe type casts

Memory Leak Detection

"Analyze frameworks/core/components for potential memory leaks and improper RefPtr usage"

AI will identify:

• Raw new/delete without smart pointers
• Circular references without WeakPtr
• Missing null checks after DynamicCast
• Improper ownership semantics

Architecture Compliance Check

"Verify that components_ng/menu follows the four-layer architecture and Pattern/Model/Property separation"

AI will validate:

• Four-layer architecture compliance
• Pattern/Model/Property separation
• No layer boundary violations
• Component lifecycle methods (OnModifyDone, etc.)

Integration Examples

Pre-commit Hook

For pre-commit hooks, consider using traditional static analysis tools:

#!/bin/bash
# .git/hooks/pre-commit

CHANGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(cpp|cc|cxx|h|hpp|ts|tsx)$')

if [ -n "$CHANGED_FILES" ]; then
    echo "Running basic static analysis..."
    # Use clang-tidy, cppcheck, eslint, etc.
    for file in $CHANGED_FILES; do
        if [[ $file == *.cpp || $file == *.h ]]; then
            clang-tidy $file --checks='*' || true
        elif [[ $file == *.ts ]]; then
            eslint $file || true
        fi
    done
fi

Manual Review Workflow

For comprehensive AI-powered review:

1. Identify code to review (PR, specific files, directory)
2. Request review with specific focus areas
3. AI analyzes code using reference standards
4. Review results with severity-tagged issues
5. Address critical and high-priority issues
6. Re-request review for verification

References

Detailed documentation for all dimensions in references/:

• DIMENSIONS.md - Quick reference for all 19+ dimensions
• STABILITY.md - Error handling, boundary conditions
• MEMORY.md - Smart pointers, leaks, ownership
• SECURITY.md - Input validation, vulnerabilities
• CODE_SMELLS.md - 22 types of code smells
• SOLID.md - Five design principles
• ACE_ENGINE_SPECIFIC.md - Project-specific rules

Assets

• report_template.md - Customizable report template for AI-generated reviews

Review Checklist

Before merging code:

Code Quality:

• No CRITICAL issues
• HIGH priority issues addressed or documented
• No compiler warnings
• Static analysis clean

Architecture:

• Four-layer architecture respected
• Proper Pattern/Model/Property separation
• No layer boundary violations

Memory:

• No memory leaks
• RefPtr used correctly
• WeakPtr used to break cycles
• Callbacks use WeakClaim

Security:

• All input validated
• No command injection
• No buffer overflows
• Sensitive data protected

Testing:

• Unit tests added
• Edge cases covered
• Error scenarios tested