tasktree 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

tasktree/parser.py

@@ -57,15 +57,24 @@ class Task:
     cmd: str
     desc: str = ""
     deps: list[str | dict[str, Any]] = field(default_factory=list)  # Can be strings or dicts with args
-    inputs: list[str] = field(default_factory=list)
-    outputs: list[str] = field(default_factory=list)
+    inputs: list[str | dict[str, str]] = field(default_factory=list)  # Can be strings or dicts with named inputs
+    outputs: list[str | dict[str, str]] = field(default_factory=list)  # Can be strings or dicts with named outputs
     working_dir: str = ""
     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
+    private: bool = False  # If True, task is hidden from --list output
+
+    # Internal fields for efficient output lookup (built in __post_init__)
+    _output_map: dict[str, str] = field(init=False, default_factory=dict, repr=False)  # name → path mapping
+    _anonymous_outputs: list[str] = field(init=False, default_factory=list, repr=False)  # unnamed outputs
+
+    # Internal fields for efficient input lookup (built in __post_init__)
+    _input_map: dict[str, str] = field(init=False, default_factory=dict, repr=False)  # name → path mapping
+    _anonymous_inputs: list[str] = field(init=False, default_factory=list, repr=False)  # unnamed inputs
 
     def __post_init__(self):
-        """Ensure lists are always lists."""
+        """Ensure lists are always lists and build output maps."""
         if isinstance(self.deps, str):
             self.deps = [self.deps]
         if isinstance(self.inputs, str):
@@ -88,6 +97,84 @@ class Task:
                 f"Arguments must be defined as a list, not a dictionary."
             )
 
+        # Build output maps for efficient lookup
+        self._output_map = {}
+        self._anonymous_outputs = []
+
+        for idx, output in enumerate(self.outputs):
+            if isinstance(output, dict):
+                # Named output: validate and store
+                if len(output) != 1:
+                    raise ValueError(
+                        f"Task '{self.name}': Named output at index {idx} must have exactly one key-value pair, got {len(output)}: {output}"
+                    )
+
+                name, path = next(iter(output.items()))
+
+                if not isinstance(path, str):
+                    raise ValueError(
+                        f"Task '{self.name}': Named output '{name}' must have a string path, got {type(path).__name__}: {path}"
+                    )
+
+                if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', name):
+                    raise ValueError(
+                        f"Task '{self.name}': Named output '{name}' must be a valid identifier "
+                        f"(letters, numbers, underscores, cannot start with number)"
+                    )
+
+                if name in self._output_map:
+                    raise ValueError(
+                        f"Task '{self.name}': Duplicate output name '{name}' at index {idx}"
+                    )
+
+                self._output_map[name] = path
+            elif isinstance(output, str):
+                # Anonymous output: just store
+                self._anonymous_outputs.append(output)
+            else:
+                raise ValueError(
+                    f"Task '{self.name}': Output at index {idx} must be a string or dict, got {type(output).__name__}: {output}"
+                )
+
+        # Build input maps for efficient lookup
+        self._input_map = {}
+        self._anonymous_inputs = []
+
+        for idx, input_item in enumerate(self.inputs):
+            if isinstance(input_item, dict):
+                # Named input: validate and store
+                if len(input_item) != 1:
+                    raise ValueError(
+                        f"Task '{self.name}': Named input at index {idx} must have exactly one key-value pair, got {len(input_item)}: {input_item}"
+                    )
+
+                name, path = next(iter(input_item.items()))
+
+                if not isinstance(path, str):
+                    raise ValueError(
+                        f"Task '{self.name}': Named input '{name}' must have a string path, got {type(path).__name__}: {path}"
+                    )
+
+                if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', name):
+                    raise ValueError(
+                        f"Task '{self.name}': Named input '{name}' must be a valid identifier "
+                        f"(letters, numbers, underscores, cannot start with number)"
+                    )
+
+                if name in self._input_map:
+                    raise ValueError(
+                        f"Task '{self.name}': Duplicate input name '{name}' at index {idx}"
+                    )
+
+                self._input_map[name] = path
+            elif isinstance(input_item, str):
+                # Anonymous input: just store
+                self._anonymous_inputs.append(input_item)
+            else:
+                raise ValueError(
+                    f"Task '{self.name}': Input at index {idx} must be a string or dict, got {type(input_item).__name__}: {input_item}"
+                )
+
 
 @dataclass
 class DependencySpec:
@@ -265,10 +352,71 @@ class Recipe:
             task.cmd = substitute_variables(task.cmd, self.evaluated_variables)
             task.desc = substitute_variables(task.desc, self.evaluated_variables)
             task.working_dir = substitute_variables(task.working_dir, self.evaluated_variables)
-            task.inputs = [substitute_variables(inp, self.evaluated_variables) for inp in task.inputs]
-            task.outputs = [substitute_variables(out, self.evaluated_variables) for out in task.outputs]
-            # Substitute in argument default values (in arg spec strings)
-            task.args = [substitute_variables(arg, self.evaluated_variables) for arg in task.args]
+
+            # Substitute variables in inputs (handle both string and dict inputs)
+            resolved_inputs = []
+            for inp in task.inputs:
+                if isinstance(inp, str):
+                    resolved_inputs.append(substitute_variables(inp, self.evaluated_variables))
+                elif isinstance(inp, dict):
+                    # Named input: substitute the path value
+                    resolved_dict = {}
+                    for name, path in inp.items():
+                        resolved_dict[name] = substitute_variables(path, self.evaluated_variables)
+                    resolved_inputs.append(resolved_dict)
+                else:
+                    resolved_inputs.append(inp)
+            task.inputs = resolved_inputs
+
+            # Substitute variables in outputs (handle both string and dict outputs)
+            resolved_outputs = []
+            for out in task.outputs:
+                if isinstance(out, str):
+                    resolved_outputs.append(substitute_variables(out, self.evaluated_variables))
+                elif isinstance(out, dict):
+                    # Named output: substitute the path value
+                    resolved_dict = {}
+                    for name, path in out.items():
+                        resolved_dict[name] = substitute_variables(path, self.evaluated_variables)
+                    resolved_outputs.append(resolved_dict)
+                else:
+                    resolved_outputs.append(out)
+            task.outputs = resolved_outputs
+
+            # Rebuild output maps after variable substitution
+            task.__post_init__()
+
+            # Substitute in argument default values (handle both string and dict args)
+            resolved_args = []
+            for arg in task.args:
+                if isinstance(arg, str):
+                    resolved_args.append(substitute_variables(arg, self.evaluated_variables))
+                elif isinstance(arg, dict):
+                    # Dict arg: substitute in nested values (like default values)
+                    resolved_dict = {}
+                    for arg_name, arg_spec in arg.items():
+                        if isinstance(arg_spec, dict):
+                            # Substitute in the nested dict values (e.g., default, help, choices)
+                            resolved_spec = {}
+                            for key, value in arg_spec.items():
+                                if isinstance(value, str):
+                                    resolved_spec[key] = substitute_variables(value, self.evaluated_variables)
+                                elif isinstance(value, list):
+                                    # Handle lists like 'choices'
+                                    resolved_spec[key] = [
+                                        substitute_variables(v, self.evaluated_variables) if isinstance(v, str) else v
+                                        for v in value
+                                    ]
+                                else:
+                                    resolved_spec[key] = value
+                            resolved_dict[arg_name] = resolved_spec
+                        else:
+                            # Simple value
+                            resolved_dict[arg_name] = substitute_variables(arg_spec, self.evaluated_variables) if isinstance(arg_spec, str) else arg_spec
+                    resolved_args.append(resolved_dict)
+                else:
+                    resolved_args.append(arg)
+            task.args = resolved_args
 
         # Substitute evaluated variables into all environments
         for env in self.environments.values():
@@ -335,19 +483,15 @@ def find_recipe_file(start_dir: Path | None = None) -> Path | None:
     while True:
         candidates = []
 
-        # Check for exact filenames first
+        # Check for exact filenames first (these are preferred)
         for filename in ["tasktree.yaml", "tasktree.yml", "tt.yaml"]:
             recipe_path = current / filename
             if recipe_path.exists():
                 candidates.append(recipe_path)
 
-        # Check for *.tasks files
-        for tasks_file in current.glob("*.tasks"):
-            if tasks_file.is_file():
-                candidates.append(tasks_file)
-
+        # If we found standard recipe files, use the first one
         if len(candidates) > 1:
-            # Multiple recipe files found - ambiguous
+            # Multiple standard recipe files found - ambiguous
             filenames = [c.name for c in candidates]
             raise ValueError(
                 f"Multiple recipe files found in {current}:\n"
@@ -358,6 +502,25 @@ def find_recipe_file(start_dir: Path | None = None) -> Path | None:
         elif len(candidates) == 1:
             return candidates[0]
 
+        # Only check for *.tasks files if no standard recipe files found
+        # (*.tasks files are typically imports, not main recipes)
+        tasks_files = []
+        for tasks_file in current.glob("*.tasks"):
+            if tasks_file.is_file():
+                tasks_files.append(tasks_file)
+
+        if len(tasks_files) > 1:
+            # Multiple *.tasks files found - ambiguous
+            filenames = [t.name for t in tasks_files]
+            raise ValueError(
+                f"Multiple recipe files found in {current}:\n"
+                f"  {', '.join(filenames)}\n\n"
+                f"Please specify which file to use with --tasks (-T):\n"
+                f"  tt --tasks {filenames[0]} <task-name>"
+            )
+        elif len(tasks_files) == 1:
+            return tasks_files[0]
+
         # Move to parent directory
         parent = current.parent
         if parent == current:
@@ -1367,14 +1530,28 @@ def collect_reachable_variables(
         # Search in inputs
         if task.inputs:
             for input_pattern in task.inputs:
-                for match in var_pattern.finditer(input_pattern):
-                    variables.add(match.group(1))
+                if isinstance(input_pattern, str):
+                    for match in var_pattern.finditer(input_pattern):
+                        variables.add(match.group(1))
+                elif isinstance(input_pattern, dict):
+                    # Named input - check the path value
+                    for input_path in input_pattern.values():
+                        if isinstance(input_path, str):
+                            for match in var_pattern.finditer(input_path):
+                                variables.add(match.group(1))
 
         # Search in outputs
         if task.outputs:
             for output_pattern in task.outputs:
-                for match in var_pattern.finditer(output_pattern):
-                    variables.add(match.group(1))
+                if isinstance(output_pattern, str):
+                    for match in var_pattern.finditer(output_pattern):
+                        variables.add(match.group(1))
+                elif isinstance(output_pattern, dict):
+                    # Named output - check the path value
+                    for output_path in output_pattern.values():
+                        if isinstance(output_path, str):
+                            for match in var_pattern.finditer(output_path):
+                                variables.add(match.group(1))
 
         # Search in argument defaults
         if task.args:
@@ -1700,6 +1877,7 @@ def _parse_file(
             args=task_data.get("args", []),
             source_file=str(file_path),
             env=task_data.get("env", ""),
+            private=task_data.get("private", False),
         )
 
         # Check for case-sensitive argument collisions

tasktree/substitution.py

@@ -12,7 +12,19 @@ from typing import Any
 # Pattern matches: {{ prefix.name }} with optional whitespace
 # Groups: (1) prefix (var|arg|env|tt), (2) name (identifier)
 PLACEHOLDER_PATTERN = re.compile(
-    r'\{\{\s*(var|arg|env|tt)\s*\.\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}'
+    r'\{\{\s*(var|arg|env|tt)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}'
+)
+
+# Pattern matches: {{ dep.task_name.outputs.output_name }} with optional whitespace
+# Groups: (1) task_name (can include dots for namespacing), (2) output_name (identifier)
+DEP_OUTPUT_PATTERN = re.compile(
+    r'\{\{\s*dep\.([a-zA-Z_][a-zA-Z0-9_.-]*)\.outputs\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}'
+)
+
+# Pattern matches: {{ self.(inputs|outputs).name }} with optional whitespace
+# Groups: (1) field (inputs|outputs), (2) name (identifier)
+SELF_REFERENCE_PATTERN = re.compile(
+    r'\{\{\s*self\.(inputs|outputs)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}'
 )
 
 
@@ -290,3 +302,146 @@ def substitute_all(text: str, variables: dict[str, str], args: dict[str, Any]) -
     text = substitute_arguments(text, args)
     text = substitute_environment(text)
     return text
+
+
+def substitute_dependency_outputs(
+    text: str,
+    current_task_name: str,
+    current_task_deps: list[str],
+    resolved_tasks: dict[str, Any],
+) -> str:
+    """Substitute {{ dep.<task>.outputs.<name> }} placeholders with dependency output paths.
+
+    This function resolves references to named outputs from dependency tasks.
+    It validates that:
+    - The referenced task exists in the resolved_tasks dict
+    - The current task lists the referenced task as a dependency
+    - The referenced output name exists in the dependency task
+
+    Args:
+        text: Text containing {{ dep.*.outputs.* }} placeholders
+        current_task_name: Name of task being resolved (for error messages)
+        current_task_deps: List of dependency task names for the current task
+        resolved_tasks: Dictionary mapping task names to Task objects (already resolved)
+
+    Returns:
+        Text with all {{ dep.*.outputs.* }} placeholders replaced with output paths
+
+    Raises:
+        ValueError: If referenced task doesn't exist, isn't a dependency,
+                   or doesn't have the named output
+
+    Example:
+        >>> # Assuming build task has output { bundle: "dist/app.js" }
+        >>> substitute_dependency_outputs(
+        ...     "Deploy {{ dep.build.outputs.bundle }}",
+        ...     "deploy",
+        ...     ["build"],
+        ...     {"build": build_task}
+        ... )
+        'Deploy dist/app.js'
+    """
+    def replacer(match: re.Match) -> str:
+        dep_task_name = match.group(1)
+        output_name = match.group(2)
+
+        # Check if dependency task exists in resolved tasks
+        if dep_task_name not in resolved_tasks:
+            raise ValueError(
+                f"Task '{current_task_name}' references output from unknown task '{dep_task_name}'.\n"
+                f"Check the task name in {{{{ dep.{dep_task_name}.outputs.{output_name} }}}}"
+            )
+
+        # Check if current task depends on referenced task
+        if dep_task_name not in current_task_deps:
+            raise ValueError(
+                f"Task '{current_task_name}' references output from '{dep_task_name}' "
+                f"but does not list it as a dependency.\n"
+                f"Add '{dep_task_name}' to the deps list:\n"
+                f"  deps: [{', '.join(current_task_deps + [dep_task_name])}]"
+            )
+
+        # Get the dependency task
+        dep_task = resolved_tasks[dep_task_name]
+
+        # Look up the named output
+        if output_name not in dep_task._output_map:
+            available = list(dep_task._output_map.keys())
+            available_msg = ", ".join(available) if available else "(none - all outputs are anonymous)"
+            raise ValueError(
+                f"Task '{current_task_name}' references output '{output_name}' "
+                f"from task '{dep_task_name}', but '{dep_task_name}' has no output named '{output_name}'.\n"
+                f"Available named outputs in '{dep_task_name}': {available_msg}\n"
+                f"Hint: Define named outputs like: outputs: [{{ {output_name}: 'path/to/file' }}]"
+            )
+
+        return dep_task._output_map[output_name]
+
+    return DEP_OUTPUT_PATTERN.sub(replacer, text)
+
+
+def substitute_self_references(
+    text: str,
+    task_name: str,
+    input_map: dict[str, str],
+    output_map: dict[str, str],
+) -> str:
+    """Substitute {{ self.inputs.name }} and {{ self.outputs.name }} placeholders.
+
+    This function resolves references to the task's own named inputs and outputs.
+    Only named entries are accessible; anonymous inputs/outputs cannot be referenced.
+    The substitution is literal string replacement - no glob expansion or path resolution.
+
+    Args:
+        text: Text containing {{ self.* }} placeholders
+        task_name: Name of current task (for error messages)
+        input_map: Dictionary mapping input names to path strings
+        output_map: Dictionary mapping output names to path strings
+
+    Returns:
+        Text with all {{ self.* }} placeholders replaced with literal path strings
+
+    Raises:
+        ValueError: If referenced name doesn't exist in input_map or output_map
+
+    Example:
+        >>> input_map = {"src": "*.txt"}
+        >>> output_map = {"dest": "out/result.txt"}
+        >>> substitute_self_references(
+        ...     "cp {{ self.inputs.src }} {{ self.outputs.dest }}",
+        ...     "copy",
+        ...     input_map,
+        ...     output_map
+        ... )
+        'cp *.txt out/result.txt'
+    """
+    def replacer(match: re.Match) -> str:
+        field = match.group(1)  # "inputs" or "outputs"
+        name = match.group(2)
+
+        # Select appropriate map
+        if field == "inputs":
+            name_map = input_map
+            field_display = "input"
+        else:  # field == "outputs"
+            name_map = output_map
+            field_display = "output"
+
+        # Check if name exists in map
+        if name not in name_map:
+            available = list(name_map.keys())
+            if available:
+                available_msg = ", ".join(available)
+            else:
+                available_msg = f"(none - all {field} are anonymous)"
+
+            raise ValueError(
+                f"Task '{task_name}' references {field_display} '{name}' "
+                f"but has no {field_display} named '{name}'.\n"
+                f"Available named {field}: {available_msg}\n"
+                f"Hint: Define named {field} like: {field}: [{{ {name}: 'path/to/file' }}]"
+            )
+
+        return name_map[name]
+
+    return SELF_REFERENCE_PATTERN.sub(replacer, text)