codebeacon 0.1.2__py3-none-any.whl

codebeacon/discover/detector.py

@@ -0,0 +1,388 @@
+"""Framework auto-detection and multi/single project determination."""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+from codebeacon.common.types import ProjectInfo
+
+
+# ── Signature files → (framework, language) ─────────────────────────────────
+
+SIGNATURE_MAP: list[tuple[str, str, str]] = [
+    # (filename_or_glob, framework, primary_language)
+    # Order matters: more specific first
+    ("angular.json",        "angular",       "typescript"),
+    ("nuxt.config.ts",      "nuxt",          "typescript"),
+    ("nuxt.config.js",      "nuxt",          "typescript"),
+    ("svelte.config.js",    "sveltekit",     "typescript"),
+    ("svelte.config.ts",    "sveltekit",     "typescript"),
+    ("build.gradle.kts",    "ktor",          "kotlin"),
+    ("build.gradle",        "spring-boot",   "java"),   # could be Ktor too, check below
+    ("pom.xml",             "spring-boot",   "java"),
+    ("Package.swift",       "vapor",         "swift"),
+    ("Cargo.toml",          "rust",          "rust"),    # actix/axum refined below
+    ("composer.json",       "laravel",       "php"),
+    ("Gemfile",             "rails",         "ruby"),
+    ("go.mod",              "go",            "go"),      # gin/echo/fiber refined below
+    ("package.json",        "node",          "typescript"),  # express/nest/next refined below
+    ("requirements.txt",    "python",        "python"),  # fastapi/django/flask refined below
+    ("pyproject.toml",      "python",        "python"),  # fastapi/django/flask refined below
+    ("setup.py",            "python",        "python"),
+    ("*.csproj",            "aspnet",        "csharp"),
+]
+
+# Refinement patterns: read content of specific files to narrow down framework
+_PACKAGE_JSON_REFINEMENTS: list[tuple[str, str]] = [
+    # (pattern_in_deps_or_scripts, framework)
+    # Order matters: more specific first
+    ("@nestjs/core",       "nestjs"),
+    ('"next"',             "nextjs"),   # "next": "..." — avoid matching "nextjs" etc.
+    ("nuxt",               "nuxt"),
+    ("@sveltejs/kit",      "sveltekit"),
+    ("@angular/core",      "angular"),
+    ("fastify",            "fastify"),
+    ("koa",                "koa"),
+    ("express",            "express"),
+    ('"react"',            "react"),    # plain React (CRA, Vite, etc.)
+    ('"react-dom"',        "react"),
+]
+
+_REQUIREMENTS_REFINEMENTS: list[tuple[str, str]] = [
+    ("fastapi",   "fastapi"),
+    ("django",    "django"),
+    ("flask",     "flask"),
+    ("tornado",   "tornado"),
+    ("aiohttp",   "aiohttp"),
+]
+
+_GO_MOD_REFINEMENTS: list[tuple[str, str]] = [
+    ("github.com/gofiber/fiber", "fiber"),
+    ("github.com/labstack/echo", "echo"),
+    ("github.com/gin-gonic/gin", "gin"),
+]
+
+_CARGO_REFINEMENTS: list[tuple[str, str]] = [
+    ("axum",   "axum"),
+    ("actix-web", "actix"),
+]
+
+_BUILD_GRADLE_KOTLIN_REFINEMENTS: list[tuple[str, str]] = [
+    ("ktor", "ktor"),
+    ("spring", "spring-boot"),
+]
+
+
+def _read_safe(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+
+def _refine_node_framework(project_dir: Path) -> str:
+    pkg = project_dir / "package.json"
+    content = _read_safe(pkg)
+    for pattern, fw in _PACKAGE_JSON_REFINEMENTS:
+        if pattern in content:
+            return fw
+    return "node"
+
+
+def _refine_python_framework(project_dir: Path) -> str:
+    for fname in ("requirements.txt", "pyproject.toml", "setup.py", "Pipfile"):
+        content = _read_safe(project_dir / fname)
+        if content:
+            lower = content.lower()
+            for pattern, fw in _REQUIREMENTS_REFINEMENTS:
+                if pattern in lower:
+                    return fw
+    return "python"
+
+
+def _refine_go_framework(project_dir: Path) -> str:
+    content = _read_safe(project_dir / "go.mod")
+    for pattern, fw in _GO_MOD_REFINEMENTS:
+        if pattern in content:
+            return fw
+    return "gin"  # most common Go web framework default
+
+
+def _refine_rust_framework(project_dir: Path) -> str:
+    content = _read_safe(project_dir / "Cargo.toml")
+    for pattern, fw in _CARGO_REFINEMENTS:
+        if pattern in content:
+            return fw
+    return "actix"
+
+
+def _refine_gradle_framework(project_dir: Path) -> tuple[str, str]:
+    content = _read_safe(project_dir / "build.gradle.kts")
+    if not content:
+        content = _read_safe(project_dir / "build.gradle")
+    lower = content.lower()
+    for pattern, fw in _BUILD_GRADLE_KOTLIN_REFINEMENTS:
+        if pattern in lower:
+            if fw == "ktor":
+                return ("ktor", "kotlin")
+            return ("spring-boot", "java")
+    return ("spring-boot", "java")
+
+
+def detect_framework(project_dir: str | Path) -> tuple[str, str, str]:
+    """Detect the framework, language and signature file for a project directory.
+
+    Returns (framework, language, signature_file).
+    Returns ("unknown", "unknown", "") if nothing detected.
+    """
+    project_dir = Path(project_dir)
+
+    # Check for *.csproj (glob-style)
+    csproj_files = list(project_dir.glob("*.csproj"))
+    if csproj_files:
+        return ("aspnet", "csharp", str(csproj_files[0]))
+
+    for sig, fw, lang in SIGNATURE_MAP:
+        if sig.startswith("*"):
+            # glob handled above
+            continue
+        sig_path = project_dir / sig
+        if sig_path.exists():
+            # Refine generic frameworks
+            if fw == "node":
+                fw = _refine_node_framework(project_dir)
+                return (fw, "typescript", str(sig_path))
+            if fw == "python":
+                fw = _refine_python_framework(project_dir)
+                return (fw, "python", str(sig_path))
+            if fw == "go":
+                fw = _refine_go_framework(project_dir)
+                return (fw, "go", str(sig_path))
+            if fw == "rust":
+                fw = _refine_rust_framework(project_dir)
+                return (fw, "rust", str(sig_path))
+            if sig in ("build.gradle.kts", "build.gradle"):
+                fw, lang = _refine_gradle_framework(project_dir)
+                return (fw, lang, str(sig_path))
+            return (fw, lang, str(sig_path))
+
+    # No signature file found — try to guess from code files
+    return ("unknown", "unknown", "")
+
+
+def _has_project_signature(directory: Path) -> bool:
+    """Return True if directory looks like a project root (has a build/config file)."""
+    signature_files = [
+        "pom.xml", "build.gradle", "build.gradle.kts",
+        "package.json", "requirements.txt", "pyproject.toml", "setup.py",
+        "go.mod", "Gemfile", "composer.json", "Cargo.toml",
+        "Package.swift", "angular.json",
+        "nuxt.config.ts", "nuxt.config.js",
+        "svelte.config.js", "svelte.config.ts",
+    ]
+    for sig in signature_files:
+        if (directory / sig).exists():
+            return True
+    # Check for *.csproj
+    if list(directory.glob("*.csproj")):
+        return True
+    return False
+
+
+def _detect_language_from_files(directory: Path) -> str:
+    """Detect dominant language by counting code files."""
+    counts: dict[str, int] = {}
+    ext_to_lang = {
+        ".java": "java", ".kt": "kotlin",
+        ".py": "python",
+        ".ts": "typescript", ".tsx": "typescript", ".js": "javascript", ".jsx": "javascript",
+        ".go": "go",
+        ".rb": "ruby",
+        ".php": "php",
+        ".cs": "csharp",
+        ".rs": "rust",
+        ".swift": "swift",
+    }
+    try:
+        for entry in directory.rglob("*"):
+            if entry.is_file() and entry.suffix in ext_to_lang:
+                lang = ext_to_lang[entry.suffix]
+                counts[lang] = counts.get(lang, 0) + 1
+    except (PermissionError, OSError):
+        pass
+
+    if not counts:
+        return "unknown"
+    return max(counts, key=lambda k: counts[k])
+
+
+def discover_projects(paths: list[str]) -> list[ProjectInfo]:
+    """Main entry point: given a list of input paths, return discovered projects.
+
+    Logic:
+    - 2+ paths → treat each as a separate project (multi mode)
+    - 1 path with signature → single project mode
+    - 1 path without signature → scan 1-depth subdirs for projects (multi mode)
+      - if subdirs have 2+ projects → multi mode
+      - if 0-1 projects but code files exist → generic single mode
+    """
+    if len(paths) > 1:
+        return _multi_from_paths(paths)
+
+    single_path = Path(paths[0]).resolve()
+
+    if not single_path.exists():
+        raise FileNotFoundError(f"Path does not exist: {single_path}")
+
+    if not single_path.is_dir():
+        raise ValueError(f"Path must be a directory: {single_path}")
+
+    if _has_project_signature(single_path):
+        return [_build_project_info(single_path, multi=False)]
+
+    # No signature: scan 1-depth subdirs
+    subdirs = [
+        d for d in sorted(single_path.iterdir())
+        if d.is_dir() and not d.name.startswith(".") and d.name not in {
+            "node_modules", "__pycache__", ".git", "dist", "build", "target",
+        }
+    ]
+
+    subprojects: list[ProjectInfo] = []
+    for subdir in subdirs:
+        if _has_project_signature(subdir):
+            subprojects.append(_build_project_info(subdir, multi=True))
+
+    if len(subprojects) >= 2:
+        return subprojects
+
+    if len(subprojects) == 1:
+        return subprojects
+
+    # No project signatures found anywhere: try generic mode
+    lang = _detect_language_from_files(single_path)
+    if lang == "unknown":
+        raise ValueError(
+            f"No projects found under {single_path}.\n"
+            "Make sure the path contains source code or a project file "
+            "(pom.xml, package.json, go.mod, etc.)"
+        )
+
+    return [ProjectInfo(
+        name=single_path.name,
+        path=str(single_path),
+        framework="generic",
+        language=lang,
+        signature_file="",
+        is_multi=False,
+    )]
+
+
+def _multi_from_paths(paths: list[str]) -> list[ProjectInfo]:
+    """Treat each path as an independent project."""
+    projects = []
+    for p in paths:
+        resolved = Path(p).resolve()
+        if not resolved.exists():
+            raise FileNotFoundError(f"Path does not exist: {resolved}")
+        projects.append(_build_project_info(resolved, multi=True))
+    return projects
+
+
+def _build_project_info(directory: Path, multi: bool) -> ProjectInfo:
+    framework, language, sig_file = detect_framework(directory)
+    if framework == "unknown":
+        lang = _detect_language_from_files(directory)
+        return ProjectInfo(
+            name=directory.name,
+            path=str(directory),
+            framework="generic",
+            language=lang or "unknown",
+            signature_file="",
+            is_multi=multi,
+        )
+    return ProjectInfo(
+        name=directory.name,
+        path=str(directory),
+        framework=framework,
+        language=language,
+        signature_file=sig_file,
+        is_multi=multi,
+    )
+
+
+def extract_convention_routes(project: ProjectInfo) -> list[str]:
+    """Extract file-system based routes for Next.js / Nuxt / SvelteKit.
+
+    Returns a list of route path strings. Actual RouteInfo objects are built in extract/routes.py.
+    This is a discovery-time stub that returns raw route strings.
+    """
+    root = Path(project.path)
+    routes: list[str] = []
+
+    if project.framework in ("nextjs", "next"):
+        # Pages Router: pages/**/*.{ts,tsx,js,jsx} → route
+        pages_dir = root / "pages"
+        if pages_dir.exists():
+            routes.extend(_fs_routes_from_dir(pages_dir, pages_dir))
+        # App Router: app/**/page.{ts,tsx,js,jsx} → route
+        app_dir = root / "app"
+        if app_dir.exists():
+            for f in app_dir.rglob("page.tsx"):
+                routes.append(_app_router_path(f, app_dir))
+            for f in app_dir.rglob("page.ts"):
+                routes.append(_app_router_path(f, app_dir))
+
+    elif project.framework == "nuxt":
+        pages_dir = root / "pages"
+        if pages_dir.exists():
+            routes.extend(_fs_routes_from_dir(pages_dir, pages_dir))
+
+    elif project.framework == "sveltekit":
+        routes_dir = root / "src" / "routes"
+        if routes_dir.exists():
+            for f in routes_dir.rglob("+page.svelte"):
+                route = "/" + str(f.parent.relative_to(routes_dir)).replace(os.sep, "/")
+                if route == "/.":
+                    route = "/"
+                routes.append(route)
+
+    return routes
+
+
+def _fs_routes_from_dir(file_dir: Path, base_dir: Path) -> list[str]:
+    """Convert Next.js / Nuxt pages directory files to route strings."""
+    routes = []
+    for f in file_dir.rglob("*"):
+        if f.is_file() and f.suffix in {".tsx", ".ts", ".jsx", ".js", ".vue"}:
+            rel = f.relative_to(base_dir)
+            parts = list(rel.parts)
+            # Remove extension from last part
+            last = parts[-1]
+            stem = last.rsplit(".", 1)[0]
+            # Skip _app, _document, _error in Next.js
+            if stem.startswith("_"):
+                continue
+            parts[-1] = stem
+            # index → ""
+            if parts[-1] == "index":
+                parts = parts[:-1]
+            route = "/" + "/".join(parts)
+            # Convert [param] → :param, [...slug] → *
+            route = re.sub(r"\[\.\.\.(\w+)\]", "*", route)
+            route = re.sub(r"\[(\w+)\]", r":\1", route)
+            routes.append(route)
+    return routes
+
+
+def _app_router_path(page_file: Path, app_dir: Path) -> str:
+    rel = page_file.parent.relative_to(app_dir)
+    parts = list(rel.parts)
+    route = "/" + "/".join(parts) if parts else "/"
+    route = re.sub(r"\(.*?\)/", "", route)   # route groups: (group)/
+    route = re.sub(r"\[\.\.\.(\w+)\]", "*", route)
+    route = re.sub(r"\[(\w+)\]", r":\1", route)
+    return route or "/"

codebeacon/discover/scanner.py

@@ -0,0 +1,192 @@
+"""Recursive file collector with ignore patterns and hash caching."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+from typing import Iterator
+
+IGNORE_DIRS: set[str] = {
+    "node_modules",
+    ".git",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "env",
+    ".env",
+    "dist",
+    "build",
+    "out",
+    ".output",
+    "coverage",
+    ".turbo",
+    ".vercel",
+    ".codebeacon",
+    ".codesight",
+    ".ai-codex",
+    "vendor",
+    ".cache",
+    ".parcel-cache",
+    ".gradle",
+    "target",           # Maven/Cargo build output
+    ".idea",
+    ".vscode",
+    "tmp",
+    "temp",
+    ".DS_Store",
+    "bin",
+    "obj",              # .NET build output
+    ".bundle",          # Ruby bundler
+    "public",           # usually static assets
+    ".terraform",
+}
+
+CODE_EXTENSIONS: set[str] = {
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+    ".py",
+    ".go",
+    ".vue", ".svelte",
+    ".rb",
+    ".java", ".kt",
+    ".rs",
+    ".php",
+    ".swift",
+    ".cs",
+    ".ex", ".exs",
+    ".dart",
+    ".scala",
+    ".clj",
+    ".hs",
+    ".graphql", ".gql",
+    ".proto",
+    ".sql",
+}
+
+
+def read_ignore_file(root: str | Path, filename: str = ".codebeaconignore") -> list[str]:
+    """Read .codebeaconignore at the project root and return ignore patterns."""
+    ignore_path = Path(root) / filename
+    try:
+        content = ignore_path.read_text(encoding="utf-8")
+        return [
+            line.strip()
+            for line in content.splitlines()
+            if line.strip() and not line.strip().startswith("#")
+        ]
+    except (FileNotFoundError, OSError):
+        return []
+
+
+def _should_ignore_dir(name: str, extra_ignore: set[str]) -> bool:
+    if name in IGNORE_DIRS:
+        return True
+    if name in extra_ignore:
+        return True
+    if name.startswith("."):
+        # Hidden dirs — skip most except known config dirs
+        return True
+    return False
+
+
+def collect_files(
+    root: str | Path,
+    max_depth: int = 15,
+    extra_ignore: list[str] | None = None,
+) -> list[str]:
+    """Recursively collect code files under root.
+
+    Returns absolute paths sorted by directory then filename.
+    """
+    root = Path(root).resolve()
+    ignore_patterns = read_ignore_file(root)
+    if extra_ignore:
+        ignore_patterns.extend(extra_ignore)
+
+    extra_ignore_set: set[str] = set()
+    for p in ignore_patterns:
+        # Simple patterns: strip leading / and trailing /* or /**
+        clean = p.lstrip("/").rstrip("/").rstrip("*").rstrip("/")
+        if clean:
+            extra_ignore_set.add(clean)
+
+    result: list[str] = []
+    _walk(root, root, 0, max_depth, extra_ignore_set, result)
+    return sorted(result)
+
+
+def _walk(
+    base: Path,
+    current: Path,
+    depth: int,
+    max_depth: int,
+    extra_ignore: set[str],
+    result: list[str],
+) -> None:
+    if depth > max_depth:
+        return
+    try:
+        entries = sorted(current.iterdir(), key=lambda e: (e.is_file(), e.name))
+    except PermissionError:
+        return
+
+    for entry in entries:
+        if entry.is_symlink():
+            continue
+        if entry.is_dir():
+            if not _should_ignore_dir(entry.name, extra_ignore):
+                _walk(base, entry, depth + 1, max_depth, extra_ignore, result)
+        elif entry.is_file():
+            if entry.suffix in CODE_EXTENSIONS:
+                result.append(str(entry))
+
+
+def hash_file(path: str | Path) -> str:
+    """Return SHA-256 hex digest (first 12 chars) of file content."""
+    try:
+        content = Path(path).read_bytes()
+        return hashlib.sha256(content).hexdigest()[:12]
+    except OSError:
+        return ""
+
+
+def load_hash_cache(cache_dir: str | Path) -> dict:
+    """Load the file hash cache from cache_dir/cache.json."""
+    cache_path = Path(cache_dir) / "cache.json"
+    try:
+        return json.loads(cache_path.read_text())
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return {"version": 1, "hashes": {}}
+
+
+def save_hash_cache(cache_dir: str | Path, cache: dict) -> None:
+    """Persist the hash cache; non-fatal if it fails."""
+    try:
+        cache_path = Path(cache_dir) / "cache.json"
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        cache_path.write_text(json.dumps(cache, indent=2))
+    except OSError:
+        pass
+
+
+def get_changed_files(files: list[str], cache: dict) -> tuple[list[str], dict]:
+    """Return files whose hash differs from cache, and the updated hash map."""
+    hashes = cache.get("hashes", {})
+    changed: list[str] = []
+    new_hashes: dict[str, str] = dict(hashes)
+
+    for f in files:
+        h = hash_file(f)
+        if hashes.get(f) != h:
+            changed.append(f)
+            new_hashes[f] = h
+
+    # Remove entries for files that no longer exist
+    existing = set(files)
+    new_hashes = {k: v for k, v in new_hashes.items() if k in existing}
+
+    return changed, {"version": 1, "hashes": new_hashes}