tasktree 0.0.21__py3-none-any.whl → 0.0.23__py3-none-any.whl

tasktree/__init__.py

@@ -1,6 +1,6 @@
 """
 Task Tree - A task automation tool with intelligent incremental execution.
-@athena: 1b4a97c4bc42
+@athena: 1f9043e194aa
 """
 
 try:

tasktree/cli.py

@@ -12,6 +12,7 @@ import sys
 from pathlib import Path
 from typing import Any, List, Optional
 
+import click
 import typer
 import yaml
 from rich.console import Console
@@ -21,12 +22,21 @@ from rich.tree import Tree
 
 from tasktree import __version__
 from tasktree.executor import Executor
-from tasktree.graph import build_dependency_tree, resolve_execution_order, resolve_dependency_output_references, resolve_self_references
+from tasktree.graph import (
+    build_dependency_tree,
+    resolve_execution_order,
+    resolve_dependency_output_references,
+    resolve_self_references,
+)
 from tasktree.hasher import hash_task, hash_args
+from tasktree.console_logger import ConsoleLogger, Logger
+from tasktree.logging import LogLevel
 from tasktree.parser import Recipe, find_recipe_file, parse_arg_spec, parse_recipe
+from tasktree.process_runner import TaskOutputTypes, make_process_runner
 from tasktree.state import StateManager
 from tasktree.types import get_click_type
 
+
 app = typer.Typer(
     help="Task Tree - A task automation tool with intelligent incremental execution",
     add_completion=False,
@@ -118,14 +128,16 @@ def _format_task_arguments(arg_specs: list[str | dict]) -> str:
     return " ".join(formatted_parts)
 
 
-def _list_tasks(tasks_file: Optional[str] = None):
+def _list_tasks(logger: Logger, tasks_file: Optional[str] = None):
     """
     List all available tasks with descriptions.
-    @athena: 778f231737a1
+    @athena: 907819fc0cc7
     """
-    recipe = _get_recipe(tasks_file)
+    recipe = _get_recipe(logger, tasks_file)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
+        logger.error(
+            "[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]",
+        )
         raise typer.Exit(1)
 
     # Calculate maximum task name length for fixed-width column (only visible tasks)
@@ -134,13 +146,17 @@ def _list_tasks(tasks_file: Optional[str] = None):
         task = recipe.get_task(name)
         if task and not task.private:
             visible_task_names.append(name)
-    max_task_name_len = max(len(name) for name in visible_task_names) if visible_task_names else 0
+    max_task_name_len = (
+        max(len(name) for name in visible_task_names) if visible_task_names else 0
+    )
 
     # Create borderless table with three columns
     table = Table(show_edge=False, show_header=False, box=None, padding=(0, 2))
 
-    # Command column: fixed width to accommodate longest task name
-    table.add_column("Command", style="bold cyan", no_wrap=True, width=max_task_name_len)
+    # Command column: fixed width to accommodate the longest task name
+    table.add_column(
+        "Command", style="bold cyan", no_wrap=True, width=max_task_name_len
+    )
 
     # Arguments column: allow wrapping with sensible max width
     table.add_column("Arguments", style="white", max_width=60)
@@ -158,29 +174,31 @@ def _list_tasks(tasks_file: Optional[str] = None):
 
         table.add_row(task_name, args_formatted, desc)
 
-    console.print(table)
+    logger.info(table)
 
 
-def _show_task(task_name: str, tasks_file: Optional[str] = None):
+def _show_task(logger: Logger, task_name: str, tasks_file: Optional[str] = None):
     """
     Show task definition with syntax highlighting.
-    @athena: 79ae3e330662
+    @athena: a6b71673d4b7
     """
     # Pass task_name as root_task for lazy variable evaluation
-    recipe = _get_recipe(tasks_file, root_task=task_name)
+    recipe = _get_recipe(logger, tasks_file, root_task=task_name)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
+        logger.error(
+            "[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]",
+        )
         raise typer.Exit(1)
 
     task = recipe.get_task(task_name)
     if task is None:
-        console.print(f"[red]Task not found: {task_name}[/red]")
+        logger.error(f"[red]Task not found: {task_name}[/red]")
         raise typer.Exit(1)
 
     # Show source file info
-    console.print(f"[bold]Task: {task_name}[/bold]")
+    logger.info(f"[bold]Task: {task_name}[/bold]")
     if task.source_file:
-        console.print(f"Source: {task.source_file}\n")
+        logger.info(f"Source: {task.source_file}\n")
 
     # Create YAML representation
     task_yaml = {
@@ -202,54 +220,56 @@ def _show_task(task_name: str, tasks_file: Optional[str] = None):
     # Configure YAML dumper to use literal block style for multiline strings
     def literal_presenter(dumper, data):
         """Use literal block style (|) for strings containing newlines."""
-        if '\n' in data:
-            return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
-        return dumper.represent_scalar('tag:yaml.org,2002:str', data)
+        if "\n" in data:
+            return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")
+        return dumper.represent_scalar("tag:yaml.org,2002:str", data)
 
     yaml.add_representer(str, literal_presenter)
 
     # Format and highlight using Rich
     yaml_str = yaml.dump(task_yaml, default_flow_style=False, sort_keys=False)
     syntax = Syntax(yaml_str, "yaml", theme="ansi_light", line_numbers=False)
-    console.print(syntax)
+    logger.info(syntax)
 
 
-def _show_tree(task_name: str, tasks_file: Optional[str] = None):
+def _show_tree(logger: Logger, task_name: str, tasks_file: Optional[str] = None):
     """
     Show dependency tree structure.
-    @athena: a906cef99324
+    @athena: 88fbc03f4915
     """
     # Pass task_name as root_task for lazy variable evaluation
-    recipe = _get_recipe(tasks_file, root_task=task_name)
+    recipe = _get_recipe(logger, tasks_file, root_task=task_name)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
+        logger.error(
+            "[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]",
+        )
         raise typer.Exit(1)
 
     task = recipe.get_task(task_name)
     if task is None:
-        console.print(f"[red]Task not found: {task_name}[/red]")
+        logger.error(f"[red]Task not found: {task_name}[/red]")
         raise typer.Exit(1)
 
     # Build dependency tree
     try:
         dep_tree = build_dependency_tree(recipe, task_name)
     except Exception as e:
-        console.print(f"[red]Error building dependency tree: {e}[/red]")
+        logger.error(f"[red]Error building dependency tree: {e}[/red]")
         raise typer.Exit(1)
 
     # Build Rich tree
     tree = _build_rich_tree(dep_tree)
-    console.print(tree)
+    logger.info(tree)
 
 
-def _init_recipe():
+def _init_recipe(logger: Logger):
     """
     Create a blank recipe file with commented examples.
-    @athena: 189726c9b6c0
+    @athena: f05c0eb014d4
     """
     recipe_path = Path("tasktree.yaml")
     if recipe_path.exists():
-        console.print("[red]tasktree.yaml already exists[/red]")
+        logger.error("[red]tasktree.yaml already exists[/red]")
         raise typer.Exit(1)
 
     template = """# Task Tree Recipe
@@ -282,8 +302,8 @@ tasks:
 """
 
     recipe_path.write_text(template)
-    console.print(f"[green]Created {recipe_path}[/green]")
-    console.print("Edit the file to define your tasks")
+    logger.info(f"[green]Created {recipe_path}[/green]")
+    logger.info("Edit the file to define your tasks")
 
 
 def _version_callback(value: bool):
@@ -307,31 +327,58 @@ def main(
         is_eager=True,
         help="Show version and exit",
     ),
-    list_opt: Optional[bool] = typer.Option(None, "--list", "-l", help="List all available tasks"),
-    show: Optional[str] = typer.Option(None, "--show", "-s", help="Show task definition"),
-    tree: Optional[str] = typer.Option(None, "--tree", "-t", help="Show dependency tree"),
-    tasks_file: Optional[str] = typer.Option(None, "--tasks", "-T", help="Path to recipe file (tasktree.yaml, *.tasks, etc.)"),
+    list_opt: Optional[bool] = typer.Option(
+        None, "--list", "-l", help="List all available tasks"
+    ),
+    show: Optional[str] = typer.Option(
+        None, "--show", "-s", help="Show task definition"
+    ),
+    tree: Optional[str] = typer.Option(
+        None, "--tree", "-t", help="Show dependency tree"
+    ),
+    tasks_file: Optional[str] = typer.Option(
+        None, "--tasks", "-T", help="Path to recipe file (tasktree.yaml, *.tasks, etc.)"
+    ),
     init: Optional[bool] = typer.Option(
         None, "--init", "-i", help="Create a blank tasktree.yaml"
     ),
     clean: Optional[bool] = typer.Option(
         None, "--clean", "-c", help="Remove state file (reset task cache)"
     ),
-    clean_state: Optional[bool] = typer.Option(
-        None, "--clean-state", "-C", help="Remove state file (reset task cache)"
-    ),
-    reset: Optional[bool] = typer.Option(
-        None, "--reset", "-r", help="Remove state file (reset task cache)"
-    ),
     force: Optional[bool] = typer.Option(
         None, "--force", "-f", help="Force re-run all tasks (ignore freshness)"
     ),
     only: Optional[bool] = typer.Option(
-        None, "--only", "-o", help="Run only the specified task, skip dependencies (implies --force)"
+        None,
+        "--only",
+        "-o",
+        help="Run only the specified task, skip dependencies (implies --force)",
     ),
     env: Optional[str] = typer.Option(
         None, "--env", "-e", help="Override environment for all tasks"
     ),
+    log_level: str = typer.Option(
+        "info",
+        "--log-level",
+        "-L",
+        click_type=click.Choice(
+            [l.name.lower() for l in LogLevel], case_sensitive=False
+        ),
+        help="""Control verbosity of tasktree's diagnostic messages""",
+    ),
+    task_output: Optional[str] = typer.Option(
+        None,
+        "--task-output",
+        "-O",
+        click_type=click.Choice([t.value for t in TaskOutputTypes], case_sensitive=False),
+        help="""Control task subprocess output display:
+        
+        - all: show both stdout and stderr output from tasks\n
+        - out: show only stdout from tasks\n
+        - err: show only stderr from tasks\n
+        - on-err: show stderr from tasks, but only if the task fails. (all stdout is suppressed)
+        - none: suppress all output)""",
+    ),
     task_args: Optional[List[str]] = typer.Argument(
         None, help="Task name and arguments"
     ),
@@ -348,64 +395,78 @@ def main(
     tt deploy prod region=us-1   # Run 'deploy' with arguments
     tt --list                    # List all tasks
     tt --tree test               # Show dependency tree for 'test'
-    @athena: f76c75c12d10
+    @athena: 40e6fdbe6100
     """
 
+    logger = ConsoleLogger(console, LogLevel(LogLevel[log_level.upper()]))
+
     if list_opt:
-        _list_tasks(tasks_file)
+        _list_tasks(logger, tasks_file)
         raise typer.Exit()
 
     if show:
-        _show_task(show, tasks_file)
+        _show_task(logger, show, tasks_file)
         raise typer.Exit()
 
     if tree:
-        _show_tree(tree, tasks_file)
+        _show_tree(logger, tree, tasks_file)
         raise typer.Exit()
 
     if init:
-        _init_recipe()
+        _init_recipe(logger)
         raise typer.Exit()
 
-    if clean or clean_state or reset:
-        _clean_state(tasks_file)
+    if clean:
+        _clean_state(logger, tasks_file)
         raise typer.Exit()
 
     if task_args:
         # --only implies --force
         force_execution = force or only or False
-        _execute_dynamic_task(task_args, force=force_execution, only=only or False, env=env, tasks_file=tasks_file)
+        _execute_dynamic_task(
+            logger,
+            task_args,
+            force=force_execution,
+            only=only or False,
+            env=env,
+            tasks_file=tasks_file,
+            task_output=task_output,
+        )
     else:
-        recipe = _get_recipe(tasks_file)
+        recipe = _get_recipe(logger, tasks_file)
         if recipe is None:
-            console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
-            console.print("Run [cyan]tt --init[/cyan] to create a blank recipe file")
+            logger.error(
+                "[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]",
+            )
+            logger.info(
+                "Run [cyan]tt --init[/cyan] to create a blank recipe file",
+            )
             raise typer.Exit(1)
 
-        console.print("[bold]Available tasks:[/bold]")
+        logger.info("[bold]Available tasks:[/bold]")
         for task_name in sorted(recipe.task_names()):
             task = recipe.get_task(task_name)
             if task and not task.private:
-                console.print(f"  - {task_name}")
-        console.print("\nUse [cyan]tt --list[/cyan] for detailed information")
-        console.print("Use [cyan]tt <task-name>[/cyan] to run a task")
+                logger.info(f"  - {task_name}")
+        logger.info("\nUse [cyan]tt --list[/cyan] for detailed information")
+        logger.info("Use [cyan]tt <task-name>[/cyan] to run a task")
 
 
-def _clean_state(tasks_file: Optional[str] = None) -> None:
+def _clean_state(logger: Logger, tasks_file: Optional[str] = None) -> None:
     """
     Remove the .tasktree-state file to reset task execution state.
-    @athena: a0ddf4b333d4
+    @athena: 2f270f8a2d70
     """
     if tasks_file:
         recipe_path = Path(tasks_file)
         if not recipe_path.exists():
-            console.print(f"[red]Recipe file not found: {tasks_file}[/red]")
+            logger.error(f"[red]Recipe file not found: {tasks_file}[/red]")
             raise typer.Exit(1)
     else:
         recipe_path = find_recipe_file()
         if recipe_path is None:
-            console.print("[yellow]No recipe file found[/yellow]")
-            console.print("State file location depends on recipe file location")
+            logger.warn("[yellow]No recipe file found[/yellow]")
+            logger.info("State file location depends on recipe file location")
             raise typer.Exit(1)
 
     project_root = recipe_path.parent
@@ -413,26 +474,31 @@ def _clean_state(tasks_file: Optional[str] = None) -> None:
 
     if state_path.exists():
         state_path.unlink()
-        console.print(f"[green]{get_action_success_string()} Removed {state_path}[/green]")
-        console.print("All tasks will run fresh on next execution")
+        logger.info(
+            f"[green]{get_action_success_string()} Removed {state_path}[/green]",
+        )
+        logger.info("All tasks will run fresh on next execution")
     else:
-        console.print(f"[yellow]No state file found at {state_path}[/yellow]")
+        logger.info(f"[yellow]No state file found at {state_path}[/yellow]")
 
 
-def _get_recipe(recipe_file: Optional[str] = None, root_task: Optional[str] = None) -> Optional[Recipe]:
+def _get_recipe(
+    logger: Logger, recipe_file: Optional[str] = None, root_task: Optional[str] = None
+) -> Optional[Recipe]:
     """
     Get parsed recipe or None if not found.
 
     Args:
+    logger_fn: Logger function for output
     recipe_file: Optional path to recipe file. If not provided, searches for recipe file.
     root_task: Optional root task for lazy variable evaluation. If provided, only variables
     reachable from this task will be evaluated (performance optimization).
-    @athena: 0ee00c67df25
+    @athena: ded906495d18
     """
     if recipe_file:
         recipe_path = Path(recipe_file)
         if not recipe_path.exists():
-            console.print(f"[red]Recipe file not found: {recipe_file}[/red]")
+            logger.error(f"[red]Recipe file not found: {recipe_file}[/red]")
             raise typer.Exit(1)
         # When explicitly specified, project root is current working directory
         project_root = Path.cwd()
@@ -443,7 +509,7 @@ def _get_recipe(recipe_file: Optional[str] = None, root_task: Optional[str] = No
                 return None
         except ValueError as e:
             # Multiple recipe files found
-            console.print(f"[red]{e}[/red]")
+            logger.error(f"[red]{e}[/red]")
             raise typer.Exit(1)
         # When auto-discovered, project root is recipe file's parent
         project_root = None
@@ -451,22 +517,32 @@ def _get_recipe(recipe_file: Optional[str] = None, root_task: Optional[str] = No
     try:
         return parse_recipe(recipe_path, project_root, root_task)
     except Exception as e:
-        console.print(f"[red]Error parsing recipe: {e}[/red]")
+        logger.error(f"[red]Error parsing recipe: {e}[/red]")
         raise typer.Exit(1)
 
 
-def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = False, env: Optional[str] = None, tasks_file: Optional[str] = None) -> None:
+def _execute_dynamic_task(
+    logger: Logger,
+    args: list[str],
+    force: bool = False,
+    only: bool = False,
+    env: Optional[str] = None,
+    tasks_file: Optional[str] = None,
+    task_output: str | None = None,
+) -> None:
     """
     Execute a task with its dependencies and handle argument parsing.
 
     Args:
-        args: Task name followed by optional task arguments
-        force: Force re-execution even if task is up-to-date
-        only: Execute only the specified task, skip dependencies
-        env: Override environment for task execution
-        tasks_file: Path to recipe file (optional)
+    logger: Logger interface for output
+    args: Task name followed by optional task arguments
+    force: Force re-execution even if task is up-to-date
+    only: Execute only the specified task, skip dependencies
+    env: Override environment for task execution
+    tasks_file: Path to recipe file (optional)
+    task_output: Control task subprocess output (all, out, err, on-err, none)
 
-    @athena: 207f7635a60d
+    @athena: 36ae914a5bc7
     """
     if not args:
         return
@@ -475,39 +551,41 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
     task_args = args[1:]
 
     # Pass task_name as root_task for lazy variable evaluation
-    recipe = _get_recipe(tasks_file, root_task=task_name)
+    recipe = _get_recipe(logger, tasks_file, root_task=task_name)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
+        logger.error(
+            "[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]",
+        )
         raise typer.Exit(1)
 
     # Apply global environment override if provided
     if env:
         # Validate that the environment exists
         if not recipe.get_environment(env):
-            console.print(f"[red]Environment not found: {env}[/red]")
-            console.print("\nAvailable environments:")
+            logger.error(f"[red]Environment not found: {env}[/red]")
+            logger.info("\nAvailable environments:")
             for env_name in sorted(recipe.environments.keys()):
-                console.print(f"  - {env_name}")
+                logger.info(f"  - {env_name}")
             raise typer.Exit(1)
         recipe.global_env_override = env
 
     task = recipe.get_task(task_name)
     if task is None:
-        console.print(f"[red]Task not found: {task_name}[/red]")
-        console.print("\nAvailable tasks:")
+        logger.error(f"[red]Task not found: {task_name}[/red]")
+        logger.info("\nAvailable tasks:")
         for name in sorted(recipe.task_names()):
             task = recipe.get_task(name)
             if task and not task.private:
-                console.print(f"  - {name}")
+                logger.info(f"  - {name}")
         raise typer.Exit(1)
 
     # Parse task arguments
-    args_dict = _parse_task_args(task.args, task_args)
+    args_dict = _parse_task_args(logger, task.args, task_args)
 
     # Create executor and state manager
     state = StateManager(recipe.project_root)
     state.load()
-    executor = Executor(recipe, state)
+    executor = Executor(recipe, state, logger, make_process_runner)
 
     # Resolve execution order to determine which tasks will actually run
     # This is important for correct state pruning after template substitution
@@ -522,14 +600,13 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
         # This substitutes {{ self.inputs.* }} and {{ self.outputs.* }} templates
         resolve_self_references(recipe, execution_order)
     except ValueError as e:
-        console.print(f"[red]Error in task template: {e}[/red]")
+        logger.error(f"[red]Error in task template: {e}[/red]")
         raise typer.Exit(1)
 
     # Prune state based on tasks that will actually execute (with their specific arguments)
     # This ensures template-substituted dependencies are handled correctly
     valid_hashes = set()
-    for exec_task_name, exec_task_args in execution_order:
-        task = recipe.tasks[exec_task_name]
+    for _, task in recipe.tasks.items():
         # Compute base task hash
         task_hash = hash_task(
             task.cmd,
@@ -537,47 +614,53 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
             task.working_dir,
             task.args,
             executor._get_effective_env_name(task),
-            task.deps
+            task.deps,
         )
 
-        # If task has arguments, append args hash to create unique cache key
-        if exec_task_args:
-            args_hash = hash_args(exec_task_args)
-            cache_key = f"{task_hash}__{args_hash}"
-        else:
-            cache_key = task_hash
-
-        valid_hashes.add(cache_key)
+        valid_hashes.add(task_hash)
 
     state.prune(valid_hashes)
     state.save()
     try:
-        executor.execute_task(task_name, args_dict, force=force, only=only)
-        console.print(f"[green]{get_action_success_string()} Task '{task_name}' completed successfully[/green]")
+        executor.execute_task(
+            task_name,
+            TaskOutputTypes(task_output.lower()) if task_output is not None else None,
+            args_dict,
+            force=force,
+            only=only,
+        )
+        logger.info(
+            f"[green]{get_action_success_string()} Task '{task_name}' completed successfully[/green]",
+        )
     except Exception as e:
-        console.print(f"[red]{get_action_failure_string()} Task '{task_name}' failed: {e}[/red]")
+        logger.error(
+            f"[red]{get_action_failure_string()} Task '{task_name}' failed: {e}[/red]"
+        )
         raise typer.Exit(1)
 
 
-def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, Any]:
+def _parse_task_args(
+    logger: Logger, arg_specs: list[str], arg_values: list[str]
+) -> dict[str, Any]:
     """
     Parse and validate task arguments from command line values.
 
     Args:
-        arg_specs: Task argument specifications with types and defaults
-        arg_values: Raw argument values from command line (positional or named)
+    logger: Logger interface for output
+    arg_specs: Task argument specifications with types and defaults
+    arg_values: Raw argument values from command line (positional or named)
 
     Returns:
-        Dictionary mapping argument names to typed, validated values
+    Dictionary mapping argument names to typed, validated values
 
     Raises:
-        typer.Exit: If arguments are invalid, missing, or unknown
+    typer.Exit: If arguments are invalid, missing, or unknown
 
-    @athena: 2072a35f9d11
+    @athena: d9a7ea55c3d6
     """
     if not arg_specs:
         if arg_values:
-            console.print(f"[red]Task does not accept arguments[/red]")
+            logger.error("[red]Task does not accept arguments[/red]")
             raise typer.Exit(1)
         return {}
 
@@ -596,12 +679,12 @@ def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, A
             # Find the spec for this argument
             spec = next((s for s in parsed_specs if s.name == arg_name), None)
             if spec is None:
-                console.print(f"[red]Unknown argument: {arg_name}[/red]")
+                logger.error(f"[red]Unknown argument: {arg_name}[/red]")
                 raise typer.Exit(1)
         else:
             # Positional argument
             if positional_index >= len(parsed_specs):
-                console.print(f"[red]Too many arguments[/red]")
+                logger.error("[red]Too many arguments[/red]")
                 raise typer.Exit(1)
             spec = parsed_specs[positional_index]
             arg_value = value_str
@@ -609,20 +692,26 @@ def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, A
 
         # Convert value to appropriate type (exported args are always strings)
         try:
-            click_type = get_click_type(spec.arg_type, min_val=spec.min_val, max_val=spec.max_val)
+            click_type = get_click_type(
+                spec.arg_type, min_val=spec.min_val, max_val=spec.max_val
+            )
             converted_value = click_type.convert(arg_value, None, None)
 
             # Validate choices after type conversion
             if spec.choices is not None and converted_value not in spec.choices:
-                console.print(f"[red]Invalid value for {spec.name}: {converted_value!r}[/red]")
-                console.print(f"Valid choices: {', '.join(repr(c) for c in spec.choices)}")
+                logger.error(
+                    f"[red]Invalid value for {spec.name}: {converted_value!r}[/red]",
+                )
+                logger.info(
+                    f"Valid choices: {', '.join(repr(c) for c in spec.choices)}",
+                )
                 raise typer.Exit(1)
 
             args_dict[spec.name] = converted_value
         except typer.Exit:
             raise  # Re-raise typer.Exit without wrapping
         except Exception as e:
-            console.print(f"[red]Invalid value for {spec.name}: {e}[/red]")
+            logger.error(f"[red]Invalid value for {spec.name}: {e}[/red]")
             raise typer.Exit(1)
 
     # Fill in defaults for missing arguments
@@ -630,13 +719,17 @@ def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, A
         if spec.name not in args_dict:
             if spec.default is not None:
                 try:
-                    click_type = get_click_type(spec.arg_type, min_val=spec.min_val, max_val=spec.max_val)
+                    click_type = get_click_type(
+                        spec.arg_type, min_val=spec.min_val, max_val=spec.max_val
+                    )
                     args_dict[spec.name] = click_type.convert(spec.default, None, None)
                 except Exception as e:
-                    console.print(f"[red]Invalid default value for {spec.name}: {e}[/red]")
+                    logger.error(
+                        f"[red]Invalid default value for {spec.name}: {e}[/red]",
+                    )
                     raise typer.Exit(1)
             else:
-                console.print(f"[red]Missing required argument: {spec.name}[/red]")
+                logger.error(f"[red]Missing required argument: {spec.name}[/red]")
                 raise typer.Exit(1)
 
     return args_dict