pltr-cli 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

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.py

@@ -10,11 +10,13 @@ from pltr.commands import (
     configure,
     verify,
     dataset,
+    folder,
     ontology,
     sql,
     admin,
     shell,
     completion,
+    alias,
 )
 
 app = typer.Typer(
@@ -27,6 +29,7 @@ app = typer.Typer(
 app.add_typer(configure.app, name="configure", help="Manage authentication profiles")
 app.add_typer(verify.app, name="verify", help="Verify authentication")
 app.add_typer(dataset.app, name="dataset", help="Manage datasets")
+app.add_typer(folder.app, name="folder", help="Manage folders")
 app.add_typer(ontology.app, name="ontology", help="Ontology operations")
 app.add_typer(sql.app, name="sql", help="Execute SQL queries")
 app.add_typer(
@@ -36,6 +39,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/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/folder.py

@@ -0,0 +1,338 @@
+"""
+Folder management commands for Foundry filesystem.
+"""
+
+import typer
+from typing import Optional, List
+from rich.console import Console
+from rich.table import Table
+
+from ..services.folder import FolderService
+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()
+formatter = OutputFormatter(console)
+
+
+@app.command("create")
+def create_folder(
+    name: str = typer.Argument(..., help="Folder display name"),
+    parent_folder: str = typer.Option(
+        "ri.compass.main.folder.0",
+        "--parent-folder",
+        "-p",
+        help="Parent folder RID (default: root folder)",
+        autocompletion=complete_rid,
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+):
+    """Create a new folder in Foundry."""
+    try:
+        service = FolderService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(f"Creating folder '{name}'..."):
+            folder = service.create_folder(
+                display_name=name, parent_folder_rid=parent_folder
+            )
+
+        # Cache the RID for future completions
+        if folder.get("rid"):
+            cache_rid(folder["rid"])
+
+        formatter.print_success(f"Successfully created folder '{name}'")
+        formatter.print_info(f"Folder RID: {folder.get('rid', 'unknown')}")
+
+        # Format output
+        if format == "json":
+            formatter.format_dict(folder)
+        elif format == "csv":
+            formatter.format_list([folder])
+        else:
+            _format_folder_table(folder)
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to create folder: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("get")
+def get_folder(
+    folder_rid: str = typer.Argument(
+        ..., help="Folder Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "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"
+    ),
+):
+    """Get detailed information about a specific folder."""
+    try:
+        # Cache the RID for future completions
+        cache_rid(folder_rid)
+
+        service = FolderService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(f"Fetching folder {folder_rid}..."):
+            folder = service.get_folder(folder_rid)
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(folder, output, "json")
+            else:
+                formatter.format_dict(folder)
+        elif format == "csv":
+            if output:
+                formatter.save_to_file([folder], output, "csv")
+            else:
+                formatter.format_list([folder])
+        else:
+            _format_folder_table(folder)
+
+        if output:
+            formatter.print_success(f"Folder information saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to get folder: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_children(
+    folder_rid: str = typer.Argument(
+        ...,
+        help="Folder Resource Identifier (use 'ri.compass.main.folder.0' for root)",
+        autocompletion=complete_rid,
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "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"
+    ),
+    page_size: Optional[int] = typer.Option(
+        None, "--page-size", help="Number of items per page"
+    ),
+):
+    """List all child resources of a folder."""
+    try:
+        # Cache the RID for future completions
+        cache_rid(folder_rid)
+
+        service = FolderService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Listing children of folder {folder_rid}..."
+        ):
+            children = service.list_children(folder_rid, page_size=page_size)
+
+        if not children:
+            formatter.print_info("No children found in this folder.")
+            return
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(children, output, "json")
+            else:
+                formatter.format_list(children)
+        elif format == "csv":
+            if output:
+                formatter.save_to_file(children, output, "csv")
+            else:
+                formatter.format_list(children)
+        else:
+            _format_children_table(children)
+
+        if output:
+            formatter.print_success(f"Folder children saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to list folder children: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("batch-get")
+def get_folders_batch(
+    folder_rids: List[str] = typer.Argument(
+        ..., help="Folder Resource Identifiers (space-separated)"
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "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"
+    ),
+):
+    """Get multiple folders in a single request (max 1000)."""
+    try:
+        service = FolderService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching {len(folder_rids)} folders..."
+        ):
+            folders = service.get_folders_batch(folder_rids)
+
+        # Cache RIDs for future completions
+        for folder in folders:
+            if folder.get("rid"):
+                cache_rid(folder["rid"])
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(folders, output, "json")
+            else:
+                formatter.format_list(folders)
+        elif format == "csv":
+            if output:
+                formatter.save_to_file(folders, output, "csv")
+            else:
+                formatter.format_list(folders)
+        else:
+            _format_folders_batch_table(folders)
+
+        if output:
+            formatter.print_success(f"Folders information saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except ValueError as e:
+        formatter.print_error(f"Invalid request: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to get folders batch: {e}")
+        raise typer.Exit(1)
+
+
+def _format_folder_table(folder: dict):
+    """Format folder information as a table."""
+    table = Table(
+        title="Folder Information", show_header=True, header_style="bold cyan"
+    )
+    table.add_column("Property", style="cyan")
+    table.add_column("Value")
+
+    table.add_row("RID", folder.get("rid", "N/A"))
+    table.add_row("Display Name", folder.get("display_name", "N/A"))
+    table.add_row("Description", folder.get("description", "N/A"))
+    table.add_row("Parent Folder", folder.get("parent_folder_rid", "N/A"))
+    table.add_row("Created", folder.get("created", "N/A"))
+    table.add_row("Modified", folder.get("modified", "N/A"))
+
+    console.print(table)
+
+
+def _format_children_table(children: List[dict]):
+    """Format folder children as a table."""
+    table = Table(title="Folder Children", show_header=True, header_style="bold cyan")
+    table.add_column("Type", style="cyan")
+    table.add_column("Display Name")
+    table.add_column("RID")
+
+    for child in children:
+        table.add_row(
+            child.get("type", "unknown"),
+            child.get("display_name", child.get("name", "N/A")),
+            child.get("rid", "N/A"),
+        )
+
+    console.print(table)
+    console.print(f"\nTotal: {len(children)} items")
+
+
+def _format_folders_batch_table(folders: List[dict]):
+    """Format multiple folders as a table."""
+    table = Table(title="Folders", show_header=True, header_style="bold cyan")
+    table.add_column("Display Name")
+    table.add_column("RID")
+    table.add_column("Parent Folder")
+    table.add_column("Description")
+
+    for folder in folders:
+        table.add_row(
+            folder.get("display_name", "N/A"),
+            folder.get("rid", "N/A"),
+            folder.get("parent_folder_rid", "N/A"),
+            folder.get("description", "N/A") or "",
+        )
+
+    console.print(table)
+    console.print(f"\nTotal: {len(folders)} folders")
+
+
+@app.callback()
+def main():
+    """
+    Folder operations using foundry-platform-sdk.
+
+    Manage folders in the Foundry filesystem. Create, retrieve, and list
+    folder contents using Resource Identifiers (RIDs).
+
+    The root folder RID is: ri.compass.main.folder.0
+
+    Examples:
+        # Create a folder in root
+        pltr folder create "My Folder"
+
+        # Create a folder in a specific parent
+        pltr folder create "Sub Folder" --parent-folder ri.compass.main.folder.xyz123
+
+        # List root folder contents
+        pltr folder list ri.compass.main.folder.0
+
+        # Get folder information
+        pltr folder get ri.compass.main.folder.xyz123
+    """
+    pass

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,

pltr/config/aliases.py

@@ -0,0 +1,254 @@
+"""Alias configuration management for pltr-cli."""
+
+import json
+from typing import Dict, List, Optional
+
+from rich import print as rprint
+from rich.table import Table
+
+from pltr.config.settings import Settings
+
+
+class AliasManager:
+    """Manages command aliases for pltr-cli."""
+
+    def __init__(self) -> None:
+        """Initialize the alias manager."""
+        settings = Settings()
+        self.config_dir = settings.config_dir
+        self.aliases_file = self.config_dir / "aliases.json"
+        self.aliases = self._load_aliases()
+
+    def _load_aliases(self) -> Dict[str, str]:
+        """Load aliases from the configuration file.
+
+        Returns:
+            Dictionary mapping alias names to commands
+        """
+        if not self.aliases_file.exists():
+            return {}
+
+        try:
+            with open(self.aliases_file, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+    def _save_aliases(self) -> None:
+        """Save aliases to the configuration file."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        with open(self.aliases_file, "w") as f:
+            json.dump(self.aliases, f, indent=2, sort_keys=True)
+
+    def add_alias(self, name: str, command: str) -> bool:
+        """Add a new alias.
+
+        Args:
+            name: Alias name
+            command: Command to alias
+
+        Returns:
+            True if alias was added, False if it already exists
+
+        Raises:
+            ValueError: If the alias would create a circular reference
+        """
+        if name in self.aliases:
+            return False
+
+        # Check for circular references
+        if self._would_create_cycle(name, command):
+            raise ValueError(f"Alias '{name}' would create a circular reference")
+
+        self.aliases[name] = command
+        self._save_aliases()
+        return True
+
+    def remove_alias(self, name: str) -> bool:
+        """Remove an alias.
+
+        Args:
+            name: Alias name to remove
+
+        Returns:
+            True if alias was removed, False if it didn't exist
+        """
+        if name not in self.aliases:
+            return False
+
+        del self.aliases[name]
+        self._save_aliases()
+        return True
+
+    def edit_alias(self, name: str, command: str) -> bool:
+        """Edit an existing alias.
+
+        Args:
+            name: Alias name to edit
+            command: New command for the alias
+
+        Returns:
+            True if alias was edited, False if it doesn't exist
+        """
+        if name not in self.aliases:
+            return False
+
+        # Check for circular references
+        if self._would_create_cycle(name, command):
+            raise ValueError(f"Alias '{name}' would create a circular reference")
+
+        self.aliases[name] = command
+        self._save_aliases()
+        return True
+
+    def get_alias(self, name: str) -> Optional[str]:
+        """Get the command for an alias.
+
+        Args:
+            name: Alias name
+
+        Returns:
+            The aliased command, or None if alias doesn't exist
+        """
+        return self.aliases.get(name)
+
+    def list_aliases(self) -> Dict[str, str]:
+        """Get all aliases.
+
+        Returns:
+            Dictionary of all aliases
+        """
+        return self.aliases.copy()
+
+    def resolve_alias(self, command: str, max_depth: int = 10) -> str:
+        """Resolve an alias to its final command.
+
+        Args:
+            command: Command that might be an alias
+            max_depth: Maximum recursion depth for nested aliases
+
+        Returns:
+            The resolved command
+        """
+        resolved = command
+        depth = 0
+        seen = set()
+
+        while resolved in self.aliases and depth < max_depth:
+            if resolved in seen:
+                # Circular reference detected
+                return command
+
+            seen.add(resolved)
+            resolved = self.aliases[resolved]
+            depth += 1
+
+        return resolved
+
+    def _would_create_cycle(self, name: str, command: str) -> bool:
+        """Check if adding/editing an alias would create a cycle.
+
+        Args:
+            name: Alias name
+            command: Command to check
+
+        Returns:
+            True if this would create a cycle
+        """
+        # Direct self-reference
+        if command == name:
+            return True
+
+        # Follow the chain starting from command
+        # If we ever reach 'name', it would create a cycle
+        current = command
+        visited = set()
+
+        while current in self.aliases:
+            # Check for existing cycles
+            if current in visited:
+                break
+            visited.add(current)
+
+            # Get what this alias points to
+            current = self.aliases[current]
+
+            # If we reached the name we're trying to add, it's a cycle
+            if current == name:
+                return True
+
+        return False
+
+    def display_aliases(self, name: Optional[str] = None) -> None:
+        """Display aliases in a formatted table.
+
+        Args:
+            name: Optional specific alias to display
+        """
+        if name:
+            command = self.get_alias(name)
+            if command:
+                rprint(f"[green]{name}[/green] → {command}")
+            else:
+                rprint(f"[red]Alias '{name}' not found[/red]")
+            return
+
+        if not self.aliases:
+            rprint("[yellow]No aliases configured[/yellow]")
+            return
+
+        table = Table(title="Command Aliases", show_header=True)
+        table.add_column("Alias", style="cyan")
+        table.add_column("Command", style="green")
+
+        for alias_name, command in sorted(self.aliases.items()):
+            table.add_row(alias_name, command)
+
+        rprint(table)
+
+    def get_completion_items(self) -> List[str]:
+        """Get alias names for shell completion.
+
+        Returns:
+            List of alias names
+        """
+        return list(self.aliases.keys())
+
+    def clear_all(self) -> int:
+        """Clear all aliases.
+
+        Returns:
+            Number of aliases cleared
+        """
+        count = len(self.aliases)
+        self.aliases = {}
+        self._save_aliases()
+        return count
+
+    def import_aliases(self, data: Dict[str, str]) -> int:
+        """Import aliases from a dictionary.
+
+        Args:
+            data: Dictionary of aliases to import
+
+        Returns:
+            Number of aliases imported
+        """
+        count = 0
+        for name, command in data.items():
+            if not self._would_create_cycle(name, command):
+                self.aliases[name] = command
+                count += 1
+
+        if count > 0:
+            self._save_aliases()
+
+        return count
+
+    def export_aliases(self) -> Dict[str, str]:
+        """Export all aliases.
+
+        Returns:
+            Dictionary of all aliases
+        """
+        return self.aliases.copy()

pltr/services/folder.py

@@ -0,0 +1,167 @@
+"""
+Folder service wrapper for Foundry SDK filesystem API.
+"""
+
+from typing import Any, Optional, Dict, List
+
+from .base import BaseService
+
+
+class FolderService(BaseService):
+    """Service wrapper for Foundry folder operations using filesystem API."""
+
+    def _get_service(self) -> Any:
+        """Get the Foundry filesystem service."""
+        return self.client.filesystem
+
+    def create_folder(
+        self, display_name: str, parent_folder_rid: str
+    ) -> Dict[str, Any]:
+        """
+        Create a new folder.
+
+        Args:
+            display_name: Folder display name
+            parent_folder_rid: Parent folder RID (use 'ri.compass.main.folder.0' for root)
+
+        Returns:
+            Created folder information
+        """
+        try:
+            folder = self.service.Folder.create(
+                display_name=display_name,
+                parent_folder_rid=parent_folder_rid,
+                preview=True,
+            )
+            return self._format_folder_info(folder)
+        except Exception as e:
+            raise RuntimeError(f"Failed to create folder '{display_name}': {e}")
+
+    def get_folder(self, folder_rid: str) -> Dict[str, Any]:
+        """
+        Get information about a specific folder.
+
+        Args:
+            folder_rid: Folder Resource Identifier
+
+        Returns:
+            Folder information dictionary
+        """
+        try:
+            folder = self.service.Folder.get(folder_rid, preview=True)
+            return self._format_folder_info(folder)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get folder {folder_rid}: {e}")
+
+    def list_children(
+        self,
+        folder_rid: str,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        List all child resources of a folder.
+
+        Args:
+            folder_rid: Folder Resource Identifier
+            page_size: Number of items per page (optional)
+            page_token: Pagination token (optional)
+
+        Returns:
+            List of child resources
+        """
+        try:
+            children = []
+            # The children method returns an iterator
+            for child in self.service.Folder.children(
+                folder_rid, page_size=page_size, page_token=page_token, preview=True
+            ):
+                children.append(self._format_resource_info(child))
+            return children
+        except Exception as e:
+            raise RuntimeError(f"Failed to list children of folder {folder_rid}: {e}")
+
+    def get_folders_batch(self, folder_rids: List[str]) -> List[Dict[str, Any]]:
+        """
+        Get multiple folders in a single request.
+
+        Args:
+            folder_rids: List of folder RIDs (max 1000)
+
+        Returns:
+            List of folder information dictionaries
+        """
+        if len(folder_rids) > 1000:
+            raise ValueError("Maximum batch size is 1000 folders")
+
+        try:
+            response = self.service.Folder.get_batch(body=folder_rids, preview=True)
+            folders = []
+            for folder in response.folders:
+                folders.append(self._format_folder_info(folder))
+            return folders
+        except Exception as e:
+            raise RuntimeError(f"Failed to get folders batch: {e}")
+
+    def _format_folder_info(self, folder: Any) -> Dict[str, Any]:
+        """
+        Format folder information for consistent output.
+
+        Args:
+            folder: Folder object from Foundry SDK
+
+        Returns:
+            Formatted folder information dictionary
+        """
+        return {
+            "rid": getattr(folder, "rid", None),
+            "display_name": getattr(folder, "display_name", None),
+            "description": getattr(folder, "description", None),
+            "created": self._format_timestamp(getattr(folder, "created", None)),
+            "modified": self._format_timestamp(getattr(folder, "modified", None)),
+            "parent_folder_rid": getattr(folder, "parent_folder_rid", None),
+            "type": "folder",
+        }
+
+    def _format_resource_info(self, resource: Any) -> Dict[str, Any]:
+        """
+        Format resource information (can be folder, dataset, etc.).
+
+        Args:
+            resource: Resource object from Foundry SDK
+
+        Returns:
+            Formatted resource information dictionary
+        """
+        resource_type = getattr(resource, "type", "unknown")
+        base_info = {
+            "rid": getattr(resource, "rid", None),
+            "display_name": getattr(resource, "display_name", None),
+            "type": resource_type,
+        }
+
+        # Add type-specific fields
+        if resource_type == "folder":
+            base_info["description"] = getattr(resource, "description", None)
+        elif resource_type == "dataset":
+            base_info["name"] = getattr(resource, "name", None)
+
+        return base_info
+
+    def _format_timestamp(self, timestamp: Any) -> Optional[str]:
+        """
+        Format timestamp for display.
+
+        Args:
+            timestamp: Timestamp object from SDK
+
+        Returns:
+            Formatted timestamp string or None
+        """
+        if timestamp is None:
+            return None
+
+        # Handle different timestamp formats from the SDK
+        if hasattr(timestamp, "time"):
+            return str(timestamp.time)
+        return str(timestamp)

pltr/services/ontology.py

@@ -13,20 +13,18 @@ class OntologyService(BaseService):
         """Get the Foundry ontologies service."""
         return self.client.ontologies
 
-    def list_ontologies(self, page_size: Optional[int] = None) -> List[Dict[str, Any]]:
+    def list_ontologies(self) -> List[Dict[str, Any]]:
         """
         List all ontologies visible to the current user.
 
-        Args:
-            page_size: Number of results per page
-
         Returns:
             List of ontology information dictionaries
         """
         try:
-            result = self.service.Ontology.list(page_size=page_size)
+            result = self.service.Ontology.list()
             ontologies = []
-            for ontology in result:
+            # The response has a 'data' field containing the list of ontologies
+            for ontology in result.data:
                 ontologies.append(self._format_ontology_info(ontology))
             return ontologies
         except Exception as e:
@@ -65,23 +63,22 @@ class ObjectTypeService(BaseService):
         """Get the Foundry ontologies service."""
         return self.client.ontologies
 
-    def list_object_types(
-        self, ontology_rid: str, page_size: Optional[int] = None
-    ) -> List[Dict[str, Any]]:
+    def list_object_types(self, ontology_rid: str) -> List[Dict[str, Any]]:
         """
         List object types in an ontology.
 
         Args:
             ontology_rid: Ontology Resource Identifier
-            page_size: Number of results per page
 
         Returns:
             List of object type information dictionaries
         """
         try:
-            result = self.service.ObjectType.list(ontology_rid, page_size=page_size)
+            # ObjectType is nested under Ontology in the SDK
+            result = self.service.Ontology.ObjectType.list(ontology_rid)
             object_types = []
-            for obj_type in result:
+            # The response has a 'data' field containing the list of object types
+            for obj_type in result.data:
                 object_types.append(self._format_object_type_info(obj_type))
             return object_types
         except Exception as e:
@@ -99,13 +96,14 @@ class ObjectTypeService(BaseService):
             Object type information dictionary
         """
         try:
-            obj_type = self.service.ObjectType.get(ontology_rid, object_type)
+            # ObjectType is nested under Ontology in the SDK
+            obj_type = self.service.Ontology.ObjectType.get(ontology_rid, object_type)
             return self._format_object_type_info(obj_type)
         except Exception as e:
             raise RuntimeError(f"Failed to get object type {object_type}: {e}")
 
     def list_outgoing_link_types(
-        self, ontology_rid: str, object_type: str, page_size: Optional[int] = None
+        self, ontology_rid: str, object_type: str
     ) -> List[Dict[str, Any]]:
         """
         List outgoing link types for an object type.
@@ -113,17 +111,18 @@ class ObjectTypeService(BaseService):
         Args:
             ontology_rid: Ontology Resource Identifier
             object_type: Object type API name
-            page_size: Number of results per page
 
         Returns:
             List of link type information dictionaries
         """
         try:
-            result = self.service.ObjectType.list_outgoing_link_types(
-                ontology_rid, object_type, page_size=page_size
+            # ObjectType is nested under Ontology in the SDK
+            result = self.service.Ontology.ObjectType.list_outgoing_link_types(
+                ontology_rid, object_type
             )
             link_types = []
-            for link_type in result:
+            # The response has a 'data' field containing the list of link types
+            for link_type in result.data:
                 link_types.append(self._format_link_type_info(link_type))
             return link_types
         except Exception as e:

pltr/utils/alias_resolver.py

@@ -0,0 +1,56 @@
+"""Alias resolution utilities for CLI commands."""
+
+import shlex
+import sys
+from typing import List, Optional
+
+from pltr.config.aliases import AliasManager
+
+
+def resolve_command_aliases(args: Optional[List[str]] = None) -> List[str]:
+    """Resolve command aliases in the argument list.
+
+    Args:
+        args: Command arguments (defaults to sys.argv[1:])
+
+    Returns:
+        Resolved command arguments
+    """
+    if args is None:
+        args = sys.argv[1:]
+
+    if not args:
+        return args
+
+    # Don't resolve aliases for certain commands
+    if args[0] in ["alias", "--help", "-h", "--version", "completion"]:
+        return args
+
+    # Check if the first argument is an alias
+    manager = AliasManager()
+    first_arg = args[0]
+
+    # Try to resolve as an alias
+    resolved = manager.resolve_alias(first_arg)
+
+    if resolved != first_arg:
+        # It's an alias - parse the resolved command
+        try:
+            resolved_parts = shlex.split(resolved)
+            # Replace the first argument with the resolved command parts
+            # and append any additional arguments
+            return resolved_parts + args[1:]
+        except ValueError:
+            # If parsing fails, return original args
+            return args
+
+    return args
+
+
+def inject_alias_resolution() -> None:
+    """Inject alias resolution into sys.argv before CLI parsing."""
+    # Get resolved arguments
+    resolved_args = resolve_command_aliases()
+
+    # Replace sys.argv with resolved arguments
+    sys.argv = [sys.argv[0]] + resolved_args

pltr/utils/completion.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import json
 
 from pltr.config.profiles import ProfileManager
+from pltr.config.aliases import AliasManager
 
 
 def get_cached_rids() -> List[str]:
@@ -111,6 +112,13 @@ def complete_ontology_action(incomplete: str):
     return [action for action in actions if action.startswith(incomplete)]
 
 
+def complete_alias_names(incomplete: str):
+    """Complete alias names."""
+    manager = AliasManager()
+    aliases = manager.get_completion_items()
+    return [alias for alias in aliases if alias.startswith(incomplete)]
+
+
 def complete_file_path(incomplete: str):
     """Complete file paths."""
     # This is handled by shell natively, but we can provide hints

{pltr_cli-0.2.0.dist-info → pltr_cli-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pltr-cli
-Version: 0.2.0
+Version: 0.4.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
@@ -37,7 +37,7 @@ Description-Content-Type: text/markdown
 
 # pltr-cli
 
-A comprehensive command-line interface for Palantir Foundry APIs, providing 65+ commands for data analysis, ontology operations, SQL queries, and administrative tasks.
+A comprehensive command-line interface for Palantir Foundry APIs, providing 70+ commands for data analysis, ontology operations, SQL queries, folder management, and administrative tasks.
 
 ## Overview
 
@@ -47,6 +47,7 @@ A comprehensive command-line interface for Palantir Foundry APIs, providing 65+
 
 - 🔐 **Secure Authentication**: Token and OAuth2 support with encrypted credential storage
 - 📊 **Dataset Operations**: Get dataset information and create new datasets (RID-based API)
+- 📁 **Folder Management**: Create, explore, and manage Foundry filesystem structure
 - 🎯 **Comprehensive Ontology Access**: 13 commands for objects, actions, and queries
 - 📝 **Full SQL Support**: Execute, submit, monitor, and export query results
 - 👥 **Admin Operations**: User, group, role, and organization management (16 commands)
@@ -109,6 +110,12 @@ pltr admin user current
 # List available ontologies
 pltr ontology list
 
+# Create a new folder
+pltr folder create "My Project"
+
+# List root folder contents
+pltr folder list ri.compass.main.folder.0
+
 # Execute a simple SQL query
 pltr sql execute "SELECT 1 as test"
 
@@ -133,7 +140,7 @@ pltr-cli provides comprehensive documentation to help you get the most out of th
 ### 📖 User Guides
 - **[Quick Start Guide](docs/user-guide/quick-start.md)** - Get up and running in 5 minutes
 - **[Authentication Setup](docs/user-guide/authentication.md)** - Complete guide to token and OAuth2 setup
-- **[Command Reference](docs/user-guide/commands.md)** - Complete reference for all 65+ commands
+- **[Command Reference](docs/user-guide/commands.md)** - Complete reference for all 70+ commands
 - **[Common Workflows](docs/user-guide/workflows.md)** - Real-world data analysis patterns
 - **[Troubleshooting](docs/user-guide/troubleshooting.md)** - Solutions to common issues
 

{pltr_cli-0.2.0.dist-info → pltr_cli-0.4.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pltr/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
-pltr/__main__.py,sha256=PQIEddxNh3RNfW-pW0DFDgH2r_RptnKvgBcF9N4S5ik,742
-pltr/cli.py,sha256=lJU7EMPjHkaehA32CJh3d6zUNF8iEGHqGX-K45ErqhU,1798
+pltr/__main__.py,sha256=HWJ49UoAYBQCf8kjuySPmBTuUjTZrOx-y6PzMTyS1KE,879
+pltr/cli.py,sha256=cogkxi-J2hKrWKzjRFy6GLvcsPfrE_r_pAG6EMmuJ8s,1955
 pltr/auth/__init__.py,sha256=G0V-Rh25FaJsH2nhrf146XQQG_ApdbyPJNuHJC25kgk,38
 pltr/auth/base.py,sha256=LvmCwS7A0q0CITcym8udPzdACL52_jSGusiaeCTOaE8,981
 pltr/auth/manager.py,sha256=ZqlGefr1a8MGx0g7kkQhpmiuVp0XTg3f43yMBCk-IRo,4305
@@ -9,14 +9,17 @@ pltr/auth/storage.py,sha256=C7I3-22CJcnrKGNdxk9nXjphsnqQVguT5gNfAnR78Ok,2474
 pltr/auth/token.py,sha256=V48kxGn7CFbNGo17er5oI_ZA3xJ3iS9TsFjphZYqS2s,1925
 pltr/commands/__init__.py,sha256=iOLJ1ql4mz-3-4nz21hAqjd-9IjpYAIxr9SJQKHNFxM,29
 pltr/commands/admin.py,sha256=foscSO-QuH6uggUR5Rmv9pTqGjEXTUzpmMFj2-8hEJs,17065
+pltr/commands/alias.py,sha256=r9xMsQNrGvaixSlspzoO2IXQ44LFXuZM4itt8vC0dRc,6862
 pltr/commands/completion.py,sha256=YTxaRL4-rDs5n7aXf3ogFsxbHVJUBo_HiBbd0fbBPZ0,10870
 pltr/commands/configure.py,sha256=oYj-VlOEj3MDwtB2RC4bYOYzI_sXTanPnz7y1GmMTqY,4800
 pltr/commands/dataset.py,sha256=BCYfaBpLji5wasOiH_jOqO-JC9ScfJhodox9kl9W2Cw,3609
-pltr/commands/ontology.py,sha256=3MwGsRgCzOsG5OTo0xu1iNa3tpZy64e_Fy3O8I45_5I,18587
+pltr/commands/folder.py,sha256=IAPPA3Smk1IWqThneEtZ08Zp79vDKVUabSkL_nDvUWk,10679
+pltr/commands/ontology.py,sha256=zUgSrmv8xi26SQK7GsM3qusgR9Wuka0GyzE7L8DkduE,18317
 pltr/commands/shell.py,sha256=QLF7TEGpaau9i0A9s3VjnegvtHde-SLRqI4suJFT4WI,3622
 pltr/commands/sql.py,sha256=wol0Rlvi_RplCFbOg4LCa3VXsOqmRZdFFVv7V6iVkh8,12602
 pltr/commands/verify.py,sha256=n8LWhbfGieYa-a5_l3MxqkYbdpyVf8-i0FQIL__AaPA,6650
 pltr/config/__init__.py,sha256=Y6gARy5lUHy-OJaOUxtfXoeQVNZV5QHLl6uKHQ8tpTk,41
+pltr/config/aliases.py,sha256=ZmesZWMfa5riZlVe3fyC7EI3uIzxEGsDHz-8shOpIbM,6947
 pltr/config/profiles.py,sha256=XMUIp6Ez5LNC6rGXZe2JLH7IKepXhARtuc8ASUA9FYA,3431
 pltr/config/settings.py,sha256=bfIiosPqH_W73TOHS71DvgZdAHka4fJDopU1SvBRFuQ,2908
 pltr/services/__init__.py,sha256=zQpgrqPdAkZI-nobi33mctU2-iGNgazzvjBVY8YRbSQ,101
@@ -25,14 +28,16 @@ pltr/services/base.py,sha256=R2G781FI-sXtjUyLd91bVnmLb4cYZI3G8U5ndR9NLA4,1593
 pltr/services/dataset.py,sha256=W3zoh-9YIJ6HBsDijejVEngKvpudFoZinYtHDmAXCOc,2785
 pltr/services/dataset_full.py,sha256=FyMiwOSyX1cUrYXaK0T_1iq5G_X0e5iZTibJHuEmMeE,9869
 pltr/services/dataset_v2.py,sha256=_uhcVJ91w_Y07glceqHceccAwPWr6q1TWSIqcP1FU8I,4259
-pltr/services/ontology.py,sha256=d5MD0QeLfqs6W_XdteiK1da0yo_TKSftBmEOfPiLvf8,14755
+pltr/services/folder.py,sha256=mWElyvn-wXPB5sv8Ik_dLeW5JM6jZg3g9KKBk6UcrlQ,5389
+pltr/services/ontology.py,sha256=iW7qRK8ptlw-u4eAwLNC-mdzLoLZzh7SRqJyok2c3GU,14883
 pltr/services/sql.py,sha256=19cscjlzN8WE1s8_ctiRcrOvMzCfmWRj49vjJ8Gs5Q4,11286
 pltr/utils/__init__.py,sha256=DF7TigL1XbKVGM5VjgU8_8AGIszofkdO80oCzLGGnTE,38
-pltr/utils/completion.py,sha256=QdTkpT9MMs7C7keuJi79sMLerFX3CarpB4FrCKImjSc,4712
+pltr/utils/alias_resolver.py,sha256=DIF7P1UnUU8kqocJfIDEWjYq4s8_0KfqRZBbECeZEh8,1539
+pltr/utils/completion.py,sha256=bjeqjleEfB2YcQFpcxvF0GoQ763F6KBbULSZC4FWY_g,4980
 pltr/utils/formatting.py,sha256=Ptv7obiB7uWNf5YTiY4rUAKmabO5UGnwLocSfLplrZ0,18552
 pltr/utils/progress.py,sha256=BKYbiLO61uhQbibabU7pxvvbAWMRLRmqk4pZldBQK_g,9053
-pltr_cli-0.2.0.dist-info/METADATA,sha256=xk4xxyxl6TXmvgvrcfkR91E-TgnJiA4FdDY6ElW434Y,8864
-pltr_cli-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pltr_cli-0.2.0.dist-info/entry_points.txt,sha256=8tvEcW04kA_oAE2Dwwu-Og9efjl4ESJvs4AzlP2KBdQ,38
-pltr_cli-0.2.0.dist-info/licenses/LICENSE,sha256=6VUFd_ytnOBD2O1tmkKrA-smigi9QEhYr_tge4h4z8Y,1070
-pltr_cli-0.2.0.dist-info/RECORD,,
+pltr_cli-0.4.0.dist-info/METADATA,sha256=RDHEVijMZLcjzM8fBjaNm8DQsY0PIK8339CbDK64s-s,9096
+pltr_cli-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pltr_cli-0.4.0.dist-info/entry_points.txt,sha256=8tvEcW04kA_oAE2Dwwu-Og9efjl4ESJvs4AzlP2KBdQ,38
+pltr_cli-0.4.0.dist-info/licenses/LICENSE,sha256=6VUFd_ytnOBD2O1tmkKrA-smigi9QEhYr_tge4h4z8Y,1070
+pltr_cli-0.4.0.dist-info/RECORD,,