Complete Phase 3: Export & Integration

- Add DataExporter class with CSV, JSON export functionality
- Implement database backup/restore capabilities
- Create ConfigManager for application configuration
- Add CLI commands for export (csv, json), backup, and restore
- All features fully tested with TDD approach
- 25 new tests added, maintaining test coverage

Author: AnrokX

src/cli.py

@@ -185,5 +185,125 @@ def today():
     click.echo("")
 
 
+@cli.group()
+def export():
+    """Export tracking data in various formats."""
+    pass
+
+
+@export.command('csv')
+@click.option('--output', '-o', type=click.Path(), required=True, help='Output file path')
+@click.option('--start', type=str, help='Start date (YYYY-MM-DD)')
+@click.option('--end', type=str, help='End date (YYYY-MM-DD)')
+def export_csv(output, start, end):
+    """Export data to CSV format."""
+    try:
+        from src.core.export import DataExporter
+        
+        if not DB_PATH.exists():
+            click.echo("No tracking data found.")
+            return
+        
+        exporter = DataExporter(DB_PATH)
+        
+        # Parse dates if provided
+        start_time = None
+        end_time = None
+        if start:
+            start_time = datetime.strptime(start, '%Y-%m-%d').timestamp()
+        if end:
+            end_time = datetime.strptime(end, '%Y-%m-%d').timestamp()
+        
+        output_path = Path(output)
+        if exporter.export_to_csv(output_path, start_time, end_time):
+            click.echo(f"Data exported to {output_path}")
+        else:
+            click.echo("Export failed.", err=True)
+            
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@export.command('json')
+@click.option('--output', '-o', type=click.Path(), required=True, help='Output file path')
+@click.option('--start', type=str, help='Start date (YYYY-MM-DD)')
+@click.option('--end', type=str, help='End date (YYYY-MM-DD)')
+def export_json(output, start, end):
+    """Export data to JSON format."""
+    try:
+        from src.core.export import DataExporter
+        
+        if not DB_PATH.exists():
+            click.echo("No tracking data found.")
+            return
+        
+        exporter = DataExporter(DB_PATH)
+        
+        # Parse dates if provided
+        start_time = None
+        end_time = None
+        if start:
+            start_time = datetime.strptime(start, '%Y-%m-%d').timestamp()
+        if end:
+            end_time = datetime.strptime(end, '%Y-%m-%d').timestamp()
+        
+        output_path = Path(output)
+        if exporter.export_to_json(output_path, start_time, end_time):
+            click.echo(f"Data exported to {output_path}")
+        else:
+            click.echo("Export failed.", err=True)
+            
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@cli.command()
+@click.option('--output', '-o', type=click.Path(), required=True, help='Backup file path')
+def backup(output):
+    """Create a backup of the database."""
+    try:
+        from src.core.export import DataExporter
+        
+        if not DB_PATH.exists():
+            click.echo("No database to backup.")
+            return
+        
+        exporter = DataExporter(DB_PATH)
+        output_path = Path(output)
+        
+        if exporter.backup_database(output_path):
+            click.echo(f"Database backed up to {output_path}")
+        else:
+            click.echo("Backup failed.", err=True)
+            
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
+@cli.command()
+@click.option('--input', '-i', 'input_file', type=click.Path(exists=True), required=True, help='Backup file to restore')
+def restore(input_file):
+    """Restore database from backup."""
+    try:
+        from src.core.export import DataExporter
+        
+        backup_path = Path(input_file)
+        
+        if DB_PATH.exists():
+            if not click.confirm("This will overwrite existing data. Continue?"):
+                return
+        
+        ensure_config_dir()
+        exporter = DataExporter(DB_PATH)
+        
+        if exporter.restore_database(backup_path):
+            click.echo(f"Database restored from {backup_path}")
+        else:
+            click.echo("Restore failed.", err=True)
+            
+    except Exception as e:
+        click.echo(f"Error: {str(e)}", err=True)
+
+
 if __name__ == '__main__':
     cli()

src/utils/config.py

@@ -0,0 +1,132 @@
+"""
+Configuration management for Tempo.
+"""
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+import copy
+
+
+class ConfigManager:
+    """Manages application configuration."""
+    
+    # Default configuration
+    DEFAULTS = {
+        'tracking': {
+            'sample_interval': 10,      # seconds between samples
+            'idle_timeout': 300,         # seconds before marking as idle
+            'min_duration': 60,          # minimum session duration to record
+        },
+        'database': {
+            'path': '~/.tempo/tempo.db',
+            'backup': {
+                'enabled': False,
+                'interval_days': 7,
+            }
+        },
+        'export': {
+            'default_format': 'csv',
+            'auto_backup': False,
+            'backup_interval_days': 7,
+        },
+        'categories': {
+            'productive': [],
+            'neutral': [],
+            'distracting': [],
+        },
+        'goals': {
+            'daily_productive_hours': 0,
+            'max_distracting_hours': 0,
+        }
+    }
+    
+    VALID_EXPORT_FORMATS = ['csv', 'json', 'pdf']
+    
+    def __init__(self, config_file: Optional[Path] = None):
+        """Initialize configuration manager."""
+        self.config_file = config_file
+        self.config = copy.deepcopy(self.DEFAULTS)
+        
+        if config_file:
+            self._load_from_file()
+    
+    def _load_from_file(self):
+        """Load configuration from file."""
+        if not self.config_file or not self.config_file.exists():
+            return
+        
+        try:
+            with open(self.config_file, 'r') as f:
+                loaded_config = json.load(f)
+                self._merge_config(loaded_config)
+        except (json.JSONDecodeError, IOError):
+            # Use defaults on error
+            pass
+    
+    def _merge_config(self, updates: Dict[str, Any]):
+        """Merge updates into configuration."""
+        def merge_dict(base: dict, updates: dict):
+            for key, value in updates.items():
+                if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+                    merge_dict(base[key], value)
+                else:
+                    base[key] = value
+        
+        merge_dict(self.config, updates)
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get configuration value using dot notation."""
+        keys = key.split('.')
+        value = self.config
+        
+        for k in keys:
+            if isinstance(value, dict) and k in value:
+                value = value[k]
+            else:
+                return default
+        
+        return value
+    
+    def set(self, key: str, value: Any):
+        """Set configuration value using dot notation."""
+        # Validate specific keys
+        if key == 'tracking.sample_interval' and value <= 0:
+            raise ValueError("Sample interval must be positive")
+        
+        if key == 'export.default_format' and value not in self.VALID_EXPORT_FORMATS:
+            raise ValueError(f"Export format must be one of {self.VALID_EXPORT_FORMATS}")
+        
+        # Set the value
+        keys = key.split('.')
+        config = self.config
+        
+        # Create nested structure
+        for k in keys[:-1]:
+            if k not in config or not isinstance(config[k], dict):
+                config[k] = {}
+            config = config[k]
+        
+        config[keys[-1]] = value
+    
+    def update(self, updates: Dict[str, Any]):
+        """Update configuration from dictionary."""
+        self._merge_config(updates)
+    
+    def save(self):
+        """Save configuration to file."""
+        if not self.config_file:
+            return
+        
+        # Create parent directory if needed
+        self.config_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(self.config_file, 'w') as f:
+            json.dump(self.config, f, indent=2)
+    
+    def get_all(self) -> Dict[str, Any]:
+        """Get entire configuration."""
+        return copy.deepcopy(self.config)
+    
+    def reset_to_defaults(self):
+        """Reset configuration to defaults."""
+        self.config = copy.deepcopy(self.DEFAULTS)