# Baba Yaga Implementation Alignment Plan

## 🎯 Goal: Achieve 90%+ Test Compatibility

Based on the comprehensive test analysis, here's a practical plan to align the JavaScript and C implementations of Baba Yaga.

## 📊 Current Status Breakdown

### JavaScript Implementation (28/34 tests passing - 82%)
**Strengths:**
- ✅ All unit tests pass (23/23)
- ✅ All integration tests pass (4/4)
- ✅ Strong core language support

**Weaknesses:**
- ❌ Array literal syntax (`[]`) not supported
- ❌ List concatenation (`concat`) not implemented
- ❌ Built-in function naming conflicts (`apply`)
- ❌ Advanced lambda calculus patterns limited

### C Implementation (25/34 tests passing - 74%)
**Strengths:**
- ✅ Basic arithmetic and logic work well
- ✅ Function definitions supported
- ✅ Case expressions working
- ✅ Some Turing completeness tests pass

**Weaknesses:**
- ❌ IO operations (`..out`, `..assert`) incomplete
- ❌ Function references (`@function`) not supported
- ❌ Advanced table operations limited
- ❌ Via operator missing
- ❌ Embedded functions not supported

## 🚀 Three-Phase Alignment Strategy

### Phase 1: Core Compatibility (Target: 26/34 tests passing)
**Focus**: Fix critical features that prevent basic language usage

#### 1.1 Fix C Implementation Core Issues

**Priority 1: IO Operations**
- **File**: `c/src/interpreter.c` or equivalent
- **Issue**: `..out` and `..assert` directives failing
- **Action**: Implement proper directive handling
- **Tests Fixed**: `05_io_operations.txt`

**Priority 2: Function References**
- **File**: `c/src/parser.c` and `c/src/interpreter.c`
- **Issue**: `@function` syntax not parsed
- **Action**: Add support for function reference operator
- **Tests Fixed**: `08_first_class_functions.txt`, `16_function_composition.txt`

#### 1.2 Fix JavaScript Implementation Core Issues

**Priority 1: Array Literals**
- **File**: `js/parser.js` and `js/lang.js`
- **Issue**: `[]` syntax not supported
- **Action**: Add array literal parsing and evaluation
- **Tests Fixed**: Multiple Turing completeness tests

**Priority 2: List Operations**
- **File**: `js/lang.js` (standard library)
- **Issue**: `concat` function missing
- **Action**: Implement array concatenation operator/function
- **Tests Fixed**: `05_loops_and_state.txt`, others

#### 1.3 Fix Test Naming Conflicts

**Priority 1: Rename Conflicting Identifiers**
- **Files**: `tests/turing-completeness/01_basic_proof.txt`
- **Issue**: `apply` conflicts with built-in function
- **Action**: Rename to `apply_func` or `call_func`
- **Tests Fixed**: `01_basic_proof.txt`

### Phase 2: Feature Expansion (Target: 30/34 tests passing)
**Focus**: Add advanced features to bring implementations closer to parity

#### 2.1 C Implementation Advanced Features

**Priority 1: Table Enhancements**
- **Files**: `c/src/parser.c`, `c/src/table.c`
- **Issue**: Complex table literals and operations
- **Action**: Improve table parsing and access methods
- **Tests Fixed**: `17_table_enhancements.txt`, `19_embedded_functions.txt`

**Priority 2: Via Operator**
- **Files**: `c/src/lexer.c`, `c/src/parser.c`
- **Issue**: Pipeline operator `via` not implemented
- **Action**: Add via operator token and evaluation
- **Tests Fixed**: `20_via_operator.txt`

#### 2.2 JavaScript Implementation Advanced Features

**Priority 1: Lambda Calculus Support**
- **Files**: `js/parser.js`, `js/lang.js`
- **Issue**: Advanced pattern matching in lambda expressions
- **Action**: Improve parser for complex lambda patterns
- **Tests Fixed**: `06_lambda_calculus.txt`, `07_complex_algorithms.txt`

### Phase 3: Full Compatibility (Target: 32+/34 tests passing)
**Focus**: Polish and optimize for complete feature parity

#### 3.1 Complex Algorithm Support
- **Both implementations**: Improve handling of recursive algorithms
- **Tests Fixed**: Remaining Turing completeness tests

#### 3.2 Integration Test Compatibility
- **Both implementations**: Ensure complex feature interactions work
- **Tests Fixed**: `integration_03_functional_programming.txt`

## 🛠️ Immediate Action Items (Week 1)

### 1. Quick Wins - Test File Modifications

Create compatibility versions of failing tests that work with current implementations:

```bash
# Create modified test files
cp tests/turing-completeness/01_basic_proof.txt tests/turing-completeness/01_basic_proof_compat.txt
cp tests/turing-completeness/05_loops_and_state.txt tests/turing-completeness/05_loops_and_state_compat.txt
```

**Modify these files to:**
- Replace `apply` with `apply_func`
- Replace `[]` with table-based alternatives
- Replace `concat` with table merging operations
- Simplify advanced lambda calculus patterns

### 2. Critical C Implementation Fixes

**File: `c/src/interpreter.c`**
```c
// Add support for ..out directive
case TOKEN_DOT_DOT_OUT:
    // Implement output handling
    printf("%s\n", evaluate_expression(expr));
    break;

// Add support for ..assert directive  
case TOKEN_DOT_DOT_ASSERT:
    // Implement assertion checking
    if (!evaluate_boolean_expression(expr)) {
        error("Assertion failed");
    }
    break;
```

**File: `c/src/parser.c`**
```c
// Add support for @ function references
case TOKEN_AT:
    advance(); // consume @
    // Parse function reference
    return create_function_reference(current_token.value);
```

### 3. Critical JavaScript Implementation Fixes

**File: `js/parser.js`**
```javascript
// Add support for array literals
parsePrimary() {
    if (this.match('LEFT_BRACKET')) {
        return this.parseArrayLiteral();
    }
    // ... existing code
}

parseArrayLiteral() {
    const elements = [];
    if (!this.check('RIGHT_BRACKET')) {
        do {
            elements.push(this.expression());
        } while (this.match('COMMA'));
    }
    this.consume('RIGHT_BRACKET', "Expected ']' after array elements");
    return { type: 'ArrayLiteral', elements };
}
```

## 📋 Weekly Milestone Tracking

### Week 1: Foundation
- [ ] Fix C IO operations
- [ ] Fix C function references  
- [ ] Fix JS array literals
- [ ] Create compatibility test files
- **Target**: 26/34 tests passing on both implementations

### Week 2: Advanced Features
- [ ] Implement C table enhancements
- [ ] Implement C via operator
- [ ] Improve JS lambda calculus support
- **Target**: 30/34 tests passing on both implementations

### Week 3: Integration & Polish
- [ ] Fix remaining integration tests
- [ ] Optimize complex algorithms
- [ ] Performance tuning
- **Target**: 32+/34 tests passing on both implementations

## 🎯 Success Criteria

### Minimum Viable Compatibility (MVP)
- **Both implementations pass core unit tests (1-14)**
- **Both implementations pass basic integration tests**
- **Basic Turing completeness demonstrated**

### Full Compatibility Goal
- **Both implementations pass 32+ of 34 tests**
- **Identical behavior on all supported features**
- **Clear documentation of any remaining differences**

## 🔄 Iterative Testing Process

After each fix:

1. **Test Specific Feature**:
   ```bash
   ./tests/run_shared_tests.sh js unit | grep "Feature Name"
   ./tests/run_shared_tests.sh c unit | grep "Feature Name"
   ```

2. **Test Full Suite**:
   ```bash
   ./tests/run_shared_tests.sh js > js_results.txt
   ./tests/run_shared_tests.sh c > c_results.txt
   diff js_results.txt c_results.txt
   ```

3. **Document Progress**:
   - Update this plan with actual results
   - Note any new issues discovered
   - Adjust priorities based on findings

## 💡 Key Principles

1. **JavaScript as Reference**: All features must work in JS first
2. **Incremental Progress**: Fix one feature category at a time
3. **Test-Driven**: Every fix must be verified by passing tests
4. **Documentation**: Keep detailed records of changes and decisions
5. **Backward Compatibility**: Don't break existing working features

The goal is systematic, measurable progress toward full implementation alignment, with JavaScript serving as the authoritative reference implementation.