just-cli 0.1.0__py3-none-any.whl

just/__init__.py

@@ -0,0 +1,40 @@
+from typing_extensions import Annotated
+from typer import Option, Argument
+
+from just.cli import just_cli,capture_exception
+from just.core.config import JustConfig, load_env_config, update_env_config, get_cache_dir
+from just.core.installer import installer, SimpleReleaseInstaller, BinaryInstaller
+from just.utils import (
+    SystemProbe,
+    create_typer_app,
+    confirm_action,
+    docstring,
+    download_with_resume,
+    echo,
+    extract,
+    execute_commands
+)
+
+
+config = JustConfig()
+system = SystemProbe()
+
+__all__ = [
+    "Annotated",
+    "Argument",
+    "Option",
+    "capture_exception",
+    "create_typer_app",
+    "docstring",
+    "echo",
+    "extract",
+    "execute_commands",
+    "config",
+    "just_cli",
+    "installer",
+    "SimpleReleaseInstaller",
+    "BinaryInstaller",
+    "load_env_config",
+    "update_env_config",
+    "system"
+]

just/cli.py

@@ -0,0 +1,79 @@
+import functools
+import importlib
+import os
+import traceback
+
+from pathlib import Path
+from typer.core import TyperGroup
+from typing import Any, Callable, List, TypeVar, Optional
+
+from just.core.config import load_env_config, get_command_dir, get_extension_dir
+from just.utils import echo
+from just.utils.typer_utils import create_typer_app
+
+
+just_cli = create_typer_app()
+
+T = TypeVar('T')
+
+
+def capture_exception(func: Callable[..., T]) -> Callable[..., Optional[T]]:
+    @functools.wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Optional[T]:
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            echo.error(str(e))
+            exit(1)
+
+    return wrapper
+
+
+class SortedGroup(TyperGroup):
+    def list_commands(self, ctx):
+        return sorted(super().list_commands(ctx))
+    
+    
+def run_just_cli(*args, **kwargs):
+    load_env_config()
+    just_cli(*args, **kwargs)
+
+
+def traverse_script_dir(directory: str) -> List[str]:
+    script_modules = []
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            if not file.startswith('_') and file.endswith(".py"):
+                script_modules.append(
+                    "just." +
+                    '.'.join(Path(root).relative_to(Path(__file__).parent).parts) +
+                    f".{str(Path(file).stem)}"
+                )
+    return script_modules
+
+
+
+def main():
+    # Dynamically import all script modules to register their commands
+    script_modules = []
+    script_modules.extend(traverse_script_dir(get_command_dir().as_posix()))
+    script_modules.extend(traverse_script_dir(get_extension_dir().as_posix()))
+    script_modules.sort()
+    missing_packages = []
+    for module_name in script_modules:
+        try:
+            # echo.debug("Importing", module_name)
+            importlib.import_module(module_name)
+        except ImportError as e:
+            traceback.print_exc()
+            package_name = e.name
+            if package_name not in missing_packages:
+                missing_packages.append(package_name)
+                # Handle the case where the module cannot be found
+                echo.warning(
+                    f"`{package_name}` is not installed, some sub commands are disabled, "
+                    f"refer to README.md for instructions."
+                )
+            continue
+    # Run the CLI application
+    run_just_cli()

just/commands/download.py

@@ -0,0 +1,62 @@
+import typer
+from typing import List, Optional, Dict
+from typing_extensions import Annotated
+
+from just import just_cli, capture_exception, echo
+from just.utils import download_with_resume
+from just.utils.download_utils import DownloadError, NetworkError, FileSystemError, DownloadCancelledError
+
+
+def parse_headers(header_list: Optional[List[str]]) -> Optional[Dict[str, str]]:
+    """Parse header list to dictionary."""
+    if not header_list:
+        return None
+    headers: Dict[str, str] = {}
+    for header in header_list:
+        if ':' in header:
+            key, value = header.split(':', 1)
+            headers[key.strip()] = value.strip()
+    return headers
+
+
+@just_cli.command(name="download")
+@capture_exception
+def download_command(
+    url: Annotated[str, typer.Argument(
+        help="URL to download",
+        show_default=False
+    )],
+    headers: Annotated[Optional[List[str]], typer.Option(
+        "-H", "--header",
+        help="Custom headers (can be used multiple times)"
+    )] = None,
+    output: Annotated[Optional[str], typer.Option(
+        "-o", "--output",
+        help="Output filename"
+    )] = None,
+    verbose: Annotated[bool, typer.Option(
+        "--verbose", "-v",
+        help="Enable verbose logging"
+    )] = False
+) -> None:
+    """
+    Download a file from URL with resume support and custom headers.
+
+    Examples:
+    just download https://example.com/file.zip
+    just download https://example.com/file.zip -H "Authorization: Bearer token" -H "User-Agent: MyApp/1.0"
+    just download https://example.com/file.zip -o myfile.zip
+    """
+    try:
+        download_with_resume(
+            url=url,
+            headers=parse_headers(headers),
+            output_file=output,
+            verbose=verbose
+        )
+    except DownloadCancelledError as e:
+        echo.info(str(e))
+        raise typer.Exit(1)
+    except (NetworkError, FileSystemError, DownloadError) as e:
+        echo.error(f"Download failed: {e}")
+        raise typer.Exit(1)

just/commands/edit.py

@@ -0,0 +1,37 @@
+import os
+import typer
+
+from pathlib import Path
+from typing_extensions import Annotated
+
+from just import just_cli, capture_exception
+from just.core.config import get_env_config_file
+from just.tui import FileEditor
+
+
+INTERNAL_FILES = {
+    "config": str(get_env_config_file())
+}
+
+
+def edit_file_by_textual(file_path):
+    """Launch the TUI file editor for the specified file"""
+    editor = FileEditor(file_path)
+    editor.run()
+
+
+@just_cli.command(name="edit")
+@capture_exception
+def edit_file(
+    file_path: Annotated[str, typer.Argument(
+        help="The file to edit",
+        show_default=False
+    )]
+):
+    """
+    Edit file.
+    """
+    if file_path.lower() in INTERNAL_FILES:
+        file_path = INTERNAL_FILES[file_path.lower()]
+
+    edit_file_by_textual(file_path)

just/commands/ext/__init__.py

@@ -0,0 +1,7 @@
+from just import create_typer_app, just_cli
+
+
+ext_cli = create_typer_app(name="ext", help="Manage just extensions.")
+just_cli.add_typer(ext_cli)
+
+__all__ = ["ext_cli"]

just/commands/ext/add.py

@@ -0,0 +1,58 @@
+import shlex
+import typer
+
+from typing import List, Optional
+
+
+from just import echo
+from just.core.extension.generator import generate_extension_script
+from just.core.extension.utils import split_command_line
+from just.tui.extension import ExtensionTUI
+from . import ext_cli
+
+
+@ext_cli.command(name="add", context_settings={"ignore_unknown_options": True})
+def add_extension(
+    commands: Optional[List[str]] = typer.Argument(
+        None,
+        help="The command to register as a just extension"
+    ),
+    tui: bool = typer.Option(
+        False,
+        "--tui",
+        help="Launch TUI to configure the command"
+    )
+):
+    """
+    Parse and register a command as a just extension.
+
+    Args:
+        commands: The commands to register, e.g., "docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' f523e75ca4ef"
+        tui: Whether to launch TUI mode
+    """
+    # If no command provided or TUI mode requested, launch TUI
+    if not commands or tui:
+        launch_tui()
+        return
+
+    # Print parsed command for debugging
+    echo.echo(str(commands))
+
+    just_extension_commands = input("Enter extension commands: ")
+    # Split the command line to handle annotations with spaces properly
+    just_extension_commands = split_command_line(just_extension_commands)
+    echo.echo(str(just_extension_commands))
+
+    # Generate the extension script
+    generate_extension_script(
+        shlex.join(commands),
+        just_extension_commands,
+    )
+
+
+def launch_tui():
+    """Launch TUI for configuring extension commands"""
+
+    # Launch the TUI app
+    app = ExtensionTUI()
+    app.run()

just/commands/extract.py

@@ -0,0 +1,76 @@
+import typer
+from pathlib import Path
+from typing import Optional
+
+from just import Annotated, just_cli, capture_exception
+from just.utils import echo
+from just.utils.archive import extract as archive_extract, detect_archive_format, ArchiveFormat
+
+
+def get_default_output_dir(archive_path: str) -> str:
+    """
+    Get default output directory from archive filename.
+    
+    Simply removes all extensions by taking everything before the first dot.
+    
+    Args:
+        archive_path: Path to the archive file
+        
+    Returns:
+        Directory name without extensions
+    """
+    return archive_path.split(".")[0]
+
+
+@just_cli.command(name="extract")
+@capture_exception
+def extract_command(
+    archive: Annotated[str, typer.Argument(
+        help="Path to the archive file to extract"
+    )],
+    output: Annotated[Optional[str], typer.Option(
+        "-o", "--output",
+        help="Output directory for extracted files (default: archive name without extension)"
+    )] = None
+) -> None:
+    """
+    Extract archive and compressed files with automatic format detection.
+    
+    Supports: ZIP, TAR (with gz/bz2/xz/zst compression), GZIP, BZIP2, XZ, ZSTD, 7Z
+    
+    Automatically detects format using magic bytes (file signatures) for reliable
+    identification, even with incorrect file extensions. Extracts to a directory
+    named after the archive by default.
+    
+    Optional dependencies:
+    - 7Z support: pip install py7zr
+    - ZSTD support: pip install zstandard
+    
+    Examples:
+        just extract archive.zip          # Extracts to ./archive/
+        just extract archive.tar.gz       # Extracts to ./archive/
+        just extract file.gz              # Extracts to ./file
+        just extract data.7z -o out/      # Extracts to ./out/
+    """
+    archive_path = Path(archive)
+    
+    if not archive_path.exists():
+        echo.error(f"Archive not found: {archive}")
+        raise typer.Exit(1)
+    
+    fmt = detect_archive_format(str(archive_path))
+    
+    if fmt == ArchiveFormat.UNKNOWN:
+        echo.error(f"Unknown or unsupported archive format: {archive}")
+        raise typer.Exit(1)
+    
+    if fmt == ArchiveFormat.RAR:
+        echo.error("RAR format detected but not supported")
+        echo.info("RAR is a proprietary format. Install rarfile: pip install rarfile")
+        raise typer.Exit(1)
+    
+    if output is None:
+        output = get_default_output_dir(str(archive_path))
+    
+    if not archive_extract(str(archive_path), output):
+        raise Exception("Failed to extract archive")

just/commands/install.py

@@ -0,0 +1,36 @@
+import typer
+from typing import List, Optional
+from typing_extensions import Annotated
+
+from just import just_cli, echo
+from just.core.installer.install_package import install_package
+from just.utils.typer_utils import show_help
+
+
+@just_cli.command(name="install", context_settings={"ignore_unknown_options": True})
+def install(
+    args: Annotated[Optional[List[str]], typer.Argument(
+        help="The arguments to install the package"
+    )] = None,
+    help_flag: Annotated[bool, typer.Option(
+        "--help", "-h",
+        help="Show this help message and exit"
+    )] = False
+):
+    if not args:
+        show_help(just_cli, "install")
+        return
+
+    package_name = args.pop(0)
+    if help_flag:
+        args.append("--help")
+
+    try:
+        install_package(package_name, args)
+    except Exception as e:
+        echo.fail(f"Error installing {package_name}: {e}")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    just_cli()

just/commands/linux.py

@@ -0,0 +1,201 @@
+import os
+import typer
+import shutil
+from pathlib import Path
+from typing_extensions import Annotated
+
+from just import just_cli, capture_exception, echo
+from just.utils.file_utils import read_file_text
+from just.utils import confirm_action
+
+
+@just_cli.command(name="cat")
+@capture_exception
+def cat_file(
+    file_paths: Annotated[list[str], typer.Argument(
+        help="Files to display",
+        show_default=False
+    )],
+    with_line_numbers: Annotated[bool, typer.Option(
+        "--number", "-n",
+        help="Number all output lines"
+    )] = False
+):
+    """
+    Concatenate and print files.
+    """
+    for file_path in file_paths:
+        if os.path.isdir(file_path):
+            echo.red(f"cat: {file_path} is a directory")
+            exit(1)
+        try:
+            echo.echo(read_file_text(file_path, with_line_numbers=with_line_numbers))
+        except FileNotFoundError:
+            echo.red(f"cat: The file {file_path} does not exist")
+            exit(1)
+
+
+@just_cli.command(name="ls")
+@capture_exception
+def list_files(
+    path: Annotated[str, typer.Argument(
+        help="Directory to list",
+        show_default=False
+    )] = ".",
+    long_format: Annotated[bool, typer.Option(
+        "-l",
+        help="Use a long listing format"
+    )] = False,
+    all_format: Annotated[bool, typer.Option(
+        "--all", "-a",
+        help="Do not ignore entries starting with ."
+    )] = False
+):
+    """
+    List directory contents.
+    """
+    p = Path(path)
+    if not p.exists():
+        echo.red(f"ls: cannot access '{path}': No such file or directory")
+        exit(1)
+
+    if not p.is_dir():
+        if long_format:
+            stat = p.stat()
+            echo.echo(f"-rw-r--r-- 1 user group {stat.st_size:>8} {p.name}")
+        else:
+            echo.echo(p.name)
+        return
+
+    entries = list(p.iterdir())
+    if not all_format:
+        entries = [entry for entry in entries if not entry.name.startswith('.')]
+
+    if long_format:
+        for entry in entries:
+            stat = entry.stat()
+            permissions = "drwxr-xr-x" if entry.is_dir() else "-rw-r--r--"
+            size = stat.st_size
+            echo.echo(f"{permissions} 1 user group {size:>8} {entry.name}")
+    else:
+        for entry in entries:
+            echo.echo(entry.name)
+
+
+@just_cli.command(name="mkdir")
+@capture_exception
+def make_directory(
+    dir_names: Annotated[list[str], typer.Argument(
+        help="Directories to create",
+        show_default=False
+    )],
+    make_parents: Annotated[bool, typer.Option(
+        "--parents", "-p",
+        help="No error if existing, make parent directories as needed"
+    )] = False
+):
+    """
+    Create directories.
+    """
+    for dir_name in dir_names:
+        if make_parents:
+            os.makedirs(dir_name, exist_ok=True)
+        else:
+            os.mkdir(dir_name)
+
+
+@just_cli.command(name="rm")
+@capture_exception
+def remove_files(
+    targets: Annotated[list[str], typer.Argument(
+        help="Files or directories to remove",
+        show_default=False
+    )],
+    recursive: Annotated[bool, typer.Option(
+        "--recursive", "-r",
+        help="Remove directories and their contents recursively"
+    )] = False
+):
+    """
+    Remove files or directories.
+    """
+    for target in targets:
+        target_path = Path(target)
+        if not target_path.exists():
+            echo.red(f"rm: cannot remove '{target}': No such file or directory")
+            exit(1)
+        if target_path.is_dir():
+            # Prompt for confirmation when removing directory without -r
+            if not recursive and not confirm_action(f"rm: descend into directory '{target}'?"):
+                continue
+            shutil.rmtree(target_path)
+        else:
+            os.remove(target_path)
+
+
+@just_cli.command(name="cp")
+@capture_exception
+def copy_files(
+    source: Annotated[str, typer.Argument(
+        help="Source file or directory",
+        show_default=False
+    )],
+    destination: Annotated[str, typer.Argument(
+        help="Destination file or directory",
+        show_default=False
+    )],
+    recursive: Annotated[bool, typer.Option(
+        "--recursive", "-r",
+        help="Copy directories recursively"
+    )] = False
+):
+    """
+    Copy files or directories.
+    """
+    source_path = Path(source)
+    dest_path = Path(destination)
+
+    if not source_path.exists():
+        echo.red(f"cp: cannot stat '{source}': No such file or directory")
+        exit(1)
+
+
+    if source_path.is_dir():
+        if not recursive:
+            # Prompt for confirmation when copying directory without -r
+            if not confirm_action(f"cp: -r not specified; omitting directory '{source}'"):
+                exit(1)
+        if dest_path.exists() and dest_path.is_dir():
+            # Copy directory into existing directory
+            shutil.copytree(source_path, dest_path / source_path.name)
+        else:
+            shutil.copytree(source_path, dest_path)
+    else:
+        shutil.copy2(source_path, dest_path)
+
+
+@just_cli.command(name="mv")
+@capture_exception
+def move_files(
+    source: Annotated[str, typer.Argument(
+        help="Source file or directory",
+        show_default=False
+    )],
+    destination: Annotated[str, typer.Argument(
+        help="Destination file or directory",
+        show_default=False
+    )]
+):
+    """
+    Move or rename files or directories.
+    """
+    source_path = Path(source)
+    dest_path = Path(destination)
+
+    if not source_path.exists():
+        echo.red(f"mv: cannot stat '{source}': No such file or directory")
+        exit(1)
+    if dest_path.exists() and not confirm_action(f"mv: overwrite '{destination}'?"):
+        exit(1)
+
+    shutil.move(str(source_path), str(dest_path))

just/commands/tunnel.py

@@ -0,0 +1,27 @@
+import typer
+
+from typing_extensions import Annotated
+
+from just import create_typer_app, capture_exception, just_cli
+from just.utils import execute_command
+
+
+tunnel_cli = create_typer_app()
+
+
+@just_cli.command(name="tunnel")
+@capture_exception
+def create_cloudflare_tunnel(
+    url: Annotated[str, typer.Argument(
+        help='The URL to tunnel',
+        show_default=False
+    )]
+):
+    """
+    Create Cloudflare tunnel.
+    """
+    command = r"""
+    cloudflared tunnel --url <URL>
+    """
+    command = command.replace('<URL>', url)
+    execute_command(command)

just/commands/view.py

@@ -0,0 +1,33 @@
+import typer
+
+from pathlib import Path
+from typing_extensions import Annotated
+
+from just import just_cli
+from just.tui.markdown import MarkdownApp
+from just.commands.edit import edit_file
+
+
+def view_markdown_by_textual(file_path: str):
+    """View markdown file."""
+    app = MarkdownApp()
+    app.path = Path(file_path)
+    app.run()
+
+
+@just_cli.command(name="view")
+def view_file(
+    file_path: Annotated[str, typer.Argument(
+        help="The file to view",
+        show_default=False
+    )]
+):
+    """
+    Preview the structured text files (e.g., Markdown, JSON, XML)
+    """
+    ext = "".join(Path(file_path).suffixes)
+    if ext == '.md':
+        view_markdown_by_textual(file_path)
+    # TODO: support other file types
+    else:
+        edit_file(file_path)