specfact-cli 0.20.0__tar.gz → 0.20.1__tar.gz

{specfact_cli-0.20.0 → specfact_cli-0.20.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfact-cli
-Version: 0.20.0
+Version: 0.20.1
 Summary: Brownfield-first CLI: Reverse engineer legacy Python → specs → enforced contracts. Automate legacy code documentation and prevent modernization regressions.
 Project-URL: Homepage, https://github.com/nold-ai/specfact-cli
 Project-URL: Repository, https://github.com/nold-ai/specfact-cli.git

{specfact_cli-0.20.0 → specfact_cli-0.20.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "specfact-cli"
-version = "0.20.0"
+version = "0.20.1"
 description = "Brownfield-first CLI: Reverse engineer legacy Python → specs → enforced contracts. Automate legacy code documentation and prevent modernization regressions."
 readme = "README.md"
 requires-python = ">=3.11"

{specfact_cli-0.20.0 → specfact_cli-0.20.1}/src/__init__.py

@@ -3,4 +3,4 @@ SpecFact CLI - Spec→Contract→Sentinel tool for contract-driven development.
 """
 
 # Define the package version (kept in sync with pyproject.toml and setup.py)
-__version__ = "0.20.0"
+__version__ = "0.20.1"

{specfact_cli-0.20.0 → specfact_cli-0.20.1}/src/specfact_cli/__init__.py

@@ -9,6 +9,6 @@ This package provides command-line tools for:
 - Validating reproducibility
 """
 
-__version__ = "0.20.0"
+__version__ = "0.20.1"
 
 __all__ = ["__version__"]

{specfact_cli-0.20.0 → specfact_cli-0.20.1}/src/specfact_cli/commands/generate.py

@@ -19,6 +19,12 @@ from specfact_cli.models.sdd import SDDManifest
 from specfact_cli.models.task import TaskList, TaskPhase
 from specfact_cli.telemetry import telemetry
 from specfact_cli.utils import print_error, print_info, print_success, print_warning
+from specfact_cli.utils.env_manager import (
+    build_tool_command,
+    detect_env_manager,
+    detect_source_directories,
+    find_test_files_for_source,
+)
 from specfact_cli.utils.optional_deps import check_cli_tool_available
 from specfact_cli.utils.structured_io import load_structured_file
 
@@ -931,12 +937,24 @@ def apply_enhanced_contracts(
             parts = enhanced_stem.split("-")
             if len(parts) >= 2:
                 original_name = parts[1]  # Get the original file name
-                # Try common locations
-                possible_paths = [
-                    repo_path / f"src/specfact_cli/{original_name}.py",
-                    repo_path / f"src/{original_name}.py",
-                    repo_path / f"{original_name}.py",
-                ]
+                # Detect source directories dynamically
+                source_dirs = detect_source_directories(repo_path)
+                # Build possible paths based on detected source directories
+                possible_paths: list[Path] = []
+                # Add root-level file
+                possible_paths.append(repo_path / f"{original_name}.py")
+                # Add paths based on detected source directories
+                for src_dir in source_dirs:
+                    # Remove trailing slash if present
+                    src_dir_clean = src_dir.rstrip("/")
+                    possible_paths.append(repo_path / src_dir_clean / f"{original_name}.py")
+                # Also try common patterns as fallback
+                possible_paths.extend(
+                    [
+                        repo_path / f"src/{original_name}.py",
+                        repo_path / f"lib/{original_name}.py",
+                    ]
+                )
                 for path in possible_paths:
                     if path.exists():
                         original_file = path
@@ -980,11 +998,16 @@ def apply_enhanced_contracts(
     console.print("\n[bold cyan]Step 2/6: Validating enhanced code syntax...[/bold cyan]")
     syntax_errors: list[str] = []
     try:
+        # Detect environment manager and build appropriate command
+        env_info = detect_env_manager(repo_path)
+        python_command = ["python", "-m", "py_compile", str(enhanced_file)]
+        compile_command = build_tool_command(env_info, python_command)
         result = subprocess.run(
-            ["python", "-m", "py_compile", str(enhanced_file)],
+            compile_command,
             capture_output=True,
             text=True,
             timeout=10,
+            cwd=str(repo_path),
         )
         if result.returncode != 0:
             error_output = result.stderr.strip()
@@ -1104,6 +1127,9 @@ def apply_enhanced_contracts(
     tools_checked = 0
     tools_passed = 0
 
+    # Detect environment manager for building commands
+    env_info = detect_env_manager(repo_path)
+
     # List of common linting/formatting tools to check
     linting_tools = [
         ("ruff", ["ruff", "check", str(enhanced_file)], "Ruff linting"),
@@ -1122,8 +1148,10 @@ def apply_enhanced_contracts(
         console.print(f"[dim]Running {description}...[/dim]")
 
         try:
+            # Build command with environment manager prefix if needed
+            command_full = build_tool_command(env_info, command)
             result = subprocess.run(
-                command,
+                command_full,
                 capture_output=True,
                 text=True,
                 timeout=30,  # 30 seconds per tool
@@ -1180,56 +1208,10 @@ def apply_enhanced_contracts(
         # Determine the source file we're testing (original or enhanced)
         source_file_rel = original_file_rel if original_file_rel else enhanced_file_rel
 
-        # Convert source file path to potential test file paths
-        # Pattern: src/specfact_cli/telemetry.py -> tests/unit/specfact_cli/test_telemetry.py
-        # or: src/common/logger.py -> tests/unit/common/test_logger.py
-        test_paths: list[Path] = []
-
-        # Remove 'src/' prefix if present
-        test_rel_path = str(source_file_rel)
-        if test_rel_path.startswith("src/"):
-            test_rel_path = test_rel_path[4:]  # Remove 'src/'
-        elif test_rel_path.startswith("tools/"):
-            test_rel_path = test_rel_path[6:]  # Remove 'tools/'
-
-        # Get directory and filename
-        test_file_dir = Path(test_rel_path).parent
-        test_file_name = Path(test_rel_path).stem  # e.g., "telemetry" from "telemetry.py"
-
-        # Try common test file patterns
-        test_file_patterns = [
-            f"test_{test_file_name}.py",
-            f"{test_file_name}_test.py",
-        ]
-
-        # Try common test directory structures
-        test_dirs = [
-            repo_path / "tests" / "unit" / test_file_dir,
-            repo_path / "tests" / test_file_dir,
-            repo_path / "tests" / "unit",
-            repo_path / "tests",
-        ]
-
-        # Build list of possible test file paths
-        for test_dir in test_dirs:
-            if test_dir.exists():
-                for pattern in test_file_patterns:
-                    test_path = test_dir / pattern
-                    if test_path.exists():
-                        test_paths.append(test_path)
-
-        # Also try E2E tests if unit tests not found
-        if not test_paths:
-            e2e_test_dirs = [
-                repo_path / "tests" / "e2e" / test_file_dir,
-                repo_path / "tests" / "e2e",
-            ]
-            for test_dir in e2e_test_dirs:
-                if test_dir.exists():
-                    for pattern in test_file_patterns:
-                        test_path = test_dir / pattern
-                        if test_path.exists():
-                            test_paths.append(test_path)
+        # Use utility function to find test files dynamically
+        test_paths = find_test_files_for_source(
+            repo_path, source_file_rel if source_file_rel.is_absolute() else repo_path / source_file_rel
+        )
 
         # If we found specific test files, run them
         if test_paths:
@@ -1238,8 +1220,13 @@ def apply_enhanced_contracts(
             console.print(f"[dim]Found test file: {test_path.relative_to(repo_path)}[/dim]")
             console.print("[dim]Running pytest on specific test file (fast, scoped validation)...[/dim]")
 
+            # Detect environment manager and build appropriate command
+            env_info = detect_env_manager(repo_path)
+            pytest_command = ["pytest", str(test_path), "-v", "--tb=short"]
+            pytest_command_full = build_tool_command(env_info, pytest_command)
+
             result = subprocess.run(
-                ["pytest", str(test_path), "-v", "--tb=short"],
+                pytest_command_full,
                 capture_output=True,
                 text=True,
                 timeout=60,  # 1 minute should be enough for a single test file
@@ -2030,10 +2017,21 @@ def generate_test_prompt(
                 console.print("\n[bold cyan]Files that may need tests:[/bold cyan]\n")
 
                 # Find Python files without corresponding test files
+                # Use dynamic source directory detection
+                source_dirs = detect_source_directories(repo_path)
                 src_files: list[Path] = []
-                for src_dir in [repo_path / "src", repo_path]:
-                    if src_dir.exists():
-                        src_files.extend(src_dir.rglob("*.py"))
+                # If no source dirs detected, check common patterns
+                if not source_dirs:
+                    for src_dir in [repo_path / "src", repo_path / "lib", repo_path]:
+                        if src_dir.exists():
+                            src_files.extend(src_dir.rglob("*.py"))
+                else:
+                    # Use detected source directories
+                    for src_dir_str in source_dirs:
+                        src_dir_clean = src_dir_str.rstrip("/")
+                        src_dir_path = repo_path / src_dir_clean
+                        if src_dir_path.exists():
+                            src_files.extend(src_dir_path.rglob("*.py"))
 
                 files_without_tests: list[tuple[Path, str]] = []
                 for src_file in src_files:
@@ -2042,12 +2040,9 @@ def generate_test_prompt(
                     if src_file.name.startswith("__"):
                         continue
 
-                    # Check for corresponding test file
-                    test_patterns = [
-                        repo_path / "tests" / "unit" / f"test_{src_file.stem}.py",
-                        repo_path / "tests" / f"test_{src_file.stem}.py",
-                    ]
-                    has_test = any(tp.exists() for tp in test_patterns)
+                    # Check for corresponding test file using dynamic detection
+                    test_files = find_test_files_for_source(repo_path, src_file)
+                    has_test = len(test_files) > 0
                     if not has_test:
                         rel_path = src_file.relative_to(repo_path) if src_file.is_relative_to(repo_path) else src_file
                         files_without_tests.append((src_file, str(rel_path)))

{specfact_cli-0.20.0 → specfact_cli-0.20.1}/src/specfact_cli/commands/init.py

@@ -18,6 +18,7 @@ from rich.console import Console
 from rich.panel import Panel
 
 from specfact_cli.telemetry import telemetry
+from specfact_cli.utils.env_manager import EnvManager, build_tool_command, detect_env_manager
 from specfact_cli.utils.ide_setup import (
     IDE_CONFIG,
     copy_templates_to_ide,
@@ -60,7 +61,7 @@ def init(
     install_deps: bool = typer.Option(
         False,
         "--install-deps",
-        help="Install required packages for contract enhancement (beartype, icontract, crosshair-tool, pytest) via pip",
+        help="Install required packages for contract enhancement (beartype, icontract, crosshair-tool, pytest) using detected environment manager",
     ),
     # Advanced/Configuration
     ide: str = typer.Option(
@@ -105,10 +106,41 @@ def init(
         console.print(f"[cyan]IDE:[/cyan] {ide_name} ({detected_ide})")
         console.print()
 
+        # Check for environment manager
+        env_info = detect_env_manager(repo_path)
+        if env_info.manager == EnvManager.UNKNOWN:
+            console.print()
+            console.print(
+                Panel(
+                    "[bold yellow]⚠ No Compatible Environment Manager Detected[/bold yellow]",
+                    border_style="yellow",
+                )
+            )
+            console.print(
+                "[yellow]SpecFact CLI works best with projects using standard Python project management tools.[/yellow]"
+            )
+            console.print()
+            console.print("[dim]Supported tools:[/dim]")
+            console.print("  - hatch (detected from [tool.hatch] in pyproject.toml)")
+            console.print("  - poetry (detected from [tool.poetry] in pyproject.toml or poetry.lock)")
+            console.print("  - uv (detected from [tool.uv] in pyproject.toml, uv.lock, or uv.toml)")
+            console.print("  - pip (detected from requirements.txt or setup.py)")
+            console.print()
+            console.print(
+                "[dim]Note: SpecFact CLI will still work, but commands like 'specfact repro' may use direct tool invocation.[/dim]"
+            )
+            console.print(
+                "[dim]Consider adding a pyproject.toml with [tool.hatch], [tool.poetry], or [tool.uv] for better integration.[/dim]"
+            )
+            console.print()
+
         # Install dependencies if requested
         if install_deps:
             console.print()
             console.print(Panel("[bold cyan]Installing Required Packages[/bold cyan]", border_style="cyan"))
+            if env_info.message:
+                console.print(f"[dim]{env_info.message}[/dim]")
+
             required_packages = [
                 "beartype>=0.22.4",
                 "icontract>=2.7.1",
@@ -119,19 +151,32 @@ def init(
             for package in required_packages:
                 console.print(f"  - {package}")
 
+            # Build install command using environment manager detection
+            install_cmd = ["pip", "install", "-U", *required_packages]
+            install_cmd = build_tool_command(env_info, install_cmd)
+
+            console.print(f"[dim]Using command: {' '.join(install_cmd)}[/dim]")
+
             try:
-                # Use pip to install packages
                 result = subprocess.run(
-                    [sys.executable, "-m", "pip", "install", "-U", *required_packages],
+                    install_cmd,
                     capture_output=True,
                     text=True,
                     check=False,
+                    cwd=str(repo_path),
+                    timeout=300,  # 5 minute timeout
                 )
 
                 if result.returncode == 0:
                     console.print()
                     console.print("[green]✓[/green] All required packages installed successfully")
-                    record({"deps_installed": True, "packages_count": len(required_packages)})
+                    record(
+                        {
+                            "deps_installed": True,
+                            "packages_count": len(required_packages),
+                            "env_manager": env_info.manager.value,
+                        }
+                    )
                 else:
                     console.print()
                     console.print("[yellow]⚠[/yellow] Some packages failed to install")
@@ -142,19 +187,60 @@ def init(
                         console.print(result.stderr)
                     console.print()
                     console.print("[yellow]You may need to install packages manually:[/yellow]")
+                    # Provide environment-specific guidance
+                    if env_info.manager == EnvManager.HATCH:
+                        console.print(f"  hatch run pip install {' '.join(required_packages)}")
+                    elif env_info.manager == EnvManager.POETRY:
+                        console.print(f"  poetry add --dev {' '.join(required_packages)}")
+                    elif env_info.manager == EnvManager.UV:
+                        console.print(f"  uv pip install {' '.join(required_packages)}")
+                    else:
+                        console.print(f"  pip install {' '.join(required_packages)}")
+                    record(
+                        {
+                            "deps_installed": False,
+                            "error": result.stderr[:200] if result.stderr else "Unknown error",
+                            "env_manager": env_info.manager.value,
+                        }
+                    )
+            except subprocess.TimeoutExpired:
+                console.print()
+                console.print("[red]Error:[/red] Installation timed out after 5 minutes")
+                console.print("[yellow]You may need to install packages manually:[/yellow]")
+                if env_info.manager == EnvManager.HATCH:
+                    console.print(f"  hatch run pip install {' '.join(required_packages)}")
+                elif env_info.manager == EnvManager.POETRY:
+                    console.print(f"  poetry add --dev {' '.join(required_packages)}")
+                elif env_info.manager == EnvManager.UV:
+                    console.print(f"  uv pip install {' '.join(required_packages)}")
+                else:
                     console.print(f"  pip install {' '.join(required_packages)}")
-                    record({"deps_installed": False, "error": result.stderr[:200]})
+                record({"deps_installed": False, "error": "timeout", "env_manager": env_info.manager.value})
             except FileNotFoundError:
                 console.print()
                 console.print("[red]Error:[/red] pip not found. Please install packages manually:")
-                console.print(f"  pip install {' '.join(required_packages)}")
-                record({"deps_installed": False, "error": "pip not found"})
+                if env_info.manager == EnvManager.HATCH:
+                    console.print(f"  hatch run pip install {' '.join(required_packages)}")
+                elif env_info.manager == EnvManager.POETRY:
+                    console.print(f"  poetry add --dev {' '.join(required_packages)}")
+                elif env_info.manager == EnvManager.UV:
+                    console.print(f"  uv pip install {' '.join(required_packages)}")
+                else:
+                    console.print(f"  pip install {' '.join(required_packages)}")
+                record({"deps_installed": False, "error": "pip not found", "env_manager": env_info.manager.value})
             except Exception as e:
                 console.print()
                 console.print(f"[red]Error:[/red] Failed to install packages: {e}")
                 console.print("[yellow]You may need to install packages manually:[/yellow]")
-                console.print(f"  pip install {' '.join(required_packages)}")
-                record({"deps_installed": False, "error": str(e)})
+                if env_info.manager == EnvManager.HATCH:
+                    console.print(f"  hatch run pip install {' '.join(required_packages)}")
+                elif env_info.manager == EnvManager.POETRY:
+                    console.print(f"  poetry add --dev {' '.join(required_packages)}")
+                elif env_info.manager == EnvManager.UV:
+                    console.print(f"  uv pip install {' '.join(required_packages)}")
+                else:
+                    console.print(f"  pip install {' '.join(required_packages)}")
+                record({"deps_installed": False, "error": str(e), "env_manager": env_info.manager.value})
             console.print()
 
         # Find templates directory