tasktree 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

tasktree/cli.py

@@ -1,8 +1,5 @@
-"""Command-line interface for Task Tree."""
-
 from __future__ import annotations
 
-import sys
 from pathlib import Path
 from typing import Any, List, Optional
 
@@ -124,23 +121,24 @@ def _init_recipe():
 
 # Example task definitions:
 
-# build:
-#   desc: Compile the application
-#   outputs: [target/release/bin]
-#   cmd: cargo build --release
-
-# test:
-#   desc: Run tests
-#   deps: [build]
-#   cmd: cargo test
-
-# deploy:
-#   desc: Deploy to environment
-#   deps: [build]
-#   args: [environment, region=eu-west-1]
-#   cmd: |
-#     echo "Deploying to {{environment}} in {{region}}"
-#     ./deploy.sh {{environment}} {{region}}
+tasks:
+  # build:
+  #   desc: Compile the application
+  #   outputs: [target/release/bin]
+  #   cmd: cargo build --release
+
+  # test:
+  #   desc: Run tests
+  #   deps: [build]
+  #   cmd: cargo test
+
+  # deploy:
+  #   desc: Deploy to environment
+  #   deps: [build]
+  #   args: [environment, region=eu-west-1]
+  #   cmd: |
+  #     echo "Deploying to {{environment}} in {{region}}"
+  #     ./deploy.sh {{environment}} {{region}}
 
 # Uncomment and modify the examples above to define your tasks
 """
@@ -168,22 +166,20 @@ def main(
         is_eager=True,
         help="Show version and exit",
     ),
-    list_tasks: Optional[bool] = typer.Option(
-        None, "--list", "-l", help="List all available tasks"
-    ),
-    show: Optional[str] = typer.Option(None, "--show", help="Show task definition"),
-    tree: Optional[str] = typer.Option(None, "--tree", help="Show dependency tree"),
+    list_opt: Optional[bool] = typer.Option(None, "--list", "-l", help="List all available tasks"),
+    show: Optional[str] = typer.Option(None, "--show", "-s", help="Show task definition"),
+    tree: Optional[str] = typer.Option(None, "--tree", "-t", help="Show dependency tree"),
     init: Optional[bool] = typer.Option(
-        None, "--init", help="Create a blank tasktree.yaml"
+        None, "--init", "-i", help="Create a blank tasktree.yaml"
     ),
     clean: Optional[bool] = typer.Option(
-        None, "--clean", help="Remove state file (reset task cache)"
+        None, "--clean", "-c", help="Remove state file (reset task cache)"
     ),
     clean_state: Optional[bool] = typer.Option(
-        None, "--clean-state", help="Remove state file (reset task cache)"
+        None, "--clean-state", "-C", help="Remove state file (reset task cache)"
     ),
     reset: Optional[bool] = typer.Option(
-        None, "--reset", help="Remove state file (reset task cache)"
+        None, "--reset", "-r", help="Remove state file (reset task cache)"
     ),
     force: Optional[bool] = typer.Option(
         None, "--force", "-f", help="Force re-run all tasks (ignore freshness)"
@@ -210,38 +206,32 @@ def main(
       tt --list                    # List all tasks
       tt --tree test               # Show dependency tree for 'test'
     """
-    # Handle list option
-    if list_tasks:
+
+    if list_opt:
         _list_tasks()
         raise typer.Exit()
 
-    # Handle show option
     if show:
         _show_task(show)
         raise typer.Exit()
 
-    # Handle tree option
     if tree:
         _show_tree(tree)
         raise typer.Exit()
 
-    # Handle init option
     if init:
         _init_recipe()
         raise typer.Exit()
 
-    # Handle clean options (all three aliases)
     if clean or clean_state or reset:
         _clean_state()
         raise typer.Exit()
 
-    # Handle task execution
     if task_args:
-        # When --only is specified, force execution (--only implies --force)
+        # --only implies --force
         force_execution = force or only or False
         _execute_dynamic_task(task_args, force=force_execution, only=only or False, env=env)
     else:
-        # No arguments - show available tasks
         recipe = _get_recipe()
         if recipe is None:
             console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
@@ -274,7 +264,7 @@ def _clean_state() -> None:
         console.print(f"[yellow]No state file found at {state_path}[/yellow]")
 
 
-def _get_recipe() -> Recipe | None:
+def _get_recipe() -> Optional[Recipe]:
     """Get parsed recipe or None if not found."""
     recipe_path = find_recipe_file()
     if recipe_path is None:
@@ -287,15 +277,7 @@ def _get_recipe() -> Recipe | None:
         raise typer.Exit(1)
 
 
-def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = False, env: str | None = None) -> None:
-    """Execute a task specified by name with arguments.
-
-    Args:
-        args: Command line arguments (task name and task arguments)
-        force: If True, ignore freshness and re-run all tasks
-        only: If True, run only the specified task without dependencies
-        env: If provided, override environment for all tasks
-    """
+def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = False, env: Optional[str] = None) -> None:
     if not args:
         return
 
@@ -350,31 +332,17 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
 
 
 def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, Any]:
-    """Parse command line arguments for a task.
-
-    Args:
-        arg_specs: Argument specifications from task definition
-        arg_values: Command line argument values
-
-    Returns:
-        Dictionary of argument names to values
-
-    Raises:
-        typer.Exit: If arguments are invalid
-    """
     if not arg_specs:
         if arg_values:
             console.print(f"[red]Task does not accept arguments[/red]")
             raise typer.Exit(1)
         return {}
 
-    # Parse argument specifications
     parsed_specs = []
     for spec in arg_specs:
         name, arg_type, default = parse_arg_spec(spec)
         parsed_specs.append((name, arg_type, default))
 
-    # Build argument dictionary
     args_dict = {}
     positional_index = 0
 
@@ -424,14 +392,6 @@ def _parse_task_args(arg_specs: list[str], arg_values: list[str]) -> dict[str, A
 
 
 def _build_rich_tree(dep_tree: dict) -> Tree:
-    """Build a Rich Tree from dependency tree structure.
-
-    Args:
-        dep_tree: Dependency tree structure
-
-    Returns:
-        Rich Tree for display
-    """
     task_name = dep_tree["name"]
     tree = Tree(task_name)
 

tasktree/hasher.py

@@ -1,77 +1,27 @@
-"""Hashing logic for tasks and arguments."""
-
 import hashlib
 import json
-from typing import Any
+from typing import Any, Optional
 
 
 def hash_task(cmd: str, outputs: list[str], working_dir: str, args: list[str], env: str = "") -> str:
-    """Compute task definition hash.
-
-    The hash includes:
-    - cmd: The command to execute
-    - outputs: Declared output files
-    - working_dir: Execution directory
-    - args: Parameter definitions (names and types)
-    - env: Environment name (effective environment after resolution)
-
-    The hash excludes:
-    - deps: Only affects scheduling order
-    - inputs: Tracked separately via timestamps
-    - desc: Documentation only
-
-    Args:
-        cmd: Command to execute
-        outputs: List of output glob patterns
-        working_dir: Working directory for execution
-        args: List of argument definitions
-        env: Environment name (empty string for platform default)
-
-    Returns:
-        8-character hex hash string
-    """
-    # Create a stable representation
     data = {
         "cmd": cmd,
-        "outputs": sorted(outputs),  # Sort for stability
+        "outputs": sorted(outputs),
         "working_dir": working_dir,
-        "args": sorted(args),  # Sort for stability
-        "env": env,  # Include effective environment
+        "args": sorted(args),
+        "env": env,
     }
 
-    # Serialize to JSON with sorted keys for deterministic hashing
     serialized = json.dumps(data, sort_keys=True, separators=(",", ":"))
-
-    # Compute hash and truncate to 8 characters
     return hashlib.sha256(serialized.encode()).hexdigest()[:8]
 
 
 def hash_args(args_dict: dict[str, Any]) -> str:
-    """Compute hash of task arguments.
-
-    Args:
-        args_dict: Dictionary of argument names to values
-
-    Returns:
-        8-character hex hash string
-    """
-    # Serialize arguments to JSON with sorted keys for deterministic hashing
     serialized = json.dumps(args_dict, sort_keys=True, separators=(",", ":"))
-
-    # Compute hash and truncate to 8 characters
     return hashlib.sha256(serialized.encode()).hexdigest()[:8]
 
 
-def make_cache_key(task_hash: str, args_hash: str | None = None) -> str:
-    """Create cache key for task execution.
-
-    Args:
-        task_hash: Task definition hash
-        args_hash: Optional arguments hash
-
-    Returns:
-        Cache key string (task_hash or task_hash__args_hash)
-    """
+def make_cache_key(task_hash: str, args_hash: Optional[str] = None) -> str:
     if args_hash:
         return f"{task_hash}__{args_hash}"
     return task_hash

tasktree/parser.py

@@ -270,7 +270,7 @@ def _parse_file(
     local_import_namespaces: set[str] = set()
 
     # Process nested imports FIRST
-    imports = data.get("import", [])
+    imports = data.get("imports", [])
     if imports:
         for import_spec in imports:
             child_file = import_spec["file"]
@@ -297,15 +297,49 @@ def _parse_file(
 
             tasks.update(nested_tasks)
 
-    # Determine where tasks are defined
-    # Tasks can be either at root level OR inside a "tasks:" key
-    tasks_data = data.get("tasks", data) if "tasks" in data else data
+    # Validate top-level keys (only imports, environments, and tasks are allowed)
+    VALID_TOP_LEVEL_KEYS = {"imports", "environments", "tasks"}
+
+    # Check if tasks key is missing when there appear to be task definitions at root
+    # Do this BEFORE checking for unknown keys, to provide better error message
+    if "tasks" not in data and data:
+        # Check if there are potential task definitions at root level
+        potential_tasks = [
+            k for k, v in data.items()
+            if isinstance(v, dict) and k not in VALID_TOP_LEVEL_KEYS
+        ]
+
+        if potential_tasks:
+            raise ValueError(
+                f"Invalid recipe format in {file_path}\n\n"
+                f"Task definitions must be under a top-level 'tasks:' key.\n\n"
+                f"Found these keys at root level: {', '.join(potential_tasks)}\n\n"
+                f"Did you mean:\n\n"
+                f"tasks:\n"
+                + '\n'.join(f"  {k}:" for k in potential_tasks) +
+                "\n    cmd: ...\n\n"
+                f"Valid top-level keys are: {', '.join(sorted(VALID_TOP_LEVEL_KEYS))}"
+            )
+
+    # Now check for other invalid top-level keys (non-dict values)
+    invalid_keys = set(data.keys()) - VALID_TOP_LEVEL_KEYS
+    if invalid_keys:
+        raise ValueError(
+            f"Invalid recipe format in {file_path}\n\n"
+            f"Unknown top-level keys: {', '.join(sorted(invalid_keys))}\n\n"
+            f"Valid top-level keys are:\n"
+            f"  - imports      (for importing task files)\n"
+            f"  - environments (for shell environment configuration)\n"
+            f"  - tasks        (for task definitions)"
+        )
+
+    # Extract tasks from "tasks" key
+    tasks_data = data.get("tasks", {})
+    if tasks_data is None:
+        tasks_data = {}
 
     # Process local tasks
     for task_name, task_data in tasks_data.items():
-        # Skip special sections (only relevant if tasks are at root level)
-        if task_name in ("import", "environments", "tasks"):
-            continue
 
         if not isinstance(task_data, dict):
             raise ValueError(f"Task '{task_name}' must be a dictionary")

tasktree/types.py

@@ -4,7 +4,7 @@ import re
 from datetime import datetime
 from ipaddress import IPv4Address, IPv6Address, ip_address
 from pathlib import Path
-from typing import Any
+from typing import Any, Optional
 
 import click
 
@@ -19,7 +19,7 @@ class HostnameType(click.ParamType):
         r"^(?=.{1,253}$)(?!-)[A-Za-z0-9-]{1,63}(?<!-)(\.[A-Za-z0-9-]{1,63})*\.?$"
     )
 
-    def convert(self, value: Any, param: click.Parameter | None, ctx: click.Context | None) -> str:
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
         if isinstance(value, str):
             if self.HOSTNAME_PATTERN.match(value):
                 return value
@@ -36,7 +36,7 @@ class EmailType(click.ParamType):
         r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
     )
 
-    def convert(self, value: Any, param: click.Parameter | None, ctx: click.Context | None) -> str:
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
         if isinstance(value, str):
             if self.EMAIL_PATTERN.match(value):
                 return value
@@ -48,7 +48,7 @@ class IPType(click.ParamType):
 
     name = "ip"
 
-    def convert(self, value: Any, param: click.Parameter | None, ctx: click.Context | None) -> str:
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
         try:
             ip_address(value)
             return str(value)
@@ -61,7 +61,7 @@ class IPv4Type(click.ParamType):
 
     name = "ipv4"
 
-    def convert(self, value: Any, param: click.Parameter | None, ctx: click.Context | None) -> str:
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
         try:
             IPv4Address(value)
             return str(value)
@@ -74,7 +74,7 @@ class IPv6Type(click.ParamType):
 
     name = "ipv6"
 
-    def convert(self, value: Any, param: click.Parameter | None, ctx: click.Context | None) -> str:
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
         try:
             IPv6Address(value)
             return str(value)
@@ -87,7 +87,7 @@ class DateTimeType(click.ParamType):
 
     name = "datetime"
 
-    def convert(self, value: Any, param: click.Parameter | None, ctx: click.Context | None) -> str:
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> str:
         if isinstance(value, str):
             try:
                 datetime.fromisoformat(value)

{tasktree-0.0.3.dist-info → tasktree-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.3
+Version: 0.0.5
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -18,6 +18,142 @@ Description-Content-Type: text/markdown
 
 A task automation tool that combines simple command execution with dependency tracking and incremental execution.
 
+## Motivation
+In any project of even moderate size, various scripts inevitably come into being along the way. These scripts often must be run in a particular order, or at a particular time. For historical reasons, this almost certainly a problem if your project is developed in a Linux environment; in Windows, an IDE like Visual Studio may be taking care of a significant proportion of your build, packaging and deployment tasks. Then again, it may not...
+
+The various incantations that have to be issued to build, package, test and deploy a project can build up and then all of a sudden there's only a few people that remember which to invoke and when and then people start making helpful readme guides on what to do with the scripts and then those become out of date and start telling lies about things and so on.
+
+Then there's the scripts themselves. In Linux, they're probably a big pile of Bash and Python, or something (Ruby, Perl, you name it). You can bet the house on people solving the problem of passing parameters to their scripts in a whole bunch of different and inconsistent ways.
+
+```bash
+#!/usr/bin/env bash
+# It's an environment variable defined.... somewhere?
+echo "FOO is: $FOO"
+```
+```bash
+#!/usr/bin/env bash
+# Using simple positional arguments... guess what means what when you're invoking it!
+echo "First: $1, Second: $2"
+```
+```bash
+#!/usr/bin/env bash
+# Oooooh fancy "make me look like a proper app" named option parsing... don't try and do --foo=bar though!
+FOO=""
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --foo) FOO=$2; shift ;;
+        --)    break ;;
+        *)     echo "Unknown: $1";;
+    esac
+    shift
+done
+```
+```bash
+#!/usr/bin/env bash
+# This thing...
+ARGS=$(getopt -o f:b --long foo:,bar: -n 'myscript' -- "$@")
+eval set -- "$ARGS"
+while true; do
+    case "$1" in
+        -b|--bar) echo "Bar: $2"; shift 2 ;;
+        -f|--foo) echo "Foo: $2"; shift 2 ;;
+        --) shift; break ;;
+        *) break ;;
+    esac
+done
+```
+
+What about help info? Who has time to wire that in?
+
+### The point
+Is this just whining and moaning? Should we just man up and revel in our own ability to memorize all the right incantations like some kind of scripting shaman?
+
+... No. That's **a dumb idea**.
+
+Task Tree allows you to pile all the knowledge of **what** to run, **when** to run it, **where** to run it and **how** to run it into a single, readable place. Then you can delete all the scripts that no-one knows how to use and all the readme docs that lie to the few people that actually waste their time reading them.
+
+The tasks you need to perform to deliver your project become summarised in an executable file that looks like:
+```yaml
+tasks:
+  build:
+    desc: Compile stuff
+    outputs: [target/release/bin]
+    cmd: cargo build --release
+
+  package:
+     desc: build installers
+     deps: [build]
+     outputs: [awesome.deb]
+     cmd: |
+        for bin in target/release/*; do
+            if [[ -x "$bin" && ! -d "$bin" ]]; then
+                install -Dm755 "$bin" "debian/awesome/usr/bin/$(basename "$bin")"
+            fi
+        done
+
+        dpkg-buildpackage -us -uc
+
+  test:
+    desc: Run tests
+    deps: [package]
+    inputs: [tests/**/*.py]
+    cmd: PYTHONPATH=src python3 -m pytest tests/ -v
+```
+
+If you want to run the tests then:
+```bash
+tt test
+```
+Boom! Done. `build` will always run, because there's no sensible way to know what Cargo did. However, if Cargo decided that nothing needed to be done and didn't touch the binaries, then `package` will realize that and not do anything. Then `test` will just run with the new tests that you just wrote. If you then immediately run `test` again, then `test` will figure out that none of the dependencies did anything and that none of the test files have changed and then just _do nothing_ - as it should.
+
+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)
@@ -26,6 +162,16 @@ A task automation tool that combines simple command execution with dependency tr
 pipx install tasktree
 ```
 
+If you have multiple Python interpreter versions installed, and the _default_ interpreter is a version <3.11, then you can use `pipx`'s `--python` option to specify an interpreter with a version >=3.11:
+
+```bash
+# If the target version is on the PATH
+pipx install --python python3.12 tasktree
+
+# With a path to an interpreter
+pipx install --python /path/to/python3.12 tasktree
+```
+
 ### From Source
 
 For the latest unreleased version from GitHub:
@@ -47,23 +193,26 @@ pipx install .
 Create a `tasktree.yaml` (or `tt.yaml`) in your project:
 
 ```yaml
-build:
-  desc: Compile the application
-  outputs: [target/release/bin]
-  cmd: cargo build --release
+tasks:
+  build:
+    desc: Compile the application
+    outputs: [target/release/bin]
+    cmd: cargo build --release
 
-test:
-  desc: Run tests
-  deps: [build]
-  cmd: cargo test
+  test:
+    desc: Run tests
+    deps: [build]
+    cmd: cargo test
 ```
 
 Run tasks:
 
 ```bash
-tt build          # Build the application
-tt test           # Run tests (builds first if needed)
+tt                # Print the help
+tt --help         # ...also print the help
 tt --list         # Show all available tasks
+tt build          # Build the application (assuming this is in your tasktree.yaml)
+tt test           # Run tests (builds first if needed)
 ```
 
 ## Core Concepts
@@ -84,15 +233,16 @@ Task Tree only runs tasks when necessary. A task executes if:
 Tasks automatically inherit inputs from dependencies, eliminating redundant declarations:
 
 ```yaml
-build:
-  outputs: [dist/app]
-  cmd: go build -o dist/app
-
-package:
-  deps: [build]
-  outputs: [dist/app.tar.gz]
-  cmd: tar czf dist/app.tar.gz dist/app
-  # Automatically tracks dist/app as an input
+tasks:
+  build:
+    outputs: [dist/app]
+    cmd: go build -o dist/app
+
+  package:
+    deps: [build]
+    outputs: [dist/app.tar.gz]
+    cmd: tar czf dist/app.tar.gz dist/app
+    # Automatically tracks dist/app as an input
 ```
 
 ### Single State File
@@ -104,15 +254,16 @@ All state lives in `.tasktree-state` at your project root. Stale entries are aut
 ### Basic Structure
 
 ```yaml
-task-name:
-  desc: Human-readable description (optional)
-  deps: [other-task]                     # Task dependencies
-  inputs: [src/**/*.go]                  # Explicit input files (glob patterns)
-  outputs: [dist/binary]                 # Output files (glob patterns)
-  working_dir: subproject/               # Execution directory (default: project root)
-  env: bash-strict                       # Execution environment (optional)
-  args: [param1, param2:path=default]    # Task parameters
-  cmd: go build -o dist/binary           # Command to execute
+tasks:
+  task-name:
+    desc: Human-readable description (optional)
+    deps: [other-task]                     # Task dependencies
+    inputs: [src/**/*.go]                  # Explicit input files (glob patterns)
+    outputs: [dist/binary]                 # Output files (glob patterns)
+    working_dir: subproject/               # Execution directory (default: project root)
+    env: bash-strict                       # Execution environment (optional)
+    args: [param1, param2:path=default]    # Task parameters
+    cmd: go build -o dist/binary           # Command to execute
 ```
 
 ### Commands
@@ -120,18 +271,20 @@ task-name:
 **Single-line commands** are executed directly via the configured shell:
 
 ```yaml
-build:
-  cmd: cargo build --release
+tasks:
+  build:
+    cmd: cargo build --release
 ```
 
 **Multi-line commands** are written to temporary script files for proper execution:
 
 ```yaml
-deploy:
-  cmd: |
-    mkdir -p dist
-    cp build/* dist/
-    rsync -av dist/ server:/opt/app/
+tasks:
+  deploy:
+    cmd: |
+      mkdir -p dist
+      cp build/* dist/
+      rsync -av dist/ server:/opt/app/
 ```
 
 Multi-line commands preserve shell syntax (line continuations, heredocs, etc.) and support shebangs on Unix/macOS.
@@ -139,12 +292,13 @@ Multi-line commands preserve shell syntax (line continuations, heredocs, etc.) a
 Or use folded blocks for long single-line commands:
 
 ```yaml
-compile:
-  cmd: >
-    gcc -o bin/app
-    src/*.c
-    -I include
-    -L lib -lm
+tasks:
+  compile:
+    cmd: >
+      gcc -o bin/app
+      src/*.c
+      -I include
+      -L lib -lm
 ```
 
 ### Execution Environments
@@ -204,12 +358,13 @@ tasks:
 Tasks can accept arguments with optional defaults:
 
 ```yaml
-deploy:
-  args: [environment, region=eu-west-1]
-  deps: [build]
-  cmd: |
-    aws s3 cp dist/app.zip s3://{{environment}}-{{region}}/
-    aws lambda update-function-code --function-name app-{{environment}}
+tasks:
+  deploy:
+    args: [environment, region=eu-west-1]
+    deps: [build]
+    cmd: |
+      aws s3 cp dist/app.zip s3://{{environment}}-{{region}}/
+      aws lambda update-function-code --function-name app-{{environment}}
 ```
 
 Invoke with: `tt deploy production` or `tt deploy staging us-east-1` or `tt deploy staging region=us-east-1`. 
@@ -236,18 +391,19 @@ Split task definitions across multiple files for better organisation:
 
 ```yaml
 # tasktree.yaml
-import:
+imports:
   - file: build/tasks.yml
     as: build
   - file: deploy/tasks.yml
     as: deploy
 
-test:
-  deps: [build.compile, build.test-compile]
-  cmd: ./run-tests.sh
+tasks:
+  test:
+    deps: [build.compile, build.test-compile]
+    cmd: ./run-tests.sh
 
-ci:
-  deps: [build.all, test, deploy.staging]
+  ci:
+    deps: [build.all, test, deploy.staging]
 ```
 
 Imported tasks are namespaced and can be referenced as dependencies. Each imported file is self-contained—it cannot depend on tasks in the importing file.
@@ -365,41 +521,42 @@ imports:
   - file: common/docker.yml
     as: docker
 
-compile:
-  desc: Build application binaries
-  outputs: [target/release/app]
-  cmd: cargo build --release
-
-test-unit:
-  desc: Run unit tests
-  deps: [compile]
-  cmd: cargo test
-
-package:
-  desc: Create distribution archive
-  deps: [compile]
-  outputs: [dist/app-{{version}}.tar.gz]
-  args: [version]
-  cmd: |
-    mkdir -p dist
-    tar czf dist/app-{{version}}.tar.gz \
-      target/release/app \
-      config/ \
-      migrations/
-
-deploy:
-  desc: Deploy to environment
-  deps: [package, docker.build-runtime]
-  args: [environment, version]
-  cmd: |
-    scp dist/app-{{version}}.tar.gz {{environment}}:/opt/
-    ssh {{environment}} /opt/deploy.sh {{version}}
-
-integration-test:
-  desc: Run integration tests against deployed environment
-  deps: [deploy]
-  args: [environment, version]
-  cmd: pytest tests/integration/ --env={{environment}}
+tasks:
+  compile:
+    desc: Build application binaries
+    outputs: [target/release/app]
+    cmd: cargo build --release
+
+  test-unit:
+    desc: Run unit tests
+    deps: [compile]
+    cmd: cargo test
+
+  package:
+    desc: Create distribution archive
+    deps: [compile]
+    outputs: [dist/app-{{version}}.tar.gz]
+    args: [version]
+    cmd: |
+      mkdir -p dist
+      tar czf dist/app-{{version}}.tar.gz \
+        target/release/app \
+        config/ \
+        migrations/
+
+  deploy:
+    desc: Deploy to environment
+    deps: [package, docker.build-runtime]
+    args: [environment, version]
+    cmd: |
+      scp dist/app-{{version}}.tar.gz {{environment}}:/opt/
+      ssh {{environment}} /opt/deploy.sh {{version}}
+
+  integration-test:
+    desc: Run integration tests against deployed environment
+    deps: [deploy]
+    args: [environment, version]
+    cmd: pytest tests/integration/ --env={{environment}}
 ```
 
 Run the full pipeline:

tasktree-0.0.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+tasktree/__init__.py,sha256=MVmdvKb3JdqLlo0x2_TPGMfgFC0HsDnP79HAzGnFnjI,1081
+tasktree/cli.py,sha256=jeLFmyFjTeF6JXDPLI46H5Xao9br68tPWL7D6LbC7u0,13272
+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=5WXoqN2cUtO9icIPDSvK5889XinBcAQMBCyNoJ2ZO6w,14152
+tasktree/state.py,sha256=rxKtS3SbsPtAuraHbN807RGWfoYYkQ3pe8CxUstwo2k,3535
+tasktree/tasks.py,sha256=2QdQZtJAX2rSGbyXKG1z9VF_siz1DUzdvzCgPkykxtU,173
+tasktree/types.py,sha256=w--sKjRTc8mGYkU5eAduqV86SolDqOYspAPuVKIuSQQ,3797
+tasktree-0.0.5.dist-info/METADATA,sha256=ncZRu7zCKZRd5YGG5fAWAL1TtH1mXbtnTqAne3RHdeA,17456
+tasktree-0.0.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tasktree-0.0.5.dist-info/entry_points.txt,sha256=lQINlvRYnimvteBbnhH84A9clTg8NnpEjCWqWkqg8KE,40
+tasktree-0.0.5.dist-info/RECORD,,

tasktree-0.0.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-tasktree/__init__.py,sha256=MVmdvKb3JdqLlo0x2_TPGMfgFC0HsDnP79HAzGnFnjI,1081
-tasktree/cli.py,sha256=hfxKF4N8nKPvy3WwyQgENHNH8YbUD3Zd7DLHGuHdeHU,14400
-tasktree/executor.py,sha256=_E37tShHuiOj0Mvx2GbS9y3GIozC3hpzAVhAjbvYJqg,18638
-tasktree/graph.py,sha256=9ngfg93y7EkOIN_lUQa0u-JhnwiMN1UdQQvIFw8RYCE,4181
-tasktree/hasher.py,sha256=xOeth3vufP-QrjnVgTDh02clkZb867aJPD6HSjhMNsg,2336
-tasktree/parser.py,sha256=apLfN3_YVa7lQIy0rcHFwo931Pg-8mKG1044AQE6fLQ,12690
-tasktree/state.py,sha256=rxKtS3SbsPtAuraHbN807RGWfoYYkQ3pe8CxUstwo2k,3535
-tasktree/tasks.py,sha256=2QdQZtJAX2rSGbyXKG1z9VF_siz1DUzdvzCgPkykxtU,173
-tasktree/types.py,sha256=wrBzO-Z2ebCTRjWyOWNvuCjqAq-74Zyb9E4FQ4beF38,3751
-tasktree-0.0.3.dist-info/METADATA,sha256=qlpV-egfSY502xJKLmmam1CTUVpVEiU4oS10LntL7gE,11961
-tasktree-0.0.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tasktree-0.0.3.dist-info/entry_points.txt,sha256=lQINlvRYnimvteBbnhH84A9clTg8NnpEjCWqWkqg8KE,40
-tasktree-0.0.3.dist-info/RECORD,,