coding-client 1.21.2__py3-none-any.whl

coding_client/models/bug.py

@@ -0,0 +1,128 @@
+"""Bug Hunter data models for error analysis and code remediation.
+
+This module provides data structures for the Bug Hunter system, which analyzes
+error logs, identifies bugs in code, and generates remediation suggestions. The models
+support the full workflow from parsing errors to generating validated code modifications.
+
+The Bug Hunter system uses these models to:
+- Parse and categorize errors from various sources (logs, static analysis, runtime)
+- Generate targeted code modifications to address identified issues
+- Validate proposed changes for safety and correctness
+- Provide comprehensive analysis results with confidence scoring
+
+Classes:
+    ErrorType: Enumeration of detectable error types across languages
+    ParsedError: Structured representation of parsed errors with context
+    CodeFix: Proposed code modification with explanation
+    BugAnalysisResult: Complete analysis including errors and remediation
+    FixValidationResult: Safety validation for proposed modifications
+
+Example:
+    ```python
+    from bug_models import ErrorType, ParsedError, CodeFix, BugAnalysisResult
+
+    # Parse an error
+    error = ParsedError(
+        error_type=ErrorType.IMPORT_ERROR,
+        message="No module named 'requests'",
+        file_path="app/main.py",
+        line_number=5,
+        function_name="fetch_data",
+        stack_trace=[],
+        confidence=0.95
+    )
+
+    # Generate a remediation
+    fix = CodeFix(
+        file_path="requirements.txt",
+        line_number=None,
+        original_code="",
+        fixed_code="requests>=2.28.0\\n",
+        explanation="Add missing 'requests' dependency",
+        confidence=0.9,
+        test_suggestion="Run 'pip install -r requirements.txt' to verify"
+    )
+
+    # Complete analysis result
+    result = BugAnalysisResult(
+        errors=[error],
+        resolves=[fix],
+        root_cause_analysis="Missing dependency declaration",
+        fix_summary="Add requests to requirements.txt",
+        estimated_effort="Low - single dependency addition",
+        risk_assessment="Minimal risk - standard library addition"
+    )
+    ```
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from pydantic.dataclasses import dataclass
+
+
+class ErrorType(Enum):
+    """Enumeration of error types that can be detected and resolved."""
+
+    SYNTAX_ERROR = "syntax_error"
+    IMPORT_ERROR = "import_error"
+    NAME_ERROR = "name_error"
+    TYPE_ERROR = "type_error"
+    ATTRIBUTE_ERROR = "attribute_error"
+    INDEX_ERROR = "index_error"
+    KEY_ERROR = "key_error"
+    VALUE_ERROR = "value_error"
+    RUNTIME_ERROR = "runtime_error"
+    LOGIC_ERROR = "logic_error"
+    PERFORMANCE_ERROR = "performance_error"
+
+
+@dataclass
+class ParsedError:
+    """Structured representation of a parsed error from logs or code analysis."""
+
+    error_type: ErrorType
+    message: str
+    file_path: str | None
+    line_number: int | None
+    function_name: str | None
+    stack_trace: list[dict[str, Any]]
+    confidence: float
+
+
+@dataclass
+class CodeFix:
+    """Represents a proposed resolve for a code issue."""
+
+    file_path: str
+    line_number: int | None
+    original_code: str
+    fixed_code: str
+    explanation: str
+    confidence: float
+    test_suggestion: str | None = None
+
+
+@dataclass
+class BugAnalysisResult:
+    """Complete result of bug analysis including errors, resolves, and assessments."""
+
+    errors: list[ParsedError]
+    resolves: list[CodeFix]
+    root_cause_analysis: str
+    fix_summary: str
+    estimated_effort: str
+    risk_assessment: str
+
+
+@dataclass
+class BugFixValidationResult:
+    """Result of validating a proposed resolve for safety and correctness."""
+
+    is_safe: bool
+    confidence: float
+    warnings: list[str]
+    suggestions: list[str]
+    risk_level: str

coding_client/models/code_graph.py

@@ -0,0 +1,317 @@
+"""Pydantic models for code graph representations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+# Request Models
+
+
+class CodebaseInitRequest(BaseModel):
+    """Request model for initializing a new Code Graph for a codebase."""
+
+    container_name: str = Field(
+        ...,
+        min_length=1,
+        description="Container name from which to initialize the graph",
+        pattern=r"^[a-zA-Z][a-zA-Z0-9\-_]{0,62}$",
+        json_schema_extra={"example": "codegraph-my-project"},
+    )
+    codebase_path: str | None = Field(
+        None,
+        min_length=1,
+        description="Path to the codebase directory (internal to the container). If not provided, will be automatically resolved from the container configuration.",
+        pattern=r"^/[a-zA-Z0-9/_\-\.]+$",
+        json_schema_extra={"example": "/app/repositories/my-project"},
+    )
+    include_tests: bool | None = Field(
+        None,
+        description="Whether to include test files in the graph analysis. If not specified, uses the default system setting.",
+    )
+    exclude_patterns: list[str] | None = Field(
+        None,
+        description="Additional patterns to exclude from analysis (e.g., ['**/legacy/**', 'temp_*']). These are added to the default ignore patterns.",
+        json_schema_extra={"example": ["**/node_modules/**", "**/dist/**"]},
+    )
+    include_patterns: list[str] | None = Field(
+        None,
+        description="Specific patterns to include even if they would normally be excluded (e.g., ['important_test_*.py']). These override exclude patterns.",
+        json_schema_extra={"example": ["**/important_*.py"]},
+    )
+    force_rebuild: bool | None = Field(
+        False,
+        description="Force rebuild of the graph even if it already exists. This will delete the existing database and create a new one.",
+    )
+
+    @field_validator("codebase_path")
+    @classmethod
+    def validate_codebase_path(cls, v: str | None) -> str | None:
+        """Validate codebase path is safe and not a system directory."""
+        if v is None:
+            return v
+
+        if not v or not v.strip():
+            raise ValueError("Codebase path cannot be empty")
+
+        v = v.strip()
+
+        # Prevent dangerous paths
+        dangerous_paths = [
+            "/",
+            "/etc",
+            "/usr",
+            "/bin",
+            "/sbin",
+            "/var",
+            "/sys",
+            "/proc",
+            "/dev",
+            "/boot",
+            "/root",
+        ]
+        if v in dangerous_paths or any(v.startswith(f"{p}/") for p in dangerous_paths[:5]):
+            raise ValueError(f"Invalid codebase path: {v}. Cannot analyze system directories.")
+
+        # Ensure path doesn't contain suspicious patterns
+        if ".." in v or "~" in v:
+            raise ValueError("Codebase path cannot contain '..' or '~'")
+
+        return v
+
+
+class CodeGraphAnalysisRequest(BaseModel):
+    """Request model for triggering analysis on a Code Graph."""
+
+    analysis_depth: str = Field(
+        "full",
+        description="Depth of analysis to perform",
+        examples=["basic_structure", "python_ast", "full"],
+    )
+
+    @field_validator("analysis_depth")
+    @classmethod
+    def validate_analysis_depth(cls, v: str) -> str:
+        """Validate analysis depth value."""
+        valid_depths = ["basic_structure", "python_ast", "full"]
+        if v not in valid_depths:
+            raise ValueError(f"analysis_depth must be one of: {valid_depths}")
+        return v
+
+
+class PatternSearchRequest(BaseModel):
+    """Request model for searching code patterns."""
+
+    pattern: str = Field(..., description="Regular expression or AST pattern to search for")
+    language: str | None = Field(None, description="Programming language for AST-based search")
+    file_paths: list[str] | None = Field(
+        None,
+        description="Specific files to search (if not provided, searches all files)",
+    )
+
+
+class EntityQueryRequest(BaseModel):
+    """Request model for querying entities in the Code Graph."""
+
+    entity_type: str = Field(..., description="Type of entity to query (e.g., 'function', 'class')")
+    name_pattern: str | None = Field(None, description="Optional pattern to match entity names")
+    limit: int = Field(100, description="Maximum number of results to return")
+    offset: int = Field(0, description="Offset for pagination")
+
+
+class RelatedNodesRequest(BaseModel):
+    """Request model for retrieving nodes related to a specific node."""
+
+    node_id: str = Field(..., description="ID of the node to find related nodes for")
+    relationship_type: str | None = Field(None, description="Optional filter by relationship type")
+    direction: str = Field("all", description="'outgoing', 'incoming', or 'all'")
+
+
+class RawQueryRequest(BaseModel):
+    """Request model for executing a raw SQL query against the Code Graph."""
+
+    sql_query: str = Field(..., description="SQL query to execute (use with caution)")
+
+
+class NodeQuery(BaseModel):
+    """Model for querying nodes in the knowledge graph."""
+
+    type: str | None = Field(None, description="Filter by node type")
+    properties: dict[str, Any] | None = Field(None, description="Filter by node properties")
+    text_search: str | None = Field(None, description="Full-text search in properties")
+    with_centrality: bool | None = Field(False, description="Include centrality metrics")
+    with_incoming: bool | None = Field(False, description="Include incoming edges count")
+    with_outgoing: bool | None = Field(False, description="Include outgoing edges count")
+    sort_by: str | None = Field(None, description="Property to sort by")
+    sort_direction: str | None = Field("desc", description="Sort direction")
+    limit: int | None = Field(100, description="Limit for pagination", gt=0, le=10000)
+    offset: int | None = Field(0, description="Offset for pagination", ge=0)
+
+    @field_validator("sort_direction")
+    @classmethod
+    def validate_sort_direction(cls, v: str | None) -> str:
+        """Validate sort direction."""
+        if v and v.lower() not in ["asc", "desc"]:
+            raise ValueError("sort_direction must be 'asc' or 'desc'")
+        return v.lower() if v else "desc"
+
+    @field_validator("type")
+    @classmethod
+    def validate_type(cls, v: str | None) -> str | None:
+        """Validate node type is not empty string."""
+        if v is not None and not v.strip():
+            raise ValueError("Node type cannot be empty string")
+        return v.strip() if v else None
+
+
+# Response Models
+
+
+class NodeResponse(BaseModel):
+    """Response model for a node in the Code Graph."""
+
+    id: str
+    type: str
+    properties: dict[str, Any]
+    centrality: dict[str, float] | None = None  # Centrality metrics (e.g., pagerank, degree)
+    incoming_edges: int | None = None  # Count of incoming edges
+    outgoing_edges: int | None = None  # Count of outgoing edges
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "id": "node-123",
+                "type": "function",
+                "properties": {"name": "process_data", "complexity": 5},
+                "centrality": {"pagerank": 0.23, "degree": 0.15},
+            }
+        }
+    )
+
+
+class EdgeResponse(BaseModel):
+    """Response model for an edge in the Code Graph."""
+
+    source: str
+    target: str
+    relationship: str
+    properties: dict[str, Any]
+    direction: str | None = None
+
+
+class InitResponse(BaseModel):
+    """Response model for Code Graph initialization."""
+
+    message: str
+    container_name: str
+    graph_db_path: str
+    nodes_created: int
+    edges_created: int
+    status: str
+
+
+class CodeGraphAnalysisResponse(BaseModel):
+    """Response model for Code Graph analysis triggering."""
+
+    code_graph_id: str
+    status: str
+    analysis_depth: str
+
+
+class PatternSearchResponse(BaseModel):
+    """Response model for pattern search results."""
+
+    matches: list[dict[str, Any]]
+    count: int
+    search_time_ms: float | None = None
+    code_graph_id: str | None = None
+    error: str | None = None
+
+
+class EntityQueryResponse(BaseModel):
+    """Response model for entity query results."""
+
+    entities: list[NodeResponse]
+    total: int
+    limit: int
+    offset: int
+
+
+class RelatedNodesResponse(BaseModel):
+    """Response model for related nodes query."""
+
+    nodes: list[NodeResponse]
+    edges: list[EdgeResponse]
+
+
+class RawQueryResponse(BaseModel):
+    """Response model for raw SQL query results."""
+
+    results: list[dict[str, Any]]
+    row_count: int
+
+
+# Architecture Extension Models
+
+
+class ArchitectureNodeResponse(NodeResponse):
+    """Extended node response with architecture data."""
+
+    architecture_data: dict[str, Any] | None = None
+    hotspot_score: float | None = None
+    quality_issues: list[dict[str, Any]] | None = None
+    dependencies: list[str] | None = None
+    component_id: str | None = None
+    layer: str | None = None
+
+
+class RuntimeEdgeResponse(EdgeResponse):
+    """Extended edge response with runtime data."""
+
+    runtime_data: dict[str, Any] | None = None
+    call_count: int | None = None
+    avg_duration_ms: float | None = None
+    error_rate: float | None = None
+    confidence: float | None = None
+
+
+class ArchitectureCodeGraphResponse(BaseModel):
+    """Response model for architecture code graph."""
+
+    nodes: list[ArchitectureNodeResponse]
+    edges: list[RuntimeEdgeResponse]
+    architecture_metadata: dict[str, Any] | None = None
+    quality_summary: dict[str, Any] | None = None
+    dependency_summary: dict[str, Any] | None = None
+
+
+class RuntimeGraphResponse(BaseModel):
+    """Response model for runtime code graph."""
+
+    nodes: list[NodeResponse]
+    edges: list[RuntimeEdgeResponse]
+    runtime_metadata: dict[str, Any] | None = None
+    trace_summary: dict[str, Any] | None = None
+
+
+class CodeGraphIntegrationRequest(BaseModel):
+    """Request model for integrating architecture data with code graph."""
+
+    include_architecture: bool = Field(True, description="Include architecture analysis data")
+    include_dependencies: bool = Field(True, description="Include dependency analysis data")
+    include_quality: bool = Field(True, description="Include quality analysis data")
+    include_runtime: bool = Field(False, description="Include runtime trace data")
+    quality_threshold: float | None = Field(None, description="Minimum quality score to include")
+    hotspot_threshold: float | None = Field(None, description="Minimum hotspot score to include")
+
+
+# Rebuild all models to resolve forward references
+CodebaseInitRequest.model_rebuild()
+CodeGraphAnalysisRequest.model_rebuild()
+PatternSearchRequest.model_rebuild()
+EntityQueryRequest.model_rebuild()
+RelatedNodesRequest.model_rebuild()
+RawQueryRequest.model_rebuild()
+CodeGraphIntegrationRequest.model_rebuild()
+InitResponse.model_rebuild()

coding_client/models/container.py

@@ -0,0 +1,241 @@
+"""Module for defining container models used in the application."""
+
+from __future__ import annotations
+
+import re
+from enum import StrEnum
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+
+class ContainerStatus(StrEnum):
+    """Container status enumeration"""
+
+    CREATING = "creating"
+    RUNNING = "running"
+    STOPPED = "stopped"
+    ERROR = "error"
+    REMOVING = "removing"
+
+
+class AnalysisConfig(BaseModel):
+    """Configuration for code analysis during provisioning."""
+
+    include_tests: bool | None = Field(
+        None,
+        description="Whether to include test files in code graph analysis",
+    )
+    language_hint: str | None = Field(
+        None,
+        description="Primary programming language hint for better analysis",
+    )
+    exclude_patterns: list[str] | None = Field(
+        None, description="Additional patterns to exclude from analysis"
+    )
+    include_patterns: list[str] | None = Field(
+        None, description="Patterns to include despite other exclusions"
+    )
+
+
+class GitHubRepoRequest(BaseModel):
+    """Request model for GitHub repository operations."""
+
+    model_config = ConfigDict(str_strip_whitespace=True, validate_assignment=True, extra="forbid")
+    repo_url: str = Field(
+        ...,
+        min_length=1,
+        description="GitHub repository URL",
+        pattern=r"^https://github\.com/[A-Za-z0-9\-_.]+/[A-Za-z0-9\-_.]+(?:/pull/\d+)?(?:\.git)?/?$",
+        json_schema_extra={"example": "https://github.com/owner/repository"},
+    )
+    branch: str = Field(
+        "main",
+        min_length=1,
+        description="Git branch to clone",
+        json_schema_extra={"example": "main"},
+    )
+    container_name: str | None = Field(
+        None,
+        description="Optional container name",
+        pattern=r"^[a-zA-Z][a-zA-Z0-9\-_]{0,62}$",
+        json_schema_extra={"example": "my-analysis-container"},
+    )
+    description: str | None = Field(None, description="Optional description", max_length=500)
+    access_token: str | None = Field(
+        None,
+        description="GitHub Personal Access Token for private repositories",
+        json_schema_extra={"example": "<github-personal-access-token>"},
+    )
+    user_id: str | None = Field(
+        None,
+        description="User ID for multi-account workflow (defaults to anonymous if not provided)",
+        pattern=r"^[a-zA-Z0-9\-_\.@]+$",
+        max_length=128,
+        json_schema_extra={"example": "user-123"},
+    )
+    force_rebuild: bool | None = Field(
+        False, description="Force recreation if container already exists"
+    )
+    analysis_config: AnalysisConfig | None = Field(
+        None, description="Configuration for code analysis during provisioning"
+    )
+    pr_number: int | None = Field(
+        None, description="Pull request number to provision", ge=1, le=999999
+    )
+    provision_type: Literal["branch", "pull_request"] = Field(
+        "branch", description="Type of provisioning"
+    )
+    secret_config_id: str | None = Field(
+        None,
+        description="Client ID for retrieving environment variables from secrets store",
+        pattern=r"^[a-zA-Z0-9\-_\.]+$",
+        max_length=128,
+        json_schema_extra={"example": "repo-myorg-myproject"},
+    )
+
+    @field_validator("repo_url")
+    @classmethod
+    def validate_repo_url(cls, v):
+        """Validate repo URL is not empty and follows GitHub URL format."""
+        if not v or not v.strip():
+            raise ValueError("Repository URL cannot be empty")
+
+        v = v.strip()
+
+        # Basic URL format validation for GitHub URLs
+
+        # Check if it's a PR URL
+        pr_url_pattern = re.compile(
+            r"^https://github\.com/[A-Za-z0-9\-_.]+/[A-Za-z0-9\-_.]+/pull/\d+(?:/.*)?$"
+        )
+
+        if pr_url_pattern.match(v):
+            # This is a PR URL - we'll handle parsing in the model validator
+            return v
+
+        # Standard repo URL pattern
+        github_url_pattern = re.compile(
+            r"^https://github\.com/[A-Za-z0-9\-_.]+/[A-Za-z0-9\-_.]+(?:\.git)?/?$"
+        )
+
+        # Additional check for obviously invalid URLs like single characters
+        if len(v) < 10 or not v.startswith("https://"):
+            raise ValueError(
+                "Repository URL must be a valid GitHub URL (e.g., https://github.com/owner/repo)"
+            )
+
+        if not github_url_pattern.match(v):
+            raise ValueError(
+                "Repository URL must be a valid GitHub URL format (e.g., https://github.com/owner/repo)"
+            )
+
+        return v
+
+    @field_validator("branch")
+    @classmethod
+    def validate_branch(cls, v):
+        """Validate branch is not empty."""
+        if not v or not v.strip():
+            raise ValueError("Branch name cannot be empty")
+        return v.strip()
+
+    @field_validator("pr_number")
+    @classmethod
+    def validate_pr_number(cls, v):
+        """Validate PR number if provided."""
+        if v is not None and v <= 0:
+            raise ValueError("PR number must be positive if provided")
+        return v
+
+    @model_validator(mode="after")
+    def parse_pr_url(self):
+        """Parse PR URL and extract repository URL and PR number if applicable."""
+
+        # Check if repo_url is a PR URL
+        pr_url_pattern = re.compile(
+            r"^https://github\.com/([A-Za-z0-9\-_.]+)/([A-Za-z0-9\-_.]+)/pull/(\d+)(?:/.*)?$"
+        )
+
+        match = pr_url_pattern.match(self.repo_url)
+        if match:
+            # Extract components from PR URL
+            owner = match.group(1)
+            repo = match.group(2)
+            pr_number = int(match.group(3))
+
+            # Update fields
+            self.repo_url = f"https://github.com/{owner}/{repo}"
+            self.pr_number = pr_number
+            self.provision_type = "pull_request"
+
+        return self
+
+
+class ContainerInfo(BaseModel):
+    """Information model for container instances."""
+
+    container_name: (
+        str  # Primary identifier - same as Docker container name, used to access code graphs
+    )
+    api_endpoint: str
+    code_graph_id: str = ""  # Code graph identifier for this container
+    codebase_path: str
+    repo_url: str
+    branch: str
+    status: ContainerStatus
+    description: str | None = None
+    pr_number: int | None = None
+    provision_type: str = "branch"
+    github_access_token: str | None = Field(
+        None,
+        description="GitHub access token for this container's repository operations (deprecated - use user_token_id)",
+    )
+    user_token_id: str | None = Field(
+        None,
+        description="Reference to encrypted user GitHub token in SecureTokenManager",
+    )
+    user_id: str | None = Field(
+        None,
+        description="User ID who provisioned this container",
+    )
+    original_repo_owner: str | None = Field(
+        None,
+        description="Original repository owner (for creating upstream PRs)",
+    )
+    original_repo_name: str | None = Field(
+        None,
+        description="Original repository name (for creating upstream PRs)",
+    )
+    system_fork_owner: str | None = Field(
+        None,
+        description="System account owner where fork resides (e.g., 'nonagenticai')",
+    )
+    graph_initialized: bool = Field(
+        False,
+        description="Whether the code graph has been initialized for this container",
+    )
+    tenant_id: str | None = Field(
+        None,
+        description="Tenant identifier for multi-tenant data isolation",
+    )
+
+
+class ContainerSpec(BaseModel):
+    """Specification model for container setup."""
+
+    name: str = Field(..., description="Container name")
+    image: str = Field(..., description="Docker image to use")
+    port: int = Field(..., description="Host port to bind to")
+    command: str | None = Field(None, description="Command to run in container")
+    working_dir: str | None = Field(None, description="Working directory")
+    environment: dict[str, Any] = Field(default_factory=dict, description="Environment variables")
+    volumes: dict[str, Any] = Field(default_factory=dict, description="Volume mounts")
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        """Validate container name is not empty."""
+        if not v or not v.strip():
+            raise ValueError("Container name cannot be empty")
+        return v.strip()