tasktree 0.0.22__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
@@ -28,10 +29,14 @@ from tasktree.graph import (
     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,
@@ -123,15 +128,15 @@ 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)
 
@@ -169,31 +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 = {
@@ -224,47 +229,47 @@ def _show_task(task_name: str, tasks_file: Optional[str] = None):
     # 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
@@ -297,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):
@@ -340,12 +345,6 @@ def main(
     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)"
     ),
@@ -358,6 +357,28 @@ def main(
     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"
     ),
@@ -374,72 +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(
+            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]"
+            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",
             )
-            console.print("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
@@ -447,30 +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]"
+        logger.info(
+            f"[green]{get_action_success_string()} Removed {state_path}[/green]",
         )
-        console.print("All tasks will run fresh on next execution")
+        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
+    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()
@@ -481,7 +509,7 @@ def _get_recipe(
                 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
@@ -489,28 +517,32 @@ def _get_recipe(
     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(
+    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
@@ -519,10 +551,10 @@ def _execute_dynamic_task(
     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)
 
@@ -530,30 +562,30 @@ def _execute_dynamic_task(
     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
@@ -568,14 +600,13 @@ def _execute_dynamic_task(
         # 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,
@@ -586,48 +617,50 @@ def _execute_dynamic_task(
             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(
+        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("[red]Task does not accept arguments[/red]")
+            logger.error("[red]Task does not accept arguments[/red]")
             raise typer.Exit(1)
         return {}
 
@@ -646,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("[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
@@ -666,11 +699,11 @@ def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, A
 
             # 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]"
+                logger.error(
+                    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.info(
+                    f"Valid choices: {', '.join(repr(c) for c in spec.choices)}",
                 )
                 raise typer.Exit(1)
 
@@ -678,7 +711,7 @@ def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, A
         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
@@ -691,12 +724,12 @@ def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, A
                     )
                     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

tasktree/console_logger.py

@@ -0,0 +1,66 @@
+from tasktree.logging import Logger, LogLevel
+from rich.console import Console
+
+
+class ConsoleLogger(Logger):
+    """
+    Console-based logger implementation using Rich for formatting.
+
+    Filters log messages based on the current log level. Messages with severity
+    lower than the current level are suppressed. Supports a stack-based level
+    management system for temporary verbosity changes.
+    @athena: a892913fc11c
+    """
+
+    def __init__(self, console: Console, level: LogLevel = LogLevel.INFO) -> None:
+        """
+        Initialize the console logger.
+
+        Args:
+        console: Rich Console instance to use for output
+        level: Initial log level (default: INFO)
+        @athena: 388d9c273a6a
+        """
+        self._console = console
+        self._levels = [level]
+
+    def log(self, level: LogLevel = LogLevel.INFO, *args, **kwargs) -> None:
+        """
+        Log a message to the console if it meets the current level threshold.
+
+        Messages are only printed if their level is at or above the current level
+        (i.e., level.value <= current_level.value, since lower values = higher severity).
+
+        Args:
+        level: The severity level of this message (default: INFO)
+        *args: Positional arguments passed to Rich Console.print()
+        **kwargs: Keyword arguments passed to Rich Console.print()
+        @athena: efae38733da1
+        """
+        if self._levels[-1].value >= level.value:
+            self._console.print(*args, **kwargs)
+
+    def push_level(self, level: LogLevel) -> None:
+        """
+        Push a new log level onto the stack.
+
+        Args:
+        level: The new log level to activate
+        @athena: 07c7493570b1
+        """
+        self._levels.append(level)
+
+    def pop_level(self) -> LogLevel:
+        """
+        Pop the current log level and return to the previous level.
+
+        Returns:
+        The log level that was popped
+
+        Raises:
+        RuntimeError: If attempting to pop the base (initial) log level
+        @athena: 65ac19e00168
+        """
+        if len(self._levels) <= 1:
+            raise RuntimeError("Cannot pop the base log level")
+        return self._levels.pop()