coding-client 1.21.2__py3-none-any.whl

coding_client/models/testing_config.py

@@ -0,0 +1,200 @@
+"""Testing configuration models for background tasks and quality analysis."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class TestingConfiguration(BaseModel):
+    """Configuration for testing and quality analysis."""
+
+    # Basic settings
+    default_timeout: int = Field(
+        default=30, ge=1, le=300, description="Default test timeout in seconds"
+    )
+    max_memory_mb: int = Field(
+        default=512,
+        ge=128,
+        le=2048,
+        description="Maximum memory per container in MB",
+    )
+    max_cpu_quota: int = Field(
+        default=50000,
+        ge=10000,
+        le=100000,
+        description="Maximum CPU quota (100000 = 1 CPU)",
+    )
+
+    # Security settings
+    network_isolation: bool = Field(
+        default=True, description="Enable network isolation for containers"
+    )
+    readonly_filesystem: bool = Field(
+        default=True, description="Use read-only filesystem for containers"
+    )
+    enable_security_scanning: bool = Field(
+        default=True, description="Enable security scanning of code"
+    )
+
+    # Language-specific settings
+    python_version: str = Field(default="3.11", description="Python version to use")
+    node_version: str = Field(default="18", description="Node.js version to use")
+
+    # Quality tool settings
+    enabled_python_tools: list[str] = Field(
+        default=["ruff", "ruff-format", "ty", "bandit"],
+        description="Enabled Python quality tools",
+    )
+    enabled_js_tools: list[str] = Field(
+        default=["eslint", "prettier"],
+        description="Enabled JavaScript quality tools",
+    )
+    enabled_ts_tools: list[str] = Field(
+        default=["eslint", "prettier", "tsc"],
+        description="Enabled TypeScript quality tools",
+    )
+
+    # Analysis settings
+    quality_score_threshold: float = Field(
+        default=7.0,
+        ge=0.0,
+        le=10.0,
+        description="Minimum quality score threshold",
+    )
+    auto_fix_enabled: bool = Field(
+        default=False, description="Enable automatic resolving of issues"
+    )
+    fail_on_security_issues: bool = Field(
+        default=True, description="Fail analysis on security issues"
+    )
+
+    # Caching settings
+    cache_test_results: bool = Field(default=True, description="Cache test execution results")
+    cache_quality_results: bool = Field(default=True, description="Cache quality analysis results")
+    cache_ttl_seconds: int = Field(
+        default=3600, ge=300, le=86400, description="Cache TTL in seconds"
+    )
+
+    # Container settings
+    cleanup_containers: bool = Field(
+        default=True,
+        description="Automatically cleanup containers after execution",
+    )
+    container_registry: str = Field(default="docker.io", description="Container registry to use")
+    base_images: dict[str, str] = Field(
+        default={
+            "python": "code_graph_helper-api:latest",
+            "javascript": "node:18-slim",
+            "typescript": "node:18-slim",
+        },
+        description="Base container images for each language",
+    )
+
+
+class DependencyScanConfig(BaseModel):
+    """Configuration for dependency scanning tasks."""
+
+    enabled: bool = Field(default=True, description="Enable dependency scanning")
+    scan_dev_dependencies: bool = Field(
+        default=False, description="Include dev dependencies in scan"
+    )
+    security_advisory_check: bool = Field(default=True, description="Check for security advisories")
+    outdated_package_check: bool = Field(default=True, description="Check for outdated packages")
+    max_scan_time_seconds: int = Field(
+        default=300, ge=30, le=1800, description="Maximum scan time in seconds"
+    )
+    cache_scan_results: bool = Field(default=True, description="Cache dependency scan results")
+    cache_ttl_hours: int = Field(default=24, ge=1, le=168, description="Cache TTL in hours")
+
+
+class QualityScanConfig(BaseModel):
+    """Configuration for quality scanning tasks."""
+
+    enabled: bool = Field(default=True, description="Enable quality scanning")
+    parallel_tool_execution: bool = Field(default=True, description="Run quality tools in parallel")
+    max_parallel_tools: int = Field(
+        default=4, ge=1, le=8, description="Maximum parallel tool executions"
+    )
+    fail_fast: bool = Field(default=False, description="Stop on first tool failure")
+    generate_reports: bool = Field(default=True, description="Generate quality reports")
+    include_suggestions: bool = Field(default=True, description="Include improvement suggestions")
+    max_scan_time_seconds: int = Field(
+        default=600, ge=60, le=3600, description="Maximum scan time in seconds"
+    )
+    cache_quality_results: bool = Field(default=True, description="Cache quality scan results")
+    cache_ttl_hours: int = Field(default=6, ge=1, le=72, description="Cache TTL in hours")
+
+
+class BackgroundTaskConfig(BaseModel):
+    """Configuration for background task execution."""
+
+    max_concurrent_tasks: int = Field(
+        default=5, ge=1, le=20, description="Maximum concurrent background tasks"
+    )
+    task_timeout_seconds: int = Field(
+        default=1800, ge=300, le=7200, description="Task timeout in seconds"
+    )
+    retry_failed_tasks: bool = Field(default=True, description="Retry failed tasks")
+    max_retries: int = Field(default=3, ge=0, le=10, description="Maximum task retry attempts")
+    retry_delay_seconds: int = Field(
+        default=60, ge=10, le=300, description="Delay between retries in seconds"
+    )
+    cleanup_completed_tasks: bool = Field(default=True, description="Cleanup completed task data")
+    cleanup_delay_hours: int = Field(
+        default=24, ge=1, le=168, description="Delay before cleanup in hours"
+    )
+
+
+class TaskExecutionResult(BaseModel):
+    """Result of a background task execution."""
+
+    task_id: str = Field(description="Unique task identifier")
+    task_type: str = Field(description="Type of task executed")
+    success: bool = Field(description="Whether task completed successfully")
+    start_time: datetime = Field(description="Task start timestamp")
+    end_time: datetime | None = Field(None, description="Task completion timestamp")
+    execution_time_seconds: float | None = Field(None, description="Task execution duration")
+    result_data: dict[str, Any] | None = Field(None, description="Task result data")
+    error_message: str | None = Field(None, description="Error message if failed")
+    retry_count: int = Field(default=0, description="Number of retry attempts")
+    metadata: dict[str, Any] | None = Field(None, description="Additional task metadata")
+
+
+class TestingTaskQueueConfig(BaseModel):
+    """Configuration for task queue management."""
+
+    queue_name: str = Field(description="Name of the task queue")
+    max_queue_size: int = Field(default=1000, ge=10, le=10000, description="Maximum queue size")
+    worker_count: int = Field(default=3, ge=1, le=10, description="Number of worker processes")
+    batch_size: int = Field(default=5, ge=1, le=50, description="Tasks processed per batch")
+    poll_interval_seconds: int = Field(
+        default=10, ge=1, le=60, description="Queue polling interval"
+    )
+    priority_enabled: bool = Field(default=True, description="Enable task priority handling")
+    dead_letter_queue: bool = Field(
+        default=True, description="Enable dead letter queue for failed tasks"
+    )
+
+
+# Factory function for creating default configurations
+def get_default_testing_config() -> TestingConfiguration:
+    """Get default testing configuration."""
+    return TestingConfiguration()
+
+
+def get_default_dependency_scan_config() -> DependencyScanConfig:
+    """Get default dependency scan configuration."""
+    return DependencyScanConfig()
+
+
+def get_default_quality_scan_config() -> QualityScanConfig:
+    """Get default quality scan configuration."""
+    return QualityScanConfig()
+
+
+def get_default_background_task_config() -> BackgroundTaskConfig:
+    """Get default background task configuration."""
+    return BackgroundTaskConfig()

coding_client/models/validation.py

@@ -0,0 +1,127 @@
+"""Validation models for multi-language code validation endpoints.
+
+This module provides language-specific validation models that ensure consistent
+request/response structures across different programming languages. The models
+are designed with Pydantic v2/v3 compatibility and support specialized validation
+options for each supported language.
+
+The validation system handles:
+- Language-specific validation requirements (class names, project types, etc.)
+- Consistent error reporting across all languages
+- Type-safe request/response validation
+- Proper field aliasing for API compatibility
+
+Supported Languages:
+    - Python: General-purpose validation with filename support
+    - JavaScript/TypeScript: ES6+ and TypeScript validation
+    - Java: Class-based validation with className parameter
+    - Rust: Crate-based validation with crate type specification
+    - C#: Project-based validation with framework targeting
+    - Go: Package-based validation with Go module support
+
+Example:
+    ```python
+    from validation_models import JavaValidationRequest, ValidationResponse
+
+    # Create Java validation request
+    request = JavaValidationRequest(
+        code='public class Hello { public static void main(String[] args) { System.out.println("Hello"); } }',
+        className="Hello"
+    )
+
+    # Process validation response
+    response = ValidationResponse(
+        validationId="val-123",
+        valid=True,
+        errors=[],
+        output="Compilation successful"
+    )
+    ```
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class ValidationRequest(BaseModel):
+    """Base validation request model."""
+
+    model_config = ConfigDict(
+        extra="forbid",  # Reject extra fields
+        str_strip_whitespace=True,  # Strip whitespace from strings
+    )
+
+    code: str = Field(..., description="Code to validate")
+
+    @field_validator("code")
+    @classmethod
+    def validate_code_not_none(cls, v: str) -> str:
+        """Ensure code is provided and not None."""
+        if v is None:
+            raise ValueError("Code field is required")
+        return v
+
+
+class JavaScriptValidationRequest(ValidationRequest):
+    """JavaScript/TypeScript validation request."""
+
+    filename: str | None = Field(default="test.js", description="Filename for validation")
+
+
+class PythonValidationRequest(ValidationRequest):
+    """Python validation request."""
+
+    filename: str | None = Field(default="test.py", description="Filename for validation")
+
+
+class JavaValidationRequest(ValidationRequest):
+    """Java validation request."""
+
+    className: str | None = Field(default="Test", description="Java class name")
+
+
+class RustValidationRequest(ValidationRequest):
+    """Rust validation request."""
+
+    crateType: Literal["bin", "lib"] | None = Field(default="bin", description="Crate type")
+
+
+class CSharpValidationRequest(ValidationRequest):
+    """C# validation request."""
+
+    projectType: Literal["console", "library"] | None = Field(
+        default="console", description="Project type"
+    )
+    targetFramework: str | None = Field(default="net8.0", description="Target framework")
+
+
+class GoValidationRequest(ValidationRequest):
+    """Go validation request."""
+
+    filename: str | None = Field(default="main.go", description="Filename for validation")
+
+
+class ValidationResponse(BaseModel):
+    """Validation response model."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    validationId: str = Field(..., description="Unique validation ID")
+    valid: bool = Field(..., description="Whether the code is valid")
+    errors: list[str] = Field(default_factory=list, description="List of validation errors")
+    output: str = Field(default="", description="Validation output")
+    warnings: list[str] | None = Field(default=None, description="List of warnings")
+
+
+class CodeValidationErrorResponse(BaseModel):
+    """Validation error response model."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    validationId: str | None = Field(default=None, description="Validation ID if available")
+    valid: bool = Field(default=False, description="Always false for errors")
+    error: str = Field(..., description="Error message")
+    details: str | None = Field(default=None, description="Additional error details")

coding_client/models_init.py

@@ -0,0 +1,272 @@
+"""
+SQLAlchemy ORM models for code graph database.
+
+Models include:
+- Node: Code entities (functions, classes, modules) with multi-language support
+- Edge: Relationships between entities (calls, imports, inheritance)
+- Codebase: Repository/project tracking
+- SchemaVersion: Migration tracking
+- NodeAudit: Change audit logging
+- Architecture analysis tables (components, metrics, patterns, packages)
+- Quality analysis tables (results, sessions)
+"""
+
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Float,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+    Text,
+    UniqueConstraint,
+    func,
+)
+from sqlalchemy.dialects.postgresql import JSONB, TSVECTOR
+
+from .db_init import Base
+
+
+class Node(Base):
+    """Code entity node in the graph."""
+
+    __tablename__ = "nodes"
+
+    id = Column(String(500), primary_key=True)
+    type = Column(String(50), nullable=False, index=True)
+    properties = Column(JSONB, nullable=True, default=dict)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    content_hash = Column(String(64), nullable=True, index=True)
+    file_size = Column(Integer, nullable=True)
+    tenant_id = Column(String(100), nullable=True, index=True)
+    tsv = Column(TSVECTOR, nullable=True)
+
+    __table_args__ = (
+        Index("ix_nodes_type_created", "type", "created_at"),
+        Index("ix_nodes_tenant_type", "tenant_id", "type"),
+        Index("ix_nodes_tsv", "tsv", postgresql_using="gin"),
+        Index("ix_nodes_properties", "properties", postgresql_using="gin"),
+    )
+
+
+class Edge(Base):
+    """Relationship edge between code entities."""
+
+    __tablename__ = "edges"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    source = Column(String(500), ForeignKey("nodes.id", ondelete="CASCADE"), nullable=False)
+    target = Column(String(500), ForeignKey("nodes.id", ondelete="CASCADE"), nullable=False)
+    relationship = Column(String(50), nullable=False)
+    properties = Column(JSONB, nullable=True, default=dict)
+    weight = Column(Float, nullable=False, default=1.0)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    tenant_id = Column(String(100), nullable=True)
+
+    __table_args__ = (
+        UniqueConstraint("source", "target", "relationship", name="uq_edges_source_target_rel"),
+        Index("ix_edges_source", "source"),
+        Index("ix_edges_target", "target"),
+        Index("ix_edges_relationship", "relationship"),
+        Index("ix_edges_source_rel", "source", "relationship"),
+        Index("ix_edges_target_rel", "target", "relationship"),
+        Index("ix_edges_weight", "relationship", "weight"),
+        Index("ix_edges_tenant", "tenant_id"),
+        Index("ix_edges_tenant_source", "tenant_id", "source"),
+    )
+
+
+class Codebase(Base):
+    """Repository/project being analyzed."""
+
+    __tablename__ = "codebases"
+
+    id = Column(String(100), primary_key=True)
+    name = Column(String(200), nullable=False)
+    description = Column(Text, nullable=True)
+    tenant_id = Column(String(100), nullable=True, index=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+
+class SchemaVersion(Base):
+    """Tracks schema migration versions."""
+
+    __tablename__ = "schema_version"
+
+    version = Column(Integer, primary_key=True)
+    description = Column(Text, nullable=True)
+    applied_at = Column(DateTime(timezone=True), server_default=func.now())
+
+
+class NodeAudit(Base):
+    """Audit log for node operations."""
+
+    __tablename__ = "nodes_audit"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    node_id = Column(String(500), nullable=True)
+    operation = Column(String(20), nullable=False)
+    timestamp = Column(DateTime(timezone=True), server_default=func.now())
+    tenant_id = Column(String(100), nullable=True)
+
+    __table_args__ = (
+        Index("ix_nodes_audit_node_id", "node_id"),
+        Index("ix_nodes_audit_tenant", "tenant_id"),
+    )
+
+
+# Architecture Analysis Tables
+
+
+class ArchitectureComponent(Base):
+    """Architecture component for dependency analysis."""
+
+    __tablename__ = "architecture_components"
+
+    id = Column(String(100), primary_key=True)
+    codebase_id = Column(
+        String(100), ForeignKey("codebases.id", ondelete="CASCADE"), nullable=False
+    )
+    name = Column(String(200), nullable=False)
+    files = Column(JSONB, nullable=False, default=list)
+    dependencies = Column(JSONB, nullable=False, default=list)
+    layer = Column(String(50), nullable=True)
+    tenant_id = Column(String(100), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+    __table_args__ = (
+        Index("ix_arch_components_codebase", "codebase_id"),
+        Index("ix_arch_components_layer", "layer"),
+        Index("ix_arch_components_tenant", "tenant_id"),
+    )
+
+
+class ArchitectureMetric(Base):
+    """Architecture quality metrics (instability, abstractness, distance)."""
+
+    __tablename__ = "architecture_metrics"
+
+    codebase_id = Column(
+        String(100), ForeignKey("codebases.id", ondelete="CASCADE"), primary_key=True
+    )
+    instability = Column(Float, nullable=False)
+    abstractness = Column(Float, nullable=False)
+    distance = Column(Float, nullable=False)
+    tenant_id = Column(String(100), nullable=True, index=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+
+class DetectedPattern(Base):
+    """Detected design patterns in codebase."""
+
+    __tablename__ = "detected_patterns"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    codebase_id = Column(
+        String(100), ForeignKey("codebases.id", ondelete="CASCADE"), nullable=False
+    )
+    name = Column(String(100), nullable=False)
+    location = Column(String(500), nullable=False)
+    confidence = Column(Float, nullable=False)
+    tenant_id = Column(String(100), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    __table_args__ = (
+        Index("ix_detected_patterns_codebase", "codebase_id"),
+        Index("ix_detected_patterns_name", "name"),
+        Index("ix_detected_patterns_tenant", "tenant_id"),
+    )
+
+
+class ExternalPackage(Base):
+    """External package dependencies with vulnerability tracking."""
+
+    __tablename__ = "external_packages"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    codebase_id = Column(
+        String(100), ForeignKey("codebases.id", ondelete="CASCADE"), nullable=False
+    )
+    name = Column(String(200), nullable=False)
+    current_version = Column(String(50), nullable=False)
+    latest_version = Column(String(50), nullable=True)
+    license = Column(String(100), nullable=True)
+    severity = Column(String(20), nullable=True)
+    tenant_id = Column(String(100), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+    __table_args__ = (
+        UniqueConstraint("codebase_id", "name", name="uq_external_packages_codebase_name"),
+        Index("ix_external_packages_codebase", "codebase_id"),
+        Index("ix_external_packages_severity", "severity"),
+    )
+
+
+class LayerAssignment(Base):
+    """Layer assignments for architecture analysis."""
+
+    __tablename__ = "layer_assignments"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    codebase_id = Column(
+        String(100), ForeignKey("codebases.id", ondelete="CASCADE"), nullable=False
+    )
+    layer_name = Column(String(50), nullable=False)
+    component_ids = Column(JSONB, nullable=False, default=list)
+    tenant_id = Column(String(100), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+    __table_args__ = (
+        UniqueConstraint("codebase_id", "layer_name", name="uq_layer_assignments_codebase_layer"),
+        Index("ix_layer_assignments_codebase", "codebase_id"),
+    )
+
+
+class QualityResult(Base):
+    """Quality analysis results."""
+
+    __tablename__ = "quality_results"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    codebase_id = Column(
+        String(100), ForeignKey("codebases.id", ondelete="CASCADE"), nullable=False
+    )
+    overall_score = Column(Float, nullable=False)
+    issues_count = Column(Integer, nullable=False)
+    issues_data = Column(JSONB, nullable=True)
+    summary_data = Column(JSONB, nullable=True)
+    tenant_id = Column(String(100), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    __table_args__ = (Index("ix_quality_results_codebase", "codebase_id"),)
+
+
+class AnalysisSession(Base):
+    """Analysis session tracking."""
+
+    __tablename__ = "analysis_sessions"
+
+    id = Column(String(100), primary_key=True)
+    codebase_id = Column(
+        String(100), ForeignKey("codebases.id", ondelete="CASCADE"), nullable=False
+    )
+    analysis_type = Column(String(50), nullable=False)
+    status = Column(String(20), nullable=False, default="running")
+    started_at = Column(DateTime(timezone=True), server_default=func.now())
+    completed_at = Column(DateTime(timezone=True), nullable=True)
+    error_message = Column(Text, nullable=True)
+    result_data = Column(JSONB, nullable=True)
+    tenant_id = Column(String(100), nullable=True)
+
+    __table_args__ = (
+        Index("ix_analysis_sessions_codebase", "codebase_id"),
+        Index("ix_analysis_sessions_type", "analysis_type"),
+        Index("ix_analysis_sessions_status", "status"),
+    )