lucidscan 0.5.12__py3-none-any.whl

lucidscan/detection/languages.py

@@ -0,0 +1,328 @@
+"""Language detection module.
+
+Detects programming languages in a project by analyzing:
+- File extensions
+- Marker files (package.json, pyproject.toml, go.mod, etc.)
+- Configuration files
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+# Directories to skip during detection
+SKIP_DIRS = {
+    ".git",
+    ".svn",
+    ".hg",
+    "node_modules",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".env",
+    "env",
+    ".tox",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    "dist",
+    "build",
+    "target",
+    "vendor",
+    ".next",
+    ".nuxt",
+    "coverage",
+    ".coverage",
+    "htmlcov",
+}
+
+# File extension to language mapping
+EXTENSION_MAP = {
+    ".py": "python",
+    ".pyw": "python",
+    ".pyi": "python",
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".scala": "scala",
+    ".rb": "ruby",
+    ".php": "php",
+    ".cs": "csharp",
+    ".swift": "swift",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+}
+
+# Marker files that indicate a language
+MARKER_FILES = {
+    "python": ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile"],
+    "javascript": ["package.json"],
+    "typescript": ["tsconfig.json"],
+    "go": ["go.mod"],
+    "rust": ["Cargo.toml"],
+    "java": ["pom.xml", "build.gradle", "build.gradle.kts"],
+    "ruby": ["Gemfile"],
+    "php": ["composer.json"],
+}
+
+
+@dataclass
+class LanguageInfo:
+    """Information about a detected language."""
+
+    name: str
+    """Language name (lowercase)."""
+
+    version: Optional[str] = None
+    """Detected version (if available)."""
+
+    file_count: int = 0
+    """Number of files with this language."""
+
+
+def detect_languages(project_root: Path) -> list[LanguageInfo]:
+    """Detect programming languages in a project.
+
+    Args:
+        project_root: Path to the project root directory.
+
+    Returns:
+        List of detected languages with metadata.
+    """
+    # Count files by extension
+    extension_counts: dict[str, int] = {}
+
+    for file_path in _walk_files(project_root):
+        ext = file_path.suffix.lower()
+        if ext in EXTENSION_MAP:
+            lang = EXTENSION_MAP[ext]
+            extension_counts[lang] = extension_counts.get(lang, 0) + 1
+
+    # Check for marker files
+    marker_languages = set()
+    for lang, markers in MARKER_FILES.items():
+        for marker in markers:
+            if (project_root / marker).exists():
+                marker_languages.add(lang)
+                break
+
+    # Combine results
+    all_languages = set(extension_counts.keys()) | marker_languages
+
+    # Build LanguageInfo objects
+    results = []
+    for lang in all_languages:
+        info = LanguageInfo(
+            name=lang,
+            file_count=extension_counts.get(lang, 0),
+            version=_detect_version(lang, project_root),
+        )
+        results.append(info)
+
+    # Sort by file count (descending)
+    results.sort(key=lambda x: x.file_count, reverse=True)
+
+    return results
+
+
+def _walk_files(root: Path, max_depth: int = 10) -> list[Path]:
+    """Walk directory tree yielding files.
+
+    Args:
+        root: Root directory to walk.
+        max_depth: Maximum recursion depth.
+
+    Returns:
+        List of file paths.
+    """
+    files = []
+
+    def _walk(path: Path, depth: int) -> None:
+        if depth > max_depth:
+            return
+
+        try:
+            for item in path.iterdir():
+                if item.is_dir():
+                    if item.name not in SKIP_DIRS and not item.name.startswith("."):
+                        _walk(item, depth + 1)
+                elif item.is_file():
+                    files.append(item)
+        except PermissionError:
+            pass
+
+    _walk(root, 0)
+    return files
+
+
+def _detect_version(language: str, project_root: Path) -> Optional[str]:
+    """Detect the version of a language from config files.
+
+    Args:
+        language: Language name.
+        project_root: Project root directory.
+
+    Returns:
+        Version string or None.
+    """
+    if language == "python":
+        return _detect_python_version(project_root)
+    elif language == "typescript":
+        return _detect_typescript_version(project_root)
+    elif language == "go":
+        return _detect_go_version(project_root)
+    elif language == "rust":
+        return _detect_rust_version(project_root)
+    elif language == "java":
+        return _detect_java_version(project_root)
+    return None
+
+
+def _detect_python_version(project_root: Path) -> Optional[str]:
+    """Detect Python version from pyproject.toml or other files."""
+    pyproject = project_root / "pyproject.toml"
+    if pyproject.exists():
+        try:
+            content = pyproject.read_text()
+            # Look for requires-python
+            match = re.search(r'requires-python\s*=\s*["\']([^"\']+)["\']', content)
+            if match:
+                version_spec = match.group(1)
+                # Extract version number (e.g., ">=3.10" -> "3.10")
+                version_match = re.search(r"(\d+\.\d+)", version_spec)
+                if version_match:
+                    return version_match.group(1)
+        except Exception:
+            pass
+
+    # Check .python-version file
+    python_version_file = project_root / ".python-version"
+    if python_version_file.exists():
+        try:
+            version = python_version_file.read_text().strip()
+            return version.split(".")[0] + "." + version.split(".")[1] if "." in version else version
+        except Exception:
+            pass
+
+    return None
+
+
+def _detect_typescript_version(project_root: Path) -> Optional[str]:
+    """Detect TypeScript version from package.json."""
+    package_json = project_root / "package.json"
+    if package_json.exists():
+        try:
+            import json
+            data = json.loads(package_json.read_text())
+            deps = {**data.get("dependencies", {}), **data.get("devDependencies", {})}
+            if "typescript" in deps:
+                version = deps["typescript"]
+                # Strip version prefix (^, ~, etc.)
+                return re.sub(r"^[\^~>=<]+", "", version)
+        except Exception:
+            pass
+    return None
+
+
+def _detect_go_version(project_root: Path) -> Optional[str]:
+    """Detect Go version from go.mod."""
+    go_mod = project_root / "go.mod"
+    if go_mod.exists():
+        try:
+            content = go_mod.read_text()
+            match = re.search(r"^go\s+(\d+\.\d+)", content, re.MULTILINE)
+            if match:
+                return match.group(1)
+        except Exception:
+            pass
+    return None
+
+
+def _detect_rust_version(project_root: Path) -> Optional[str]:
+    """Detect Rust edition from Cargo.toml."""
+    cargo_toml = project_root / "Cargo.toml"
+    if cargo_toml.exists():
+        try:
+            content = cargo_toml.read_text()
+            match = re.search(r'edition\s*=\s*["\'](\d+)["\']', content)
+            if match:
+                return match.group(1)
+        except Exception:
+            pass
+    return None
+
+
+def _detect_java_version(project_root: Path) -> Optional[str]:
+    """Detect Java version from pom.xml or build.gradle."""
+    # Check pom.xml (Maven)
+    pom_xml = project_root / "pom.xml"
+    if pom_xml.exists():
+        try:
+            content = pom_xml.read_text()
+            # Look for maven.compiler.source or java.version property
+            match = re.search(
+                r"<(?:maven\.compiler\.source|java\.version)>(\d+)</",
+                content,
+            )
+            if match:
+                return match.group(1)
+            # Look for release property
+            match = re.search(r"<release>(\d+)</release>", content)
+            if match:
+                return match.group(1)
+        except Exception:
+            pass
+
+    # Check build.gradle (Gradle)
+    for gradle_file in ["build.gradle", "build.gradle.kts"]:
+        gradle_path = project_root / gradle_file
+        if gradle_path.exists():
+            try:
+                content = gradle_path.read_text()
+                # Look for sourceCompatibility or targetCompatibility
+                match = re.search(
+                    r"(?:source|target)Compatibility\s*=\s*['\"]?(?:JavaVersion\.VERSION_)?(\d+)",
+                    content,
+                )
+                if match:
+                    return match.group(1)
+                # Look for toolchain languageVersion
+                match = re.search(
+                    r"languageVersion\.set\s*\(\s*JavaLanguageVersion\.of\s*\(\s*(\d+)\s*\)",
+                    content,
+                )
+                if match:
+                    return match.group(1)
+            except Exception:
+                pass
+
+    # Check .java-version file
+    java_version_file = project_root / ".java-version"
+    if java_version_file.exists():
+        try:
+            version = java_version_file.read_text().strip()
+            # Extract major version (e.g., "17.0.2" -> "17")
+            match = re.match(r"(\d+)", version)
+            if match:
+                return match.group(1)
+        except Exception:
+            pass
+
+    return None

lucidscan/detection/tools.py

@@ -0,0 +1,229 @@
+"""Tool configuration detection module.
+
+Detects existing tool configurations for:
+- Linters (Ruff, ESLint, Biome, etc.)
+- Type checkers (mypy, TypeScript, Pyright, etc.)
+- Formatters (Black, Prettier, etc.)
+- Security scanners (Trivy, etc.)
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ToolConfig:
+    """Detected tool configuration."""
+
+    tool: str
+    """Tool name (e.g., 'ruff', 'eslint')."""
+
+    config_file: Optional[Path] = None
+    """Path to the configuration file."""
+
+    config_location: Optional[str] = None
+    """Location type: 'file', 'pyproject.toml', 'package.json'."""
+
+
+# Tool detection definitions
+# Format: tool_name -> (config_files, pyproject_section, package_json_key)
+TOOL_CONFIGS: Dict[str, Dict[str, Any]] = {
+    # Python linters
+    "ruff": {
+        "files": ["ruff.toml", ".ruff.toml"],
+        "pyproject_section": "tool.ruff",
+    },
+    "flake8": {
+        "files": [".flake8", "setup.cfg", "tox.ini"],
+        "pyproject_section": None,  # flake8 doesn't use pyproject.toml natively
+    },
+    "pylint": {
+        "files": [".pylintrc", "pylintrc"],
+        "pyproject_section": "tool.pylint",
+    },
+    "black": {
+        "files": [".black.toml"],
+        "pyproject_section": "tool.black",
+    },
+    "isort": {
+        "files": [".isort.cfg"],
+        "pyproject_section": "tool.isort",
+    },
+
+    # Python type checkers
+    "mypy": {
+        "files": ["mypy.ini", ".mypy.ini"],
+        "pyproject_section": "tool.mypy",
+    },
+    "pyright": {
+        "files": ["pyrightconfig.json"],
+        "pyproject_section": "tool.pyright",
+    },
+
+    # Python test tools
+    "pytest": {
+        "files": ["pytest.ini", "setup.cfg"],
+        "pyproject_section": "tool.pytest",
+    },
+    "coverage": {
+        "files": [".coveragerc"],
+        "pyproject_section": "tool.coverage",
+    },
+
+    # JavaScript/TypeScript linters
+    "eslint": {
+        "files": [
+            ".eslintrc", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.mjs",
+            ".eslintrc.json", ".eslintrc.yaml", ".eslintrc.yml",
+            "eslint.config.js", "eslint.config.mjs", "eslint.config.cjs",
+        ],
+        "package_json_key": "eslintConfig",
+    },
+    "biome": {
+        "files": ["biome.json", "biome.jsonc"],
+    },
+    "prettier": {
+        "files": [
+            ".prettierrc", ".prettierrc.json", ".prettierrc.yaml",
+            ".prettierrc.yml", ".prettierrc.js", ".prettierrc.cjs",
+            "prettier.config.js", "prettier.config.cjs",
+        ],
+        "package_json_key": "prettier",
+    },
+
+    # TypeScript
+    "typescript": {
+        "files": ["tsconfig.json"],
+    },
+
+    # Security scanners
+    "trivy": {
+        "files": [".trivy.yaml", "trivy.yaml"],
+    },
+    "semgrep": {
+        "files": [".semgrep.yaml", ".semgrep.yml", "semgrep.yaml"],
+    },
+    "checkov": {
+        "files": [".checkov.yaml", ".checkov.yml"],
+    },
+
+    # JavaScript/TypeScript test runners
+    "jest": {
+        "files": ["jest.config.js", "jest.config.ts", "jest.config.mjs", "jest.config.cjs"],
+        "package_json_key": "jest",
+    },
+    "karma": {
+        "files": ["karma.conf.js", "karma.conf.ts", "karma.config.js", "karma.config.ts"],
+    },
+    "playwright": {
+        "files": ["playwright.config.js", "playwright.config.ts", "playwright.config.mjs"],
+    },
+
+    # Other
+    "pre-commit": {
+        "files": [".pre-commit-config.yaml"],
+    },
+}
+
+
+def detect_tools(project_root: Path) -> dict[str, ToolConfig]:
+    """Detect existing tool configurations in a project.
+
+    Args:
+        project_root: Path to the project root directory.
+
+    Returns:
+        Dictionary mapping tool names to their configurations.
+    """
+    detected = {}
+
+    # Load pyproject.toml if it exists
+    pyproject_content = None
+    pyproject_path = project_root / "pyproject.toml"
+    if pyproject_path.exists():
+        try:
+            pyproject_content = pyproject_path.read_text()
+        except Exception:
+            pass
+
+    # Load package.json if it exists
+    package_json_content = None
+    package_json_path = project_root / "package.json"
+    if package_json_path.exists():
+        try:
+            import json
+            package_json_content = json.loads(package_json_path.read_text())
+        except Exception:
+            pass
+
+    # Check each tool
+    for tool_name, config in TOOL_CONFIGS.items():
+        result = _check_tool(
+            tool_name,
+            config,
+            project_root,
+            pyproject_content,
+            package_json_content,
+        )
+        if result:
+            detected[tool_name] = result
+
+    return detected
+
+
+def _check_tool(
+    tool_name: str,
+    config: dict,
+    project_root: Path,
+    pyproject_content: Optional[str],
+    package_json_content: Optional[dict],
+) -> Optional[ToolConfig]:
+    """Check if a specific tool is configured.
+
+    Args:
+        tool_name: Name of the tool.
+        config: Tool configuration definition.
+        project_root: Project root directory.
+        pyproject_content: Content of pyproject.toml (if exists).
+        package_json_content: Parsed package.json (if exists).
+
+    Returns:
+        ToolConfig if found, None otherwise.
+    """
+    # Check for standalone config files
+    for config_file in config.get("files", []):
+        file_path = project_root / config_file
+        if file_path.exists():
+            return ToolConfig(
+                tool=tool_name,
+                config_file=file_path,
+                config_location="file",
+            )
+
+    # Check pyproject.toml section
+    pyproject_section = config.get("pyproject_section")
+    if pyproject_section and pyproject_content:
+        # Convert section to regex pattern (e.g., "tool.ruff" -> [tool.ruff])
+        section_pattern = pyproject_section.replace(".", r"\.")
+        if re.search(rf"\[{section_pattern}(\.[^\]]+)?\]", pyproject_content):
+            return ToolConfig(
+                tool=tool_name,
+                config_file=project_root / "pyproject.toml",
+                config_location="pyproject.toml",
+            )
+
+    # Check package.json key
+    package_key = config.get("package_json_key")
+    if package_key and package_json_content:
+        if package_key in package_json_content:
+            return ToolConfig(
+                tool=tool_name,
+                config_file=project_root / "package.json",
+                config_location="package.json",
+            )
+
+    return None

lucidscan/generation/__init__.py

@@ -0,0 +1,15 @@
+"""Configuration generation module.
+
+This module provides generators for:
+- lucidscan.yml configuration files
+- Package manager tool installation
+"""
+
+from lucidscan.generation.config_generator import ConfigGenerator, InitChoices
+from lucidscan.generation.package_installer import PackageInstaller
+
+__all__ = [
+    "ConfigGenerator",
+    "InitChoices",
+    "PackageInstaller",
+]