tasktree 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

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)
@@ -375,8 +423,8 @@ def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, A
 
     parsed_specs = []
     for spec in arg_specs:
-        name, arg_type, default = parse_arg_spec(spec)
-        parsed_specs.append((name, arg_type, default))
+        parsed = parse_arg_spec(spec)
+        parsed_specs.append(parsed)
 
     args_dict = {}
     positional_index = 0
@@ -386,41 +434,49 @@ def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, A
         if "=" in value_str:
             arg_name, arg_value = value_str.split("=", 1)
             # Find the spec for this argument
-            spec = next((s for s in parsed_specs if s[0] == arg_name), None)
+            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]")
                 raise typer.Exit(1)
-            name, arg_type, default = spec
         else:
             # Positional argument
             if positional_index >= len(parsed_specs):
                 console.print(f"[red]Too many arguments[/red]")
                 raise typer.Exit(1)
-            name, arg_type, default = parsed_specs[positional_index]
+            spec = parsed_specs[positional_index]
             arg_value = value_str
             positional_index += 1
 
-        # Convert value to appropriate type
+        # Convert value to appropriate type (exported args are always strings)
         try:
-            click_type = get_click_type(arg_type)
+            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)
-            args_dict[name] = converted_value
+
+            # 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)}")
+                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 {name}: {e}[/red]")
+            console.print(f"[red]Invalid value for {spec.name}: {e}[/red]")
             raise typer.Exit(1)
 
     # Fill in defaults for missing arguments
-    for name, arg_type, default in parsed_specs:
-        if name not in args_dict:
-            if default is not None:
+    for spec in parsed_specs:
+        if spec.name not in args_dict:
+            if spec.default is not None:
                 try:
-                    click_type = get_click_type(arg_type)
-                    args_dict[name] = click_type.convert(default, None, None)
+                    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 {name}: {e}[/red]")
+                    console.print(f"[red]Invalid default value for {spec.name}: {e}[/red]")
                     raise typer.Exit(1)
             else:
-                console.print(f"[red]Missing required argument: {name}[/red]")
+                console.print(f"[red]Missing required argument: {spec.name}[/red]")
                 raise typer.Exit(1)
 
     return args_dict

tasktree/docker.py

@@ -6,6 +6,7 @@ Provides Docker image building and container execution capabilities.
 from __future__ import annotations
 
 import os
+import platform
 import re
 import subprocess
 import time
@@ -39,6 +40,22 @@ class DockerManager:
         self._project_root = project_root
         self._built_images: dict[str, tuple[str, str]] = {}  # env_name -> (image_tag, image_id) cache
 
+    def _should_add_user_flag(self) -> bool:
+        """Check if --user flag should be added to docker run.
+
+        Returns False on Windows (where Docker Desktop handles UID mapping automatically).
+        Returns True on Linux/macOS where os.getuid() and os.getgid() are available.
+
+        Returns:
+            True if --user flag should be added, False otherwise
+        """
+        # Skip on Windows - Docker Desktop handles UID mapping differently
+        if platform.system() == "Windows":
+            return False
+
+        # Check if os.getuid() and os.getgid() are available (Linux/macOS)
+        return hasattr(os, "getuid") and hasattr(os, "getgid")
+
     def ensure_image_built(self, env: Environment) -> tuple[str, str]:
         """Build Docker image if not already built this invocation.
 
@@ -127,6 +144,14 @@ class DockerManager:
         # Build docker run command
         docker_cmd = ["docker", "run", "--rm"]
 
+        # Add user mapping (run as current host user) unless explicitly disabled or on Windows
+        if not env.run_as_root and self._should_add_user_flag():
+            uid = os.getuid()
+            gid = os.getgid()
+            docker_cmd.extend(["--user", f"{uid}:{gid}"])
+
+        docker_cmd.extend(env.extra_args)
+
         # Add volume mounts
         for volume in env.volumes:
             # Resolve volume paths