tapps-agents 3.5.41__py3-none-any.whl → 3.6.0__py3-none-any.whl

tapps_agents/workflow/migration_utils.py

@@ -1,116 +1,116 @@
-"""
-Migration Utilities for Artifact Migration.
-
-Provides utilities for migrating artifacts from dataclass format to Pydantic models.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, TypeVar
-
-from pydantic import BaseModel
-
-logger = logging.getLogger(__name__)
-
-T = TypeVar("T", bound=BaseModel)
-
-
-def migrate_artifact_from_dataclass(
-    data: dict[str, Any],
-    artifact_type: type[T],
-) -> T:
-    """
-    Migrate old dataclass artifact to Pydantic model.
-
-    This function attempts to convert old dataclass-formatted artifact data
-    to the new Pydantic model format. It handles:
-    - Schema version differences
-    - Field name changes
-    - Type conversions (strings to enums, etc.)
-    - Providing defaults for new fields
-
-    Args:
-        data: Dictionary containing artifact data (from old format)
-        artifact_type: Pydantic model class to migrate to
-
-    Returns:
-        Migrated Pydantic model instance
-
-    Raises:
-        ValueError: If migration fails and model validation fails
-    """
-    # First, try direct Pydantic validation (for already-migrated artifacts)
-    try:
-        return artifact_type.model_validate(data)
-    except Exception as e:
-        logger.debug(f"Direct validation failed, attempting migration: {e}")
-
-    # If direct validation fails, try using the model's from_dict method if it exists
-    # (many artifacts have backward-compatible from_dict methods)
-    if hasattr(artifact_type, "from_dict"):
-        try:
-            result = artifact_type.from_dict(data)
-            logger.debug(f"Migrated {artifact_type.__name__} using from_dict method")
-            return result
-        except Exception as e:
-            logger.warning(f"from_dict migration failed for {artifact_type.__name__}: {e}")
-
-    # As a last resort, try validation again (might work with some fields)
-    # This allows Pydantic to use defaults for missing fields
-    try:
-        return artifact_type.model_validate(data, strict=False)
-    except Exception as e:
-        logger.error(f"Migration failed for {artifact_type.__name__}: {e}")
-        raise ValueError(f"Failed to migrate artifact to {artifact_type.__name__}: {e}") from e
-
-
-def detect_artifact_schema_version(data: dict[str, Any]) -> str:
-    """
-    Detect artifact schema version from data.
-
-    Args:
-        data: Artifact data dictionary
-
-    Returns:
-        Schema version string (defaults to "1.0" if not found)
-    """
-    return data.get("schema_version", "1.0")
-
-
-def is_pydantic_artifact(data: dict[str, Any]) -> bool:
-    """
-    Check if artifact data appears to be in Pydantic format.
-
-    This is a heuristic check - artifacts with enum values (not strings)
-    are likely already migrated.
-
-    Args:
-        data: Artifact data dictionary
-
-    Returns:
-        True if artifact appears to be in Pydantic format
-    """
-    # Check for common enum fields that should be strings in old format
-    # but enum instances in new format
-    status_fields = ["status", "operation_type", "priority"]
-    for field in status_fields:
-        if field in data:
-            value = data[field]
-            # Enums have a 'value' attribute
-            if hasattr(value, "value"):
-                return True
-            # Or they might be enum instances directly
-            if hasattr(value, "name") and hasattr(value, "value"):
-                return True
-
-    # Check for structured nested objects (Pydantic models)
-    # Old format would have plain dicts, new format might have model instances
-    nested_fields = ["plan", "metadata", "inputs", "results"]
-    for field in nested_fields:
-        if field in data:
-            value = data[field]
-            if isinstance(value, BaseModel):
-                return True
-
-    return False
+"""
+Migration Utilities for Artifact Migration.
+
+Provides utilities for migrating artifacts from dataclass format to Pydantic models.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, TypeVar
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def migrate_artifact_from_dataclass(
+    data: dict[str, Any],
+    artifact_type: type[T],
+) -> T:
+    """
+    Migrate old dataclass artifact to Pydantic model.
+
+    This function attempts to convert old dataclass-formatted artifact data
+    to the new Pydantic model format. It handles:
+    - Schema version differences
+    - Field name changes
+    - Type conversions (strings to enums, etc.)
+    - Providing defaults for new fields
+
+    Args:
+        data: Dictionary containing artifact data (from old format)
+        artifact_type: Pydantic model class to migrate to
+
+    Returns:
+        Migrated Pydantic model instance
+
+    Raises:
+        ValueError: If migration fails and model validation fails
+    """
+    # First, try direct Pydantic validation (for already-migrated artifacts)
+    try:
+        return artifact_type.model_validate(data)
+    except Exception as e:
+        logger.debug(f"Direct validation failed, attempting migration: {e}")
+
+    # If direct validation fails, try using the model's from_dict method if it exists
+    # (many artifacts have backward-compatible from_dict methods)
+    if hasattr(artifact_type, "from_dict"):
+        try:
+            result = artifact_type.from_dict(data)
+            logger.debug(f"Migrated {artifact_type.__name__} using from_dict method")
+            return result
+        except Exception as e:
+            logger.warning(f"from_dict migration failed for {artifact_type.__name__}: {e}")
+
+    # As a last resort, try validation again (might work with some fields)
+    # This allows Pydantic to use defaults for missing fields
+    try:
+        return artifact_type.model_validate(data, strict=False)
+    except Exception as e:
+        logger.error(f"Migration failed for {artifact_type.__name__}: {e}")
+        raise ValueError(f"Failed to migrate artifact to {artifact_type.__name__}: {e}") from e
+
+
+def detect_artifact_schema_version(data: dict[str, Any]) -> str:
+    """
+    Detect artifact schema version from data.
+
+    Args:
+        data: Artifact data dictionary
+
+    Returns:
+        Schema version string (defaults to "1.0" if not found)
+    """
+    return data.get("schema_version", "1.0")
+
+
+def is_pydantic_artifact(data: dict[str, Any]) -> bool:
+    """
+    Check if artifact data appears to be in Pydantic format.
+
+    This is a heuristic check - artifacts with enum values (not strings)
+    are likely already migrated.
+
+    Args:
+        data: Artifact data dictionary
+
+    Returns:
+        True if artifact appears to be in Pydantic format
+    """
+    # Check for common enum fields that should be strings in old format
+    # but enum instances in new format
+    status_fields = ["status", "operation_type", "priority"]
+    for field in status_fields:
+        if field in data:
+            value = data[field]
+            # Enums have a 'value' attribute
+            if hasattr(value, "value"):
+                return True
+            # Or they might be enum instances directly
+            if hasattr(value, "name") and hasattr(value, "value"):
+                return True
+
+    # Check for structured nested objects (Pydantic models)
+    # Old format would have plain dicts, new format might have model instances
+    nested_fields = ["plan", "metadata", "inputs", "results"]
+    for field in nested_fields:
+        if field in data:
+            value = data[field]
+            if isinstance(value, BaseModel):
+                return True
+
+    return False

tapps_agents/workflow/models.py

@@ -1,148 +1,148 @@
-"""
-Workflow models - Data structures for workflow definitions.
-"""
-
-from dataclasses import dataclass, field
-from datetime import datetime
-from enum import Enum
-from typing import Any, Literal
-
-
-class WorkflowType(Enum):
-    """Workflow type."""
-
-    GREENFIELD = "greenfield"
-    BROWNFIELD = "brownfield"
-    HYBRID = "hybrid"
-
-
-class StepCondition(Enum):
-    """Step condition type."""
-
-    REQUIRED = "required"
-    OPTIONAL = "optional"
-    CONDITIONAL = "conditional"
-
-
-@dataclass
-class Artifact:
-    """Workflow artifact."""
-
-    name: str
-    path: str
-    status: str = "pending"  # pending, complete, failed
-    created_by: str | None = None
-    created_at: datetime | None = None
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass
-class WorkflowStep:
-    """A single workflow step."""
-
-    id: str
-    agent: str
-    action: str
-    context_tier: int = 2
-    creates: list[str] = field(default_factory=list)
-    requires: list[str] = field(default_factory=list)
-    condition: str = "required"  # required, optional, conditional
-    next: str | None = None
-    gate: dict[str, Any] | None = None
-    consults: list[str] = field(default_factory=list)
-    optional_steps: list[str] = field(default_factory=list)
-    notes: str | None = None
-    repeats: bool = False
-    scoring: dict[str, Any] | None = None
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass
-class WorkflowSettings:
-    """Workflow settings."""
-
-    quality_gates: bool = True
-    code_scoring: bool = True
-    context_tier_default: int = 2
-    auto_detect: bool = True
-
-
-@dataclass
-class Workflow:
-    """Workflow definition."""
-
-    id: str
-    name: str
-    description: str
-    version: str
-    type: WorkflowType = WorkflowType.GREENFIELD
-    settings: WorkflowSettings = field(default_factory=WorkflowSettings)
-    steps: list[WorkflowStep] = field(default_factory=list)
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass
-class StepExecution:
-    """Execution tracking for a workflow step."""
-
-    step_id: str
-    agent: str
-    action: str
-    started_at: datetime
-    completed_at: datetime | None = None
-    duration_seconds: float | None = None
-    status: str = "running"  # running, completed, failed, skipped
-    error: str | None = None
-
-
-@dataclass
-class StepResult:
-    """Result of step execution with proper error handling.
-
-    This class represents the outcome of executing a workflow step,
-    including success/failure status, error details, and artifacts created.
-    Used by CursorExecutor to properly track step outcomes and halt
-    workflows when required steps fail.
-    """
-
-    step_id: str
-    status: Literal["completed", "failed", "skipped"]
-    success: bool
-    duration: float
-    started_at: datetime
-    completed_at: datetime
-    error: str | None = None
-    error_traceback: str | None = None
-    artifacts: list[str] = field(default_factory=list)
-    skip_reason: str | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for serialization."""
-        return {
-            "step_id": self.step_id,
-            "status": self.status,
-            "success": self.success,
-            "duration": self.duration,
-            "started_at": self.started_at.isoformat(),
-            "completed_at": self.completed_at.isoformat(),
-            "error": self.error,
-            "error_traceback": self.error_traceback,
-            "artifacts": self.artifacts,
-            "skip_reason": self.skip_reason,
-        }
-
-
-@dataclass
-class WorkflowState:
-    """Workflow execution state."""
-
-    workflow_id: str
-    started_at: datetime
-    current_step: str | None = None
-    completed_steps: list[str] = field(default_factory=list)
-    skipped_steps: list[str] = field(default_factory=list)
-    artifacts: dict[str, Artifact] = field(default_factory=dict)
-    variables: dict[str, Any] = field(default_factory=dict)
-    status: str = "running"  # running, paused, completed, failed
-    error: str | None = None
-    step_executions: list[StepExecution] = field(default_factory=list)
+"""
+Workflow models - Data structures for workflow definitions.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Literal
+
+
+class WorkflowType(Enum):
+    """Workflow type."""
+
+    GREENFIELD = "greenfield"
+    BROWNFIELD = "brownfield"
+    HYBRID = "hybrid"
+
+
+class StepCondition(Enum):
+    """Step condition type."""
+
+    REQUIRED = "required"
+    OPTIONAL = "optional"
+    CONDITIONAL = "conditional"
+
+
+@dataclass
+class Artifact:
+    """Workflow artifact."""
+
+    name: str
+    path: str
+    status: str = "pending"  # pending, complete, failed
+    created_by: str | None = None
+    created_at: datetime | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class WorkflowStep:
+    """A single workflow step."""
+
+    id: str
+    agent: str
+    action: str
+    context_tier: int = 2
+    creates: list[str] = field(default_factory=list)
+    requires: list[str] = field(default_factory=list)
+    condition: str = "required"  # required, optional, conditional
+    next: str | None = None
+    gate: dict[str, Any] | None = None
+    consults: list[str] = field(default_factory=list)
+    optional_steps: list[str] = field(default_factory=list)
+    notes: str | None = None
+    repeats: bool = False
+    scoring: dict[str, Any] | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class WorkflowSettings:
+    """Workflow settings."""
+
+    quality_gates: bool = True
+    code_scoring: bool = True
+    context_tier_default: int = 2
+    auto_detect: bool = True
+
+
+@dataclass
+class Workflow:
+    """Workflow definition."""
+
+    id: str
+    name: str
+    description: str
+    version: str
+    type: WorkflowType = WorkflowType.GREENFIELD
+    settings: WorkflowSettings = field(default_factory=WorkflowSettings)
+    steps: list[WorkflowStep] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class StepExecution:
+    """Execution tracking for a workflow step."""
+
+    step_id: str
+    agent: str
+    action: str
+    started_at: datetime
+    completed_at: datetime | None = None
+    duration_seconds: float | None = None
+    status: str = "running"  # running, completed, failed, skipped
+    error: str | None = None
+
+
+@dataclass
+class StepResult:
+    """Result of step execution with proper error handling.
+
+    This class represents the outcome of executing a workflow step,
+    including success/failure status, error details, and artifacts created.
+    Used by CursorExecutor to properly track step outcomes and halt
+    workflows when required steps fail.
+    """
+
+    step_id: str
+    status: Literal["completed", "failed", "skipped"]
+    success: bool
+    duration: float
+    started_at: datetime
+    completed_at: datetime
+    error: str | None = None
+    error_traceback: str | None = None
+    artifacts: list[str] = field(default_factory=list)
+    skip_reason: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "step_id": self.step_id,
+            "status": self.status,
+            "success": self.success,
+            "duration": self.duration,
+            "started_at": self.started_at.isoformat(),
+            "completed_at": self.completed_at.isoformat(),
+            "error": self.error,
+            "error_traceback": self.error_traceback,
+            "artifacts": self.artifacts,
+            "skip_reason": self.skip_reason,
+        }
+
+
+@dataclass
+class WorkflowState:
+    """Workflow execution state."""
+
+    workflow_id: str
+    started_at: datetime
+    current_step: str | None = None
+    completed_steps: list[str] = field(default_factory=list)
+    skipped_steps: list[str] = field(default_factory=list)
+    artifacts: dict[str, Artifact] = field(default_factory=dict)
+    variables: dict[str, Any] = field(default_factory=dict)
+    status: str = "running"  # running, paused, completed, failed
+    error: str | None = None
+    step_executions: list[StepExecution] = field(default_factory=list)