tasktree 0.0.14__tar.gz → 0.0.16__tar.gz

{tasktree-0.0.14 → tasktree-0.0.16}/.github/workflows/validate-pipx-install.yml

@@ -50,6 +50,12 @@ jobs:
           python -m pipx install tasktree
         shell: bash
 
+      - name: Get installed tt version
+        working-directory: example
+        run: |
+          tt --version
+        shell: bash
+
       - name: Test tt --list command
         working-directory: example
         run: |
@@ -103,6 +109,13 @@ jobs:
           pipx install --python python3.12 tasktree
         shell: bash
 
+      - name: Get installed tt version
+        working-directory: example
+        run: |
+          export PATH="$HOME/.local/bin:$PATH"
+          tt --version
+        shell: bash
+
       - name: Test tt --list command
         working-directory: example
         run: |

{tasktree-0.0.14 → tasktree-0.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.14
+Version: 0.0.16
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0

{tasktree-0.0.14 → tasktree-0.0.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tasktree"
-version = "0.0.14"
+version = "0.0.16"
 description = "A task automation tool with incremental execution"
 readme = "README.md"
 requires-python = ">=3.11"

{tasktree-0.0.14 → tasktree-0.0.16}/src/tasktree/cli.py

@@ -14,8 +14,8 @@ from rich.tree import Tree
 
 from tasktree import __version__
 from tasktree.executor import Executor
-from tasktree.graph import build_dependency_tree
-from tasktree.hasher import hash_task
+from tasktree.graph import build_dependency_tree, resolve_execution_order
+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
 from tasktree.types import get_click_type
@@ -137,7 +137,8 @@ def _list_tasks(tasks_file: Optional[str] = None):
 
 def _show_task(task_name: str, tasks_file: Optional[str] = None):
     """Show task definition with syntax highlighting."""
-    recipe = _get_recipe(tasks_file)
+    # Pass task_name as root_task for lazy variable evaluation
+    recipe = _get_recipe(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]")
         raise typer.Exit(1)
@@ -186,7 +187,8 @@ def _show_task(task_name: str, tasks_file: Optional[str] = None):
 
 def _show_tree(task_name: str, tasks_file: Optional[str] = None):
     """Show dependency tree structure."""
-    recipe = _get_recipe(tasks_file)
+    # Pass task_name as root_task for lazy variable evaluation
+    recipe = _get_recipe(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]")
         raise typer.Exit(1)
@@ -372,11 +374,13 @@ def _clean_state(tasks_file: Optional[str] = None) -> None:
         console.print(f"[yellow]No state file found at {state_path}[/yellow]")
 
 
-def _get_recipe(recipe_file: Optional[str] = None) -> Optional[Recipe]:
+def _get_recipe(recipe_file: Optional[str] = None, root_task: Optional[str] = None) -> Optional[Recipe]:
     """Get parsed recipe or None if not found.
 
     Args:
         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).
     """
     if recipe_file:
         recipe_path = Path(recipe_file)
@@ -398,7 +402,7 @@ def _get_recipe(recipe_file: Optional[str] = None) -> Optional[Recipe]:
         project_root = None
 
     try:
-        return parse_recipe(recipe_path, project_root)
+        return parse_recipe(recipe_path, project_root, root_task)
     except Exception as e:
         console.print(f"[red]Error parsing recipe: {e}[/red]")
         raise typer.Exit(1)
@@ -411,7 +415,8 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
     task_name = args[0]
     task_args = args[1:]
 
-    recipe = _get_recipe(tasks_file)
+    # Pass task_name as root_task for lazy variable evaluation
+    recipe = _get_recipe(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]")
         raise typer.Exit(1)
@@ -443,11 +448,34 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
     state.load()
     executor = Executor(recipe, state)
 
-    # Prune state before execution (compute hashes with effective environment and dependencies)
-    valid_hashes = {
-        hash_task(t.cmd, t.outputs, t.working_dir, t.args, executor._get_effective_env_name(t), t.deps)
-        for t in recipe.tasks.values()
-    }
+    # Resolve execution order to determine which tasks will actually run
+    # This is important for correct state pruning after template substitution
+    execution_order = resolve_execution_order(recipe, task_name, args_dict)
+
+    # 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]
+        # Compute base task hash
+        task_hash = hash_task(
+            task.cmd,
+            task.outputs,
+            task.working_dir,
+            task.args,
+            executor._get_effective_env_name(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)
+
     state.prune(valid_hashes)
     state.save()
     try:

{tasktree-0.0.14 → tasktree-0.0.16}/src/tasktree/executor.py

@@ -662,6 +662,60 @@ class Executor:
             except OSError:
                 pass  # Ignore cleanup errors
 
+    def _substitute_builtin_in_environment(self, env: Environment, builtin_vars: dict[str, str]) -> Environment:
+        """Substitute builtin and environment variables in environment fields.
+
+        Args:
+            env: Environment to process
+            builtin_vars: Built-in variable values
+
+        Returns:
+            New Environment with builtin and environment variables substituted
+
+        Raises:
+            ValueError: If builtin variable or environment variable is not defined
+        """
+        from dataclasses import replace
+
+        # Substitute in volumes (builtin vars first, then env vars)
+        substituted_volumes = [
+            self._substitute_env(self._substitute_builtin(vol, builtin_vars)) for vol in env.volumes
+        ] if env.volumes else []
+
+        # Substitute in env_vars values (builtin vars first, then env vars)
+        substituted_env_vars = {
+            key: self._substitute_env(self._substitute_builtin(value, builtin_vars))
+            for key, value in env.env_vars.items()
+        } if env.env_vars else {}
+
+        # Substitute in ports (builtin vars first, then env vars)
+        substituted_ports = [
+            self._substitute_env(self._substitute_builtin(port, builtin_vars)) for port in env.ports
+        ] if env.ports else []
+
+        # Substitute in working_dir (builtin vars first, then env vars)
+        substituted_working_dir = self._substitute_env(self._substitute_builtin(env.working_dir, builtin_vars)) if env.working_dir else ""
+
+        # Substitute in build args (for Docker environments, args is a dict)
+        # Apply builtin vars first, then env vars
+        if isinstance(env.args, dict):
+            substituted_args = {
+                key: self._substitute_env(self._substitute_builtin(str(value), builtin_vars))
+                for key, value in env.args.items()
+            }
+        else:
+            substituted_args = env.args
+
+        # Create new environment with substituted values
+        return replace(
+            env,
+            volumes=substituted_volumes,
+            env_vars=substituted_env_vars,
+            ports=substituted_ports,
+            working_dir=substituted_working_dir,
+            args=substituted_args
+        )
+
     def _run_task_in_docker(
         self, task: Task, env: Any, cmd: str, working_dir: Path,
         exported_env_vars: dict[str, str] | None = None
@@ -678,6 +732,13 @@ class Executor:
         Raises:
             ExecutionError: If Docker execution fails
         """
+        # Get builtin variables for substitution in environment fields
+        task_start_time = datetime.now(timezone.utc)
+        builtin_vars = self._collect_builtin_variables(task, working_dir, task_start_time)
+
+        # Substitute builtin variables in environment fields (volumes, env_vars, etc.)
+        env = self._substitute_builtin_in_environment(env, builtin_vars)
+
         # Resolve container working directory
         container_working_dir = docker_module.resolve_container_working_dir(
             env.working_dir, task.working_dir

{tasktree-0.0.14 → tasktree-0.0.16}/src/tasktree/graph.py

@@ -5,7 +5,161 @@ from pathlib import Path
 from typing import Any
 
 from tasktree.hasher import hash_args
-from tasktree.parser import Recipe, Task, DependencyInvocation, parse_dependency_spec
+from tasktree.parser import (
+    Recipe,
+    Task,
+    DependencyInvocation,
+    parse_dependency_spec,
+    parse_arg_spec,
+)
+from tasktree.substitution import substitute_dependency_args
+
+
+def _get_exported_arg_names(task: Task) -> set[str]:
+    """Extract names of exported arguments from a task.
+
+    Exported arguments are identified by the '$' prefix in their definition.
+
+    Args:
+        task: Task to extract exported arg names from
+
+    Returns:
+        Set of exported argument names (without the '$' prefix)
+
+    Example:
+        Task with args: ["$server", "port"]
+        Returns: {"server"}
+    """
+    if not task.args:
+        return set()
+
+    exported = set()
+    for arg_spec in task.args:
+        if isinstance(arg_spec, str):
+            # Simple string format: "$argname" or "argname"
+            if arg_spec.startswith("$"):
+                exported.add(arg_spec[1:])  # Remove '$' prefix
+        elif isinstance(arg_spec, dict):
+            # Dictionary format: {"$argname": {...}} or {"argname": {...}}
+            for arg_name in arg_spec.keys():
+                if arg_name.startswith("$"):
+                    exported.add(arg_name[1:])  # Remove '$' prefix
+
+    return exported
+
+
+def resolve_dependency_invocation(
+    dep_spec: str | dict[str, Any],
+    parent_task_name: str,
+    parent_args: dict[str, Any],
+    parent_exported_args: set[str],
+    recipe: Recipe
+) -> DependencyInvocation:
+    """Parse dependency specification and substitute parent argument templates.
+
+    This function handles template substitution in dependency arguments. It:
+    1. Checks if dependency arguments contain {{ arg.* }} templates
+    2. Substitutes templates using parent task's arguments
+    3. Delegates to parse_dependency_spec for type conversion and validation
+
+    Args:
+        dep_spec: Dependency specification (str or dict with task name and args)
+        parent_task_name: Name of the parent task (for error messages)
+        parent_args: Parent task's argument values (for template substitution)
+        parent_exported_args: Set of parent's exported argument names
+        recipe: Recipe containing task definitions
+
+    Returns:
+        DependencyInvocation with typed, validated arguments
+
+    Raises:
+        ValueError: If template substitution fails, argument validation fails,
+                   or dependency task doesn't exist
+
+    Examples:
+        Simple string (no templates):
+        >>> resolve_dependency_invocation("build", "test", {}, set(), recipe)
+        DependencyInvocation("build", None)
+
+        Literal arguments (no templates):
+        >>> resolve_dependency_invocation({"build": ["debug"]}, "test", {}, set(), recipe)
+        DependencyInvocation("build", {"mode": "debug"})
+
+        Template substitution:
+        >>> resolve_dependency_invocation(
+        ...     {"build": ["{{ arg.env }}"]},
+        ...     "test",
+        ...     {"env": "production"},
+        ...     set(),
+        ...     recipe
+        ... )
+        DependencyInvocation("build", {"mode": "production"})
+    """
+    # Simple string case - no args to substitute
+    if isinstance(dep_spec, str):
+        return parse_dependency_spec(dep_spec, recipe)
+
+    # Dictionary case: {"task_name": args_spec}
+    if not isinstance(dep_spec, dict) or len(dep_spec) != 1:
+        # Invalid format, let parse_dependency_spec handle the error
+        return parse_dependency_spec(dep_spec, recipe)
+
+    task_name, arg_spec = next(iter(dep_spec.items()))
+
+    # Check if any argument values contain templates
+    has_templates = False
+    if isinstance(arg_spec, list):
+        # Positional args: check each value
+        for val in arg_spec:
+            if isinstance(val, str) and "{{ arg." in val:
+                has_templates = True
+                break
+    elif isinstance(arg_spec, dict):
+        # Named args: check each value
+        for val in arg_spec.values():
+            if isinstance(val, str) and "{{ arg." in val:
+                has_templates = True
+                break
+
+    # If no templates, use existing parser (fast path for backward compatibility)
+    if not has_templates:
+        return parse_dependency_spec(dep_spec, recipe)
+
+    # Template substitution path
+    # Substitute {{ arg.* }} in argument values
+    substituted_arg_spec: list[Any] | dict[str, Any]
+
+    if isinstance(arg_spec, list):
+        # Positional args: substitute each value that's a string
+        substituted_arg_spec = []
+        for val in arg_spec:
+            if isinstance(val, str):
+                substituted_val = substitute_dependency_args(
+                    val, parent_task_name, parent_args, parent_exported_args
+                )
+                substituted_arg_spec.append(substituted_val)
+            else:
+                # Non-string values (bool, int, etc.) pass through unchanged
+                substituted_arg_spec.append(val)
+    elif isinstance(arg_spec, dict):
+        # Named args: substitute each string value
+        substituted_arg_spec = {}
+        for arg_name, val in arg_spec.items():
+            if isinstance(val, str):
+                substituted_val = substitute_dependency_args(
+                    val, parent_task_name, parent_args, parent_exported_args
+                )
+                substituted_arg_spec[arg_name] = substituted_val
+            else:
+                # Non-string values pass through unchanged
+                substituted_arg_spec[arg_name] = val
+    else:
+        # Invalid format, let parse_dependency_spec handle it
+        return parse_dependency_spec(dep_spec, recipe)
+
+    # Create new dep_spec with substituted values and parse it
+    substituted_dep_spec = {task_name: substituted_arg_spec}
+    return parse_dependency_spec(substituted_dep_spec, recipe)
 
 
 class CycleError(Exception):
@@ -99,7 +253,7 @@ def resolve_execution_order(
         return seen_invocations[key]
 
     def build_graph(node: TaskNode) -> None:
-        """Recursively build dependency graph."""
+        """Recursively build dependency graph with template substitution."""
         if node in graph:
             # Already processed
             return
@@ -108,11 +262,21 @@ def resolve_execution_order(
         if task is None:
             raise TaskNotFoundError(f"Task not found: {node.task_name}")
 
-        # Parse and normalize dependencies
+        # Get parent task's exported argument names
+        parent_exported_args = _get_exported_arg_names(task)
+
+        # Parse and normalize dependencies with template substitution
         dep_nodes = set()
         for dep_spec in task.deps:
-            # Parse dependency specification
-            dep_inv = parse_dependency_spec(dep_spec, recipe)
+            # Resolve dependency specification with parent context
+            # This handles template substitution if {{ arg.* }} is present
+            dep_inv = resolve_dependency_invocation(
+                dep_spec,
+                parent_task_name=node.task_name,
+                parent_args=node.args or {},
+                parent_exported_args=parent_exported_args,
+                recipe=recipe
+            )
 
             # Create or get node for this dependency invocation
             dep_node = get_or_create_node(dep_inv.task_name, dep_inv.args)