mcli-framework 7.1.3__py3-none-any.whl → 7.2.0__py3-none-any.whl

mcli/workflow/sync/sync_cmd.py

@@ -1,437 +0,0 @@
-"""Multi-cloud synchronization commands for mcli."""
-
-import asyncio
-import json
-import os
-import shutil
-import subprocess
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Optional
-
-import click
-
-from mcli.lib.logger.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class MultiCloudSync:
-    """Handles synchronization across GitHub, OneDrive, iCloud, and Google Drive."""
-
-    def __init__(self, vault_path: str):
-        self.vault_path = Path(vault_path).resolve()
-        self.sync_config_path = self.vault_path / ".mcli_sync_config.json"
-        self.sync_log_path = self.vault_path / ".mcli_sync_log.json"
-
-        # Cloud storage paths - these will need to be configured by user
-        self.cloud_paths = {"onedrive": None, "icloud": None, "googledrive": None}
-
-        self.load_config()
-
-    def load_config(self) -> None:
-        """Load sync configuration from file."""
-        if self.sync_config_path.exists():
-            try:
-                with open(self.sync_config_path, "r") as f:
-                    config = json.load(f)
-                    self.cloud_paths.update(config.get("cloud_paths", {}))
-                    logger.info(f"Loaded sync config from {self.sync_config_path}")
-            except Exception as e:
-                logger.warning(f"Failed to load sync config: {e}")
-
-    def save_config(self) -> None:
-        """Save sync configuration to file."""
-        config = {
-            "cloud_paths": self.cloud_paths,
-            "vault_path": str(self.vault_path),
-            "last_updated": datetime.now().isoformat(),
-        }
-        try:
-            with open(self.sync_config_path, "w") as f:
-                json.dump(config, f, indent=2)
-            logger.info(f"Saved sync config to {self.sync_config_path}")
-        except Exception as e:
-            logger.error(f"Failed to save sync config: {e}")
-
-    def log_sync_action(self, action: str, target: str, status: str, details: str = "") -> None:
-        """Log sync actions for debugging and auditing."""
-        log_entry = {
-            "timestamp": datetime.now().isoformat(),
-            "action": action,
-            "target": target,
-            "status": status,
-            "details": details,
-        }
-
-        # Load existing log
-        logs = []
-        if self.sync_log_path.exists():
-            try:
-                with open(self.sync_log_path, "r") as f:
-                    logs = json.load(f)
-            except Exception as e:
-                logger.warning(f"Failed to load sync log: {e}")
-
-        # Append new entry and keep only last 100 entries
-        logs.append(log_entry)
-        logs = logs[-100:]
-
-        # Save log
-        try:
-            with open(self.sync_log_path, "w") as f:
-                json.dump(logs, f, indent=2)
-        except Exception as e:
-            logger.warning(f"Failed to save sync log: {e}")
-
-    def sync_to_github(self) -> bool:
-        """Sync vault to GitHub repository."""
-        try:
-            # Check if we're in a git repository
-            result = subprocess.run(
-                ["git", "status"], cwd=self.vault_path, capture_output=True, text=True
-            )
-            if result.returncode != 0:
-                self.log_sync_action("git_sync", "github", "error", "Not a git repository")
-                return False
-
-            # Add all changes
-            subprocess.run(["git", "add", "."], cwd=self.vault_path, check=True)
-
-            # Check if there are changes to commit
-            result = subprocess.run(
-                ["git", "diff", "--staged", "--quiet"], cwd=self.vault_path, capture_output=True
-            )
-            if result.returncode == 0:
-                self.log_sync_action("git_sync", "github", "success", "No changes to commit")
-                return True
-
-            # Commit changes
-            commit_msg = f"Auto-sync vault - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
-            subprocess.run(["git", "commit", "-m", commit_msg], cwd=self.vault_path, check=True)
-
-            # Push to remote
-            subprocess.run(["git", "push"], cwd=self.vault_path, check=True)
-
-            self.log_sync_action(
-                "git_sync", "github", "success", f"Committed and pushed: {commit_msg}"
-            )
-            return True
-
-        except subprocess.CalledProcessError as e:
-            self.log_sync_action("git_sync", "github", "error", str(e))
-            logger.error(f"Git sync failed: {e}")
-            return False
-
-    def sync_to_cloud_storage(self, cloud_name: str) -> bool:
-        """Sync vault to specified cloud storage."""
-        cloud_path = self.cloud_paths.get(cloud_name)
-        if not cloud_path:
-            self.log_sync_action("cloud_sync", cloud_name, "error", "Cloud path not configured")
-            return False
-
-        cloud_path = Path(cloud_path)
-        if not cloud_path.exists():
-            try:
-                cloud_path.mkdir(parents=True, exist_ok=True)
-                self.log_sync_action(
-                    "cloud_sync", cloud_name, "info", f"Created directory: {cloud_path}"
-                )
-            except Exception as e:
-                self.log_sync_action(
-                    "cloud_sync", cloud_name, "error", f"Failed to create directory: {e}"
-                )
-                return False
-
-        try:
-            # Use rsync for efficient sync (macOS has rsync built-in)
-            result = subprocess.run(
-                [
-                    "rsync",
-                    "-av",
-                    "--delete",
-                    "--exclude=.git",
-                    "--exclude=.obsidian/workspace*",
-                    "--exclude=.mcli_sync_*",
-                    "--exclude=__pycache__",
-                    "--exclude=*.pyc",
-                    f"{self.vault_path}/",
-                    f"{cloud_path}/",
-                ],
-                capture_output=True,
-                text=True,
-            )
-
-            if result.returncode == 0:
-                self.log_sync_action("cloud_sync", cloud_name, "success", f"Synced to {cloud_path}")
-                return True
-            else:
-                self.log_sync_action("cloud_sync", cloud_name, "error", result.stderr)
-                return False
-
-        except Exception as e:
-            self.log_sync_action("cloud_sync", cloud_name, "error", str(e))
-            logger.error(f"Cloud sync to {cloud_name} failed: {e}")
-            return False
-
-    def sync_from_cloud_storage(self, cloud_name: str) -> bool:
-        """Sync from cloud storage to vault."""
-        cloud_path = self.cloud_paths.get(cloud_name)
-        if not cloud_path or not Path(cloud_path).exists():
-            self.log_sync_action("cloud_pull", cloud_name, "error", "Cloud path not found")
-            return False
-
-        try:
-            # Use rsync to pull changes from cloud
-            result = subprocess.run(
-                [
-                    "rsync",
-                    "-av",
-                    "--exclude=.git",
-                    "--exclude=.obsidian/workspace*",
-                    "--exclude=.mcli_sync_*",
-                    "--exclude=__pycache__",
-                    "--exclude=*.pyc",
-                    f"{cloud_path}/",
-                    f"{self.vault_path}/",
-                ],
-                capture_output=True,
-                text=True,
-            )
-
-            if result.returncode == 0:
-                self.log_sync_action(
-                    "cloud_pull", cloud_name, "success", f"Pulled from {cloud_path}"
-                )
-                return True
-            else:
-                self.log_sync_action("cloud_pull", cloud_name, "error", result.stderr)
-                return False
-
-        except Exception as e:
-            self.log_sync_action("cloud_pull", cloud_name, "error", str(e))
-            logger.error(f"Cloud pull from {cloud_name} failed: {e}")
-            return False
-
-    def get_sync_status(self) -> Dict:
-        """Get current sync status for all configured targets."""
-        status = {
-            "vault_path": str(self.vault_path),
-            "last_check": datetime.now().isoformat(),
-            "targets": {},
-        }
-
-        # Check git status
-        try:
-            result = subprocess.run(
-                ["git", "status", "--porcelain"],
-                cwd=self.vault_path,
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode == 0:
-                has_changes = bool(result.stdout.strip())
-                status["targets"]["github"] = {
-                    "configured": True,
-                    "has_uncommitted_changes": has_changes,
-                    "status": "dirty" if has_changes else "clean",
-                }
-            else:
-                status["targets"]["github"] = {"configured": False, "error": "Not a git repository"}
-        except Exception as e:
-            status["targets"]["github"] = {"configured": False, "error": str(e)}
-
-        # Check cloud storage paths
-        for cloud_name, cloud_path in self.cloud_paths.items():
-            if cloud_path:
-                path_obj = Path(cloud_path)
-                status["targets"][cloud_name] = {
-                    "configured": True,
-                    "path": cloud_path,
-                    "exists": path_obj.exists(),
-                    "accessible": path_obj.exists() and os.access(path_obj, os.R_OK | os.W_OK),
-                }
-            else:
-                status["targets"][cloud_name] = {"configured": False, "path": None}
-
-        return status
-
-
-@click.group(name="sync")
-def sync():
-    """Multi-cloud synchronization commands for vault management."""
-    pass
-
-
-# Import and register test commands
-try:
-    from .test_cmd import test as sync_test
-
-    sync.add_command(sync_test)
-except ImportError:
-    pass
-
-
-@sync.command()
-@click.option("--vault-path", default=".", help="Path to vault directory")
-def status(vault_path):
-    """Show sync status for all configured targets."""
-    syncer = MultiCloudSync(vault_path)
-    status_info = syncer.get_sync_status()
-
-    click.echo(f"📁 Vault: {status_info['vault_path']}")
-    click.echo(f"🕒 Last check: {status_info['last_check']}")
-    click.echo()
-
-    for target, info in status_info["targets"].items():
-        if info["configured"]:
-            if target == "github":
-                icon = "📚" if info["status"] == "clean" else "⚠️"
-                click.echo(f"{icon} {target.title()}: {info['status']}")
-                if info.get("has_uncommitted_changes"):
-                    click.echo(f"   └─ Uncommitted changes present")
-            else:
-                icon = "☁️" if info["accessible"] else "❌"
-                click.echo(
-                    f"{icon} {target.title()}: {'accessible' if info['accessible'] else 'not accessible'}"
-                )
-                click.echo(f"   └─ Path: {info['path']}")
-        else:
-            click.echo(f"⚪ {target.title()}: not configured")
-            if "error" in info:
-                click.echo(f"   └─ Error: {info['error']}")
-
-
-@sync.command()
-@click.option("--vault-path", default=".", help="Path to vault directory")
-@click.option("--onedrive", help="Path to OneDrive sync folder")
-@click.option("--icloud", help="Path to iCloud Drive sync folder")
-@click.option("--googledrive", help="Path to Google Drive sync folder")
-def configure(vault_path, onedrive, icloud, googledrive):
-    """Configure cloud storage paths for synchronization."""
-    syncer = MultiCloudSync(vault_path)
-
-    if onedrive:
-        syncer.cloud_paths["onedrive"] = onedrive
-        click.echo(f"✅ OneDrive path set to: {onedrive}")
-
-    if icloud:
-        syncer.cloud_paths["icloud"] = icloud
-        click.echo(f"✅ iCloud path set to: {icloud}")
-
-    if googledrive:
-        syncer.cloud_paths["googledrive"] = googledrive
-        click.echo(f"✅ Google Drive path set to: {googledrive}")
-
-    syncer.save_config()
-    click.echo("🔧 Configuration saved!")
-
-
-@sync.command()
-@click.option("--vault-path", default=".", help="Path to vault directory")
-@click.option(
-    "--target",
-    type=click.Choice(["all", "github", "onedrive", "icloud", "googledrive"]),
-    default="all",
-    help="Sync target",
-)
-def push(vault_path, target):
-    """Push vault changes to specified target(s)."""
-    syncer = MultiCloudSync(vault_path)
-
-    targets = [target] if target != "all" else ["github", "onedrive", "icloud", "googledrive"]
-
-    results = {}
-
-    for t in targets:
-        if t == "github":
-            click.echo(f"🔄 Syncing to GitHub...")
-            results[t] = syncer.sync_to_github()
-        else:
-            if syncer.cloud_paths.get(t):
-                click.echo(f"🔄 Syncing to {t.title()}...")
-                results[t] = syncer.sync_to_cloud_storage(t)
-            else:
-                click.echo(f"⚠️ {t.title()} not configured, skipping...")
-                results[t] = False
-
-    # Show results
-    click.echo("\n📊 Sync Results:")
-    for target_name, success in results.items():
-        icon = "✅" if success else "❌"
-        click.echo(f"{icon} {target_name.title()}: {'Success' if success else 'Failed'}")
-
-
-@sync.command()
-@click.option("--vault-path", default=".", help="Path to vault directory")
-@click.option(
-    "--target",
-    type=click.Choice(["onedrive", "icloud", "googledrive"]),
-    required=True,
-    help="Cloud storage to pull from",
-)
-def pull(vault_path, target):
-    """Pull changes from cloud storage to vault."""
-    syncer = MultiCloudSync(vault_path)
-
-    if not syncer.cloud_paths.get(target):
-        click.echo(f"❌ {target.title()} not configured!")
-        return
-
-    click.echo(f"🔄 Pulling from {target.title()}...")
-    success = syncer.sync_from_cloud_storage(target)
-
-    if success:
-        click.echo(f"✅ Successfully pulled from {target.title()}")
-    else:
-        click.echo(f"❌ Failed to pull from {target.title()}")
-
-
-@sync.command()
-@click.option("--vault-path", default=".", help="Path to vault directory")
-@click.option("--lines", default=20, help="Number of log lines to show")
-def logs(vault_path, lines):
-    """Show sync operation logs."""
-    syncer = MultiCloudSync(vault_path)
-
-    if not syncer.sync_log_path.exists():
-        click.echo("📝 No sync logs found.")
-        return
-
-    try:
-        with open(syncer.sync_log_path, "r") as f:
-            logs_data = json.load(f)
-
-        # Show last N entries
-        recent_logs = logs_data[-lines:]
-
-        click.echo(f"📝 Last {len(recent_logs)} sync operations:")
-        click.echo()
-
-        for log_entry in recent_logs:
-            timestamp = log_entry.get("timestamp", "Unknown")
-            action = log_entry.get("action", "Unknown")
-            target = log_entry.get("target", "Unknown")
-            status = log_entry.get("status", "Unknown")
-            details = log_entry.get("details", "")
-
-            # Format timestamp
-            try:
-                dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
-                time_str = dt.strftime("%Y-%m-%d %H:%M:%S")
-            except:
-                time_str = timestamp
-
-            # Status icon
-            icon = {"success": "✅", "error": "❌", "info": "ℹ️"}.get(status, "📝")
-
-            click.echo(f"{icon} {time_str} | {action} → {target} | {status}")
-            if details:
-                click.echo(f"   └─ {details}")
-
-    except Exception as e:
-        click.echo(f"❌ Failed to read logs: {e}")
-
-
-if __name__ == "__main__":
-    sync()

mcli/workflow/videos/videos.py

@@ -1,242 +0,0 @@
-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()