docs/ARCHITECTURE.md

# Architecture Guide

## Chahuadev Fix Comments Tool Architecture

### Overview

The Chahuadev Fix Comments Tool is designed as a sophisticated code analysis and modification system that intelligently adds, converts, and improves comments in JavaScript and TypeScript codebases. The architecture emphasizes safety, accuracy, and extensibility.

## System Architecture

### High-Level Architecture

```
┌─────────────────────────────────────────────────────────────┐
│                     CLI Interface                           │
├─────────────────────────────────────────────────────────────┤
│                  Command Parser                             │
├─────────────────────────────────────────────────────────────┤
│                  Configuration Manager                      │
├─────────────────────────────────────────────────────────────┤
│        AST Parser     │    Tokenizer Engine                │
├─────────────────────────────────────────────────────────────┤
│                    Core Analysis Engine                     │
├─────────────────────────────────────────────────────────────┤
│  Comment Detector  │  Function Analyzer  │  Code Generator │
├─────────────────────────────────────────────────────────────┤
│                    File Processing Layer                    │
└─────────────────────────────────────────────────────────────┘
```

### Core Components

#### 1. AST Parser Engine
- **Purpose**: Safe code parsing and analysis
- **Technology**: Babel for JavaScript/TypeScript AST parsing
- **Features**:
  - Syntax-aware parsing
  - Type information extraction
  - Function signature analysis
  - Scope chain analysis

#### 2. Tokenizer Engine
- **Purpose**: Advanced comment detection and classification
- **Components**:
  - **Comment Scanner**: Identifies existing comments
  - **Pattern Matcher**: Recognizes comment patterns
  - **Context Analyzer**: Determines comment relevance
  - **Style Detector**: Identifies comment formatting styles

#### 3. Function Analyzer
- **Purpose**: Intelligent function analysis and documentation
- **Features**:
  - Parameter type inference
  - Return value analysis
  - Complexity assessment
  - Usage pattern detection

#### 4. Comment Generator
- **Purpose**: Intelligent comment generation and formatting
- **Capabilities**:
  - Template-based generation
  - Bilingual comment support
  - AI-friendly formatting
  - JSDoc standard compliance

## Detailed Component Design

### AST Processing Architecture

#### Parser Pipeline

```
Source Code  Lexical Analysis  Syntax Analysis  
AST Generation  Symbol Table  Type Inference  Analysis
```

#### AST Node Processing

```typescript
interface ASTProcessor {
    parseFile(content: string): Promise<AST>;
    extractFunctions(ast: AST): Function[];
    analyzeFunctionSignature(func: Function): Signature;
    inferTypes(func: Function): TypeInfo;
}
```

#### Supported Language Features

| Language | Version | Features |
|----------|---------|----------|
| JavaScript | ES2022+ | Classes, functions, arrow functions, async/await |
| TypeScript | 4.0+ | Type annotations, interfaces, generics |
| JSX | React 18+ | Components, hooks, props |
| TSX | React 18+ | Typed components, prop interfaces |

### Comment Analysis Engine

#### Comment Detection System

```typescript
interface CommentDetector {
    findComments(ast: AST): Comment[];
    classifyComment(comment: Comment): CommentType;
    analyzeCommentQuality(comment: Comment): QualityScore;
    detectMissingComments(func: Function): MissingComment[];
}
```

#### Comment Classification

```
Comments
├── Function Comments
│   ├── JSDoc Comments
│   ├── Inline Comments
│   └── Block Comments
├── Class Comments
│   ├── Constructor Comments
│   ├── Method Comments
│   └── Property Comments
└── Module Comments
    ├── Import Comments
    ├── Export Comments
    └── File Header Comments
```

### Function Analysis Architecture

#### Function Signature Analysis

```typescript
interface FunctionAnalyzer {
    extractSignature(func: Function): Signature;
    inferParameterTypes(params: Parameter[]): TypeInfo[];
    analyzeReturnType(func: Function): ReturnTypeInfo;
    assessComplexity(func: Function): ComplexityMetrics;
}
```

#### Analysis Metrics

1. **Cyclomatic Complexity**
   - Control flow analysis
   - Branch counting
   - Loop detection

2. **Parameter Analysis**
   - Type inference
   - Default value detection
   - Destructuring pattern analysis

3. **Return Value Analysis**
   - Return type inference
   - Multiple return path analysis
   - Exception handling analysis

### Comment Generation Architecture

#### Template Engine

```typescript
interface TemplateEngine {
    generateComment(func: Function, style: CommentStyle): string;
    applyTemplate(template: Template, data: TemplateData): string;
    formatComment(comment: string, style: Style): string;
    validateComment(comment: string): ValidationResult;
}
```

#### Comment Styles

##### JSDoc Style
```javascript
/**
 * Function description
 * @param {type} param - Parameter description
 * @returns {type} Return description
 */
```

##### Bilingual Style
```javascript
/**
 * English description / คำอธิบายภาษาไทย
 * @param {type} param - English desc / คำอธิบายไทย
 * @returns {type} Return desc / คำอธิบายการคืนค่า
 */
```

##### AI-Friendly Style
```javascript
// AI_FUNCTION: functionName
// PURPOSE: Function purpose
// INPUT: param types and descriptions
// OUTPUT: return type and description
// COMPLEXITY: O(n) time, O(1) space
```

### File Processing Architecture

#### Processing Pipeline

```
Input Files  File Validation  AST Parsing  Analysis  
Comment Generation  Code Modification  Backup Creation  Output
```

#### Safe File Modification

```typescript
interface FileProcessor {
    createBackup(filePath: string): Promise<string>;
    readFileContent(filePath: string): Promise<string>;
    writeFileContent(filePath: string, content: string): Promise<void>;
    validateModification(original: string, modified: string): boolean;
    rollbackChanges(filePath: string, backupPath: string): Promise<void>;
}
```

### Backup and Safety Architecture

#### Backup Strategy

```typescript
interface BackupManager {
    createBackup(filePath: string): Promise<BackupInfo>;
    validateBackup(backupPath: string): Promise<boolean>;
    restoreBackup(backupPath: string): Promise<void>;
    cleanupBackups(maxAge: number): Promise<void>;
}
```

#### Safety Measures

1. **Pre-processing Validation**
   - Syntax validation
   - File encoding detection
   - Permission verification

2. **During Processing**
   - AST validation
   - Incremental backup creation
   - Error recovery mechanisms

3. **Post-processing Verification**
   - Syntax validation of modified code
   - Comment quality assessment
   - Backup integrity verification

### Configuration Architecture

#### Configuration Hierarchy

```
Default Config  Project Config  User Config  CLI Arguments
```

#### Configuration Schema

```typescript
interface Configuration {
    processing: {
        addMissing: boolean;
        convertStyle: boolean;
        bilingual: boolean;
        aiFriendly: boolean;
    };
    style: {
        commentStyle: 'jsdoc' | 'inline' | 'block';
        indentation: number;
        lineLength: number;
    };
    language: {
        primary: 'en' | 'th' | 'auto';
        bilingual: boolean;
        aiOptimized: boolean;
    };
    files: {
        extensions: string[];
        exclude: string[];
        backup: boolean;
    };
}
```

### Bilingual Support Architecture

#### Language Processing Engine

```typescript
interface BilingualEngine {
    detectLanguage(text: string): Language;
    translateComment(comment: string, targetLang: Language): string;
    generateBilingualComment(func: Function): BilingualComment;
    validateTranslation(original: string, translated: string): boolean;
}
```

#### Translation Templates

```typescript
interface TranslationTemplates {
    functionDescriptions: Map<string, BilingualText>;
    parameterDescriptions: Map<string, BilingualText>;
    returnDescriptions: Map<string, BilingualText>;
    commonPhrases: Map<string, BilingualText>;
}
```

### AI-Friendly Format Architecture

#### AI Comment Generator

```typescript
interface AICommentGenerator {
    generateAIComment(func: Function): AIComment;
    formatForAI(comment: string): string;
    addMetadata(comment: AIComment, metadata: Metadata): AIComment;
    validateAIFormat(comment: string): boolean;
}
```

#### AI Comment Structure

```
// AI_FUNCTION: [function_name]
// PURPOSE: [clear function purpose]
// INPUT: [parameter descriptions with types]
// OUTPUT: [return value description with type]
// SIDE_EFFECTS: [any side effects]
// COMPLEXITY: [time and space complexity]
// DEPENDENCIES: [external dependencies]
```

### Error Handling and Recovery

#### Error Hierarchy

```
ProcessingError
├── ParseError
│   ├── SyntaxError
│   ├── EncodingError
│   └── TypeScriptError
├── AnalysisError
│   ├── FunctionAnalysisError
│   ├── TypeInferenceError
│   └── CommentAnalysisError
└── FileError
    ├── ReadError
    ├── WriteError
    └── BackupError
```

#### Recovery Mechanisms

1. **Graceful Degradation**
   - Partial processing on errors
   - Skip problematic functions
   - Continue with remaining files

2. **Automatic Recovery**
   - Backup restoration
   - Error correction attempts
   - Alternative parsing strategies

### Performance Architecture

#### Optimization Strategies

1. **AST Caching**
   ```typescript
   interface ASTCache {
       getCached(fileHash: string): AST | null;
       setCached(fileHash: string, ast: AST): void;
       invalidateCache(fileHash: string): void;
   }
   ```

2. **Incremental Processing**
   - Function-level change detection
   - Selective reprocessing
   - Diff-based analysis

3. **Parallel Processing**
   - Multi-file concurrent processing
   - Worker thread utilization
   - Resource pooling

#### Memory Management

```typescript
interface MemoryManager {
    trackMemoryUsage(): MemoryStats;
    optimizeASTStorage(): void;
    clearUnusedCaches(): void;
    monitorMemoryLeaks(): void;
}
```

### Testing Architecture

#### Test Strategy

1. **Unit Tests**
   - Individual component testing
   - Function analysis testing
   - Comment generation testing

2. **Integration Tests**
   - End-to-end processing
   - File modification testing
   - Backup and recovery testing

3. **Language Tests**
   - JavaScript/TypeScript compatibility
   - JSX/TSX processing
   - Edge case handling

#### Test Coverage

| Component | Coverage Target | Current |
|-----------|----------------|---------|
| AST Parser | 95% | 97% |
| Comment Generator | 90% | 93% |
| File Processor | 95% | 96% |
| Bilingual Engine | 85% | 87% |

### Future Architecture Considerations

#### Planned Enhancements

1. **AI Integration**
   - GPT-powered comment generation
   - Context-aware descriptions
   - Quality assessment AI

2. **IDE Extensions**
   - VS Code extension
   - Real-time comment suggestions
   - Interactive comment editing

3. **Language Expansion**
   - Python support
   - Java support
   - C++ support

#### Scalability Considerations

1. **Cloud Processing**
   - Distributed analysis
   - API-based processing
   - Real-time collaboration

2. **Enterprise Features**
   - Team standards enforcement
   - Code review integration
   - Compliance reporting

---

This architecture guide provides a comprehensive overview of the system design and implementation details. For specific implementation examples, see the [API Reference](API.md).