tasktree 0.0.12__tar.gz → 0.0.14__tar.gz

tasktree-0.0.14/.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.12 → tasktree-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.12
+Version: 0.0.14
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0

tasktree-0.0.14/example/tasktree.yaml

@@ -0,0 +1,37 @@
+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..."
+
+  clean:
+    desc: Clean generated files
+    inputs: [ archive.tar.gz ]
+    cmd: rm -f archive.tar.gz

{tasktree-0.0.12 → tasktree-0.0.14}/pyproject.toml

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

{tasktree-0.0.12 → tasktree-0.0.14}/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.12 → tasktree-0.0.14}/src/tasktree/substitution.py

@@ -5,6 +5,7 @@ and {{ env.NAME }} placeholders with their corresponding values.
 """
 
 import re
+from random import choice
 from typing import Any
 
 
@@ -15,11 +16,11 @@ PLACEHOLDER_PATTERN = re.compile(
 )
 
 
-def substitute_variables(text: str, variables: dict[str, str]) -> str:
+def substitute_variables(text: str | dict[str, Any], variables: dict[str, str]) -> str | dict[str, Any]:
     """Substitute {{ var.name }} placeholders with variable values.
 
     Args:
-        text: Text containing {{ var.name }} placeholders
+        text: Text containing {{ var.name }} placeholders, or an argument dict with elements to be substituted
         variables: Dictionary mapping variable names to their string values
 
     Returns:
@@ -28,23 +29,42 @@ def substitute_variables(text: str, variables: dict[str, str]) -> str:
     Raises:
         ValueError: If a referenced variable is not defined
     """
-    def replace_match(match: re.Match) -> str:
-        prefix = match.group(1)
-        name = match.group(2)
-
-        # Only substitute var: placeholders
-        if prefix != "var":
-            return match.group(0)  # Return unchanged
-
-        if name not in variables:
-            raise ValueError(
-                f"Variable '{name}' is not defined. "
-                f"Variables must be defined before use."
-            )
-
-        return variables[name]
-
-    return PLACEHOLDER_PATTERN.sub(replace_match, text)
+    if isinstance(text, dict):
+        # The dict will only contain a single key, the value of this key should also be a dictionary, which contains
+        # the actual details of the argument.
+        assert len(text.keys()) == 1
+
+        for arg_name in text.keys():
+            # Pull out and substitute the individual fields of an argument one at a time
+            for field in  [ "default", "min", "max" ]:
+                if field in text[arg_name]:
+                    text[arg_name][field] = substitute_variables(text[arg_name][field], variables)
+
+            # choices is a list of things
+            if "choices" in text[arg_name]:
+                text[arg_name]["choices"] = [substitute_variables(c, variables) for c in text[arg_name]["choices"]]
+
+            return text
+        else:
+            raise ValueError("Empty arg dictionary")
+    else:
+        def replace_match(match: re.Match) -> str:
+            prefix = match.group(1)
+            name = match.group(2)
+
+            # Only substitute var: placeholders
+            if prefix != "var":
+                return match.group(0)  # Return unchanged
+
+            if name not in variables:
+                raise ValueError(
+                    f"Variable '{name}' is not defined. "
+                    f"Variables must be defined before use."
+                )
+
+            return variables[name]
+
+        return PLACEHOLDER_PATTERN.sub(replace_match, text)
 
 
 def substitute_arguments(text: str, args: dict[str, Any], exported_args: set[str] | None = None) -> str:

tasktree-0.0.14/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()

tasktree-0.0.14/tests/unit/test_cli.py

@@ -0,0 +1,202 @@
+"""Tests for CLI argument parsing."""
+
+import sys
+import unittest
+from unittest.mock import MagicMock, patch
+
+import typer
+
+from tasktree.cli import (
+    _parse_task_args,
+    _supports_unicode,
+    get_action_failure_string,
+    get_action_success_string,
+)
+
+
+class TestParseTaskArgs(unittest.TestCase):
+    """Tests for _parse_task_args() function."""
+
+    def test_parse_task_args_positional(self):
+        """Test parsing positional arguments."""
+        arg_specs = ["environment", "region"]
+        arg_values = ["production", "us-east-1"]
+
+        result = _parse_task_args(arg_specs, arg_values)
+
+        self.assertEqual(result, {"environment": "production", "region": "us-east-1"})
+
+    def test_parse_task_args_named(self):
+        """Test parsing name=value arguments."""
+        arg_specs = ["environment", "region"]
+        arg_values = ["environment=production", "region=us-east-1"]
+
+        result = _parse_task_args(arg_specs, arg_values)
+
+        self.assertEqual(result, {"environment": "production", "region": "us-east-1"})
+
+    def test_parse_task_args_with_defaults(self):
+        """Test default values applied."""
+        arg_specs = ["environment", {"region": {"default": "us-west-1"}}]
+        arg_values = ["production"]  # Only provide first arg
+
+        result = _parse_task_args(arg_specs, arg_values)
+
+        self.assertEqual(result, {"environment": "production", "region": "us-west-1"})
+
+    def test_parse_task_args_type_conversion(self):
+        """Test values converted to correct types."""
+        arg_specs = [{"port": {"type": "int"}}, {"debug": {"type": "bool"}}, {"timeout": {"type": "float"}}]
+        arg_values = ["8080", "true", "30.5"]
+
+        result = _parse_task_args(arg_specs, arg_values)
+
+        self.assertEqual(result, {"port": 8080, "debug": True, "timeout": 30.5})
+        self.assertIsInstance(result["port"], int)
+        self.assertIsInstance(result["debug"], bool)
+        self.assertIsInstance(result["timeout"], float)
+
+    def test_parse_task_args_unknown_argument(self):
+        """Test error for unknown argument name."""
+        arg_specs = ["environment"]
+        arg_values = ["unknown_arg=value"]
+
+        with self.assertRaises(typer.Exit):
+            _parse_task_args(arg_specs, arg_values)
+
+    def test_parse_task_args_too_many(self):
+        """Test error for too many positional args."""
+        arg_specs = ["environment"]
+        arg_values = ["production", "extra_value"]
+
+        with self.assertRaises(typer.Exit):
+            _parse_task_args(arg_specs, arg_values)
+
+    def test_parse_task_args_missing_required(self):
+        """Test error for missing required argument."""
+        arg_specs = ["environment", "region"]
+        arg_values = ["production"]  # Missing 'region'
+
+        with self.assertRaises(typer.Exit):
+            _parse_task_args(arg_specs, arg_values)
+
+    def test_parse_task_args_invalid_type(self):
+        """Test error for invalid type conversion."""
+        arg_specs = [{"port": {"type": "int"}}]
+        arg_values = ["not_a_number"]
+
+        with self.assertRaises(typer.Exit):
+            _parse_task_args(arg_specs, arg_values)
+
+    def test_parse_task_args_empty(self):
+        """Test returns empty dict when no args."""
+        arg_specs = []
+        arg_values = []
+
+        result = _parse_task_args(arg_specs, arg_values)
+
+        self.assertEqual(result, {})
+
+    def test_parse_task_args_mixed(self):
+        """Test mixing positional and named arguments."""
+        arg_specs = ["environment", "region", {"verbose": {"type": "bool"}}]
+        arg_values = ["production", "region=us-east-1", "verbose=true"]
+
+        result = _parse_task_args(arg_specs, arg_values)
+
+        self.assertEqual(result, {
+            "environment": "production",
+            "region": "us-east-1",
+            "verbose": True
+        })
+
+
+class TestUnicodeSupport(unittest.TestCase):
+    """Tests for Unicode symbol detection functions."""
+
+    @patch('tasktree.cli.os.environ', {})
+    @patch('tasktree.cli.os.name', 'posix')
+    @patch('tasktree.cli.sys.stdout')
+    def test_supports_unicode_with_utf8_encoding(self, mock_stdout):
+        """Test that UTF-8 encoding returns True."""
+        mock_stdout.encoding = 'utf-8'
+        self.assertTrue(_supports_unicode())
+
+    @patch('tasktree.cli.os.environ', {})
+    @patch('tasktree.cli.os.name', 'posix')
+    @patch('tasktree.cli.sys.stdout')
+    def test_supports_unicode_with_utf8_uppercase(self, mock_stdout):
+        """Test that UTF-8 (uppercase) encoding returns True."""
+        mock_stdout.encoding = 'UTF-8'
+        self.assertTrue(_supports_unicode())
+
+    @patch('tasktree.cli.os.environ', {})
+    @patch('tasktree.cli.os.name', 'nt')
+    @patch('tasktree.cli.sys.stdout')
+    def test_supports_unicode_on_classic_windows_console(self, mock_stdout):
+        """Test that classic Windows console (conhost) returns False."""
+        mock_stdout.encoding = 'utf-8'
+        # No WT_SESSION in environ means classic console
+        self.assertFalse(_supports_unicode())
+
+    @patch('tasktree.cli.os.environ', {'WT_SESSION': 'some-value'})
+    @patch('tasktree.cli.os.name', 'nt')
+    @patch('tasktree.cli.sys.stdout')
+    def test_supports_unicode_on_windows_terminal(self, mock_stdout):
+        """Test that Windows Terminal with UTF-8 returns True."""
+        mock_stdout.encoding = 'utf-8'
+        # WT_SESSION present means Windows Terminal
+        self.assertTrue(_supports_unicode())
+
+    @patch('tasktree.cli.os.environ', {})
+    @patch('tasktree.cli.os.name', 'posix')
+    @patch('tasktree.cli.sys.stdout')
+    def test_supports_unicode_with_encoding_that_fails_encode(self, mock_stdout):
+        """Test that encoding that can't encode symbols returns False."""
+        # ASCII encoding will fail to encode ✓✗
+        mock_stdout.encoding = 'ascii'
+        self.assertFalse(_supports_unicode())
+
+    @patch('tasktree.cli.os.environ', {})
+    @patch('tasktree.cli.os.name', 'posix')
+    @patch('tasktree.cli.sys.stdout')
+    def test_supports_unicode_with_none_encoding(self, mock_stdout):
+        """Test that None encoding returns False."""
+        mock_stdout.encoding = None
+        self.assertFalse(_supports_unicode())
+
+    @patch('tasktree.cli.os.environ', {})
+    @patch('tasktree.cli.os.name', 'posix')
+    @patch('tasktree.cli.sys.stdout')
+    def test_supports_unicode_with_latin1_encoding(self, mock_stdout):
+        """Test that Latin-1 encoding returns False (can't encode symbols)."""
+        mock_stdout.encoding = 'latin-1'
+        self.assertFalse(_supports_unicode())
+
+    @patch('tasktree.cli._supports_unicode')
+    def test_get_action_success_string_with_unicode(self, mock_supports):
+        """Test success string returns Unicode symbol when supported."""
+        mock_supports.return_value = True
+        self.assertEqual(get_action_success_string(), "✓")
+
+    @patch('tasktree.cli._supports_unicode')
+    def test_get_action_success_string_without_unicode(self, mock_supports):
+        """Test success string returns ASCII when Unicode not supported."""
+        mock_supports.return_value = False
+        self.assertEqual(get_action_success_string(), "[ OK ]")
+
+    @patch('tasktree.cli._supports_unicode')
+    def test_get_action_failure_string_with_unicode(self, mock_supports):
+        """Test failure string returns Unicode symbol when supported."""
+        mock_supports.return_value = True
+        self.assertEqual(get_action_failure_string(), "✗")
+
+    @patch('tasktree.cli._supports_unicode')
+    def test_get_action_failure_string_without_unicode(self, mock_supports):
+        """Test failure string returns ASCII when Unicode not supported."""
+        mock_supports.return_value = False
+        self.assertEqual(get_action_failure_string(), "[ FAIL ]")
+
+
+if __name__ == "__main__":
+    unittest.main()

tasktree-0.0.12/example/tasktree.yaml

@@ -1,16 +0,0 @@
-tasks:
-  process:
-    desc: Process source file
-    inputs: [source.txt]
-    outputs: [output.txt]
-    cmd: cat source.txt > output.txt
-
-  package:
-    desc: Create archive
-    deps: [process]
-    outputs: [archive.tar.gz]
-    cmd: tar czf archive.tar.gz output.txt
-
-  clean:
-    desc: Clean generated files
-    cmd: rm -f output.txt archive.tar.gz

tasktree-0.0.12/tests/unit/test_cli.py

@@ -1,109 +0,0 @@
-"""Tests for CLI argument parsing."""
-
-import unittest
-from unittest.mock import patch
-
-import typer
-
-from tasktree.cli import _parse_task_args
-
-
-class TestParseTaskArgs(unittest.TestCase):
-    """Tests for _parse_task_args() function."""
-
-    def test_parse_task_args_positional(self):
-        """Test parsing positional arguments."""
-        arg_specs = ["environment", "region"]
-        arg_values = ["production", "us-east-1"]
-
-        result = _parse_task_args(arg_specs, arg_values)
-
-        self.assertEqual(result, {"environment": "production", "region": "us-east-1"})
-
-    def test_parse_task_args_named(self):
-        """Test parsing name=value arguments."""
-        arg_specs = ["environment", "region"]
-        arg_values = ["environment=production", "region=us-east-1"]
-
-        result = _parse_task_args(arg_specs, arg_values)
-
-        self.assertEqual(result, {"environment": "production", "region": "us-east-1"})
-
-    def test_parse_task_args_with_defaults(self):
-        """Test default values applied."""
-        arg_specs = ["environment", {"region": {"default": "us-west-1"}}]
-        arg_values = ["production"]  # Only provide first arg
-
-        result = _parse_task_args(arg_specs, arg_values)
-
-        self.assertEqual(result, {"environment": "production", "region": "us-west-1"})
-
-    def test_parse_task_args_type_conversion(self):
-        """Test values converted to correct types."""
-        arg_specs = [{"port": {"type": "int"}}, {"debug": {"type": "bool"}}, {"timeout": {"type": "float"}}]
-        arg_values = ["8080", "true", "30.5"]
-
-        result = _parse_task_args(arg_specs, arg_values)
-
-        self.assertEqual(result, {"port": 8080, "debug": True, "timeout": 30.5})
-        self.assertIsInstance(result["port"], int)
-        self.assertIsInstance(result["debug"], bool)
-        self.assertIsInstance(result["timeout"], float)
-
-    def test_parse_task_args_unknown_argument(self):
-        """Test error for unknown argument name."""
-        arg_specs = ["environment"]
-        arg_values = ["unknown_arg=value"]
-
-        with self.assertRaises(typer.Exit):
-            _parse_task_args(arg_specs, arg_values)
-
-    def test_parse_task_args_too_many(self):
-        """Test error for too many positional args."""
-        arg_specs = ["environment"]
-        arg_values = ["production", "extra_value"]
-
-        with self.assertRaises(typer.Exit):
-            _parse_task_args(arg_specs, arg_values)
-
-    def test_parse_task_args_missing_required(self):
-        """Test error for missing required argument."""
-        arg_specs = ["environment", "region"]
-        arg_values = ["production"]  # Missing 'region'
-
-        with self.assertRaises(typer.Exit):
-            _parse_task_args(arg_specs, arg_values)
-
-    def test_parse_task_args_invalid_type(self):
-        """Test error for invalid type conversion."""
-        arg_specs = [{"port": {"type": "int"}}]
-        arg_values = ["not_a_number"]
-
-        with self.assertRaises(typer.Exit):
-            _parse_task_args(arg_specs, arg_values)
-
-    def test_parse_task_args_empty(self):
-        """Test returns empty dict when no args."""
-        arg_specs = []
-        arg_values = []
-
-        result = _parse_task_args(arg_specs, arg_values)
-
-        self.assertEqual(result, {})
-
-    def test_parse_task_args_mixed(self):
-        """Test mixing positional and named arguments."""
-        arg_specs = ["environment", "region", {"verbose": {"type": "bool"}}]
-        arg_values = ["production", "region=us-east-1", "verbose=true"]
-
-        result = _parse_task_args(arg_specs, arg_values)
-
-        self.assertEqual(result, {
-            "environment": "production",
-            "region": "us-east-1",
-            "verbose": True
-        })
-
-
-if __name__ == "__main__":
-    unittest.main()