tasktree 0.0.10__tar.gz → 0.0.11__tar.gz

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

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

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

{tasktree-0.0.10 → 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.10 → 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.10 → tasktree-0.0.11}/src/tasktree/parser.py

@@ -1259,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)
@@ -1328,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
+    # 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 +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.10 → 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.10 → 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.10 → 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.10 → 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.10 → 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.10 → 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.10 → 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.10 → 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.10 → 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):
@@ -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)