lucidscan 0.5.12__py3-none-any.whl

lucidscan/generation/config_generator.py

@@ -0,0 +1,275 @@
+"""Configuration file generator.
+
+Generates lucidscan.yml configuration files based on detected project
+characteristics and user choices.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from lucidscan.detection import ProjectContext
+
+
+@dataclass
+class InitChoices:
+    """User choices made during initialization."""
+
+    # Linting
+    linter: Optional[str] = None  # "ruff", "eslint", "biome", or None
+    linter_config: Optional[str] = None  # Path to existing config or None
+
+    # Type checking
+    type_checker: Optional[str] = None  # "mypy", "pyright", "typescript", or None
+    type_checker_strict: bool = False
+
+    # Security
+    security_enabled: bool = True
+    security_tools: list[str] = field(default_factory=lambda: ["trivy", "opengrep"])
+
+    # Testing
+    test_runner: Optional[str] = None  # "pytest", "jest", or None
+    coverage_enabled: bool = False
+    coverage_threshold: int = 80
+
+    # Fail thresholds
+    fail_on_linting: str = "error"  # "error", "warning", "none"
+    fail_on_security: str = "high"  # "critical", "high", "medium", "low", "none"
+
+
+class ConfigGenerator:
+    """Generates lucidscan.yml configuration files."""
+
+    def generate(
+        self,
+        context: ProjectContext,
+        choices: InitChoices,
+    ) -> str:
+        """Generate lucidscan.yml content.
+
+        Args:
+            context: Detected project context.
+            choices: User initialization choices.
+
+        Returns:
+            YAML string for lucidscan.yml.
+        """
+        config = self._build_config(context, choices)
+        return self._to_yaml(config)
+
+    def write(
+        self,
+        context: ProjectContext,
+        choices: InitChoices,
+        output_path: Optional[Path] = None,
+    ) -> Path:
+        """Generate and write lucidscan.yml file.
+
+        Args:
+            context: Detected project context.
+            choices: User initialization choices.
+            output_path: Output file path (default: project_root/lucidscan.yml).
+
+        Returns:
+            Path to the written file.
+        """
+        if output_path is None:
+            output_path = context.root / "lucidscan.yml"
+
+        content = self.generate(context, choices)
+        output_path.write_text(content)
+        return output_path
+
+    def _build_config(
+        self,
+        context: ProjectContext,
+        choices: InitChoices,
+    ) -> dict:
+        """Build configuration dictionary.
+
+        Args:
+            context: Detected project context.
+            choices: User initialization choices.
+
+        Returns:
+            Configuration dictionary.
+        """
+        config = {
+            "version": 1,
+            "project": self._build_project_section(context),
+        }
+
+        # Add pipeline section
+        pipeline = {}
+
+        # Linting
+        if choices.linter:
+            pipeline["linting"] = self._build_linting_section(choices)
+
+        # Type checking
+        if choices.type_checker:
+            pipeline["type_checking"] = self._build_type_checking_section(choices)
+
+        # Security
+        if choices.security_enabled and choices.security_tools:
+            pipeline["security"] = self._build_security_section(choices)
+
+        # Testing
+        if choices.test_runner:
+            pipeline["testing"] = self._build_testing_section(choices)
+
+        # Coverage
+        if choices.coverage_enabled:
+            pipeline["coverage"] = self._build_coverage_section(choices)
+
+        if pipeline:
+            config["pipeline"] = pipeline
+
+        # Fail thresholds
+        config["fail_on"] = self._build_fail_on_section(choices)
+
+        # Ignore patterns
+        config["ignore"] = self._build_ignore_patterns(context)
+
+        return config
+
+    def _build_project_section(self, context: ProjectContext) -> dict:
+        """Build project section."""
+        languages = [lang.name for lang in context.languages]
+        return {
+            "name": context.root.name,
+            "languages": languages,
+        }
+
+    def _build_linting_section(self, choices: InitChoices) -> dict:
+        """Build linting pipeline section."""
+        tools: list[dict] = []
+        section = {
+            "enabled": True,
+            "tools": tools,
+        }
+
+        tool: dict = {"name": choices.linter}
+        if choices.linter_config:
+            tool["config"] = choices.linter_config
+
+        tools.append(tool)
+        return section
+
+    def _build_type_checking_section(self, choices: InitChoices) -> dict:
+        """Build type checking pipeline section."""
+        tools: list[dict] = []
+        section = {
+            "enabled": True,
+            "tools": tools,
+        }
+
+        tool: dict = {"name": choices.type_checker}
+        if choices.type_checker_strict:
+            tool["strict"] = True
+
+        tools.append(tool)
+        return section
+
+    def _build_security_section(self, choices: InitChoices) -> dict:
+        """Build security pipeline section."""
+        tools: list[dict] = []
+        section = {
+            "enabled": True,
+            "tools": tools,
+        }
+
+        for tool_name in choices.security_tools:
+            tool: dict = {"name": tool_name}
+
+            # Add domains based on tool
+            if tool_name == "trivy":
+                tool["domains"] = ["sca"]
+            elif tool_name == "opengrep":
+                tool["domains"] = ["sast"]
+            elif tool_name == "checkov":
+                tool["domains"] = ["iac"]
+
+            tools.append(tool)
+
+        return section
+
+    def _build_testing_section(self, choices: InitChoices) -> dict:
+        """Build testing pipeline section."""
+        section = {
+            "enabled": True,
+            "tools": [{"name": choices.test_runner}],
+        }
+        return section
+
+    def _build_coverage_section(self, choices: InitChoices) -> dict:
+        """Build coverage pipeline section."""
+        return {
+            "enabled": True,
+            "threshold": choices.coverage_threshold,
+        }
+
+    def _build_fail_on_section(self, choices: InitChoices) -> dict:
+        """Build fail_on thresholds section."""
+        return {
+            "linting": choices.fail_on_linting,
+            "type_checking": "error",
+            "security": choices.fail_on_security,
+            "testing": "any",
+            "coverage": "below_threshold" if choices.coverage_enabled else "none",
+        }
+
+    def _build_ignore_patterns(self, context: ProjectContext) -> list:
+        """Build ignore patterns list."""
+        patterns = [
+            "**/__pycache__/**",
+            "**/node_modules/**",
+            "**/.venv/**",
+            "**/venv/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/.git/**",
+        ]
+
+        # Add language-specific patterns
+        if context.has_python:
+            patterns.extend([
+                "**/*.egg-info/**",
+                "**/.pytest_cache/**",
+                "**/.mypy_cache/**",
+                "**/.ruff_cache/**",
+            ])
+
+        if context.has_javascript:
+            patterns.extend([
+                "**/coverage/**",
+                "**/.next/**",
+                "**/.nuxt/**",
+            ])
+
+        return patterns
+
+    def _to_yaml(self, config: dict) -> str:
+        """Convert config dict to YAML string.
+
+        Args:
+            config: Configuration dictionary.
+
+        Returns:
+            YAML string.
+        """
+        # Add header comment
+        header = "# LucidScan Configuration\n# Generated by lucidscan init\n\n"
+
+        yaml_content = yaml.dump(
+            config,
+            default_flow_style=False,
+            sort_keys=False,
+            allow_unicode=True,
+        )
+
+        return header + yaml_content

lucidscan/generation/package_installer.py

@@ -0,0 +1,330 @@
+"""Package manager installer.
+
+Adds development tools to package manager configuration files
+(pyproject.toml, package.json).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Dict, List
+
+from lucidscan.core.logging import get_logger
+from lucidscan.detection import ProjectContext
+
+LOGGER = get_logger(__name__)
+
+# Tool to package mapping
+PYTHON_PACKAGES: Dict[str, str] = {
+    "ruff": "ruff>=0.8.0",
+    "mypy": "mypy>=1.0",
+    "pyright": "pyright>=1.1",
+    "pytest": "pytest>=7.0",
+    "pytest-cov": "pytest-cov>=4.0",
+}
+
+JAVASCRIPT_PACKAGES: Dict[str, str] = {
+    "eslint": "eslint@^9.0.0",
+    "biome": "@biomejs/biome@^1.0.0",
+    "typescript": "typescript@^5.0.0",
+    "jest": "jest@^29.0.0",
+    "vitest": "vitest@^2.0.0",
+}
+
+
+class PackageInstaller:
+    """Adds tools to package manager configuration files."""
+
+    def install_tools(
+        self,
+        context: ProjectContext,
+        tools: List[str],
+    ) -> Dict[str, Path]:
+        """Install tools to appropriate package files.
+
+        Args:
+            context: Detected project context.
+            tools: List of tool names to install.
+
+        Returns:
+            Dict mapping tool name to the file it was added to.
+        """
+        installed: Dict[str, Path] = {}
+
+        # Separate tools by language
+        python_tools = [t for t in tools if t in PYTHON_PACKAGES]
+        js_tools = [t for t in tools if t in JAVASCRIPT_PACKAGES]
+
+        # Install Python tools
+        if python_tools and context.has_python:
+            pyproject = context.root / "pyproject.toml"
+            requirements = context.root / "requirements-dev.txt"
+
+            if pyproject.exists():
+                added = self._add_to_pyproject(pyproject, python_tools)
+                for tool in added:
+                    installed[tool] = pyproject
+            elif requirements.exists():
+                added = self._add_to_requirements(requirements, python_tools)
+                for tool in added:
+                    installed[tool] = requirements
+            else:
+                # Create pyproject.toml if no package file exists
+                added = self._create_pyproject(context.root, python_tools)
+                for tool in added:
+                    installed[tool] = context.root / "pyproject.toml"
+
+        # Install JavaScript tools
+        if js_tools and context.has_javascript:
+            package_json = context.root / "package.json"
+
+            if package_json.exists():
+                added = self._add_to_package_json(package_json, js_tools)
+                for tool in added:
+                    installed[tool] = package_json
+            else:
+                # Create package.json if it doesn't exist
+                added = self._create_package_json(context.root, js_tools)
+                for tool in added:
+                    installed[tool] = context.root / "package.json"
+
+        return installed
+
+    def _add_to_pyproject(
+        self,
+        pyproject_path: Path,
+        tools: List[str],
+    ) -> List[str]:
+        """Add tools to pyproject.toml dev dependencies.
+
+        Args:
+            pyproject_path: Path to pyproject.toml.
+            tools: Tools to add.
+
+        Returns:
+            List of tools that were added.
+        """
+        content = pyproject_path.read_text()
+        added = []
+
+        # Check which tools are already present
+        packages_to_add = []
+        for tool in tools:
+            package = PYTHON_PACKAGES.get(tool)
+            if package:
+                # Check if already in file (simple check)
+                tool_name = package.split(">=")[0].split("[")[0]
+                if tool_name not in content:
+                    packages_to_add.append(package)
+                    added.append(tool)
+
+        if not packages_to_add:
+            return added
+
+        # Check if [project.optional-dependencies] exists
+        if "[project.optional-dependencies]" in content:
+            # Check if dev section exists
+            if re.search(r'\[project\.optional-dependencies\].*?dev\s*=', content, re.DOTALL):
+                # Add to existing dev list
+                content = self._append_to_dev_deps(content, packages_to_add)
+            else:
+                # Add dev section after [project.optional-dependencies]
+                dev_section = f'\ndev = [\n  {self._format_deps(packages_to_add)}\n]'
+                content = content.replace(
+                    "[project.optional-dependencies]",
+                    f"[project.optional-dependencies]{dev_section}"
+                )
+        elif "[project]" in content:
+            # Add optional-dependencies section
+            deps_section = f'\n[project.optional-dependencies]\ndev = [\n  {self._format_deps(packages_to_add)}\n]\n'
+            # Find a good place to insert (after dependencies if exists, or at end)
+            if "dependencies = [" in content:
+                # Find end of dependencies section
+                match = re.search(r'dependencies\s*=\s*\[.*?\]', content, re.DOTALL)
+                if match:
+                    insert_pos = match.end()
+                    content = content[:insert_pos] + deps_section + content[insert_pos:]
+            else:
+                # Add at end of [project] section
+                content += deps_section
+        else:
+            # No project section, add one
+            content += f'\n[project.optional-dependencies]\ndev = [\n  {self._format_deps(packages_to_add)}\n]\n'
+
+        pyproject_path.write_text(content)
+        LOGGER.info(f"Added {len(added)} tools to {pyproject_path}")
+        return added
+
+    def _append_to_dev_deps(self, content: str, packages: List[str]) -> str:
+        """Append packages to existing dev dependencies list."""
+        # Find the dev = [...] section and append
+        pattern = r'(dev\s*=\s*\[)(.*?)(\])'
+
+        def replacer(match):
+            existing = match.group(2).strip()
+            if existing and not existing.endswith(","):
+                existing += ","
+            new_deps = self._format_deps(packages)
+            return f'{match.group(1)}{existing}\n  {new_deps}\n{match.group(3)}'
+
+        return re.sub(pattern, replacer, content, flags=re.DOTALL)
+
+    def _format_deps(self, packages: List[str]) -> str:
+        """Format packages as TOML array items."""
+        return ",\n  ".join(f'"{pkg}"' for pkg in packages)
+
+    def _add_to_requirements(
+        self,
+        requirements_path: Path,
+        tools: List[str],
+    ) -> List[str]:
+        """Add tools to requirements-dev.txt.
+
+        Args:
+            requirements_path: Path to requirements file.
+            tools: Tools to add.
+
+        Returns:
+            List of tools that were added.
+        """
+        content = requirements_path.read_text()
+        added = []
+
+        for tool in tools:
+            package = PYTHON_PACKAGES.get(tool)
+            if package:
+                tool_name = package.split(">=")[0]
+                if tool_name not in content:
+                    content += f"\n{package}"
+                    added.append(tool)
+
+        if added:
+            requirements_path.write_text(content.strip() + "\n")
+            LOGGER.info(f"Added {len(added)} tools to {requirements_path}")
+
+        return added
+
+    def _create_pyproject(
+        self,
+        project_root: Path,
+        tools: List[str],
+    ) -> List[str]:
+        """Create pyproject.toml with dev dependencies.
+
+        Args:
+            project_root: Project root directory.
+            tools: Tools to add.
+
+        Returns:
+            List of tools that were added.
+        """
+        packages = [PYTHON_PACKAGES[t] for t in tools if t in PYTHON_PACKAGES]
+
+        content = f'''[project]
+name = "{project_root.name}"
+version = "0.3.0"
+requires-python = ">=3.10"
+
+[project.optional-dependencies]
+dev = [
+  {self._format_deps(packages)}
+]
+
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+'''
+
+        pyproject_path = project_root / "pyproject.toml"
+        pyproject_path.write_text(content)
+        LOGGER.info(f"Created {pyproject_path}")
+        return tools
+
+    def _add_to_package_json(
+        self,
+        package_json_path: Path,
+        tools: List[str],
+    ) -> List[str]:
+        """Add tools to package.json devDependencies.
+
+        Args:
+            package_json_path: Path to package.json.
+            tools: Tools to add.
+
+        Returns:
+            List of tools that were added.
+        """
+        content = package_json_path.read_text()
+        data = json.loads(content)
+        added = []
+
+        if "devDependencies" not in data:
+            data["devDependencies"] = {}
+
+        for tool in tools:
+            package = JAVASCRIPT_PACKAGES.get(tool)
+            if package:
+                # Parse package name and version
+                if "@" in package and not package.startswith("@"):
+                    name, version = package.rsplit("@", 1)
+                elif package.startswith("@"):
+                    # Scoped package like @biomejs/biome@^1.0.0
+                    parts = package.split("@")
+                    name = f"@{parts[1]}"
+                    version = parts[2] if len(parts) > 2 else "latest"
+                else:
+                    name = package
+                    version = "latest"
+
+                if name not in data["devDependencies"]:
+                    data["devDependencies"][name] = version
+                    added.append(tool)
+
+        if added:
+            package_json_path.write_text(
+                json.dumps(data, indent=2) + "\n"
+            )
+            LOGGER.info(f"Added {len(added)} tools to {package_json_path}")
+
+        return added
+
+    def _create_package_json(
+        self,
+        project_root: Path,
+        tools: List[str],
+    ) -> List[str]:
+        """Create package.json with devDependencies.
+
+        Args:
+            project_root: Project root directory.
+            tools: Tools to add.
+
+        Returns:
+            List of tools that were added.
+        """
+        data = {
+            "name": project_root.name,
+            "version": "1.0.0",
+            "devDependencies": {},
+        }
+
+        for tool in tools:
+            package = JAVASCRIPT_PACKAGES.get(tool)
+            if package:
+                if "@" in package and not package.startswith("@"):
+                    name, version = package.rsplit("@", 1)
+                elif package.startswith("@"):
+                    parts = package.split("@")
+                    name = f"@{parts[1]}"
+                    version = parts[2] if len(parts) > 2 else "latest"
+                else:
+                    name = package
+                    version = "latest"
+                data["devDependencies"][name] = version  # type: ignore[index]
+
+        package_json_path = project_root / "package.json"
+        package_json_path.write_text(json.dumps(data, indent=2) + "\n")
+        LOGGER.info(f"Created {package_json_path}")
+        return tools

lucidscan/mcp/__init__.py

@@ -0,0 +1,20 @@
+"""MCP (Model Context Protocol) integration for LucidScan.
+
+This package provides MCP server functionality for AI agent integration,
+enabling tools like Claude Code and Cursor to invoke LucidScan checks.
+"""
+
+from __future__ import annotations
+
+from lucidscan.mcp.server import LucidScanMCPServer
+from lucidscan.mcp.formatter import InstructionFormatter, FixInstruction
+from lucidscan.mcp.tools import MCPToolExecutor
+from lucidscan.mcp.watcher import LucidScanFileWatcher
+
+__all__ = [
+    "LucidScanMCPServer",
+    "InstructionFormatter",
+    "FixInstruction",
+    "MCPToolExecutor",
+    "LucidScanFileWatcher",
+]