tasktree 0.0.20__tar.gz → 0.0.21__tar.gz

{tasktree-0.0.20 → tasktree-0.0.21}/.claude/settings.local.json

@@ -15,7 +15,9 @@
       "Bash(cat:*)",
       "Bash(tt --help:*)",
       "Bash(head:*)",
-      "Bash(wc:*)"
+      "Bash(wc:*)",
+      "Bash(athena status:*)",
+      "Bash(athena sync:*)"
     ]
   }
 }

{tasktree-0.0.20 → tasktree-0.0.21}/.gitignore

@@ -157,6 +157,5 @@ example/.tasktree-state
 # Requirements files copied from GitHub issues (for driving Claude Code)
 requirements/*
 
-# UV lock file (optional - some prefer to commit this)
-# uv.lock
+.athena-cache
 

{tasktree-0.0.20 → tasktree-0.0.21}/CLAUDE.md

@@ -74,15 +74,30 @@ Your sponsor is not made of money! Try to minimise token useage, so that we can
 
 ## Development Commands
 
+## IMPORTANT! Tool use
+### Athena Code Knowledge
+This repo uses Athena to store and retrieve knowledge about the codebase. YOU SHOULD USE THE TOOL TO MAKE INQUIRIES ABOUT THE CODE.
+
+1. Find a function/class: `athena locate <function/class name>`
+2. Find information about what a function/class does:
+   - `athena info path/to/module.py:ClassName`
+   - `athena info path/to/module.py:ClassName.method`
+   - `athena info path/to/module.py:some_function`
+3. Search for relevant code information:
+   - `athena serch "generate JWT authentication tokens`
+4. AFTER code changes, run `athena status` to check which docs should have been updated
+5. AFTER checking/updating docs, run `athena sync` to register the changes
+
+**prefer this workflow to using native `grep` and `find` tools** for understanding the code.
+
 ### Testing
 ```bash
 python3 -m pytest tests/
 ```
-
-The project has **656 tests** across three categories:
-- **Unit tests** (`tests/unit/`): 15 test files covering parser, executor, graph, hasher, types, substitution, state
-- **Integration tests** (`tests/integration/`): 21 test files for CLI options, parameterized tasks, Docker, variables, arg validation
-- **E2E tests** (`tests/e2e/`): 5 test files for Docker volumes, ownership, environment, and basic functionality
+The project has tests across three categories:
+- **Unit tests** (`tests/unit/`): Should always be updated for any change. Makes up the bulk of code coverage
+- **Integration tests** (`tests/integration/`): Test changes using the Typer CliRunner to cover end-to-end workflows across multiple modules
+- **E2E tests** (`tests/e2e/`): Heavyweight tests that cover running the tool in a subprocess and/or containerized environment 
 
 ### Running the Application
 ```bash

{tasktree-0.0.20 → tasktree-0.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.20
+Version: 0.0.21
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -835,7 +835,7 @@ Hint: Define named outputs like: outputs: [{ missing: 'path/to/file' }]
 
 ### Self-References
 
-Tasks can reference their own named inputs and outputs using `{{ self.inputs.name }}` and `{{ self.outputs.name }}` templates. This eliminates repetition when paths contain variables or when tasks have multiple inputs/outputs.
+Tasks can reference their own inputs and outputs using `{{ self.inputs.name }}` (named access) or `{{ self.inputs.0 }}` (positional access) templates. This eliminates repetition when paths contain variables or when tasks have multiple inputs/outputs.
 
 **Named Inputs and Outputs:**
 
@@ -862,8 +862,10 @@ tasks:
 
 - **Defining named inputs**: `inputs: [{ name: "path/to/file" }]`
 - **Defining named outputs**: `outputs: [{ name: "path/to/file" }]`
-- **Referencing inputs**: `{{ self.inputs.input_name }}`
-- **Referencing outputs**: `{{ self.outputs.output_name }}`
+- **Defining anonymous inputs**: `inputs: ["path/to/file"]`
+- **Defining anonymous outputs**: `outputs: ["path/to/file"]`
+- **Referencing by name**: `{{ self.inputs.input_name }}` or `{{ self.outputs.output_name }}`
+- **Referencing by index**: `{{ self.inputs.0 }}` or `{{ self.outputs.1 }}` (0-based)
 - **Mixed format**: Can combine named and anonymous inputs/outputs in the same task
 
 **Why Use Self-References?**
@@ -972,6 +974,129 @@ tasks:
     cmd: build-tool --config {{ self.inputs.config }} --output {{ self.outputs.binary }}
 ```
 
+**Positional Index References:**
+
+In addition to named references, you can access inputs and outputs by their positional index using `{{ self.inputs.0 }}`, `{{ self.inputs.1 }}`, etc. This provides an alternative way to reference items, especially useful for:
+
+- **Anonymous inputs/outputs**: Reference items that don't have names
+- **Simple sequential access**: When order is more important than naming
+- **Mixed with named access**: Use both styles in the same task
+
+**Syntax:**
+
+```yaml
+tasks:
+  process:
+    inputs: ["file1.txt", "file2.txt", "file3.txt"]
+    outputs: ["output1.txt", "output2.txt"]
+    cmd: |
+      cat {{ self.inputs.0 }} {{ self.inputs.1 }} > {{ self.outputs.0 }}
+      cat {{ self.inputs.2 }} > {{ self.outputs.1 }}
+```
+
+Indices follow YAML declaration order, starting from 0 (zero-based indexing):
+- First input/output = index 0
+- Second input/output = index 1
+- Third input/output = index 2, etc.
+
+**Works with Both Named and Anonymous:**
+
+```yaml
+tasks:
+  build:
+    inputs:
+      - config: "build.yaml"  # Index 0, also accessible as {{ self.inputs.config }}
+      - "src/**/*.c"          # Index 1, ONLY accessible as {{ self.inputs.1 }}
+      - headers: "include/*.h" # Index 2, also accessible as {{ self.inputs.headers }}
+    outputs:
+      - "dist/app.js"         # Index 0
+      - bundle: "dist/bundle.js" # Index 1, also accessible as {{ self.outputs.bundle }}
+    cmd: |
+      # Mix positional and named references
+      build-tool \
+        --config {{ self.inputs.0 }} \
+        --sources {{ self.inputs.1 }} \
+        --headers {{ self.inputs.headers }} \
+        --output {{ self.outputs.bundle }}
+```
+
+**Same Item, Multiple Ways:**
+
+Named items can be accessed by both name and index:
+
+```yaml
+tasks:
+  copy:
+    inputs:
+      - source: data.txt
+    cmd: |
+      # These are equivalent:
+      cat {{ self.inputs.source }} > copy1.txt
+      cat {{ self.inputs.0 }} > copy2.txt
+```
+
+**With Variables and Arguments:**
+
+Positional references work with variable-expanded paths:
+
+```yaml
+variables:
+  version: "1.0"
+
+tasks:
+  package:
+    args: [platform]
+    inputs:
+      - "dist/app-{{ var.version }}.js"
+      - "dist/lib-{{ arg.platform }}.so"
+    outputs: ["release-{{ var.version }}-{{ arg.platform }}.tar.gz"]
+    cmd: tar czf {{ self.outputs.0 }} {{ self.inputs.0 }} {{ self.inputs.1 }}
+```
+
+**Index Boundaries:**
+
+Indices are validated before execution:
+
+```yaml
+tasks:
+  build:
+    inputs: ["file1.txt", "file2.txt"]
+    cmd: cat {{ self.inputs.5 }}  # Error: index 5 out of bounds!
+```
+
+Error message:
+```
+Task 'build' references input index '5' but only has 2 inputs (indices 0-1)
+```
+
+**Empty Lists:**
+
+Referencing an index when no inputs/outputs exist:
+
+```yaml
+tasks:
+  generate:
+    cmd: echo "test" > {{ self.outputs.0 }}  # Error: no outputs defined!
+```
+
+Error message:
+```
+Task 'generate' references output index '0' but has no outputs defined
+```
+
+**When to Use Index References:**
+
+- **Anonymous items**: Only way to reference inputs/outputs without names
+- **Order-based processing**: When the sequence matters more than naming
+- **Simple tasks**: Quick access without defining names
+- **Compatibility**: Accessing items in legacy YAML that uses anonymous format
+
+**When to Use Named References:**
+
+- **Clarity**: Names make commands more readable (`{{ self.inputs.config }}` vs `{{ self.inputs.2 }}`)
+- **Maintainability**: Adding/removing items doesn't break indices
+- **Complex tasks**: Many inputs/outputs are easier to manage with names
+
 **Error Messages:**
 
 If you reference a non-existent input or output:
@@ -1011,18 +1136,21 @@ Hint: Define named inputs like: inputs: [{ src: 'file.txt' }]
 
 **Key Behaviors:**
 
+- **Two access methods**: Reference by name (`{{ self.inputs.name }}`) or by index (`{{ self.inputs.0 }}`)
 - **Template resolution**: Self-references are resolved during dependency graph planning
 - **Substitution order**: Variables → Dependency outputs → Self-references → Arguments/Environment
-- **Fail-fast validation**: Errors are caught before execution begins
-- **Clear error messages**: Lists available names if reference doesn't exist
+- **Fail-fast validation**: Errors are caught before execution begins (missing names, out-of-bounds indices)
+- **Clear error messages**: Lists available names/indices if reference doesn't exist
 - **Backward compatible**: Existing anonymous inputs/outputs work unchanged
 - **State tracking**: Works correctly with incremental execution and freshness checks
+- **Index order**: Positional indices follow YAML declaration order (0-based)
 
 **Limitations:**
 
-- **Anonymous not referenceable**: Only named inputs/outputs can be referenced
+- **Anonymous not referenceable by name**: Anonymous inputs/outputs cannot be referenced by name (use positional index instead: `{{ self.inputs.0 }}`)
 - **Case sensitive**: `{{ self.inputs.Src }}` and `{{ self.inputs.src }}` are different
 - **Argument defaults**: Self-references in argument defaults are not supported (arguments are evaluated before self-references)
+- **No negative indices**: Python-style negative indexing (`{{ self.inputs.-1 }}`) is not supported
 
 **Use Cases:**
 

{tasktree-0.0.20 → tasktree-0.0.21}/README.md

@@ -820,7 +820,7 @@ Hint: Define named outputs like: outputs: [{ missing: 'path/to/file' }]
 
 ### Self-References
 
-Tasks can reference their own named inputs and outputs using `{{ self.inputs.name }}` and `{{ self.outputs.name }}` templates. This eliminates repetition when paths contain variables or when tasks have multiple inputs/outputs.
+Tasks can reference their own inputs and outputs using `{{ self.inputs.name }}` (named access) or `{{ self.inputs.0 }}` (positional access) templates. This eliminates repetition when paths contain variables or when tasks have multiple inputs/outputs.
 
 **Named Inputs and Outputs:**
 
@@ -847,8 +847,10 @@ tasks:
 
 - **Defining named inputs**: `inputs: [{ name: "path/to/file" }]`
 - **Defining named outputs**: `outputs: [{ name: "path/to/file" }]`
-- **Referencing inputs**: `{{ self.inputs.input_name }}`
-- **Referencing outputs**: `{{ self.outputs.output_name }}`
+- **Defining anonymous inputs**: `inputs: ["path/to/file"]`
+- **Defining anonymous outputs**: `outputs: ["path/to/file"]`
+- **Referencing by name**: `{{ self.inputs.input_name }}` or `{{ self.outputs.output_name }}`
+- **Referencing by index**: `{{ self.inputs.0 }}` or `{{ self.outputs.1 }}` (0-based)
 - **Mixed format**: Can combine named and anonymous inputs/outputs in the same task
 
 **Why Use Self-References?**
@@ -957,6 +959,129 @@ tasks:
     cmd: build-tool --config {{ self.inputs.config }} --output {{ self.outputs.binary }}
 ```
 
+**Positional Index References:**
+
+In addition to named references, you can access inputs and outputs by their positional index using `{{ self.inputs.0 }}`, `{{ self.inputs.1 }}`, etc. This provides an alternative way to reference items, especially useful for:
+
+- **Anonymous inputs/outputs**: Reference items that don't have names
+- **Simple sequential access**: When order is more important than naming
+- **Mixed with named access**: Use both styles in the same task
+
+**Syntax:**
+
+```yaml
+tasks:
+  process:
+    inputs: ["file1.txt", "file2.txt", "file3.txt"]
+    outputs: ["output1.txt", "output2.txt"]
+    cmd: |
+      cat {{ self.inputs.0 }} {{ self.inputs.1 }} > {{ self.outputs.0 }}
+      cat {{ self.inputs.2 }} > {{ self.outputs.1 }}
+```
+
+Indices follow YAML declaration order, starting from 0 (zero-based indexing):
+- First input/output = index 0
+- Second input/output = index 1
+- Third input/output = index 2, etc.
+
+**Works with Both Named and Anonymous:**
+
+```yaml
+tasks:
+  build:
+    inputs:
+      - config: "build.yaml"  # Index 0, also accessible as {{ self.inputs.config }}
+      - "src/**/*.c"          # Index 1, ONLY accessible as {{ self.inputs.1 }}
+      - headers: "include/*.h" # Index 2, also accessible as {{ self.inputs.headers }}
+    outputs:
+      - "dist/app.js"         # Index 0
+      - bundle: "dist/bundle.js" # Index 1, also accessible as {{ self.outputs.bundle }}
+    cmd: |
+      # Mix positional and named references
+      build-tool \
+        --config {{ self.inputs.0 }} \
+        --sources {{ self.inputs.1 }} \
+        --headers {{ self.inputs.headers }} \
+        --output {{ self.outputs.bundle }}
+```
+
+**Same Item, Multiple Ways:**
+
+Named items can be accessed by both name and index:
+
+```yaml
+tasks:
+  copy:
+    inputs:
+      - source: data.txt
+    cmd: |
+      # These are equivalent:
+      cat {{ self.inputs.source }} > copy1.txt
+      cat {{ self.inputs.0 }} > copy2.txt
+```
+
+**With Variables and Arguments:**
+
+Positional references work with variable-expanded paths:
+
+```yaml
+variables:
+  version: "1.0"
+
+tasks:
+  package:
+    args: [platform]
+    inputs:
+      - "dist/app-{{ var.version }}.js"
+      - "dist/lib-{{ arg.platform }}.so"
+    outputs: ["release-{{ var.version }}-{{ arg.platform }}.tar.gz"]
+    cmd: tar czf {{ self.outputs.0 }} {{ self.inputs.0 }} {{ self.inputs.1 }}
+```
+
+**Index Boundaries:**
+
+Indices are validated before execution:
+
+```yaml
+tasks:
+  build:
+    inputs: ["file1.txt", "file2.txt"]
+    cmd: cat {{ self.inputs.5 }}  # Error: index 5 out of bounds!
+```
+
+Error message:
+```
+Task 'build' references input index '5' but only has 2 inputs (indices 0-1)
+```
+
+**Empty Lists:**
+
+Referencing an index when no inputs/outputs exist:
+
+```yaml
+tasks:
+  generate:
+    cmd: echo "test" > {{ self.outputs.0 }}  # Error: no outputs defined!
+```
+
+Error message:
+```
+Task 'generate' references output index '0' but has no outputs defined
+```
+
+**When to Use Index References:**
+
+- **Anonymous items**: Only way to reference inputs/outputs without names
+- **Order-based processing**: When the sequence matters more than naming
+- **Simple tasks**: Quick access without defining names
+- **Compatibility**: Accessing items in legacy YAML that uses anonymous format
+
+**When to Use Named References:**
+
+- **Clarity**: Names make commands more readable (`{{ self.inputs.config }}` vs `{{ self.inputs.2 }}`)
+- **Maintainability**: Adding/removing items doesn't break indices
+- **Complex tasks**: Many inputs/outputs are easier to manage with names
+
 **Error Messages:**
 
 If you reference a non-existent input or output:
@@ -996,18 +1121,21 @@ Hint: Define named inputs like: inputs: [{ src: 'file.txt' }]
 
 **Key Behaviors:**
 
+- **Two access methods**: Reference by name (`{{ self.inputs.name }}`) or by index (`{{ self.inputs.0 }}`)
 - **Template resolution**: Self-references are resolved during dependency graph planning
 - **Substitution order**: Variables → Dependency outputs → Self-references → Arguments/Environment
-- **Fail-fast validation**: Errors are caught before execution begins
-- **Clear error messages**: Lists available names if reference doesn't exist
+- **Fail-fast validation**: Errors are caught before execution begins (missing names, out-of-bounds indices)
+- **Clear error messages**: Lists available names/indices if reference doesn't exist
 - **Backward compatible**: Existing anonymous inputs/outputs work unchanged
 - **State tracking**: Works correctly with incremental execution and freshness checks
+- **Index order**: Positional indices follow YAML declaration order (0-based)
 
 **Limitations:**
 
-- **Anonymous not referenceable**: Only named inputs/outputs can be referenced
+- **Anonymous not referenceable by name**: Anonymous inputs/outputs cannot be referenced by name (use positional index instead: `{{ self.inputs.0 }}`)
 - **Case sensitive**: `{{ self.inputs.Src }}` and `{{ self.inputs.src }}` are different
 - **Argument defaults**: Self-references in argument defaults are not supported (arguments are evaluated before self-references)
+- **No negative indices**: Python-style negative indexing (`{{ self.inputs.-1 }}`) is not supported
 
 **Use Cases:**
 

tasktree-0.0.21/__init__.py

@@ -0,0 +1,3 @@
+"""
+@athena: a46f4c60df41
+"""

tasktree-0.0.21/example/tasktree.yaml

@@ -0,0 +1,64 @@
+variables:
+  log_level: { env: LOG_LEVEL, default: "info" }
+
+tasks:
+  build:
+    desc: Building outputs (imagine this is a call to Cargo, or gcc, or something)
+    args:
+      - build_type:
+          choices: [ "debug", "release", "{{ var.log_level }}" ]
+          default: "{{ var.log_level }}"
+      - target:
+           type: str
+           choices:
+             - "x86"
+             - "x86_64"
+             - "arm"
+             - "ppc"
+           default: "x86_64"
+    outputs: [build/**]
+    cmd: |
+      echo building for {{ arg.target }}...
+      cd build
+      echo "code and stuff" > output-{{ arg.build_type }}-{{ arg.target }}.txt
+
+  package:
+    desc: Create archive
+    deps:
+      - build: [ "debug", "x86" ]
+      - build: [ "release" ]
+      - build: { build_type: "release", target: "ppc" }
+    outputs: [archive.tar.gz]
+    cmd: echo "making archive.tar.gz..."
+
+  transform:
+    desc: Transform data using self-references (demonstrates named inputs/outputs)
+    inputs:
+      - source: build/output-debug-x86_64.txt  # Named input - can reference with {{ self.inputs.source }}
+      - config: config.yaml                     # Named input
+    outputs:
+      - result: processed/result.txt            # Named output - can reference with {{ self.outputs.result }}
+      - log: processed/transform.log            # Named output
+    cmd: |
+      mkdir -p processed
+      echo "Processing {{ self.inputs.source }} with config {{ self.inputs.config }}" > {{ self.outputs.log }}
+      cat {{ self.inputs.source }} | tr '[:lower:]' '[:upper:]' > {{ self.outputs.result }}
+      echo "Done" >> {{ self.outputs.log }}
+
+  deploy:
+    desc: Deploy using dependency outputs and self-references
+    deps: [transform]
+    inputs:
+      - manifest: deploy-manifest.yaml
+    outputs:
+      - deployed: deployed/app.tar.gz
+    cmd: |
+      mkdir -p deployed
+      echo "Deploying with manifest {{ self.inputs.manifest }}"
+      tar czf {{ self.outputs.deployed }} {{ dep.transform.outputs.result }} {{ self.inputs.manifest }}
+      echo "Deployed to {{ self.outputs.deployed }}"
+
+  clean:
+    desc: Clean generated files
+    inputs: [ archive.tar.gz ]
+    cmd: rm -f archive.tar.gz

{tasktree-0.0.20 → tasktree-0.0.21}/pyproject.toml

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

{tasktree-0.0.20 → tasktree-0.0.21}/schema/README.md

@@ -62,11 +62,14 @@ check-jsonschema --schemafile schema/tasktree-schema.json tasktree.yaml
 
 The schema validates:
 
-- **Top-level structure**: Only `imports`, `environments`, and `tasks` are allowed at root
+- **Top-level structure**: Only `imports`, `environments`, `variables`, and `tasks` are allowed at root
 - **Required fields**: Tasks must have a `cmd` field
 - **Field types**: Ensures strings, arrays, and objects are used correctly
 - **Naming patterns**: Task names and namespaces must match `^[a-zA-Z][a-zA-Z0-9_-]*$`
-- **Environment requirements**: Environments must specify a `shell`
+- **Named inputs/outputs**: Supports both anonymous (strings) and named (objects) format
+- **Self-references**: Named inputs/outputs can be referenced with `{{ self.inputs.name }}` and `{{ self.outputs.name }}`
+- **Dependency outputs**: Named outputs can be referenced with `{{ dep.task.outputs.name }}`
+- **Environment requirements**: Environments must specify a `shell` (or `dockerfile` for Docker environments)
 
 ## Example
 
@@ -85,25 +88,40 @@ tasks:
   build:
     desc: Build the application
     deps: [base.setup]
-    inputs: ["src/**/*.rs"]
+    inputs:
+      - sources: "src/**/*.rs"        # Named input - can use {{ self.inputs.sources }}
     outputs:
       - binary: target/release/bin    # Named output - can be referenced
       - target/release/bin.map        # Anonymous output
-    cmd: cargo build --release
+    cmd: cargo build --release --manifest-path {{ self.inputs.sources }}/../Cargo.toml
 
   test:
     desc: Run tests
     deps: [build]
     cmd: cargo test
 
+  package:
+    desc: Package the application
+    deps: [build]
+    inputs:
+      - manifest: package.yaml        # Named input
+    outputs:
+      - archive: dist/app.tar.gz      # Named output
+    cmd: |
+      mkdir -p dist
+      # Use self-references for own inputs/outputs
+      tar czf {{ self.outputs.archive }} \
+        {{ dep.build.outputs.binary }} \
+        {{ self.inputs.manifest }}
+
   deploy:
     desc: Deploy to environment
-    deps: [build]
+    deps: [package]
     args: [environment, region=us-west-1]
     cmd: |
       echo "Deploying to {{ arg.environment }} in {{ arg.region }}"
       # Reference named output from dependency
-      scp {{ dep.build.outputs.binary }} server:/opt/
+      scp {{ dep.package.outputs.archive }} server:/opt/
       ./deploy.sh {{ arg.environment }} {{ arg.region }}
 ```
 

{tasktree-0.0.20 → tasktree-0.0.21}/schema/tasktree-schema.json

@@ -244,21 +244,36 @@
               ]
             },
             "inputs": {
-              "description": "Input file patterns (glob supported). Task re-runs if inputs change.",
+              "description": "Input file patterns (glob supported). Supports anonymous inputs (strings) and named inputs (objects). Named inputs can be referenced in the same task using {{ self.inputs.name }}. Task re-runs if inputs change.",
               "oneOf": [
                 {
                   "type": "array",
                   "items": {
-                    "type": "string"
+                    "oneOf": [
+                      {
+                        "type": "string",
+                        "description": "Anonymous input file pattern"
+                      },
+                      {
+                        "type": "object",
+                        "description": "Named input (format: { name: 'path/to/file' })",
+                        "minProperties": 1,
+                        "maxProperties": 1,
+                        "additionalProperties": {
+                          "type": "string"
+                        }
+                      }
+                    ]
                   }
                 },
                 {
-                  "type": "string"
+                  "type": "string",
+                  "description": "Single anonymous input file pattern"
                 }
               ]
             },
             "outputs": {
-              "description": "Output file patterns (glob supported). Supports anonymous outputs (strings) and named outputs (objects). Named outputs can be referenced by dependent tasks using {{ dep.task.outputs.name }}. Task re-runs if outputs missing.",
+              "description": "Output file patterns (glob supported). Supports anonymous outputs (strings) and named outputs (objects). Named outputs can be referenced by dependent tasks using {{ dep.task.outputs.name }} or in the same task using {{ self.outputs.name }}. Task re-runs if outputs missing.",
               "oneOf": [
                 {
                   "type": "array",
@@ -352,7 +367,7 @@
             },
             "cmd": {
               "type": "string",
-              "description": "Shell command to execute. Use {{arg}} for parameter substitution."
+              "description": "Shell command to execute. Supports template substitution: {{ arg.name }} for arguments, {{ var.name }} for variables, {{ env.NAME }} for environment variables, {{ dep.task.outputs.name }} for dependency outputs, {{ self.inputs.name }} and {{ self.outputs.name }} for own inputs/outputs, {{ tt.* }} for built-in variables."
             }
           },
           "required": ["cmd"],

tasktree-0.0.21/src/__init__.py

@@ -0,0 +1,4 @@
+"""
+A task automation tool that combines simple command execution with dependency tracking and incremental execution.
+@athena: e94406c67571
+"""

{tasktree-0.0.20 → tasktree-0.0.21}/src/tasktree/__init__.py

@@ -1,4 +1,7 @@
-"""Task Tree - A task automation tool with intelligent incremental execution."""
+"""
+Task Tree - A task automation tool with intelligent incremental execution.
+@athena: 1b4a97c4bc42
+"""
 
 try:
     from importlib.metadata import version