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

tasktree/docker.py

@@ -0,0 +1,413 @@
+"""Docker integration for Task Tree.
+
+Provides Docker image building and container execution capabilities.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+try:
+    import pathspec
+except ImportError:
+    pathspec = None  # type: ignore
+
+if TYPE_CHECKING:
+    from tasktree.parser import Environment
+
+
+class DockerError(Exception):
+    """Raised when Docker operations fail."""
+
+    pass
+
+
+class DockerManager:
+    """Manages Docker image building and container execution."""
+
+    def __init__(self, project_root: Path):
+        """Initialize Docker manager.
+
+        Args:
+            project_root: Root directory of the project (where tasktree.yaml is located)
+        """
+        self._project_root = project_root
+        self._built_images: dict[str, tuple[str, str]] = {}  # env_name -> (image_tag, image_id) cache
+
+    def ensure_image_built(self, env: Environment) -> tuple[str, str]:
+        """Build Docker image if not already built this invocation.
+
+        Args:
+            env: Environment definition with dockerfile and context
+
+        Returns:
+            Tuple of (image_tag, image_id)
+            - image_tag: Tag like "tt-env-builder"
+            - image_id: Full image ID like "sha256:abc123..."
+
+        Raises:
+            DockerError: If docker command not available or build fails
+        """
+        # Check if already built this invocation
+        if env.name in self._built_images:
+            tag, image_id = self._built_images[env.name]
+            return tag, image_id
+
+        # Check if docker is available
+        self._check_docker_available()
+
+        # Resolve paths
+        dockerfile_path = self._project_root / env.dockerfile
+        context_path = self._project_root / env.context
+
+        # Generate image tag
+        image_tag = f"tt-env-{env.name}"
+
+        # Build the image
+        try:
+            subprocess.run(
+                [
+                    "docker",
+                    "build",
+                    "-t",
+                    image_tag,
+                    "-f",
+                    str(dockerfile_path),
+                    str(context_path),
+                ],
+                check=True,
+                capture_output=False,  # Show build output to user
+            )
+        except subprocess.CalledProcessError as e:
+            raise DockerError(
+                f"Failed to build Docker image for environment '{env.name}': "
+                f"docker build exited with code {e.returncode}"
+            ) from e
+        except FileNotFoundError:
+            raise DockerError(
+                "Docker command not found. Please install Docker and ensure it's in your PATH."
+            )
+
+        # Get the image ID
+        image_id = self._get_image_id(image_tag)
+
+        # Cache both tag and ID
+        self._built_images[env.name] = (image_tag, image_id)
+        return image_tag, image_id
+
+    def run_in_container(
+        self,
+        env: Environment,
+        cmd: str,
+        working_dir: Path,
+        container_working_dir: str,
+    ) -> subprocess.CompletedProcess:
+        """Execute command inside Docker container.
+
+        Args:
+            env: Environment definition
+            cmd: Command to execute
+            working_dir: Host working directory (for resolving relative volume paths)
+            container_working_dir: Working directory inside container
+
+        Returns:
+            CompletedProcess from subprocess.run
+
+        Raises:
+            DockerError: If docker run fails
+        """
+        # Ensure image is built (returns tag and ID)
+        image_tag, image_id = self.ensure_image_built(env)
+
+        # Build docker run command
+        docker_cmd = ["docker", "run", "--rm"]
+
+        # Add volume mounts
+        for volume in env.volumes:
+            # Resolve volume paths
+            resolved_volume = self._resolve_volume_mount(volume)
+            docker_cmd.extend(["-v", resolved_volume])
+
+        # Add port mappings
+        for port in env.ports:
+            docker_cmd.extend(["-p", port])
+
+        # Add environment variables
+        for var_name, var_value in env.env_vars.items():
+            docker_cmd.extend(["-e", f"{var_name}={var_value}"])
+
+        # Add working directory
+        if container_working_dir:
+            docker_cmd.extend(["-w", container_working_dir])
+
+        # Add image tag
+        docker_cmd.append(image_tag)
+
+        # Add shell and command
+        shell = env.shell or "sh"
+        docker_cmd.extend([shell, "-c", cmd])
+
+        # Execute
+        try:
+            result = subprocess.run(
+                docker_cmd,
+                cwd=working_dir,
+                check=True,
+                capture_output=False,  # Stream output to terminal
+            )
+            return result
+        except subprocess.CalledProcessError as e:
+            raise DockerError(
+                f"Docker container execution failed with exit code {e.returncode}"
+            ) from e
+
+    def _resolve_volume_mount(self, volume: str) -> str:
+        """Resolve volume mount specification.
+
+        Handles:
+        - Relative paths (resolved relative to project_root)
+        - Home directory expansion (~)
+        - Absolute paths (used as-is)
+
+        Args:
+            volume: Volume specification (e.g., "./src:/workspace/src" or "~/.cargo:/root/.cargo")
+
+        Returns:
+            Resolved volume specification with absolute host path
+        """
+        if ":" not in volume:
+            raise ValueError(
+                f"Invalid volume specification: '{volume}'. "
+                f"Format should be 'host_path:container_path'"
+            )
+
+        host_path, container_path = volume.split(":", 1)
+
+        # Expand home directory
+        if host_path.startswith("~"):
+            host_path = os.path.expanduser(host_path)
+            resolved_host_path = Path(host_path)
+        # Resolve relative paths
+        elif not Path(host_path).is_absolute():
+            resolved_host_path = self._project_root / host_path
+        # Absolute paths used as-is
+        else:
+            resolved_host_path = Path(host_path)
+
+        return f"{resolved_host_path}:{container_path}"
+
+    def _check_docker_available(self) -> None:
+        """Check if docker command is available.
+
+        Raises:
+            DockerError: If docker is not available
+        """
+        try:
+            subprocess.run(
+                ["docker", "--version"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            raise DockerError(
+                "Docker is not available. Please install Docker and ensure it's running.\n"
+                "Visit https://docs.docker.com/get-docker/ for installation instructions."
+            )
+
+    def _get_image_id(self, image_tag: str) -> str:
+        """Get the full image ID for a given tag.
+
+        Args:
+            image_tag: Docker image tag (e.g., "tt-env-builder")
+
+        Returns:
+            Full image ID (e.g., "sha256:abc123def456...")
+
+        Raises:
+            DockerError: If cannot inspect image
+        """
+        try:
+            result = subprocess.run(
+                ["docker", "inspect", "--format={{.Id}}", image_tag],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            image_id = result.stdout.strip()
+            return image_id
+        except subprocess.CalledProcessError as e:
+            raise DockerError(f"Failed to inspect image {image_tag}: {e.stderr}")
+
+
+def is_docker_environment(env: Environment) -> bool:
+    """Check if environment is Docker-based.
+
+    Args:
+        env: Environment to check
+
+    Returns:
+        True if environment has a dockerfile field, False otherwise
+    """
+    return bool(env.dockerfile)
+
+
+def resolve_container_working_dir(
+    env_working_dir: str, task_working_dir: str
+) -> str:
+    """Resolve working directory inside container.
+
+    Combines environment's working_dir with task's working_dir:
+    - If task specifies working_dir: container_dir = env_working_dir / task_working_dir
+    - If task doesn't specify: container_dir = env_working_dir
+    - If neither specify: container_dir = "/" (Docker default)
+
+    Args:
+        env_working_dir: Working directory from environment definition
+        task_working_dir: Working directory from task definition
+
+    Returns:
+        Resolved working directory path
+    """
+    if not env_working_dir and not task_working_dir:
+        return "/"
+
+    if not task_working_dir:
+        return env_working_dir
+
+    # Combine paths
+    if env_working_dir:
+        # Join paths using POSIX separator (works inside Linux containers)
+        return f"{env_working_dir.rstrip('/')}/{task_working_dir.lstrip('/')}"
+    else:
+        return f"/{task_working_dir.lstrip('/')}"
+
+
+def parse_dockerignore(dockerignore_path: Path) -> "pathspec.PathSpec | None":
+    """Parse .dockerignore file into pathspec matcher.
+
+    Args:
+        dockerignore_path: Path to .dockerignore file
+
+    Returns:
+        PathSpec object for matching, or None if file doesn't exist or pathspec not available
+    """
+    if pathspec is None:
+        # pathspec library not available - can't parse .dockerignore
+        return None
+
+    if not dockerignore_path.exists():
+        return pathspec.PathSpec([])  # Empty matcher
+
+    try:
+        with open(dockerignore_path, "r") as f:
+            spec = pathspec.PathSpec.from_lines("gitwildmatch", f)
+        return spec
+    except Exception:
+        # Invalid patterns - return empty matcher rather than failing
+        return pathspec.PathSpec([])
+
+
+def context_changed_since(
+    context_path: Path,
+    dockerignore_path: Path | None,
+    last_run_time: float,
+) -> bool:
+    """Check if any file in Docker build context has changed since last run.
+
+    Uses early-exit optimization: stops on first changed file found.
+
+    Args:
+        context_path: Path to Docker build context directory
+        dockerignore_path: Optional path to .dockerignore file
+        last_run_time: Unix timestamp of last task run
+
+    Returns:
+        True if any file changed, False otherwise
+    """
+    # Parse .dockerignore
+    dockerignore_spec = None
+    if dockerignore_path:
+        dockerignore_spec = parse_dockerignore(dockerignore_path)
+
+    # Walk context directory
+    for file_path in context_path.rglob("*"):
+        if not file_path.is_file():
+            continue
+
+        # Check if file matches .dockerignore patterns
+        if dockerignore_spec:
+            try:
+                relative_path = file_path.relative_to(context_path)
+                if dockerignore_spec.match_file(str(relative_path)):
+                    continue  # Skip ignored files
+            except ValueError:
+                # File not relative to context (shouldn't happen with rglob)
+                continue
+
+        # Check if file changed (early exit)
+        try:
+            if file_path.stat().st_mtime > last_run_time:
+                return True  # Found a changed file
+        except (OSError, FileNotFoundError):
+            # File might have been deleted - consider it changed
+            return True
+
+    return False  # No changes found
+
+
+def extract_from_images(dockerfile_content: str) -> list[tuple[str, str | None]]:
+    """Extract image references from FROM lines in Dockerfile.
+
+    Args:
+        dockerfile_content: Content of Dockerfile
+
+    Returns:
+        List of (image_reference, digest) tuples where digest may be None for unpinned images
+        Example: [("rust:1.75", None), ("rust", "sha256:abc123...")]
+    """
+    # Regex pattern to match FROM lines
+    # Handles: FROM [--platform=...] image[:tag][@digest] [AS alias]
+    from_pattern = re.compile(
+        r"^\s*FROM\s+"  # FROM keyword
+        r"(?:--platform=[^\s]+\s+)?"  # Optional platform flag
+        r"([^\s@]+)"  # Image name (possibly with :tag)
+        r"(?:@(sha256:[a-f0-9]+))?"  # Optional @digest
+        r"(?:\s+AS\s+\w+)?"  # Optional AS alias
+        r"\s*$",
+        re.MULTILINE | re.IGNORECASE,
+    )
+
+    matches = from_pattern.findall(dockerfile_content)
+    return [(image, digest if digest else None) for image, digest in matches]
+
+
+def check_unpinned_images(dockerfile_content: str) -> list[str]:
+    """Check for unpinned base images in Dockerfile.
+
+    Args:
+        dockerfile_content: Content of Dockerfile
+
+    Returns:
+        List of unpinned image references (images without @sha256:... digests)
+    """
+    images = extract_from_images(dockerfile_content)
+    return [image for image, digest in images if digest is None]
+
+
+def parse_base_image_digests(dockerfile_content: str) -> list[str]:
+    """Parse pinned base image digests from Dockerfile.
+
+    Args:
+        dockerfile_content: Content of Dockerfile
+
+    Returns:
+        List of digests (e.g., ["sha256:abc123...", "sha256:def456..."])
+    """
+    images = extract_from_images(dockerfile_content)
+    return [digest for _image, digest in images if digest is not None]

tasktree/executor.py

@@ -13,6 +13,7 @@ from datetime import datetime
 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.hasher import hash_args, hash_task, make_cache_key
 from tasktree.parser import Recipe, Task
@@ -26,7 +27,7 @@ class TaskStatus:
     task_name: str
     will_run: bool
     reason: str  # "fresh", "inputs_changed", "definition_changed",
-    # "never_run", "dependency_triggered", "no_outputs"
+    # "never_run", "no_outputs", "outputs_missing", "forced", "environment_changed"
     changed_files: list[str] = field(default_factory=list)
     last_run: datetime | None = None
 
@@ -49,6 +50,7 @@ class Executor:
         """
         self.recipe = recipe
         self.state = state_manager
+        self.docker_manager = docker_module.DockerManager(recipe.project_root)
 
     def _get_platform_default_environment(self) -> tuple[str, list[str]]:
         """Get default shell and args for current platform.
@@ -133,7 +135,6 @@ class Executor:
         self,
         task: Task,
         args_dict: dict[str, Any],
-        dep_statuses: dict[str, TaskStatus],
         force: bool = False,
     ) -> TaskStatus:
         """Check if a task needs to run.
@@ -141,16 +142,16 @@ class Executor:
         A task executes if ANY of these conditions are met:
         1. Force flag is set (--force)
         2. Task definition hash differs from cached state
-        3. Any explicit inputs have newer mtime than last_run
-        4. Any implicit inputs (from deps) have changed
-        5. No cached state exists for this task+args combination
-        6. Task has no inputs AND no outputs (always runs)
-        7. Different arguments than any cached execution
+        3. Environment definition has changed
+        4. Any explicit inputs have newer mtime than last_run
+        5. Any implicit inputs (from deps) have changed
+        6. No cached state exists for this task+args combination
+        7. Task has no inputs AND no outputs (always runs)
+        8. Different arguments than any cached execution
 
         Args:
             task: Task to check
             args_dict: Arguments for this task execution
-            dep_statuses: Status of dependencies
             force: If True, ignore freshness and force execution
 
         Returns:
@@ -179,21 +180,23 @@ class Executor:
                 reason="no_outputs",
             )
 
-        # Check if any dependency triggered
-        if any(status.will_run for status in dep_statuses.values()):
+        # Check cached state
+        cached_state = self.state.get(cache_key)
+        if cached_state is None:
             return TaskStatus(
                 task_name=task.name,
                 will_run=True,
-                reason="dependency_triggered",
+                reason="never_run",
             )
 
-        # Check cached state
-        cached_state = self.state.get(cache_key)
-        if cached_state is None:
+        # Check if environment definition has changed
+        env_changed = self._check_environment_changed(task, cached_state, effective_env)
+        if env_changed:
             return TaskStatus(
                 task_name=task.name,
                 will_run=True,
-                reason="never_run",
+                reason="environment_changed",
+                last_run=datetime.fromtimestamp(cached_state.last_run),
             )
 
         # Check if inputs have changed
@@ -262,23 +265,19 @@ class Executor:
             # Execute task and all dependencies
             execution_order = resolve_execution_order(self.recipe, task_name)
 
-        # Check status of all tasks
+        # Single phase: Check and execute incrementally
         statuses: dict[str, TaskStatus] = {}
         for name in execution_order:
             task = self.recipe.tasks[name]
 
-            # Get status of dependencies
-            dep_statuses = {dep: statuses[dep] for dep in task.deps if dep in statuses}
-
             # Determine task-specific args (only for target task)
             task_args = args_dict if name == task_name else {}
 
-            status = self.check_task_status(task, task_args, dep_statuses, force=force)
+            # Check if task needs to run (based on CURRENT filesystem state)
+            status = self.check_task_status(task, task_args, force=force)
             statuses[name] = status
 
-        # Execute tasks that need to run
-        for name in execution_order:
-            status = statuses[name]
+            # Execute immediately if needed
             if status.will_run:
                 # Warn if re-running due to missing outputs
                 if status.reason == "outputs_missing":
@@ -288,8 +287,6 @@ class Executor:
                         file=sys.stderr,
                     )
 
-                task = self.recipe.tasks[name]
-                task_args = args_dict if name == task_name else {}
                 self._run_task(task, task_args)
 
         return statuses
@@ -310,17 +307,28 @@ class Executor:
         # Determine working directory
         working_dir = self.recipe.project_root / task.working_dir
 
-        # Resolve environment for this task
-        shell, shell_args, preamble = self._resolve_environment(task)
+        # Check if task uses Docker environment
+        env_name = self._get_effective_env_name(task)
+        env = None
+        if env_name:
+            env = self.recipe.get_environment(env_name)
 
         # Execute command
         print(f"Running: {task.name}")
 
-        # Detect multi-line commands (ignore trailing newlines from YAML folded blocks)
-        if "\n" in cmd.rstrip():
-            self._run_multiline_command(cmd, working_dir, task.name, shell, preamble)
+        # Route to Docker execution or regular execution
+        if env and env.dockerfile:
+            # Docker execution path
+            self._run_task_in_docker(task, env, cmd, working_dir)
         else:
-            self._run_single_line_command(cmd, working_dir, task.name, shell, shell_args)
+            # Regular execution path
+            shell, shell_args, preamble = self._resolve_environment(task)
+
+            # Detect multi-line commands (ignore trailing newlines from YAML folded blocks)
+            if "\n" in cmd.rstrip():
+                self._run_multiline_command(cmd, working_dir, task.name, shell, preamble)
+            else:
+                self._run_single_line_command(cmd, working_dir, task.name, shell, shell_args)
 
         # Update state
         self._update_state(task, args_dict)
@@ -421,6 +429,36 @@ class Executor:
             except OSError:
                 pass  # Ignore cleanup errors
 
+    def _run_task_in_docker(
+        self, task: Task, env: Any, cmd: str, working_dir: Path
+    ) -> None:
+        """Execute task inside Docker container.
+
+        Args:
+            task: Task to execute
+            env: Docker environment configuration
+            cmd: Command to execute
+            working_dir: Host working directory
+
+        Raises:
+            ExecutionError: If Docker execution fails
+        """
+        # Resolve container working directory
+        container_working_dir = docker_module.resolve_container_working_dir(
+            env.working_dir, task.working_dir
+        )
+
+        # Execute in container
+        try:
+            self.docker_manager.run_in_container(
+                env=env,
+                cmd=cmd,
+                working_dir=working_dir,
+                container_working_dir=container_working_dir,
+            )
+        except docker_module.DockerError as e:
+            raise ExecutionError(str(e)) from e
+
     def _substitute_args(self, cmd: str, args_dict: dict[str, Any]) -> str:
         """Substitute arguments in command string.
 
@@ -451,11 +489,100 @@ class Executor:
         all_inputs.extend(implicit_inputs)
         return all_inputs
 
+    def _check_environment_changed(
+        self, task: Task, cached_state: TaskState, env_name: str
+    ) -> bool:
+        """Check if environment definition has changed since last run.
+
+        For shell environments: checks YAML definition hash
+        For Docker environments: checks YAML hash AND Docker image ID
+
+        Args:
+            task: Task to check
+            cached_state: Cached state from previous run
+            env_name: Effective environment name (from _get_effective_env_name)
+
+        Returns:
+            True if environment definition changed, False otherwise
+        """
+        # If using platform default (no environment), no definition to track
+        if not env_name:
+            return False
+
+        # Get environment definition
+        env = self.recipe.get_environment(env_name)
+        if env is None:
+            # Environment was deleted - treat as changed
+            return True
+
+        # Compute current environment hash (YAML definition)
+        from tasktree.hasher import hash_environment_definition
+
+        current_env_hash = hash_environment_definition(env)
+
+        # Get cached environment hash
+        marker_key = f"_env_hash_{env_name}"
+        cached_env_hash = cached_state.input_state.get(marker_key)
+
+        # If no cached hash (old state file), treat as changed to establish baseline
+        if cached_env_hash is None:
+            return True
+
+        # Check if YAML definition changed
+        if current_env_hash != cached_env_hash:
+            return True  # YAML changed, no need to check image
+
+        # For Docker environments, also check if image ID changed
+        if env.dockerfile:
+            return self._check_docker_image_changed(env, cached_state, env_name)
+
+        # Shell environment with unchanged hash
+        return False
+
+    def _check_docker_image_changed(
+        self, env: Environment, cached_state: TaskState, env_name: str
+    ) -> bool:
+        """Check if Docker image ID has changed.
+
+        Builds the image and compares the resulting image ID with the cached ID.
+        This detects changes from unpinned base images, network-dependent builds, etc.
+
+        Args:
+            env: Docker environment definition
+            cached_state: Cached state from previous run
+            env_name: Environment name
+
+        Returns:
+            True if image ID changed, False otherwise
+        """
+        # Build/ensure image is built and get its ID
+        try:
+            image_tag, current_image_id = self.docker_manager.ensure_image_built(env)
+        except Exception as e:
+            # If we can't build, treat as changed (will fail later with better error)
+            return True
+
+        # Get cached image ID
+        image_id_key = f"_docker_image_id_{env_name}"
+        cached_image_id = cached_state.input_state.get(image_id_key)
+
+        # If no cached ID (first run or old state), treat as changed
+        if cached_image_id is None:
+            return True
+
+        # Compare image IDs
+        return current_image_id != cached_image_id
+
     def _check_inputs_changed(
         self, task: Task, cached_state: TaskState, all_inputs: list[str]
     ) -> list[str]:
         """Check if any input files have changed since last run.
 
+        Handles both regular file inputs and Docker-specific inputs:
+        - Regular files: checked via mtime
+        - Docker context: checked via directory walk with early exit
+        - Dockerfile digests: checked via parsing and comparison
+
         Args:
             task: Task to check
             cached_state: Cached state from previous run
@@ -469,7 +596,66 @@ class Executor:
         # Expand glob patterns
         input_files = self._expand_globs(all_inputs, task.working_dir)
 
+        # Check if task uses Docker environment
+        env_name = self._get_effective_env_name(task)
+        docker_env = None
+        if env_name:
+            docker_env = self.recipe.get_environment(env_name)
+            if docker_env and not docker_env.dockerfile:
+                docker_env = None  # Not a Docker environment
+
         for file_path in input_files:
+            # Handle Docker context directory check
+            if file_path.startswith("_docker_context_"):
+                if docker_env:
+                    context_name = file_path.replace("_docker_context_", "")
+                    context_path = self.recipe.project_root / context_name
+                    dockerignore_path = context_path / ".dockerignore"
+
+                    # Get last context check time
+                    cached_context_time = cached_state.input_state.get(
+                        f"_context_{context_name}"
+                    )
+                    if cached_context_time is None:
+                        # Never checked before - consider changed
+                        changed_files.append(f"Docker context: {context_name}")
+                        continue
+
+                    # Check if context changed (with early exit optimization)
+                    if docker_module.context_changed_since(
+                        context_path, dockerignore_path, cached_context_time
+                    ):
+                        changed_files.append(f"Docker context: {context_name}")
+                continue
+
+            # Handle Docker Dockerfile digest check
+            if file_path.startswith("_docker_dockerfile_"):
+                if docker_env:
+                    dockerfile_name = file_path.replace("_docker_dockerfile_", "")
+                    dockerfile_path = self.recipe.project_root / dockerfile_name
+
+                    try:
+                        dockerfile_content = dockerfile_path.read_text()
+                        current_digests = set(
+                            docker_module.parse_base_image_digests(dockerfile_content)
+                        )
+
+                        # Get cached digests
+                        cached_digests = set()
+                        for key in cached_state.input_state:
+                            if key.startswith("_digest_"):
+                                digest = key.replace("_digest_", "")
+                                cached_digests.add(digest)
+
+                        # Check if digests changed
+                        if current_digests != cached_digests:
+                            changed_files.append(f"Docker base image digests in {dockerfile_name}")
+                    except (OSError, IOError):
+                        # Can't read Dockerfile - consider changed
+                        changed_files.append(f"Dockerfile: {dockerfile_name}")
+                continue
+
+            # Regular file check
             file_path_obj = self.recipe.project_root / task.working_dir / file_path
             if not file_path_obj.exists():
                 continue
@@ -549,10 +735,61 @@ class Executor:
 
         input_state = {}
         for file_path in input_files:
+            # Skip Docker special markers (handled separately below)
+            if file_path.startswith("_docker_"):
+                continue
+
             file_path_obj = self.recipe.project_root / task.working_dir / file_path
             if file_path_obj.exists():
                 input_state[file_path] = file_path_obj.stat().st_mtime
 
+        # Record Docker-specific inputs if task uses Docker environment
+        env_name = self._get_effective_env_name(task)
+        if env_name:
+            env = self.recipe.get_environment(env_name)
+            if env and env.dockerfile:
+                # Record Dockerfile mtime
+                dockerfile_path = self.recipe.project_root / env.dockerfile
+                if dockerfile_path.exists():
+                    input_state[env.dockerfile] = dockerfile_path.stat().st_mtime
+
+                # Record .dockerignore mtime if exists
+                context_path = self.recipe.project_root / env.context
+                dockerignore_path = context_path / ".dockerignore"
+                if dockerignore_path.exists():
+                    relative_dockerignore = str(
+                        dockerignore_path.relative_to(self.recipe.project_root)
+                    )
+                    input_state[relative_dockerignore] = dockerignore_path.stat().st_mtime
+
+                # Record context check timestamp
+                input_state[f"_context_{env.context}"] = time.time()
+
+                # Parse and record base image digests from Dockerfile
+                try:
+                    dockerfile_content = dockerfile_path.read_text()
+                    digests = docker_module.parse_base_image_digests(dockerfile_content)
+                    for digest in digests:
+                        # Store digest with Dockerfile's mtime
+                        input_state[f"_digest_{digest}"] = dockerfile_path.stat().st_mtime
+                except (OSError, IOError):
+                    # If we can't read Dockerfile, skip digest tracking
+                    pass
+
+            # Record environment definition hash for all environments (shell and Docker)
+            if env:
+                from tasktree.hasher import hash_environment_definition
+
+                env_hash = hash_environment_definition(env)
+                input_state[f"_env_hash_{env_name}"] = env_hash
+
+                # For Docker environments, also store the image ID
+                if env.dockerfile:
+                    # Image was already built during check phase or task execution
+                    if env_name in self.docker_manager._built_images:
+                        image_tag, image_id = self.docker_manager._built_images[env_name]
+                        input_state[f"_docker_image_id_{env_name}"] = image_id
+
         # Create new state
         state = TaskState(
             last_run=time.time(),

tasktree/graph.py

@@ -1,6 +1,7 @@
 """Dependency resolution using topological sorting."""
 
 from graphlib import TopologicalSorter
+from pathlib import Path
 
 from tasktree.parser import Recipe, Task
 
@@ -71,16 +72,21 @@ def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
     Tasks automatically inherit inputs from dependencies:
     1. All outputs from dependency tasks become implicit inputs
     2. All inputs from dependency tasks that don't declare outputs are inherited
+    3. If task uses a Docker environment, Docker artifacts become implicit inputs:
+       - Dockerfile
+       - .dockerignore (if present)
+       - Special markers for context directory and base image digests
 
     Args:
         recipe: Parsed recipe containing all tasks
         task: Task to get implicit inputs for
 
     Returns:
-        List of glob patterns for implicit inputs
+        List of glob patterns for implicit inputs, including Docker-specific markers
     """
     implicit_inputs = []
 
+    # Inherit from dependencies
     for dep_name in task.deps:
         dep_task = recipe.tasks.get(dep_name)
         if dep_task is None:
@@ -93,6 +99,29 @@ def get_implicit_inputs(recipe: Recipe, task: Task) -> list[str]:
         elif dep_task.inputs:
             implicit_inputs.extend(dep_task.inputs)
 
+    # Add Docker-specific implicit inputs if task uses Docker environment
+    env_name = task.env or recipe.default_env
+    if env_name:
+        env = recipe.get_environment(env_name)
+        if env and env.dockerfile:
+            # Add Dockerfile as input
+            implicit_inputs.append(env.dockerfile)
+
+            # Add .dockerignore if it exists in context directory
+            context_path = recipe.project_root / env.context
+            dockerignore_path = context_path / ".dockerignore"
+            if dockerignore_path.exists():
+                relative_dockerignore = str(
+                    dockerignore_path.relative_to(recipe.project_root)
+                )
+                implicit_inputs.append(relative_dockerignore)
+
+            # Add special markers for context directory and digest tracking
+            # These are tracked differently in state management (not file paths)
+            # The executor will handle these specially
+            implicit_inputs.append(f"_docker_context_{env.context}")
+            implicit_inputs.append(f"_docker_dockerfile_{env.dockerfile}")
+
     return implicit_inputs
 
 

tasktree/hasher.py

@@ -21,6 +21,33 @@ def hash_args(args_dict: dict[str, Any]) -> str:
     return hashlib.sha256(serialized.encode()).hexdigest()[:8]
 
 
+def hash_environment_definition(env) -> str:
+    """Hash environment definition fields that affect task execution.
+
+    Args:
+        env: Environment to hash
+
+    Returns:
+        16-character hash of environment definition
+    """
+    # Import inside function to avoid circular dependency
+    from tasktree.parser import Environment
+
+    data = {
+        "shell": env.shell,
+        "args": sorted(env.args),  # Sort for determinism
+        "preamble": env.preamble,
+        "dockerfile": env.dockerfile,
+        "context": env.context,
+        "volumes": sorted(env.volumes),
+        "ports": sorted(env.ports),
+        "env_vars": dict(sorted(env.env_vars.items())),
+        "working_dir": env.working_dir,
+    }
+    serialized = json.dumps(data, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(serialized.encode()).hexdigest()[:16]
+
+
 def make_cache_key(task_hash: str, args_hash: Optional[str] = None) -> str:
     if args_hash:
         return f"{task_hash}__{args_hash}"

tasktree/parser.py

@@ -16,12 +16,24 @@ class CircularImportError(Exception):
 
 @dataclass
 class Environment:
-    """Represents an execution environment configuration."""
+    """Represents an execution environment configuration.
+
+    Can be either a shell environment or a Docker environment:
+    - Shell environment: has 'shell' field, executes directly on host
+    - Docker environment: has 'dockerfile' field, executes in container
+    """
 
     name: str
-    shell: str
+    shell: str = ""  # Path to shell (required for shell envs, optional for Docker)
     args: list[str] = field(default_factory=list)
     preamble: str = ""
+    # Docker-specific fields (presence of dockerfile indicates Docker environment)
+    dockerfile: str = ""  # Path to Dockerfile
+    context: str = ""  # Path to build context directory
+    volumes: list[str] = field(default_factory=list)  # Volume mounts
+    ports: list[str] = field(default_factory=list)  # Port mappings
+    env_vars: dict[str, str] = field(default_factory=dict)  # Environment variables
+    working_dir: str = ""  # Working directory (container or host)
 
     def __post_init__(self):
         """Ensure args is always a list."""
@@ -201,18 +213,71 @@ def _parse_file_with_env(
                             f"Environment '{env_name}' must be a dictionary"
                         )
 
-                    # Parse environment configuration
+                    # Parse common environment configuration
                     shell = env_config.get("shell", "")
-                    if not shell:
+                    args = env_config.get("args", [])
+                    preamble = env_config.get("preamble", "")
+                    working_dir = env_config.get("working_dir", "")
+
+                    # Parse Docker-specific fields
+                    dockerfile = env_config.get("dockerfile", "")
+                    context = env_config.get("context", "")
+                    volumes = env_config.get("volumes", [])
+                    ports = env_config.get("ports", [])
+                    env_vars = env_config.get("env_vars", {})
+
+                    # Validate environment type
+                    if not shell and not dockerfile:
                         raise ValueError(
-                            f"Environment '{env_name}' must specify 'shell'"
+                            f"Environment '{env_name}' must specify either 'shell' "
+                            f"(for shell environments) or 'dockerfile' (for Docker environments)"
                         )
 
-                    args = env_config.get("args", [])
-                    preamble = env_config.get("preamble", "")
+                    # Validate Docker environment requirements
+                    if dockerfile and not context:
+                        raise ValueError(
+                            f"Docker environment '{env_name}' must specify 'context' "
+                            f"when 'dockerfile' is specified"
+                        )
+
+                    # Validate that Dockerfile exists if specified
+                    if dockerfile:
+                        dockerfile_path = project_root / dockerfile
+                        if not dockerfile_path.exists():
+                            raise ValueError(
+                                f"Environment '{env_name}': Dockerfile not found at {dockerfile_path}"
+                            )
+
+                    # Validate that context directory exists if specified
+                    if context:
+                        context_path = project_root / context
+                        if not context_path.exists():
+                            raise ValueError(
+                                f"Environment '{env_name}': context directory not found at {context_path}"
+                            )
+                        if not context_path.is_dir():
+                            raise ValueError(
+                                f"Environment '{env_name}': context must be a directory, got {context_path}"
+                            )
+
+                    # Validate environment name (must be valid Docker tag)
+                    if not env_name.replace("-", "").replace("_", "").isalnum():
+                        raise ValueError(
+                            f"Environment name '{env_name}' must be alphanumeric "
+                            f"(with optional hyphens and underscores)"
+                        )
 
                     environments[env_name] = Environment(
-                        name=env_name, shell=shell, args=args, preamble=preamble
+                        name=env_name,
+                        shell=shell,
+                        args=args,
+                        preamble=preamble,
+                        dockerfile=dockerfile,
+                        context=context,
+                        volumes=volumes,
+                        ports=ports,
+                        env_vars=env_vars,
+                        working_dir=working_dir,
                     )
 
     return tasks, environments, default_env
@@ -425,6 +490,7 @@ def _parse_file(
             working_dir=working_dir,
             args=task_data.get("args", []),
             source_file=str(file_path),
+            env=task_data.get("env", ""),
         )
 
         tasks[full_name] = task

tasktree/state.py

@@ -13,7 +13,7 @@ class TaskState:
     """State for a single task execution."""
 
     last_run: float
-    input_state: dict[str, float] = field(default_factory=dict)
+    input_state: dict[str, float | str] = field(default_factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""

{tasktree-0.0.6.dist-info → tasktree-0.0.7.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.6
+Version: 0.0.7
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
 Requires-Dist: colorama>=0.4.6
+Requires-Dist: pathspec>=0.11.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.9.0
@@ -108,52 +109,6 @@ Boom! Done. `build` will always run, because there's no sensible way to know wha
 
 This is a toy example, but you can image how it plays out on a more complex project.
 
-## Migrating from v1.x to v2.0
-
-Version 2.0 requires all task definitions to be under a top-level `tasks:` key.
-
-### Quick Migration
-
-Wrap your existing tasks in a `tasks:` block:
-
-```yaml
-# Before (v1.x)
-build:
-  cmd: cargo build
-
-# After (v2.0)
-tasks:
-  build:
-    cmd: cargo build
-```
-
-### Why This Change?
-
-1. **Clearer structure**: Explicit separation of tasks from configuration
-2. **No naming conflicts**: You can now create tasks named "imports" or "environments"
-3. **Better error messages**: More helpful validation errors
-4. **Consistency**: All recipe files use the same format
-
-### Error Messages
-
-If you forget to update, you'll see a clear error:
-
-```
-Invalid recipe format in tasktree.yaml
-
-Task definitions must be under a top-level "tasks:" key.
-
-Found these keys at root level: build, test
-
-Did you mean:
-
-tasks:
-  build:
-    cmd: ...
-  test:
-    cmd: ...
-```
-
 ## Installation
 
 ### From PyPI (Recommended)

tasktree-0.0.7.dist-info/RECORD

@@ -0,0 +1,14 @@
+tasktree/__init__.py,sha256=MVmdvKb3JdqLlo0x2_TPGMfgFC0HsDnP79HAzGnFnjI,1081
+tasktree/cli.py,sha256=0xusNitT1AtLgR3guUsupnHSXJ0_C749Dx7dfYCENJA,15233
+tasktree/docker.py,sha256=duIT5HkGBvLNOPdbgdXuqqUSwJgdWsb4Sxv_HVm8hzA,13118
+tasktree/executor.py,sha256=8xNKPYkekhaGd_gCO7PT7E-n0JeHVtDgIbxACuvPUzU,28707
+tasktree/graph.py,sha256=lA3ExNM_ag0AlC6iW20unseCjRg5wCZXbmXs2M6TnQw,5578
+tasktree/hasher.py,sha256=dCyakihE4rHoOVCbt8hgTQZVuez3P1V0SrWUl-aM2Tw,1670
+tasktree/parser.py,sha256=gkbzlTOwudJsU5gvgSCpVVY2GoYZlo_kLBVsIRbeZiU,19076
+tasktree/state.py,sha256=Cktl4D8iDZVd55aO2LqVyPrc-BnljkesxxkcMcdcfOY,3541
+tasktree/tasks.py,sha256=2QdQZtJAX2rSGbyXKG1z9VF_siz1DUzdvzCgPkykxtU,173
+tasktree/types.py,sha256=w--sKjRTc8mGYkU5eAduqV86SolDqOYspAPuVKIuSQQ,3797
+tasktree-0.0.7.dist-info/METADATA,sha256=YthtlFiUCaHTgO8n5jUsiJQ3py4pQ23_Zh3Ycshi4fk,17439
+tasktree-0.0.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tasktree-0.0.7.dist-info/entry_points.txt,sha256=lQINlvRYnimvteBbnhH84A9clTg8NnpEjCWqWkqg8KE,40
+tasktree-0.0.7.dist-info/RECORD,,

tasktree-0.0.6.dist-info/RECORD

@@ -1,13 +0,0 @@
-tasktree/__init__.py,sha256=MVmdvKb3JdqLlo0x2_TPGMfgFC0HsDnP79HAzGnFnjI,1081
-tasktree/cli.py,sha256=0xusNitT1AtLgR3guUsupnHSXJ0_C749Dx7dfYCENJA,15233
-tasktree/executor.py,sha256=_E37tShHuiOj0Mvx2GbS9y3GIozC3hpzAVhAjbvYJqg,18638
-tasktree/graph.py,sha256=9ngfg93y7EkOIN_lUQa0u-JhnwiMN1UdQQvIFw8RYCE,4181
-tasktree/hasher.py,sha256=puJey9wF_p37k_xqjhYr_6ICsbAfrTBWHec6MqKV4BU,814
-tasktree/parser.py,sha256=SzWn-V4KMgjxNZrN0ERApb5dd39LPJTfkA2Ih2nYWcs,15580
-tasktree/state.py,sha256=rxKtS3SbsPtAuraHbN807RGWfoYYkQ3pe8CxUstwo2k,3535
-tasktree/tasks.py,sha256=2QdQZtJAX2rSGbyXKG1z9VF_siz1DUzdvzCgPkykxtU,173
-tasktree/types.py,sha256=w--sKjRTc8mGYkU5eAduqV86SolDqOYspAPuVKIuSQQ,3797
-tasktree-0.0.6.dist-info/METADATA,sha256=GQZHcFVOIXfWmgPbb9pAt7zB0iH22hyGToc0YEwUv34,18287
-tasktree-0.0.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tasktree-0.0.6.dist-info/entry_points.txt,sha256=lQINlvRYnimvteBbnhH84A9clTg8NnpEjCWqWkqg8KE,40
-tasktree-0.0.6.dist-info/RECORD,,