relm 3.0.2__tar.gz → 5.0.0__tar.gz

{relm-3.0.2 → relm-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relm
-Version: 3.0.2
+Version: 5.0.0
 Summary: A unified CLI tool to manage versioning, git, and PyPI releases for multiple projects.
 Author-email: dhruv13x <dhruv13x@gmail.com>
 License: MIT © dhruv13x
@@ -20,6 +20,7 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: rich-argparse>=1.0.0
 Requires-Dist: build>=1.0.0
 Requires-Dist: twine>=4.0.0
+Requires-Dist: pyfakefs>=5.10.2
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0.0; extra == "dev"

{relm-3.0.2 → relm-5.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "relm"
-version = "3.0.2"
+version = "5.0.0"
 description = "A unified CLI tool to manage versioning, git, and PyPI releases for multiple projects."
 readme = "README.md"
 requires-python = ">=3.8"
@@ -37,7 +37,8 @@ dependencies = [
   "rich>=13.0.0",
   "rich-argparse>=1.0.0",
   "build>=1.0.0",
-  "twine>=4.0.0"
+  "twine>=4.0.0",
+  "pyfakefs>=5.10.2",
 ]
 
 [project.urls]

{relm-3.0.2 → relm-5.0.0}/src/relm/__init__.py

@@ -1,3 +1,3 @@
 # src/relm/__init__.py
 
-__version__ = "3.0.2"
+__version__ = "5.0.0"

{relm-3.0.2 → relm-5.0.0}/src/relm/commands/base.py

@@ -1,3 +1,4 @@
+import argparse
 from argparse import ArgumentParser, Namespace
 from rich.console import Console
 

{relm-3.0.2 → relm-5.0.0}/src/relm/commands/clean_command.py

@@ -1,3 +1,4 @@
+import argparse
 import sys
 from argparse import Namespace, _SubParsersAction
 from pathlib import Path
@@ -5,27 +6,45 @@ from rich.console import Console
 from ..core import find_projects
 from ..clean import clean_project
 
-def register(subparsers: _SubParsersAction):
+def register(subparsers: _SubParsersAction, base_parser: argparse.ArgumentParser):
     """Register the clean command."""
-    clean_parser = subparsers.add_parser("clean", help="Recursively remove build artifacts (dist/, build/, __pycache__)")
+    clean_parser = subparsers.add_parser("clean", help="Recursively remove build artifacts (dist/, build/, __pycache__)", parents=[base_parser])
     clean_parser.add_argument("project_name", help="Name of the project to clean or 'all'", nargs="?", default="all")
     clean_parser.set_defaults(func=execute)
 
 def execute(args: Namespace, console: Console):
     """Execute the clean command."""
     root_path = Path(args.path).resolve()
-    all_projects = find_projects(root_path)
+    all_projects = find_projects(
+        root_path,
+        recursive=getattr(args, "recursive", False),
+        max_depth=getattr(args, "depth", 2)
+    )
     target_projects = []
 
     if args.project_name == "all":
         target_projects = all_projects
+        if getattr(args, "from_root", False):
+            target_projects = [p for p in target_projects if p.path.resolve() != root_path.resolve()]
         console.print(f"[bold]Cleaning workspace for {len(target_projects)} projects...[/bold]")
     else:
-        target = next((p for p in all_projects if p.name == args.project_name), None)
-        if not target:
-            console.print(f"[red]Project '{args.project_name}' not found in {root_path}[/red]")
-            sys.exit(1)
-        target_projects = [target]
+        # 1. Try path-based matching
+        target_dir = (root_path / args.project_name).resolve()
+        if target_dir.exists() and target_dir.is_dir():
+            target_projects = [
+                p for p in all_projects 
+                if p.path.resolve() == target_dir or target_dir in p.path.resolve().parents
+            ]
+            if target_projects:
+                console.print(f"[bold]Targeting {len(target_projects)} projects in folder: [cyan]{args.project_name}[/cyan][/bold]")
+
+        # 2. Try exact name match
+        if not target_projects:
+            target = next((p for p in all_projects if p.name == args.project_name), None)
+            if not target:
+                console.print(f"[red]Project or folder '{args.project_name}' not found in {root_path}[/red]")
+                sys.exit(1)
+            target_projects = [target]
 
     total_cleaned_paths = 0
 

{relm-3.0.2 → relm-5.0.0}/src/relm/commands/create_command.py

@@ -1,14 +1,13 @@
+import argparse
 import os
 from argparse import Namespace, _SubParsersAction
 from pathlib import Path
 from rich.console import Console
 
-def register(subparsers: _SubParsersAction):
+def register(subparsers: _SubParsersAction, base_parser: argparse.ArgumentParser):
     """Register the create command."""
-    parser = subparsers.add_parser("create", help="Create a new Python project")
-    parser.add_argument("name", help="Name of the project")
-    parser.add_argument("path", nargs="?", help="Directory to create the project in (defaults to current directory)")
-    parser.set_defaults(func=execute)
+    create_parser = subparsers.add_parser("create", help="Create a new Python project", parents=[base_parser])
+    create_parser.add_argument("name", help="Name of the new project")
 
 def execute(args: Namespace, console: Console):
     """Execute the create command."""

{relm-3.0.2 → relm-5.0.0}/src/relm/commands/gc_command.py

@@ -1,3 +1,4 @@
+import argparse
 import sys
 from argparse import Namespace, _SubParsersAction
 from pathlib import Path
@@ -5,10 +6,10 @@ from rich.console import Console
 from ..core import find_projects
 from ..gc import gc_project
 
-def register(subparsers: _SubParsersAction):
+def register(subparsers: _SubParsersAction, base_parser: argparse.ArgumentParser):
     """Register the gc command."""
-    gc_parser = subparsers.add_parser("gc", help="Run git gc on project(s)")
-    gc_parser.add_argument("project_name", help="Name of the project to clean or 'all'", nargs="?", default="all")
+    gc_parser = subparsers.add_parser("gc", help="Run git gc on project(s)", parents=[base_parser])
+    gc_parser.add_argument("project_name", help="Name of the project to gc or 'all'", nargs="?", default="all")
     gc_parser.set_defaults(func=execute)
 
 def execute(args: Namespace, console: Console):

relm-5.0.0/src/relm/commands/install_command.py

@@ -0,0 +1,97 @@
+import argparse
+import sys
+from argparse import Namespace, _SubParsersAction
+from pathlib import Path
+from rich.console import Console
+from ..core import find_projects, sort_projects_by_dependency
+from ..install import install_project
+
+def register(subparsers: _SubParsersAction, base_parser: argparse.ArgumentParser):
+    """Register the install command."""
+    install_parser = subparsers.add_parser("install", help="Install projects into the current environment", parents=[base_parser])
+    install_parser.add_argument("project_name", help="Name of the project to install or 'all'")
+    install_parser.add_argument("--no-editable", action="store_true", help="Install in standard mode instead of editable")
+    install_parser.set_defaults(func=execute)
+
+def execute(args: Namespace, console: Console):
+    """Execute the install command."""
+    root_path = Path(args.path).resolve()
+    all_projects = find_projects(
+        root_path,
+        recursive=getattr(args, "recursive", False),
+        max_depth=getattr(args, "depth", 2)
+    )
+    target_projects = []
+
+    if args.project_name == "all":
+        try:
+            target_projects = sort_projects_by_dependency(all_projects)
+            if getattr(args, "from_root", False):
+                target_projects = [p for p in target_projects if p.path.resolve() != root_path.resolve()]
+        except ValueError as e:
+            console.print(f"[red]Dependency sorting failed: {e}[/red]")
+            sys.exit(1)
+    else:
+        # 1. Try path-based matching
+        target_dir = (root_path / args.project_name).resolve()
+        if target_dir.exists() and target_dir.is_dir():
+            target_projects = [
+                p for p in all_projects 
+                if p.path.resolve() == target_dir or target_dir in p.path.resolve().parents
+            ]
+            if target_projects:
+                try:
+                    target_projects = sort_projects_by_dependency(target_projects)
+                except ValueError as e:
+                    console.print(f"[red]Dependency sorting failed: {e}[/red]")
+                    sys.exit(1)
+                console.print(f"[bold]Targeting {len(target_projects)} projects in folder: [cyan]{args.project_name}[/cyan][/bold]")
+
+        # 2. Try exact name match
+        if not target_projects:
+            target = next((p for p in all_projects if p.name == args.project_name), None)
+            if not target:
+                console.print(f"[red]Project or folder '{args.project_name}' not found in {root_path}[/red]")
+                sys.exit(1)
+            target_projects = [target]
+
+    results = {"installed": [], "failed": []}
+    editable_mode = not args.no_editable
+
+    if getattr(args, "parallel", False):
+        from ..runner import execute_in_parallel
+        
+        def cmd_provider(p):
+            # We need to construct the pip install command manually for parallel runner
+            # since install_project uses subprocess directly.
+            mode = "-e" if editable_mode else ""
+            return [sys.executable, "-m", "pip", "install", mode, "."]
+
+        results_data = execute_in_parallel(
+            target_projects,
+            command_provider=cmd_provider,
+            max_workers=args.jobs,
+            fail_fast=True # Always fail-fast for installation dependencies
+        )
+        
+        for res in results_data:
+            if res["success"]:
+                results["installed"].append(res["name"])
+            else:
+                results["failed"].append(res["name"])
+                console.rule(f"[red]Install FAILED for: {res['name']}[/red]")
+                if res["stdout"]: console.print(res["stdout"])
+                if res["stderr"]: console.print(res["stderr"], style="red")
+    else:
+        for project in target_projects:
+            success = install_project(project, editable=editable_mode)
+            if success:
+                results["installed"].append(project.name)
+            else:
+                results["failed"].append(project.name)
+
+    if args.project_name == "all":
+        console.rule("Bulk Install Summary")
+        console.print(f"[green]Installed: {len(results['installed'])}[/green] {results['installed']}")
+        if results["failed"]:
+            console.print(f"[red]Failed:    {len(results['failed'])}[/red] {results['failed']}")

{relm-3.0.2 → relm-5.0.0}/src/relm/commands/list_command.py

@@ -1,3 +1,4 @@
+import argparse
 from argparse import Namespace, _SubParsersAction
 from pathlib import Path
 from rich.console import Console
@@ -5,16 +6,20 @@ from rich.table import Table
 from ..core import find_projects
 from ..git_ops import git_has_changes_since
 
-def register(subparsers: _SubParsersAction):
+def register(subparsers: _SubParsersAction, base_parser: argparse.ArgumentParser):
     """Register the list command."""
-    list_parser = subparsers.add_parser("list", help="List all discovered projects")
+    list_parser = subparsers.add_parser("list", help="List all discovered projects", parents=[base_parser])
     list_parser.add_argument("--since", help="List only projects changed since the given git ref")
     list_parser.set_defaults(func=execute)
 
 def execute(args: Namespace, console: Console):
     """Execute the list command."""
     root_path = Path(args.path).resolve()
-    projects = find_projects(root_path)
+    projects = find_projects(
+        root_path, 
+        recursive=getattr(args, "recursive", False), 
+        max_depth=getattr(args, "depth", 2)
+    )
 
     if args.since:
         projects = [p for p in projects if git_has_changes_since(p.path, args.since)]

relm-5.0.0/src/relm/commands/pytest_command.py

@@ -0,0 +1,195 @@
+import argparse
+import sys
+import subprocess
+from argparse import Namespace, _SubParsersAction
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from ..core import find_projects, sort_projects_by_dependency
+from ..runner import execute_in_parallel
+
+def register(subparsers: _SubParsersAction, base_parser: argparse.ArgumentParser):
+    """Register the pytest command."""
+    pytest_parser = subparsers.add_parser("pytest", help="Run pytest across projects and summarize results", parents=[base_parser])
+    pytest_parser.add_argument(
+        "project_name", 
+        nargs="?", 
+        default="all", 
+        help="Name of the project to run on or 'all' (default: all)"
+    )
+    pytest_parser.add_argument(
+        "--fail-fast", 
+        action="store_true", 
+        help="Stop execution if a project's tests fail"
+    )
+    # We handle pytest arguments manually via -- separator in execute()
+    pytest_parser.set_defaults(func=execute)
+
+def execute(args: Namespace, console: Console):
+    """Execute the pytest command."""
+    # Manual extraction of pytest arguments from sys.argv
+    pytest_args = []
+    if "--" in sys.argv:
+        idx = sys.argv.index("--")
+        pytest_args = sys.argv[idx + 1:]
+
+    root_path = Path(args.path).resolve()
+    all_projects = find_projects(
+        root_path,
+        recursive=getattr(args, "recursive", False),
+        max_depth=getattr(args, "depth", 2)
+    )
+    target_projects = []
+
+    if args.project_name == "all":
+        try:
+            target_projects = sort_projects_by_dependency(all_projects)
+            # If running from root, skip the project that IS the root to avoid double execution
+            if getattr(args, "from_root", False):
+                target_projects = [p for p in target_projects if p.path.resolve() != root_path.resolve()]
+        except ValueError as e:
+            console.print(f"[red]Dependency sorting failed: {e}[/red]")
+            sys.exit(1)
+    else:
+        # 1. Try path-based matching (e.g. relm pytest packages)
+        target_dir = (root_path / args.project_name).resolve()
+        if target_dir.exists() and target_dir.is_dir():
+            # Filter all projects that are under this directory
+            target_projects = [
+                p for p in all_projects 
+                if p.path.resolve() == target_dir or target_dir in p.path.resolve().parents
+            ]
+            if target_projects:
+                try:
+                    target_projects = sort_projects_by_dependency(target_projects)
+                except ValueError as e:
+                    console.print(f"[red]Dependency sorting failed: {e}[/red]")
+                    sys.exit(1)
+                console.print(f"[bold]Targeting {len(target_projects)} projects in folder: [cyan]{args.project_name}[/cyan][/bold]")
+        
+        # 2. If no projects found via path, try exact name match
+        if not target_projects:
+            target = next((p for p in all_projects if p.name == args.project_name), None)
+            if not target:
+                console.print(f"[red]Project or folder '{args.project_name}' not found in {root_path}[/red]")
+                sys.exit(1)
+            target_projects = [target]
+
+    console.print(f"[bold]Running pytest on {len(target_projects)} projects...[/bold]")
+    if pytest_args:
+        console.print(f"[dim]Pytest arguments: {' '.join(pytest_args)}[/dim]")
+
+    use_from_root = getattr(args, "from_root", False)
+    cwd = root_path if use_from_root else None
+
+    if getattr(args, "parallel", False):
+        def cmd_provider(p):
+            base_cmd = [sys.executable, "-m", "pytest"]
+            if use_from_root:
+                # Use relative path if possible for cleaner output
+                try:
+                    target_path = str(p.path.relative_to(root_path))
+                except ValueError:
+                    target_path = str(p.path)
+                return base_cmd + [target_path] + pytest_args
+            return base_cmd + pytest_args
+
+        results_data = execute_in_parallel(
+            target_projects,
+            command_provider=cmd_provider,
+            max_workers=args.jobs,
+            fail_fast=args.fail_fast,
+            cwd=cwd
+        )
+        # Map back to simple results format for summary
+        results = results_data
+        
+        # In parallel mode, show output for failed projects since it was captured
+        for res in results:
+            if not res["success"]:
+                console.rule(f"[red]Summary for FAILED project: {res['name']}[/red]")
+                if res["stdout"]:
+                    from rich.panel import Panel
+                    console.print(Panel(
+                        res["stdout"], 
+                        title="Last 50 lines of output", 
+                        subtitle="Truncated to prevent system crash",
+                        border_style="red"
+                    ))
+                if res["stderr"]:
+                    console.print(res["stderr"], style="red")
+    else:
+        results = []
+        for project in target_projects:
+            console.rule(f"Testing {project.name}")
+            
+            base_cmd = [sys.executable, "-m", "pytest"]
+            if use_from_root:
+                try:
+                    target_path = str(project.path.relative_to(root_path))
+                except ValueError:
+                    target_path = str(project.path)
+                cmd = base_cmd + [target_path] + pytest_args
+            else:
+                cmd = base_cmd + pytest_args
+            
+            try:
+                from ..runner import run_project_command_tail
+                res_data = run_project_command_tail(cwd or project.path, cmd, tail_lines=50)
+                success = (res_data["returncode"] == 0)
+                
+                if not success:
+                    from rich.panel import Panel
+                    console.print(Panel(
+                        res_data["stdout"], 
+                        title=f"Failure Summary: {project.name}", 
+                        subtitle="Last 50 lines of output",
+                        border_style="red"
+                    ))
+            except Exception as e:
+                console.print(f"[red]Error executing pytest in {project.name}: {e}[/red]")
+                success = False
+                res_data = {"stdout": str(e), "stderr": ""}
+
+            results.append({
+                "name": project.name,
+                "success": success,
+                "path": project.path,
+                "stdout": res_data["stdout"]
+            })
+
+            if not success and args.fail_fast:
+                console.print(f"[red]Fail-fast enabled. Stopping further tests.[/red]")
+                break
+
+    # Final Summary
+    console.rule("Pytest Summary")
+    
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Project", style="cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Path", style="dim")
+
+    passed_count = 0
+    for res in results:
+        status = "[green]PASSED[/green]" if res["success"] else "[red]FAILED[/red]"
+        if res["success"]:
+            passed_count += 1
+        table.add_row(res["name"], status, str(res["path"]))
+
+    console.print(table)
+
+    total = len(target_projects)
+    run_count = len(results)
+    failed_count = run_count - passed_count
+
+    summary_msg = f"[bold]Ran tests for {run_count}/{total} projects.[/bold] "
+    summary_msg += f"[green]{passed_count} passed[/green], [red]{failed_count} failed[/red]."
+    
+    if run_count < total:
+        summary_msg += f" [yellow]({total - run_count} skipped due to fail-fast)[/yellow]"
+    
+    console.print(summary_msg)
+
+    if failed_count > 0:
+        sys.exit(1)

{relm-3.0.2 → relm-5.0.0}/src/relm/commands/release_command.py

@@ -1,3 +1,4 @@
+import argparse
 import sys
 from argparse import Namespace, _SubParsersAction
 from pathlib import Path
@@ -5,9 +6,9 @@ from rich.console import Console
 from ..core import find_projects, sort_projects_by_dependency
 from ..release import perform_release
 
-def register(subparsers: _SubParsersAction):
+def register(subparsers: _SubParsersAction, base_parser: argparse.ArgumentParser):
     """Register the release command."""
-    release_parser = subparsers.add_parser("release", help="Release a new version of a project")
+    release_parser = subparsers.add_parser("release", help="Release a new version of a project", parents=[base_parser])
     release_parser.add_argument("project_name", help="Name of the project to release (must match pyproject.toml name)")
     release_parser.add_argument("type", choices=["major", "minor", "patch", "alpha", "beta", "rc", "release"], default="patch", nargs="?", help="Type of version bump")
     release_parser.add_argument("-y", "--yes", action="store_true", help="Skip confirmation prompts (assume yes)")
@@ -17,7 +18,11 @@ def register(subparsers: _SubParsersAction):
 def execute(args: Namespace, console: Console):
     """Execute the release command."""
     root_path = Path(args.path).resolve()
-    all_projects = find_projects(root_path)
+    all_projects = find_projects(
+        root_path,
+        recursive=getattr(args, "recursive", False),
+        max_depth=getattr(args, "depth", 2)
+    )
 
     target_projects = []
     check_changes_flag = False

relm-5.0.0/src/relm/commands/run_command.py

@@ -0,0 +1,102 @@
+import argparse
+import sys
+from argparse import Namespace, _SubParsersAction
+from pathlib import Path
+from rich.console import Console
+from ..core import find_projects, sort_projects_by_dependency
+from ..runner import run_project_command
+
+def register(subparsers: _SubParsersAction, base_parser: argparse.ArgumentParser):
+    """Register the run command."""
+    run_parser = subparsers.add_parser("run", help="Run a shell command across projects", parents=[base_parser])
+    run_parser.add_argument("command_string", help="The shell command to execute")
+    run_parser.add_argument("project_name", nargs="?", default="all", help="Name of the project to run on or 'all'")
+    run_parser.add_argument("--fail-fast", action="store_true", help="Stop execution if a command fails")
+    run_parser.set_defaults(func=execute)
+
+def execute(args: Namespace, console: Console):
+    """Execute the run command."""
+    root_path = Path(args.path).resolve()
+    all_projects = find_projects(
+        root_path,
+        recursive=getattr(args, "recursive", False),
+        max_depth=getattr(args, "depth", 2)
+    )
+    target_projects = []
+
+    if args.project_name == "all":
+        try:
+            target_projects = sort_projects_by_dependency(all_projects)
+            if getattr(args, "from_root", False):
+                target_projects = [p for p in target_projects if p.path.resolve() != root_path.resolve()]
+        except ValueError as e:
+            console.print(f"[red]Dependency sorting failed: {e}[/red]")
+            sys.exit(1)
+    else:
+        # 1. Try path-based matching (e.g. relm run "ls" packages)
+        target_dir = (root_path / args.project_name).resolve()
+        if target_dir.exists() and target_dir.is_dir():
+            target_projects = [
+                p for p in all_projects 
+                if p.path.resolve() == target_dir or target_dir in p.path.resolve().parents
+            ]
+            if target_projects:
+                try:
+                    target_projects = sort_projects_by_dependency(target_projects)
+                except ValueError as e:
+                    console.print(f"[red]Dependency sorting failed: {e}[/red]")
+                    sys.exit(1)
+                console.print(f"[bold]Targeting {len(target_projects)} projects in folder: [cyan]{args.project_name}[/cyan][/bold]")
+
+        # 2. Try exact name match
+        if not target_projects:
+            target = next((p for p in all_projects if p.name == args.project_name), None)
+            if not target:
+                console.print(f"[red]Project or folder '{args.project_name}' not found in {root_path}[/red]")
+                sys.exit(1)
+            target_projects = [target]
+
+    results = {"success": [], "failed": []}
+    use_from_root = getattr(args, "from_root", False)
+    cwd = root_path if use_from_root else None
+
+    if getattr(args, "parallel", False):
+        from ..runner import execute_in_parallel
+        
+        def cmd_provider(p):
+            return args.command_string
+
+        results_data = execute_in_parallel(
+            target_projects,
+            command_provider=cmd_provider,
+            max_workers=args.jobs,
+            fail_fast=args.fail_fast,
+            cwd=cwd
+        )
+        
+        for res in results_data:
+            if res["success"]:
+                results["success"].append(res["name"])
+            else:
+                results["failed"].append(res["name"])
+                console.rule(f"[red]Output for FAILED project: {res['name']}[/red]")
+                if res["stdout"]: console.print(res["stdout"])
+                if res["stderr"]: console.print(res["stderr"], style="red")
+    else:
+        for project in target_projects:
+            console.rule(f"Running on {project.name}")
+            success = run_project_command(cwd or project.path, args.command_string)
+            if success:
+                results["success"].append(project.name)
+            else:
+                results["failed"].append(project.name)
+                if args.fail_fast:
+                    console.print(f"[red]Fail-fast enabled. Stopping execution.[/red]")
+                    break
+
+    console.rule("Execution Summary")
+    if results["success"]:
+        console.print(f"[green]Success: {len(results['success'])}[/green] {results['success']}")
+    if results["failed"]:
+        console.print(f"[red]Failed:  {len(results['failed'])}[/red] {results['failed']}")
+        sys.exit(1)

{relm-3.0.2 → relm-5.0.0}/src/relm/commands/status_command.py

@@ -1,3 +1,4 @@
+import argparse
 import sys
 from argparse import Namespace, _SubParsersAction
 from pathlib import Path
@@ -6,26 +7,42 @@ from rich.table import Table
 from ..core import find_projects
 from ..git_ops import is_git_clean, get_current_branch
 
-def register(subparsers: _SubParsersAction):
+def register(subparsers: _SubParsersAction, base_parser: argparse.ArgumentParser):
     """Register the status command."""
-    status_parser = subparsers.add_parser("status", help="Check git status of projects")
+    status_parser = subparsers.add_parser("status", help="Check git status of projects", parents=[base_parser])
     status_parser.add_argument("project_name", help="Name of the project to check or 'all'", nargs="?", default="all")
     status_parser.set_defaults(func=execute)
 
 def execute(args: Namespace, console: Console):
     """Execute the status command."""
     root_path = Path(args.path).resolve()
-    all_projects = find_projects(root_path)
+    all_projects = find_projects(
+        root_path,
+        recursive=getattr(args, "recursive", False),
+        max_depth=getattr(args, "depth", 2)
+    )
     target_projects = []
 
     if args.project_name == "all":
         target_projects = all_projects
     else:
-        target = next((p for p in all_projects if p.name == args.project_name), None)
-        if not target:
-            console.print(f"[red]Project '{args.project_name}' not found in {root_path}[/red]")
-            sys.exit(1)
-        target_projects = [target]
+        # 1. Try path-based matching
+        target_dir = (root_path / args.project_name).resolve()
+        if target_dir.exists() and target_dir.is_dir():
+            target_projects = [
+                p for p in all_projects 
+                if p.path.resolve() == target_dir or target_dir in p.path.resolve().parents
+            ]
+            if target_projects:
+                console.print(f"[bold]Targeting {len(target_projects)} projects in folder: [cyan]{args.project_name}[/cyan][/bold]")
+
+        # 2. Try exact name match
+        if not target_projects:
+            target = next((p for p in all_projects if p.name == args.project_name), None)
+            if not target:
+                console.print(f"[red]Project or folder '{args.project_name}' not found in {root_path}[/red]")
+                sys.exit(1)
+            target_projects = [target]
 
     table = Table(title=f"Git Status for {len(target_projects)} Projects")
     table.add_column("Project", style="cyan", no_wrap=True)