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

tasktree/cli.py

@@ -26,11 +26,11 @@ app = typer.Typer(
 console = Console()
 
 
-def _list_tasks():
+def _list_tasks(tasks_file: Optional[str] = None):
     """List all available tasks with descriptions."""
-    recipe = _get_recipe()
+    recipe = _get_recipe(tasks_file)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+        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")
@@ -45,11 +45,11 @@ def _list_tasks():
     console.print(table)
 
 
-def _show_task(task_name: str):
+def _show_task(task_name: str, tasks_file: Optional[str] = None):
     """Show task definition with syntax highlighting."""
-    recipe = _get_recipe()
+    recipe = _get_recipe(tasks_file)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
         raise typer.Exit(1)
 
     task = recipe.get_task(task_name)
@@ -79,17 +79,26 @@ def _show_task(task_name: str):
     task_dict = task_yaml[task_name]
     task_yaml[task_name] = {k: v for k, v in task_dict.items() if v}
 
+    # Configure YAML dumper to use literal block style for multiline strings
+    def literal_presenter(dumper, data):
+        """Use literal block style (|) for strings containing newlines."""
+        if '\n' in data:
+            return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
+        return dumper.represent_scalar('tag:yaml.org,2002:str', data)
+
+    yaml.add_representer(str, literal_presenter)
+
     # Format and highlight using Rich
     yaml_str = yaml.dump(task_yaml, default_flow_style=False, sort_keys=False)
     syntax = Syntax(yaml_str, "yaml", theme="ansi_light", line_numbers=False)
     console.print(syntax)
 
 
-def _show_tree(task_name: str):
+def _show_tree(task_name: str, tasks_file: Optional[str] = None):
     """Show dependency tree structure."""
-    recipe = _get_recipe()
+    recipe = _get_recipe(tasks_file)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
         raise typer.Exit(1)
 
     task = recipe.get_task(task_name)
@@ -117,27 +126,28 @@ def _init_recipe():
         raise typer.Exit(1)
 
     template = """# Task Tree Recipe
-# See https://github.com/kevinchannon/task-tree for documentation
+# See https://github.com/kevinchannon/tasktree for documentation
 
 # 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,6 +178,7 @@ def main(
     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"),
+    tasks_file: Optional[str] = typer.Option(None, "--tasks", "-T", help="Path to recipe file (tasktree.yaml, *.tasks, etc.)"),
     init: Optional[bool] = typer.Option(
         None, "--init", "-i", help="Create a blank tasktree.yaml"
     ),
@@ -207,15 +218,15 @@ def main(
     """
 
     if list_opt:
-        _list_tasks()
+        _list_tasks(tasks_file)
         raise typer.Exit()
 
     if show:
-        _show_task(show)
+        _show_task(show, tasks_file)
         raise typer.Exit()
 
     if tree:
-        _show_tree(tree)
+        _show_tree(tree, tasks_file)
         raise typer.Exit()
 
     if init:
@@ -223,17 +234,17 @@ def main(
         raise typer.Exit()
 
     if clean or clean_state or reset:
-        _clean_state()
+        _clean_state(tasks_file)
         raise typer.Exit()
 
     if task_args:
         # --only implies --force
         force_execution = force or only or False
-        _execute_dynamic_task(task_args, force=force_execution, only=only or False, env=env)
+        _execute_dynamic_task(task_args, force=force_execution, only=only or False, env=env, tasks_file=tasks_file)
     else:
-        recipe = _get_recipe()
+        recipe = _get_recipe(tasks_file)
         if recipe is None:
-            console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+            console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
             console.print("Run [cyan]tt --init[/cyan] to create a blank recipe file")
             raise typer.Exit(1)
 
@@ -244,13 +255,19 @@ def main(
         console.print("Use [cyan]tt <task-name>[/cyan] to run a task")
 
 
-def _clean_state() -> None:
+def _clean_state(tasks_file: Optional[str] = None) -> None:
     """Remove the .tasktree-state file to reset task execution state."""
-    recipe_path = find_recipe_file()
-    if recipe_path is None:
-        console.print("[yellow]No recipe file found[/yellow]")
-        console.print("State file location depends on recipe file location")
-        raise typer.Exit(1)
+    if tasks_file:
+        recipe_path = Path(tasks_file)
+        if not recipe_path.exists():
+            console.print(f"[red]Recipe file not found: {tasks_file}[/red]")
+            raise typer.Exit(1)
+    else:
+        recipe_path = find_recipe_file()
+        if recipe_path is None:
+            console.print("[yellow]No recipe file found[/yellow]")
+            console.print("State file location depends on recipe file location")
+            raise typer.Exit(1)
 
     project_root = recipe_path.parent
     state_path = project_root / ".tasktree-state"
@@ -263,29 +280,48 @@ def _clean_state() -> None:
         console.print(f"[yellow]No state file found at {state_path}[/yellow]")
 
 
-def _get_recipe() -> Optional[Recipe]:
-    """Get parsed recipe or None if not found."""
-    recipe_path = find_recipe_file()
-    if recipe_path is None:
-        return None
+def _get_recipe(recipe_file: Optional[str] = None) -> Optional[Recipe]:
+    """Get parsed recipe or None if not found.
+
+    Args:
+        recipe_file: Optional path to recipe file. If not provided, searches for recipe file.
+    """
+    if recipe_file:
+        recipe_path = Path(recipe_file)
+        if not recipe_path.exists():
+            console.print(f"[red]Recipe file not found: {recipe_file}[/red]")
+            raise typer.Exit(1)
+        # When explicitly specified, project root is current working directory
+        project_root = Path.cwd()
+    else:
+        try:
+            recipe_path = find_recipe_file()
+            if recipe_path is None:
+                return None
+        except ValueError as e:
+            # Multiple recipe files found
+            console.print(f"[red]{e}[/red]")
+            raise typer.Exit(1)
+        # When auto-discovered, project root is recipe file's parent
+        project_root = None
 
     try:
-        return parse_recipe(recipe_path)
+        return parse_recipe(recipe_path, project_root)
     except Exception as e:
         console.print(f"[red]Error parsing recipe: {e}[/red]")
         raise typer.Exit(1)
 
 
-def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = False, env: Optional[str] = None) -> None:
+def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = False, env: Optional[str] = None, tasks_file: Optional[str] = None) -> None:
     if not args:
         return
 
     task_name = args[0]
     task_args = args[1:]
 
-    recipe = _get_recipe()
+    recipe = _get_recipe(tasks_file)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
         raise typer.Exit(1)
 
     # Apply global environment override if provided

tasktree/parser.py

@@ -94,13 +94,25 @@ class Recipe:
 
 
 def find_recipe_file(start_dir: Path | None = None) -> Path | None:
-    """Find recipe file (tasktree.yaml or tt.yaml) in current or parent directories.
+    """Find recipe file in current or parent directories.
+
+    Looks for recipe files matching these patterns (in order of preference):
+    - tasktree.yaml
+    - tasktree.yml
+    - tt.yaml
+    - *.tasks
+
+    If multiple recipe files are found in the same directory, raises ValueError
+    with instructions to use --tasks option.
 
     Args:
         start_dir: Directory to start searching from (defaults to cwd)
 
     Returns:
         Path to recipe file if found, None otherwise
+
+    Raises:
+        ValueError: If multiple recipe files found in the same directory
     """
     if start_dir is None:
         start_dir = Path.cwd()
@@ -109,10 +121,30 @@ def find_recipe_file(start_dir: Path | None = None) -> Path | None:
 
     # Search up the directory tree
     while True:
-        for filename in ["tasktree.yaml", "tt.yaml"]:
+        candidates = []
+
+        # Check for exact filenames first
+        for filename in ["tasktree.yaml", "tasktree.yml", "tt.yaml"]:
             recipe_path = current / filename
             if recipe_path.exists():
-                return recipe_path
+                candidates.append(recipe_path)
+
+        # Check for *.tasks files
+        for tasks_file in current.glob("*.tasks"):
+            if tasks_file.is_file():
+                candidates.append(tasks_file)
+
+        if len(candidates) > 1:
+            # Multiple recipe files found - ambiguous
+            filenames = [c.name for c in candidates]
+            raise ValueError(
+                f"Multiple recipe files found in {current}:\n"
+                f"  {', '.join(filenames)}\n\n"
+                f"Please specify which file to use with --tasks (-T):\n"
+                f"  tt --tasks {filenames[0]} <task-name>"
+            )
+        elif len(candidates) == 1:
+            return candidates[0]
 
         # Move to parent directory
         parent = current.parent
@@ -186,11 +218,13 @@ def _parse_file_with_env(
     return tasks, environments, default_env
 
 
-def parse_recipe(recipe_path: Path) -> Recipe:
+def parse_recipe(recipe_path: Path, project_root: Path | None = None) -> Recipe:
     """Parse a recipe file and handle imports recursively.
 
     Args:
         recipe_path: Path to the main recipe file
+        project_root: Optional project root directory. If not provided, uses recipe file's parent directory.
+                     When using --tasks option, this should be the current working directory.
 
     Returns:
         Recipe object with all tasks (including recursively imported tasks)
@@ -204,7 +238,9 @@ def parse_recipe(recipe_path: Path) -> Recipe:
     if not recipe_path.exists():
         raise FileNotFoundError(f"Recipe file not found: {recipe_path}")
 
-    project_root = recipe_path.parent
+    # Default project root to recipe file's parent if not specified
+    if project_root is None:
+        project_root = recipe_path.parent
 
     # Parse main file - it will recursively handle all imports
     tasks, environments, default_env = _parse_file_with_env(
@@ -263,14 +299,15 @@ def _parse_file(
     tasks: dict[str, Task] = {}
     file_dir = file_path.parent
 
-    # Default working directory is the file's directory
-    default_working_dir = str(file_dir.relative_to(project_root)) if file_dir != project_root else "."
+    # Default working directory is the project root (where tt is invoked)
+    # NOT the directory where the tasks file is located
+    default_working_dir = "."
 
     # Track local import namespaces for dependency rewriting
     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 +334,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-0.0.4.dist-info → tasktree-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.4
+Version: 0.0.6
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -70,33 +70,34 @@ Is this just whining and moaning? Should we just man up and revel in our own abi
 
 ... 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. 
+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
-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
+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:
@@ -107,6 +108,52 @@ 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)
@@ -141,20 +188,52 @@ cd tasktree
 pipx install .
 ```
 
+## Editor Support
+
+Task Tree includes a [JSON Schema](schema/tasktree-schema.json) that provides autocomplete, validation, and documentation in modern editors.
+
+### VS Code
+
+Install the [YAML extension](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-yaml), then add to your workspace `.vscode/settings.json`:
+
+```json
+{
+  "yaml.schemas": {
+    "https://raw.githubusercontent.com/kevinchannon/tasktree/main/schema/tasktree-schema.json": [
+      "tasktree.yaml",
+      "tt.yaml"
+    ]
+  }
+}
+```
+
+Or add a comment at the top of your `tasktree.yaml`:
+
+```yaml
+# yaml-language-server: $schema=https://raw.githubusercontent.com/kevinchannon/tasktree/main/schema/tasktree-schema.json
+
+tasks:
+  build:
+    cmd: cargo build
+```
+
+See [schema/README.md](schema/README.md) for IntelliJ/PyCharm and command-line validation.
+
 ## Quick Start
 
 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:
@@ -185,15 +264,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
@@ -205,15 +285,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
@@ -221,18 +302,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.
@@ -240,12 +323,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
@@ -305,12 +389,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`. 
@@ -337,18 +422,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.
@@ -466,41 +552,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.4.dist-info → tasktree-0.0.6.dist-info}/RECORD

@@ -1,13 +1,13 @@
 tasktree/__init__.py,sha256=MVmdvKb3JdqLlo0x2_TPGMfgFC0HsDnP79HAzGnFnjI,1081
-tasktree/cli.py,sha256=2Pm0pxWdG4RaQbVMijaMUIrm3v0b9J98CUsUp7cDFvI,13236
+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=apLfN3_YVa7lQIy0rcHFwo931Pg-8mKG1044AQE6fLQ,12690
+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.4.dist-info/METADATA,sha256=dxJ5QiaRWhBbae-cK358ESQuwbjDg04ITWomlgrO9Lc,16312
-tasktree-0.0.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tasktree-0.0.4.dist-info/entry_points.txt,sha256=lQINlvRYnimvteBbnhH84A9clTg8NnpEjCWqWkqg8KE,40
-tasktree-0.0.4.dist-info/RECORD,,
+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,,