attune-ai 2.1.4__py3-none-any.whl → 2.2.0__py3-none-any.whl

attune/workflows/manage_docs.py

@@ -1,87 +0,0 @@
-"""Manage documentation
-
-Stages:
-1. process - Process
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import logging
-from typing import Any
-
-from attune.workflows.base import BaseWorkflow, ModelTier
-
-logger = logging.getLogger(__name__)
-
-
-class ManageDocsWorkflow(BaseWorkflow):
-    """Manage documentation
-
-
-    Usage:
-        workflow = ManageDocsWorkflow()
-        result = await workflow.execute(
-            # Add parameters here
-        )
-    """
-
-    name = "manage-docs"
-    description = "Manage documentation"
-    stages = ["process"]
-    tier_map = {
-        "process": ModelTier.CAPABLE,
-    }
-
-    def __init__(
-        self,
-        **kwargs: Any,
-    ):
-        """Initialize manage-docs workflow.
-
-        Args:
-            **kwargs: Additional arguments passed to BaseWorkflow
-
-        """
-        super().__init__(**kwargs)
-
-    async def run_stage(
-        self,
-        stage_name: str,
-        tier: ModelTier,
-        input_data: Any,
-    ) -> tuple[Any, int, int]:
-        """Execute the single processing stage."""
-        if stage_name == "process":
-            return await self._process(input_data, tier)
-        raise ValueError(f"Unknown stage: {stage_name}")
-
-    async def _process(
-        self,
-        input_data: Any,
-        tier: ModelTier,
-    ) -> tuple[Any, int, int]:
-        """Process the input data.
-
-        Args:
-            input_data: Input data to process
-            tier: Model tier to use
-
-        Returns:
-            Tuple of (result, input_tokens, output_tokens)
-
-        """
-        # TODO: Implement processing logic
-        prompt = f"Process this input: {input_data}"
-
-        # Use LLM executor if available
-        if self._executor:
-            result = await self._executor.run(
-                task_type="workflow_stage",
-                prompt=prompt,
-                tier=tier.to_unified() if hasattr(tier, "to_unified") else tier,
-            )
-            return result.content, result.input_tokens, result.output_tokens
-
-        # Fallback to basic processing
-        return {"result": "Processed", "input": input_data}, 0, 0

attune/workflows/test5.py

@@ -1,125 +0,0 @@
-"""scan code for bugs or opportunities to improve the code and generate a detailed report.
-
-Stages:
-1. analyze - Analyze
-2. process - Process
-3. test - Test
-4. report - Report
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import logging
-from typing import Any
-
-from attune.workflows.base import BaseWorkflow, ModelTier
-
-logger = logging.getLogger(__name__)
-
-
-class Test5Workflow(BaseWorkflow):
-    """scan code for bugs or opportunities to improve the code and generate a detailed report.
-
-
-    Usage:
-        workflow = Test5Workflow()
-        result = await workflow.execute(
-            # Add parameters here
-        )
-    """
-
-    name = "test5"
-    description = (
-        "scan code for bugs or opportunities to improve the code and generate a detailed report."
-    )
-    stages = ["analyze", "fix"]
-    tier_map = {
-        "analyze": ModelTier.CAPABLE,
-        "fix": ModelTier.CAPABLE,
-    }
-
-    def __init__(
-        self,
-        **kwargs: Any,
-    ):
-        """Initialize test5 workflow.
-
-        Args:
-            **kwargs: Additional arguments passed to BaseWorkflow
-
-        """
-        super().__init__(**kwargs)
-        self._crew: Any = None
-        self._crew_available = False
-
-    async def _initialize_crew(self) -> None:
-        """Initialize the Refactoring Crew."""
-        if self._crew is not None:
-            return
-
-        try:
-            from attune_llm.agent_factory.crews.refactoring import RefactoringCrew
-
-            self._crew = RefactoringCrew()
-            self._crew_available = True
-            logger.info("RefactoringCrew initialized successfully")
-        except ImportError as e:
-            logger.warning(f"RefactoringCrew not available: {e}")
-            self._crew_available = False
-
-    async def run_stage(
-        self,
-        stage_name: str,
-        tier: ModelTier,
-        input_data: Any,
-    ) -> tuple[Any, int, int]:
-        """Execute RefactoringCrew for the given stage."""
-        await self._initialize_crew()
-
-        if not self._crew_available:
-            return {"error": "Crew not available"}, 0, 0
-
-        try:
-            if stage_name == "analyze":
-                # Use RefactoringCrew's analyze method
-                result = await self._crew.analyze(
-                    code=input_data.get("code", ""), file_path=input_data.get("path", ".")
-                )
-
-                return (
-                    {
-                        "findings": [
-                            {
-                                "title": f.title,
-                                "description": f.description,
-                                "category": f.category.value,
-                                "severity": f.severity.value,
-                                "file": f.file_path,
-                                "lines": f"{f.start_line}-{f.end_line}",
-                            }
-                            for f in result.findings
-                        ],
-                        "summary": f"Found {len(result.findings)} refactoring opportunities",
-                    },
-                    0,
-                    0,
-                )
-
-            elif stage_name == "fix":
-                # Apply refactorings (placeholder for now)
-                return (
-                    {
-                        "status": "Refactoring recommendations ready",
-                        "message": "Review findings from analyze stage to apply fixes",
-                    },
-                    0,
-                    0,
-                )
-
-            else:
-                return {"error": f"Unknown stage: {stage_name}"}, 0, 0
-
-        except Exception as e:
-            logger.error(f"Crew execution failed: {e}")
-            return {"error": str(e)}, 0, 0