pltr-cli 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

pltr/commands/dataset.py

@@ -22,6 +22,9 @@ branches_app = typer.Typer()
 files_app = typer.Typer()
 transactions_app = typer.Typer()
 views_app = typer.Typer()
+schema_app = typer.Typer()
+schedules_app = typer.Typer()
+jobs_app = typer.Typer()
 console = Console()
 formatter = OutputFormatter(console)
 
@@ -70,7 +73,175 @@ def get_dataset(
         raise typer.Exit(1)
 
 
-# schema command removed - uses preview-only API that returns INVALID_ARGUMENT
+# Schema commands
+@schema_app.command("get")
+def get_schema(
+    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)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get the schema of a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching schema for {dataset_rid}..."
+        ):
+            schema = service.get_schema(dataset_rid)
+
+        # Format schema for display
+        if format == "json":
+            formatter._format_json(schema, output)
+        else:
+            formatter.print_info(f"Dataset: {dataset_rid}")
+            formatter.print_info(f"Status: {schema.get('status', 'Unknown')}")
+            if schema.get("schema"):
+                formatter.print_info("\nSchema:")
+                formatter._format_json(schema.get("schema"))
+
+        if output:
+            formatter.print_success(f"Schema 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 schema: {e}")
+        raise typer.Exit(1)
+
+
+@schema_app.command("set")
+def set_schema(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    from_csv: Optional[str] = typer.Option(
+        None, "--from-csv", help="Infer schema from CSV file"
+    ),
+    json_schema: Optional[str] = typer.Option(
+        None, "--json", help="JSON string defining the schema"
+    ),
+    json_file: Optional[str] = typer.Option(
+        None, "--json-file", help="Path to JSON file containing schema definition"
+    ),
+    branch: str = typer.Option("master", "--branch", help="Dataset branch"),
+    transaction_rid: Optional[str] = typer.Option(
+        None, "--transaction-rid", help="Transaction RID to use"
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+):
+    """Set or update the schema of a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        # Validate that exactly one input method is provided
+        input_methods = [from_csv, json_schema, json_file]
+        if sum(x is not None for x in input_methods) != 1:
+            formatter.print_error(
+                "Exactly one of --from-csv, --json, or --json-file must be provided"
+            )
+            raise typer.Exit(1)
+
+        schema = None
+
+        # Infer schema from CSV
+        if from_csv:
+            with SpinnerProgressTracker().track_spinner(
+                f"Inferring schema from {from_csv}..."
+            ):
+                schema = service.infer_schema_from_csv(from_csv)
+                formatter.print_info(
+                    f"Inferred schema from CSV with {len(schema.field_schema_list)} fields"
+                )
+                for field in schema.field_schema_list:
+                    formatter.print_info(
+                        f"  - {field.name}: {field.type} (nullable={field.nullable})"
+                    )
+
+        # Parse schema from JSON string
+        elif json_schema:
+            import json
+            from foundry_sdk.v2.core.models import DatasetSchema, DatasetFieldSchema
+
+            try:
+                schema_data = json.loads(json_schema)
+                fields = []
+                for field_data in schema_data.get("fields", []):
+                    fields.append(
+                        DatasetFieldSchema(
+                            name=field_data["name"],
+                            type=field_data["type"],
+                            nullable=field_data.get("nullable", True),
+                        )
+                    )
+                schema = DatasetSchema(field_schema_list=fields)
+            except (json.JSONDecodeError, KeyError) as e:
+                formatter.print_error(f"Invalid JSON schema: {e}")
+                raise typer.Exit(1)
+
+        # Load schema from JSON file
+        elif json_file:
+            import json
+            from foundry_sdk.v2.core.models import DatasetSchema, DatasetFieldSchema
+
+            try:
+                with open(json_file, "r") as f:
+                    schema_data = json.load(f)
+                fields = []
+                for field_data in schema_data.get("fields", []):
+                    fields.append(
+                        DatasetFieldSchema(
+                            name=field_data["name"],
+                            type=field_data["type"],
+                            nullable=field_data.get("nullable", True),
+                        )
+                    )
+                schema = DatasetSchema(field_schema_list=fields)
+            except (FileNotFoundError, json.JSONDecodeError, KeyError) as e:
+                formatter.print_error(f"Failed to load schema from file: {e}")
+                raise typer.Exit(1)
+
+        # Apply the schema
+        with SpinnerProgressTracker().track_spinner(
+            f"Setting schema on dataset {dataset_rid}..."
+        ):
+            service.put_schema(
+                dataset_rid=dataset_rid,
+                schema=schema,
+                branch=branch,
+                transaction_rid=transaction_rid,
+            )
+
+        formatter.print_success(f"Successfully set schema on dataset {dataset_rid}")
+        if transaction_rid:
+            formatter.print_info(f"Transaction RID: {transaction_rid}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except FileNotFoundError as e:
+        formatter.print_error(f"File not found: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to set schema: {e}")
+        raise typer.Exit(1)
 
 
 @app.command("create")
@@ -189,6 +360,139 @@ def create_branch(
         raise typer.Exit(1)
 
 
+@branches_app.command("delete")
+def delete_branch(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    branch_name: str = typer.Argument(..., help="Branch name to delete"),
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+):
+    """Delete a branch from a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        # Prevent deleting master branch
+        if branch_name.lower() == "master":
+            formatter.print_error("Cannot delete the master branch")
+            raise typer.Exit(1)
+
+        # Confirmation prompt
+        if not confirm:
+            confirmed = typer.confirm(
+                f"Are you sure you want to delete branch '{branch_name}' from dataset {dataset_rid}? "
+                f"This action cannot be undone."
+            )
+            if not confirmed:
+                formatter.print_info("Branch deletion cancelled")
+                raise typer.Exit(0)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Deleting branch '{branch_name}' from {dataset_rid}..."
+        ):
+            service.delete_branch(dataset_rid, branch_name)
+
+        formatter.print_success(f"Branch '{branch_name}' deleted successfully")
+        formatter.print_info(f"Dataset: {dataset_rid}")
+
+    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 delete branch: {e}")
+        raise typer.Exit(1)
+
+
+@branches_app.command("get")
+def get_branch(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    branch_name: str = typer.Argument(..., help="Branch name"),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get detailed information about a specific branch."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching branch '{branch_name}' from {dataset_rid}..."
+        ):
+            branch = service.get_branch(dataset_rid, branch_name)
+
+        formatter.format_branch_detail(branch, format, output)
+
+        if output:
+            formatter.print_success(f"Branch 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 branch: {e}")
+        raise typer.Exit(1)
+
+
+@branches_app.command("transactions")
+def list_branch_transactions(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    branch_name: str = typer.Argument(..., help="Branch name"),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get transaction history for a specific branch."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching transaction history for branch '{branch_name}' in {dataset_rid}..."
+        ):
+            transactions = service.get_branch_transactions(dataset_rid, branch_name)
+
+        formatter.format_transactions(transactions, format, output)
+
+        if output:
+            formatter.print_success(f"Branch transactions 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 branch transactions: {e}")
+        raise typer.Exit(1)
+
+
 # Files commands
 @files_app.command("list")
 def list_files(
@@ -320,6 +624,93 @@ def get_file(
         raise typer.Exit(1)
 
 
+@files_app.command("delete")
+def delete_file(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    file_path: str = typer.Argument(..., help="Path of file within dataset to delete"),
+    branch: str = typer.Option("master", "--branch", help="Dataset branch"),
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+):
+    """Delete a file from a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        # Confirmation prompt
+        if not confirm:
+            confirmed = typer.confirm(
+                f"Are you sure you want to delete '{file_path}' from dataset {dataset_rid}?"
+            )
+            if not confirmed:
+                formatter.print_info("File deletion cancelled")
+                raise typer.Exit(0)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Deleting {file_path} from {dataset_rid}..."
+        ):
+            service.delete_file(dataset_rid, file_path, branch)
+
+        formatter.print_success(f"File '{file_path}' deleted successfully")
+        formatter.print_info(f"Dataset: {dataset_rid}")
+        formatter.print_info(f"Branch: {branch}")
+
+    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 delete file: {e}")
+        raise typer.Exit(1)
+
+
+@files_app.command("info")
+def get_file_info(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    file_path: str = typer.Argument(..., help="Path of file within dataset"),
+    branch: str = typer.Option("master", "--branch", help="Dataset branch"),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get metadata information about a file in a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Getting file info for {file_path} in {dataset_rid}..."
+        ):
+            file_info = service.get_file_info(dataset_rid, file_path, branch)
+
+        formatter.format_file_info(file_info, format, output)
+
+        if output:
+            formatter.print_success(f"File 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 file info: {e}")
+        raise typer.Exit(1)
+
+
 # Transaction commands
 @transactions_app.command("start")
 def start_transaction(
@@ -581,6 +972,49 @@ def list_transactions(
         raise typer.Exit(1)
 
 
+@transactions_app.command("build")
+def get_transaction_build(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    transaction_rid: str = typer.Argument(..., help="Transaction Resource Identifier"),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get build information for a transaction."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching build information for transaction {transaction_rid}..."
+        ):
+            build_info = service.get_transaction_build(dataset_rid, transaction_rid)
+
+        formatter.format_transaction_build(build_info, format, output)
+
+        if output:
+            formatter.print_success(f"Build 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 transaction build: {e}")
+        raise typer.Exit(1)
+
+
 # Views commands
 @views_app.command("list")
 def list_views(
@@ -627,6 +1061,223 @@ def list_views(
         raise typer.Exit(1)
 
 
+@views_app.command("get")
+def get_view(
+    view_rid: str = typer.Argument(
+        ..., help="View Resource Identifier", autocompletion=complete_rid
+    ),
+    branch: str = typer.Option("master", "--branch", help="Branch name"),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get detailed information about a view."""
+    try:
+        cache_rid(view_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(f"Fetching view {view_rid}..."):
+            view = service.get_view(view_rid, branch)
+
+        formatter.format_view_detail(view, format, output)
+
+        if output:
+            formatter.print_success(f"View 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 view: {e}")
+        raise typer.Exit(1)
+
+
+@views_app.command("add-datasets")
+def add_backing_datasets(
+    view_rid: str = typer.Argument(
+        ..., help="View Resource Identifier", autocompletion=complete_rid
+    ),
+    dataset_rids: list[str] = typer.Argument(
+        ..., help="Dataset RIDs to add as backing datasets"
+    ),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+):
+    """Add backing datasets to a view."""
+    try:
+        cache_rid(view_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Adding {len(dataset_rids)} backing datasets to view {view_rid}..."
+        ):
+            result = service.add_backing_datasets(view_rid, dataset_rids)
+
+        formatter.print_success("Successfully added backing datasets to view")
+        formatter.print_info(f"View RID: {view_rid}")
+        formatter.print_info(f"Added datasets: {', '.join(dataset_rids)}")
+
+        if format == "json":
+            formatter._format_json(result)
+
+    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 add backing datasets: {e}")
+        raise typer.Exit(1)
+
+
+@views_app.command("remove-datasets")
+def remove_backing_datasets(
+    view_rid: str = typer.Argument(
+        ..., help="View Resource Identifier", autocompletion=complete_rid
+    ),
+    dataset_rids: list[str] = typer.Argument(
+        ..., help="Dataset RIDs to remove as backing datasets"
+    ),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+):
+    """Remove backing datasets from a view."""
+    try:
+        cache_rid(view_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Removing {len(dataset_rids)} backing datasets from view {view_rid}..."
+        ):
+            result = service.remove_backing_datasets(view_rid, dataset_rids)
+
+        formatter.print_success("Successfully removed backing datasets from view")
+        formatter.print_info(f"View RID: {view_rid}")
+        formatter.print_info(f"Removed datasets: {', '.join(dataset_rids)}")
+
+        if format == "json":
+            formatter._format_json(result)
+
+    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 remove backing datasets: {e}")
+        raise typer.Exit(1)
+
+
+@views_app.command("replace-datasets")
+def replace_backing_datasets(
+    view_rid: str = typer.Argument(
+        ..., help="View Resource Identifier", autocompletion=complete_rid
+    ),
+    dataset_rids: list[str] = typer.Argument(
+        ..., help="Dataset RIDs to set as backing datasets"
+    ),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+):
+    """Replace all backing datasets in a view."""
+    try:
+        cache_rid(view_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Replacing backing datasets in view {view_rid} with {len(dataset_rids)} new datasets..."
+        ):
+            result = service.replace_backing_datasets(view_rid, dataset_rids)
+
+        formatter.print_success("Successfully replaced backing datasets in view")
+        formatter.print_info(f"View RID: {view_rid}")
+        formatter.print_info(f"New datasets: {', '.join(dataset_rids)}")
+
+        if format == "json":
+            formatter._format_json(result)
+
+    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 replace backing datasets: {e}")
+        raise typer.Exit(1)
+
+
+@views_app.command("add-primary-key")
+def add_primary_key(
+    view_rid: str = typer.Argument(
+        ..., help="View Resource Identifier", autocompletion=complete_rid
+    ),
+    key_fields: list[str] = typer.Argument(
+        ..., help="Field names to use as primary key"
+    ),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+):
+    """Add a primary key to a view."""
+    try:
+        cache_rid(view_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Adding primary key to view {view_rid}..."
+        ):
+            result = service.add_primary_key(view_rid, key_fields)
+
+        formatter.print_success("Successfully added primary key to view")
+        formatter.print_info(f"View RID: {view_rid}")
+        formatter.print_info(f"Primary key fields: {', '.join(key_fields)}")
+
+        if format == "json":
+            formatter._format_json(result)
+
+    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 add primary key: {e}")
+        raise typer.Exit(1)
+
+
 @views_app.command("create")
 def create_view(
     dataset_rid: str = typer.Argument(
@@ -671,11 +1322,101 @@ def create_view(
         raise typer.Exit(1)
 
 
+# Schedules commands
+@schedules_app.command("list")
+def list_schedules(
+    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)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """List schedules that target a specific dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching schedules for dataset {dataset_rid}..."
+        ):
+            schedules = service.get_schedules(dataset_rid)
+
+        formatter.format_schedules(schedules, format, output)
+
+        if output:
+            formatter.print_success(f"Schedules 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 schedules: {e}")
+        raise typer.Exit(1)
+
+
+# Jobs commands
+@jobs_app.command("list")
+def list_jobs(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    branch: str = typer.Option("master", "--branch", help="Dataset branch"),
+    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)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """List jobs for a specific dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching jobs for dataset {dataset_rid} (branch: {branch})..."
+        ):
+            jobs = service.get_jobs(dataset_rid, branch)
+
+        formatter.format_jobs(jobs, format, output)
+
+        if output:
+            formatter.print_success(f"Jobs 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 jobs: {e}")
+        raise typer.Exit(1)
+
+
 # Add subcommands to main app
 app.add_typer(branches_app, name="branches")
 app.add_typer(files_app, name="files")
 app.add_typer(transactions_app, name="transactions")
 app.add_typer(views_app, name="views")
+app.add_typer(schema_app, name="schema")
+app.add_typer(schedules_app, name="schedules")
+app.add_typer(jobs_app, name="jobs")
 
 
 @app.callback()