tasktree 0.0.5__tar.gz → 0.0.6__tar.gz

{tasktree-0.0.5 → tasktree-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.5
+Version: 0.0.6
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -188,6 +188,37 @@ cd tasktree
 pipx install .
 ```
 
+## Editor Support
+
+Task Tree includes a [JSON Schema](schema/tasktree-schema.json) that provides autocomplete, validation, and documentation in modern editors.
+
+### VS Code
+
+Install the [YAML extension](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-yaml), then add to your workspace `.vscode/settings.json`:
+
+```json
+{
+  "yaml.schemas": {
+    "https://raw.githubusercontent.com/kevinchannon/tasktree/main/schema/tasktree-schema.json": [
+      "tasktree.yaml",
+      "tt.yaml"
+    ]
+  }
+}
+```
+
+Or add a comment at the top of your `tasktree.yaml`:
+
+```yaml
+# yaml-language-server: $schema=https://raw.githubusercontent.com/kevinchannon/tasktree/main/schema/tasktree-schema.json
+
+tasks:
+  build:
+    cmd: cargo build
+```
+
+See [schema/README.md](schema/README.md) for IntelliJ/PyCharm and command-line validation.
+
 ## Quick Start
 
 Create a `tasktree.yaml` (or `tt.yaml`) in your project:

{tasktree-0.0.5 → tasktree-0.0.6}/README.md

@@ -174,6 +174,37 @@ cd tasktree
 pipx install .
 ```
 
+## Editor Support
+
+Task Tree includes a [JSON Schema](schema/tasktree-schema.json) that provides autocomplete, validation, and documentation in modern editors.
+
+### VS Code
+
+Install the [YAML extension](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-yaml), then add to your workspace `.vscode/settings.json`:
+
+```json
+{
+  "yaml.schemas": {
+    "https://raw.githubusercontent.com/kevinchannon/tasktree/main/schema/tasktree-schema.json": [
+      "tasktree.yaml",
+      "tt.yaml"
+    ]
+  }
+}
+```
+
+Or add a comment at the top of your `tasktree.yaml`:
+
+```yaml
+# yaml-language-server: $schema=https://raw.githubusercontent.com/kevinchannon/tasktree/main/schema/tasktree-schema.json
+
+tasks:
+  build:
+    cmd: cargo build
+```
+
+See [schema/README.md](schema/README.md) for IntelliJ/PyCharm and command-line validation.
+
 ## Quick Start
 
 Create a `tasktree.yaml` (or `tt.yaml`) in your project:

{tasktree-0.0.5 → tasktree-0.0.6}/pyproject.toml

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

tasktree-0.0.6/schema/README.md

@@ -0,0 +1,118 @@
+# Task Tree YAML Schema
+
+This directory contains the JSON Schema for Task Tree recipe files (`tasktree.yaml` or `tt.yaml`).
+
+## What is a YAML Schema?
+
+The JSON Schema provides:
+- **Autocomplete**: Get suggestions for task fields as you type
+- **Validation**: Immediate feedback on syntax errors
+- **Documentation**: Hover over fields to see descriptions
+- **Type checking**: Ensure values match expected types
+
+## Usage
+
+### VS Code
+
+For your project, copy the settings from `schema/vscode-settings-snippet.json` to your `.vscode/settings.json`:
+
+```json
+{
+  "yaml.schemas": {
+    "https://raw.githubusercontent.com/kevinchannon/tasktree/main/schema/tasktree-schema.json": [
+      "tasktree.yaml",
+      "tt.yaml"
+    ]
+  }
+}
+```
+
+Or add a comment at the top of your `tasktree.yaml`:
+
+```yaml
+# yaml-language-server: $schema=https://raw.githubusercontent.com/kevinchannon/tasktree/main/schema/tasktree-schema.json
+
+tasks:
+  build:
+    cmd: cargo build
+```
+
+### IntelliJ / PyCharm
+
+1. Go to **Settings → Languages & Frameworks → Schemas and DTDs → JSON Schema Mappings**
+2. Add new mapping:
+   - **Name**: Task Tree
+   - **Schema file**: Point to `schema/tasktree-schema.json`
+   - **Schema version**: JSON Schema version 7
+   - **File path pattern**: `tasktree.yaml` or `tt.yaml`
+
+### Command Line Validation
+
+You can validate your recipe files using tools like `check-jsonschema`:
+
+```bash
+# Install
+pip install check-jsonschema
+
+# Validate
+check-jsonschema --schemafile schema/tasktree-schema.json tasktree.yaml
+```
+
+## Schema Features
+
+The schema validates:
+
+- **Top-level structure**: Only `imports`, `environments`, and `tasks` are allowed at root
+- **Required fields**: Tasks must have a `cmd` field
+- **Field types**: Ensures strings, arrays, and objects are used correctly
+- **Naming patterns**: Task names and namespaces must match `^[a-zA-Z][a-zA-Z0-9_-]*$`
+- **Environment requirements**: Environments must specify a `shell`
+
+## Example
+
+```yaml
+imports:
+  - file: common/base.yaml
+    as: base
+
+environments:
+  default: bash-strict
+  bash-strict:
+    shell: /bin/bash
+    args: ['-e', '-u', '-o', 'pipefail']
+
+tasks:
+  build:
+    desc: Build the application
+    deps: [base.setup]
+    inputs: ["src/**/*.rs"]
+    outputs: [target/release/bin]
+    cmd: cargo build --release
+
+  test:
+    desc: Run tests
+    deps: [build]
+    cmd: cargo test
+
+  deploy:
+    desc: Deploy to environment
+    deps: [build]
+    args: [environment, region=us-west-1]
+    cmd: |
+      echo "Deploying to {{environment}} in {{region}}"
+      ./deploy.sh {{environment}} {{region}}
+```
+
+## Contributing
+
+If you find issues with the schema or want to improve it, please:
+
+1. Update `tasktree-schema.json`
+2. Test with your editor
+3. Submit a pull request
+
+## References
+
+- [JSON Schema Specification](https://json-schema.org/)
+- [VS Code YAML Extension](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-yaml)
+- [YAML Language Server](https://github.com/redhat-developer/yaml-language-server)

tasktree-0.0.6/schema/tasktree-schema.json

@@ -0,0 +1,163 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/kevinchannon/tasktree/schema/tasktree-schema.json",
+  "title": "Task Tree Recipe Schema",
+  "description": "Schema for Task Tree (tt) recipe files (tasktree.yaml or tt.yaml)",
+  "type": "object",
+  "properties": {
+    "imports": {
+      "description": "Import task definitions from other files",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "file": {
+            "type": "string",
+            "description": "Path to the YAML file to import (relative to current file)"
+          },
+          "as": {
+            "type": "string",
+            "description": "Namespace to use for imported tasks",
+            "pattern": "^[a-zA-Z][a-zA-Z0-9_-]*$"
+          }
+        },
+        "required": ["file", "as"],
+        "additionalProperties": false
+      }
+    },
+    "environments": {
+      "description": "Shell execution environment configurations",
+      "type": "object",
+      "properties": {
+        "default": {
+          "type": "string",
+          "description": "Name of the default environment to use"
+        }
+      },
+      "patternProperties": {
+        "^[a-zA-Z][a-zA-Z0-9_-]*$": {
+          "type": "object",
+          "properties": {
+            "shell": {
+              "type": "string",
+              "description": "Path to the shell executable (e.g., /bin/bash, python3, pwsh)"
+            },
+            "args": {
+              "description": "Arguments to pass to the shell",
+              "oneOf": [
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "string"
+                }
+              ]
+            },
+            "preamble": {
+              "type": "string",
+              "description": "Code to execute before the command (e.g., imports, setup)"
+            }
+          },
+          "required": ["shell"],
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "tasks": {
+      "description": "Task definitions",
+      "type": "object",
+      "patternProperties": {
+        "^[a-zA-Z][a-zA-Z0-9_-]*$": {
+          "type": "object",
+          "properties": {
+            "desc": {
+              "type": "string",
+              "description": "Human-readable description of the task"
+            },
+            "deps": {
+              "description": "Task dependencies (must run before this task)",
+              "oneOf": [
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "string"
+                }
+              ]
+            },
+            "inputs": {
+              "description": "Input file patterns (glob supported). Task re-runs if inputs change.",
+              "oneOf": [
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "string"
+                }
+              ]
+            },
+            "outputs": {
+              "description": "Output file patterns (glob supported). Task re-runs if outputs missing.",
+              "oneOf": [
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "string"
+                }
+              ]
+            },
+            "working_dir": {
+              "type": "string",
+              "description": "Directory to execute the command in (relative to recipe file)"
+            },
+            "args": {
+              "description": "Parameterized arguments for the task (format: name, name:type, name:type=default)",
+              "oneOf": [
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "string"
+                }
+              ]
+            },
+            "env": {
+              "type": "string",
+              "description": "Environment to use for this task (overrides default)"
+            },
+            "cmd": {
+              "type": "string",
+              "description": "Shell command to execute. Use {{arg}} for parameter substitution."
+            }
+          },
+          "required": ["cmd"],
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false,
+  "anyOf": [
+    { "required": ["tasks"] },
+    { "required": ["imports"] },
+    { "required": ["environments"] }
+  ]
+}

tasktree-0.0.6/schema/vscode-settings-snippet.json

@@ -0,0 +1,10 @@
+{
+  "yaml.schemas": {
+    "../schema/tasktree-schema.json": [
+      "tasktree.yaml",
+      "tt.yaml",
+      "**/tasktree.yaml",
+      "**/tt.yaml"
+    ]
+  }
+}

{tasktree-0.0.5 → tasktree-0.0.6}/src/tasktree/cli.py

@@ -26,11 +26,11 @@ app = typer.Typer(
 console = Console()
 
 
-def _list_tasks():
+def _list_tasks(tasks_file: Optional[str] = None):
     """List all available tasks with descriptions."""
-    recipe = _get_recipe()
+    recipe = _get_recipe(tasks_file)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
         raise typer.Exit(1)
 
     table = Table(title="Available Tasks")
@@ -45,11 +45,11 @@ def _list_tasks():
     console.print(table)
 
 
-def _show_task(task_name: str):
+def _show_task(task_name: str, tasks_file: Optional[str] = None):
     """Show task definition with syntax highlighting."""
-    recipe = _get_recipe()
+    recipe = _get_recipe(tasks_file)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
         raise typer.Exit(1)
 
     task = recipe.get_task(task_name)
@@ -79,17 +79,26 @@ def _show_task(task_name: str):
     task_dict = task_yaml[task_name]
     task_yaml[task_name] = {k: v for k, v in task_dict.items() if v}
 
+    # Configure YAML dumper to use literal block style for multiline strings
+    def literal_presenter(dumper, data):
+        """Use literal block style (|) for strings containing newlines."""
+        if '\n' in data:
+            return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
+        return dumper.represent_scalar('tag:yaml.org,2002:str', data)
+
+    yaml.add_representer(str, literal_presenter)
+
     # Format and highlight using Rich
     yaml_str = yaml.dump(task_yaml, default_flow_style=False, sort_keys=False)
     syntax = Syntax(yaml_str, "yaml", theme="ansi_light", line_numbers=False)
     console.print(syntax)
 
 
-def _show_tree(task_name: str):
+def _show_tree(task_name: str, tasks_file: Optional[str] = None):
     """Show dependency tree structure."""
-    recipe = _get_recipe()
+    recipe = _get_recipe(tasks_file)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
         raise typer.Exit(1)
 
     task = recipe.get_task(task_name)
@@ -169,6 +178,7 @@ def main(
     list_opt: Optional[bool] = typer.Option(None, "--list", "-l", help="List all available tasks"),
     show: Optional[str] = typer.Option(None, "--show", "-s", help="Show task definition"),
     tree: Optional[str] = typer.Option(None, "--tree", "-t", help="Show dependency tree"),
+    tasks_file: Optional[str] = typer.Option(None, "--tasks", "-T", help="Path to recipe file (tasktree.yaml, *.tasks, etc.)"),
     init: Optional[bool] = typer.Option(
         None, "--init", "-i", help="Create a blank tasktree.yaml"
     ),
@@ -208,15 +218,15 @@ def main(
     """
 
     if list_opt:
-        _list_tasks()
+        _list_tasks(tasks_file)
         raise typer.Exit()
 
     if show:
-        _show_task(show)
+        _show_task(show, tasks_file)
         raise typer.Exit()
 
     if tree:
-        _show_tree(tree)
+        _show_tree(tree, tasks_file)
         raise typer.Exit()
 
     if init:
@@ -224,17 +234,17 @@ def main(
         raise typer.Exit()
 
     if clean or clean_state or reset:
-        _clean_state()
+        _clean_state(tasks_file)
         raise typer.Exit()
 
     if task_args:
         # --only implies --force
         force_execution = force or only or False
-        _execute_dynamic_task(task_args, force=force_execution, only=only or False, env=env)
+        _execute_dynamic_task(task_args, force=force_execution, only=only or False, env=env, tasks_file=tasks_file)
     else:
-        recipe = _get_recipe()
+        recipe = _get_recipe(tasks_file)
         if recipe is None:
-            console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+            console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
             console.print("Run [cyan]tt --init[/cyan] to create a blank recipe file")
             raise typer.Exit(1)
 
@@ -245,13 +255,19 @@ def main(
         console.print("Use [cyan]tt <task-name>[/cyan] to run a task")
 
 
-def _clean_state() -> None:
+def _clean_state(tasks_file: Optional[str] = None) -> None:
     """Remove the .tasktree-state file to reset task execution state."""
-    recipe_path = find_recipe_file()
-    if recipe_path is None:
-        console.print("[yellow]No recipe file found[/yellow]")
-        console.print("State file location depends on recipe file location")
-        raise typer.Exit(1)
+    if tasks_file:
+        recipe_path = Path(tasks_file)
+        if not recipe_path.exists():
+            console.print(f"[red]Recipe file not found: {tasks_file}[/red]")
+            raise typer.Exit(1)
+    else:
+        recipe_path = find_recipe_file()
+        if recipe_path is None:
+            console.print("[yellow]No recipe file found[/yellow]")
+            console.print("State file location depends on recipe file location")
+            raise typer.Exit(1)
 
     project_root = recipe_path.parent
     state_path = project_root / ".tasktree-state"
@@ -264,29 +280,48 @@ def _clean_state() -> None:
         console.print(f"[yellow]No state file found at {state_path}[/yellow]")
 
 
-def _get_recipe() -> Optional[Recipe]:
-    """Get parsed recipe or None if not found."""
-    recipe_path = find_recipe_file()
-    if recipe_path is None:
-        return None
+def _get_recipe(recipe_file: Optional[str] = None) -> Optional[Recipe]:
+    """Get parsed recipe or None if not found.
+
+    Args:
+        recipe_file: Optional path to recipe file. If not provided, searches for recipe file.
+    """
+    if recipe_file:
+        recipe_path = Path(recipe_file)
+        if not recipe_path.exists():
+            console.print(f"[red]Recipe file not found: {recipe_file}[/red]")
+            raise typer.Exit(1)
+        # When explicitly specified, project root is current working directory
+        project_root = Path.cwd()
+    else:
+        try:
+            recipe_path = find_recipe_file()
+            if recipe_path is None:
+                return None
+        except ValueError as e:
+            # Multiple recipe files found
+            console.print(f"[red]{e}[/red]")
+            raise typer.Exit(1)
+        # When auto-discovered, project root is recipe file's parent
+        project_root = None
 
     try:
-        return parse_recipe(recipe_path)
+        return parse_recipe(recipe_path, project_root)
     except Exception as e:
         console.print(f"[red]Error parsing recipe: {e}[/red]")
         raise typer.Exit(1)
 
 
-def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = False, env: Optional[str] = None) -> None:
+def _execute_dynamic_task(args: list[str], force: bool = False, only: bool = False, env: Optional[str] = None, tasks_file: Optional[str] = None) -> None:
     if not args:
         return
 
     task_name = args[0]
     task_args = args[1:]
 
-    recipe = _get_recipe()
+    recipe = _get_recipe(tasks_file)
     if recipe is None:
-        console.print("[red]No recipe file found (tasktree.yaml or tt.yaml)[/red]")
+        console.print("[red]No recipe file found (tasktree.yaml, tasktree.yml, tt.yaml, or *.tasks)[/red]")
         raise typer.Exit(1)
 
     # Apply global environment override if provided

{tasktree-0.0.5 → tasktree-0.0.6}/src/tasktree/parser.py

@@ -94,13 +94,25 @@ class Recipe:
 
 
 def find_recipe_file(start_dir: Path | None = None) -> Path | None:
-    """Find recipe file (tasktree.yaml or tt.yaml) in current or parent directories.
+    """Find recipe file in current or parent directories.
+
+    Looks for recipe files matching these patterns (in order of preference):
+    - tasktree.yaml
+    - tasktree.yml
+    - tt.yaml
+    - *.tasks
+
+    If multiple recipe files are found in the same directory, raises ValueError
+    with instructions to use --tasks option.
 
     Args:
         start_dir: Directory to start searching from (defaults to cwd)
 
     Returns:
         Path to recipe file if found, None otherwise
+
+    Raises:
+        ValueError: If multiple recipe files found in the same directory
     """
     if start_dir is None:
         start_dir = Path.cwd()
@@ -109,10 +121,30 @@ def find_recipe_file(start_dir: Path | None = None) -> Path | None:
 
     # Search up the directory tree
     while True:
-        for filename in ["tasktree.yaml", "tt.yaml"]:
+        candidates = []
+
+        # Check for exact filenames first
+        for filename in ["tasktree.yaml", "tasktree.yml", "tt.yaml"]:
             recipe_path = current / filename
             if recipe_path.exists():
-                return recipe_path
+                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 len(candidates) > 1:
+            # Multiple recipe files found - ambiguous
+            filenames = [c.name for c in candidates]
+            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(candidates) == 1:
+            return candidates[0]
 
         # Move to parent directory
         parent = current.parent
@@ -186,11 +218,13 @@ def _parse_file_with_env(
     return tasks, environments, default_env
 
 
-def parse_recipe(recipe_path: Path) -> Recipe:
+def parse_recipe(recipe_path: Path, project_root: Path | None = None) -> Recipe:
     """Parse a recipe file and handle imports recursively.
 
     Args:
         recipe_path: Path to the main recipe file
+        project_root: Optional project root directory. If not provided, uses recipe file's parent directory.
+                     When using --tasks option, this should be the current working directory.
 
     Returns:
         Recipe object with all tasks (including recursively imported tasks)
@@ -204,7 +238,9 @@ def parse_recipe(recipe_path: Path) -> Recipe:
     if not recipe_path.exists():
         raise FileNotFoundError(f"Recipe file not found: {recipe_path}")
 
-    project_root = recipe_path.parent
+    # Default project root to recipe file's parent if not specified
+    if project_root is None:
+        project_root = recipe_path.parent
 
     # Parse main file - it will recursively handle all imports
     tasks, environments, default_env = _parse_file_with_env(
@@ -263,8 +299,9 @@ def _parse_file(
     tasks: dict[str, Task] = {}
     file_dir = file_path.parent
 
-    # Default working directory is the file's directory
-    default_working_dir = str(file_dir.relative_to(project_root)) if file_dir != project_root else "."
+    # Default working directory is the project root (where tt is invoked)
+    # NOT the directory where the tasks file is located
+    default_working_dir = "."
 
     # Track local import namespaces for dependency rewriting
     local_import_namespaces: set[str] = set()

{tasktree-0.0.5 → tasktree-0.0.6}/tasktree.yaml

@@ -1,3 +1,5 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/kevinchannon/tasktree/main/schema/tasktree-schema.json
+
 tasks:
   dev-setup:
     desc: Install development dependencies

{tasktree-0.0.5 → tasktree-0.0.6}/tests/integration/test_cli_options.py

@@ -209,6 +209,69 @@ tasks:
                 os.chdir(original_cwd)
 
 
+class TestShowOption(unittest.TestCase):
+    """Test the --show option displays task definitions correctly."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+        self.env = {"NO_COLOR": "1"}
+
+    def test_show_multiline_command_preserves_newlines(self):
+        """Test that --show displays multiline commands with proper newlines, not escaped \\n."""
+        with self.runner.isolated_filesystem():
+            recipe_file = Path("tasktree.yaml")
+            recipe_file.write_text(
+                """
+tasks:
+  multiline:
+    desc: Task with multiline command
+    cmd: |
+      echo "Line 1"
+      echo "Line 2"
+      echo "Line 3"
+"""
+            )
+
+            result = self.runner.invoke(app, ["--show", "multiline"], env=self.env)
+
+            self.assertEqual(result.exit_code, 0)
+
+            # Should show the literal block style indicator
+            self.assertIn("cmd: |", result.stdout)
+
+            # Should show each line on a separate line (not escaped \\n)
+            self.assertIn('echo "Line 1"', result.stdout)
+            self.assertIn('echo "Line 2"', result.stdout)
+            self.assertIn('echo "Line 3"', result.stdout)
+
+            # Should NOT show escaped newlines
+            self.assertNotIn("\\n", result.stdout)
+
+    def test_show_single_line_command(self):
+        """Test that --show displays single-line commands cleanly."""
+        with self.runner.isolated_filesystem():
+            recipe_file = Path("tasktree.yaml")
+            recipe_file.write_text(
+                """
+tasks:
+  single:
+    desc: Task with single line command
+    cmd: echo "Hello world"
+"""
+            )
+
+            result = self.runner.invoke(app, ["--show", "single"], env=self.env)
+
+            self.assertEqual(result.exit_code, 0)
+
+            # Should show the command on a single line
+            self.assertIn('cmd: echo "Hello world"', result.stdout)
+
+            # Should NOT use literal block style for single-line commands
+            self.assertNotIn("cmd: |", result.stdout)
+
+
 class TestForceOption(unittest.TestCase):
     """Test the --force/-f option forces re-run of all tasks."""
 
@@ -649,5 +712,164 @@ tasks:
                 os.chdir(original_cwd)
 
 
+class TestTasksFileOption(unittest.TestCase):
+    """Test the --tasks/-T option for specifying recipe files."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+        self.env = {"NO_COLOR": "1"}
+
+    def test_tasks_option_with_yml_extension(self):
+        """Test --tasks option works with .yml extension."""
+        with self.runner.isolated_filesystem():
+            recipe_file = Path("tasktree.yml")
+            recipe_file.write_text(
+                """
+tasks:
+  build:
+    desc: Build with yml
+    cmd: echo "Building from yml"
+"""
+            )
+
+            result = self.runner.invoke(app, ["--tasks", "tasktree.yml", "build"], env=self.env)
+
+            self.assertEqual(result.exit_code, 0)
+            self.assertIn("build", result.stdout)
+            self.assertIn("completed successfully", result.stdout)
+
+    def test_tasks_option_with_tasks_extension(self):
+        """Test --tasks option works with .tasks extension."""
+        with self.runner.isolated_filesystem():
+            recipe_file = Path("build.tasks")
+            recipe_file.write_text(
+                """
+tasks:
+  compile:
+    desc: Compile code
+    cmd: echo "Compiling"
+"""
+            )
+
+            result = self.runner.invoke(app, ["--tasks", "build.tasks", "compile"], env=self.env)
+
+            self.assertEqual(result.exit_code, 0)
+            self.assertIn("compile", result.stdout)
+            self.assertIn("completed successfully", result.stdout)
+
+    def test_tasks_option_with_short_flag(self):
+        """Test -T short flag works."""
+        with self.runner.isolated_filesystem():
+            recipe_file = Path("my.tasks")
+            recipe_file.write_text(
+                """
+tasks:
+  test:
+    cmd: echo "Testing"
+"""
+            )
+
+            result = self.runner.invoke(app, ["-T", "my.tasks", "test"], env=self.env)
+
+            self.assertEqual(result.exit_code, 0)
+            self.assertIn("test", result.stdout)
+            self.assertIn("completed successfully", result.stdout)
+
+    def test_multiple_recipe_files_without_tasks_option_fails(self):
+        """Test that having multiple recipe files without --tasks raises error."""
+        with self.runner.isolated_filesystem():
+            # Create multiple recipe files
+            Path("tasktree.yaml").write_text("tasks:\n  build:\n    cmd: echo yaml")
+            Path("tasktree.yml").write_text("tasks:\n  build:\n    cmd: echo yml")
+
+            # Should fail with helpful error message
+            result = self.runner.invoke(app, ["build"], env=self.env)
+
+            self.assertNotEqual(result.exit_code, 0)
+            self.assertIn("Multiple recipe files found", result.stdout)
+            self.assertIn("--tasks", result.stdout)
+
+    def test_tasks_option_selects_specific_file_when_multiple_exist(self):
+        """Test --tasks option selects specific file when multiple exist."""
+        with self.runner.isolated_filesystem():
+            # Create multiple recipe files with different task names
+            Path("tasktree.yaml").write_text(
+                """
+tasks:
+  yaml-task:
+    cmd: echo "From yaml"
+"""
+            )
+            Path("build.tasks").write_text(
+                """
+tasks:
+  tasks-task:
+    cmd: echo "From tasks"
+"""
+            )
+
+            # Use --tasks to select the .tasks file - should be able to run tasks-task
+            result = self.runner.invoke(app, ["--tasks", "build.tasks", "tasks-task"], env=self.env)
+            self.assertEqual(result.exit_code, 0)
+            self.assertIn("tasks-task", result.stdout)
+
+            # Should not be able to run yaml-task from build.tasks
+            result = self.runner.invoke(app, ["--tasks", "build.tasks", "yaml-task"], env=self.env)
+            self.assertNotEqual(result.exit_code, 0)
+            self.assertIn("Task not found", result.stdout)
+
+    def test_tasks_option_with_list(self):
+        """Test --tasks option works with --list."""
+        with self.runner.isolated_filesystem():
+            recipe_file = Path("custom.tasks")
+            recipe_file.write_text(
+                """
+tasks:
+  task1:
+    desc: First task
+    cmd: echo one
+  task2:
+    desc: Second task
+    cmd: echo two
+"""
+            )
+
+            result = self.runner.invoke(app, ["--tasks", "custom.tasks", "--list"], env=self.env)
+
+            self.assertEqual(result.exit_code, 0)
+            self.assertIn("task1", result.stdout)
+            self.assertIn("task2", result.stdout)
+            self.assertIn("First task", result.stdout)
+
+    def test_tasks_option_with_show(self):
+        """Test --tasks option works with --show."""
+        with self.runner.isolated_filesystem():
+            recipe_file = Path("my.tasks")
+            recipe_file.write_text(
+                """
+tasks:
+  build:
+    desc: Build task
+    cmd: echo building
+"""
+            )
+
+            result = self.runner.invoke(app, ["--tasks", "my.tasks", "--show", "build"], env=self.env)
+
+            self.assertEqual(result.exit_code, 0)
+            self.assertIn("build:", result.stdout)
+            self.assertIn("desc: Build task", result.stdout)
+
+    def test_tasks_option_with_nonexistent_file(self):
+        """Test --tasks option with nonexistent file shows error."""
+        with self.runner.isolated_filesystem():
+            result = self.runner.invoke(app, ["--tasks", "nonexistent.yaml", "build"], env=self.env)
+
+            self.assertNotEqual(result.exit_code, 0)
+            self.assertIn("Recipe file not found", result.stdout)
+            self.assertIn("nonexistent.yaml", result.stdout)
+
+
 if __name__ == "__main__":
     unittest.main()

{tasktree-0.0.5 → tasktree-0.0.6}/tests/integration/test_working_directory.py

@@ -102,6 +102,47 @@ tasks:
             finally:
                 os.chdir(original_cwd)
 
+    def test_default_working_dir_is_invocation_dir_not_tasks_file_dir(self):
+        """Test that without explicit working_dir, tasks run from where tt is invoked, not where the tasks file is."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            # Create subdirectory with tasks file
+            subdir = project_root / "config"
+            subdir.mkdir()
+
+            # Create tasks file in subdirectory
+            tasks_file = subdir / "build.tasks"
+            tasks_file.write_text("""
+tasks:
+  check-location:
+    desc: Check where we execute from
+    cmd: pwd > location.txt
+""")
+
+            original_cwd = os.getcwd()
+            try:
+                # Invoke tt from project root, pointing to tasks file in subdir
+                os.chdir(project_root)
+
+                result = self.runner.invoke(app, ["--tasks", "config/build.tasks", "check-location"], env=self.env)
+                self.assertEqual(result.exit_code, 0)
+
+                # Verify output was created in project root (where we invoked tt)
+                # NOT in config/ (where the tasks file is)
+                output_in_root = project_root / "location.txt"
+                output_in_subdir = subdir / "location.txt"
+
+                self.assertTrue(output_in_root.exists(), "Output should be in invocation directory (project root)")
+                self.assertFalse(output_in_subdir.exists(), "Output should NOT be in tasks file directory")
+
+                # Verify pwd shows project root path
+                pwd_output = output_in_root.read_text().strip()
+                self.assertEqual(Path(pwd_output).resolve(), project_root.resolve())
+
+            finally:
+                os.chdir(original_cwd)
+
 
 if __name__ == "__main__":
     unittest.main()

{tasktree-0.0.5 → tasktree-0.0.6}/tests/unit/test_parser.py

@@ -910,8 +910,8 @@ class TestFindRecipeFile(unittest.TestCase):
             result = find_recipe_file(project_root)
             self.assertIsNone(result)
 
-    def test_find_recipe_file_prefers_tasktree(self):
-        """Test prefers tasktree.yaml over tt.yaml."""
+    def test_find_recipe_file_multiple_files_raises_error(self):
+        """Test raises error when multiple recipe files found."""
         with TemporaryDirectory() as tmpdir:
             project_root = Path(tmpdir).resolve()
             tasktree_path = project_root / "tasktree.yaml"
@@ -921,8 +921,53 @@ class TestFindRecipeFile(unittest.TestCase):
             tasktree_path.write_text("tasks:\n  build:\n    cmd: echo from tasktree")
             tt_path.write_text("tasks:\n  build:\n    cmd: echo from tt")
 
+            # Should raise ValueError with helpful message
+            with self.assertRaises(ValueError) as cm:
+                find_recipe_file(project_root)
+
+            error_msg = str(cm.exception)
+            self.assertIn("Multiple recipe files found", error_msg)
+            self.assertIn("tasktree.yaml", error_msg)
+            self.assertIn("tt.yaml", error_msg)
+            self.assertIn("--tasks", error_msg)
+
+    def test_find_recipe_file_yml_extension(self):
+        """Test finds tasktree.yml (with .yml extension)."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir).resolve()
+            recipe_path = project_root / "tasktree.yml"
+            recipe_path.write_text("tasks:\n  build:\n    cmd: echo test")
+
+            result = find_recipe_file(project_root)
+            self.assertEqual(result, recipe_path)
+
+    def test_find_recipe_file_tasks_extension(self):
+        """Test finds *.tasks files."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir).resolve()
+            recipe_path = project_root / "build.tasks"
+            recipe_path.write_text("tasks:\n  build:\n    cmd: echo test")
+
             result = find_recipe_file(project_root)
-            self.assertEqual(result, tasktree_path)
+            self.assertEqual(result, recipe_path)
+
+    def test_find_recipe_file_multiple_tasks_files_raises_error(self):
+        """Test raises error when multiple *.tasks files found."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir).resolve()
+            build_tasks = project_root / "build.tasks"
+            test_tasks = project_root / "test.tasks"
+
+            build_tasks.write_text("tasks:\n  build:\n    cmd: echo build")
+            test_tasks.write_text("tasks:\n  test:\n    cmd: echo test")
+
+            # Should raise ValueError
+            with self.assertRaises(ValueError) as cm:
+                find_recipe_file(project_root)
+
+            error_msg = str(cm.exception)
+            self.assertIn("Multiple recipe files found", error_msg)
+            self.assertIn("--tasks", error_msg)
 
 
 class TestEnvironmentParsing(unittest.TestCase):