Updates per claude refactor PR #75

Author: Bullish-Design

src/devman/application/use_cases.py

@@ -1,23 +1,28 @@
 # src/devman/application/use_cases.py
 from __future__ import annotations
 
-import subprocess
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 from result import Err, Ok, Result
 
-from devman.domain.errors import DomainError, DevmanNotFoundError
+from devman.constants import DEVENV_COMMAND
+from devman.domain.errors import DevmanNotFoundError
 from devman.domain.finder import DevmanFinder
 from devman.domain.models import DevmanDirectory, ProjectRoot, ValidationResult
-from devman.templates import TemplateReference, TemplateValidator
+from devman.domain.protocols import (
+    CommandError,
+    CommandExecutor,
+    SubprocessExecutor,
+)
+from devman.domain.templates import TemplateReference, TemplateValidator
 
 
 @dataclass(frozen=True)
 class FindDevmanCommand:
     """Command to locate .devman directory."""
 
-    start_path: Path | None = None
+    start_path: Path
     projects_root: ProjectRoot | None = None
 
 
@@ -58,47 +63,22 @@ class RunDevenvResult:
     exit_code: int
 
 
-@dataclass(frozen=True)
-class RunDevenvError(DomainError):
-    """Error running devenv command."""
-
-    exit_code: int
-    stderr: str | None = None
-
-
 class RunDevenvUseCase:
     """Use case: Execute devenv command in .devman directory."""
 
+    def __init__(self, executor: CommandExecutor | None = None) -> None:
+        self._executor = executor or SubprocessExecutor()
+
     def execute(
         self, command: RunDevenvCommand
-    ) -> Result[RunDevenvResult, RunDevenvError]:
+    ) -> Result[RunDevenvResult, CommandError]:
         """Execute devenv with provided arguments."""
-        try:
-            result = subprocess.run(
-                ["devenv", *command.devenv_args],
-                cwd=command.devman_directory.path,
-                check=True,
-                capture_output=True,
-                text=True,
-            )
-            return Ok(RunDevenvResult(exit_code=result.returncode))
-
-        except subprocess.CalledProcessError as e:
-            return Err(
-                RunDevenvError(
-                    message=f"devenv failed with exit code {e.returncode}",
-                    exit_code=e.returncode,
-                    stderr=e.stderr if e.stderr else None,
-                )
-            )
+        result = self._executor.execute(
+            args=[DEVENV_COMMAND, *command.devenv_args],
+            cwd=command.devman_directory.path,
+        )
 
-        except FileNotFoundError:
-            return Err(
-                RunDevenvError(
-                    message="devenv command not found",
-                    exit_code=127,
-                )
-            )
+        return result.map(lambda r: RunDevenvResult(exit_code=r.exit_code))
 
 
 @dataclass(frozen=True)
@@ -124,5 +104,89 @@ class ValidateTemplateUseCase:
 
     def execute(self, command: ValidateTemplateCommand) -> ValidateTemplateResult:
         """Execute validation."""
-        validation_result = TemplateValidator.validate_typed(command.template_reference)
+        validation_result = TemplateValidator.validate_reference(
+            command.template_reference
+        )
         return ValidateTemplateResult(validation_result=validation_result)
+
+
+@dataclass(frozen=True)
+class CreateProjectCommand:
+    """Command to create a new project from a template."""
+
+    template_source: str
+    destination: Path
+    data: dict[str, str] = field(default_factory=dict)
+    validate: bool = True
+
+
+@dataclass(frozen=True)
+class CreateProjectResult:
+    """Result of project creation."""
+
+    destination: Path
+    validation_result: ValidationResult | None = None
+
+
+@dataclass(frozen=True)
+class CreateProjectError:
+    """Error during project creation."""
+
+    message: str
+    validation_result: ValidationResult | None = None
+
+
+class CreateProjectUseCase:
+    """Use case: Create a new project from a copier template."""
+
+    def execute(
+        self, command: CreateProjectCommand
+    ) -> Result[CreateProjectResult, CreateProjectError]:
+        """Execute project creation."""
+        # Parse template reference
+        try:
+            template_ref = TemplateReference.from_string(command.template_source)
+        except ValueError as e:
+            return Err(
+                CreateProjectError(message=f"Invalid template source: {e}")
+            )
+
+        # Validate if requested
+        validation_result: ValidationResult | None = None
+        if command.validate:
+            validation_result = TemplateValidator.validate_reference(template_ref)
+
+            if not validation_result.is_valid:
+                return Err(
+                    CreateProjectError(
+                        message="Template validation failed",
+                        validation_result=validation_result,
+                    )
+                )
+
+        # Resolve source path
+        source = template_ref.location
+        if template_ref.source_type == "file":
+            source = str(template_ref.resolve_path())
+
+        # Run copier
+        try:
+            from copier import run_copy
+
+            run_copy(
+                src_path=source,
+                dst_path=str(command.destination),
+                data=command.data if command.data else None,
+                unsafe=True,
+            )
+        except Exception as e:
+            return Err(
+                CreateProjectError(message=f"Failed to create project: {e}")
+            )
+
+        return Ok(
+            CreateProjectResult(
+                destination=command.destination,
+                validation_result=validation_result,
+            )
+        )

src/devman/cli.py

@@ -6,55 +6,18 @@
 from pathlib import Path
 
 import typer
-from copier import run_copy
 
 from devman import __version__
 from devman.application.use_cases import (
+    CreateProjectCommand,
+    CreateProjectUseCase,
     FindDevmanCommand,
     FindDevmanUseCase,
     RunDevenvCommand,
     RunDevenvUseCase,
-    ValidateTemplateCommand,
-    ValidateTemplateUseCase,
 )
-from devman.config import load_config
+from devman.config import ConfigRepository, load_config
 from devman.domain.models import ProjectRoot
-from devman.templates import TemplateReference
-
-
-# Re-export domain DevmanFinder for backward compatibility
-from devman.domain.finder import DevmanFinder as _DomainFinder  # noqa: F401
-
-
-class DevmanFinder:
-    """Locate the nearest devman configuration directory.
-
-    Legacy wrapper for backward compatibility.
-    Prefer using devman.domain.finder.DevmanFinder directly.
-    """
-
-    def __init__(self, projects_root: Path | None = None) -> None:
-        self.projects_root = projects_root
-
-    @classmethod
-    def from_config(cls) -> DevmanFinder:
-        config = load_config()
-        return cls(projects_root=config.projects_root)
-
-    def find(self, start_path: Path | None = None) -> Path | None:
-        """Find .devman directory, returning Path or None for backward compat."""
-        root = None
-        if self.projects_root is not None:
-            root_result = ProjectRoot.create(self.projects_root)
-            if root_result.is_ok():
-                root = root_result.unwrap()
-
-        domain_finder = _DomainFinder(projects_root=root)
-        result = domain_finder.find(start_path=start_path)
-
-        if result.is_ok():
-            return result.unwrap().path
-        return None
 
 
 app = typer.Typer()
@@ -86,7 +49,7 @@ def run(
 
     # Execute find use case
     find_use_case = FindDevmanUseCase()
-    find_command = FindDevmanCommand(projects_root=root)
+    find_command = FindDevmanCommand(start_path=Path.cwd(), projects_root=root)
     find_result = find_use_case.execute(find_command)
 
     if find_result.is_err():
@@ -125,66 +88,52 @@ def new(
     ),
 ) -> None:
     """Create a new project from a copier template."""
-    # Parse template reference
-    try:
-        template_ref = TemplateReference.from_string(template_source)
-    except ValueError as e:
-        typer.echo(f"Invalid template source: {e}", err=True)
-        raise typer.Exit(1)
-
-    # Validate if requested
-    if validate:
-        typer.echo("Validating template...")
-
-        validate_use_case = ValidateTemplateUseCase()
-        validate_command = ValidateTemplateCommand(template_reference=template_ref)
-        validate_result = validate_use_case.execute(validate_command)
-
-        vr = validate_result.validation_result
-
-        if not vr.is_valid:
-            typer.echo("Template validation errors:", err=True)
-            for error in vr.errors:
-                loc = f" ({error.location})" if error.location else ""
-                typer.echo(f"  - {error.message}{loc}", err=True)
-            raise typer.Exit(1)
-
-        if vr.warnings:
-            typer.echo("Template warnings:")
-            for warning in vr.warnings:
-                loc = f" ({warning.location})" if warning.location else ""
-                typer.echo(f"  - {warning.message}{loc}")
-
     # Parse data overrides
-    data_dict = {}
+    data_dict: dict[str, str] = {}
     for item in data:
         if "=" not in item:
             typer.echo(f"Invalid data format: {item} (expected key=value)", err=True)
             raise typer.Exit(1)
         key, value = item.split("=", 1)
         data_dict[key] = value
 
-    # Run copier
-    try:
-        typer.echo(f"Creating project at {destination}...")
+    # Execute use case
+    use_case = CreateProjectUseCase()
+    command = CreateProjectCommand(
+        template_source=template_source,
+        destination=destination,
+        data=data_dict,
+        validate=validate,
+    )
 
-        source = template_ref.location
-        if template_ref.source_type == "file":
-            source = str(template_ref.resolve_path())
+    typer.echo(f"Creating project at {destination}...")
+    result = use_case.execute(command)
 
-        run_copy(
-            src_path=source,
-            dst_path=str(destination),
-            data=data_dict if data_dict else None,
-            unsafe=True,
-        )
+    if result.is_err():
+        error = result.unwrap_err()
 
-        typer.echo(f"Project created successfully at {destination}")
+        # Show validation errors if present
+        if error.validation_result and not error.validation_result.is_valid:
+            typer.echo("Template validation errors:", err=True)
+            for issue in error.validation_result.errors:
+                loc = f" ({issue.location})" if issue.location else ""
+                typer.echo(f"  - {issue.message}{loc}", err=True)
+        else:
+            typer.echo(error.message, err=True)
 
-    except Exception as e:
-        typer.echo(f"Failed to create project: {e}", err=True)
         raise typer.Exit(1)
 
+    success = result.unwrap()
+
+    # Show warnings if any
+    if success.validation_result and success.validation_result.warnings:
+        typer.echo("Template warnings:")
+        for warning in success.validation_result.warnings:
+            loc = f" ({warning.location})" if warning.location else ""
+            typer.echo(f"  - {warning.message}{loc}")
+
+    typer.echo(f"Project created successfully at {destination}")
+
 
 @app.command()
 def config(
@@ -199,23 +148,20 @@ def config(
         typer.echo("No configuration changes provided.", err=True)
         raise typer.Exit(1)
 
+    repo = ConfigRepository()
+
     if show:
-        current_config = load_config()
+        current_config = repo.load()
         typer.echo("Current configuration:")
         if current_config.projects_root is None:
             typer.echo("  projects_root: (not set)")
         else:
             typer.echo(f"  projects_root: {current_config.projects_root}")
 
     if projects_root is not None:
-        config_path = Path("~/.config/devman/config.env").expanduser()
-        config_path.parent.mkdir(parents=True, exist_ok=True)
-        resolved_root = projects_root.expanduser().resolve()
-        config_path.write_text(
-            f"DEVMAN_PROJECTS_ROOT={resolved_root}\n",
-            encoding="utf-8",
-        )
-        typer.echo(f"Updated projects root to {resolved_root}.")
+        repo.save_projects_root(projects_root)
+        resolved = projects_root.expanduser().resolve()
+        typer.echo(f"Updated projects root to {resolved}.")
 
 
 @app.command()