tasktree 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

tasktree/__init__.py

@@ -13,7 +13,9 @@ from tasktree.graph import (
     TaskNotFoundError,
     build_dependency_tree,
     get_implicit_inputs,
+    resolve_dependency_output_references,
     resolve_execution_order,
+    resolve_self_references,
 )
 from tasktree.hasher import hash_args, hash_task, make_cache_key
 from tasktree.parser import Recipe, Task, find_recipe_file, parse_arg_spec, parse_recipe
@@ -28,7 +30,9 @@ __all__ = [
     "TaskNotFoundError",
     "build_dependency_tree",
     "get_implicit_inputs",
+    "resolve_dependency_output_references",
     "resolve_execution_order",
+    "resolve_self_references",
     "hash_args",
     "hash_task",
     "make_cache_key",

tasktree/cli.py

@@ -14,7 +14,7 @@ from rich.tree import Tree
 
 from tasktree import __version__
 from tasktree.executor import Executor
-from tasktree.graph import build_dependency_tree, resolve_execution_order
+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.parser import Recipe, find_recipe_file, parse_arg_spec, parse_recipe
 from tasktree.state import StateManager
@@ -110,8 +110,13 @@ def _list_tasks(tasks_file: Optional[str] = None):
         console.print("[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
-    max_task_name_len = max(len(name) for name in recipe.task_names()) if recipe.task_names() else 0
+    # Calculate maximum task name length for fixed-width column (only visible tasks)
+    visible_task_names = []
+    for name in recipe.task_names():
+        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
 
     # Create borderless table with three columns
     table = Table(show_edge=False, show_header=False, box=None, padding=(0, 2))
@@ -127,6 +132,9 @@ def _list_tasks(tasks_file: Optional[str] = None):
 
     for task_name in sorted(recipe.task_names()):
         task = recipe.get_task(task_name)
+        # Skip private tasks in list output
+        if task and task.private:
+            continue
         desc = task.desc if task else ""
         args_formatted = _format_task_arguments(task.args) if task else ""
 
@@ -344,7 +352,9 @@ def main(
 
         console.print("[bold]Available tasks:[/bold]")
         for task_name in sorted(recipe.task_names()):
-            console.print(f"  - {task_name}")
+            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")
 
@@ -437,7 +447,9 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
         console.print(f"[red]Task not found: {task_name}[/red]")
         console.print("\nAvailable tasks:")
         for name in sorted(recipe.task_names()):
-            console.print(f"  - {name}")
+            task = recipe.get_task(name)
+            if task and not task.private:
+                console.print(f"  - {name}")
         raise typer.Exit(1)
 
     # Parse task arguments
@@ -452,6 +464,18 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
     # This is important for correct state pruning after template substitution
     execution_order = resolve_execution_order(recipe, task_name, args_dict)
 
+    try:
+        # Resolve dependency output references in topological order
+        # This substitutes {{ dep.*.outputs.* }} templates before execution
+        resolve_dependency_output_references(recipe, execution_order)
+
+        # Resolve self-references in topological order
+        # 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]")
+        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()

tasktree/executor.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any
 
 from tasktree import docker as docker_module
-from tasktree.graph import get_implicit_inputs, resolve_execution_order
+from tasktree.graph import get_implicit_inputs, resolve_execution_order, resolve_dependency_output_references, resolve_self_references
 from tasktree.hasher import hash_args, hash_task, make_cache_key
 from tasktree.parser import Recipe, Task, Environment
 from tasktree.state import StateManager, TaskState
@@ -433,6 +433,14 @@ class Executor:
             # Execute task and all dependencies
             execution_order = resolve_execution_order(self.recipe, task_name, args_dict)
 
+        # Resolve dependency output references in topological order
+        # This substitutes {{ dep.*.outputs.* }} templates before execution
+        resolve_dependency_output_references(self.recipe, execution_order)
+
+        # Resolve self-references in topological order
+        # This substitutes {{ self.inputs.* }} and {{ self.outputs.* }} templates
+        resolve_self_references(self.recipe, execution_order)
+
         # Single phase: Check and execute incrementally
         statuses: dict[str, TaskStatus] = {}
         for name, task_args in execution_order:
@@ -857,7 +865,15 @@ class Executor:
         Returns:
             List of input glob patterns
         """
-        all_inputs = list(task.inputs)
+        # Extract paths from inputs (handle both anonymous strings and named dicts)
+        all_inputs = []
+        for inp in task.inputs:
+            if isinstance(inp, str):
+                all_inputs.append(inp)
+            elif isinstance(inp, dict):
+                # Named input - extract the path value(s)
+                all_inputs.extend(inp.values())
+
         implicit_inputs = get_implicit_inputs(self.recipe, task)
         all_inputs.extend(implicit_inputs)
         return all_inputs
@@ -1042,6 +1058,25 @@ class Executor:
 
         return changed_files
 
+    def _expand_output_paths(self, task: Task) -> list[str]:
+        """Extract all output paths from task outputs (both named and anonymous).
+
+        Args:
+            task: Task with outputs to extract
+
+        Returns:
+            List of output path patterns (glob patterns as strings)
+        """
+        paths = []
+        for output in task.outputs:
+            if isinstance(output, str):
+                # Anonymous output: just the path string
+                paths.append(output)
+            elif isinstance(output, dict):
+                # Named output: extract the path value
+                paths.extend(output.values())
+        return paths
+
     def _check_outputs_missing(self, task: Task) -> list[str]:
         """Check if any declared outputs are missing.
 
@@ -1057,7 +1092,10 @@ class Executor:
         missing_patterns = []
         base_path = self.recipe.project_root / task.working_dir
 
-        for pattern in task.outputs:
+        # Expand outputs to paths (handles both named and anonymous)
+        output_paths = self._expand_output_paths(task)
+
+        for pattern in output_paths:
             # Check if pattern has any matches
             matches = list(base_path.glob(pattern))
             if not matches:

tasktree/graph.py

@@ -306,6 +306,175 @@ def resolve_execution_order(
         raise CycleError(f"Dependency cycle detected: {e}")
 
 
+def resolve_dependency_output_references(
+    recipe: Recipe,
+    ordered_tasks: list[tuple[str, dict[str, Any]]],
+) -> None:
+    """Resolve {{ dep.<task>.outputs.<name> }} references in topological order.
+
+    This function walks through tasks in dependency order (dependencies first) and
+    resolves any references to dependency outputs in task fields. Templates are
+    resolved in place, modifying the Task objects in the recipe.
+
+    Args:
+        recipe: Recipe containing task definitions
+        ordered_tasks: List of (task_name, args) tuples in topological order
+
+    Raises:
+        ValueError: If template references cannot be resolved (missing task,
+                   missing output, task not in dependencies, etc.)
+
+    Example:
+        Given tasks in topological order: [('build', {}), ('deploy', {})]
+        If deploy.cmd contains "{{ dep.build.outputs.bundle }}", it will be
+        resolved to the actual output path from the build task.
+    """
+    from tasktree.substitution import substitute_dependency_outputs
+
+    # Track which tasks have been resolved (for validation)
+    resolved_tasks = {}
+
+    for task_name, task_args in ordered_tasks:
+        task = recipe.tasks.get(task_name)
+        if task is None:
+            continue  # Skip if task doesn't exist (shouldn't happen)
+
+        # Get list of dependency task names for this task
+        dep_task_names = []
+        for dep_spec in task.deps:
+            # Handle both string and dict dependency specs
+            if isinstance(dep_spec, str):
+                dep_task_names.append(dep_spec)
+            elif isinstance(dep_spec, dict):
+                # Dict spec: {"task_name": [args]}
+                dep_task_names.append(list(dep_spec.keys())[0])
+
+        # Resolve output references in command
+        if task.cmd:
+            task.cmd = substitute_dependency_outputs(
+                task.cmd,
+                task_name,
+                dep_task_names,
+                resolved_tasks,
+            )
+
+        # Resolve output references in working_dir
+        if task.working_dir:
+            task.working_dir = substitute_dependency_outputs(
+                task.working_dir,
+                task_name,
+                dep_task_names,
+                resolved_tasks,
+            )
+
+        # Resolve output references in outputs
+        resolved_outputs = []
+        for output in task.outputs:
+            if isinstance(output, str):
+                resolved_outputs.append(
+                    substitute_dependency_outputs(
+                        output,
+                        task_name,
+                        dep_task_names,
+                        resolved_tasks,
+                    )
+                )
+            elif isinstance(output, dict):
+                # Named output: resolve the path value
+                resolved_dict = {}
+                for name, path in output.items():
+                    resolved_dict[name] = substitute_dependency_outputs(
+                        path,
+                        task_name,
+                        dep_task_names,
+                        resolved_tasks,
+                    )
+                resolved_outputs.append(resolved_dict)
+        task.outputs = resolved_outputs
+
+        # Rebuild output maps after resolution
+        task.__post_init__()
+
+        # Resolve output references in argument defaults
+        if task.args:
+            for arg_spec in task.args:
+                if isinstance(arg_spec, dict):
+                    # Get arg name and details
+                    for arg_name, arg_details in arg_spec.items():
+                        if isinstance(arg_details, dict) and "default" in arg_details:
+                            if isinstance(arg_details["default"], str):
+                                arg_details["default"] = substitute_dependency_outputs(
+                                    arg_details["default"],
+                                    task_name,
+                                    dep_task_names,
+                                    resolved_tasks,
+                                )
+
+        # Mark this task as resolved for future references
+        resolved_tasks[task_name] = task
+
+
+def resolve_self_references(
+    recipe: Recipe,
+    ordered_tasks: list[tuple[str, dict[str, Any]]],
+) -> None:
+    """Resolve {{ self.inputs.name }} and {{ self.outputs.name }} references.
+
+    This function walks through tasks and resolves self-references to task's own
+    inputs/outputs. Must be called AFTER resolve_dependency_output_references()
+    so that dependency outputs are already resolved in output paths.
+
+    Args:
+        recipe: Recipe containing task definitions
+        ordered_tasks: List of (task_name, args) tuples in topological order
+
+    Raises:
+        ValueError: If self-reference cannot be resolved (missing name, etc.)
+
+    Example:
+        If task.cmd contains "{{ self.inputs.src }}" and task has input {src: "*.txt"},
+        it will be resolved to "*.txt" (literal string, no glob expansion).
+    """
+    from tasktree.substitution import substitute_self_references
+
+    for task_name, task_args in ordered_tasks:
+        task = recipe.tasks.get(task_name)
+        if task is None:
+            continue
+
+        # Resolve self-references in command
+        if task.cmd:
+            task.cmd = substitute_self_references(
+                task.cmd,
+                task_name,
+                task._input_map,
+                task._output_map,
+            )
+
+        # Resolve self-references in working_dir
+        if task.working_dir:
+            task.working_dir = substitute_self_references(
+                task.working_dir,
+                task_name,
+                task._input_map,
+                task._output_map,
+            )
+
+        # Resolve self-references in argument defaults
+        if task.args:
+            for arg_spec in task.args:
+                if isinstance(arg_spec, dict):
+                    for arg_name, arg_details in arg_spec.items():
+                        if isinstance(arg_details, dict) and "default" in arg_details:
+                            if isinstance(arg_details["default"], str):
+                                arg_details["default"] = substitute_self_references(
+                                    arg_details["default"],
+                                    task_name,
+                                    task._input_map,
+                                    task._output_map,
+                                )
+
+
 def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
     """Get implicit inputs for a task based on its dependencies.
 
@@ -336,7 +505,14 @@ def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
 
         # If dependency has outputs, inherit them
         if dep_task.outputs:
-            implicit_inputs.extend(dep_task.outputs)
+            # Extract paths from both named and anonymous outputs
+            for output in dep_task.outputs:
+                if isinstance(output, str):
+                    # Anonymous output: just the path
+                    implicit_inputs.append(output)
+                elif isinstance(output, dict):
+                    # Named output: extract path values
+                    implicit_inputs.extend(output.values())
         # If dependency has no outputs, inherit its inputs
         elif dep_task.inputs:
             implicit_inputs.extend(dep_task.inputs)

tasktree/hasher.py

@@ -37,9 +37,38 @@ def _normalize_choices_lists(args: list[str | dict[str, Any]]) ->  list[str | di
     return normalized_args
 
 
+def _serialize_outputs_for_hash(outputs: list[str | dict[str, str]]) -> list[str]:
+    """Serialize outputs to consistent list of strings for hashing.
+
+    Converts both named outputs (dicts) and anonymous outputs (strings)
+    into a consistent, sortable format.
+
+    Args:
+        outputs: List of output specifications (strings or dicts)
+
+    Returns:
+        List of serialized output strings in sorted order
+
+    Example:
+        >>> _serialize_outputs_for_hash(["file.txt", {"bundle": "app.js"}])
+        ['bundle:app.js', 'file.txt']
+    """
+    serialized = []
+    for output in outputs:
+        if isinstance(output, str):
+            # Anonymous output: just the path
+            serialized.append(output)
+        elif isinstance(output, dict):
+            # Named output: serialize as "name:path" for each entry
+            # Sort dict items for consistent ordering
+            for name, path in sorted(output.items()):
+                serialized.append(f"{name}:{path}")
+    return sorted(serialized)
+
+
 def hash_task(
     cmd: str,
-    outputs: list[str],
+    outputs: list[str | dict[str, str]],
     working_dir: str,
     args: list[str | dict[str, Any]],
     env: str = "",
@@ -49,7 +78,7 @@ def hash_task(
 
     Args:
         cmd: Task command
-        outputs: Task outputs
+        outputs: Task outputs (strings or named dicts)
         working_dir: Working directory
         args: Task argument specifications
         env: Environment name
@@ -60,7 +89,7 @@ def hash_task(
     """
     data = {
         "cmd": cmd,
-        "outputs": sorted(outputs),
+        "outputs": _serialize_outputs_for_hash(outputs),
         "working_dir": working_dir,
         "args": sorted(_normalize_choices_lists(args), key=_arg_sort_key),
         "env": env,