tasktree 0.0.2__tar.gz

tasktree-0.0.2/.github/workflows/release.yml

@@ -0,0 +1,62 @@
+name: Release to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'  # Triggers on tags like v1.0.0, v1.2.3, etc.
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write  # For creating GitHub release
+      id-token: write  # For trusted publishing to PyPI
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Full history for proper version detection
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Extract version from tag
+        id: get_version
+        run: |
+          VERSION=${GITHUB_REF#refs/tags/v}
+          echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+          echo "Releasing version $VERSION"
+
+      - name: Update version in pyproject.toml
+        run: |
+          sed -i 's/version = ".*"/version = "${{ steps.get_version.outputs.VERSION }}"/' pyproject.toml
+          cat pyproject.toml | grep version
+
+      - name: Build package
+        run: uv build
+
+      - name: Verify wheel contents
+        run: |
+          unzip -l dist/*.whl
+          ls -lh dist/
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/*
+          generate_release_notes: true
+          draft: false
+          prerelease: false
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          # Uses trusted publisher authentication (no API token needed)
+          # Configure at https://pypi.org/manage/account/publishing/
+          packages-dir: dist/

tasktree-0.0.2/.github/workflows/test.yml

@@ -0,0 +1,61 @@
+name: Tests
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ['3.11', '3.12']
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v4
+
+    - name: Install dependencies
+      run: |
+        uv pip install --system -e ".[dev]"
+
+    - name: Run tests
+      run: |
+        python -m pytest tests/ -v --tb=short
+
+    - name: Test CLI commands
+      run: |
+        python -m tasktree.cli --help
+        python -m tasktree.cli --list || true
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v4
+
+    - name: Install dependencies
+      run: |
+        uv pip install --system -e ".[dev]"
+
+    - name: Check code can be imported
+      run: |
+        python -c "from tasktree import Executor, Recipe, Task; print('Import successful')"

tasktree-0.0.2/.gitignore

@@ -0,0 +1,161 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# IDEs
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+.project
+.pydevproject
+.settings/
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+Desktop.ini
+
+# Task Tree specific
+.tasktree-state
+
+# Example outputs (keep source files but ignore generated outputs)
+example/output.txt
+example/archive.tar.gz
+example/.tasktree-state
+
+# UV lock file (optional - some prefer to commit this)
+# uv.lock

tasktree-0.0.2/CLAUDE.md

@@ -0,0 +1,69 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Task Tree (tt) is a task automation tool that combines simple command execution with intelligent dependency tracking and incremental execution. The project is a Python application built with a focus on:
+
+- **Intelligent incremental execution**: Tasks only run when necessary based on input changes, dependency updates, or task definition changes
+- **YAML-based task definition**: Tasks are defined in `tasktree.yaml` or `tt.yaml` files with dependencies, inputs, outputs, and commands
+- **Automatic input inheritance**: Tasks automatically inherit inputs from dependencies
+- **Parameterized tasks**: Tasks can accept typed arguments with defaults
+- **File imports**: Task definitions can be split across multiple files and namespaced
+
+## Architecture
+
+### Core Components
+
+- **`src/tasktree/tasks.py`**: Core task execution logic using subprocess to run shell commands
+- **`src/tasktree/cli.py`**: Command-line interface (currently minimal)
+- **`main.py`**: Entry point for the application
+- **`tests/unit/test_tasks.py`**: Unit tests using Python's unittest framework
+
+### Key Dependencies
+
+- **PyYAML**: For recipe parsing
+- **Typer, Click, Rich**: For CLI (mentioned in README but not yet implemented)
+- **graphlib.TopologicalSorter**: For dependency resolution
+- **pathlib**: For file operations and glob expansion
+
+## Development Commands
+
+### Testing
+```bash
+python -m pytest tests/
+```
+
+### Running the Application
+```bash
+python main.py
+```
+
+### Package Management
+This project uses `uv` for dependency management (indicated by `uv.lock` file).
+
+## State Management
+
+The application uses a `.tasktree-state` file at the project root to track:
+- When tasks last ran
+- Timestamps of input files at execution time
+- Task hashes based on command, outputs, and working directory
+
+## Testing Approach
+
+The project uses Python's built-in `unittest` framework with mocking via `unittest.mock`. Tests focus on verifying subprocess calls for task execution.
+
+## Task Definition Format
+
+Tasks are defined in YAML with the following structure:
+```yaml
+task-name:
+  desc: Description (optional)
+  deps: [dependency-tasks]
+  inputs: [glob-patterns]
+  outputs: [glob-patterns]
+  working_dir: execution-directory
+  args: [typed-parameters]
+  cmd: shell-command
+```

tasktree-0.0.2/PKG-INFO

@@ -0,0 +1,375 @@
+Metadata-Version: 2.4
+Name: tasktree
+Version: 0.0.2
+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: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=9.0.2; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Task Tree (tt)
+
+[![Tests](https://github.com/kevinchannon/task-tree/actions/workflows/test.yml/badge.svg)](https://github.com/kevinchannon/task-tree/actions/workflows/test.yml)
+
+A task automation tool that combines simple command execution with dependency tracking and incremental execution.
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pipx install tasktree
+```
+
+### From Source
+
+For the latest unreleased version from GitHub:
+
+```bash
+pipx install git+https://github.com/kevinchannon/task-tree.git
+```
+
+Or to install from a local clone:
+
+```bash
+git clone https://github.com/kevinchannon/task-tree.git
+cd tasktree
+pipx install .
+```
+
+## 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
+
+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 --list         # Show all available tasks
+```
+
+## Core Concepts
+
+### Intelligent Incremental Execution
+
+Task Tree only runs tasks when necessary. A task executes if:
+
+- Its definition (command, outputs, working directory) has changed
+- Any input files have changed since the last run
+- Any dependencies have re-run
+- It has never been executed before
+- It has no inputs or outputs (always runs)
+
+### Automatic Input Inheritance
+
+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
+```
+
+### Single State File
+
+All state lives in `.tasktree-state` at your project root. Stale entries are automatically pruned—no manual cleanup needed.
+
+## Task Definition
+
+### 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)
+  args: [param1, param2:path=default]   # Task parameters
+  cmd: go build -o dist/binary     # Command to execute
+```
+
+### Commands
+
+Multi-line commands using YAML literal blocks:
+
+```yaml
+deploy:
+  cmd: |
+    mkdir -p dist
+    cp build/* dist/
+    rsync -av dist/ server:/opt/app/
+```
+
+Or folded blocks for long single-line commands:
+
+```yaml
+compile:
+  cmd: >
+    gcc -o bin/app
+    src/*.c
+    -I include
+    -L lib -lm
+```
+
+### Parameterised 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}}
+```
+
+Invoke with: `tt deploy production` or `tt deploy staging us-east-1` or `tt deploy staging region=us-east-1`. 
+
+Arguments may be typed, or not and have a default, or not. Valid argument types are:
+
+* int - an integer value (e.g. 0, 10, 123, -9)
+* float - a floating point value (e.g. 1.234, -3.1415, 2e-4)
+* bool - Boolean-ish value (e.g. true, false, yes, no, 1, 0, etc)
+* str - a string
+* path - a pathlike string
+* datetime - a datetime in the format 2025-12-17T16:56:12
+* ip - an ip address (v4 or v6)
+* ipv4 - an IPv4 value
+* ipv6 - an IPv6 value
+* email - String validated, but not positively confirmed to be a reachable address.
+* hostname - looks like a hostname, resolution of the name is not attempted as part of the validation
+
+Different argument values are tracked separately—tasks re-run when invoked with new arguments.
+
+## File Imports
+
+Split task definitions across multiple files for better organisation:
+
+```yaml
+# tasktree.yaml
+import:
+  - file: build/tasks.yml
+    as: build
+  - file: deploy/tasks.yml
+    as: deploy
+
+test:
+  deps: [build.compile, build.test-compile]
+  cmd: ./run-tests.sh
+
+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.
+
+## Glob Patterns
+
+Input and output patterns support standard glob syntax:
+
+- `src/*.rs` — All Rust files in `src/`
+- `src/**/*.rs` — All Rust files recursively
+- `{file1,file2}` — Specific files
+- `**/*.{js,ts}` — Multiple extensions recursively
+
+## State Management
+
+### How State Works
+
+Each task is identified by a hash of its definition (command, outputs, working directory). State tracks:
+
+- When the task last ran
+- Timestamps of input files at that time
+
+Tasks are re-run when their definition changes or inputs are newer than the last run.
+
+### What's Not In The Hash
+
+Changes to these don't invalidate cached state:
+
+- Task name (tasks can be renamed freely)
+- Description
+- Dependencies (only affects execution order)
+- Explicit inputs (tracked by timestamp, not definition)
+
+### Automatic Cleanup
+
+At the start of each invocation, state is checked for invalid task hashes and non-existent ones are automatically removed. Delete a task from your recipe file and its state disappears the next time you run `tt <cmd>`
+
+## Example: Full Build Pipeline
+
+```yaml
+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}}
+```
+
+Run the full pipeline:
+
+```bash
+tt integration-test staging version=1.2.3
+```
+
+This will:
+1. Compile if sources have changed
+2. Run unit tests if compilation ran
+3. Package if compilation ran or version argument is new
+4. Build Docker runtime (from imported file) if needed
+5. Deploy if package or Docker image changed
+6. Run integration tests (always runs)
+
+## Implementation Notes
+
+Built with Python 3.11+ using:
+
+- **PyYAML** for recipe parsing
+- **Typer**, **Click**, **Rich** for CLI
+- **graphlib.TopologicalSorter** for dependency resolution
+- **pathlib** for file operations and glob expansion
+
+State file uses JSON format for simplicity and standard library compatibility.
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Clone repository
+git clone https://github.com/kevinchannon/task-tree.git
+cd tasktree
+
+# Install uv (if not already installed)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Install dependencies
+uv sync
+
+# Install in editable mode
+pipx install -e .
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+uv run pytest
+
+# Run with verbose output
+uv run pytest -v
+
+# Run specific test file
+uv run pytest tests/unit/test_executor.py
+```
+
+### Using Task Tree for Development
+
+The repository includes a `tasktree.yaml` with development tasks:
+
+```bash
+tt test          # Run tests
+tt build         # Build wheel package
+tt install-dev   # Install package in development mode
+tt clean         # Remove build artifacts
+```
+
+## Releasing
+
+New releases are created by pushing version tags to GitHub. The release workflow automatically:
+- Builds wheel and source distributions
+- Creates a GitHub Release with artifacts
+- Publishes to PyPI via trusted publishing
+
+### Release Process
+
+1. Ensure main branch is ready:
+```bash
+git checkout main
+git pull
+```
+
+2. Create and push a version tag:
+```bash
+git tag v1.0.0
+git push origin v1.0.0
+```
+
+3. GitHub Actions will automatically:
+   - Extract version from tag (e.g., `v1.0.0` → `1.0.0`)
+   - Update `pyproject.toml` with the version
+   - Build wheel and sdist
+   - Create GitHub Release
+   - Publish to PyPI
+
+4. Verify the release:
+   - GitHub: https://github.com/kevinchannon/task-tree/releases
+   - PyPI: https://pypi.org/kevinchannon/tasktree/
+   - Test: `pipx install --force tasktree`
+
+### Version Numbering
+
+Follow semantic versioning:
+- `v1.0.0` - Major release (breaking changes)
+- `v1.1.0` - Minor release (new features, backward compatible)
+- `v1.1.1` - Patch release (bug fixes)