patchwork-ai 0.1.0__py3-none-any.whl

agents/base.py

@@ -0,0 +1,106 @@
+import asyncio
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from models.schemas import UpgradeEpisode, AgentPlan, AgentReflection
+from memory.episodic import EpisodicMemory
+from utils.logger import logger
+
+@dataclass
+class WorkingMemory:
+    repo_path: str
+    package: str
+    from_version: str
+    to_version: str
+    plan: Optional[AgentPlan] = None
+    thought_trace: List[str] = field(default_factory=list)
+    tool_calls: List[Dict[str, Any]] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+    start_time: datetime = field(default_factory=datetime.utcnow)
+
+class BaseAgent(ABC):
+    def __init__(self, name: str, memory: EpisodicMemory):
+        self.name = name
+        self.memory = memory
+
+    @abstractmethod
+    async def detect(self, repo_path: str) -> List[Dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    async def analyze(self, state: WorkingMemory) -> Any:
+        pass
+
+    @abstractmethod
+    async def plan(self, state: WorkingMemory) -> AgentPlan:
+        pass
+
+    @abstractmethod
+    async def patch(self, state: WorkingMemory) -> bool:
+        pass
+
+    @abstractmethod
+    async def test(self, state: WorkingMemory) -> bool:
+        pass
+
+    @abstractmethod
+    async def pr(self, state: WorkingMemory) -> str:
+        pass
+
+    @abstractmethod
+    async def reflect(self, state: WorkingMemory, success: bool) -> AgentReflection:
+        pass
+
+    async def run_loop(self, repo_path: str, package: str, from_version: str, to_version: str):
+        state = WorkingMemory(repo_path, package, from_version, to_version)
+        logger.info("agent_loop_started", agent=self.name, package=package)
+
+        try:
+            # 1. Analyze
+            state.thought_trace.append("Starting analysis of breaking changes.")
+            await self.analyze(state)
+
+            # 2. Plan (with retry logic)
+            max_retries = 3
+            for attempt in range(max_retries):
+                state.plan = await self.plan(state)
+                
+                # 3. Patch
+                state.thought_trace.append(f"Attempting patch (Attempt {attempt+1}).")
+                if await self.patch(state):
+                    # 4. Test
+                    if await self.test(state):
+                        # 5. PR
+                        pr_url = await self.pr(state)
+                        await self.reflect(state, success=True)
+                        logger.info("upgrade_successful", package=package, pr=pr_url)
+                        return True
+                    else:
+                        state.errors.append(f"Tests failed on attempt {attempt+1}")
+                else:
+                    state.errors.append(f"Patching failed on attempt {attempt+1}")
+            
+            await self.reflect(state, success=False)
+            return False
+
+        except Exception as e:
+            logger.error("agent_loop_crashed", error=str(e))
+            state.errors.append(f"Crash: {str(e)}")
+            await self.reflect(state, success=False)
+            return False
+        finally:
+            # Final logging to episodic memory
+            episode = UpgradeEpisode(
+                repo_id=repo_path,
+                package=package,
+                from_version=from_version,
+                to_version=to_version,
+                outcome="success" if not state.errors else "failed_tests",
+                thought_trace=state.thought_trace,
+                tool_calls=state.tool_calls,
+                errors_encountered=state.errors,
+                time_spent_minutes=int((datetime.utcnow() - state.start_time).total_seconds() / 60),
+                context_tags=["auto-upgrade"]
+            )
+            await self.memory.create_episode(episode)

agents/dependency_surgeon.py

@@ -0,0 +1,78 @@
+from .base import BaseAgent, WorkingMemory
+from tools.package_detect import PackageDetect
+from tools.changelog_reader import ChangelogReader
+from tools.ast_analyzer import ASTAnalyzer
+from tools.sandbox import Sandbox
+from tools.git_miner import GitMiner
+from memory.episodic import EpisodicMemory
+from memory.procedural import ProceduralMemory
+from llm.gateway import LLMGateway
+from models.schemas import AgentPlan, AgentReflection, UpgradeRecipe
+from utils.logger import logger
+from typing import List, Dict, Any
+
+class DependencySurgeon(BaseAgent):
+    def __init__(self, llm_gateway: LLMGateway, episodic: EpisodicMemory, procedural: ProceduralMemory):
+        super().__init__("DependencySurgeon", episodic)
+        self.llm_gateway = llm_gateway
+        self.procedural = procedural
+        self.package_detect = PackageDetect()
+        self.changelog_reader = ChangelogReader(llm_gateway)
+        self.ast_analyzer = ASTAnalyzer()
+        self.sandbox = Sandbox()
+        self.git_miner = GitMiner()
+
+    async def detect(self, repo_path: str) -> List[Dict[str, Any]]:
+        return await self.package_detect.scan_pip(repo_path)
+
+    async def analyze(self, state: WorkingMemory):
+        raw_changelog = await self.changelog_reader.fetch_changelog(state.package, "pip")
+        state.thought_trace.append(f"Fetched changelog for {state.package}")
+        breaking_changes = await self.changelog_reader.extract_breaking_changes(
+            raw_changelog, state.from_version, state.to_version
+        )
+        state.thought_trace.append(f"Identified {len(breaking_changes)} breaking changes.")
+        return breaking_changes
+
+    async def plan(self, state: WorkingMemory) -> AgentPlan:
+        # Check for existing recipes
+        recipe = await self.procedural.match_recipe(state.package, f"{state.from_version}->{state.to_version}", [])
+        if recipe:
+            state.thought_trace.append(f"Matched existing recipe: {recipe.recipe_id}")
+            # Map recipe steps to AgentPlan
+            return AgentPlan(goal=f"Upgrade {state.package}", steps=[])
+        
+        # Or generate new plan via LLM
+        messages = [{"role": "user", "content": f"Create a plan to upgrade {state.package}"}]
+        return await self.llm_gateway.request(AgentPlan, messages)
+
+    async def patch(self, state: WorkingMemory) -> bool:
+        # Implementation of applying the plan
+        state.thought_trace.append("Applying codemods.")
+        return True # Mocked
+
+    async def test(self, state: WorkingMemory) -> bool:
+        passed, output, duration = await self.sandbox.run_tests(state.repo_path)
+        state.thought_trace.append(f"Tests {'passed' if passed else 'failed'} in {duration}s")
+        return passed
+
+    async def pr(self, state: WorkingMemory) -> str:
+        state.thought_trace.append("Creating PR branch and report.")
+        return "https://github.com/org/repo/pull/1"
+
+    async def reflect(self, state: WorkingMemory, success: bool) -> AgentReflection:
+        if success:
+            # Save successful recipe
+            recipe = UpgradeRecipe(
+                recipe_id=f"recipe-{state.package}",
+                created_from_episode=state.package,
+                confidence=0.9,
+                trigger={"package": state.package},
+                steps=[],
+                known_pitfalls=[],
+                verified_repos=[state.repo_path]
+            )
+            await self.procedural.save_recipe(recipe)
+        
+        messages = [{"role": "user", "content": f"Reflect on the upgrade of {state.package}. Success: {success}"}]
+        return await self.llm_gateway.request(AgentReflection, messages)

llm/cost_tracker.py

@@ -0,0 +1,15 @@
+from models.schemas import TokenUsage
+
+class CostTracker:
+    def __init__(self):
+        self.total_usage = TokenUsage()
+
+    def update(self, usage: TokenUsage):
+        self.total_usage.prompt_tokens += usage.prompt_tokens
+        self.total_usage.completion_tokens += usage.completion_tokens
+        self.total_usage.total_tokens += usage.total_tokens
+        # Simple cost calculation placeholder
+        self.total_usage.cost_usd += (usage.total_tokens / 1000) * 0.01 
+
+    def get_summary(self) -> TokenUsage:
+        return self.total_usage

llm/gateway.py

@@ -0,0 +1,40 @@
+from typing import Any, List, Type, TypeVar, Dict
+from pydantic import BaseModel
+from models.schemas import PatchworkConfig, ProviderType, TokenUsage
+from .providers import BaseProvider, AnthropicProvider, MistralProvider, GroqProvider
+from .cost_tracker import CostTracker
+from utils.logger import logger
+
+T = TypeVar("T", bound=BaseModel)
+
+class LLMGateway:
+    def __init__(self, config: PatchworkConfig):
+        self.config = config
+        self.cost_tracker = CostTracker()
+        self.providers: Dict[ProviderType, BaseProvider] = {
+            ProviderType.ANTHROPIC: AnthropicProvider(),
+            ProviderType.MISTRAL: MistralProvider(),
+            ProviderType.GROQ: GroqProvider(),
+        }
+
+    async def request(
+        self, 
+        response_model: Type[T], 
+        messages: List[dict], 
+        provider_type: ProviderType = None
+    ) -> T:
+        provider_type = provider_type or self.config.default_provider
+        provider = self.providers.get(provider_type)
+        
+        if not provider:
+            raise ValueError(f"Unsupported provider: {provider_type}")
+            
+        model_config = self.config.providers[provider_type]
+        
+        logger.info("llm_request", provider=provider_type, model=model_config.model_name)
+        
+        # In a real app, we'd extract token usage from the response
+        # instructor returns the model directly, but we can access _raw_response if needed
+        result = await provider.generate(response_model, messages, model_config)
+        
+        return result

llm/instructor_patch.py

@@ -0,0 +1,16 @@
+import instructor
+from typing import Any, Type, TypeVar
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+class StructuredOutputWrapper:
+    def __init__(self, client: Any):
+        self.client = instructor.patch(client)
+
+    async def chat_completion(self, response_model: Type[T], messages: list, **kwargs) -> T:
+        return await self.client.chat.completions.create(
+            response_model=response_model,
+            messages=messages,
+            **kwargs
+        )

llm/providers.py

@@ -0,0 +1,50 @@
+import os
+from abc import ABC, abstractmethod
+from typing import Any, List, Type, TypeVar
+from pydantic import BaseModel
+import httpx
+from anthropic import AsyncAnthropic
+from mistralai.async_client import MistralAsyncClient
+from groq import AsyncGroq
+import instructor
+
+from models.schemas import LLMModelConfig, ProviderType
+
+T = TypeVar("T", bound=BaseModel)
+
+class BaseProvider(ABC):
+    @abstractmethod
+    async def generate(self, response_model: Type[T], messages: List[dict], config: LLMModelConfig) -> T:
+        pass
+
+class AnthropicProvider(BaseProvider):
+    async def generate(self, response_model: Type[T], messages: List[dict], config: LLMModelConfig) -> T:
+        client = instructor.from_anthropic(AsyncAnthropic(api_key=config.api_key or os.environ.get("ANTHROPIC_API_KEY")))
+        return await client.chat.completions.create(
+            model=config.model_name,
+            max_tokens=config.max_tokens,
+            messages=messages,
+            response_model=response_model,
+            temperature=config.temperature,
+        )
+
+class MistralProvider(BaseProvider):
+    async def generate(self, response_model: Type[T], messages: List[dict], config: LLMModelConfig) -> T:
+        # Mistral support in instructor is via their own client
+        client = instructor.from_mistral(MistralAsyncClient(api_key=config.api_key or os.environ.get("MISTRAL_API_KEY")))
+        return await client.chat.completions.create(
+            model=config.model_name,
+            messages=messages,
+            response_model=response_model,
+            temperature=config.temperature,
+        )
+
+class GroqProvider(BaseProvider):
+    async def generate(self, response_model: Type[T], messages: List[dict], config: LLMModelConfig) -> T:
+        client = instructor.from_groq(AsyncGroq(api_key=config.api_key or os.environ.get("GROQ_API_KEY")))
+        return await client.chat.completions.create(
+            model=config.model_name,
+            messages=messages,
+            response_model=response_model,
+            temperature=config.temperature,
+        )

memory/episodic.py

@@ -0,0 +1,130 @@
+import aiosqlite
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional, Any
+from models.schemas import UpgradeEpisode
+from utils.logger import logger
+
+DB_PATH = Path(".patchwork/episodes.db")
+
+class EpisodicMemory:
+    def __init__(self, db_path: Path = DB_PATH):
+        self.db_path = db_path
+        self._initialized = False
+
+    async def _init_db(self):
+        if self._initialized:
+            return
+        
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        async with aiosqlite.connect(self.db_path) as db:
+            # Main episodes table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS episodes (
+                    episode_id TEXT PRIMARY KEY,
+                    timestamp TEXT,
+                    repo_id TEXT,
+                    package TEXT,
+                    from_version TEXT,
+                    to_version TEXT,
+                    outcome TEXT,
+                    thought_trace TEXT,
+                    tool_calls TEXT,
+                    errors_encountered TEXT,
+                    resolution TEXT,
+                    time_spent_minutes INTEGER,
+                    context_tags TEXT
+                )
+            """)
+            
+            # FTS5 virtual table for thought_trace
+            # Check if FTS5 table exists
+            cursor = await db.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='episodes_fts'")
+            if not await cursor.fetchone():
+                await db.execute("CREATE VIRTUAL TABLE episodes_fts USING fts5(episode_id, thought_trace)")
+            
+            await db.commit()
+        self._initialized = True
+
+    async def create_episode(self, episode: UpgradeEpisode):
+        await self._init_db()
+        try:
+            async with aiosqlite.connect(self.db_path) as db:
+                await db.execute(
+                    """INSERT INTO episodes (
+                        episode_id, timestamp, repo_id, package, from_version, to_version, 
+                        outcome, thought_trace, tool_calls, errors_encountered, 
+                        resolution, time_spent_minutes, context_tags
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                    (
+                        episode.episode_id,
+                        episode.timestamp.isoformat(),
+                        episode.repo_id,
+                        episode.package,
+                        episode.from_version,
+                        episode.to_version,
+                        episode.outcome,
+                        json.dumps(episode.thought_trace),
+                        json.dumps(episode.tool_calls),
+                        json.dumps(episode.errors_encountered),
+                        episode.resolution,
+                        episode.time_spent_minutes,
+                        json.dumps(episode.context_tags)
+                    )
+                )
+                # Update FTS
+                await db.execute(
+                    "INSERT INTO episodes_fts (episode_id, thought_trace) VALUES (?, ?)",
+                    (episode.episode_id, " ".join(episode.thought_trace))
+                )
+                await db.commit()
+            logger.info("episode_stored", episode_id=episode.episode_id, package=episode.package)
+        except Exception as e:
+            logger.error("episode_storage_failed", error=str(e), episode_id=episode.episode_id)
+            raise
+
+    async def get_similar_episodes(self, package: str, context_tags: List[str], limit: int = 5) -> List[UpgradeEpisode]:
+        await self._init_db()
+        episodes = []
+        try:
+            async with aiosqlite.connect(self.db_path) as db:
+                db.row_factory = aiosqlite.Row
+                # Simple similarity based on package and context tags intersection
+                # In a real app, this might use the FTS or semantic search
+                cursor = await db.execute(
+                    "SELECT * FROM episodes WHERE package = ? ORDER BY timestamp DESC LIMIT ?",
+                    (package, limit)
+                )
+                rows = await cursor.fetchall()
+                for row in rows:
+                    episodes.append(UpgradeEpisode(
+                        episode_id=row['episode_id'],
+                        timestamp=datetime.fromisoformat(row['timestamp']),
+                        repo_id=row['repo_id'],
+                        package=row['package'],
+                        from_version=row['from_version'],
+                        to_version=row['to_version'],
+                        outcome=row['outcome'],
+                        thought_trace=json.loads(row['thought_trace']),
+                        tool_calls=json.loads(row['tool_calls']),
+                        errors_encountered=json.loads(row['errors_encountered']),
+                        resolution=row['resolution'],
+                        time_spent_minutes=row['time_spent_minutes'],
+                        context_tags=json.loads(row['context_tags'])
+                    ))
+            return episodes
+        except Exception as e:
+            logger.error("get_similar_episodes_failed", error=str(e), package=package)
+            return []
+
+    async def update_episode_outcome(self, episode_id: str, outcome: str, resolution: Optional[str] = None):
+        await self._init_db()
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute(
+                "UPDATE episodes SET outcome = ?, resolution = ? WHERE episode_id = ?",
+                (outcome, resolution, episode_id)
+            )
+            await db.commit()
+        logger.info("episode_updated", episode_id=episode_id, outcome=outcome)

memory/procedural.py

@@ -0,0 +1,67 @@
+import yaml
+import json
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+from models.schemas import UpgradeRecipe
+from utils.logger import logger
+
+RECIPES_DIR = Path(".patchwork/recipes")
+
+class ProceduralMemory:
+    def __init__(self, recipes_dir: Path = RECIPES_DIR):
+        self.recipes_dir = recipes_dir
+        self.recipes_dir.mkdir(parents=True, exist_ok=True)
+
+    async def save_recipe(self, recipe: UpgradeRecipe):
+        try:
+            recipe_path = self.recipes_dir / f"{recipe.recipe_id}.yaml"
+            with open(recipe_path, "w") as f:
+                yaml.dump(recipe.model_dump(), f)
+            logger.info("recipe_saved", recipe_id=recipe.recipe_id)
+        except Exception as e:
+            logger.error("save_recipe_failed", error=str(e), recipe_id=recipe.recipe_id)
+            raise
+
+    async def load_recipe(self, recipe_id: str) -> Optional[UpgradeRecipe]:
+        recipe_path = self.recipes_dir / f"{recipe_id}.yaml"
+        if not recipe_path.exists():
+            return None
+        try:
+            with open(recipe_path, "r") as f:
+                data = yaml.safe_load(f)
+                return UpgradeRecipe(**data)
+        except Exception as e:
+            logger.error("load_recipe_failed", error=str(e), recipe_id=recipe_id)
+            return None
+
+    async def list_recipes(self) -> List[UpgradeRecipe]:
+        recipes = []
+        for file in self.recipes_dir.glob("*.yaml"):
+            recipe = await self.load_recipe(file.stem)
+            if recipe:
+                recipes.append(recipe)
+        return recipes
+
+    async def match_recipe(self, package: str, version_range: str, detected_patterns: List[str]) -> Optional[UpgradeRecipe]:
+        # Simple matching logic. Real implementation would use semantic similarity on patterns
+        all_recipes = await self.list_recipes()
+        best_match = None
+        highest_score = 0.0
+
+        for recipe in all_recipes:
+            if recipe.trigger.get("package") == package:
+                # Basic score based on pattern overlap
+                recipe_patterns = recipe.trigger.get("detected_patterns", [])
+                if not recipe_patterns:
+                    continue
+                
+                intersection = set(detected_patterns).intersection(set(recipe_patterns))
+                score = len(intersection) / len(set(detected_patterns).union(set(recipe_patterns)))
+                
+                if score > highest_score:
+                    highest_score = score
+                    best_match = recipe
+        
+        if best_match and highest_score > 0.5: # Threshold
+            return best_match
+        return None

memory/semantic.py

@@ -0,0 +1,99 @@
+import chromadb
+import httpx
+from pathlib import Path
+from typing import List, Optional
+from models.schemas import CodeFingerprint
+from models.config import get_config
+from utils.logger import logger
+
+CHROMA_PATH = Path(".patchwork/chroma")
+
+class SemanticMemory:
+    def __init__(self, persist_directory: Path = CHROMA_PATH):
+        self.persist_directory = persist_directory
+        self.client = chromadb.PersistentClient(path=str(self.persist_directory))
+        self.collection = self.client.get_or_create_collection(name="code_fingerprints")
+        self.config = get_config()
+
+    async def _get_embedding(self, text: str) -> List[float]:
+        provider = self.config.embeddings.get("provider")
+        model = self.config.embeddings.get("model")
+        api_key = self.config.embeddings.get("api_key")
+        base_url = self.config.embeddings.get("base_url")
+
+        if provider == "ollama":
+            url = f"{base_url or 'http://localhost:11434'}/api/embeddings"
+            async with httpx.AsyncClient() as client:
+                resp = await client.post(url, json={"model": model, "prompt": text})
+                resp.raise_for_status()
+                return resp.json()["embedding"]
+        elif provider == "mistral":
+            # Mistral embeddings
+            url = "https://api.mistral.ai/v1/embeddings"
+            async with httpx.AsyncClient() as client:
+                resp = await client.post(
+                    url, 
+                    headers={"Authorization": f"Bearer {api_key}"},
+                    json={"model": model, "input": [text]}
+                )
+                resp.raise_for_status()
+                return resp.json()["data"][0]["embedding"]
+        else:
+            # Fallback or placeholder for other providers
+            logger.warning("unsupported_embedding_provider", provider=provider)
+            return [0.0] * 1536 # Dummy
+
+    async def add_fingerprint(self, fingerprint: CodeFingerprint):
+        try:
+            # If embedding is not provided, generate it
+            if not fingerprint.embedding:
+                fingerprint.embedding = await self._get_embedding(fingerprint.code_snippet)
+            
+            self.collection.add(
+                ids=[fingerprint.fingerprint_id],
+                embeddings=[fingerprint.embedding],
+                metadatas=[{
+                    "repo_id": fingerprint.repo_id,
+                    "package": fingerprint.package,
+                    "file_path": fingerprint.file_path,
+                    "line_number": fingerprint.line_number,
+                    "pattern_type": fingerprint.pattern_type,
+                    "related_episodes": ",".join(fingerprint.related_episodes)
+                }],
+                documents=[fingerprint.code_snippet]
+            )
+            logger.info("fingerprint_added", id=fingerprint.fingerprint_id, package=fingerprint.package)
+        except Exception as e:
+            logger.error("add_fingerprint_failed", error=str(e))
+            raise
+
+    async def query_similar(self, package: str, query_text: str, n: int = 10) -> List[CodeFingerprint]:
+        try:
+            results = self.collection.query(
+                query_texts=[query_text],
+                n_results=n,
+                where={"package": package}
+            )
+            
+            fingerprints = []
+            for i in range(len(results["ids"][0])):
+                metadata = results["metadatas"][0][i]
+                fingerprints.append(CodeFingerprint(
+                    fingerprint_id=results["ids"][0][i],
+                    repo_id=metadata["repo_id"],
+                    package=metadata["package"],
+                    embedding=results["embeddings"][0][i] if results["embeddings"] else [],
+                    code_snippet=results["documents"][0][i],
+                    file_path=metadata["file_path"],
+                    line_number=metadata["line_number"],
+                    pattern_type=metadata["pattern_type"],
+                    related_episodes=metadata["related_episodes"].split(",") if metadata["related_episodes"] else []
+                ))
+            return fingerprints
+        except Exception as e:
+            logger.error("query_similar_failed", error=str(e))
+            return []
+
+    async def delete_by_repo(self, repo_id: str):
+        self.collection.delete(where={"repo_id": repo_id})
+        logger.info("fingerprints_deleted_for_repo", repo_id=repo_id)

memory/team.py

@@ -0,0 +1,63 @@
+import yaml
+from pathlib import Path
+from typing import Any, Optional, Dict, List
+from utils.logger import logger
+
+TEAM_MEMORY_PATH = Path(".patchwork/team_memory.yaml")
+
+DEFAULT_TEAM_MEMORY = {
+    "policies": {
+        "auto_commit": False,
+        "require_tests": True,
+        "allowed_upgrades": "minor",
+        "forbidden_packages": ["insecure-pkg", "deprecated-lib"]
+    },
+    "cursed_pairs": [
+        {"pkg1": "pydantic-v1", "pkg2": "pydantic-v2", "note": "Strict conflict in same environment"}
+    ]
+}
+
+class TeamMemory:
+    def __init__(self, path: Path = TEAM_MEMORY_PATH):
+        self.path = path
+        self._ensure_exists()
+
+    def _ensure_exists(self):
+        if not self.path.exists():
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.path, "w") as f:
+                yaml.dump(DEFAULT_TEAM_MEMORY, f)
+            logger.info("default_team_memory_created")
+
+    def _load(self) -> Dict[str, Any]:
+        with open(self.path, "r") as f:
+            return yaml.safe_load(f)
+
+    def _save(self, data: Dict[str, Any]):
+        with open(self.path, "w") as f:
+            yaml.dump(data, f)
+
+    async def get_policy(self, key: str) -> Any:
+        data = self._load()
+        return data.get("policies", {}).get(key)
+
+    async def update_policy(self, key: str, value: Any):
+        data = self._load()
+        if "policies" not in data:
+            data["policies"] = {}
+        data["policies"][key] = value
+        self._save(data)
+        logger.info("policy_updated", key=key, value=value)
+
+    async def is_forbidden(self, package: str) -> bool:
+        forbidden = await self.get_policy("forbidden_packages") or []
+        return package in forbidden
+
+    async def get_known_cursed_pair(self, pkg1: str, pkg2: str) -> Optional[Dict[str, str]]:
+        data = self._load()
+        cursed_pairs = data.get("cursed_pairs", [])
+        for pair in cursed_pairs:
+            if (pair["pkg1"] == pkg1 and pair["pkg2"] == pkg2) or \
+               (pair["pkg1"] == pkg2 and pair["pkg2"] == pkg1):
+                return pair
+        return None

models/config.py

@@ -0,0 +1,70 @@
+import os
+import re
+import yaml
+from pathlib import Path
+from typing import Optional, Any, Dict
+from .schemas import PatchworkConfig
+
+DEFAULT_CONFIG: Dict[str, Any] = {
+    "llm": {
+        "provider": "anthropic",
+        "model": "claude-3-opus-20240229",
+        "temperature": 0.0,
+        "max_tokens": 4096,
+        "api_key": "${ANTHROPIC_API_KEY}"
+    },
+    "embeddings": {
+        "provider": "anthropic",
+        "model": "claude-3-opus-20240229",
+        "api_key": "${ANTHROPIC_API_KEY}"
+    },
+    "budget": {
+        "max_daily_spend": 10.0,
+        "alert_at": 5.0
+    },
+    "team": {
+        "policies": {
+            "auto_commit": False,
+            "require_tests": True
+        }
+    }
+}
+
+class ConfigManager:
+    _instance: Optional[PatchworkConfig] = None
+
+    @classmethod
+    def interpolate_env_vars(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            return {k: cls.interpolate_env_vars(v) for k, v in data.items()}
+        elif isinstance(data, list):
+            return [cls.interpolate_env_vars(i) for i in data]
+        elif isinstance(data, str):
+            # Match ${VAR_NAME} or ${VAR_NAME:-default}
+            pattern = re.compile(r'\$\{(?P<var>[^}:]+)(?::-(?P<default>[^}]*))?\}')
+            
+            def replace(match):
+                var = match.group('var')
+                default = match.group('default')
+                return os.environ.get(var, default if default is not None else match.group(0))
+            
+            return pattern.sub(replace, data)
+        return data
+
+    @classmethod
+    def get_config(cls, config_path: str = ".patchwork/config.yaml") -> PatchworkConfig:
+        if cls._instance is None:
+            path = Path(config_path)
+            if not path.exists():
+                raw_data = DEFAULT_CONFIG
+            else:
+                with open(path, "r") as f:
+                    raw_data = yaml.safe_load(f)
+            
+            interpolated_data = cls.interpolate_env_vars(raw_data)
+            cls._instance = PatchworkConfig(**interpolated_data)
+        
+        return cls._instance
+
+def get_config() -> PatchworkConfig:
+    return ConfigManager.get_config()

models/schemas.py

@@ -0,0 +1,54 @@
+import uuid
+from datetime import datetime
+from typing import Literal, Optional, List, Dict, Union, Any
+from pydantic import BaseModel, Field, ConfigDict
+
+class BreakingChange(BaseModel):
+    version_from: str
+    version_to: str
+    change_type: Literal["removed", "renamed", "signature", "behavioral"]
+    old_pattern: str
+    new_pattern: Optional[str] = None
+    migration_note: str
+
+class UpgradeRecipe(BaseModel):
+    recipe_id: str
+    created_from_episode: str
+    confidence: float  # 0.0 to 1.0
+    trigger: Dict[str, Any]  # package, version range, detected patterns
+    steps: List[Dict[str, Any]]  # action, tool, script, description
+    known_pitfalls: List[str]
+    verified_repos: List[str]
+
+class UpgradeEpisode(BaseModel):
+    episode_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    repo_id: str
+    package: str
+    from_version: str
+    to_version: str
+    outcome: Literal["success", "failed_tests", "build_broken", "aborted"]
+    thought_trace: List[str]
+    tool_calls: List[Dict[str, Any]]
+    errors_encountered: List[str]
+    resolution: Optional[str] = None
+    time_spent_minutes: int
+    context_tags: List[str]
+
+class CodeFingerprint(BaseModel):
+    fingerprint_id: str
+    repo_id: str
+    package: str
+    embedding: List[float]
+    code_snippet: str
+    file_path: str
+    line_number: int
+    pattern_type: Literal["import", "function_call", "class_extension", "type_reference", "config"]
+    related_episodes: List[str]
+
+class PatchworkConfig(BaseModel):
+    model_config = ConfigDict(protected_namespaces=())
+    llm: Dict[str, Any]  # provider, model, api_key, base_url, temperature, max_tokens
+    embeddings: Dict[str, Any]  # provider, model, api_key, base_url
+    budget: Optional[Dict[str, Any]] = None  # max_daily_spend, alert_at
+    team: Optional[Dict[str, Any]] = None  # policies

patchwork_ai-0.1.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: patchwork-ai
+Version: 0.1.0
+Summary: Autonomous dependency upgrade agent
+License-File: LICENSE
+Author: coder11125
+Author-email: shashvathpuppala.21cmis0265@meruinternationalschool.com
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: aiosqlite (>=0.19.0,<0.20.0)
+Requires-Dist: anthropic (>=0.21.0,<0.22.0)
+Requires-Dist: chromadb (>=0.4.24,<0.5.0)
+Requires-Dist: gitpython (>=3.1.42,<4.0.0)
+Requires-Dist: groq (>=0.4.2,<0.5.0)
+Requires-Dist: httpx (>=0.27.0,<0.28.0)
+Requires-Dist: instructor (>=1.2.0,<2.0.0)
+Requires-Dist: mistralai (>=0.1.8,<0.2.0)
+Requires-Dist: pydantic (>=2.6.0,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: rich (>=13.7.1,<14.0.0)
+Requires-Dist: sqlalchemy[asyncio] (>=2.0.27,<3.0.0)
+Requires-Dist: structlog (>=24.1.0,<25.0.0)
+Requires-Dist: tree-sitter (>=0.21.0,<0.22.0)
+Requires-Dist: tree-sitter-python (>=0.21.0,<0.22.0)
+Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
+Description-Content-Type: text/markdown
+
+# Patchwork — Autonomous Dependency Surgery
+
+Patchwork is an autonomous agent designed to handle the "grunt work" of dependency upgrades. It doesn't just bump versions; it analyzes changelogs, identifies breaking changes, applies codemods, and verifies the upgrade with your test suite.
+
+## 🚀 Pitch
+Stop wasting hours on `v1 → v2` migrations. Let Patchwork perform the surgery.
+
+## 🛠 Architecture
+```text
+      +-----------+       +-------------------+
+      |  CLI/Web  | <---> |  Agent Loop       |
+      +-----------+       | (Plan-Patch-Test) |
+            ^             +---------+---------+
+            |                       |
+    +-------+-------+       +-------+-------+
+    | Episodic Mem  |       | Semantic Mem  |
+    | (SQLite/FTS)  |       | (Chroma/Code) |
+    +---------------+       +---------------+
+            |                       |
+    +-------+-------+       +-------+-------+
+    | LLM Gateway   | <---> | Tools         |
+    | (Anthropic,..) |       | (AST, Git,..) |
+    +---------------+       +---------------+
+```
+
+## 📦 Installation
+```bash
+pip install patchwork-cli
+# or via poetry
+poetry add patchwork
+```
+
+## ⚡ Quickstart
+1. **Initialize Config**:
+   ```bash
+   patchwork init
+   ```
+2. **Scan for Upgrades**:
+   ```bash
+   patchwork detect
+   ```
+3. **Perform Surgery**:
+   ```bash
+   patchwork upgrade pydantic --provider anthropic
+   ```
+
+## ⚙️ Configuration
+| Provider | Status | Config Key | Env Var |
+|---|---|---|---|
+| **Anthropic** | Native | `anthropic` | `ANTHROPIC_API_KEY` |
+| **Mistral** | Native | `mistral` | `MISTRAL_API_KEY` |
+| **Groq** | Native | `groq` | `GROQ_API_KEY` |
+| **Ollama** | Native | `ollama` | - |
+
+## 💰 Cost Transparency
+Patchwork logs every token. Run `patchwork cost` to see exactly what you're spending on your migrations.
+
+## 📄 License
+MIT
+

patchwork_ai-0.1.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agents/base.py,sha256=RSZPoJSqE-10vFdVjRgECAICRwbxUk6IVz8tXatio9U,3832
+agents/dependency_surgeon.py,sha256=sJYxE3bxrN0tsQTPKgCvOyenL2hKB1oupALfS1UisRY,3645
+llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+llm/cost_tracker.py,sha256=LRAISjwdy5aPUcjPk8PXsXTl1a8NT72BM_oLMApu2Js,549
+llm/gateway.py,sha256=mNPInLoMLL46Wn0HjPN7mrHH43kG-p8iqJEF_vMnvng,1547
+llm/instructor_patch.py,sha256=XoJdztk3E8elamfBOzs6NPm34aXsXg3oH6In4ppNcS0,495
+llm/providers.py,sha256=MZhTWeoFBCG7d1KsUvETKLvwhu_44IfOSmuGyEv4HHQ,2069
+memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memory/episodic.py,sha256=-eC_IGItyhR7puv9LoikzJjQOcBHzpLMsIShms-c8ts,5759
+memory/procedural.py,sha256=-u_xQ2K3VwKWtdx-l3xFQiRyfCKQ9r8Z45yiKoeYdxk,2670
+memory/semantic.py,sha256=ad-pJbRB9P5IU6KHdxFbW249sQGosKUJvWysXld7dXE,4440
+memory/team.py,sha256=JbViWGgVtfFoIBviKpQDTAotBZgd4UaJIZcPStGJ8EU,2111
+models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+models/config.py,sha256=UHqfdlazHIVJ6lSoAypEmhWEob01j-CyqsS2j-We6-w,2171
+models/schemas.py,sha256=78YSipqCRvyHWc5bZj6O7DwnO21gBJWgokVaaa2epLM,1907
+tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tools/ast_analyzer.py,sha256=oGct-2RS13rB-G7x7Uq9kpJ7REgStLf9ey1CJ22LLrs,1137
+tools/changelog_reader.py,sha256=mSeXIDOnpKuy_qSM2pnZuehK8ABpRDvK85gsmv_AhyA,1215
+tools/git_miner.py,sha256=VpWM6oZ7CrrC9Osi17xGit8Jo2fsSV4ay7tDvB2AkkY,1317
+tools/github_app.py,sha256=Q4f6loN8rACgI4TqJxdCFWvU-8qvoQP8-rbBKi6BoMY,2669
+tools/package_detect.py,sha256=Q2C2v86Vz314OlKFjB6PUl_dNPNfAoIhCIZUjGysqbA,1629
+tools/sandbox.py,sha256=FpIWaaBDZt2YY4Qe70fa3bY86-N76FR7njY0BE5IoxI,1285
+utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utils/logger.py,sha256=CLJOecoqF9BhmtGDK2GgIRGQXDn0qtk_tdfwcvjUsn0,707
+patchwork_ai-0.1.0.dist-info/METADATA,sha256=TTwLyqM-jfagVWrKPjN5NLLkbLcbl75DH8diMRfKNMY,3118
+patchwork_ai-0.1.0.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+patchwork_ai-0.1.0.dist-info/entry_points.txt,sha256=_XX-tG9EpvXxs9eI90SKullrpWdnLAZ0Vy8m2MOQlWE,37
+patchwork_ai-0.1.0.dist-info/licenses/LICENSE,sha256=q0biO4MJw239pgf-k81-tqTpyuy7CkGPP7MHljVP0tM,1067
+patchwork_ai-0.1.0.dist-info/RECORD,,

patchwork_ai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any

patchwork_ai-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+patchwork=cli:app
+

patchwork_ai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 coder11125
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tools/ast_analyzer.py

@@ -0,0 +1,31 @@
+import os
+import re
+from typing import List
+from models.schemas import CodeFingerprint
+from utils.logger import logger
+
+class ASTAnalyzer:
+    async def fingerprint_file(self, file_path: str, package: str) -> List[CodeFingerprint]:
+        # Mocked implementation of tree-sitter scanning
+        return []
+
+    async def find_call_sites(self, repo_path: str, package: str, function_name: str) -> List[Dict[str, Any]]:
+        # Recursive grep/search for function calls
+        return []
+
+    async def apply_codemod(self, file_path: str, old_pattern: str, new_pattern: str) -> bool:
+        try:
+            with open(file_path, "r") as f:
+                content = f.read()
+            
+            # Simple regex replacement for MVP
+            new_content = re.sub(re.escape(old_pattern), new_pattern, content)
+            
+            if new_content != content:
+                with open(file_path, "w") as f:
+                    f.write(new_content)
+                return True
+            return False
+        except Exception as e:
+            logger.error("codemod_failed", file=file_path, error=str(e))
+            return False

tools/changelog_reader.py

@@ -0,0 +1,29 @@
+import httpx
+from typing import List
+from models.schemas import BreakingChange
+from llm.gateway import LLMGateway
+from utils.logger import logger
+
+class ChangelogReader:
+    def __init__(self, llm_gateway: LLMGateway):
+        self.llm_gateway = llm_gateway
+
+    async def fetch_changelog(self, package: str, ecosystem: str) -> str:
+        # Mocking GitHub API call for releases/changelog
+        return f"Changelog for {package} ({ecosystem}):\n- Removed old_api\n- Renamed x to y"
+
+    async def extract_breaking_changes(self, changelog_text: str, from_ver: str, to_ver: str) -> List[BreakingChange]:
+        prompt = f"Extract breaking changes from this changelog between {from_ver} and {to_ver}:\n\n{changelog_text}"
+        messages = [{"role": "user", "content": prompt}]
+        # In reality, we'd use the LLMGateway to return a List[BreakingChange]
+        # For now, return a mock result
+        return [
+            BreakingChange(
+                version_from=from_ver,
+                version_to=to_ver,
+                change_type="removed",
+                old_pattern="old_api()",
+                new_pattern="new_api()",
+                migration_note="Use new_api instead"
+            )
+        ]

tools/git_miner.py

@@ -0,0 +1,30 @@
+import asyncio
+from typing import List, Dict, Any
+from utils.logger import logger
+
+class GitMiner:
+    async def _run_git(self, args: List[str], cwd: str) -> str:
+        process = await asyncio.create_subprocess_exec(
+            "git", *args, cwd=cwd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, _ = await process.communicate()
+        return stdout.decode()
+
+    async def get_line_history(self, repo_path: str, file_path: str, line_number: int) -> List[Dict[str, Any]]:
+        args = ["log", "-L", f"{line_number},{line_number}:{file_path}", "--format=%H|%an|%ai|%s"]
+        output = await self._run_git(args, repo_path)
+        commits = []
+        for line in output.strip().split("\n"):
+            if "|" in line:
+                h, a, d, m = line.split("|", 3)
+                commits.append({"hash": h, "author": a, "date": d, "message": m})
+        return commits
+
+    async def get_commit_context(self, repo_path: str, commit_hash: str) -> Dict[str, Any]:
+        output = await self._run_git(["show", "-s", "--format=%an|%s", commit_hash], repo_path)
+        if "|" in output:
+            author, message = output.strip().split("|", 1)
+            return {"author": author, "message": message, "hash": commit_hash}
+        return {}

tools/github_app.py

@@ -0,0 +1,83 @@
+import os
+from github import Github
+from pathlib import Path
+from typing import Dict, Any
+from utils.logger import logger
+
+class GitHubIntegration:
+    def __init__(self, token: str = None):
+        self.token = token or os.environ.get("GITHUB_TOKEN")
+        if not self.token:
+            logger.warning("github_token_missing", message="GITHUB_TOKEN env var not set")
+            self.gh = None
+        else:
+            self.gh = Github(self.token)
+
+    async def create_upgrade_pr(
+        self, 
+        repo_path: str, 
+        package: str, 
+        from_ver: str, 
+        to_ver: str, 
+        changes_summary: str, 
+        test_results: str,
+        danger_level: str = "green",
+        recipe_id: str = None
+    ) -> str:
+        if not self.gh:
+            raise ValueError("GitHub client not initialized. Check GITHUB_TOKEN.")
+
+        # In a real tool, we'd use GitPython to push branches
+        # For this implementation, we'll assume the branch is pushed or mock the PR creation
+        repo_name = self._get_repo_name(repo_path)
+        repo = self.gh.get_repo(repo_name)
+        
+        branch_name = f"patchwork/upgrade-{package}-{to_ver}"
+        base_branch = repo.default_branch
+        
+        pr_title = f"chore(deps): upgrade {package} {from_ver} → {to_ver}"
+        
+        pr_body = f"""
+## 🤖 Patchwork Upgrade Report
+
+### 📦 Package: `{package}`
+- **Upgrade:** `{from_ver}` → `{to_ver}`
+- **Danger Level:** {self._get_danger_emoji(danger_level)} `{danger_level.upper()}`
+
+### 🔍 Analysis
+{changes_summary}
+
+### 🛠 Breaking Changes Handled
+- Automated codemods applied for identified breaking changes.
+
+### 🧪 Test Results
+```
+{test_results}
+```
+
+---
+*Generated by [Patchwork](https://github.com/patchwork-agent/patchwork)*
+{"*Recipe used: " + recipe_id if recipe_id else ""}
+"""
+        
+        try:
+            # Note: This requires the branch to exist on remote
+            pr = repo.create_pull(
+                title=pr_title,
+                body=pr_body,
+                head=branch_name,
+                base=base_branch
+            )
+            pr.add_to_labels("dependencies", "patchwork")
+            logger.info("pr_created", url=pr.html_url)
+            return pr.html_url
+        except Exception as e:
+            logger.error("pr_creation_failed", error=str(e))
+            return f"Failed to create PR: {str(e)}"
+
+    def _get_repo_name(self, repo_path: str) -> str:
+        # Simplistic extraction from git config or path
+        return "owner/repo" # Mock
+
+    def _get_danger_emoji(self, level: str) -> str:
+        return {"green": "🟢", "yellow": "🟡", "red": "🔴"}.get(level.lower(), "⚪")

tools/package_detect.py

@@ -0,0 +1,43 @@
+import asyncio
+import httpx
+from typing import List, Dict, Any, Optional
+from utils.logger import logger
+
+class PackageDetect:
+    async def _run_cmd(self, cmd: List[str], cwd: str) -> str:
+        process = await asyncio.create_subprocess_exec(
+            *cmd, cwd=cwd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, _ = await process.communicate()
+        return stdout.decode()
+
+    async def scan_npm(self, repo_path: str) -> List[Dict[str, Any]]:
+        output = await self._run_cmd(["npm", "outdated", "--json"], repo_path)
+        if not output: return []
+        data = json.loads(output)
+        return [{"package": k, **v} for k, v in data.items()]
+
+    async def scan_pip(self, repo_path: str) -> List[Dict[str, Any]]:
+        output = await self._run_cmd(["pip", "list", "--outdated", "--format=json"], repo_path)
+        if not output: return []
+        return json.loads(output)
+
+    async def scan_poetry(self, repo_path: str) -> List[Dict[str, Any]]:
+        # Simulation since poetry output varies
+        return []
+
+    async def check_cve(self, package: str, version: str) -> List[Dict[str, Any]]:
+        async with httpx.AsyncClient() as client:
+            url = "https://api.osv.dev/v1/query"
+            payload = {
+                "version": version,
+                "package": {"name": package}
+            }
+            try:
+                resp = await client.post(url, json=payload)
+                resp.raise_for_status()
+                return resp.json().get("vulns", [])
+            except Exception:
+                return []

tools/sandbox.py

@@ -0,0 +1,34 @@
+import asyncio
+import json
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import List, Dict, Any, Tuple
+from utils.logger import logger
+
+class Sandbox:
+    async def run_tests(self, repo_path: str, test_command: str = "pytest") -> Tuple[bool, str, int]:
+        start_time = asyncio.get_event_loop().time()
+        
+        # In a real MVP, we'd use git worktree to avoid messing with the current checkout
+        # But for this implementation, we'll simulate running in the provided path
+        logger.info("running_tests", repo=repo_path, command=test_command)
+        
+        try:
+            process = await asyncio.create_subprocess_shell(
+                test_command,
+                cwd=repo_path,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await process.communicate()
+            
+            duration = int(asyncio.get_event_loop().time() - start_time)
+            output = stdout.decode() + "\n" + stderr.decode()
+            passed = process.returncode == 0
+            
+            return passed, output, duration
+        except Exception as e:
+            logger.error("test_execution_failed", error=str(e))
+            return False, str(e), 0

utils/logger.py

@@ -0,0 +1,22 @@
+import structlog
+import logging
+import sys
+
+def setup_logger():
+    structlog.configure(
+        processors=[
+            structlog.contextvars.merge_contextvars,
+            structlog.processors.add_log_level,
+            structlog.processors.StackInfoRenderer(),
+            structlog.dev.set_exc_info,
+            structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S", utc=False),
+            structlog.dev.ConsoleRenderer()
+        ],
+        wrapper_class=structlog.make_filtering_bound_logger(logging.NOTSET),
+        context_class=dict,
+        logger_factory=structlog.PrintLoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+    return structlog.get_logger()
+
+logger = setup_logger()