forge-dev 0.1.0__py3-none-any.whl

forge_core/detector.py

@@ -0,0 +1,209 @@
+"""Project Detector — understands the state of the current directory.
+
+Detects whether we're in:
+- An empty directory (greenfield)
+- A directory with docs but no code
+- A directory with existing code
+- A directory already initialized with Forge
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from forge_core.models import ProjectState
+
+
+# File patterns that indicate different project states
+CODE_EXTENSIONS = {
+    ".py", ".js", ".ts", ".jsx", ".tsx", ".cs", ".vb", ".java",
+    ".go", ".rs", ".rb", ".php", ".swift", ".kt",
+}
+
+DOC_EXTENSIONS = {
+    ".md", ".txt", ".pdf", ".docx", ".doc", ".rtf",
+}
+
+CONFIG_FILES = {
+    "package.json", "pyproject.toml", "requirements.txt", "Cargo.toml",
+    "go.mod", "pom.xml", "build.gradle", "Gemfile", "composer.json",
+    "Makefile", "Dockerfile", "docker-compose.yml", "docker-compose.yaml",
+}
+
+IGNORE_DIRS = {
+    ".git", ".forge", "node_modules", "__pycache__", ".venv", "venv",
+    ".tox", ".mypy_cache", ".pytest_cache", "dist", "build", ".next",
+}
+
+
+class ProjectDetection:
+    """Result of detecting project state."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path.resolve()
+        self.state: ProjectState = ProjectState.EMPTY
+        self.has_forge: bool = False
+        self.has_git: bool = False
+        self.code_files: list[Path] = []
+        self.doc_files: list[Path] = []
+        self.config_files: list[Path] = []
+        self.detected_stack: dict[str, str] = {}
+        self.forge_context_path: Path | None = None
+
+    @property
+    def is_empty(self) -> bool:
+        return self.state == ProjectState.EMPTY
+
+    @property
+    def is_greenfield(self) -> bool:
+        return self.state in (ProjectState.EMPTY, ProjectState.HAS_DOCS)
+
+    @property
+    def has_existing_code(self) -> bool:
+        return self.state == ProjectState.HAS_CODE
+
+    def summary(self) -> str:
+        """Human-readable summary of detection."""
+        lines = [f"Project path: {self.path}"]
+        lines.append(f"State: {self.state.value}")
+
+        if self.has_forge:
+            lines.append("Forge: Already initialized")
+        if self.has_git:
+            lines.append("Git: Yes")
+        if self.code_files:
+            lines.append(f"Code files: {len(self.code_files)}")
+        if self.doc_files:
+            lines.append(f"Documents: {len(self.doc_files)}")
+        if self.config_files:
+            lines.append(f"Config files: {[f.name for f in self.config_files]}")
+        if self.detected_stack:
+            lines.append(f"Detected stack: {self.detected_stack}")
+
+        return "\n".join(lines)
+
+
+def detect_project(path: Path | None = None) -> ProjectDetection:
+    """Detect the state of a project directory.
+    
+    Args:
+        path: Directory to analyze. Defaults to current directory.
+        
+    Returns:
+        ProjectDetection with all findings.
+    """
+    if path is None:
+        path = Path.cwd()
+    path = path.resolve()
+
+    detection = ProjectDetection(path)
+
+    # Check for .forge/
+    forge_dir = path / ".forge"
+    if forge_dir.exists() and (forge_dir / "context.yaml").exists():
+        detection.has_forge = True
+        detection.forge_context_path = forge_dir / "context.yaml"
+        detection.state = ProjectState.HAS_FORGE
+
+    # Check for .git/
+    detection.has_git = (path / ".git").exists()
+
+    # Scan files (max 2 levels deep for speed)
+    _scan_directory(path, detection, max_depth=3, current_depth=0)
+
+    # Determine state if not already set by .forge
+    if not detection.has_forge:
+        if detection.code_files or detection.config_files:
+            detection.state = ProjectState.HAS_CODE
+        elif detection.doc_files:
+            detection.state = ProjectState.HAS_DOCS
+        else:
+            detection.state = ProjectState.EMPTY
+
+    # Detect stack from config files
+    detection.detected_stack = _detect_stack(path, detection.config_files)
+
+    return detection
+
+
+def _scan_directory(
+    path: Path, detection: ProjectDetection, max_depth: int, current_depth: int
+) -> None:
+    """Recursively scan directory for relevant files."""
+    if current_depth >= max_depth:
+        return
+
+    try:
+        entries = sorted(path.iterdir())
+    except PermissionError:
+        return
+
+    for entry in entries:
+        if entry.name.startswith(".") and entry.name not in (".env.example",):
+            continue
+        if entry.name in IGNORE_DIRS:
+            continue
+
+        if entry.is_file():
+            suffix = entry.suffix.lower()
+            if suffix in CODE_EXTENSIONS:
+                detection.code_files.append(entry)
+            elif suffix in DOC_EXTENSIONS:
+                detection.doc_files.append(entry)
+            if entry.name in CONFIG_FILES:
+                detection.config_files.append(entry)
+        elif entry.is_dir():
+            _scan_directory(entry, detection, max_depth, current_depth + 1)
+
+
+def _detect_stack(path: Path, config_files: list[Path]) -> dict[str, str]:
+    """Detect the technology stack from config files."""
+    stack: dict[str, str] = {}
+    config_names = {f.name for f in config_files}
+
+    # Backend detection
+    if "pyproject.toml" in config_names or "requirements.txt" in config_names:
+        stack["language"] = "python"
+        # Try to detect framework
+        for cfg in config_files:
+            if cfg.name in ("pyproject.toml", "requirements.txt"):
+                try:
+                    content = cfg.read_text(errors="ignore").lower()
+                    if "fastapi" in content:
+                        stack["backend"] = "python/fastapi"
+                    elif "django" in content:
+                        stack["backend"] = "python/django"
+                    elif "flask" in content:
+                        stack["backend"] = "python/flask"
+                except Exception:
+                    pass
+
+    if "package.json" in config_names:
+        stack.setdefault("language", "node")
+        for cfg in config_files:
+            if cfg.name == "package.json":
+                try:
+                    content = cfg.read_text(errors="ignore").lower()
+                    if "express" in content:
+                        stack["backend"] = "node/express"
+                    elif "fastify" in content:
+                        stack["backend"] = "node/fastify"
+                    elif "nestjs" in content or "@nestjs" in content:
+                        stack["backend"] = "node/nestjs"
+                    # Frontend detection
+                    if '"react"' in content or '"react-dom"' in content:
+                        stack["frontend"] = "react"
+                    elif '"next"' in content:
+                        stack["frontend"] = "nextjs"
+                    elif '"vue"' in content:
+                        stack["frontend"] = "vue"
+                    elif '"svelte"' in content:
+                        stack["frontend"] = "svelte"
+                except Exception:
+                    pass
+
+    # Docker detection
+    if "Dockerfile" in config_names or "docker-compose.yml" in config_names:
+        stack["containerized"] = "true"
+
+    return stack