tasktree 0.0.8__tar.gz → 0.0.10__tar.gz

{tasktree-0.0.8 → tasktree-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.8
+Version: 0.0.10
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -594,6 +594,97 @@ If an exported argument with a default isn't available as an environment variabl
 2. The CLI automatically applies defaults before execution
 3. You can explicitly provide the value: `tt deploy prod-server port=8080`
 
+### Parameterized Dependencies
+
+Dependencies can invoke tasks with specific arguments, enabling flexible and reusable task graphs:
+
+**Syntax:**
+
+```yaml
+tasks:
+  # Task with parameters
+  process:
+    args: [mode, verbose=false]
+    cmd: echo "mode={{arg.mode}} verbose={{arg.verbose}}"
+
+  # Simple dependency (uses defaults)
+  consumer1:
+    deps: [process]  # Equivalent to: process(mode must be provided)
+    cmd: echo "done"
+
+  # Positional arguments
+  consumer2:
+    deps:
+      - process: [debug, true]  # Maps to: mode=debug, verbose=true
+    cmd: echo "done"
+
+  # Named arguments
+  consumer3:
+    deps:
+      - process: {mode: release, verbose: false}
+    cmd: echo "done"
+
+  # Multiple invocations with different args
+  multi_build:
+    deps:
+      - process: [debug]
+      - process: [release]
+    cmd: echo "All builds complete"
+```
+
+**Key behaviors:**
+
+- **Simple string form** (`- task_name`): Uses task defaults for all arguments. Required arguments must have defaults or task invocation fails.
+- **Positional form** (`- task_name: [arg1, arg2]`): Arguments mapped by position. Can omit trailing args if they have defaults.
+- **Named form** (`- task_name: {arg1: val1}`): Arguments mapped by name. Can omit any arg with a default.
+- **Multiple invocations**: Same task with different arguments creates separate graph nodes, each executing independently.
+- **Normalization**: All forms normalized to named arguments with defaults filled before execution.
+- **Cache separation**: `process(debug)` and `process(release)` cache independently.
+
+**Restrictions:**
+
+- **No empty lists**: `- task: []` is invalid (use `- task` instead)
+- **No mixed positional and named**: Choose one form per dependency
+- **Single-key dicts**: `{task1: [x], task2: [y]}` is invalid (multi-key not allowed)
+
+**Validation:**
+
+Validation happens at graph construction time with clear error messages:
+
+```
+Task 'process' takes 2 arguments, got 3
+Task 'build' has no argument named 'mode'
+Task 'deploy' requires argument 'environment' (no default provided)
+```
+
+**Example use cases:**
+
+```yaml
+tasks:
+  # Compile for different platforms
+  compile:
+    args: [target]
+    cmd: cargo build --target {{arg.target}}
+
+  dist:
+    deps:
+      - compile: [x86_64-unknown-linux-gnu]
+      - compile: [aarch64-unknown-linux-gnu]
+    cmd: tar czf dist.tar.gz target/*/release/app
+
+  # Run tests with different configurations
+  test:
+    args: [config]
+    cmd: pytest --config={{arg.config}}
+
+  ci:
+    deps:
+      - test: [unit]
+      - test: [integration]
+      - test: [e2e]
+    cmd: echo "All tests passed"
+```
+
 ## Environment Variables
 
 Task Tree supports reading environment variables in two ways:

{tasktree-0.0.8 → tasktree-0.0.10}/README.md

@@ -579,6 +579,97 @@ If an exported argument with a default isn't available as an environment variabl
 2. The CLI automatically applies defaults before execution
 3. You can explicitly provide the value: `tt deploy prod-server port=8080`
 
+### Parameterized Dependencies
+
+Dependencies can invoke tasks with specific arguments, enabling flexible and reusable task graphs:
+
+**Syntax:**
+
+```yaml
+tasks:
+  # Task with parameters
+  process:
+    args: [mode, verbose=false]
+    cmd: echo "mode={{arg.mode}} verbose={{arg.verbose}}"
+
+  # Simple dependency (uses defaults)
+  consumer1:
+    deps: [process]  # Equivalent to: process(mode must be provided)
+    cmd: echo "done"
+
+  # Positional arguments
+  consumer2:
+    deps:
+      - process: [debug, true]  # Maps to: mode=debug, verbose=true
+    cmd: echo "done"
+
+  # Named arguments
+  consumer3:
+    deps:
+      - process: {mode: release, verbose: false}
+    cmd: echo "done"
+
+  # Multiple invocations with different args
+  multi_build:
+    deps:
+      - process: [debug]
+      - process: [release]
+    cmd: echo "All builds complete"
+```
+
+**Key behaviors:**
+
+- **Simple string form** (`- task_name`): Uses task defaults for all arguments. Required arguments must have defaults or task invocation fails.
+- **Positional form** (`- task_name: [arg1, arg2]`): Arguments mapped by position. Can omit trailing args if they have defaults.
+- **Named form** (`- task_name: {arg1: val1}`): Arguments mapped by name. Can omit any arg with a default.
+- **Multiple invocations**: Same task with different arguments creates separate graph nodes, each executing independently.
+- **Normalization**: All forms normalized to named arguments with defaults filled before execution.
+- **Cache separation**: `process(debug)` and `process(release)` cache independently.
+
+**Restrictions:**
+
+- **No empty lists**: `- task: []` is invalid (use `- task` instead)
+- **No mixed positional and named**: Choose one form per dependency
+- **Single-key dicts**: `{task1: [x], task2: [y]}` is invalid (multi-key not allowed)
+
+**Validation:**
+
+Validation happens at graph construction time with clear error messages:
+
+```
+Task 'process' takes 2 arguments, got 3
+Task 'build' has no argument named 'mode'
+Task 'deploy' requires argument 'environment' (no default provided)
+```
+
+**Example use cases:**
+
+```yaml
+tasks:
+  # Compile for different platforms
+  compile:
+    args: [target]
+    cmd: cargo build --target {{arg.target}}
+
+  dist:
+    deps:
+      - compile: [x86_64-unknown-linux-gnu]
+      - compile: [aarch64-unknown-linux-gnu]
+    cmd: tar czf dist.tar.gz target/*/release/app
+
+  # Run tests with different configurations
+  test:
+    args: [config]
+    cmd: pytest --config={{arg.config}}
+
+  ci:
+    deps:
+      - test: [unit]
+      - test: [integration]
+      - test: [e2e]
+    cmd: echo "All tests passed"
+```
+
 ## Environment Variables
 
 Task Tree supports reading environment variables in two ways:

{tasktree-0.0.8 → tasktree-0.0.10}/pyproject.toml

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

{tasktree-0.0.8 → tasktree-0.0.10}/src/tasktree/cli.py

@@ -26,6 +26,41 @@ app = typer.Typer(
 console = Console()
 
 
+def _format_task_arguments(arg_specs: list[str | dict]) -> str:
+    """Format task arguments for display in list output.
+
+    Args:
+        arg_specs: List of argument specifications from task definition (strings or dicts)
+
+    Returns:
+        Formatted string showing arguments with types and defaults
+
+    Examples:
+        ["mode", "target"] -> "mode:str target:str"
+        ["mode=debug", "target=x86_64"] -> "mode:str [=debug] target:str [=x86_64]"
+        ["port:int", "debug:bool=false"] -> "port:int debug:bool [=false]"
+        [{"timeout": {"type": "int", "default": 30}}] -> "timeout:int [=30]"
+    """
+    if not arg_specs:
+        return ""
+
+    formatted_parts = []
+    for spec_str in arg_specs:
+        parsed = parse_arg_spec(spec_str)
+
+        # Format: name:type or name:type [=default]
+        # Argument names in normal intensity, types and defaults in dim
+        arg_part = f"{parsed.name}[dim]:{parsed.arg_type}[/dim]"
+
+        if parsed.default is not None:
+            # Use dim styling for the default value part
+            arg_part += f" [dim]\\[={parsed.default}][/dim]"
+
+        formatted_parts.append(arg_part)
+
+    return " ".join(formatted_parts)
+
+
 def _list_tasks(tasks_file: Optional[str] = None):
     """List all available tasks with descriptions."""
     recipe = _get_recipe(tasks_file)
@@ -33,14 +68,27 @@ 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)
 
-    table = Table(title="Available Tasks")
-    table.add_column("Task", style="cyan", no_wrap=True)
-    table.add_column("Description", style="white")
+    # 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
+
+    # 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)
+
+    # Arguments column: allow wrapping with sensible max width
+    table.add_column("Arguments", style="white", max_width=60)
+
+    # Description column: allow wrapping with sensible max width
+    table.add_column("Description", style="white", max_width=80)
 
     for task_name in sorted(recipe.task_names()):
         task = recipe.get_task(task_name)
         desc = task.desc if task else ""
-        table.add_row(task_name, desc)
+        args_formatted = _format_task_arguments(task.args) if task else ""
+
+        table.add_row(task_name, args_formatted, desc)
 
     console.print(table)
 
@@ -351,9 +399,9 @@ 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)
+    # 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))
+        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()
     }
     state.prune(valid_hashes)

{tasktree-0.0.8 → tasktree-0.0.10}/src/tasktree/docker.py

@@ -87,16 +87,24 @@ class DockerManager:
 
         # Build the image
         try:
+            docker_build_cmd = [
+                "docker",
+                "build",
+                "-t",
+                image_tag,
+                "-f",
+                str(dockerfile_path),
+            ]
+
+            # Add build args if environment has them (docker environments use dict for args)
+            if isinstance(env.args, dict):
+                for arg_name, arg_value in env.args.items():
+                    docker_build_cmd.extend(["--build-arg", f"{arg_name}={arg_value}"])
+
+            docker_build_cmd.append(str(context_path))
+
             subprocess.run(
-                [
-                    "docker",
-                    "build",
-                    "-t",
-                    image_tag,
-                    "-f",
-                    str(dockerfile_path),
-                    str(context_path),
-                ],
+                docker_build_cmd,
                 check=True,
                 capture_output=False,  # Show build output to user
             )

{tasktree-0.0.8 → tasktree-0.0.10}/src/tasktree/executor.py

@@ -64,6 +64,62 @@ class Executor:
         self.state = state_manager
         self.docker_manager = docker_module.DockerManager(recipe.project_root)
 
+    def _has_regular_args(self, task: Task) -> bool:
+        """Check if a task has any regular (non-exported) arguments.
+
+        Args:
+            task: Task to check
+
+        Returns:
+            True if task has at least one regular (non-exported) argument, False otherwise
+        """
+        if not task.args:
+            return False
+
+        # Check if any arg is not exported (doesn't start with $)
+        for arg_spec in task.args:
+            # Handle both string and dict arg specs
+            if isinstance(arg_spec, str):
+                # Remove default value part if present
+                arg_name = arg_spec.split('=')[0].split(':')[0].strip()
+                if not arg_name.startswith('$'):
+                    return True
+            elif isinstance(arg_spec, dict):
+                # Dict format: { argname: { ... } } or { $argname: { ... } }
+                for key in arg_spec.keys():
+                    if not key.startswith('$'):
+                        return True
+
+        return False
+
+    def _filter_regular_args(self, task: Task, task_args: dict[str, Any]) -> dict[str, Any]:
+        """Filter task_args to only include regular (non-exported) arguments.
+
+        Args:
+            task: Task definition
+            task_args: Dictionary of all task arguments
+
+        Returns:
+            Dictionary containing only regular (non-exported) arguments
+        """
+        if not task.args or not task_args:
+            return {}
+
+        # Build set of exported arg names (without the $ prefix)
+        exported_names = set()
+        for arg_spec in task.args:
+            if isinstance(arg_spec, str):
+                arg_name = arg_spec.split('=')[0].split(':')[0].strip()
+                if arg_name.startswith('$'):
+                    exported_names.add(arg_name[1:])  # Remove $ prefix
+            elif isinstance(arg_spec, dict):
+                for key in arg_spec.keys():
+                    if key.startswith('$'):
+                        exported_names.add(key[1:])  # Remove $ prefix
+
+        # Filter out exported args
+        return {k: v for k, v in task_args.items() if k not in exported_names}
+
     def _collect_early_builtin_variables(self, task: Task, timestamp: datetime) -> dict[str, str]:
         """Collect built-in variables that don't depend on working_dir.
 
@@ -277,9 +333,9 @@ class Executor:
                 reason="forced",
             )
 
-        # Compute hashes (include effective environment)
+        # Compute hashes (include effective environment and dependencies)
         effective_env = self._get_effective_env_name(task)
-        task_hash = hash_task(task.cmd, task.outputs, task.working_dir, task.args, effective_env)
+        task_hash = hash_task(task.cmd, task.outputs, task.working_dir, task.args, effective_env, task.deps)
         args_hash = hash_args(args_dict) if args_dict else None
         cache_key = make_cache_key(task_hash, args_hash)
 
@@ -372,22 +428,39 @@ class Executor:
         # Resolve execution order
         if only:
             # Only execute the target task, skip dependencies
-            execution_order = [task_name]
+            execution_order = [(task_name, args_dict)]
         else:
             # Execute task and all dependencies
-            execution_order = resolve_execution_order(self.recipe, task_name)
+            execution_order = resolve_execution_order(self.recipe, task_name, args_dict)
 
         # Single phase: Check and execute incrementally
         statuses: dict[str, TaskStatus] = {}
-        for name in execution_order:
+        for name, task_args in execution_order:
             task = self.recipe.tasks[name]
 
-            # Determine task-specific args (only for target task)
-            task_args = args_dict if name == task_name else {}
+            # Convert None to {} for internal use (None is used to distinguish simple deps in graph)
+            args_dict_for_execution = task_args if task_args is not None else {}
 
             # Check if task needs to run (based on CURRENT filesystem state)
-            status = self.check_task_status(task, task_args, force=force)
-            statuses[name] = status
+            status = self.check_task_status(task, args_dict_for_execution, force=force)
+
+            # Use a key that includes args for status tracking
+            # Only include regular (non-exported) args in status key for parameterized dependencies
+            # For the root task (invoked from CLI), status key is always just the task name
+            # For dependencies with parameterized invocations, include the regular args
+            is_root_task = (name == task_name)
+            if not is_root_task and args_dict_for_execution and self._has_regular_args(task):
+                import json
+                # Filter to only include regular (non-exported) args
+                regular_args = self._filter_regular_args(task, args_dict_for_execution)
+                if regular_args:
+                    args_str = json.dumps(regular_args, sort_keys=True, separators=(",", ":"))
+                    status_key = f"{name}({args_str})"
+                else:
+                    status_key = name
+            else:
+                status_key = name
+            statuses[status_key] = status
 
             # Execute immediately if needed
             if status.will_run:
@@ -399,7 +472,7 @@ class Executor:
                         file=sys.stderr,
                     )
 
-                self._run_task(task, task_args)
+                self._run_task(task, args_dict_for_execution)
 
         return statuses
 
@@ -962,9 +1035,9 @@ class Executor:
             task: Task that was executed
             args_dict: Arguments used for execution
         """
-        # Compute hashes (include effective environment)
+        # Compute hashes (include effective environment and dependencies)
         effective_env = self._get_effective_env_name(task)
-        task_hash = hash_task(task.cmd, task.outputs, task.working_dir, task.args, effective_env)
+        task_hash = hash_task(task.cmd, task.outputs, task.working_dir, task.args, effective_env, task.deps)
         args_hash = hash_args(args_dict) if args_dict else None
         cache_key = make_cache_key(task_hash, args_hash)