evolution-sdk 0.8.0__py3-none-any.whl

evolution/__init__.py

@@ -0,0 +1,102 @@
+"""
+Evolution Python SDK — AI-Native Version Control Platform.
+"Version Intelligence, Not Code."
+"""
+
+from pathlib import Path
+
+from evolution.adapters import (
+    from_anthropic,
+    from_crewai,
+    from_langchain,
+    from_llamaindex,
+    from_openai,
+)
+from evolution.capture import RecordContextManager, record, track
+from evolution.evaluators import (
+    DimensionScore,
+    EvaluationReport,
+    SemanticEvaluator,
+)
+from evolution.exceptions import (
+    ArtifactNotFoundError,
+    CommandExecutionError,
+    EvolutionError,
+    ManifestNotFoundError,
+    ManifestValidationError,
+    RepositoryAlreadyExistsError,
+    RepositoryNotFoundError,
+)
+from evolution.models import (
+    BaseArtifact,
+    EvaluationResult,
+    EvaluationScore,
+    Execution,
+    Manifest,
+    ManifestArtifacts,
+    MemoryArtifact,
+    ModelConfigArtifact,
+    PolicyArtifact,
+    PromptArtifact,
+    RetrievalArtifact,
+    TokenUsage,
+    ToolArtifact,
+    artifact_from_dict,
+    compute_blob_hash,
+)
+from evolution.repository import CommitInfo, RepoStatus, Repository
+
+__version__ = "0.8.0"
+
+
+def init(path: Path | str = ".", name: str = "ai-intelligence") -> Repository:
+    """Convenience function to initialize a new Evolution repository."""
+    return Repository.init(path=path, name=name)
+
+
+def open(path: Path | str = ".") -> Repository:
+    """Convenience function to open an existing Evolution repository."""
+    return Repository.open(path=path)
+
+
+__all__ = [
+    "ArtifactNotFoundError",
+    "BaseArtifact",
+    "CommandExecutionError",
+    "CommitInfo",
+    "DimensionScore",
+    "EvaluationReport",
+    "EvaluationResult",
+    "EvaluationScore",
+    "EvolutionError",
+    "Execution",
+    "Manifest",
+    "ManifestArtifacts",
+    "ManifestNotFoundError",
+    "ManifestValidationError",
+    "MemoryArtifact",
+    "ModelConfigArtifact",
+    "PolicyArtifact",
+    "PromptArtifact",
+    "RecordContextManager",
+    "RepoStatus",
+    "Repository",
+    "RepositoryAlreadyExistsError",
+    "RepositoryNotFoundError",
+    "RetrievalArtifact",
+    "SemanticEvaluator",
+    "TokenUsage",
+    "ToolArtifact",
+    "__version__",
+    "artifact_from_dict",
+    "compute_blob_hash",
+    "from_anthropic",
+    "from_crewai",
+    "from_langchain",
+    "from_llamaindex",
+    "from_openai",
+    "init",
+    "open",
+    "record",
+    "track",
+]

evolution/adapters/__init__.py

@@ -0,0 +1,28 @@
+"""
+Evolution framework adapters package.
+"""
+
+from evolution.adapters.base import BaseAdapter
+from evolution.adapters.crewai import CrewAIAdapter, from_crewai
+from evolution.adapters.direct import (
+    AnthropicAdapter,
+    OpenAIAdapter,
+    from_anthropic,
+    from_openai,
+)
+from evolution.adapters.langchain import LangChainAdapter, from_langchain
+from evolution.adapters.llamaindex import LlamaIndexAdapter, from_llamaindex
+
+__all__ = [
+    "AnthropicAdapter",
+    "BaseAdapter",
+    "CrewAIAdapter",
+    "LangChainAdapter",
+    "LlamaIndexAdapter",
+    "OpenAIAdapter",
+    "from_anthropic",
+    "from_crewai",
+    "from_langchain",
+    "from_llamaindex",
+    "from_openai",
+]

evolution/adapters/base.py

@@ -0,0 +1,21 @@
+"""
+Base protocol and abstract class for framework adapters.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from evolution.models.manifest import Manifest
+
+
+class BaseAdapter(ABC):
+    """Abstract base class for converting framework-specific AI configurations
+    into standard Intelligence Manifests (Spec v1.0).
+    """
+
+    @abstractmethod
+    def to_manifest(self, obj: Any, name: str = "ai-intelligence", description: str = "") -> Manifest:
+        """Converts a framework-specific object into an Evolution Manifest."""
+        pass

evolution/adapters/crewai.py

@@ -0,0 +1,86 @@
+"""
+CrewAI framework adapter for extracting multi-agent Intelligence Manifests.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from evolution.adapters.base import BaseAdapter
+from evolution.models.artifacts import (
+    ModelConfigArtifact,
+    PromptArtifact,
+    ToolArtifact,
+)
+from evolution.models.manifest import Manifest
+
+
+class CrewAIAdapter(BaseAdapter):
+    """Converts CrewAI Crews, Agents, and Tasks into a multi-agent Intelligence Manifest."""
+
+    def to_manifest(self, obj: Any, name: str = "crewai-multi-agent", description: str = "") -> Manifest:
+        manifest = Manifest(name=name, description=description or "CrewAI multi-agent system state")
+
+        agents = getattr(obj, "agents", []) or []
+        if not agents and hasattr(obj, "role"):  # If a single Agent was passed
+            agents = [obj]
+
+        seen_models = set()
+        seen_tools = set()
+
+        for idx, agent in enumerate(agents):
+            role = getattr(agent, "role", f"agent-{idx+1}")
+            goal = getattr(agent, "goal", "")
+            backstory = getattr(agent, "backstory", "")
+
+            # 1. Agent role prompt artifact
+            prompt_content = f"Role: {role}\nGoal: {goal}\nBackstory: {backstory}".strip()
+            manifest.add_artifact(PromptArtifact(
+                name=f"{role.lower().replace(' ', '-')}-prompt",
+                role="system",
+                description=prompt_content[:300],
+            ))
+
+            # 2. Agent tools
+            agent_tools = getattr(agent, "tools", []) or []
+            for t in agent_tools:
+                t_name = getattr(t, "name", str(t))
+                if t_name not in seen_tools:
+                    seen_tools.add(t_name)
+                    manifest.add_artifact(ToolArtifact(
+                        name=t_name,
+                        provider="crewai",
+                        description=getattr(t, "description", ""),
+                    ))
+
+            # 3. Agent LLM
+            llm = getattr(agent, "llm", None)
+            if llm is not None and str(llm) not in seen_models:
+                seen_models.add(str(llm))
+                model_str = getattr(llm, "model", getattr(llm, "model_name", str(llm)))
+                provider = "openai"
+                if "claude" in str(model_str).lower():
+                    provider = "anthropic"
+                elif "gemini" in str(model_str).lower():
+                    provider = "google"
+
+                manifest.add_artifact(ModelConfigArtifact(
+                    name=f"model-{role.lower().replace(' ', '-')}",
+                    model=str(model_str),
+                    provider=provider,
+                ))
+
+        # Capture crew structure in metadata
+        tasks = getattr(obj, "tasks", []) or []
+        manifest.metadata["crewai"] = {
+            "agent_count": len(agents),
+            "task_count": len(tasks),
+            "process": str(getattr(obj, "process", "sequential")),
+        }
+
+        return manifest
+
+
+def from_crewai(obj: Any, name: str = "crewai-multi-agent", description: str = "") -> Manifest:
+    """Convenience function to extract an Intelligence Manifest from a CrewAI Crew or Agent."""
+    return CrewAIAdapter().to_manifest(obj, name=name, description=description)

evolution/adapters/direct.py

@@ -0,0 +1,120 @@
+"""
+Direct API adapters for OpenAI and Anthropic API payloads and clients.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from evolution.adapters.base import BaseAdapter
+from evolution.models.artifacts import (
+    ModelConfigArtifact,
+    PromptArtifact,
+    ToolArtifact,
+)
+from evolution.models.manifest import Manifest
+
+
+class OpenAIAdapter(BaseAdapter):
+    """Converts OpenAI request dictionaries or client configurations into an Intelligence Manifest."""
+
+    def to_manifest(self, obj: Any, name: str = "openai-system", description: str = "") -> Manifest:
+        manifest = Manifest(name=name, description=description or "OpenAI API intelligence state")
+        params = obj if isinstance(obj, dict) else getattr(obj, "__dict__", {})
+
+        # 1. Model configuration
+        model = params.get("model", "gpt-4o")
+        temp = params.get("temperature", 0.7)
+        max_tokens = params.get("max_tokens") or params.get("max_completion_tokens")
+        top_p = params.get("top_p")
+
+        manifest.add_artifact(ModelConfigArtifact(
+            name=f"openai-{model}",
+            model=str(model),
+            provider="openai",
+            temperature=float(temp) if temp is not None else 0.7,
+            max_tokens=int(max_tokens) if max_tokens is not None else None,
+            top_p=float(top_p) if top_p is not None else None,
+        ))
+
+        # 2. Prompts from messages
+        messages = params.get("messages", [])
+        for idx, msg in enumerate(messages):
+            if isinstance(msg, dict):
+                role = msg.get("role", "user")
+                content = str(msg.get("content", ""))
+                if role in ("system", "user", "assistant", "few_shot"):
+                    manifest.add_artifact(PromptArtifact(
+                        name=f"openai-msg-{idx+1}-{role}",
+                        role=role,
+                        description=content[:200],
+                    ))
+
+        # 3. Tools
+        tools = params.get("tools", [])
+        for t in tools:
+            if isinstance(t, dict):
+                fn = t.get("function", {})
+                t_name = fn.get("name") or t.get("name", "custom-tool")
+                t_desc = fn.get("description", "")
+                manifest.add_artifact(ToolArtifact(
+                    name=t_name,
+                    provider="openai",
+                    description=t_desc,
+                ))
+
+        return manifest
+
+
+class AnthropicAdapter(BaseAdapter):
+    """Converts Anthropic request dictionaries or client configurations into an Intelligence Manifest."""
+
+    def to_manifest(self, obj: Any, name: str = "anthropic-system", description: str = "") -> Manifest:
+        manifest = Manifest(name=name, description=description or "Anthropic API intelligence state")
+        params = obj if isinstance(obj, dict) else getattr(obj, "__dict__", {})
+
+        # 1. Model configuration
+        model = params.get("model", "claude-3.5-sonnet")
+        temp = params.get("temperature", 0.7)
+        max_tokens = params.get("max_tokens", 4096)
+
+        manifest.add_artifact(ModelConfigArtifact(
+            name=f"anthropic-{model}",
+            model=str(model),
+            provider="anthropic",
+            temperature=float(temp) if temp is not None else 0.7,
+            max_tokens=int(max_tokens) if max_tokens is not None else None,
+        ))
+
+        # 2. System prompt
+        system = params.get("system")
+        if system:
+            manifest.add_artifact(PromptArtifact(
+                name="anthropic-system-prompt",
+                role="system",
+                description=str(system)[:200],
+            ))
+
+        # 3. Tools
+        tools = params.get("tools", [])
+        for t in tools:
+            if isinstance(t, dict):
+                t_name = t.get("name", "custom-tool")
+                t_desc = t.get("description", "")
+                manifest.add_artifact(ToolArtifact(
+                    name=t_name,
+                    provider="anthropic",
+                    description=t_desc,
+                ))
+
+        return manifest
+
+
+def from_openai(params: dict[str, Any] | Any, name: str = "openai-system", description: str = "") -> Manifest:
+    """Convenience function to extract an Intelligence Manifest from an OpenAI request payload."""
+    return OpenAIAdapter().to_manifest(params, name=name, description=description)
+
+
+def from_anthropic(params: dict[str, Any] | Any, name: str = "anthropic-system", description: str = "") -> Manifest:
+    """Convenience function to extract an Intelligence Manifest from an Anthropic request payload."""
+    return AnthropicAdapter().to_manifest(params, name=name, description=description)

evolution/adapters/langchain.py

@@ -0,0 +1,112 @@
+"""
+LangChain framework adapter for extracting Intelligence Manifests.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from evolution.adapters.base import BaseAdapter
+from evolution.models.artifacts import (
+    MemoryArtifact,
+    ModelConfigArtifact,
+    PromptArtifact,
+    ToolArtifact,
+)
+from evolution.models.manifest import Manifest
+
+
+class LangChainAdapter(BaseAdapter):
+    """Converts LangChain chains, agents, prompt templates, and tools into an Intelligence Manifest."""
+
+    def to_manifest(self, obj: Any, name: str = "langchain-agent", description: str = "") -> Manifest:
+        manifest = Manifest(name=name, description=description or "LangChain application state")
+
+        # 1. Inspect LLM / Model
+        llm = getattr(obj, "llm", None) or getattr(obj, "llm_chain", None)
+        if llm is None and (hasattr(obj, "model_name") or hasattr(obj, "model")):
+            llm = obj
+
+        if llm is not None:
+            model_name = getattr(llm, "model_name", None) or getattr(llm, "model", "gpt-4o")
+            temperature = getattr(llm, "temperature", 0.7)
+            max_tokens = getattr(llm, "max_tokens", None) or getattr(llm, "max_output_tokens", None)
+
+            # Determine provider
+            provider = "openai"
+            cls_name = llm.__class__.__name__.lower()
+            if "anthropic" in cls_name or "claude" in str(model_name).lower():
+                provider = "anthropic"
+            elif "google" in cls_name or "gemini" in str(model_name).lower():
+                provider = "google"
+            elif "mistral" in cls_name:
+                provider = "mistral"
+            elif "cohere" in cls_name:
+                provider = "cohere"
+
+            manifest.add_artifact(ModelConfigArtifact(
+                name="langchain-llm",
+                model=str(model_name),
+                provider=provider,
+                temperature=float(temperature) if temperature is not None else 0.7,
+                max_tokens=int(max_tokens) if max_tokens is not None else None,
+            ))
+
+        # 2. Inspect Prompts
+        prompt = getattr(obj, "prompt", None) or getattr(obj, "prompt_template", None)
+        if prompt is None and hasattr(obj, "messages"):
+            prompt = obj
+
+        if prompt is not None:
+            prompt_text = ""
+            if hasattr(prompt, "template"):
+                prompt_text = str(prompt.template)
+            elif hasattr(prompt, "messages"):
+                msg_strs = []
+                for m in prompt.messages:
+                    role = getattr(m, "role", "system")
+                    content = getattr(m, "content", getattr(m, "template", str(m)))
+                    msg_strs.append(f"[{role}] {content}")
+                prompt_text = "\n".join(msg_strs)
+            else:
+                prompt_text = str(prompt)
+
+            manifest.add_artifact(PromptArtifact(
+                name="langchain-prompt",
+                role="system",
+                description=prompt_text[:200] if prompt_text else "LangChain prompt template",
+            ))
+
+        # 3. Inspect Tools
+        tools = getattr(obj, "tools", []) or []
+        for t in tools:
+            tool_name = getattr(t, "name", str(t))
+            tool_desc = getattr(t, "description", "")
+            manifest.add_artifact(ToolArtifact(
+                name=tool_name,
+                provider="langchain",
+                description=tool_desc,
+            ))
+
+        # 4. Inspect Memory
+        memory = getattr(obj, "memory", None)
+        if memory is not None:
+            mem_cls = memory.__class__.__name__.lower()
+            strategy = "buffer_window"
+            if "summary" in mem_cls:
+                strategy = "summary"
+            elif "vector" in mem_cls:
+                strategy = "vector"
+
+            manifest.add_artifact(MemoryArtifact(
+                name="langchain-memory",
+                strategy=strategy,
+                max_tokens=getattr(memory, "max_token_limit", None),
+            ))
+
+        return manifest
+
+
+def from_langchain(obj: Any, name: str = "langchain-agent", description: str = "") -> Manifest:
+    """Convenience function to extract an Intelligence Manifest from a LangChain object."""
+    return LangChainAdapter().to_manifest(obj, name=name, description=description)

evolution/adapters/llamaindex.py

@@ -0,0 +1,96 @@
+"""
+LlamaIndex framework adapter for extracting Intelligence Manifests.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from evolution.adapters.base import BaseAdapter
+from evolution.models.artifacts import (
+    ModelConfigArtifact,
+    RetrievalArtifact,
+)
+from evolution.models.manifest import Manifest
+
+
+class LlamaIndexAdapter(BaseAdapter):
+    """Converts LlamaIndex indices, query engines, and retrievers into an Intelligence Manifest."""
+
+    def to_manifest(self, obj: Any, name: str = "llamaindex-rag", description: str = "") -> Manifest:
+        manifest = Manifest(name=name, description=description or "LlamaIndex RAG application state")
+
+        # 1. Extract Retrieval settings
+        source = "chroma"
+        chunk_size: int | None = None
+        top_k: int | None = None
+
+        # Inspect storage_context / vector_store
+        sc = getattr(obj, "storage_context", None)
+        vs = getattr(sc, "vector_store", None) if sc else getattr(obj, "vector_store", None)
+        if vs is not None:
+            vs_name = vs.__class__.__name__.lower()
+            if "pinecone" in vs_name:
+                source = "pinecone"
+            elif "weaviate" in vs_name:
+                source = "weaviate"
+            elif "elasticsearch" in vs_name or "elastic" in vs_name:
+                source = "elasticsearch"
+            elif "chroma" in vs_name:
+                source = "chroma"
+            else:
+                source = "local"
+
+        # Inspect retriever / query engine top_k
+        retriever = getattr(obj, "retriever", None) or getattr(obj, "_retriever", None)
+        if retriever is not None:
+            top_k = getattr(retriever, "similarity_top_k", None) or getattr(retriever, "top_k", None)
+        elif hasattr(obj, "similarity_top_k"):
+            top_k = getattr(obj, "similarity_top_k")
+
+        # Inspect chunk size
+        service_context = getattr(obj, "service_context", None)
+        if service_context is not None:
+            node_parser = getattr(service_context, "node_parser", None)
+            if node_parser is not None:
+                chunk_size = getattr(node_parser, "chunk_size", None)
+        elif hasattr(obj, "chunk_size"):
+            chunk_size = getattr(obj, "chunk_size")
+
+        manifest.add_artifact(RetrievalArtifact(
+            name="llamaindex-retrieval",
+            source=source,
+            chunk_size=int(chunk_size) if chunk_size is not None else 512,
+            top_k=int(top_k) if top_k is not None else 5,
+            description="LlamaIndex vector retrieval configuration",
+        ))
+
+        # 2. Extract LLM configuration
+        llm = getattr(obj, "llm", None)
+        if service_context and not llm:
+            llm = getattr(service_context, "llm", None)
+
+        if llm is not None:
+            model_name = getattr(llm, "model", getattr(llm, "model_name", "gpt-4o"))
+            temperature = getattr(llm, "temperature", 0.1)
+
+            provider = "openai"
+            cls_name = llm.__class__.__name__.lower()
+            if "anthropic" in cls_name or "claude" in str(model_name).lower():
+                provider = "anthropic"
+            elif "google" in cls_name or "gemini" in str(model_name).lower():
+                provider = "google"
+
+            manifest.add_artifact(ModelConfigArtifact(
+                name="llamaindex-llm",
+                model=str(model_name),
+                provider=provider,
+                temperature=float(temperature) if temperature is not None else 0.1,
+            ))
+
+        return manifest
+
+
+def from_llamaindex(obj: Any, name: str = "llamaindex-rag", description: str = "") -> Manifest:
+    """Convenience function to extract an Intelligence Manifest from a LlamaIndex object."""
+    return LlamaIndexAdapter().to_manifest(obj, name=name, description=description)

evolution/capture/__init__.py

@@ -0,0 +1,22 @@
+"""
+Automatic intelligence capture and execution recording package.
+"""
+
+from evolution.capture.introspect import (
+    extract_docstring_prompt,
+    extract_inputs_from_args,
+    extract_llm_response,
+    extract_model_config_from_kwargs,
+)
+from evolution.capture.recorder import RecordContextManager, record
+from evolution.capture.tracker import track
+
+__all__ = [
+    "RecordContextManager",
+    "extract_docstring_prompt",
+    "extract_inputs_from_args",
+    "extract_llm_response",
+    "extract_model_config_from_kwargs",
+    "record",
+    "track",
+]