mcli-framework 7.0.0__py3-none-any.whl

mcli/workflow/sync/test_cmd.py

@@ -0,0 +1,314 @@
+"""
+Multi-cloud sync testing commands for mcli workflow system.
+Provides comprehensive connectivity and validation testing.
+"""
+
+import json
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional
+
+import click
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class McliSyncTester:
+    """MCLI-integrated sync testing functionality."""
+
+    def __init__(self, vault_path: str = "."):
+        self.vault_path = Path(vault_path).resolve()
+        self.test_script = self.vault_path / "test_sync_connectivity.py"
+
+    def run_connectivity_test(self, quick: bool = False, output_file: Optional[str] = None) -> Dict:
+        """Run connectivity tests using the standalone test script."""
+
+        if not self.test_script.exists():
+            raise FileNotFoundError(f"Test script not found: {self.test_script}")
+
+        # Build command
+        cmd = [sys.executable, str(self.test_script), "--vault-path", str(self.vault_path)]
+
+        if quick:
+            cmd.append("--quick")
+
+        if output_file:
+            cmd.extend(["--output", output_file])
+
+        try:
+            # Run the test script
+            result = subprocess.run(
+                cmd,
+                cwd=self.vault_path,
+                capture_output=True,
+                text=True,
+                timeout=300,  # 5 minute timeout
+            )
+
+            # Parse output if JSON report was generated
+            report = None
+            if output_file and Path(output_file).exists():
+                try:
+                    with open(output_file, "r") as f:
+                        report = json.load(f)
+                except Exception as e:
+                    logger.warning(f"Could not parse test report: {e}")
+
+            return {
+                "returncode": result.returncode,
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "report": report,
+                "success": result.returncode == 0,
+            }
+
+        except subprocess.TimeoutExpired:
+            return {
+                "returncode": -1,
+                "stdout": "",
+                "stderr": "Test timed out after 5 minutes",
+                "report": None,
+                "success": False,
+            }
+        except Exception as e:
+            return {
+                "returncode": -1,
+                "stdout": "",
+                "stderr": str(e),
+                "report": None,
+                "success": False,
+            }
+
+    def validate_cloud_connectivity(self) -> Dict[str, bool]:
+        """Quick validation of cloud service connectivity."""
+
+        cloud_paths = {
+            "onedrive": Path.home() / "Library/CloudStorage/OneDrive-Personal",
+            "icloud": Path.home() / "Library/Mobile Documents/com~apple~CloudDocs",
+            "googledrive": Path.home() / "Library/CloudStorage/GoogleDrive-luis@lefv.io/My Drive",
+        }
+
+        results = {}
+
+        for service, path in cloud_paths.items():
+            try:
+                if path.exists() and path.is_dir():
+                    # Test write access
+                    test_file = path / ".mcli_connectivity_test"
+                    test_file.write_text(f"Connectivity test - {datetime.now().isoformat()}")
+
+                    if test_file.exists():
+                        test_file.unlink()
+                        results[service] = True
+                    else:
+                        results[service] = False
+                else:
+                    results[service] = False
+
+            except Exception as e:
+                logger.debug(f"Connectivity test failed for {service}: {e}")
+                results[service] = False
+
+        return results
+
+    def check_sync_health(self) -> Dict[str, any]:
+        """Check overall sync system health."""
+
+        health = {
+            "timestamp": datetime.now().isoformat(),
+            "vault_path": str(self.vault_path),
+            "system_ready": True,
+            "issues": [],
+        }
+
+        # Check vault directory
+        if not self.vault_path.exists():
+            health["system_ready"] = False
+            health["issues"].append(f"Vault directory not found: {self.vault_path}")
+
+        # Check git repository
+        git_dir = self.vault_path / ".git"
+        if not git_dir.exists():
+            health["issues"].append("Not a git repository")
+
+        # Check sync configuration
+        config_file = self.vault_path / ".vault_sync_config.json"
+        if not config_file.exists():
+            health["system_ready"] = False
+            health["issues"].append("Sync configuration not found")
+
+        # Check cloud connectivity
+        cloud_status = self.validate_cloud_connectivity()
+        health["cloud_connectivity"] = cloud_status
+
+        offline_services = [service for service, online in cloud_status.items() if not online]
+        if offline_services:
+            health["issues"].extend([f"{service} not accessible" for service in offline_services])
+
+        return health
+
+
+@click.group(name="test")
+def test():
+    """Testing commands for sync functionality."""
+    pass
+
+
+@test.command()
+@click.option("--vault-path", default=".", help="Path to vault directory")
+@click.option("--quick", is_flag=True, help="Run quick tests only")
+@click.option("--output", help="Save detailed report to JSON file")
+def connectivity(vault_path, quick, output):
+    """Run comprehensive connectivity tests for all cloud services."""
+
+    tester = McliSyncTester(vault_path)
+
+    click.echo("🧪 Running Multi-Cloud Sync Connectivity Tests...")
+    click.echo("=" * 50)
+
+    # Run the tests
+    result = tester.run_connectivity_test(quick=quick, output_file=output)
+
+    # Display results
+    if result["stdout"]:
+        click.echo(result["stdout"])
+
+    if result["stderr"]:
+        click.echo(f"\n❌ Errors:\n{result['stderr']}")
+
+    # Show summary from report if available
+    if result["report"]:
+        report = result["report"]
+        stats = report.get("statistics", {})
+        success_rate = report.get("success_rate", 0)
+
+        click.echo("\n" + "=" * 50)
+        click.echo("📊 MCLI Test Summary")
+        click.echo("=" * 50)
+        click.echo(f"Success Rate: {success_rate:.1f}%")
+        click.echo(f"Total Tests: {stats.get('total_tests', 0)}")
+        click.echo(f"✅ Passed: {stats.get('passed', 0)}")
+        click.echo(f"❌ Failed: {stats.get('failed', 0)}")
+
+        if success_rate >= 90:
+            click.echo("\n🎉 Excellent! Your sync system is working perfectly.")
+        elif success_rate >= 70:
+            click.echo("\n✅ Good! Minor issues may need attention.")
+        else:
+            click.echo("\n⚠️ Issues detected. Please review the detailed output above.")
+
+    # Exit with appropriate code
+    if not result["success"]:
+        sys.exit(1)
+
+
+@test.command()
+@click.option("--vault-path", default=".", help="Path to vault directory")
+def health(vault_path):
+    """Check sync system health status."""
+
+    tester = McliSyncTester(vault_path)
+
+    click.echo("🏥 Checking Sync System Health...")
+
+    health = tester.check_sync_health()
+
+    # Display health status
+    if health["system_ready"]:
+        click.echo("✅ System Ready")
+    else:
+        click.echo("❌ System Issues Detected")
+
+    click.echo(f"📁 Vault: {health['vault_path']}")
+    click.echo(f"🕒 Checked: {health['timestamp']}")
+
+    # Cloud connectivity status
+    click.echo("\n☁️ Cloud Service Status:")
+    cloud_status = health.get("cloud_connectivity", {})
+    for service, online in cloud_status.items():
+        status = "✅ Online" if online else "❌ Offline"
+        click.echo(f"  {service.title()}: {status}")
+
+    # Issues
+    if health["issues"]:
+        click.echo("\n⚠️ Issues Found:")
+        for i, issue in enumerate(health["issues"], 1):
+            click.echo(f"  {i}. {issue}")
+    else:
+        click.echo("\n🎉 No issues detected!")
+
+    # Exit with error if system not ready
+    if not health["system_ready"]:
+        sys.exit(1)
+
+
+@test.command()
+@click.option("--vault-path", default=".", help="Path to vault directory")
+@click.option(
+    "--service",
+    type=click.Choice(["github", "onedrive", "icloud", "googledrive", "all"]),
+    default="all",
+    help="Service to test",
+)
+def sync(vault_path, service):
+    """Test sync functionality for specific service or all services."""
+
+    # Import the sync functionality
+    try:
+        sys.path.insert(0, vault_path)
+        from vault_sync_standalone import VaultSync
+    except ImportError:
+        click.echo(
+            "❌ Could not import sync functionality. Ensure vault_sync_standalone.py is available."
+        )
+        sys.exit(1)
+
+    syncer = VaultSync(vault_path)
+
+    click.echo(f"🔄 Testing Sync Functionality - {service.title()}...")
+
+    services_to_test = (
+        [service] if service != "all" else ["github", "onedrive", "icloud", "googledrive"]
+    )
+
+    results = {}
+
+    for svc in services_to_test:
+        click.echo(f"\n🔄 Testing {svc.title()}...")
+
+        try:
+            if svc == "github":
+                success = syncer.git_sync()
+            else:
+                success = syncer.cloud_sync(svc)
+
+            if success:
+                click.echo(f"✅ {svc.title()}: Sync successful")
+                results[svc] = True
+            else:
+                click.echo(f"❌ {svc.title()}: Sync failed")
+                results[svc] = False
+
+        except Exception as e:
+            click.echo(f"💥 {svc.title()}: Error - {e}")
+            results[svc] = False
+
+    # Summary
+    successful = sum(results.values())
+    total = len(results)
+
+    click.echo(f"\n📊 Sync Test Results: {successful}/{total} successful")
+
+    if successful == total:
+        click.echo("🎉 All sync tests passed!")
+    else:
+        click.echo("⚠️ Some sync tests failed. Check configuration and connectivity.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    test()

mcli/workflow/videos/videos.py

@@ -0,0 +1,242 @@
+import os
+import sys
+from pathlib import Path
+
+import click
+
+# Add the app/video directory to the path so we can import the video processor
+app_video_path = Path(__file__).parent.parent.parent / "app" / "video"
+sys.path.insert(0, str(app_video_path))
+
+# Lazy import variables
+_video_module = None
+_import_error = None
+
+
+def _get_video_module():
+    """Lazy import of video processing module."""
+    global _video_module, _import_error
+
+    if _video_module is not None:
+        return _video_module
+
+    if _import_error is not None:
+        raise _import_error
+
+    try:
+        from mcli.app.video.video import (
+            CONFIG,
+            EnhancedVideoProcessor,
+            IntelligentVideoProcessor,
+            VideoProcessor,
+        )
+
+        _video_module = {
+            "VideoProcessor": VideoProcessor,
+            "EnhancedVideoProcessor": EnhancedVideoProcessor,
+            "IntelligentVideoProcessor": IntelligentVideoProcessor,
+            "CONFIG": CONFIG,
+        }
+    except ImportError:
+        try:
+            # Fallback import
+            import importlib.util
+
+            spec = importlib.util.spec_from_file_location("video", app_video_path / "video.py")
+            video_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(video_module)
+
+            _video_module = {
+                "VideoProcessor": video_module.VideoProcessor,
+                "EnhancedVideoProcessor": video_module.EnhancedVideoProcessor,
+                "IntelligentVideoProcessor": video_module.IntelligentVideoProcessor,
+                "CONFIG": video_module.CONFIG,
+            }
+        except Exception as e:
+            _import_error = ImportError(f"Could not import video processing modules: {e}")
+            # Return basic fallback
+            _video_module = {
+                "VideoProcessor": None,
+                "EnhancedVideoProcessor": None,
+                "IntelligentVideoProcessor": None,
+                "CONFIG": {"temp_dir": "./temp", "output_dir": "./output"},
+            }
+
+    return _video_module
+
+
+@click.group()
+def videos():
+    """Video processing and overlay removal tools."""
+    pass
+
+
+@videos.command()
+@click.argument("input_video", type=click.Path(exists=True))
+@click.option("--output", "-o", type=click.Path(), help="Output video path")
+@click.option("--fps", "-f", default=30, help="Frame extraction rate (default: 30)")
+@click.option("--context", "-c", default=3, help="Temporal context window size (default: 3)")
+@click.option(
+    "--method",
+    type=click.Choice(["intelligent", "basic"]),
+    default="intelligent",
+    help="Processing method (default: intelligent)",
+)
+@click.option("--dry-run", is_flag=True, help="Only extract frames and analyze video")
+def remove_overlay(input_video, output, fps, context, method, dry_run):
+    """Remove overlays from videos with intelligent content reconstruction."""
+
+    try:
+        video_module = _get_video_module()
+    except ImportError as e:
+        click.echo(click.style(f"❌ Video processing modules not available: {e}", fg="red"))
+        return
+
+    VideoProcessor = video_module["VideoProcessor"]
+    EnhancedVideoProcessor = video_module["EnhancedVideoProcessor"]
+    IntelligentVideoProcessor = video_module["IntelligentVideoProcessor"]
+
+    if VideoProcessor is None:
+        click.echo(
+            click.style(
+                "❌ Video processing modules not available. Please install required dependencies.",
+                fg="red",
+            )
+        )
+        return
+
+    if method == "intelligent":
+        if IntelligentVideoProcessor is None:
+            click.echo(
+                click.style(
+                    "❌ Intelligent video processor not available. Using basic processor.",
+                    fg="yellow",
+                )
+            )
+            processor = EnhancedVideoProcessor() if EnhancedVideoProcessor else VideoProcessor()
+        else:
+            processor = IntelligentVideoProcessor()
+
+        if dry_run:
+            click.echo(
+                click.style(
+                    "🔍 Dry run mode - extracting frames and analyzing video only", fg="cyan"
+                )
+            )
+            frame_paths = processor.extract_frames(input_video, fps)
+            click.echo(
+                click.style(
+                    f"✅ Dry run complete. Extracted {len(frame_paths)} frames to {processor.temp_dir}",
+                    fg="green",
+                )
+            )
+            click.echo(click.style(f"📁 Temp directory: {processor.temp_dir}", fg="blue"))
+            if hasattr(processor, "video_info"):
+                click.echo(click.style(f"🎬 Video info: {processor.video_info}", fg="blue"))
+            return
+
+        if hasattr(processor, "remove_overlay_from_video_intelligent"):
+            result = processor.remove_overlay_from_video_intelligent(
+                video_path=input_video, output_path=output, fps=fps, context_window=context
+            )
+        else:
+            result = processor.remove_overlay_from_video(
+                video_path=input_video, output_path=output, fps=fps
+            )
+    else:
+        processor = EnhancedVideoProcessor() if EnhancedVideoProcessor else VideoProcessor()
+        if hasattr(processor, "remove_overlay_from_video"):
+            result = processor.remove_overlay_from_video(
+                video_path=input_video, output_path=output, fps=fps
+            )
+        else:
+            click.echo(
+                click.style("❌ Overlay removal not available with current processor.", fg="red")
+            )
+            return
+
+    click.echo(f"Video processed successfully: {result}")
+
+
+@videos.command()
+@click.argument("input_video", type=click.Path(exists=True))
+@click.option("--output", "-o", type=click.Path(), help="Output directory path")
+@click.option("--fps", "-f", default=8, help="Frame extraction rate (default: 8)")
+def extract_frames(input_video, output, fps):
+    """Extract frames from video to timestamped directory."""
+
+    try:
+        video_module = _get_video_module()
+    except ImportError as e:
+        click.echo(click.style(f"❌ Video processing modules not available: {e}", fg="red"))
+        return
+
+    VideoProcessor = video_module["VideoProcessor"]
+
+    if VideoProcessor is None:
+        click.echo(
+            click.style(
+                "❌ Video processing modules not available. Please install required dependencies.",
+                fg="red",
+            )
+        )
+        return
+
+    processor = VideoProcessor()
+
+    result_dir = processor.extract_frames_to_directory(
+        video_path=input_video, output_dir=output, fps=fps
+    )
+
+    click.echo(click.style(f"✅ Frame extraction complete!", fg="bright_green"))
+    click.echo(click.style(f"📁 Output directory: {result_dir}", fg="green"))
+
+
+@videos.command()
+@click.argument("frame_directory", type=click.Path(exists=True))
+@click.option("--output", "-o", type=click.Path(), help="Output video path")
+@click.option("--fps", "-f", default=30.0, help="Output video FPS (default: 30)")
+def frames_to_video(frame_directory, output, fps):
+    """Convert frames back to video."""
+
+    try:
+        video_module = _get_video_module()
+    except ImportError as e:
+        click.echo(click.style(f"❌ Video processing modules not available: {e}", fg="red"))
+        return
+
+    VideoProcessor = video_module["VideoProcessor"]
+
+    if VideoProcessor is None:
+        click.echo(
+            click.style(
+                "❌ Video processing modules not available. Please install required dependencies.",
+                fg="red",
+            )
+        )
+        return
+
+    processor = VideoProcessor()
+
+    # Get all frame files from directory
+    frame_dir = Path(frame_directory)
+    frame_files = sorted([f for f in frame_dir.glob("*.png")])
+
+    if not frame_files:
+        click.echo(click.style("❌ No PNG frames found in directory", fg="red"))
+        return
+
+    if output is None:
+        output = str(frame_dir.parent / f"{frame_dir.name}_reconstructed.mp4")
+
+    frame_paths = [str(f) for f in frame_files]
+
+    # Set video info manually for frames_to_video
+    processor.video_info = {"original_fps": fps}
+
+    result = processor.frames_to_video(frame_paths, output, fps)
+    click.echo(f"Video created successfully: {result}")
+
+
+if __name__ == "__main__":
+    videos()

mcli/workflow/wakatime/wakatime.py

@@ -0,0 +1,11 @@
+import click
+
+
+@click.group(name="wakatime")
+def wakatime():
+    """WakaTime commands"""
+    pass
+
+
+if __name__ == "__main__":
+    wakatime()

mcli/workflow/workflow.py

@@ -0,0 +1,37 @@
+import click
+
+from .daemon.api_daemon import api_daemon
+from .daemon.commands import daemon
+from .dashboard.dashboard_cmd import dashboard
+from .file.file import file
+from .git_commit.commands import git_commit_cli
+from .politician_trading.commands import politician_trading_cli
+from .scheduler.commands import scheduler
+from .sync.sync_cmd import sync
+from .videos.videos import videos
+
+
+@click.group(name="workflow")
+def workflow():
+    """Workflow commands"""
+    pass
+
+
+# Add subcommands
+def register_workflow_commands():
+    workflow.add_command(file)
+    workflow.add_command(videos)
+    workflow.add_command(daemon)
+    workflow.add_command(api_daemon)
+    workflow.add_command(dashboard)
+    workflow.add_command(git_commit_cli)
+    workflow.add_command(scheduler)
+    workflow.add_command(sync)
+    workflow.add_command(politician_trading_cli)
+
+
+register_workflow_commands()
+
+
+if __name__ == "__main__":
+    workflow()