tasktree 0.0.11__tar.gz → 0.0.13__tar.gz

tasktree-0.0.13/.github/workflows/validate-pipx-install.yml

@@ -0,0 +1,122 @@
+name: Validate pipx Installation
+
+on:
+  workflow_run:
+    workflows: ["Release to PyPI"]
+    types:
+      - completed
+  workflow_dispatch:  # Allow manual triggering
+
+jobs:
+  validate-installation:
+    # Only run if the release workflow succeeded
+    if: ${{ github.event.workflow_run.conclusion == 'success' || github.event_name == 'workflow_dispatch' }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: Ubuntu
+          - os: macos-latest
+            platform: macOS
+          - os: windows-latest
+            platform: Windows
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Wait for PyPI propagation
+        if: github.event_name == 'workflow_run'
+        run: |
+          echo "Waiting 90 seconds for PyPI to propagate the new package..."
+          sleep 90
+        shell: bash
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install pipx
+        run: |
+          python -m pip install --user pipx
+          python -m pipx ensurepath
+        shell: bash
+
+      - name: Install tasktree via pipx
+        run: |
+          python -m pipx install tasktree
+        shell: bash
+
+      - name: Test tt --list command
+        working-directory: example
+        run: |
+          tt --list
+        shell: bash
+
+      - name: Run test task
+        working-directory: example
+        run: |
+          tt package
+        shell: bash
+
+      - name: Verify installation
+        run: |
+          echo "✓ tasktree successfully installed via pipx on ${{ matrix.platform }}"
+
+  validate-centos:
+    # Only run if the release workflow succeeded
+    if: ${{ github.event.workflow_run.conclusion == 'success' || github.event_name == 'workflow_dispatch' }}
+    runs-on: ubuntu-latest
+    container:
+      image: quay.io/centos/centos:stream9
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Wait for PyPI propagation
+        if: github.event_name == 'workflow_run'
+        run: |
+          echo "Waiting 90 seconds for PyPI to propagate the new package..."
+          sleep 90
+
+      - name: Install dependencies
+        run: |
+          dnf install -y python python-pip
+        shell: bash
+
+      - name: Install Python 3.12
+        run: dnf install -y python3.12
+        shell: bash
+
+      - name: Install pipx with Python 3.12
+        run: |
+          pip install pipx
+          pipx ensurepath
+        shell: bash
+
+      - name: Install tasktree via pipx with Python 3.12
+        run: |
+          pipx install --python python3.12 tasktree
+        shell: bash
+
+      - name: Test tt --list command
+        working-directory: example
+        run: |
+          export PATH="$HOME/.local/bin:$PATH"
+          tt --list
+        shell: bash
+
+      - name: Run test task
+        working-directory: example
+        run: |
+          export PATH="$HOME/.local/bin:$PATH"
+          tt package
+        shell: bash
+
+      - name: Verify installation
+        run: |
+          echo "✓ tasktree successfully installed via pipx on CentOS Stream 9"

{tasktree-0.0.11 → tasktree-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.11
+Version: 0.0.13
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -718,10 +718,13 @@ For more complex scenarios, define environment variables in the `variables` sect
 
 ```yaml
 variables:
-  # Direct env reference (resolved at parse time)
+  # Required env var (error if not set)
   api_key: { env: API_KEY }
-  db_host: { env: DATABASE_HOST }
-
+  
+  # Optional env var with default
+  port: { env: PORT, default: "8080" }
+  log_level: { env: LOG_LEVEL, default: "info" }
+  
   # Or using string substitution
   deploy_user: "{{ env.DEPLOY_USER }}"
 

{tasktree-0.0.11 → tasktree-0.0.13}/README.md

@@ -703,10 +703,13 @@ For more complex scenarios, define environment variables in the `variables` sect
 
 ```yaml
 variables:
-  # Direct env reference (resolved at parse time)
+  # Required env var (error if not set)
   api_key: { env: API_KEY }
-  db_host: { env: DATABASE_HOST }
-
+  
+  # Optional env var with default
+  port: { env: PORT, default: "8080" }
+  log_level: { env: LOG_LEVEL, default: "info" }
+  
   # Or using string substitution
   deploy_user: "{{ env.DEPLOY_USER }}"
 

tasktree-0.0.13/example/tasktree.yaml

@@ -0,0 +1,33 @@
+tasks:
+  build:
+    desc: Building outputs (imagine this is a call to Cargo, or gcc, or something)
+    args:
+      - build_type:
+          choices: [ "debug", "release" ]
+      - 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..."
+
+  clean:
+    desc: Clean generated files
+    inputs: [ archive.tar.gz ]
+    cmd: rm -f archive.tar.gz

{tasktree-0.0.11 → tasktree-0.0.13}/pyproject.toml

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

{tasktree-0.0.11 → tasktree-0.0.13}/src/tasktree/cli.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import os
+import sys
 from pathlib import Path
 from typing import Any, List, Optional
 
@@ -26,6 +28,46 @@ app = typer.Typer(
 console = Console()
 
 
+def _supports_unicode() -> bool:
+    """Check if the terminal supports Unicode characters.
+
+    Returns:
+        True if terminal supports UTF-8, False otherwise
+    """
+    # Hard stop: classic Windows console (conhost)
+    if os.name == "nt" and "WT_SESSION" not in os.environ:
+        return False
+
+    # Encoding check
+    encoding = sys.stdout.encoding
+    if not encoding:
+        return False
+
+    try:
+        "✓✗".encode(encoding)
+        return True
+    except UnicodeEncodeError:
+        return False
+
+
+def get_action_success_string() -> str:
+    """Get the appropriate success symbol based on terminal capabilities.
+
+    Returns:
+        Unicode tick symbol (✓) if terminal supports UTF-8, otherwise "[ OK ]"
+    """
+    return "✓" if _supports_unicode() else "[ OK ]"
+
+
+def get_action_failure_string() -> str:
+    """Get the appropriate failure symbol based on terminal capabilities.
+
+    Returns:
+        Unicode cross symbol (✗) if terminal supports UTF-8, otherwise "[ FAIL ]"
+    """
+    return "✗" if _supports_unicode() else "[ FAIL ]"
+
+
 def _format_task_arguments(arg_specs: list[str | dict]) -> str:
     """Format task arguments for display in list output.
 
@@ -324,7 +366,7 @@ def _clean_state(tasks_file: Optional[str] = None) -> None:
 
     if state_path.exists():
         state_path.unlink()
-        console.print(f"[green]✓ Removed {state_path}[/green]")
+        console.print(f"[green]{get_action_success_string()} Removed {state_path}[/green]")
         console.print("All tasks will run fresh on next execution")
     else:
         console.print(f"[yellow]No state file found at {state_path}[/yellow]")
@@ -410,9 +452,9 @@ def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = Fal
     state.save()
     try:
         executor.execute_task(task_name, args_dict, force=force, only=only)
-        console.print(f"[green]✓ Task '{task_name}' completed successfully[/green]")
+        console.print(f"[green]{get_action_success_string()} Task '{task_name}' completed successfully[/green]")
     except Exception as e:
-        console.print(f"[red]✗ Task '{task_name}' failed: {e}[/red]")
+        console.print(f"[red]{get_action_failure_string()} Task '{task_name}' failed: {e}[/red]")
         raise typer.Exit(1)
 
 

{tasktree-0.0.11 → tasktree-0.0.13}/src/tasktree/parser.py

@@ -287,26 +287,35 @@ def _is_env_variable_reference(value: Any) -> bool:
     return isinstance(value, dict) and "env" in value
 
 
-def _validate_env_variable_reference(var_name: str, value: dict) -> str:
-    """Validate and extract environment variable name from reference.
+def _validate_env_variable_reference(var_name: str, value: dict) -> tuple[str, str | None]:
+    """Validate and extract environment variable name and optional default from reference.
 
     Args:
         var_name: Name of the variable being defined
-        value: Dict that should be { env: ENV_VAR_NAME }
+        value: Dict that should be { env: ENV_VAR_NAME } or { env: ENV_VAR_NAME, default: "value" }
 
     Returns:
-        Environment variable name
+        Tuple of (environment variable name, default value or None)
 
     Raises:
         ValueError: If reference is invalid
     """
-    # Validate dict structure
-    if len(value) != 1:
-        extra_keys = [k for k in value.keys() if k != "env"]
+    # Validate dict structure - allow 'env' and optionally 'default'
+    valid_keys = {"env", "default"}
+    invalid_keys = set(value.keys()) - valid_keys
+    if invalid_keys:
         raise ValueError(
             f"Invalid environment variable reference in variable '{var_name}'.\n"
-            f"Expected: {{ env: VARIABLE_NAME }}\n"
-            f"Found extra keys: {', '.join(extra_keys)}"
+            f"Expected: {{ env: VARIABLE_NAME }} or {{ env: VARIABLE_NAME, default: \"value\" }}\n"
+            f"Found invalid keys: {', '.join(invalid_keys)}"
+        )
+
+    # Validate 'env' key is present
+    if "env" not in value:
+        raise ValueError(
+            f"Invalid environment variable reference in variable '{var_name}'.\n"
+            f"Missing required 'env' key.\n"
+            f"Expected: {{ env: VARIABLE_NAME }} or {{ env: VARIABLE_NAME, default: \"value\" }}"
         )
 
     env_var_name = value["env"]
@@ -315,7 +324,7 @@ def _validate_env_variable_reference(var_name: str, value: dict) -> str:
     if not env_var_name or not isinstance(env_var_name, str):
         raise ValueError(
             f"Invalid environment variable reference in variable '{var_name}'.\n"
-            f"Expected: {{ env: VARIABLE_NAME }}\n"
+            f"Expected: {{ env: VARIABLE_NAME }} or {{ env: VARIABLE_NAME, default: \"value\" }}"
             f"Found: {{ env: {env_var_name!r} }}"
         )
 
@@ -327,23 +336,36 @@ def _validate_env_variable_reference(var_name: str, value: dict) -> str:
             f"and contain only alphanumerics and underscores."
         )
 
-    return env_var_name
+    # Extract and validate default if present
+    default = value.get("default")
+    if default is not None:
+        # Default must be a string (env vars are always strings)
+        if not isinstance(default, str):
+            raise ValueError(
+                f"Invalid default value in variable '{var_name}'.\n"
+                f"Environment variable defaults must be strings.\n"
+                f"Got: {default!r} (type: {type(default).__name__})\n"
+                f"Use a quoted string: {{ env: {env_var_name}, default: \"{default}\" }}"
+            )
+
+    return env_var_name, default
 
 
-def _resolve_env_variable(var_name: str, env_var_name: str) -> str:
+def _resolve_env_variable(var_name: str, env_var_name: str, default: str | None = None) -> str:
     """Resolve environment variable value.
 
     Args:
         var_name: Name of the variable being defined
         env_var_name: Name of environment variable to read
+        default: Optional default value to use if environment variable is not set
 
     Returns:
-        Environment variable value as string
+        Environment variable value as string, or default if not set and default provided
 
     Raises:
-        ValueError: If environment variable is not set
+        ValueError: If environment variable is not set and no default provided
     """
-    value = os.environ.get(env_var_name)
+    value = os.environ.get(env_var_name, default)
 
     if value is None:
         raise ValueError(
@@ -730,11 +752,11 @@ def _resolve_variable_value(
 
         # Check if this is an environment variable reference
         if _is_env_variable_reference(raw_value):
-            # Validate and extract env var name
-            env_var_name = _validate_env_variable_reference(name, raw_value)
+            # Validate and extract env var name and optional default
+            env_var_name, default = _validate_env_variable_reference(name, raw_value)
 
-            # Resolve from os.environ
-            string_value = _resolve_env_variable(name, env_var_name)
+            # Resolve from os.environ (with optional default)
+            string_value = _resolve_env_variable(name, env_var_name, default)
 
             # Still perform variable-in-variable substitution
             from tasktree.substitution import substitute_variables

tasktree-0.0.13/tests/e2e/test_non_docker.py

@@ -0,0 +1,132 @@
+"""E2E tests for non-docker environments."""
+
+import unittest
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from . import run_tasktree_cli
+
+
+class TestNonDockerEnvironment(unittest.TestCase):
+    """Test basic task execution without Docker."""
+
+    def test_simple_parameterized_task(self):
+        """Test that parameterized task executes with default environment value."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            # Create recipe with parameterized task
+            (project_root / "tasktree.yaml").write_text("""
+tasks:
+  deploy:
+    args:
+      - foo
+      - environment: { type: str, choices: ["dev", "staging", "prod"], default: "dev" }
+    outputs: [deploy.log]
+    cmd: |
+      echo "environment={{ arg.environment }}" > deploy.log
+      echo "foo was {{ arg.foo }}"
+""")
+
+            # Execute with positional argument and default environment
+            result = run_tasktree_cli(["deploy", "42"], cwd=project_root)
+
+            # Assert success
+            self.assertEqual(
+                result.returncode,
+                0,
+                f"CLI failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+            )
+
+            # Verify output file
+            output_file = project_root / "deploy.log"
+            self.assertTrue(output_file.exists(), "Output file not created")
+            self.assertEqual(
+                output_file.read_text().strip(),
+                "environment=dev"
+            )
+
+            # Verify terminal output
+            self.assertIn("foo was 42", result.stdout)
+
+    def test_parameterized_task_with_custom_environment(self):
+        """Test that parameterized task executes with explicit environment value."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            # Create recipe with parameterized task
+            (project_root / "tasktree.yaml").write_text("""
+tasks:
+  deploy:
+    args:
+      - foo
+      - environment: { type: str, choices: ["dev", "staging", "prod"], default: "dev" }
+    outputs: [deploy.log]
+    cmd: |
+      echo "environment={{ arg.environment }}" > deploy.log
+      echo "foo was {{ arg.foo }}"
+""")
+
+            # Execute with both arguments
+            result = run_tasktree_cli(["deploy", "42", "environment=prod"], cwd=project_root)
+
+            # Assert success
+            self.assertEqual(
+                result.returncode,
+                0,
+                f"CLI failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+            )
+
+            # Verify output file
+            output_file = project_root / "deploy.log"
+            self.assertTrue(output_file.exists(), "Output file not created")
+            self.assertEqual(
+                output_file.read_text().strip(),
+                "environment=prod"
+            )
+
+            # Verify terminal output
+            self.assertIn("foo was 42", result.stdout)
+
+    def test_list_tasks_output(self):
+        """Test that --list displays tasks with correct formatting."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            # Create recipe with parameterized task
+            (project_root / "tasktree.yaml").write_text("""
+tasks:
+  deploy:
+    desc: Deploy to environment
+    args:
+      - foo
+      - environment: { type: str, choices: ["dev", "staging", "prod"], default: "dev" }
+    outputs: [deploy.log]
+    cmd: |
+      echo "environment={{ arg.environment }}" > deploy.log
+      echo "foo was {{ arg.foo }}"
+""")
+
+            # Execute --list
+            result = run_tasktree_cli(["--list"], cwd=project_root)
+
+            # Assert success
+            self.assertEqual(
+                result.returncode,
+                0,
+                f"CLI failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+            )
+
+            # Verify task name is in output
+            self.assertIn("deploy", result.stdout)
+
+            # Verify description is in output
+            self.assertIn("Deploy to environment", result.stdout)
+
+            # Verify arguments are shown (the actual format includes ANSI codes, so we check for the argument names)
+            self.assertIn("foo", result.stdout)
+            self.assertIn("environment", result.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()