fido 0.1.1

# Debug Logging Infrastructure Implementation

## Overview
This document describes the debug logging infrastructure added to the Fido TUI application for diagnosing modal rendering and state issues.

## Files Created/Modified

### New Files
1. **`src/debug_log.rs`** - Core logging module with helper functions
2. **`src/lib.rs`** - Library interface for testing
3. **`tests/debug_log_test.rs`** - Unit tests for logging functions
4. **`tests/integration_test.rs`** - Integration test simulating application flow

### Modified Files
1. **`src/main.rs`** - Added debug_log module import, clear_debug_log() on startup, and key event logging
2. **`src/ui/tabs.rs`** - Added debug_log import and logging at render points

## Implementation Details

### Debug Log Module (`src/debug_log.rs`)

#### Constants
- `DEBUG_LOG_FILE: &str = "fido_modal_debug.log"` - Log file path

#### Functions
- `clear_debug_log()` - Clears/creates the log file (called on app startup)
- `log_modal_state(viewing_post_detail, show_full_post_modal, composer_open, composer_mode)` - Logs modal state
- `log_key_event(key_code, modal_context)` - Logs keyboard events with context
- `log_debug(message)` - Logs custom debug messages
- `append_to_log(message)` - Internal function that adds timestamps and writes to file

### Integration Points

#### Application Startup (`src/main.rs`)
```rust
#[tokio::main]
async fn main() -> Result<()> {
    // Clear debug log on startup
    debug_log::clear_debug_log();
    // ... rest of initialization
}
```

#### Key Event Logging (`src/main.rs`)
```rust
if let Event::Key(key) = event {
    if key.kind == KeyEventKind::Press {
        // Log key event with modal context
        let modal_context = if app.composer_state.is_open() {
            "composer_open"
        } else if app.viewing_post_detail {
            "post_detail"
        } else {
            "main_view"
        };
        debug_log::log_key_event(&format!("{:?}", key.code), modal_context);
        // ... handle key event
    }
}
```

#### Modal Rendering Logging (`src/ui/tabs.rs`)

**At start of render_main_screen (before modal rendering):**
```rust
// Log modal state before rendering
let composer_mode = if let Some(mode) = &app.composer_state.mode {
    format!("{:?}", mode)
} else {
    "None".to_string()
};
debug_log::log_modal_state(
    app.viewing_post_detail,
    app.post_detail_state.as_ref().map(|s| s.show_full_post_modal).unwrap_or(false),
    app.composer_state.is_open(),
    &composer_mode,
);
```

**Before thread modal rendering:**
```rust
if show_full_post_modal {
    debug_log::log_debug("Rendering thread modal (full post modal)");
    if !app.composer_state.is_open() {
        debug_log::log_debug("Rendering dimmed background");
        render_dimmed_background(frame, area);
    } else {
        debug_log::log_debug("Skipping dimmed background (composer is open)");
    }
    render_full_post_modal(frame, app, area);
}
```

**Before composer modal rendering:**
```rust
if app.composer_state.is_open() {
    debug_log::log_debug(&format!("Rendering composer modal (mode: {})", composer_mode));
    render_unified_composer_modal(frame, app, area);
}
```

**At start of render_posts_tab_with_data:**
```rust
pub fn render_posts_tab_with_data(frame: &mut Frame, app: &mut App, area: Rect) {
    debug_log::log_debug("render_posts_tab_with_data: START");
    // ... rest of function
}
```

## Log Format

Each log entry includes:
- Timestamp: `[YYYY-MM-DD HH:MM:SS.mmm]`
- Message content

### Example Log Output
```
[2024-12-04 15:30:45.123] MODAL_STATE: viewing_post_detail=true, show_full_post_modal=true, composer_open=false, composer_mode=None
[2024-12-04 15:30:45.124] render_posts_tab_with_data: START
[2024-12-04 15:30:45.125] Rendering thread modal (full post modal)
[2024-12-04 15:30:45.126] Rendering dimmed background
[2024-12-04 15:30:45.234] KEY_EVENT: key=Char('r'), context=post_detail
[2024-12-04 15:30:45.235] MODAL_STATE: viewing_post_detail=true, show_full_post_modal=true, composer_open=true, composer_mode=Reply
[2024-12-04 15:30:45.236] Rendering thread modal (full post modal)
[2024-12-04 15:30:45.237] Skipping dimmed background (composer is open)
[2024-12-04 15:30:45.238] Rendering composer modal (mode: Reply)
```

## Testing

### Unit Tests (`tests/debug_log_test.rs`)
- `test_debug_log_creation` - Verifies log file can be created
- `test_log_file_constant` - Verifies constant is correct
- `test_clear_debug_log` - Tests clear functionality
- `test_log_modal_state` - Tests modal state logging
- `test_log_key_event` - Tests key event logging
- `test_log_debug` - Tests custom debug logging

### Integration Test (`tests/integration_test.rs`)
- `test_logging_integration` - Simulates full application flow with logging

All tests pass successfully.

## Usage

1. **Run the application** - The log file is automatically cleared on startup
2. **Interact with modals** - All modal operations are logged
3. **Review logs** - Open `fido_modal_debug.log` to see detailed execution trace
4. **Debug issues** - Use timestamps and state information to diagnose problems

## Requirements Satisfied

This implementation satisfies all requirements from task 1:
- ✅ Created log helper functions (log_modal_state, log_key_event, log_debug, clear_debug_log)
- ✅ Added log file path constant: `fido_modal_debug.log`
- ✅ Called clear_debug_log() on application startup in main.rs
- ✅ Added logging to render_posts_tab function in tabs.rs
- ✅ Added logging to key event handler in main.rs
- ✅ Tested that logs are being written correctly (6 unit tests + 1 integration test)
- ✅ Satisfies Requirements: 4.1, 4.2, 4.3, 4.4, 4.5