mcli-framework 7.8.3__py3-none-any.whl → 7.8.5__py3-none-any.whl

mcli/test/cron_test_cmd.py

@@ -1,697 +0,0 @@
-#!/usr/bin/env python3
-"""
-Cron validation and testing command for MCLI
-
-This command allows users to validate that the cron/scheduler functionality
-is working correctly by creating test jobs and monitoring their execution.
-"""
-
-import json
-import os
-import tempfile
-import time
-from datetime import datetime, timedelta
-from pathlib import Path
-
-import click
-
-from mcli.lib.ui.styling import console
-from mcli.workflow.scheduler.cron_parser import CronExpression
-from mcli.workflow.scheduler.job import JobStatus, JobType, ScheduledJob
-from mcli.workflow.scheduler.persistence import JobStorage
-from mcli.workflow.scheduler.scheduler import JobScheduler
-
-
-@click.command()
-@click.option(
-    "--quick", is_flag=True, help="Run quick validation (30 seconds) instead of full test"
-)
-@click.option("--cleanup", is_flag=True, help="Clean up test jobs and files after validation")
-@click.option("--verbose", "-v", is_flag=True, help="Show detailed output during testing")
-def cron_test(quick: bool, cleanup: bool, verbose: bool):
-    """
-    Validate MCLI cron/scheduler functionality with comprehensive tests.
-
-    This command creates test jobs, schedules them, and monitors execution
-    to ensure the cron system is working correctly.
-    """
-    console.print("\n[bold cyan]🕒 MCLI Cron Validation Test[/bold cyan]")
-    console.print("=" * 50)
-
-    # Test configuration
-    test_duration = 30 if quick else 90  # seconds
-    test_file = Path(tempfile.mkdtemp()) / "mcli_cron_test.txt"
-
-    try:
-        # Initialize components
-        scheduler = JobScheduler()
-        storage = JobStorage()
-
-        console.print(f"\n[green]📋 Test Configuration:[/green]")
-        console.print(f"  • Duration: {test_duration} seconds")
-        console.print(f"  • Test file: {test_file}")
-        console.print(f"  • Verbose: {'Yes' if verbose else 'No'}")
-
-        # Test 1: Basic scheduler functionality
-        console.print(f"\n[blue]Test 1: Scheduler Initialization[/blue]")
-        test_scheduler_init(scheduler, verbose)
-
-        # Test 2: Job creation and persistence
-        console.print(f"\n[blue]Test 2: Job Creation & Persistence[/blue]")
-        test_jobs = create_test_jobs(test_file, verbose, quick)
-
-        # Test 3: Job scheduling
-        console.print(f"\n[blue]Test 3: Job Scheduling[/blue]")
-        test_job_scheduling(scheduler, storage, test_jobs, verbose)
-
-        # Test 4: Cron expression parsing
-        console.print(f"\n[blue]Test 4: Cron Expression Parsing[/blue]")
-        test_cron_parsing(verbose)
-
-        # Test 5: Manual job execution test
-        console.print(f"\n[blue]Test 5: Manual Job Execution[/blue]")
-        test_manual_execution(scheduler, test_jobs[0] if test_jobs else None, test_file, verbose)
-
-        # Test 6: Job execution monitoring
-        console.print(f"\n[blue]Test 6: Job Execution Monitoring[/blue]")
-        monitor_job_execution(scheduler, storage, test_duration, test_file, verbose)
-
-        # Test 7: Results validation
-        console.print(f"\n[blue]Test 7: Results Validation[/blue]")
-        validate_results(test_file, storage, verbose)
-
-        # Test 8: Detailed job completion analysis
-        console.print(f"\n[blue]Test 8: Job Completion Analysis[/blue]")
-        analyze_job_completions(storage, test_file, verbose)
-
-        # Summary
-        show_test_summary(storage, test_jobs)
-
-    except Exception as e:
-        console.print(f"\n[red]❌ Test failed with error: {e}[/red]")
-        return False
-
-    finally:
-        if cleanup:
-            cleanup_test_environment(test_file, test_jobs, storage)
-
-    return True
-
-
-def test_scheduler_init(scheduler: JobScheduler, verbose: bool) -> bool:
-    """Test scheduler initialization"""
-    try:
-        console.print("  🔧 Initializing scheduler...")
-
-        # Test scheduler state
-        if hasattr(scheduler, "jobs"):
-            console.print("  ✅ Scheduler jobs dictionary initialized")
-        else:
-            raise Exception("Scheduler missing jobs dictionary")
-
-        # Test scheduler can be started/stopped
-        if hasattr(scheduler, "start") and hasattr(scheduler, "stop"):
-            console.print("  ✅ Scheduler has start/stop methods")
-        else:
-            raise Exception("Scheduler missing start/stop methods")
-
-        console.print("  [green]✅ Scheduler initialization: PASSED[/green]")
-        return True
-
-    except Exception as e:
-        console.print(f"  [red]❌ Scheduler initialization: FAILED - {e}[/red]")
-        return False
-
-
-def create_test_jobs(test_file: Path, verbose: bool, quick: bool = False) -> list:
-    """Create test jobs for validation"""
-    console.print("  🛠️ Creating test jobs...")
-
-    if quick:
-        # For quick tests, create jobs that should run immediately
-        from datetime import datetime
-
-        current_minute = datetime.now().minute
-        next_minute = (current_minute + 1) % 60
-
-        test_jobs = [
-            {
-                "name": "cron_test_immediate",
-                "cron": f"{next_minute} * * * *",  # Next minute
-                "type": JobType.COMMAND,
-                "command": f"echo 'Quick test job executed at $(date)' >> {test_file}",
-                "description": f"Test job that runs at minute {next_minute}",
-            },
-            {
-                "name": "cron_test_simple",
-                "cron": "* * * * *",  # Every minute (will run once during test)
-                "type": JobType.COMMAND,
-                "command": f"echo 'Simple test executed at $(date)' >> {test_file}",
-                "description": "Simple test job",
-            },
-        ]
-    else:
-        test_jobs = [
-            {
-                "name": "cron_test_every_minute",
-                "cron": "* * * * *",  # Every minute
-                "type": JobType.COMMAND,
-                "command": f"echo 'Test job executed at $(date)' >> {test_file}",
-                "description": "Test job that runs every minute",
-            },
-            {
-                "name": "cron_test_every_2min",
-                "cron": "*/2 * * * *",  # Every 2 minutes
-                "type": JobType.COMMAND,
-                "command": f"echo 'Long test job executed at $(date)' >> {test_file}",
-                "description": "Test job that runs every 2 minutes",
-            },
-            {
-                "name": "cron_test_python",
-                "cron": "* * * * *",  # Every minute
-                "type": JobType.PYTHON,
-                "command": f"""
-import datetime
-with open('{test_file}', 'a') as f:
-    f.write(f'Python test job executed at {{datetime.datetime.now()}}\\n')
-""",
-                "description": "Python test job that runs every minute",
-            },
-        ]
-
-    if verbose:
-        for job in test_jobs:
-            console.print(f"    • {job['name']}: {job['cron']} - {job['description']}")
-
-    console.print(f"  ✅ Created {len(test_jobs)} test jobs")
-    return test_jobs
-
-
-def test_job_scheduling(
-    scheduler: JobScheduler, storage: JobStorage, test_jobs: list, verbose: bool
-) -> bool:
-    """Test job scheduling functionality"""
-    console.print("  ⏰ Testing job scheduling...")
-
-    scheduled_count = 0
-
-    try:
-        for job_config in test_jobs:
-            # Create ScheduledJob object
-            job = ScheduledJob(
-                name=job_config["name"],
-                cron_expression=job_config["cron"],
-                job_type=job_config["type"],
-                command=job_config["command"],
-                description=job_config["description"],
-            )
-
-            # Schedule the job
-            scheduler.add_job(job)
-            storage.save_job(job)
-            scheduled_count += 1
-
-            if verbose:
-                console.print(f"    • Scheduled: {job.name}")
-
-        console.print(f"  ✅ Successfully scheduled {scheduled_count} jobs")
-        return True
-
-    except Exception as e:
-        console.print(f"  [red]❌ Job scheduling failed: {e}[/red]")
-        return False
-
-
-def test_manual_execution(
-    scheduler: JobScheduler, test_job_config: dict, test_file: Path, verbose: bool
-) -> bool:
-    """Test manual job execution to verify executor is working"""
-    if not test_job_config:
-        console.print("  ⚠️ No test job available for manual execution")
-        return False
-
-    console.print("  🚀 Testing manual job execution...")
-
-    try:
-        # Create a simple test job
-        test_job = ScheduledJob(
-            name="manual_test_job",
-            cron_expression="* * * * *",
-            job_type=JobType.COMMAND,
-            command=f"echo 'Manual test executed at $(date)' >> {test_file}",
-            description="Manual execution test",
-        )
-
-        # Get the executor from scheduler and execute directly
-        if hasattr(scheduler, "executor"):
-            result = scheduler.executor.execute_job(test_job)
-
-            if verbose:
-                console.print(f"    📊 Execution result: {result.get('status', 'unknown')}")
-                if result.get("output"):
-                    console.print(f"    📝 Output: {result['output'][:100]}...")
-
-            # Check if test file was created
-            if test_file.exists():
-                console.print("  ✅ Manual execution test: PASSED")
-                return True
-            else:
-                console.print("  ⚠️ Manual execution completed but no output file created")
-                return False
-        else:
-            console.print("  ⚠️ Scheduler has no executor attribute")
-            return False
-
-    except Exception as e:
-        console.print(f"  [red]❌ Manual execution test failed: {e}[/red]")
-        return False
-
-
-def test_cron_parsing(verbose: bool) -> bool:
-    """Test cron expression parsing"""
-    console.print("  📝 Testing cron expression parsing...")
-
-    test_expressions = [
-        ("* * * * *", "Every minute"),
-        ("0 * * * *", "Every hour"),
-        ("0 12 * * *", "Every day at noon"),
-        ("0 0 * * 1", "Every Monday at midnight"),
-        ("*/5 * * * *", "Every 5 minutes"),
-    ]
-
-    passed = 0
-
-    try:
-        for expr, description in test_expressions:
-            try:
-                cron = CronExpression(expr)
-                next_run = cron.get_next_run()
-
-                if next_run and next_run > datetime.now():
-                    passed += 1
-                    if verbose:
-                        console.print(f"    ✅ {expr} -> {description} (next: {next_run})")
-                else:
-                    if verbose:
-                        console.print(f"    ❌ {expr} -> Invalid next run time")
-
-            except Exception as e:
-                if verbose:
-                    console.print(f"    ❌ {expr} -> Parse error: {e}")
-
-        console.print(f"  ✅ Cron parsing: {passed}/{len(test_expressions)} expressions valid")
-        return passed == len(test_expressions)
-
-    except Exception as e:
-        console.print(f"  [red]❌ Cron parsing test failed: {e}[/red]")
-        return False
-
-
-def monitor_job_execution(
-    scheduler: JobScheduler, storage: JobStorage, duration: int, test_file: Path, verbose: bool
-):
-    """Monitor job execution for specified duration"""
-    console.print(f"  👀 Monitoring job execution for {duration} seconds...")
-
-    # Start scheduler
-    try:
-        scheduler.start()
-        console.print("  ✅ Scheduler started")
-    except Exception as e:
-        console.print(f"  ⚠️ Scheduler start warning: {e}")
-
-    # Monitor for specified duration
-    start_time = time.time()
-    last_check = 0
-
-    while (time.time() - start_time) < duration:
-        elapsed = int(time.time() - start_time)
-
-        # Show progress every 10 seconds
-        if elapsed > last_check + 10:
-            console.print(f"  ⏳ Monitoring... {elapsed}/{duration}s elapsed")
-
-            # Check if test file has been written to
-            if test_file.exists():
-                size = test_file.stat().st_size
-                if verbose and size > 0:
-                    console.print(f"    📝 Test file size: {size} bytes")
-
-            last_check = elapsed
-
-        time.sleep(1)
-
-    # Stop scheduler
-    try:
-        scheduler.stop()
-        console.print("  ✅ Scheduler stopped")
-    except Exception as e:
-        console.print(f"  ⚠️ Scheduler stop warning: {e}")
-
-
-def validate_results(test_file: Path, storage: JobStorage, verbose: bool) -> bool:
-    """Validate test results"""
-    console.print("  🔍 Validating test results...")
-
-    success = True
-
-    # Check test file exists and has content
-    if test_file.exists():
-        content = test_file.read_text()
-        lines = content.strip().split("\n") if content.strip() else []
-
-        console.print(f"  ✅ Test file created with {len(lines)} execution records")
-
-        if verbose and lines:
-            console.print("    📋 Execution log sample:")
-            for line in lines[:5]:  # Show first 5 lines
-                console.print(f"      {line}")
-            if len(lines) > 5:
-                console.print(f"      ... and {len(lines) - 5} more")
-
-        if len(lines) == 0:
-            console.print("  ⚠️ Warning: No job executions recorded")
-            success = False
-    else:
-        console.print("  [red]❌ Test file was not created[/red]")
-        success = False
-
-    # Check job statuses in storage
-    try:
-        jobs = storage.load_jobs()
-        console.print(f"  ✅ Found {len(jobs)} jobs in storage")
-
-        if verbose:
-            for job in jobs:
-                if hasattr(job, "name") and "cron_test" in job.name:
-                    status = job.status.value if hasattr(job, "status") else "unknown"
-                    console.print(f"    • {job.name}: {status}")
-
-    except Exception as e:
-        console.print(f"  ⚠️ Storage validation warning: {e}")
-
-    return success
-
-
-def analyze_job_completions(storage: JobStorage, test_file: Path, verbose: bool) -> bool:
-    """Analyze completed jobs with detailed metrics and output"""
-    console.print("  📊 Analyzing job completion details...")
-
-    try:
-        all_jobs = storage.load_jobs()
-        test_jobs = [
-            job
-            for job in all_jobs
-            if hasattr(job, "name") and ("cron_test" in job.name or "manual_test" in job.name)
-        ]
-
-        if not test_jobs:
-            console.print("  ⚠️ No test jobs found for analysis")
-            return False
-
-        console.print(f"  📋 Found {len(test_jobs)} test jobs for analysis")
-
-        # Categorize jobs by status
-        completed_jobs = []
-        running_jobs = []
-        failed_jobs = []
-        pending_jobs = []
-
-        for job in test_jobs:
-            if hasattr(job, "status"):
-                if job.status == JobStatus.COMPLETED:
-                    completed_jobs.append(job)
-                elif job.status == JobStatus.RUNNING:
-                    running_jobs.append(job)
-                elif job.status == JobStatus.FAILED:
-                    failed_jobs.append(job)
-                else:
-                    pending_jobs.append(job)
-
-        # Display job status summary
-        console.print(f"\n  📈 Job Status Summary:")
-        console.print(f"    ✅ Completed: {len(completed_jobs)}")
-        console.print(f"    🔄 Running: {len(running_jobs)}")
-        console.print(f"    ❌ Failed: {len(failed_jobs)}")
-        console.print(f"    ⏳ Pending: {len(pending_jobs)}")
-
-        # Detailed analysis of completed jobs
-        if completed_jobs:
-            console.print(f"\n  🔍 Detailed Completed Job Analysis:")
-            for job in completed_jobs:
-                analyze_individual_job(job, verbose)
-
-        # Analysis of failed jobs
-        if failed_jobs:
-            console.print(f"\n  ❌ Failed Job Analysis:")
-            for job in failed_jobs:
-                console.print(f"    • {job.name}:")
-                console.print(f"      Status: {job.status.value}")
-                if hasattr(job, "last_error") and job.last_error:
-                    console.print(f"      Error: {job.last_error}")
-                if hasattr(job, "run_count"):
-                    console.print(f"      Attempts: {job.run_count}")
-
-        # Execution output analysis
-        if test_file.exists():
-            console.print(f"\n  📄 Execution Output Analysis:")
-            analyze_execution_output(test_file, verbose)
-
-        # Performance metrics
-        console.print(f"\n  ⚡ Performance Metrics:")
-        calculate_performance_metrics(test_jobs, verbose)
-
-        return True
-
-    except Exception as e:
-        console.print(f"  [red]❌ Job completion analysis failed: {e}[/red]")
-        return False
-
-
-def analyze_individual_job(job: ScheduledJob, verbose: bool):
-    """Analyze a single completed job in detail"""
-    console.print(f"\n    🎯 Job: [cyan]{job.name}[/cyan]")
-    console.print(f"      ID: {job.id}")
-    console.print(f"      Status: [green]{job.status.value}[/green]")
-    console.print(f"      Type: {job.job_type.value}")
-    console.print(f"      Cron: {job.cron_expression}")
-
-    # Execution statistics
-    if hasattr(job, "run_count"):
-        console.print(f"      Total Runs: {job.run_count}")
-    if hasattr(job, "success_count"):
-        console.print(f"      Successful: {job.success_count}")
-    if hasattr(job, "failure_count"):
-        console.print(f"      Failed: {job.failure_count}")
-
-    # Timing information
-    if hasattr(job, "created_at"):
-        console.print(f"      Created: {job.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
-    if hasattr(job, "last_run") and job.last_run:
-        console.print(f"      Last Run: {job.last_run.strftime('%Y-%m-%d %H:%M:%S')}")
-    if hasattr(job, "runtime_seconds") and job.runtime_seconds > 0:
-        console.print(f"      Runtime: {job.runtime_seconds:.2f}s")
-
-    # Output and errors
-    if hasattr(job, "last_output") and job.last_output and verbose:
-        output_preview = (
-            job.last_output[:200] + "..." if len(job.last_output) > 200 else job.last_output
-        )
-        console.print(f"      Output: {output_preview}")
-
-    if hasattr(job, "last_error") and job.last_error:
-        console.print(f"      [red]Error: {job.last_error}[/red]")
-
-    # Command details
-    if verbose:
-        console.print(
-            f"      Command: {job.command[:100]}{'...' if len(job.command) > 100 else ''}"
-        )
-        if job.description:
-            console.print(f"      Description: {job.description}")
-
-
-def analyze_execution_output(test_file: Path, verbose: bool):
-    """Analyze the execution output file for insights"""
-    try:
-        content = test_file.read_text()
-        lines = content.strip().split("\n") if content.strip() else []
-
-        console.print(f"    📝 Output file contains {len(lines)} execution records")
-
-        if lines:
-            # Count different types of executions
-            manual_executions = len([line for line in lines if "Manual test" in line])
-            simple_executions = len([line for line in lines if "Simple test" in line])
-            other_executions = len(lines) - manual_executions - simple_executions
-
-            console.print(f"    • Manual tests: {manual_executions}")
-            console.print(f"    • Simple tests: {simple_executions}")
-            console.print(f"    • Other executions: {other_executions}")
-
-            # Show execution timeline if verbose
-            if verbose and lines:
-                console.print(f"\n    ⏰ Execution Timeline (showing last 5):")
-                for i, line in enumerate(lines[-5:], 1):
-                    console.print(f"      {i}. {line}")
-
-        # File size and creation info
-        file_stats = test_file.stat()
-        console.print(f"    📊 File size: {file_stats.st_size} bytes")
-        console.print(
-            f"    📅 Created: {datetime.fromtimestamp(file_stats.st_ctime).strftime('%H:%M:%S')}"
-        )
-        console.print(
-            f"    🔄 Modified: {datetime.fromtimestamp(file_stats.st_mtime).strftime('%H:%M:%S')}"
-        )
-
-    except Exception as e:
-        console.print(f"    [red]❌ Output analysis failed: {e}[/red]")
-
-
-def calculate_performance_metrics(test_jobs: list, verbose: bool):
-    """Calculate and display performance metrics"""
-    if not test_jobs:
-        console.print("    ⚠️ No jobs available for performance analysis")
-        return
-
-    total_runs = sum(getattr(job, "run_count", 0) for job in test_jobs)
-    total_successes = sum(getattr(job, "success_count", 0) for job in test_jobs)
-    total_failures = sum(getattr(job, "failure_count", 0) for job in test_jobs)
-
-    success_rate = (total_successes / total_runs * 100) if total_runs > 0 else 0
-
-    console.print(f"    📊 Overall Statistics:")
-    console.print(f"      Total Executions: {total_runs}")
-    console.print(f"      Success Rate: {success_rate:.1f}%")
-    console.print(f"      Successful: {total_successes}")
-    console.print(f"      Failed: {total_failures}")
-
-    # Average runtime calculation
-    runtime_jobs = [
-        job for job in test_jobs if hasattr(job, "runtime_seconds") and job.runtime_seconds > 0
-    ]
-    if runtime_jobs:
-        avg_runtime = sum(job.runtime_seconds for job in runtime_jobs) / len(runtime_jobs)
-        max_runtime = max(job.runtime_seconds for job in runtime_jobs)
-        min_runtime = min(job.runtime_seconds for job in runtime_jobs)
-
-        console.print(f"      Average Runtime: {avg_runtime:.2f}s")
-        console.print(f"      Max Runtime: {max_runtime:.2f}s")
-        console.print(f"      Min Runtime: {min_runtime:.2f}s")
-
-    # Job type distribution
-    if verbose:
-        job_types = {}
-        for job in test_jobs:
-            job_type = job.job_type.value if hasattr(job, "job_type") else "unknown"
-            job_types[job_type] = job_types.get(job_type, 0) + 1
-
-        console.print(f"\n    📈 Job Type Distribution:")
-        for job_type, count in job_types.items():
-            console.print(f"      {job_type}: {count} jobs")
-
-
-def show_test_summary(storage: JobStorage, test_jobs: list):
-    """Show comprehensive test summary"""
-    console.print(f"\n[bold green]📊 Final Test Summary[/bold green]")
-    console.print("=" * 40)
-
-    # Count test jobs and their statuses
-    try:
-        all_jobs = storage.load_jobs()
-        test_job_count = sum(
-            1 for job in all_jobs if hasattr(job, "name") and "cron_test" in job.name
-        )
-
-        # Status breakdown
-        status_counts = {}
-        for job in all_jobs:
-            if hasattr(job, "name") and "cron_test" in job.name:
-                status = job.status.value if hasattr(job, "status") else "unknown"
-                status_counts[status] = status_counts.get(status, 0) + 1
-
-        console.print(f"  📋 Test jobs created: {test_job_count}/{len(test_jobs)}")
-        if status_counts:
-            console.print(f"  📊 Final status breakdown:")
-            for status, count in status_counts.items():
-                emoji = {"completed": "✅", "running": "🔄", "failed": "❌", "pending": "⏳"}.get(
-                    status, "❓"
-                )
-                console.print(f"    {emoji} {status.capitalize()}: {count}")
-
-    except Exception as e:
-        console.print(f"  📋 Test jobs created: {len(test_jobs)} (storage check failed: {e})")
-
-    # Overall result with enhanced messaging
-    console.print("\n[bold green]🎉 MCLI Cron Validation Completed![/bold green]")
-
-    console.print("\n[cyan]✅ Successfully Tested Components:[/cyan]")
-    console.print("  • ✅ Scheduler initialization and control")
-    console.print("  • ✅ Job creation and persistence")
-    console.print("  • ✅ Manual job execution")
-    console.print("  • ✅ Job scheduling and monitoring")
-    console.print("  • ✅ File output and logging")
-    console.print("  • ✅ Performance metrics tracking")
-    console.print("  • ✅ Detailed completion analysis")
-
-    console.print("\n[yellow]🚀 Ready for Production Use![/yellow]")
-    console.print("Your cron system is fully functional and ready to schedule real jobs.")
-
-    console.print("\n[blue]💬 Chat Integration Commands:[/blue]")
-    console.print("  • 'list my jobs' - View all scheduled cron jobs")
-    console.print("  • 'what's my status?' - System overview with job info")
-    console.print("  • 'cancel job <name>' - Remove specific jobs")
-    console.print("  • 'schedule <task>' - Create new scheduled tasks")
-
-    console.print("\n[green]🔧 CLI Commands:[/green]")
-    console.print("  • mcli cron-test --quick - Fast validation (30s)")
-    console.print("  • mcli cron-test --verbose - Detailed output")
-    console.print("  • mcli cron-test --cleanup - Auto-cleanup test data")
-
-
-def cleanup_test_environment(test_file: Path, test_jobs: list, storage: JobStorage):
-    """Clean up test environment"""
-    console.print(f"\n[yellow]🧹 Cleaning up test environment...[/yellow]")
-
-    # Remove test file
-    try:
-        if test_file.exists():
-            test_file.unlink()
-            console.print("  ✅ Removed test file")
-
-        # Remove parent temp directory if empty
-        parent = test_file.parent
-        if parent.exists() and not list(parent.iterdir()):
-            parent.rmdir()
-            console.print("  ✅ Removed temp directory")
-
-    except Exception as e:
-        console.print(f"  ⚠️ File cleanup warning: {e}")
-
-    # Remove test jobs from storage
-    try:
-        all_jobs = storage.load_jobs()
-        remaining_jobs = []
-        removed_count = 0
-
-        for job in all_jobs:
-            if hasattr(job, "name") and "cron_test" in job.name:
-                removed_count += 1
-            else:
-                remaining_jobs.append(job)
-
-        # Save remaining jobs back
-        if removed_count > 0:
-            storage.jobs = remaining_jobs
-            storage.save_jobs()
-            console.print(f"  ✅ Removed {removed_count} test jobs from storage")
-
-    except Exception as e:
-        console.print(f"  ⚠️ Job cleanup warning: {e}")
-
-    console.print("  [green]✅ Cleanup completed[/green]")
-
-
-if __name__ == "__main__":
-    cron_test()