pltr-cli 0.1.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

pltr/commands/alias.py

@@ -0,0 +1,241 @@
+"""Command alias management commands."""
+
+import json
+from typing import Optional
+
+import typer
+from rich import print as rprint
+
+from pltr.config.aliases import AliasManager
+from pltr.utils.completion import complete_alias_names
+
+app = typer.Typer(name="alias", help="Manage command aliases", no_args_is_help=True)
+
+
+@app.command()
+def add(
+    name: str = typer.Argument(..., help="Alias name"),
+    command: str = typer.Argument(..., help="Command to alias"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing alias"),
+) -> None:
+    """Create a new command alias."""
+    manager = AliasManager()
+
+    # Check if alias already exists
+    if manager.get_alias(name) and not force:
+        rprint(f"[red]Alias '{name}' already exists. Use --force to overwrite.[/red]")
+        raise typer.Exit(1)
+
+    # Check for reserved command names
+    reserved_commands = [
+        "configure",
+        "verify",
+        "dataset",
+        "ontology",
+        "sql",
+        "admin",
+        "shell",
+        "completion",
+        "alias",
+        "help",
+        "--version",
+    ]
+    if name in reserved_commands:
+        rprint(f"[red]Cannot use reserved command name '{name}' as alias[/red]")
+        raise typer.Exit(1)
+
+    try:
+        if force and manager.get_alias(name):
+            success = manager.edit_alias(name, command)
+            action = "Updated"
+        else:
+            success = manager.add_alias(name, command)
+            action = "Created"
+
+        if success:
+            rprint(f"[green]{action} alias:[/green] {name} → {command}")
+        else:
+            rprint(f"[red]Failed to create alias '{name}'[/red]")
+            raise typer.Exit(1)
+    except ValueError as e:
+        rprint(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def remove(
+    name: str = typer.Argument(
+        ..., help="Alias name to remove", autocompletion=complete_alias_names
+    ),
+    confirm: bool = typer.Option(
+        True, "--confirm/--no-confirm", help="Confirm removal"
+    ),
+) -> None:
+    """Remove a command alias."""
+    manager = AliasManager()
+
+    command = manager.get_alias(name)
+    if not command:
+        rprint(f"[red]Alias '{name}' not found[/red]")
+        raise typer.Exit(1)
+
+    if confirm:
+        confirmation = typer.confirm(f"Remove alias '{name}' → {command}?")
+        if not confirmation:
+            rprint("[yellow]Removal cancelled[/yellow]")
+            return
+
+    if manager.remove_alias(name):
+        rprint(f"[green]Removed alias '{name}'[/green]")
+    else:
+        rprint(f"[red]Failed to remove alias '{name}'[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def edit(
+    name: str = typer.Argument(
+        ..., help="Alias name to edit", autocompletion=complete_alias_names
+    ),
+    command: str = typer.Argument(..., help="New command for the alias"),
+) -> None:
+    """Edit an existing command alias."""
+    manager = AliasManager()
+
+    if not manager.get_alias(name):
+        rprint(f"[red]Alias '{name}' not found[/red]")
+        raise typer.Exit(1)
+
+    try:
+        if manager.edit_alias(name, command):
+            rprint(f"[green]Updated alias:[/green] {name} → {command}")
+        else:
+            rprint(f"[red]Failed to edit alias '{name}'[/red]")
+            raise typer.Exit(1)
+    except ValueError as e:
+        rprint(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_aliases() -> None:
+    """List all command aliases."""
+    manager = AliasManager()
+    manager.display_aliases()
+
+
+@app.command()
+def show(
+    name: str = typer.Argument(
+        ..., help="Alias name to show", autocompletion=complete_alias_names
+    ),
+) -> None:
+    """Show details of a specific alias."""
+    manager = AliasManager()
+    manager.display_aliases(name)
+
+
+@app.command()
+def clear(
+    confirm: bool = typer.Option(
+        True, "--confirm/--no-confirm", help="Confirm clearing all aliases"
+    ),
+) -> None:
+    """Clear all command aliases."""
+    manager = AliasManager()
+
+    aliases = manager.list_aliases()
+    if not aliases:
+        rprint("[yellow]No aliases to clear[/yellow]")
+        return
+
+    if confirm:
+        confirmation = typer.confirm(f"Clear all {len(aliases)} aliases?")
+        if not confirmation:
+            rprint("[yellow]Clear cancelled[/yellow]")
+            return
+
+    count = manager.clear_all()
+    rprint(f"[green]Cleared {count} aliases[/green]")
+
+
+@app.command("export")
+def export_aliases(
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file (default: stdout)"
+    ),
+) -> None:
+    """Export aliases to JSON format."""
+    manager = AliasManager()
+    aliases = manager.export_aliases()
+
+    if not aliases:
+        rprint("[yellow]No aliases to export[/yellow]")
+        return
+
+    json_data = json.dumps(aliases, indent=2, sort_keys=True)
+
+    if output:
+        with open(output, "w") as f:
+            f.write(json_data)
+        rprint(f"[green]Exported {len(aliases)} aliases to {output}[/green]")
+    else:
+        print(json_data)
+
+
+@app.command("import")
+def import_aliases(
+    input_file: str = typer.Argument(..., help="JSON file containing aliases"),
+    merge: bool = typer.Option(
+        False, "--merge", "-m", help="Merge with existing aliases (default: replace)"
+    ),
+) -> None:
+    """Import aliases from a JSON file."""
+    manager = AliasManager()
+
+    try:
+        with open(input_file, "r") as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, IOError) as e:
+        rprint(f"[red]Error reading file: {e}[/red]")
+        raise typer.Exit(1)
+
+    if not isinstance(data, dict):
+        rprint("[red]Invalid format: expected JSON object with alias mappings[/red]")
+        raise typer.Exit(1)
+
+    # Clear existing aliases if not merging
+    if not merge and manager.list_aliases():
+        confirmation = typer.confirm("Replace existing aliases?")
+        if not confirmation:
+            rprint("[yellow]Import cancelled[/yellow]")
+            return
+        manager.clear_all()
+
+    count = manager.import_aliases(data)
+    rprint(f"[green]Imported {count} aliases from {input_file}[/green]")
+
+
+@app.command()
+def resolve(
+    command: str = typer.Argument(
+        ..., help="Command to resolve", autocompletion=complete_alias_names
+    ),
+) -> None:
+    """Resolve an alias to show the actual command."""
+    manager = AliasManager()
+
+    resolved = manager.resolve_alias(command)
+    if resolved == command:
+        if command in manager.list_aliases():
+            rprint(
+                f"[yellow]'{command}' is an alias but may have circular references[/yellow]"
+            )
+        else:
+            rprint(f"[yellow]'{command}' is not an alias[/yellow]")
+    else:
+        rprint(f"[green]{command}[/green] → {resolved}")
+
+
+if __name__ == "__main__":
+    app()

pltr/commands/completion.py

@@ -0,0 +1,383 @@
+"""Shell completion commands for pltr CLI."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+console = Console()
+app = typer.Typer(help="Manage shell completions for pltr CLI")
+
+
+def get_shell_from_env() -> Optional[str]:
+    """Detect the current shell from environment."""
+    shell_path = os.environ.get("SHELL", "")
+    if "bash" in shell_path:
+        return "bash"
+    elif "zsh" in shell_path:
+        return "zsh"
+    elif "fish" in shell_path:
+        return "fish"
+    return None
+
+
+@app.command()
+def install(
+    shell: Optional[str] = typer.Option(
+        None,
+        "--shell",
+        "-s",
+        help="Shell type (bash, zsh, fish). Auto-detected if not specified.",
+    ),
+    path: Optional[Path] = typer.Option(
+        None,
+        "--path",
+        "-p",
+        help="Custom path to install completion file.",
+    ),
+):
+    """Install shell completions for pltr CLI.
+
+    This command will install shell completions for the specified shell
+    (or auto-detect from your environment). After installation, restart
+    your shell or source the appropriate file to enable completions.
+
+    Examples:
+        pltr completion install
+        pltr completion install --shell bash
+        pltr completion install --shell zsh --path ~/.config/custom/completions
+    """
+    # Auto-detect shell if not specified
+    if shell is None:
+        shell = get_shell_from_env()
+        if shell is None:
+            console.print(
+                "[red]Could not detect shell type. Please specify with --shell option.[/red]"
+            )
+            console.print("Supported shells: bash, zsh, fish")
+            raise typer.Exit(1)
+        console.print(f"[cyan]Auto-detected shell: {shell}[/cyan]")
+
+    shell = shell.lower()
+    if shell not in ["bash", "zsh", "fish"]:
+        console.print(f"[red]Unsupported shell: {shell}[/red]")
+        console.print("Supported shells: bash, zsh, fish")
+        raise typer.Exit(1)
+
+    # Generate completion script
+    completion_script = generate_completion_script(shell)
+
+    # Determine installation path
+    if path is None:
+        path = get_default_completion_path(shell)
+
+    # Ensure directory exists
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write completion file
+    try:
+        path.write_text(completion_script)
+        console.print(f"[green]✓[/green] Completion file written to: {path}")
+    except Exception as e:
+        console.print(f"[red]Failed to write completion file: {e}[/red]")
+        raise typer.Exit(1)
+
+    # Show instructions for activation
+    show_activation_instructions(shell, path)
+
+
+@app.command()
+def show(
+    shell: Optional[str] = typer.Option(
+        None,
+        "--shell",
+        "-s",
+        help="Shell type (bash, zsh, fish). Auto-detected if not specified.",
+    ),
+):
+    """Show the completion script for the specified shell.
+
+    This displays the completion script without installing it,
+    useful for manual installation or debugging.
+    """
+    # Auto-detect shell if not specified
+    if shell is None:
+        shell = get_shell_from_env()
+        if shell is None:
+            console.print(
+                "[red]Could not detect shell type. Please specify with --shell option.[/red]"
+            )
+            console.print("Supported shells: bash, zsh, fish")
+            raise typer.Exit(1)
+
+    shell = shell.lower()
+    if shell not in ["bash", "zsh", "fish"]:
+        console.print(f"[red]Unsupported shell: {shell}[/red]")
+        console.print("Supported shells: bash, zsh, fish")
+        raise typer.Exit(1)
+
+    # Generate and display completion script
+    completion_script = generate_completion_script(shell)
+    syntax = Syntax(completion_script, "bash", theme="monokai", line_numbers=True)
+
+    panel = Panel(
+        syntax,
+        title=f"{shell.capitalize()} Completion Script",
+        border_style="cyan",
+    )
+    console.print(panel)
+
+
+def generate_completion_script(shell: str) -> str:
+    """Generate completion script for the specified shell."""
+    if shell == "bash":
+        return generate_bash_completion()
+    elif shell == "zsh":
+        return generate_zsh_completion()
+    elif shell == "fish":
+        return generate_fish_completion()
+    else:
+        raise ValueError(f"Unsupported shell: {shell}")
+
+
+def generate_bash_completion() -> str:
+    """Generate Bash completion script."""
+    return """# pltr bash completion script
+# Generated by pltr completion install
+
+_pltr_completion() {
+    local IFS=$'\\n'
+    local response
+
+    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD _PLTR_COMPLETE=bash_complete pltr)
+
+    for completion in $response; do
+        IFS=',' read type value <<< "$completion"
+
+        if [[ $type == 'dir' ]]; then
+            COMPREPLY+=("$value/")
+            compopt -o dirnames
+        elif [[ $type == 'file' ]]; then
+            COMPREPLY+=("$value")
+            compopt -o filenames
+        elif [[ $type == 'plain' ]]; then
+            COMPREPLY+=("$value")
+        fi
+    done
+
+    return 0
+}
+
+_pltr_completion_setup() {
+    complete -o nosort -F _pltr_completion pltr
+}
+
+_pltr_completion_setup
+"""
+
+
+def generate_zsh_completion() -> str:
+    """Generate Zsh completion script."""
+    return """#compdef pltr
+# pltr zsh completion script
+# Generated by pltr completion install
+
+_pltr() {
+    local -a completions
+    local -a completions_with_descriptions
+    local -a response
+    (( ! $+commands[pltr] )) && return 1
+
+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) _PLTR_COMPLETE=zsh_complete pltr)}")
+
+    for type key descr in ${response}; do
+        if [[ "$type" == "plain" ]]; then
+            if [[ "$descr" == "_" ]]; then
+                completions+=("$key")
+            else
+                completions_with_descriptions+=("$key":"$descr")
+            fi
+        elif [[ "$type" == "dir" ]]; then
+            _path_files -/
+        elif [[ "$type" == "file" ]]; then
+            _path_files -f
+        fi
+    done
+
+    if [ -n "$completions_with_descriptions" ]; then
+        _describe -V unsorted completions_with_descriptions -U
+    fi
+
+    if [ -n "$completions" ]; then
+        compadd -U -V unsorted -a completions
+    fi
+}
+
+if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
+    _pltr "$@"
+else
+    compdef _pltr pltr
+fi
+"""
+
+
+def generate_fish_completion() -> str:
+    """Generate Fish completion script."""
+    return """# pltr fish completion script
+# Generated by pltr completion install
+
+function _pltr_completion
+    set -l response (env COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t) _PLTR_COMPLETE=fish_complete pltr)
+
+    for completion in $response
+        set -l metadata (string split "," $completion)
+
+        if test $metadata[1] = "dir"
+            __fish_complete_directories $metadata[2]
+        else if test $metadata[1] = "file"
+            __fish_complete_path $metadata[2]
+        else if test $metadata[1] = "plain"
+            echo $metadata[2]
+        end
+    end
+end
+
+complete -c pltr -f -a "(_pltr_completion)"
+"""
+
+
+def get_default_completion_path(shell: str) -> Path:
+    """Get the default path for completion file installation."""
+    home = Path.home()
+
+    if shell == "bash":
+        # Try bash-completion paths
+        paths = [
+            home / ".local" / "share" / "bash-completion" / "completions" / "pltr",
+            home / ".bash_completion.d" / "pltr",
+            Path("/etc/bash_completion.d/pltr"),
+        ]
+        # Use first writable path
+        for p in paths[:-1]:  # Skip system path for user installs
+            if p.parent.exists() or not p.parent.parent.exists():
+                return p
+        return paths[0]
+
+    elif shell == "zsh":
+        # Zsh completion paths
+        return home / ".zfunc" / "_pltr"
+
+    elif shell == "fish":
+        # Fish completion path
+        return home / ".config" / "fish" / "completions" / "pltr.fish"
+
+    else:
+        raise ValueError(f"Unknown shell: {shell}")
+
+
+def show_activation_instructions(shell: str, path: Path):
+    """Show instructions for activating completions."""
+    console.print("\n[yellow]Activation Instructions:[/yellow]")
+
+    if shell == "bash":
+        console.print(
+            Panel(
+                f"""To activate completions, add this to your ~/.bashrc:
+
+[cyan]# Load pltr completions
+if [ -f {path} ]; then
+    source {path}
+fi[/cyan]
+
+Then reload your shell:
+[cyan]source ~/.bashrc[/cyan]
+
+Or start a new terminal session.""",
+                title="Bash Activation",
+                border_style="green",
+            )
+        )
+
+    elif shell == "zsh":
+        console.print(
+            Panel(
+                f"""To activate completions, add this to your ~/.zshrc:
+
+[cyan]# Add custom completion directory
+fpath=({path.parent} $fpath)
+
+# Initialize completions (if not already done)
+autoload -Uz compinit && compinit[/cyan]
+
+Then reload your shell:
+[cyan]source ~/.zshrc[/cyan]
+
+Or start a new terminal session.""",
+                title="Zsh Activation",
+                border_style="green",
+            )
+        )
+
+    elif shell == "fish":
+        console.print(
+            Panel(
+                f"""Completions should be automatically loaded from:
+{path}
+
+If not working, reload your shell:
+[cyan]exec fish[/cyan]
+
+Or start a new terminal session.""",
+                title="Fish Activation",
+                border_style="green",
+            )
+        )
+
+
+@app.command()
+def uninstall(
+    shell: Optional[str] = typer.Option(
+        None,
+        "--shell",
+        "-s",
+        help="Shell type (bash, zsh, fish). Auto-detected if not specified.",
+    ),
+):
+    """Uninstall shell completions for pltr CLI."""
+    # Auto-detect shell if not specified
+    if shell is None:
+        shell = get_shell_from_env()
+        if shell is None:
+            console.print(
+                "[red]Could not detect shell type. Please specify with --shell option.[/red]"
+            )
+            raise typer.Exit(1)
+
+    shell = shell.lower()
+    if shell not in ["bash", "zsh", "fish"]:
+        console.print(f"[red]Unsupported shell: {shell}[/red]")
+        raise typer.Exit(1)
+
+    # Get default completion path
+    path = get_default_completion_path(shell)
+
+    if path.exists():
+        try:
+            path.unlink()
+            console.print(f"[green]✓[/green] Removed completion file: {path}")
+            console.print(
+                "\n[yellow]Remember to remove any sourcing commands from your shell config.[/yellow]"
+            )
+        except Exception as e:
+            console.print(f"[red]Failed to remove completion file: {e}[/red]")
+            raise typer.Exit(1)
+    else:
+        console.print(f"[yellow]No completion file found at: {path}[/yellow]")
+
+
+if __name__ == "__main__":
+    app()

pltr/commands/dataset.py

@@ -10,6 +10,12 @@ from ..services.dataset import DatasetService
 from ..utils.formatting import OutputFormatter
 from ..utils.progress import SpinnerProgressTracker
 from ..auth.base import ProfileNotFoundError, MissingCredentialsError
+from ..utils.completion import (
+    complete_rid,
+    complete_profile,
+    complete_output_format,
+    cache_rid,
+)
 
 app = typer.Typer()
 console = Console()
@@ -18,10 +24,18 @@ formatter = OutputFormatter(console)
 
 @app.command("get")
 def get_dataset(
-    dataset_rid: str = typer.Argument(..., help="Dataset Resource Identifier"),
-    profile: Optional[str] = typer.Option(None, "--profile", "-p", help="Profile name"),
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
     format: str = typer.Option(
-        "table", "--format", "-f", help="Output format (table, json, csv)"
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
     ),
     output: Optional[str] = typer.Option(
         None, "--output", "-o", help="Output file path"
@@ -29,6 +43,9 @@ def get_dataset(
 ):
     """Get detailed information about a specific dataset."""
     try:
+        # Cache the RID for future completions
+        cache_rid(dataset_rid)
+
         service = DatasetService(profile=profile)
 
         with SpinnerProgressTracker().track_spinner(