tasktree 0.0.10__tar.gz → 0.0.12__tar.gz

{tasktree-0.0.10 → tasktree-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.10
+Version: 0.0.12
 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)
@@ -716,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.10 → tasktree-0.0.12}/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)
@@ -701,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.10 → tasktree-0.0.12}/pyproject.toml

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

{tasktree-0.0.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/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
@@ -1259,18 +1281,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)
@@ -1328,34 +1348,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
+    # 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 }}"
+        )
 
-    # Split on : to separate name from type
-    if ":" in name_type:
-        name, arg_type = name_type.split(":", 1)
+    name = arg_spec
+    arg_type = "str"
 
-        # 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"
-
-    # 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,
@@ -1403,6 +1413,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.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/tests/integration/test_variables.py

@@ -693,6 +693,238 @@ tasks:
             finally:
                 os.chdir(original_cwd)
 
+    def test_env_variable_with_default_when_not_set(self):
+        """Test default value is used when environment variable is not set."""
+        # Ensure env var is NOT set
+        if "TEST_PORT_DEFAULT" in os.environ:
+            del os.environ["TEST_PORT_DEFAULT"]
+
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            recipe_file = project_root / "tasktree.yaml"
+            recipe_file.write_text("""
+variables:
+  port: { env: TEST_PORT_DEFAULT, default: "8080" }
+
+tasks:
+  test:
+    outputs: [config.txt]
+    cmd: echo "Port={{ var.port }}" > config.txt
+""")
+
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(project_root)
+
+                # Run task
+                result = self.runner.invoke(app, ["test"], env=self.env)
+                self.assertEqual(result.exit_code, 0)
+
+                # Verify default value was used
+                output_file = project_root / "config.txt"
+                self.assertTrue(output_file.exists())
+                content = output_file.read_text().strip()
+                self.assertEqual(content, "Port=8080")
+
+            finally:
+                os.chdir(original_cwd)
+
+    def test_env_variable_with_default_when_set(self):
+        """Test environment variable value is used when set, ignoring default."""
+        # Set environment variable
+        os.environ["TEST_PORT_OVERRIDE"] = "9000"
+
+        try:
+            with TemporaryDirectory() as tmpdir:
+                project_root = Path(tmpdir)
+
+                recipe_file = project_root / "tasktree.yaml"
+                recipe_file.write_text("""
+variables:
+  port: { env: TEST_PORT_OVERRIDE, default: "8080" }
+
+tasks:
+  test:
+    outputs: [config.txt]
+    cmd: echo "Port={{ var.port }}" > config.txt
+""")
+
+                original_cwd = os.getcwd()
+                try:
+                    os.chdir(project_root)
+
+                    # Run task
+                    result = self.runner.invoke(app, ["test"], env=self.env)
+                    self.assertEqual(result.exit_code, 0)
+
+                    # Verify env var value was used, not default
+                    output_file = project_root / "config.txt"
+                    self.assertTrue(output_file.exists())
+                    content = output_file.read_text().strip()
+                    self.assertEqual(content, "Port=9000")
+
+                finally:
+                    os.chdir(original_cwd)
+
+        finally:
+            del os.environ["TEST_PORT_OVERRIDE"]
+
+    def test_env_variable_empty_string_vs_default(self):
+        """Test that empty string env var is used, not the default."""
+        # Set environment variable to empty string
+        os.environ["TEST_EMPTY_VAR"] = ""
+
+        try:
+            with TemporaryDirectory() as tmpdir:
+                project_root = Path(tmpdir)
+
+                recipe_file = project_root / "tasktree.yaml"
+                recipe_file.write_text("""
+variables:
+  value: { env: TEST_EMPTY_VAR, default: "default_value" }
+
+tasks:
+  test:
+    outputs: [output.txt]
+    cmd: echo "Value=[{{ var.value }}]" > output.txt
+""")
+
+                original_cwd = os.getcwd()
+                try:
+                    os.chdir(project_root)
+
+                    # Run task
+                    result = self.runner.invoke(app, ["test"], env=self.env)
+                    self.assertEqual(result.exit_code, 0)
+
+                    # Verify empty string was used (not default)
+                    output_file = project_root / "output.txt"
+                    self.assertTrue(output_file.exists())
+                    content = output_file.read_text().strip()
+                    self.assertEqual(content, "Value=[]")
+
+                finally:
+                    os.chdir(original_cwd)
+
+        finally:
+            del os.environ["TEST_EMPTY_VAR"]
+
+    def test_env_variable_default_must_be_string(self):
+        """Test that non-string defaults are rejected."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            recipe_file = project_root / "tasktree.yaml"
+            recipe_file.write_text("""
+variables:
+  port: { env: TEST_PORT, default: 8080 }
+
+tasks:
+  test:
+    cmd: echo test
+""")
+
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(project_root)
+
+                # Should fail at parse time with clear error
+                result = self.runner.invoke(app, ["test"], env=self.env)
+                self.assertNotEqual(result.exit_code, 0)
+
+                # Error should mention that default must be string
+                output = result.stdout
+                self.assertIn("default", output.lower())
+                self.assertIn("string", output.lower())
+
+            finally:
+                os.chdir(original_cwd)
+
+    def test_env_variable_multiple_with_defaults(self):
+        """Test multiple env variables with defaults work together."""
+        # Set only one env var
+        os.environ["TEST_HOST"] = "prod.example.com"
+
+        try:
+            # Ensure other env var is NOT set
+            if "TEST_PORT" in os.environ:
+                del os.environ["TEST_PORT"]
+
+            with TemporaryDirectory() as tmpdir:
+                project_root = Path(tmpdir)
+
+                recipe_file = project_root / "tasktree.yaml"
+                recipe_file.write_text("""
+variables:
+  host: { env: TEST_HOST, default: "localhost" }
+  port: { env: TEST_PORT, default: "8080" }
+  url: "{{ var.host }}:{{ var.port }}"
+
+tasks:
+  test:
+    outputs: [config.txt]
+    cmd: echo "URL={{ var.url }}" > config.txt
+""")
+
+                original_cwd = os.getcwd()
+                try:
+                    os.chdir(project_root)
+
+                    # Run task
+                    result = self.runner.invoke(app, ["test"], env=self.env)
+                    self.assertEqual(result.exit_code, 0)
+
+                    # Verify one used env var, one used default
+                    output_file = project_root / "config.txt"
+                    self.assertTrue(output_file.exists())
+                    content = output_file.read_text().strip()
+                    self.assertEqual(content, "URL=prod.example.com:8080")
+
+                finally:
+                    os.chdir(original_cwd)
+
+        finally:
+            del os.environ["TEST_HOST"]
+
+    def test_env_variable_default_with_variable_substitution(self):
+        """Test default value can contain variable references."""
+        # Ensure env var is NOT set
+        if "TEST_OVERRIDE" in os.environ:
+            del os.environ["TEST_OVERRIDE"]
+
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            recipe_file = project_root / "tasktree.yaml"
+            recipe_file.write_text("""
+variables:
+  base_url: "https://api.example.com"
+  endpoint: { env: TEST_OVERRIDE, default: "{{ var.base_url }}/users" }
+
+tasks:
+  test:
+    outputs: [config.txt]
+    cmd: echo "Endpoint={{ var.endpoint }}" > config.txt
+""")
+
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(project_root)
+
+                # Run task
+                result = self.runner.invoke(app, ["test"], env=self.env)
+                self.assertEqual(result.exit_code, 0)
+
+                # Verify default with variable substitution worked
+                output_file = project_root / "config.txt"
+                self.assertTrue(output_file.exists())
+                content = output_file.read_text().strip()
+                self.assertEqual(content, "Endpoint=https://api.example.com/users")
+
+            finally:
+                os.chdir(original_cwd)
+
 
 if __name__ == "__main__":
     unittest.main()

{tasktree-0.0.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/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.10 → tasktree-0.0.12}/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):
@@ -1708,7 +1703,7 @@ tasks:
             recipe_path = Path(tmpdir) / "tasktree.yaml"
             recipe_path.write_text("""
 variables:
-  my_var: { env: TEST_VAR, default: "foo" }
+  my_var: { env: TEST_VAR, foo: "bar" }
 
 tasks:
   test:
@@ -1719,8 +1714,8 @@ tasks:
                 parse_recipe(recipe_path)
 
             error_msg = str(cm.exception)
-            self.assertIn("extra keys", error_msg.lower())
-            self.assertIn("default", error_msg)
+            self.assertIn("found invalid keys", error_msg.lower())
+            self.assertIn("foo", error_msg)
 
     def test_parse_env_variable_invalid_name_empty(self):
         """Test error for { env: } with empty value."""
@@ -2664,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)