max-cli 0.3.0__tar.gz → 0.3.3__tar.gz

{max_cli-0.3.0/src/max_cli.egg-info → max_cli-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: max-cli
-Version: 0.3.0
+Version: 0.3.3
 Summary: The Local, Fast, & Lazy Terminal Assistant for high-performance tasks.
 Author-email: Abubakr Alsheikh <abubakralsheikh@outlook.com>
 Requires-Python: >=3.9
@@ -17,6 +17,7 @@ Requires-Dist: requests>=2.31.0
 Requires-Dist: yt-dlp>=2023.0.0
 Requires-Dist: segno>=1.5.0
 Requires-Dist: pyperclip>=1.8.0
+Requires-Dist: mutagen>=1.47.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -60,6 +61,10 @@ Max transforms complex tasks—like compressing videos, merging PDFs, or downloa
 |------|-------------|---------|
 | **Compress videos** | `max video compress` | `max video compress movie.mp4` |
 | **Convert video to audio** | `max video to-audio` | `max video to-audio podcast.mp4` |
+| **Get audio metadata** | `max audio get` | `max audio get song.mp3` |
+| **Set audio metadata** | `max audio set` | `max audio set song.mp3 --artist "Artist" --album "Album"` |
+| **Batch organize audio** | `max audio batch` | `max audio batch "folder/*.mp3" --album "My Album" --artist "Band"` |
+| **Organize to folders** | `max audio organize` | `max audio organize "*.mp3" --pattern artist` |
 | **Download videos/music** | `max grab download` | `max grab download youtube.com/...` |
 | **Check download queue** | `max grab queue` | `max grab queue` |
 | **Download history** | `max grab history` | `max grab history` |

{max_cli-0.3.0 → max_cli-0.3.3}/README.md

@@ -31,6 +31,10 @@ Max transforms complex tasks—like compressing videos, merging PDFs, or downloa
 |------|-------------|---------|
 | **Compress videos** | `max video compress` | `max video compress movie.mp4` |
 | **Convert video to audio** | `max video to-audio` | `max video to-audio podcast.mp4` |
+| **Get audio metadata** | `max audio get` | `max audio get song.mp3` |
+| **Set audio metadata** | `max audio set` | `max audio set song.mp3 --artist "Artist" --album "Album"` |
+| **Batch organize audio** | `max audio batch` | `max audio batch "folder/*.mp3" --album "My Album" --artist "Band"` |
+| **Organize to folders** | `max audio organize` | `max audio organize "*.mp3" --pattern artist` |
 | **Download videos/music** | `max grab download` | `max grab download youtube.com/...` |
 | **Check download queue** | `max grab queue` | `max grab queue` |
 | **Download history** | `max grab history` | `max grab history` |

{max_cli-0.3.0 → max_cli-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "max-cli"
-version = "0.3.0"
+version = "0.3.3"
 description = "The Local, Fast, & Lazy Terminal Assistant for high-performance tasks."
 authors = [{name = "Abubakr Alsheikh", email = "abubakralsheikh@outlook.com"}]
 readme = "README.md"
@@ -20,7 +20,8 @@ dependencies = [
     "requests>=2.31.0",
     "yt-dlp>=2023.0.0",
     "segno>=1.5.0",
-    "pyperclip>=1.8.0"
+    "pyperclip>=1.8.0",
+    "mutagen>=1.47.0"
 ]
 
 [project.optional-dependencies]

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli/core/cli/commands/__init__.py

@@ -1,6 +1,7 @@
 # Command registration modules
 from max_cli.core.cli.commands import (
     ai,
+    audio,
     config,
     files,
     media,
@@ -9,4 +10,13 @@ from max_cli.core.cli.commands import (
     tools,
 )
 
-__all__ = ["ai", "config", "files", "media", "network", "plugin_commands", "tools"]
+__all__ = [
+    "ai",
+    "audio",
+    "config",
+    "files",
+    "media",
+    "network",
+    "plugin_commands",
+    "tools",
+]

max_cli-0.3.3/src/max_cli/core/cli/commands/audio.py

@@ -0,0 +1,14 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typer import Typer
+
+from max_cli.interface import cli_audio
+
+
+def register(app: "Typer") -> None:
+    """Register audio metadata commands."""
+    app.add_typer(
+        cli_audio.app, name="audio", help="Read, write, and manage audio metadata."
+    )
+    app.add_typer(cli_audio.app, name="a", hidden=True)

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli/core/cli/registry.py

@@ -16,6 +16,7 @@ def register(app: "Typer") -> None:
     commands.tools.register(app)
     commands.config.register(app)
     commands.plugin_commands.register(app)
+    commands.audio.register(app)
 
 
 init_plugins = plugins.init_plugins

max_cli-0.3.3/src/max_cli/core/engines/audio_metadata_engine.py

@@ -0,0 +1,317 @@
+from pathlib import Path
+from typing import Dict, Optional, Any, List
+from mutagen._file import File as MutagenFile
+
+
+SUPPORTED_EXTENSIONS = {".mp3", ".flac", ".m4a", ".aac", ".ogg", ".wav"}
+
+
+class AudioMetadataEngine:
+    """
+    Engine for reading, writing, and clearing audio file metadata.
+    Supports MP3, FLAC, M4A/AAC, OGG, and WAV files.
+    """
+
+    def get_metadata(self, file_path: Path) -> Dict[str, Any]:
+        """
+        Retrieve all metadata from an audio file.
+        """
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        if file_path.suffix.lower() not in SUPPORTED_EXTENSIONS:
+            raise ValueError(
+                f"Unsupported format: {file_path.suffix}. "
+                f"Supported: {', '.join(SUPPORTED_EXTENSIONS)}"
+            )
+
+        audio = MutagenFile(file_path)
+
+        if audio is None:
+            raise ValueError(f"Unable to read metadata from: {file_path}")
+
+        metadata: Dict[str, Any] = {}
+
+        metadata["title"] = audio.get("title", [None])[0]
+        metadata["artist"] = audio.get("artist", [None])[0]
+        metadata["album"] = audio.get("album", [None])[0]
+        metadata["albumartist"] = audio.get("albumartist", [None])[0]
+        metadata["genre"] = audio.get("genre", [None])[0]
+        metadata["date"] = audio.get("date", [None])[0]
+        metadata["tracknumber"] = audio.get("tracknumber", [None])[0]
+        metadata["discnumber"] = audio.get("discnumber", [None])[0]
+        metadata["composer"] = audio.get("composer", [None])[0]
+        metadata["comment"] = audio.get("comment", [None])[0]
+
+        if hasattr(audio, "info"):
+            metadata["duration"] = round(audio.info.length, 2)
+            metadata["bitrate"] = getattr(audio.info, "bitrate", None)
+            metadata["sample_rate"] = getattr(audio.info, "sample_rate", None)
+            metadata["channels"] = getattr(audio.info, "channels", None)
+
+        for key in list(metadata.keys()):
+            if metadata[key] is None:
+                del metadata[key]
+
+        return metadata
+
+    def set_metadata(
+        self,
+        file_path: Path,
+        output_path: Optional[Path] = None,
+        title: Optional[str] = None,
+        artist: Optional[str] = None,
+        album: Optional[str] = None,
+        albumartist: Optional[str] = None,
+        genre: Optional[str] = None,
+        date: Optional[str] = None,
+        tracknumber: Optional[str] = None,
+        discnumber: Optional[str] = None,
+        composer: Optional[str] = None,
+        comment: Optional[str] = None,
+    ) -> Path:
+        """
+        Set metadata on an audio file.
+        If output_path is provided, writes to a new file; otherwise modifies in place.
+        """
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        target = output_path if output_path else file_path
+
+        if file_path.suffix.lower() not in SUPPORTED_EXTENSIONS:
+            raise ValueError(
+                f"Unsupported format: {file_path.suffix}. "
+                f"Supported: {', '.join(SUPPORTED_EXTENSIONS)}"
+            )
+
+        audio = MutagenFile(file_path)
+
+        if audio is None:
+            raise ValueError(f"Unable to read file: {file_path}")
+
+        if title is not None:
+            audio["title"] = title
+        if artist is not None:
+            audio["artist"] = artist
+        if album is not None:
+            audio["album"] = album
+        if albumartist is not None:
+            audio["albumartist"] = albumartist
+        if genre is not None:
+            audio["genre"] = genre
+        if date is not None:
+            audio["date"] = date
+        if tracknumber is not None:
+            audio["tracknumber"] = tracknumber
+        if discnumber is not None:
+            audio["discnumber"] = discnumber
+        if composer is not None:
+            audio["composer"] = composer
+        if comment is not None:
+            audio["comment"] = comment
+
+        audio.save(target)
+        return target
+
+    def clear_metadata(
+        self,
+        file_path: Path,
+        output_path: Optional[Path] = None,
+        keep_duration: bool = True,
+    ) -> Path:
+        """
+        Clear all metadata from an audio file.
+        If keep_duration is True, preserves audio info (duration, bitrate, etc.).
+        """
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        target = output_path if output_path else file_path
+
+        if file_path.suffix.lower() not in SUPPORTED_EXTENSIONS:
+            raise ValueError(
+                f"Unsupported format: {file_path.suffix}. "
+                f"Supported: {', '.join(SUPPORTED_EXTENSIONS)}"
+            )
+
+        audio = MutagenFile(file_path)
+
+        if audio is None:
+            raise ValueError(f"Unable to read file: {file_path}")
+
+        if keep_duration and hasattr(audio, "info"):
+            audio.info.length  # Verify we can read info without storing
+
+        tags_to_remove = list(audio.keys())
+        for key in tags_to_remove:
+            del audio[key]
+
+        audio.save(target)
+
+        return target
+
+    def batch_set_metadata(
+        self,
+        file_paths: List[Path],
+        title: Optional[str] = None,
+        artist: Optional[str] = None,
+        album: Optional[str] = None,
+        albumartist: Optional[str] = None,
+        genre: Optional[str] = None,
+        date: Optional[str] = None,
+        tracknumber: Optional[str] = None,
+        discnumber: Optional[str] = None,
+        composer: Optional[str] = None,
+        comment: Optional[str] = None,
+    ) -> List[Path]:
+        """
+        Set the same metadata on multiple audio files.
+        Useful for organizing a batch of files under the same album/artist.
+        """
+        results: List[Path] = []
+
+        for path in file_paths:
+            try:
+                result = self.set_metadata(
+                    path,
+                    title=title,
+                    artist=artist,
+                    album=album,
+                    albumartist=albumartist,
+                    genre=genre,
+                    date=date,
+                    tracknumber=tracknumber,
+                    discnumber=discnumber,
+                    composer=composer,
+                    comment=comment,
+                )
+                results.append(result)
+            except Exception as e:
+                raise RuntimeError(f"Failed to set metadata on {path}: {e}")
+
+        return results
+
+    def auto_tag_from_filename(
+        self,
+        file_path: Path,
+        output_path: Optional[Path] = None,
+    ) -> Path:
+        """
+        Attempt to extract metadata from filename patterns.
+        Common pattern: "Artist - Title.ext" or "Track - Artist - Title.ext"
+        """
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        stem = file_path.stem
+        parts = stem.split(" - ")
+
+        title = None
+        artist = None
+
+        if len(parts) >= 2:
+            artist = parts[0].strip()
+            title = parts[1].strip()
+        elif len(parts) == 1:
+            title = parts[0].strip()
+
+        return self.set_metadata(
+            file_path,
+            output_path,
+            title=title,
+            artist=artist,
+        )
+
+    def organize(
+        self,
+        source_paths: List[Path],
+        target_dir: Path,
+        pattern: str = "artist",
+    ) -> Dict[str, Any]:
+        """
+        Organize audio files into folders by metadata.
+
+        Args:
+            source_paths: List of audio files to organize
+            target_dir: Root directory to organize into
+            pattern: Folder structure - 'artist', 'album', 'artist-album', 'genre'
+
+        Returns:
+            Dict with 'moved', 'skipped', 'errors' counts and details
+        """
+        moved: List[str] = []
+        skipped: List[str] = []
+        errors: List[str] = []
+
+        for file_path in source_paths:
+            try:
+                if not file_path.exists():
+                    errors.append(f"{file_path.name}: File not found")
+                    continue
+
+                metadata = self.get_metadata(file_path)
+
+                artist = metadata.get("artist", "Unknown Artist")
+                album = metadata.get("album", "Unknown Album")
+                genre = metadata.get("genre", "Unknown Genre")
+                title = metadata.get("title", file_path.stem)
+                track = metadata.get("tracknumber", "")
+
+                artist = self._sanitize_filename(artist)
+                album = self._sanitize_filename(album)
+                genre = self._sanitize_filename(genre)
+                title = self._sanitize_filename(title)
+
+                if pattern == "artist":
+                    dest_dir = target_dir / artist
+                elif pattern == "album":
+                    dest_dir = target_dir / album
+                elif pattern == "genre":
+                    dest_dir = target_dir / genre
+                else:
+                    dest_dir = target_dir / artist / album
+
+                dest_dir.mkdir(parents=True, exist_ok=True)
+
+                if track:
+                    new_name = f"{track} - {title}{file_path.suffix}"
+                else:
+                    new_name = f"{title}{file_path.suffix}"
+
+                dest_path = dest_dir / new_name
+                counter = 1
+                while dest_path.exists():
+                    if track:
+                        new_name = f"{track} - {title} ({counter}){file_path.suffix}"
+                    else:
+                        new_name = f"{title} ({counter}){file_path.suffix}"
+                    dest_path = dest_dir / new_name
+                    counter += 1
+
+                file_path.rename(dest_path)
+                moved.append(f"{file_path.name} -> {dest_path}")
+
+            except Exception as e:
+                errors.append(f"{file_path.name}: {str(e)}")
+
+        return {
+            "moved": moved,
+            "skipped": skipped,
+            "errors": errors,
+            "total_moved": len(moved),
+            "total_skipped": len(skipped),
+            "total_errors": len(errors),
+        }
+
+    def _sanitize_filename(self, name: str) -> str:
+        """Remove invalid characters from folder/file names."""
+        if not name:
+            return "Unknown"
+
+        invalid_chars = '<>:"/\\|?*'
+        for char in invalid_chars:
+            name = name.replace(char, "_")
+
+        name = name.strip()
+        return name if name else "Unknown"

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli/interface/cli_ai.py

@@ -20,6 +20,7 @@ MAIN_APP_REF: Optional[typer.Typer] = None
 
 
 @app.command("ask")
+@app.command("a", hidden=True)
 def ask_ai(
     prompt: str = typer.Argument(..., help="What do you want to do?"),
     explain: bool = typer.Option(
@@ -92,6 +93,7 @@ def ask_ai(
 
 
 @app.command("analyze")
+@app.command("ana", hidden=True)
 def analyze_image(
     target: Path = typer.Argument(..., help="Path to the image."),
     prompt: str = typer.Option(
@@ -132,6 +134,7 @@ def analyze_image(
 
 
 @app.command("create")
+@app.command("c", hidden=True)
 def create_image(
     prompt: str = typer.Argument(..., help="Description of the image to create."),
     output: Optional[Path] = typer.Option(None, "-o", "--output", help="Save path."),
@@ -197,6 +200,7 @@ def _handle_image_result(url: str, output_path: Optional[Path], default_name: st
 
 
 @app.command("chat")
+@app.command("ch", hidden=True)
 def chat_session(
     clear: bool = typer.Option(False, "--clear", help="Clear conversation history."),
     export: Optional[Path] = typer.Option(
@@ -291,6 +295,7 @@ def chat_session(
 
 
 @app.command("search")
+@app.command("s", hidden=True)
 def semantic_search_cmd(
     query: str = typer.Argument(..., help="Search query in natural language."),
     path: Path = typer.Argument(".", help="Folder to search in."),

max_cli-0.3.3/src/max_cli/interface/cli_audio.py

@@ -0,0 +1,249 @@
+import typer
+from pathlib import Path
+from typing import Optional, List
+from rich.table import Table
+
+from max_cli.core.engines.audio_metadata_engine import AudioMetadataEngine
+from max_cli.common.logger import console, log_error, log_success
+
+app = typer.Typer()
+engine = AudioMetadataEngine()
+
+
+@app.command("get")
+@app.command("g", hidden=True)
+def get_metadata(
+    target: Path = typer.Argument(..., help="Audio file to read metadata from."),
+):
+    """
+    Display all metadata from an audio file (title, artist, album, genre, etc.).
+    """
+    try:
+        metadata = engine.get_metadata(target)
+
+        table = Table(title=f"Metadata: {target.name}", show_header=False)
+        table.add_column("Field", style="cyan")
+        table.add_column("Value", style="white")
+
+        for key, value in metadata.items():
+            table.add_row(key, str(value))
+
+        console.print(table)
+
+    except Exception as e:
+        log_error(f"Failed to read metadata: {e}")
+
+
+@app.command("set")
+@app.command("s", hidden=True)
+def set_metadata(
+    target: Path = typer.Argument(..., help="Audio file to modify."),
+    title: Optional[str] = typer.Option(None, "--title", "-t", help="Song title."),
+    artist: Optional[str] = typer.Option(None, "--artist", "-a", help="Artist name."),
+    album: Optional[str] = typer.Option(None, "--album", "-b", help="Album name."),
+    albumartist: Optional[str] = typer.Option(
+        None, "--album-artist", help="Album artist name."
+    ),
+    genre: Optional[str] = typer.Option(None, "--genre", "-g", help="Genre."),
+    date: Optional[str] = typer.Option(
+        None, "--date", "-d", help="Release date (YYYY-MM-DD)."
+    ),
+    tracknumber: Optional[str] = typer.Option(
+        None, "--track", "-n", help="Track number."
+    ),
+    discnumber: Optional[str] = typer.Option(None, "--disc", help="Disc number."),
+    composer: Optional[str] = typer.Option(None, "--composer", help="Composer name."),
+    comment: Optional[str] = typer.Option(
+        None, "--comment", "-c", help="Comment/description."
+    ),
+    output: Optional[Path] = typer.Option(
+        None, "-o", "--output", help="Output file (default: overwrite)."
+    ),
+):
+    """
+    Set metadata on an audio file. Use flags to set specific fields.
+    """
+    if not any(
+        [
+            title,
+            artist,
+            album,
+            albumartist,
+            genre,
+            date,
+            tracknumber,
+            discnumber,
+            composer,
+            comment,
+        ]
+    ):
+        console.print(
+            "[yellow]No metadata fields specified. Use --help to see available options.[/yellow]"
+        )
+        return
+
+    try:
+        result = engine.set_metadata(
+            target,
+            output,
+            title=title,
+            artist=artist,
+            album=album,
+            albumartist=albumartist,
+            genre=genre,
+            date=date,
+            tracknumber=tracknumber,
+            discnumber=discnumber,
+            composer=composer,
+            comment=comment,
+        )
+        log_success(f"Metadata saved: {result}")
+
+    except Exception as e:
+        log_error(f"Failed to set metadata: {e}")
+
+
+@app.command("clear")
+@app.command("cl", hidden=True)
+def clear_metadata(
+    target: Path = typer.Argument(..., help="Audio file to clear metadata from."),
+    keep_duration: bool = typer.Option(
+        True, "--keep-duration/--no-duration", help="Preserve audio info."
+    ),
+    output: Optional[Path] = typer.Option(
+        None, "-o", "--output", help="Output file (default: overwrite)."
+    ),
+):
+    """
+    Remove all metadata from an audio file.
+    """
+    try:
+        result = engine.clear_metadata(target, output, keep_duration=keep_duration)
+        log_success(f"Cleared metadata: {result}")
+
+    except Exception as e:
+        log_error(f"Failed to clear metadata: {e}")
+
+
+@app.command("batch")
+@app.command("b", hidden=True)
+def batch_set_metadata(
+    targets: List[Path] = typer.Argument(
+        ..., help="Audio files to update (supports glob patterns)."
+    ),
+    title: Optional[str] = typer.Option(None, "--title", "-t", help="Song title."),
+    artist: Optional[str] = typer.Option(None, "--artist", "-a", help="Artist name."),
+    album: Optional[str] = typer.Option(None, "--album", "-b", help="Album name."),
+    albumartist: Optional[str] = typer.Option(
+        None, "--album-artist", help="Album artist name."
+    ),
+    genre: Optional[str] = typer.Option(None, "--genre", "-g", help="Genre."),
+    date: Optional[str] = typer.Option(
+        None, "--date", "-d", help="Release date (YYYY-MM-DD)."
+    ),
+    tracknumber: Optional[str] = typer.Option(
+        None, "--track", "-n", help="Track number (auto-increment with --start)."
+    ),
+    start: Optional[int] = typer.Option(
+        None, "--start", help="Starting track number for auto-increment."
+    ),
+):
+    """
+    Set the same metadata on multiple audio files at once.
+    Useful for organizing files into an album or artist.
+    """
+    if not targets:
+        log_error("No files provided.")
+        return
+
+    if not any([title, artist, album, albumartist, genre, date, tracknumber]):
+        console.print(
+            "[yellow]No metadata fields specified. Use --help to see available options.[/yellow]"
+        )
+        return
+
+    count = 0
+    current_track = start if start else 0
+
+    for target in targets:
+        try:
+            track = str(current_track) if tracknumber or start else None
+
+            engine.set_metadata(
+                target,
+                title=title,
+                artist=artist,
+                album=album,
+                albumartist=albumartist,
+                genre=genre,
+                date=date,
+                tracknumber=track,
+            )
+            count += 1
+
+            if start:
+                current_track += 1
+
+        except Exception as e:
+            console.print(f"[red]Failed on {target.name}: {e}[/red]")
+
+    log_success(f"Updated {count} files successfully.")
+
+
+@app.command("organize")
+@app.command("org", hidden=True)
+def organize_files(
+    targets: List[Path] = typer.Argument(
+        ..., help="Audio files to organize (supports glob patterns)."
+    ),
+    output: Path = typer.Option(
+        None, "-o", "--output", help="Target directory (default: same as source)."
+    ),
+    pattern: str = typer.Option(
+        "artist",
+        "--pattern",
+        "-p",
+        help="Folder structure: artist, album, genre, artist-album.",
+    ),
+):
+    """
+    Organize audio files into folders by metadata.
+
+    Default: Files are moved to folders named by artist.
+    Example patterns:
+      - artist:     Music/Artist Name/Song.mp3
+      - album:      Music/Album Name/Song.mp3
+      - genre:      Music/Rock/Song.mp3
+      - artist-album: Music/Artist Name/Album Name/Song.mp3
+    """
+    if not targets:
+        log_error("No files provided.")
+        return
+
+    valid_patterns = ["artist", "album", "genre", "artist-album"]
+    if pattern not in valid_patterns:
+        log_error(f"Invalid pattern. Use: {', '.join(valid_patterns)}")
+        return
+
+    target_dir = output if output else targets[0].parent
+
+    console.print(f"[cyan]Organizing {len(targets)} files into {target_dir}...[/cyan]")
+
+    with console.status("[bold green]Organizing files...[/bold green]"):
+        result = engine.organize(targets, target_dir, pattern)
+
+    if result["total_moved"]:
+        console.print(f"[green]Moved {result['total_moved']} files:[/green]")
+        for move in result["moved"][:5]:
+            console.print(f"  [dim]{move}[/dim]")
+        if len(result["moved"]) > 5:
+            console.print(f"  [dim]...and {len(result['moved']) - 5} more[/dim]")
+
+    if result["total_errors"]:
+        console.print(f"[red]Errors ({result['total_errors']}):[/red]")
+        for err in result["errors"][:5]:
+            console.print(f"  [red]{err}[/red]")
+
+    log_success(
+        f"Done! Moved: {result['total_moved']}, Errors: {result['total_errors']}"
+    )

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli/interface/cli_files.py

@@ -13,6 +13,7 @@ organizer = FileOrganizer()
 
 
 @app.command("order")
+@app.command("ord", hidden=True)
 def order_files(
     folder: Path = typer.Argument(..., help="The folder containing files to order."),
     dry_run: bool = typer.Option(
@@ -90,6 +91,7 @@ def order_files(
 
 
 @app.command("smart-sort")
+@app.command("ss", hidden=True)
 def smart_sort(
     path: Path = typer.Argument(".", help="Folder to organize."),
     dry_run: bool = typer.Option(
@@ -131,6 +133,7 @@ def smart_sort(
 
 
 @app.command("duplicates")
+@app.command("dup", hidden=True)
 def find_duplicates(
     folder: Path = typer.Argument(".", help="Folder to scan for duplicates."),
     recursive: bool = typer.Option(

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli/interface/cli_images.py

@@ -28,6 +28,7 @@ def _resolve_batch(target: Path) -> Tuple[List[Path], Path]:
 
 
 @app.command("compress")
+@app.command("c", hidden=True)
 def compress_images(
     target: Path = typer.Argument(Path("."), help="File or folder."),
     quality: int = typer.Option(
@@ -64,6 +65,7 @@ def compress_images(
 
 
 @app.command("resize")
+@app.command("r", hidden=True)
 def resize_images(
     target: Path = typer.Argument(Path("."), help="File or folder."),
     width: Optional[int] = typer.Option(None, "-w", help="Width in px."),
@@ -90,6 +92,7 @@ def resize_images(
 
 
 @app.command("convert")
+@app.command("cv", hidden=True)
 def convert_images(
     target: Path = typer.Argument(Path("."), help="File or folder."),
     to: str = typer.Option(..., help="Target format (webp, jpg, png)."),
@@ -103,6 +106,7 @@ def convert_images(
 
 
 @app.command("strip")
+@app.command("s", hidden=True)
 def strip_metadata(
     target: Path = typer.Argument(Path("."), help="File or folder."),
     workers: int = typer.Option(

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli/interface/cli_media.py

@@ -24,6 +24,7 @@ def _check_engine():
 
 
 @app.command("compress")
+@app.command("c", hidden=True)
 def compress_video(
     target: Path = typer.Argument(..., help="Video file to compress."),
     output: Optional[Path] = typer.Option(None, "-o", help="Output path."),
@@ -72,6 +73,7 @@ def compress_video(
 
 
 @app.command("convert")
+@app.command("cv", hidden=True)
 def convert_format(
     target: Path = typer.Argument(..., help="Input video file."),
     fmt: str = typer.Option(
@@ -95,6 +97,7 @@ def convert_format(
 
 
 @app.command("to-audio")
+@app.command("rip", hidden=True)
 def video_to_audio(
     target: Path = typer.Argument(..., help="Source video file."),
     format: str = typer.Option(

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli/interface/cli_network.py

@@ -44,6 +44,7 @@ def _clean_url(url: str, strip_playlist: bool) -> str:
 
 
 @app.command("download")
+@app.command("do", hidden=True)
 def download_media(
     url: Optional[str] = typer.Argument(None, help="URL to download."),
     quality: Optional[str] = typer.Option(

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli/interface/cli_pdf.py

@@ -13,6 +13,7 @@ engine = PDFEngine()
 
 
 @app.command("merge")
+@app.command("m", hidden=True)
 def merge_pdfs(
     inputs: Optional[List[Path]] = typer.Argument(
         None, help="List of files OR a single folder."
@@ -50,6 +51,7 @@ def merge_pdfs(
 
 
 @app.command("compress")
+@app.command("c", hidden=True)
 def compress_pdf(
     target: Path = typer.Argument(..., help="PDF file OR Folder to compress."),
     dpi: int = typer.Option(
@@ -140,6 +142,7 @@ def compress_pdf(
 
 
 @app.command("bundle")
+@app.command("b", hidden=True)
 def bundle_pdfs(
     inputs: Optional[List[Path]] = typer.Argument(
         None, help="Files or Folder to bundle."
@@ -281,6 +284,7 @@ def _resolve_files(inputs: List[Path]) -> List[Path]:
 
 
 @app.command("split")
+@app.command("sp", hidden=True)
 def split_pdf(
     target: Path = typer.Argument(..., help="PDF file to split."),
     start: int = typer.Option(
@@ -385,6 +389,7 @@ def split_pdf(
 
 
 @app.command("stamp")
+@app.command("st", hidden=True)
 def stamp_pdf(
     target: Path = typer.Argument(..., help="PDF to watermark."),
     text: str = typer.Argument("DRAFT", help="Text to overlay."),
@@ -402,6 +407,7 @@ def stamp_pdf(
 
 
 @app.command("lock")
+@app.command("l", hidden=True)
 def lock_pdf(
     target: Path = typer.Argument(..., help="PDF to encrypt."),
     password: str = typer.Option(
@@ -444,6 +450,7 @@ def rip_content(
 
 
 @app.command("ocr")
+@app.command("o", hidden=True)
 def ocr_pdf(
     target: Path = typer.Argument(..., help="PDF file to OCR."),
     lang: str = typer.Option(

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli/interface/cli_tools.py

@@ -9,6 +9,7 @@ engine = SystemEngine()
 
 
 @app.command("share")
+@app.command("qr", hidden=True)
 def share_qr(
     data: str = typer.Argument(..., help="Text or URL to convert to QR Code."),
 ):

{max_cli-0.3.0 → max_cli-0.3.3/src/max_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: max-cli
-Version: 0.3.0
+Version: 0.3.3
 Summary: The Local, Fast, & Lazy Terminal Assistant for high-performance tasks.
 Author-email: Abubakr Alsheikh <abubakralsheikh@outlook.com>
 Requires-Python: >=3.9
@@ -17,6 +17,7 @@ Requires-Dist: requests>=2.31.0
 Requires-Dist: yt-dlp>=2023.0.0
 Requires-Dist: segno>=1.5.0
 Requires-Dist: pyperclip>=1.8.0
+Requires-Dist: mutagen>=1.47.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -60,6 +61,10 @@ Max transforms complex tasks—like compressing videos, merging PDFs, or downloa
 |------|-------------|---------|
 | **Compress videos** | `max video compress` | `max video compress movie.mp4` |
 | **Convert video to audio** | `max video to-audio` | `max video to-audio podcast.mp4` |
+| **Get audio metadata** | `max audio get` | `max audio get song.mp3` |
+| **Set audio metadata** | `max audio set` | `max audio set song.mp3 --artist "Artist" --album "Album"` |
+| **Batch organize audio** | `max audio batch` | `max audio batch "folder/*.mp3" --album "My Album" --artist "Band"` |
+| **Organize to folders** | `max audio organize` | `max audio organize "*.mp3" --pattern artist` |
 | **Download videos/music** | `max grab download` | `max grab download youtube.com/...` |
 | **Check download queue** | `max grab queue` | `max grab queue` |
 | **Download history** | `max grab history` | `max grab history` |

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ src/max_cli/core/cli/plugins.py
 src/max_cli/core/cli/registry.py
 src/max_cli/core/cli/commands/__init__.py
 src/max_cli/core/cli/commands/ai.py
+src/max_cli/core/cli/commands/audio.py
 src/max_cli/core/cli/commands/config.py
 src/max_cli/core/cli/commands/files.py
 src/max_cli/core/cli/commands/media.py
@@ -29,6 +30,7 @@ src/max_cli/core/cli/commands/plugins.py
 src/max_cli/core/cli/commands/tools.py
 src/max_cli/core/engines/__init__.py
 src/max_cli/core/engines/ai_engine.py
+src/max_cli/core/engines/audio_metadata_engine.py
 src/max_cli/core/engines/file_organizer.py
 src/max_cli/core/engines/image_processor.py
 src/max_cli/core/engines/media_engine.py
@@ -37,6 +39,7 @@ src/max_cli/core/engines/pdf_engine.py
 src/max_cli/core/engines/queue_manager.py
 src/max_cli/core/engines/system_engine.py
 src/max_cli/interface/cli_ai.py
+src/max_cli/interface/cli_audio.py
 src/max_cli/interface/cli_config.py
 src/max_cli/interface/cli_files.py
 src/max_cli/interface/cli_images.py

{max_cli-0.3.0 → max_cli-0.3.3}/src/max_cli.egg-info/requires.txt

@@ -9,6 +9,7 @@ requests>=2.31.0
 yt-dlp>=2023.0.0
 segno>=1.5.0
 pyperclip>=1.8.0
+mutagen>=1.47.0
 
 [dev]
 pytest>=7.0.0