coding-client 1.21.2__py3-none-any.whl

coding_client/models/docker_container.py

@@ -0,0 +1,104 @@
+"""Docker-specific container models for internal container management.
+
+This module provides Pydantic models that represent Docker containers and their
+metadata within the code graph helper system. These models facilitate the management
+of containerized development environments for code analysis.
+
+The models in this module are specifically designed for internal use by the DockerService
+and handle the conversion between Docker-specific representations and the public API models.
+
+Classes:
+    DockerContainerDetails: Internal representation of a Docker container with all
+        Docker-specific metadata including ports, environment variables, and status.
+
+Example:
+    ```python
+    from docker_container_models import DockerContainerDetails, ContainerStatus
+
+    # Create container details
+    container = DockerContainerDetails(
+        docker_id="abc123",
+        container_name="my-analysis-container",
+        image="code-graph-helper:latest",
+        ports={"8700/tcp": 8700},
+        workspace_path="/app/workspace",
+        status=ContainerStatus.RUNNING
+    )
+
+    # Convert to public API model
+    api_model = container.to_container_info(
+        code_graph_id="graph-123",
+        repo_url="https://github.com/owner/repo"
+    )
+    ```
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from pydantic import BaseModel, Field
+
+from .container import ContainerInfo, ContainerStatus
+
+
+class DockerContainerDetails(BaseModel):
+    """Docker-specific container details for internal use by DockerService."""
+
+    docker_id: str
+    container_name: str
+    image: str
+    ports: dict[str, int]
+    environment: dict[str, str] = Field(default_factory=dict)
+    workspace_path: str
+    last_activity: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    status: ContainerStatus
+
+    def to_container_info(
+        self,
+        code_graph_id: str = "",
+        codebase_path: str = "/app/data/repo",
+        repo_url: str = "",
+        branch: str = "main",
+        description: str | None = None,
+    ) -> ContainerInfo:
+        """Convert Docker-specific details to public ContainerInfo model.
+
+        Transforms the internal Docker container representation into a public API model
+        that hides Docker-specific implementation details while providing essential
+        container information to API consumers.
+
+        Args:
+            code_graph_id (str, optional): Unique identifier for the associated code graph.
+                Defaults to empty string.
+            codebase_path (str, optional): Path to the codebase within the container.
+                Defaults to "/app/data/repo".
+            repo_url (str, optional): URL of the repository being analyzed.
+                Defaults to empty string.
+            branch (str, optional): Git branch being analyzed.
+                Defaults to "main".
+            description (Optional[str], optional): Human-readable description of the container.
+                Defaults to None.
+
+        Returns:
+            ContainerInfo: Public API model containing essential container information
+                including the container name, API endpoint URL, and status.
+
+        Note:
+            The method extracts the first available port mapping from the Docker container
+            to construct the API endpoint URL. If no ports are mapped, it defaults to 8700.
+        """
+
+        # Get the first port mapping (usually there's only one)
+        port = next(iter(self.ports.values()), 8700)
+
+        return ContainerInfo(
+            container_name=self.container_name,
+            api_endpoint=f"http://localhost:{port}",
+            code_graph_id=code_graph_id,
+            codebase_path=codebase_path,
+            repo_url=repo_url,
+            branch=branch,
+            status=self.status,
+            description=description,
+        )

coding_client/models/github.py

@@ -0,0 +1,293 @@
+"""GitHub integration models for repository operations and webhook handling.
+
+This module provides comprehensive data models for GitHub API integration, supporting
+repository operations, pull request management, webhook processing, and code analysis
+workflows. The models facilitate seamless integration between GitHub's API and the
+code graph helper system.
+
+The GitHub integration supports:
+- Repository cloning and synchronization
+- Pull request analysis and validation
+- Webhook event processing
+- Code snippet evaluation in repository context
+- Automated PR creation and management
+- User and organization data handling
+
+Key Model Categories:
+    Core GitHub Models: GitHubUser, GitHubRepository, GitHubCommit for basic entities
+    Pull Request Models: PullRequestData, PullRequest for PR operations
+    Webhook Models: GitHubWebhookPayload for event processing
+    Workspace Models: RepoWorkspace, RepoSetupResult for repository management
+    Request Models: SnippetAnalysisRequest, PRCreationRequest for API operations
+
+Example:
+    ```python
+    from github_models import GitHubRepository, PullRequestData, RepoSetupResult
+
+    # Repository information
+    repo = GitHubRepository(
+        id=123456,
+        name="my-project",
+        full_name="owner/my-project",
+        description="A sample project",
+        url="https://github.com/owner/my-project",
+        clone_url="https://github.com/owner/my-project.git",
+        default_branch="main",
+        language="Python",
+        size=1024,
+        stargazers_count=42,
+        forks_count=7,
+        open_issues_count=3,
+        private=False,
+        owner=GitHubUser(...)
+    )
+
+    # Pull request data
+    pr = PullRequestData(
+        number=123,
+        title="Add new feature",
+        state="open",
+        author="contributor",
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
+        base_branch="main",
+        head_branch="feature/new-feature",
+        url="https://github.com/owner/my-project/pull/123"
+    )
+    ```
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class PullRequestData(BaseModel):
+    """Pull request data model."""
+
+    number: int = Field(..., description="Pull request number")
+    title: str = Field(..., description="Pull request title")
+    message: str | None = Field(None, description="Pull request message")
+    state: str = Field(..., description="Pull request state (open, closed, merged)")
+    author: str = Field(..., description="Pull request author")
+    created_at: datetime = Field(..., description="Creation timestamp")
+    updated_at: datetime = Field(..., description="Last update timestamp")
+    merged_at: datetime | None = Field(None, description="Merge timestamp")
+    base_branch: str = Field(..., description="Base branch")
+    head_branch: str = Field(..., description="Head branch")
+    url: str = Field(..., description="Pull request URL")
+    diff_url: str = Field(..., description="Diff URL")
+    patch_url: str = Field(..., description="Patch URL")
+
+
+class GitHubUser(BaseModel):
+    """GitHub user model."""
+
+    login: str = Field(..., description="Username")
+    id: int = Field(..., description="User ID")
+    avatar_url: str = Field(..., description="Avatar URL")
+    url: str = Field(..., description="User URL")
+    type: str = Field(..., description="User type")
+
+
+class GitHubRepository(BaseModel):
+    """GitHub repository model."""
+
+    id: int = Field(..., description="Repository ID")
+    name: str = Field(..., description="Repository name")
+    full_name: str = Field(..., description="Full repository name")
+    description: str | None = Field(None, description="Repository description")
+    url: str = Field(..., description="Repository URL")
+    clone_url: str = Field(..., description="Clone URL")
+    ssh_url: str = Field(..., description="SSH URL")
+    default_branch: str = Field(..., description="Default branch")
+    language: str | None = Field(None, description="Primary language")
+    size: int = Field(..., description="Repository size")
+    stargazers_count: int = Field(..., description="Number of stars")
+    forks_count: int = Field(..., description="Number of forks")
+    open_issues_count: int = Field(..., description="Number of open issues")
+    private: bool = Field(..., description="Whether repository is private")
+    owner: GitHubUser = Field(..., description="Repository owner")
+
+
+class GitHubCommit(BaseModel):
+    """GitHub commit model."""
+
+    sha: str = Field(..., description="Commit SHA")
+    message: str = Field(..., description="Commit message")
+    author: GitHubUser = Field(..., description="Commit author")
+    committer: GitHubUser = Field(..., description="Commit committer")
+    timestamp: datetime = Field(..., description="Commit timestamp")
+    url: str = Field(..., description="Commit URL")
+
+
+class GitHubIssue(BaseModel):
+    """GitHub issue model."""
+
+    number: int = Field(..., description="Issue number")
+    title: str = Field(..., description="Issue title")
+    message: str | None = Field(None, description="Issue message")
+    state: str = Field(..., description="Issue state")
+    author: GitHubUser = Field(..., description="Issue author")
+    assignees: list[GitHubUser] = Field(default_factory=list, description="Issue assignees")
+    labels: list[str] = Field(default_factory=list, description="Issue labels")
+    created_at: datetime = Field(..., description="Creation timestamp")
+    updated_at: datetime = Field(..., description="Last update timestamp")
+    closed_at: datetime | None = Field(None, description="Close timestamp")
+    url: str = Field(..., description="Issue URL")
+
+
+class GitHubWebhookPayload(BaseModel):
+    """GitHub webhook payload model."""
+
+    action: str = Field(..., description="Webhook action")
+    repository: GitHubRepository = Field(..., description="Repository data")
+    sender: GitHubUser = Field(..., description="Event sender")
+    pull_request: PullRequestData | None = Field(None, description="Pull request data")
+    issue: GitHubIssue | None = Field(None, description="Issue data")
+    commits: list[GitHubCommit] | None = Field(None, description="Commit data")
+    ref: str | None = Field(None, description="Git reference")
+    before: str | None = Field(None, description="Before SHA")
+    after: str | None = Field(None, description="After SHA")
+
+
+# Additional GitHub-specific models (consolidated from github_dataclasses.py)
+
+
+class GitHubRepoInfo(BaseModel):
+    """GitHub repository information."""
+
+    owner: str = Field(..., description="Repository owner")
+    name: str = Field(..., description="Repository name")
+    url: str = Field(..., description="Repository URL")
+    default_branch: str = Field("main", description="Default branch")
+    description: str | None = Field(None, description="Repository description")
+    language: str | None = Field(None, description="Primary language")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class CloneResult(BaseModel):
+    """Result of repository cloning operation."""
+
+    success: bool = Field(..., description="Whether cloning was successful")
+    repo_id: str = Field(..., description="Repository identifier")
+    local_path: str = Field(..., description="Local path where repo was cloned")
+    error: str | None = Field(None, description="Error message if cloning failed")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class SyncResult(BaseModel):
+    """Result of repository synchronization."""
+
+    success: bool = Field(..., description="Whether sync was successful")
+    commits_behind: int = Field(0, description="Number of commits behind")
+    has_updates: bool = Field(False, description="Whether there are updates available")
+    error: str | None = Field(None, description="Error message if sync failed")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class CodeSnippet(BaseModel):
+    """Code snippet model for GitHub operations."""
+
+    code: str = Field(..., description="Code content")
+    language: str = Field(..., description="Programming language")
+    file_path: str | None = Field(None, description="File path")
+    line_number: int | None = Field(None, description="Line number")
+    description: str | None = Field(None, description="Code description")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class RepositoryContext(BaseModel):
+    """Context information about a repository."""
+
+    existing_patterns: list[dict[str, Any]] = Field(
+        default_factory=list, description="Existing code patterns"
+    )
+    style_guide: dict[str, Any] = Field(default_factory=dict, description="Style guide rules")
+    api_surface: dict[str, Any] = Field(default_factory=dict, description="API surface analysis")
+    size_metrics: dict[str, Any] = Field(
+        default_factory=dict, description="Repository size metrics"
+    )
+
+
+class PRFileChange(BaseModel):
+    """File change information for pull requests."""
+
+    file_path: str = Field(..., description="Path to changed file")
+    change_type: str = Field(..., description="Type of change (added, modified, deleted)")
+    content: str | None = Field(None, description="New file content")
+    old_content: str | None = Field(None, description="Previous file content")
+    additions: int = Field(0, description="Number of lines added")
+    deletions: int = Field(0, description="Number of lines deleted")
+    patch: str | None = Field(None, description="Git patch content")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class PullRequest(BaseModel):
+    """Pull request model for GitHub operations."""
+
+    id: str = Field(..., description="Pull request ID")
+    number: int = Field(..., description="Pull request number")
+    title: str = Field(..., description="Pull request title")
+    description: str = Field(..., description="Pull request description")
+    url: str = Field(..., description="Pull request URL")
+    status: str = Field(..., description="Pull request status")
+    created_at: datetime = Field(..., description="Creation timestamp")
+    updated_at: datetime | None = Field(None, description="Last update timestamp")
+    merged_at: datetime | None = Field(None, description="Merge timestamp")
+    author: str = Field(..., description="Pull request author")
+    base_branch: str = Field(..., description="Base branch")
+    head_branch: str = Field(..., description="Head branch")
+    labels: list[str] = Field(default_factory=list, description="Labels")
+    reviewers: list[str] = Field(default_factory=list, description="Reviewers")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class RepoWorkspace(BaseModel):
+    """Repository workspace model."""
+
+    repo_id: str = Field(..., description="Repository ID")
+    repo_url: str = Field(..., description="Repository URL")
+    local_path: str = Field(..., description="Local workspace path")
+    branch: str = Field("main", description="Current branch")
+    last_sync: datetime = Field(..., description="Last sync timestamp")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class RepoSetupResult(BaseModel):
+    """Result of repository setup operation."""
+
+    success: bool = Field(..., description="Whether setup was successful")
+    workspace: RepoWorkspace | None = Field(None, description="Created workspace")
+    error: str | None = Field(None, description="Error message if setup failed")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class SnippetAnalysisRequest(BaseModel):
+    """Request for code snippet analysis."""
+
+    snippet: CodeSnippet = Field(..., description="Code snippet to analyze")
+    workspace_id: str = Field(..., description="Workspace ID for context")
+    context: dict[str, Any] = Field(default_factory=dict, description="Additional context")
+
+
+class SnippetEvaluationRequest(BaseModel):
+    """Request for code snippet evaluation."""
+
+    workspace_id: str = Field(..., description="Workspace ID")
+    snippet: CodeSnippet = Field(..., description="Code snippet to evaluate")
+    evaluation_options: dict[str, Any] = Field(
+        default_factory=dict, description="Evaluation options"
+    )
+
+
+class PRCreationRequest(BaseModel):
+    """Request for pull request creation."""
+
+    workspace_id: str = Field(..., description="Workspace ID")
+    changes: list[PRFileChange] = Field(..., description="File changes")
+    pr_data: PullRequestData = Field(..., description="Pull request data")
+    analysis_options: dict[str, Any] = Field(default_factory=dict, description="Analysis options")

coding_client/models/logging.py

@@ -0,0 +1,29 @@
+"""
+Shared logging models for the application.
+
+This module provides common logging-related models used across different
+components of the application to avoid duplication.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class LogLevel(StrEnum):
+    """Standard logging levels with clear hierarchy."""
+
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+    @classmethod
+    def from_lowercase(cls, value: str) -> LogLevel:
+        """Convert lowercase log level to enum value."""
+        return cls(value.upper())
+
+    def to_lowercase(self) -> str:
+        """Convert enum value to lowercase string."""
+        return self.value.lower()

coding_client/models/package_manager.py

@@ -0,0 +1,257 @@
+"""Base models for package management across system and language package managers.
+
+This module provides clear separation between system-level package managers
+(apt, brew, yum) and language-specific package managers (pip, npm, cargo).
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class SystemPackageManager(Enum):
+    """System-level package managers for OS dependencies."""
+
+    # Linux distributions
+    APT = "apt-get"  # Debian/Ubuntu
+    YUM = "yum"  # RHEL/CentOS (older)
+    DNF = "dnf"  # Fedora/RHEL/CentOS (newer)
+    PACMAN = "pacman"  # Arch Linux
+    ZYPPER = "zypper"  # openSUSE
+    APK = "apk"  # Alpine Linux
+
+    # macOS
+    BREW = "brew"  # Homebrew
+
+    # Windows
+    CHOCO = "choco"  # Chocolatey
+
+    @property
+    def install_command(self) -> list[str]:
+        """Get the base install command for this package manager."""
+        commands: dict[SystemPackageManager, list[str]] = {
+            SystemPackageManager.APT: ["sudo", "apt-get", "install", "-y"],
+            SystemPackageManager.YUM: ["sudo", "yum", "install", "-y"],
+            SystemPackageManager.DNF: ["sudo", "dnf", "install", "-y"],
+            SystemPackageManager.PACMAN: ["sudo", "pacman", "-S", "--noconfirm"],
+            SystemPackageManager.ZYPPER: ["sudo", "zypper", "install", "-y"],
+            SystemPackageManager.APK: ["sudo", "apk", "add"],
+            SystemPackageManager.BREW: ["brew", "install"],
+            SystemPackageManager.CHOCO: ["choco", "install", "-y"],
+        }
+        return commands.get(self, [])
+
+    @property
+    def update_command(self) -> list[str]:
+        """Get the update command for this package manager."""
+        commands: dict[SystemPackageManager, list[str]] = {
+            SystemPackageManager.APT: ["sudo", "apt-get", "update"],
+            SystemPackageManager.YUM: ["sudo", "yum", "update", "-y"],
+            SystemPackageManager.DNF: ["sudo", "dnf", "update", "-y"],
+            SystemPackageManager.PACMAN: ["sudo", "pacman", "-Syu", "--noconfirm"],
+            SystemPackageManager.ZYPPER: ["sudo", "zypper", "refresh"],
+            SystemPackageManager.APK: ["sudo", "apk", "update"],
+            SystemPackageManager.BREW: ["brew", "update"],
+            SystemPackageManager.CHOCO: ["choco", "upgrade", "all", "-y"],
+        }
+        return commands.get(self, [])
+
+
+class LanguagePackageManager(Enum):
+    """Language-specific package managers."""
+
+    # Python
+    PIP = "pip"
+    POETRY = "poetry"
+    PIPENV = "pipenv"
+    UV = "uv"
+    CONDA = "conda"
+
+    # JavaScript/TypeScript
+    NPM = "npm"
+    YARN = "yarn"
+    PNPM = "pnpm"
+    BUN = "bun"
+
+    # Rust
+    CARGO = "cargo"
+
+    # Java
+    MAVEN = "maven"
+    GRADLE = "gradle"
+
+    # Ruby
+    GEM = "gem"
+    BUNDLER = "bundler"
+
+    # Go
+    GO_MOD = "go mod"
+
+    # PHP
+    COMPOSER = "composer"
+
+    # .NET
+    NUGET = "nuget"
+    DOTNET = "dotnet"
+
+    @property
+    def manifest_files(self) -> list[str]:
+        """Get typical manifest files for this package manager."""
+        manifests: dict[LanguagePackageManager, list[str]] = {
+            LanguagePackageManager.PIP: ["requirements.txt", "requirements/*.txt"],
+            LanguagePackageManager.POETRY: ["pyproject.toml", "poetry.lock"],
+            LanguagePackageManager.PIPENV: ["Pipfile", "Pipfile.lock"],
+            LanguagePackageManager.UV: ["pyproject.toml", "uv.lock"],
+            LanguagePackageManager.CONDA: ["environment.yml", "environment.yaml"],
+            LanguagePackageManager.NPM: ["package.json", "package-lock.json"],
+            LanguagePackageManager.YARN: ["package.json", "yarn.lock"],
+            LanguagePackageManager.PNPM: ["package.json", "pnpm-lock.yaml"],
+            LanguagePackageManager.BUN: ["package.json", "bun.lockb"],
+            LanguagePackageManager.CARGO: ["Cargo.toml", "Cargo.lock"],
+            LanguagePackageManager.MAVEN: ["pom.xml"],
+            LanguagePackageManager.GRADLE: ["build.gradle", "build.gradle.kts"],
+            LanguagePackageManager.GEM: ["Gemfile", "Gemfile.lock"],
+            LanguagePackageManager.BUNDLER: ["Gemfile", "Gemfile.lock"],
+            LanguagePackageManager.GO_MOD: ["go.mod", "go.sum"],
+            LanguagePackageManager.COMPOSER: ["composer.json", "composer.lock"],
+            LanguagePackageManager.NUGET: ["packages.config", "*.csproj"],
+            LanguagePackageManager.DOTNET: ["*.csproj", "*.fsproj", "*.vbproj"],
+        }
+        return manifests.get(self, [])
+
+    @property
+    def install_command(self) -> list[str]:
+        """Get the install command for this package manager."""
+        commands: dict[LanguagePackageManager, list[str]] = {
+            LanguagePackageManager.PIP: ["pip", "install"],
+            LanguagePackageManager.POETRY: ["poetry", "install"],
+            LanguagePackageManager.PIPENV: ["pipenv", "install"],
+            LanguagePackageManager.UV: ["uv", "pip", "install"],
+            LanguagePackageManager.CONDA: ["conda", "install"],
+            LanguagePackageManager.NPM: ["npm", "install"],
+            LanguagePackageManager.YARN: ["yarn", "install"],
+            LanguagePackageManager.PNPM: ["pnpm", "install"],
+            LanguagePackageManager.BUN: ["bun", "install"],
+            LanguagePackageManager.CARGO: ["cargo", "build"],
+            LanguagePackageManager.MAVEN: ["mvn", "install"],
+            LanguagePackageManager.GRADLE: ["gradle", "build"],
+            LanguagePackageManager.GEM: ["gem", "install"],
+            LanguagePackageManager.BUNDLER: ["bundle", "install"],
+            LanguagePackageManager.GO_MOD: ["go", "mod", "download"],
+            LanguagePackageManager.COMPOSER: ["composer", "install"],
+            LanguagePackageManager.NUGET: ["nuget", "restore"],
+            LanguagePackageManager.DOTNET: ["dotnet", "restore"],
+        }
+        return commands.get(self, [])
+
+
+class ExternalPackage(BaseModel):
+    """Represents an external package dependency with optional enrichment data."""
+
+    name: str = Field(..., description="Package name")
+    version: str | None = Field(None, description="Version specification (e.g., >=1.0.0)")
+    manager: LanguagePackageManager | None = Field(None, description="Package manager used")
+    is_dev: bool = Field(False, description="Whether this is a development dependency")
+    source: str | None = Field(None, description="Source file where this dependency was found")
+    extras: list[str] = Field(
+        default_factory=list,
+        description="Extra features requested (e.g., package[extra1,extra2])",
+    )
+
+    # Extended fields for enrichment and security analysis
+    license: str | None = Field(None, description="Package license")
+    ecosystem: str | None = Field(None, description="Package ecosystem (pypi, npm, etc.)")
+    description: str | None = Field(None, description="Package description")
+    homepage: str | None = Field(None, description="Package homepage URL")
+    repository: str | None = Field(None, description="Package repository URL")
+
+    # Legacy fields for compatibility
+    current_version: str | None = Field(None, description="Currently installed version")
+    latest_version: str | None = Field(None, description="Latest available version")
+    severity: str | None = Field(None, description="Security severity if vulnerable")
+
+    model_config = ConfigDict(extra="forbid")
+
+    @property
+    def full_spec(self) -> str:
+        """Get the full package specification including version."""
+        spec = self.name
+        if self.extras:
+            spec = f"{spec}[{','.join(self.extras)}]"
+        if self.version:
+            spec = f"{spec}{self.version}"
+        return spec
+
+
+class SystemDependency(BaseModel):
+    """Represents a system-level dependency required by a package."""
+
+    name: str = Field(..., description="Dependency name")
+    packages: dict[SystemPackageManager, list[str]] = Field(
+        ..., description="Mapping of system package managers to their package names"
+    )
+    description: str = Field(..., description="Human-readable description")
+    required_by: list[str] = Field(
+        default_factory=list,
+        description="List of language packages that require this system dependency",
+    )
+    test_command: str | None = Field(None, description="Command to test if dependency is installed")
+    version_command: str | None = Field(None, description="Command to get installed version")
+    min_version: str | None = Field(None, description="Minimum required version")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PackageManagerCapability(BaseModel):
+    """Describes capabilities of a package manager."""
+
+    manager: SystemPackageManager | LanguagePackageManager = Field(
+        ..., description="The package manager"
+    )
+    supports_lockfile: bool = Field(False, description="Whether this manager supports lock files")
+    supports_virtual_env: bool = Field(
+        False, description="Whether this manager supports virtual environments"
+    )
+    supports_dev_dependencies: bool = Field(
+        False, description="Whether this manager distinguishes dev dependencies"
+    )
+    supports_workspaces: bool = Field(
+        False, description="Whether this manager supports workspaces/monorepos"
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+# Pre-defined capabilities for common package managers
+PACKAGE_MANAGER_CAPABILITIES = {
+    LanguagePackageManager.PIP: PackageManagerCapability(
+        manager=LanguagePackageManager.PIP,
+        supports_lockfile=False,
+        supports_virtual_env=True,
+        supports_dev_dependencies=False,
+        supports_workspaces=False,
+    ),
+    LanguagePackageManager.POETRY: PackageManagerCapability(
+        manager=LanguagePackageManager.POETRY,
+        supports_lockfile=True,
+        supports_virtual_env=True,
+        supports_dev_dependencies=True,
+        supports_workspaces=False,
+    ),
+    LanguagePackageManager.NPM: PackageManagerCapability(
+        manager=LanguagePackageManager.NPM,
+        supports_lockfile=True,
+        supports_virtual_env=False,
+        supports_dev_dependencies=True,
+        supports_workspaces=True,
+    ),
+    LanguagePackageManager.CARGO: PackageManagerCapability(
+        manager=LanguagePackageManager.CARGO,
+        supports_lockfile=True,
+        supports_virtual_env=False,
+        supports_dev_dependencies=True,
+        supports_workspaces=True,
+    ),
+}