tasktree 0.0.9__tar.gz → 0.0.11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.9
+Version: 0.0.11
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -604,7 +604,9 @@ Dependencies can invoke tasks with specific arguments, enabling flexible and reu
 tasks:
   # Task with parameters
   process:
-    args: [mode, verbose=false]
+    args:
+      - mode
+      - verbose: { default: false }
     cmd: echo "mode={{arg.mode}} verbose={{arg.verbose}}"
 
   # Simple dependency (uses defaults)

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

@@ -589,7 +589,9 @@ Dependencies can invoke tasks with specific arguments, enabling flexible and reu
 tasks:
   # Task with parameters
   process:
-    args: [mode, verbose=false]
+    args:
+      - mode
+      - verbose: { default: false }
     cmd: echo "mode={{arg.mode}} verbose={{arg.verbose}}"
 
   # Simple dependency (uses defaults)

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

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

{tasktree-0.0.9 → tasktree-0.0.11}/schema/tasktree-schema.json

@@ -99,6 +99,70 @@
       },
       "additionalProperties": false
     },
+    "variables": {
+      "description": "Variable definitions that can be referenced in tasks using {{ var.name }} syntax",
+      "type": "object",
+      "patternProperties": {
+        "^[a-zA-Z][a-zA-Z0-9_-]*$": {
+          "oneOf": [
+            {
+              "type": "string",
+              "description": "Simple string value"
+            },
+            {
+              "type": "integer",
+              "description": "Integer value"
+            },
+            {
+              "type": "number",
+              "description": "Floating-point number value"
+            },
+            {
+              "type": "boolean",
+              "description": "Boolean value (true/false)"
+            },
+            {
+              "type": "object",
+              "description": "Environment variable reference",
+              "properties": {
+                "env": {
+                  "type": "string",
+                  "description": "Name of environment variable to read",
+                  "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$"
+                }
+              },
+              "required": ["env"],
+              "additionalProperties": false
+            },
+            {
+              "type": "object",
+              "description": "File read reference",
+              "properties": {
+                "read": {
+                  "type": "string",
+                  "description": "Path to file to read (relative to recipe file, or absolute)"
+                }
+              },
+              "required": ["read"],
+              "additionalProperties": false
+            },
+            {
+              "type": "object",
+              "description": "Eval command reference (executes shell command and captures output)",
+              "properties": {
+                "eval": {
+                  "type": "string",
+                  "description": "Shell command to execute (stdout becomes variable value)"
+                }
+              },
+              "required": ["eval"],
+              "additionalProperties": false
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
     "tasks": {
       "description": "Task definitions",
       "type": "object",
@@ -190,6 +254,7 @@
   "anyOf": [
     { "required": ["tasks"] },
     { "required": ["imports"] },
-    { "required": ["environments"] }
+    { "required": ["environments"] },
+    { "required": ["variables"] }
   ]
 }

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

@@ -192,10 +192,12 @@ tasks:
   # deploy:
   #   desc: Deploy to environment
   #   deps: [build]
-  #   args: [environment, region=eu-west-1]
+  #   args:
+  #     - environment
+  #     - region: { default: eu-west-1 }
   #   cmd: |
-  #     echo "Deploying to {{environment}} in {{region}}"
-  #     ./deploy.sh {{environment}} {{region}}
+  #     echo "Deploying to {{ arg.environment }} in {{ arg.region }}"
+  #     ./deploy.sh {{ arg.environment }} {{ arg.region }}
 
 # Uncomment and modify the examples above to define your tasks
 """

{tasktree-0.0.9 → tasktree-0.0.11}/src/tasktree/docker.py

@@ -87,16 +87,24 @@ class DockerManager:
 
         # Build the image
         try:
+            docker_build_cmd = [
+                "docker",
+                "build",
+                "-t",
+                image_tag,
+                "-f",
+                str(dockerfile_path),
+            ]
+
+            # Add build args if environment has them (docker environments use dict for args)
+            if isinstance(env.args, dict):
+                for arg_name, arg_value in env.args.items():
+                    docker_build_cmd.extend(["--build-arg", f"{arg_name}={arg_value}"])
+
+            docker_build_cmd.append(str(context_path))
+
             subprocess.run(
-                [
-                    "docker",
-                    "build",
-                    "-t",
-                    image_tag,
-                    "-f",
-                    str(dockerfile_path),
-                    str(context_path),
-                ],
+                docker_build_cmd,
                 check=True,
                 capture_output=False,  # Show build output to user
             )

{tasktree-0.0.9 → tasktree-0.0.11}/src/tasktree/hasher.py

@@ -104,9 +104,16 @@ def hash_environment_definition(env) -> str:
     # Import inside function to avoid circular dependency
     from tasktree.parser import Environment
 
+    # Handle args - can be list (shell args) or dict (docker build args)
+    args_value = env.args
+    if isinstance(env.args, dict):
+        args_value = dict(sorted(env.args.items()))  # Sort dict for determinism
+    elif isinstance(env.args, list):
+        args_value = sorted(env.args)  # Sort list for determinism
+
     data = {
         "shell": env.shell,
-        "args": sorted(env.args),  # Sort for determinism
+        "args": args_value,
         "preamble": env.preamble,
         "dockerfile": env.dockerfile,
         "context": env.context,

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

@@ -31,7 +31,7 @@ class Environment:
 
     name: str
     shell: str = ""  # Path to shell (required for shell envs, optional for Docker)
-    args: list[str] = field(default_factory=list)
+    args: list[str] | dict[str, str] = field(default_factory=list)  # Shell args (list) or Docker build args (dict)
     preamble: str = ""
     # Docker-specific fields (presence of dockerfile indicates Docker environment)
     dockerfile: str = ""  # Path to Dockerfile
@@ -44,7 +44,7 @@ class Environment:
     run_as_root: bool = False  # If True, skip user mapping (run as root in container)
 
     def __post_init__(self):
-        """Ensure args is always a list."""
+        """Ensure args is in the correct format."""
         if isinstance(self.args, str):
             self.args = [self.args]
 
@@ -60,7 +60,7 @@ class Task:
     inputs: list[str] = field(default_factory=list)
     outputs: list[str] = field(default_factory=list)
     working_dir: str = ""
-    args: list[str] = field(default_factory=list)
+    args: list[str | dict[str, Any]] = field(default_factory=list)  # Can be strings or dicts (each dict has single key: arg name)
     source_file: str = ""  # Track which file defined this task
     env: str = ""  # Environment name to use for execution
 
@@ -75,6 +75,19 @@ class Task:
         if isinstance(self.args, str):
             self.args = [self.args]
 
+        # Validate args is not a dict (common YAML mistake)
+        if isinstance(self.args, dict):
+            raise ValueError(
+                f"Task '{self.name}' has invalid 'args' syntax.\n\n"
+                f"Found dictionary syntax (without dashes):\n"
+                f"  args:\n"
+                f"    {list(self.args.keys())[0] if self.args else 'key'}: ...\n\n"
+                f"Correct syntax uses list format (with dashes):\n"
+                f"  args:\n"
+                f"    - {list(self.args.keys())[0] if self.args else 'key'}: ...\n\n"
+                f"Arguments must be defined as a list, not a dictionary."
+            )
+
 
 @dataclass
 class DependencyInvocation:
@@ -1246,18 +1259,16 @@ def parse_arg_spec(arg_spec: str | dict) -> ArgSpec:
 
     Supports both string format and dictionary format:
 
-    String format:
+    String format (simple names only):
         - Simple name: "argname"
         - Exported (becomes env var): "$argname"
-        - With default: "argname=value" or "$argname=value"
-        - Legacy type syntax: "argname:type=value" (for backwards compat)
 
     Dictionary format:
         - argname: { default: "value" }
         - argname: { type: int, default: 42 }
         - argname: { type: int, min: 1, max: 100 }
         - argname: { type: str, choices: ["dev", "staging", "prod"] }
-        - $argname: { default: "value" }  # Exported
+        - $argname: { default: "value" }  # Exported (type not allowed)
 
     Args:
         arg_spec: Argument specification (string or dict with single key)
@@ -1315,34 +1326,24 @@ def parse_arg_spec(arg_spec: str | dict) -> ArgSpec:
     if is_exported:
         arg_spec = arg_spec[1:]  # Remove $ prefix
 
-    # Split on = to separate name:type from default
-    if "=" in arg_spec:
-        name_type, default = arg_spec.split("=", 1)
-    else:
-        name_type = arg_spec
-        default = None
-
-    # Split on : to separate name from type
-    if ":" in name_type:
-        name, arg_type = name_type.split(":", 1)
+    # String format only supports simple names (no = or :)
+    if "=" in arg_spec or ":" in arg_spec:
+        raise ValueError(
+            f"Invalid argument syntax: {'$' if is_exported else ''}{arg_spec}\n\n"
+            f"String format only supports simple argument names.\n"
+            f"Use YAML dict format for type annotations, defaults, or constraints:\n"
+            f"  args:\n"
+            f"    - {'$' if is_exported else ''}{arg_spec.split('=')[0].split(':')[0]}: {{ default: value }}"
+        )
 
-        # Exported arguments cannot have type annotations
-        if is_exported:
-            raise ValueError(
-                f"Type annotations not allowed on exported arguments\n"
-                f"In argument: ${name}:{arg_type}\n\n"
-                f"Exported arguments are always strings. Remove the type annotation:\n"
-                f"  args: [${name}]"
-            )
-    else:
-        name = name_type
-        arg_type = "str"
+    name = arg_spec
+    arg_type = "str"
 
-    # String format doesn't support min/max/choices
+    # String format doesn't support min/max/choices/defaults
     return ArgSpec(
         name=name,
         arg_type=arg_type,
-        default=default,
+        default=None,
         is_exported=is_exported,
         min_val=None,
         max_val=None,
@@ -1390,6 +1391,15 @@ def _parse_arg_dict(arg_name: str, config: dict, is_exported: bool) -> ArgSpec:
             f"Exported arguments are always strings. Remove the 'type' field"
         )
 
+    # Exported arguments must have string defaults (if any default is provided)
+    if is_exported and default is not None and not isinstance(default, str):
+        raise ValueError(
+            f"Exported argument '${arg_name}' must have a string default value.\n"
+            f"Got: {default!r} (type: {type(default).__name__})\n"
+            f"Exported arguments become environment variables, which are always strings.\n"
+            f"Use a quoted string: ${arg_name}: {{ default: \"{default}\" }}"
+        )
+
     # Validate choices
     if choices is not None:
         # Validate choices is a list

tasktree-0.0.11/tests/integration/test_docker_build_args.py

@@ -0,0 +1,79 @@
+"""Integration tests for Docker build args functionality."""
+
+import os
+import unittest
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from typer.testing import CliRunner
+
+from tasktree.cli import app
+
+
+class TestDockerBuildArgs(unittest.TestCase):
+    """Test Docker build args are passed correctly to docker build."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+        self.env = {"NO_COLOR": "1"}
+
+    def test_build_args_passed_to_dockerfile(self):
+        """Test that build args are passed to docker build and used in Dockerfile."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            # Create a Dockerfile that uses ARG statements
+            dockerfile = project_root / "Dockerfile"
+            dockerfile.write_text("""FROM alpine:latest
+
+ARG BUILD_VERSION
+ARG BUILD_DATE
+ARG PYTHON_VERSION=3.11
+
+RUN echo "Build version: $BUILD_VERSION" > /build-info.txt && \\
+    echo "Build date: $BUILD_DATE" >> /build-info.txt && \\
+    echo "Python version: $PYTHON_VERSION" >> /build-info.txt
+
+CMD ["cat", "/build-info.txt"]
+""")
+
+            # Create recipe with Docker environment and build args
+            recipe_file = project_root / "tasktree.yaml"
+            recipe_file.write_text("""
+environments:
+  default: builder
+  builder:
+    dockerfile: ./Dockerfile
+    context: .
+    args:
+      BUILD_VERSION: "1.2.3"
+      BUILD_DATE: "2024-01-01"
+      PYTHON_VERSION: "3.12"
+
+tasks:
+  build:
+    env: builder
+    cmd: echo "Build args test"
+""")
+
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(project_root)
+
+                # Run the task - this will build the Docker image with build args
+                # Note: This test will be skipped in CI if Docker is not available
+                result = self.runner.invoke(app, ["build"], env=self.env)
+
+                # If Docker is not available, skip the test
+                if "Docker is not available" in result.stdout or result.exit_code != 0:
+                    self.skipTest("Docker not available in test environment")
+
+                self.assertEqual(result.exit_code, 0)
+
+            finally:
+                os.chdir(original_cwd)
+
+
+if __name__ == "__main__":
+    unittest.main()

{tasktree-0.0.9 → tasktree-0.0.11}/tests/integration/test_end_to_end.py

@@ -35,7 +35,11 @@ class TestEndToEnd(unittest.TestCase):
             recipe_file.write_text("""
 tasks:
   deploy:
-    args: [environment, region:str=us-west-1, port:int=8080, debug:bool=false]
+    args:
+      - environment
+      - region: { type: str, default: us-west-1 }
+      - port: { type: int, default: 8080 }
+      - debug: { type: bool, default: false }
     outputs: [deploy.log]
     cmd: echo "env={{ arg.environment }} region={{ arg.region }} port={{ arg.port }} debug={{ arg.debug }}" > deploy.log
 """)

{tasktree-0.0.9 → tasktree-0.0.11}/tests/integration/test_exported_args.py

@@ -28,7 +28,9 @@ class TestExportedArgs(unittest.TestCase):
                 f"""
 tasks:
   test:
-    args: [$server, $user=admin]
+    args:
+      - $server
+      - $user: {{ default: admin }}
     cmd: {env_check}
 """
             )
@@ -59,7 +61,9 @@ tasks:
                 f"""
 tasks:
   test:
-    args: [$server, $port=8080]
+    args:
+      - $server
+      - $port: {{ default: "8080" }}
     cmd: {env_check}
 """
             )
@@ -94,7 +98,9 @@ tasks:
                 f"""
 tasks:
   test:
-    args: [$server, $port=8080]
+    args:
+      - $server
+      - $port: {{ default: "8080" }}
     cmd: {env_check}
 """
             )
@@ -164,7 +170,9 @@ tasks:
                 f"""
 tasks:
   deploy:
-    args: [$server, port=8080]
+    args:
+      - $server
+      - port: {{ default: 8080 }}
     cmd: {cmd_line}
 """
             )
@@ -242,12 +250,22 @@ tasks:
         """Test that exported arguments with type annotations fail during arg parsing."""
         from tasktree.parser import parse_arg_spec
 
-        # Test that parse_arg_spec raises error for exported args with types
+        # Test that parse_arg_spec raises error for exported args with types (old colon syntax)
         with self.assertRaises(ValueError) as cm:
             parse_arg_spec("$server:str")
 
+        self.assertIn("Invalid argument syntax", str(cm.exception))
+
+    def test_exported_arg_yaml_dict_with_type_fails(self):
+        """Test that exported arguments with type field in YAML dict format fails."""
+        from tasktree.parser import parse_arg_spec
+
+        # Test that parse_arg_spec raises error for exported args with type in dict format
+        with self.assertRaises(ValueError) as cm:
+            parse_arg_spec({"$server": {"type": "str"}})
+
         self.assertIn("Type annotations not allowed", str(cm.exception))
-        self.assertIn("$server:str", str(cm.exception))
+        self.assertIn("$server", str(cm.exception))
 
     def test_multiline_command_with_exported_args(self):
         """Test exported args work with multi-line commands."""

{tasktree-0.0.9 → tasktree-0.0.11}/tests/integration/test_parameterized_dependencies.yaml

@@ -1,8 +1,8 @@
 tasks:
   task_parameterized:
     args:
-      - mode=debug
-      - verbose=false
+      - mode: { default: "debug" }
+      - verbose: { default: "false" }
     cmd: echo "mode={{arg.mode}} verbose={{arg.verbose}}"
 
   task_consumer_implicit:

{tasktree-0.0.9 → tasktree-0.0.11}/tests/integration/test_parameterized_deps_execution.py

@@ -37,8 +37,8 @@ class TestParameterizedDependencyExecution(unittest.TestCase):
 tasks:
   build:
     args:
-      - mode=debug
-      - optimize:bool=false
+      - mode: { default: "debug" }
+      - optimize: { type: bool, default: false }
     outputs:
       - "build-{{arg.mode}}.log"
     cmd: echo "Building {{arg.mode}} optimize={{arg.optimize}}" > build-{{arg.mode}}.log
@@ -151,8 +151,8 @@ tasks:
 tasks:
   generate:
     args:
-      - format=json
-      - pretty:bool=false
+      - format: { default: "json" }
+      - pretty: { type: bool, default: false }
     outputs:
       - "data.{{arg.format}}"
     cmd: echo "{{arg.format}},pretty={{arg.pretty}}" > data.{{arg.format}}

{tasktree-0.0.9 → tasktree-0.0.11}/tests/unit/test_cli.py

@@ -31,7 +31,7 @@ class TestParseTaskArgs(unittest.TestCase):
 
     def test_parse_task_args_with_defaults(self):
         """Test default values applied."""
-        arg_specs = ["environment", "region=us-west-1"]
+        arg_specs = ["environment", {"region": {"default": "us-west-1"}}]
         arg_values = ["production"]  # Only provide first arg
 
         result = _parse_task_args(arg_specs, arg_values)
@@ -40,7 +40,7 @@ class TestParseTaskArgs(unittest.TestCase):
 
     def test_parse_task_args_type_conversion(self):
         """Test values converted to correct types."""
-        arg_specs = ["port:int", "debug:bool", "timeout:float"]
+        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)
@@ -76,7 +76,7 @@ class TestParseTaskArgs(unittest.TestCase):
 
     def test_parse_task_args_invalid_type(self):
         """Test error for invalid type conversion."""
-        arg_specs = ["port:int"]
+        arg_specs = [{"port": {"type": "int"}}]
         arg_values = ["not_a_number"]
 
         with self.assertRaises(typer.Exit):
@@ -93,7 +93,7 @@ class TestParseTaskArgs(unittest.TestCase):
 
     def test_parse_task_args_mixed(self):
         """Test mixing positional and named arguments."""
-        arg_specs = ["environment", "region", "verbose:bool"]
+        arg_specs = ["environment", "region", {"verbose": {"type": "bool"}}]
         arg_values = ["production", "region=us-east-1", "verbose=true"]
 
         result = _parse_task_args(arg_specs, arg_values)

{tasktree-0.0.9 → tasktree-0.0.11}/tests/unit/test_dependency_parsing.py

@@ -18,7 +18,7 @@ class TestDependencyParsing(unittest.TestCase):
         self.task_with_args = Task(
             name="process",
             cmd="echo mode={{arg.mode}} verbose={{arg.verbose}}",
-            args=["mode", "verbose=false"],
+            args=["mode", {"verbose": {"default": "false"}}],
         )
         self.task_no_args = Task(
             name="build",

{tasktree-0.0.9 → tasktree-0.0.11}/tests/unit/test_docker.py

@@ -142,6 +142,39 @@ class TestIsDockerEnvironment(unittest.TestCase):
         )
         self.assertFalse(is_docker_environment(env))
 
+    def test_shell_environment_with_list_args(self):
+        """Test that shell environments still work with list args (backward compatibility)."""
+        # Shell environments should use list args for shell arguments
+        env = Environment(
+            name="bash",
+            shell="bash",
+            args=["-c", "-e"],  # List of shell arguments
+        )
+
+        # Verify it's recognized as a shell environment (not Docker)
+        self.assertFalse(is_docker_environment(env))
+
+        # Verify args are stored as a list
+        self.assertIsInstance(env.args, list)
+        self.assertEqual(env.args, ["-c", "-e"])
+
+    def test_docker_environment_with_dict_args(self):
+        """Test that Docker environments use dict args for build arguments."""
+        # Docker environments should use dict args for build arguments
+        env = Environment(
+            name="builder",
+            dockerfile="./Dockerfile",
+            context=".",
+            args={"BUILD_VERSION": "1.0.0", "BUILD_DATE": "2024-01-01"},
+        )
+
+        # Verify it's recognized as a Docker environment
+        self.assertTrue(is_docker_environment(env))
+
+        # Verify args are stored as a dict
+        self.assertIsInstance(env.args, dict)
+        self.assertEqual(env.args, {"BUILD_VERSION": "1.0.0", "BUILD_DATE": "2024-01-01"})
+
 
 class TestResolveContainerWorkingDir(unittest.TestCase):
     """Test container working directory resolution."""
@@ -246,6 +279,132 @@ class TestDockerManager(unittest.TestCase):
         self.assertEqual(build_call_args[3], "tt-env-builder")
         self.assertEqual(build_call_args[4], "-f")
 
+    @patch("tasktree.docker.subprocess.run")
+    def test_build_command_with_build_args(self, mock_run):
+        """Test that docker build command includes --build-arg flags."""
+        env = Environment(
+            name="builder",
+            dockerfile="./Dockerfile",
+            context=".",
+            args={"FOO": "fooable", "bar": "you're barred!"},
+        )
+
+        # Mock docker inspect returning image ID
+        def mock_run_side_effect(*args, **kwargs):
+            cmd = args[0]
+            if "inspect" in cmd:
+                result = Mock()
+                result.stdout = "sha256:abc123def456\n"
+                return result
+            return None
+
+        mock_run.side_effect = mock_run_side_effect
+
+        self.manager.ensure_image_built(env)
+
+        # Check that docker build was called with build args (2nd call, after docker --version)
+        build_call_args = mock_run.call_args_list[1][0][0]
+
+        # Verify basic command structure
+        self.assertEqual(build_call_args[0], "docker")
+        self.assertEqual(build_call_args[1], "build")
+        self.assertEqual(build_call_args[2], "-t")
+        self.assertEqual(build_call_args[3], "tt-env-builder")
+        self.assertEqual(build_call_args[4], "-f")
+
+        # Verify build args are included
+        self.assertIn("--build-arg", build_call_args)
+
+        # Find all build arg pairs
+        build_args = {}
+        for i, arg in enumerate(build_call_args):
+            if arg == "--build-arg":
+                arg_pair = build_call_args[i + 1]
+                key, value = arg_pair.split("=", 1)
+                build_args[key] = value
+
+        # Verify expected build args
+        self.assertEqual(build_args["FOO"], "fooable")
+        self.assertEqual(build_args["bar"], "you're barred!")
+
+    @patch("tasktree.docker.subprocess.run")
+    def test_build_command_with_empty_build_args(self, mock_run):
+        """Test that docker build command works with empty build args dict."""
+        env = Environment(
+            name="builder",
+            dockerfile="./Dockerfile",
+            context=".",
+            args={},
+        )
+
+        # Mock docker inspect returning image ID
+        def mock_run_side_effect(*args, **kwargs):
+            cmd = args[0]
+            if "inspect" in cmd:
+                result = Mock()
+                result.stdout = "sha256:abc123def456\n"
+                return result
+            return None
+
+        mock_run.side_effect = mock_run_side_effect
+
+        self.manager.ensure_image_built(env)
+
+        # Check that docker build was called (2nd call, after docker --version)
+        build_call_args = mock_run.call_args_list[1][0][0]
+
+        # Verify basic command structure
+        self.assertEqual(build_call_args[0], "docker")
+        self.assertEqual(build_call_args[1], "build")
+
+        # Verify NO build args are included
+        self.assertNotIn("--build-arg", build_call_args)
+
+    @patch("tasktree.docker.subprocess.run")
+    def test_build_command_with_special_characters_in_args(self, mock_run):
+        """Test that build args with special characters are handled correctly."""
+        env = Environment(
+            name="builder",
+            dockerfile="./Dockerfile",
+            context=".",
+            args={
+                "API_KEY": "sk-1234_abcd-5678",
+                "MESSAGE": "Hello, World!",
+                "PATH_WITH_SPACES": "/path/to/my files",
+                "SPECIAL_CHARS": "test=value&foo=bar",
+            },
+        )
+
+        # Mock docker inspect returning image ID
+        def mock_run_side_effect(*args, **kwargs):
+            cmd = args[0]
+            if "inspect" in cmd:
+                result = Mock()
+                result.stdout = "sha256:abc123def456\n"
+                return result
+            return None
+
+        mock_run.side_effect = mock_run_side_effect
+
+        self.manager.ensure_image_built(env)
+
+        # Check that docker build was called (2nd call, after docker --version)
+        build_call_args = mock_run.call_args_list[1][0][0]
+
+        # Find all build arg pairs
+        build_args = {}
+        for i, arg in enumerate(build_call_args):
+            if arg == "--build-arg":
+                arg_pair = build_call_args[i + 1]
+                key, value = arg_pair.split("=", 1)
+                build_args[key] = value
+
+        # Verify special characters are preserved
+        self.assertEqual(build_args["API_KEY"], "sk-1234_abcd-5678")
+        self.assertEqual(build_args["MESSAGE"], "Hello, World!")
+        self.assertEqual(build_args["PATH_WITH_SPACES"], "/path/to/my files")
+        self.assertEqual(build_args["SPECIAL_CHARS"], "test=value&foo=bar")
+
     def test_resolve_volume_mount_relative(self):
         """Test relative volume path resolution."""
         volume = "./src:/workspace/src"

{tasktree-0.0.9 → tasktree-0.0.11}/tests/unit/test_list_formatting.py

@@ -25,7 +25,7 @@ class TestFormatTaskArguments(unittest.TestCase):
 
     def test_format_single_optional_argument(self):
         """Test formatting task with single optional argument."""
-        result = _format_task_arguments(["environment=production"])
+        result = _format_task_arguments([{"environment": {"default": "production"}}])
         self.assertIn("environment[dim]:str[/dim]", result)
         self.assertIn("[dim]\\[=production][/dim]", result)
 
@@ -39,7 +39,7 @@ class TestFormatTaskArguments(unittest.TestCase):
 
     def test_format_multiple_optional_arguments(self):
         """Test formatting task with multiple optional arguments."""
-        result = _format_task_arguments(["mode=debug", "target=x86_64"])
+        result = _format_task_arguments([{"mode": {"default": "debug"}}, {"target": {"default": "x86_64"}}])
         self.assertIn("mode[dim]:str[/dim]", result)
         self.assertIn("[dim]\\[=debug][/dim]", result)
         self.assertIn("target[dim]:str[/dim]", result)
@@ -47,7 +47,7 @@ class TestFormatTaskArguments(unittest.TestCase):
 
     def test_format_mixed_required_and_optional_arguments(self):
         """Test formatting task with mixed required and optional arguments."""
-        result = _format_task_arguments(["environment", "region=us-west-1"])
+        result = _format_task_arguments(["environment", {"region": {"default": "us-west-1"}}])
         self.assertIn("environment[dim]:str[/dim]", result)
         self.assertIn("region[dim]:str[/dim]", result)
         self.assertIn("[dim]\\[=us-west-1][/dim]", result)
@@ -66,7 +66,7 @@ class TestFormatTaskArguments(unittest.TestCase):
 
     def test_format_default_values_with_equals_sign(self):
         """Test formatting shows default values with equals sign."""
-        result = _format_task_arguments(["port=8080"])
+        result = _format_task_arguments([{"port": {"default": "8080"}}])
         self.assertIn("[dim]\\[=8080][/dim]", result)
 
     def test_format_shows_str_type_explicitly(self):
@@ -76,22 +76,22 @@ class TestFormatTaskArguments(unittest.TestCase):
 
     def test_format_shows_int_type(self):
         """Test formatting shows int type."""
-        result = _format_task_arguments(["port:int"])
+        result = _format_task_arguments([{"port": {"type": "int"}}])
         self.assertIn("port[dim]:int[/dim]", result)
 
     def test_format_shows_float_type(self):
         """Test formatting shows float type."""
-        result = _format_task_arguments(["timeout:float"])
+        result = _format_task_arguments([{"timeout": {"type": "float"}}])
         self.assertIn("timeout[dim]:float[/dim]", result)
 
     def test_format_shows_bool_type(self):
         """Test formatting shows bool type."""
-        result = _format_task_arguments(["verbose:bool"])
+        result = _format_task_arguments([{"verbose": {"type": "bool"}}])
         self.assertIn("verbose[dim]:bool[/dim]", result)
 
     def test_format_shows_path_type(self):
         """Test formatting shows path type."""
-        result = _format_task_arguments(["output:path"])
+        result = _format_task_arguments([{"output": {"type": "path"}}])
         self.assertIn("output[dim]:path[/dim]", result)
 
     def test_format_shows_datetime_type(self):
@@ -150,7 +150,7 @@ class TestFormatTaskArguments(unittest.TestCase):
     def test_format_escapes_rich_markup_in_defaults(self):
         """Test formatting properly escapes Rich markup in default values."""
         # Test with brackets in default value
-        result = _format_task_arguments(["pattern=[a-z]+"])
+        result = _format_task_arguments([{"pattern": {"default": "[a-z]+"}}])
         # The brackets in the default should be escaped
         self.assertIn("[dim]\\[=[a-z]+][/dim]", result)
 

{tasktree-0.0.9 → tasktree-0.0.11}/tests/unit/test_parameterized_graph.py

@@ -84,7 +84,7 @@ class TestParameterizedGraphConstruction(unittest.TestCase):
             "process": Task(
                 name="process",
                 cmd="echo mode={{arg.mode}}",
-                args=["mode=debug"],
+                args=[{"mode": {"default": "debug"}}],
                 deps=[],
             ),
             "consumer1": Task(

{tasktree-0.0.9 → tasktree-0.0.11}/tests/unit/test_parser.py

@@ -27,29 +27,23 @@ class TestParseArgSpec(unittest.TestCase):
         self.assertIsNone(spec.default)
         self.assertFalse(spec.is_exported)
 
-    def test_parse_arg_with_default(self):
-        """Test parsing argument with default value."""
-        spec = parse_arg_spec("region=eu-west-1")
-        self.assertEqual(spec.name,"region")
-        self.assertEqual(spec.arg_type,"str")
-        self.assertEqual(spec.default,"eu-west-1")
-        self.assertFalse(spec.is_exported)
+    def test_parse_arg_with_default_raises_error(self):
+        """Test that string format with default raises error."""
+        with self.assertRaises(ValueError) as context:
+            parse_arg_spec("region=eu-west-1")
+        self.assertIn("Invalid argument syntax", str(context.exception))
 
-    def test_parse_arg_with_type(self):
-        """Test parsing argument with type."""
-        spec = parse_arg_spec("port:int")
-        self.assertEqual(spec.name,"port")
-        self.assertEqual(spec.arg_type,"int")
-        self.assertIsNone(spec.default)
-        self.assertFalse(spec.is_exported)
+    def test_parse_arg_with_type_raises_error(self):
+        """Test that string format with type raises error."""
+        with self.assertRaises(ValueError) as context:
+            parse_arg_spec("port:int")
+        self.assertIn("Invalid argument syntax", str(context.exception))
 
-    def test_parse_arg_with_type_and_default(self):
-        """Test parsing argument with type and default."""
-        spec = parse_arg_spec("port:int=8080")
-        self.assertEqual(spec.name,"port")
-        self.assertEqual(spec.arg_type,"int")
-        self.assertEqual(spec.default,"8080")
-        self.assertFalse(spec.is_exported)
+    def test_parse_arg_with_type_and_default_raises_error(self):
+        """Test that string format with type and default raises error."""
+        with self.assertRaises(ValueError) as context:
+            parse_arg_spec("port:int=8080")
+        self.assertIn("Invalid argument syntax", str(context.exception))
 
     def test_parse_exported_arg(self):
         """Test parsing exported argument ($ prefix)."""
@@ -59,39 +53,34 @@ class TestParseArgSpec(unittest.TestCase):
         self.assertIsNone(spec.default)
         self.assertTrue(spec.is_exported)
 
-    def test_parse_exported_arg_with_default(self):
-        """Test parsing exported argument with default value."""
-        spec = parse_arg_spec("$user=admin")
-        self.assertEqual(spec.name,"user")
-        self.assertEqual(spec.arg_type,"str")
-        self.assertEqual(spec.default,"admin")
-        self.assertTrue(spec.is_exported)
+    def test_parse_exported_arg_with_default_raises_error(self):
+        """Test that exported argument string format with default raises error."""
+        with self.assertRaises(ValueError) as context:
+            parse_arg_spec("$user=admin")
+        self.assertIn("Invalid argument syntax", str(context.exception))
 
     def test_parse_exported_arg_with_type_raises_error(self):
         """Test that exported arguments with type annotations raise error."""
         with self.assertRaises(ValueError) as context:
             parse_arg_spec("$server:str")
-        self.assertIn("Type annotations not allowed on exported arguments", str(context.exception))
-        self.assertIn("$server:str", str(context.exception))
+        self.assertIn("Invalid argument syntax", str(context.exception))
 
     def test_parse_exported_arg_with_type_and_default_raises_error(self):
         """Test that exported arguments with type and default raise error."""
         with self.assertRaises(ValueError) as context:
             parse_arg_spec("$port:int=8080")
-        self.assertIn("Type annotations not allowed on exported arguments", str(context.exception))
+        self.assertIn("Invalid argument syntax", str(context.exception))
 
     def test_yaml_parses_dollar_prefix_as_literal(self):
         """Test that PyYAML correctly parses $ prefix as literal text."""
         yaml_text = """
 args:
   - $server
-  - $user=admin
-  - port:int=8080
+  - environment
 """
         data = yaml.safe_load(yaml_text)
         self.assertEqual(data["args"][0], "$server")
-        self.assertEqual(data["args"][1], "$user=admin")
-        self.assertEqual(data["args"][2], "port:int=8080")
+        self.assertEqual(data["args"][1], "environment")
 
 
 class TestParseArgSpecYAML(unittest.TestCase):
@@ -416,7 +405,9 @@ tasks:
     inputs: ["src/**/*.rs"]
     outputs: [target/release/bin]
     working_dir: subproject
-    args: [environment, region=eu-west-1]
+    args:
+      - environment
+      - region: { default: eu-west-1 }
     cmd: cargo build --release
 """
             )
@@ -428,7 +419,9 @@ tasks:
             self.assertEqual(task.inputs, ["src/**/*.rs"])
             self.assertEqual(task.outputs, ["target/release/bin"])
             self.assertEqual(task.working_dir, "subproject")
-            self.assertEqual(task.args, ["environment", "region=eu-west-1"])
+            self.assertEqual(len(task.args), 2)
+            self.assertEqual(task.args[0], "environment")
+            self.assertIsInstance(task.args[1], dict)
             self.assertEqual(task.cmd, "cargo build --release")
 
     def test_parse_with_imports(self):
@@ -729,7 +722,9 @@ tasks:
     inputs: ["src/**/*.rs"]
     outputs: [target/release/bin]
     working_dir: subproject
-    args: [environment, region=eu-west-1]
+    args:
+      - environment
+      - region: { default: eu-west-1 }
     cmd: cargo build --release
 """)
 
@@ -747,7 +742,7 @@ imports:
             self.assertEqual(task.inputs, ["src/**/*.rs"])
             self.assertEqual(task.outputs, ["target/release/bin"])
             self.assertEqual(task.working_dir, "subproject")
-            self.assertEqual(task.args, ["environment", "region=eu-west-1"])
+            self.assertEqual(task.args, ["environment", {"region": {"default": "eu-west-1"}}])
             self.assertEqual(task.cmd, "cargo build --release")
 
     def test_cross_import_dependencies(self):
@@ -1540,6 +1535,73 @@ tasks:
             self.assertEqual(len(recipe.tasks), 0)
 
 
+class TestArgsValidation(unittest.TestCase):
+    """Tests for validating task args must be a list, not a dict."""
+
+    def test_args_dict_syntax_raises_error(self):
+        """Test that dictionary syntax for args raises a helpful error."""
+        with TemporaryDirectory() as tmpdir:
+            recipe_path = Path(tmpdir) / "tasktree.yaml"
+            recipe_path.write_text("""
+tasks:
+  foo:
+    args:
+      x: {}
+      y: { type: int, default: 10 }
+    cmd: echo x = {{ arg.x }}, y = {{ arg.y }}
+""")
+
+            with self.assertRaises(ValueError) as cm:
+                parse_recipe(recipe_path)
+
+            error_msg = str(cm.exception)
+            self.assertIn("invalid 'args' syntax", error_msg)
+            self.assertIn("dictionary syntax", error_msg)
+            self.assertIn("list format", error_msg)
+            self.assertIn("with dashes", error_msg)
+            # Should show the first key as an example
+            self.assertIn("x", error_msg)
+
+    def test_args_list_syntax_is_valid(self):
+        """Test that list syntax for args works correctly."""
+        with TemporaryDirectory() as tmpdir:
+            recipe_path = Path(tmpdir) / "tasktree.yaml"
+            recipe_path.write_text("""
+tasks:
+  foo:
+    args:
+      - x
+      - y: { type: int, default: 10 }
+    cmd: echo x = {{ arg.x }}, y = {{ arg.y }}
+""")
+
+            # Should parse without error
+            recipe = parse_recipe(recipe_path)
+
+            # Verify the task was parsed correctly
+            self.assertIn("foo", recipe.tasks)
+            task = recipe.tasks["foo"]
+            self.assertEqual(len(task.args), 2)
+
+    def test_args_empty_dict_raises_error(self):
+        """Test that even an empty dict for args raises an error."""
+        with TemporaryDirectory() as tmpdir:
+            recipe_path = Path(tmpdir) / "tasktree.yaml"
+            recipe_path.write_text("""
+tasks:
+  foo:
+    args: {}
+    cmd: echo hello
+""")
+
+            with self.assertRaises(ValueError) as cm:
+                parse_recipe(recipe_path)
+
+            error_msg = str(cm.exception)
+            self.assertIn("invalid 'args' syntax", error_msg)
+            self.assertIn("dictionary syntax", error_msg)
+
+
 class TestVariablesParsing(unittest.TestCase):
     """Test parsing of variables section with environment variable support."""
 
@@ -2597,7 +2659,7 @@ class TestArgMinMax(unittest.TestCase):
 
     def test_string_format_args_have_no_min_max(self):
         """Test that string format args return None for min/max."""
-        spec = parse_arg_spec("count:int=5")
+        spec = parse_arg_spec("count")
         self.assertIsNone(spec.min_val)
         self.assertIsNone(spec.max_val)