pltr-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{pltr_cli-0.2.0 → pltr_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pltr-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Command-line interface for Palantir Foundry APIs
 Project-URL: Homepage, https://github.com/anjor/pltr-cli
 Project-URL: Repository, https://github.com/anjor/pltr-cli

{pltr_cli-0.2.0 → pltr_cli-0.3.0}/docs/README.md

@@ -8,6 +8,7 @@ Welcome to the pltr-cli documentation! This CLI tool provides a command-line int
 - **[Quick Start Guide](user-guide/quick-start.md)** - Get up and running in minutes
 - **[Authentication Setup](user-guide/authentication.md)** - Configure token and OAuth2 authentication
 - **[Command Reference](user-guide/commands.md)** - Complete reference for all 50+ commands
+- **[Command Aliases](user-guide/aliases.md)** - Create shortcuts for frequently used commands
 - **[Common Workflows](user-guide/workflows.md)** - Real-world data analysis patterns
 - **[Troubleshooting](user-guide/troubleshooting.md)** - Common issues and solutions
 

pltr_cli-0.3.0/docs/user-guide/aliases.md

@@ -0,0 +1,257 @@
+# Command Aliases
+
+Command aliases allow you to create shortcuts for frequently used commands, improving your productivity when working with pltr-cli.
+
+## Overview
+
+Aliases are custom shortcuts that expand to full commands. They help you:
+- Save time by reducing typing for common operations
+- Create personalized workflows
+- Simplify complex command sequences
+- Build reusable command templates
+
+## Creating Aliases
+
+### Basic Alias
+
+Create a simple alias with the `add` command:
+
+```bash
+# Create an alias 'ds' for 'dataset get'
+pltr alias add ds "dataset get"
+
+# Now you can use:
+pltr ds ri.foundry.main.dataset.123
+# Instead of:
+pltr dataset get ri.foundry.main.dataset.123
+```
+
+### Complex Aliases
+
+Aliases can include options and arguments:
+
+```bash
+# Create an alias for SQL queries with JSON output
+pltr alias add jsonsql "sql execute --format json"
+
+# Usage:
+pltr jsonsql "SELECT * FROM table LIMIT 10"
+```
+
+### Overwriting Existing Aliases
+
+Use the `--force` flag to overwrite an existing alias:
+
+```bash
+pltr alias add ds "dataset list" --force
+```
+
+## Managing Aliases
+
+### List All Aliases
+
+View all configured aliases:
+
+```bash
+pltr alias list
+```
+
+Output:
+```
+┏━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ Alias   ┃ Command                     ┃
+┡━━━━━━━━━┩━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ ds      │ dataset get                 │
+│ jsonsql │ sql execute --format json   │
+│ onto    │ ontology object-list        │
+└─────────┴─────────────────────────────┘
+```
+
+### Show Specific Alias
+
+Display details of a single alias:
+
+```bash
+pltr alias show ds
+# Output: ds → dataset get
+```
+
+### Edit an Alias
+
+Modify an existing alias:
+
+```bash
+pltr alias edit ds "dataset create"
+```
+
+### Remove an Alias
+
+Delete an alias you no longer need:
+
+```bash
+pltr alias remove ds
+# Or skip confirmation:
+pltr alias remove ds --no-confirm
+```
+
+### Clear All Aliases
+
+Remove all aliases at once:
+
+```bash
+pltr alias clear
+# Or skip confirmation:
+pltr alias clear --no-confirm
+```
+
+## Advanced Features
+
+### Resolve Aliases
+
+See what command an alias expands to:
+
+```bash
+pltr alias resolve ds
+# Output: ds → dataset get
+```
+
+### Export and Import
+
+Export aliases to share with teammates or backup:
+
+```bash
+# Export to file
+pltr alias export --output my-aliases.json
+
+# Export to stdout
+pltr alias export
+```
+
+Import aliases from a file:
+
+```bash
+# Replace existing aliases
+pltr alias import aliases.json
+
+# Merge with existing aliases
+pltr alias import aliases.json --merge
+```
+
+### Nested Aliases
+
+Aliases can reference other aliases:
+
+```bash
+pltr alias add d "dataset"
+pltr alias add dg "d get"
+# 'dg' expands to 'dataset get'
+```
+
+## Common Alias Examples
+
+Here are some useful aliases to get you started:
+
+```bash
+# Dataset operations
+pltr alias add dsg "dataset get"
+pltr alias add dsc "dataset create"
+
+# SQL shortcuts
+pltr alias add sq "sql execute"
+pltr alias add sqj "sql execute --format json"
+pltr alias add sqc "sql execute --format csv"
+pltr alias add sqx "sql export"
+
+# Ontology shortcuts
+pltr alias add ol "ontology list"
+pltr alias add oo "ontology object-list"
+pltr alias add oget "ontology object-get"
+
+# Admin shortcuts
+pltr alias add ul "admin user list"
+pltr alias add uc "admin user current"
+pltr alias add gl "admin group list"
+
+# Combined operations
+pltr alias add quicksql "sql execute --format table --limit 100"
+pltr alias add mydata "dataset get ri.foundry.main.dataset.my-favorite-dataset"
+```
+
+## Shell Integration
+
+Aliases work seamlessly with shell completion and interactive mode:
+
+### Tab Completion
+
+After installing shell completions, alias names are available for tab completion:
+
+```bash
+pltr d<TAB>
+# Shows: ds, dsc, dsg
+```
+
+### Interactive Shell
+
+Aliases are available in the interactive shell:
+
+```bash
+pltr shell
+pltr> ds ri.foundry.main.dataset.123
+# Expands to: dataset get ri.foundry.main.dataset.123
+```
+
+## Best Practices
+
+1. **Use meaningful names**: Choose alias names that are easy to remember
+2. **Keep it simple**: Avoid overly complex aliases that are hard to understand
+3. **Document your aliases**: Export and share team-standard aliases
+4. **Avoid conflicts**: Don't use names that conflict with existing commands
+5. **Test before sharing**: Verify aliases work correctly before distribution
+
+## Limitations
+
+- Aliases cannot use reserved command names (configure, verify, dataset, etc.)
+- Circular references are not allowed and will be detected
+- Aliases are expanded only once (no recursive expansion)
+- Maximum alias chain depth is 10 to prevent infinite loops
+
+## Configuration Storage
+
+Aliases are stored in `~/.config/pltr/aliases.json` and persist across sessions. The file uses standard JSON format and can be manually edited if needed.
+
+## Troubleshooting
+
+### Alias Not Working
+
+1. Check if the alias exists:
+   ```bash
+   pltr alias show myalias
+   ```
+
+2. Verify the alias syntax:
+   ```bash
+   pltr alias resolve myalias
+   ```
+
+3. Test the expanded command directly:
+   ```bash
+   pltr <expanded command>
+   ```
+
+### Circular Reference Error
+
+If you see a circular reference error, check your alias chain:
+
+```bash
+# Example of circular reference (not allowed):
+pltr alias add a "b"
+pltr alias add b "a"  # Error: would create circular reference
+```
+
+### Import Errors
+
+When importing fails, check:
+- File exists and is readable
+- JSON format is valid
+- No circular references in imported aliases
+- No conflicts with reserved command names

{pltr_cli-0.2.0 → pltr_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pltr-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "Command-line interface for Palantir Foundry APIs"
 authors = [
     { name = "anjor", email = "anjor@umd.edu" }

{pltr_cli-0.2.0 → pltr_cli-0.3.0}/src/pltr/__main__.py

@@ -23,6 +23,9 @@ if "_PLTR_COMPLETE" in os.environ:
 
 # Normal CLI execution
 from pltr.cli import app
+from pltr.utils.alias_resolver import inject_alias_resolution
 
 if __name__ == "__main__":
+    # Resolve aliases before running the app
+    inject_alias_resolution()
     app()

{pltr_cli-0.2.0 → pltr_cli-0.3.0}/src/pltr/cli.py

@@ -15,6 +15,7 @@ from pltr.commands import (
     admin,
     shell,
     completion,
+    alias,
 )
 
 app = typer.Typer(
@@ -36,6 +37,7 @@ app.add_typer(
 )
 app.add_typer(shell.shell_app, name="shell", help="Interactive shell mode")
 app.add_typer(completion.app, name="completion", help="Manage shell completions")
+app.add_typer(alias.app, name="alias", help="Manage command aliases")
 
 
 def version_callback(value: bool):

pltr_cli-0.3.0/src/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_cli-0.2.0 → pltr_cli-0.3.0}/src/pltr/commands/ontology.py

@@ -33,16 +33,13 @@ def list_ontologies(
     output: Optional[str] = typer.Option(
         None, "--output", "-o", help="Output file path"
     ),
-    page_size: Optional[int] = typer.Option(
-        None, "--page-size", help="Number of results per page"
-    ),
 ):
     """List all available ontologies."""
     try:
         service = OntologyService(profile=profile)
 
         with SpinnerProgressTracker().track_spinner("Fetching ontologies..."):
-            ontologies = service.list_ontologies(page_size=page_size)
+            ontologies = service.list_ontologies()
 
         formatter.format_table(
             ontologies,
@@ -106,16 +103,13 @@ def list_object_types(
     output: Optional[str] = typer.Option(
         None, "--output", "-o", help="Output file path"
     ),
-    page_size: Optional[int] = typer.Option(
-        None, "--page-size", help="Number of results per page"
-    ),
 ):
     """List object types in an ontology."""
     try:
         service = ObjectTypeService(profile=profile)
 
         with SpinnerProgressTracker().track_spinner("Fetching object types..."):
-            object_types = service.list_object_types(ontology_rid, page_size=page_size)
+            object_types = service.list_object_types(ontology_rid)
 
         formatter.format_table(
             object_types,