EvoScientist 0.0.1.dev4__tar.gz → 0.0.1.dev6__tar.gz

{evoscientist-0.0.1.dev4 → evoscientist-0.0.1.dev6}/EvoScientist/EvoScientist.py

@@ -22,6 +22,7 @@ from deepagents.backends import FilesystemBackend, CompositeBackend
 from .backends import CustomSandboxBackend, MergedReadOnlyBackend
 from .config import get_effective_config, apply_config_to_env
 from .llm import get_chat_model
+from .mcp import load_mcp_tools
 from .middleware import create_skills_middleware, create_memory_middleware
 from .prompts import RESEARCHER_INSTRUCTIONS, get_system_prompt
 from .utils import load_subagents
@@ -29,6 +30,7 @@ from .tools import tavily_search, think_tool, skill_manager
 from .paths import (
     ensure_dirs,
     default_workspace_dir,
+    set_active_workspace,
     MEMORY_DIR as _MEMORY_DIR_PATH,
     USER_SKILLS_DIR as _USER_SKILLS_DIR_PATH,
 )
@@ -51,6 +53,7 @@ MAX_ITERATIONS = _config.max_iterations
 # Workspace settings
 ensure_dirs()
 WORKSPACE_DIR = str(default_workspace_dir())
+set_active_workspace(WORKSPACE_DIR)
 MEMORY_DIR = str(_MEMORY_DIR_PATH)  # Shared across sessions (not per-session)
 SKILLS_DIR = str(Path(__file__).parent / "skills")
 USER_SKILLS_DIR = str(_USER_SKILLS_DIR_PATH)
@@ -73,7 +76,6 @@ SYSTEM_PROMPT = get_system_prompt(
 chat_model = get_chat_model(
     model=_config.model,
     provider=_config.provider,
-    # thinking={"type": "enabled", "budget_tokens": 2000},
 )
 
 # Initialize workspace backend based on mode
@@ -115,45 +117,116 @@ tool_registry = {
     "tavily_search": tavily_search,
 }
 
+# Base tools that every agent variant gets (before MCP)
+BASE_TOOLS = [think_tool, skill_manager]
+
+
+def _build_base_kwargs(base_backend, base_middleware):
+    """Build agent kwargs *without* MCP (fast, no subprocess spawning)."""
+    subs = load_subagents(
+        SUBAGENTS_CONFIG,
+        tool_registry=tool_registry,
+        prompt_refs=prompt_refs,
+    )
+    return dict(
+        name="EvoScientist",
+        model=chat_model,
+        tools=list(BASE_TOOLS),
+        backend=base_backend,
+        subagents=subs,
+        middleware=base_middleware,
+        system_prompt=SYSTEM_PROMPT,
+    )
+
+
+def load_mcp_and_build_kwargs(base_backend, base_middleware):
+    """(Re-)load MCP tools and build agent kwargs.
+
+    Called on every ``create_cli_agent()`` call so that ``/new`` picks up
+    MCP config changes. Falls back to base kwargs if no MCP configured.
+    """
+    mcp_by_agent = load_mcp_tools()
+    if not mcp_by_agent:
+        return _build_base_kwargs(base_backend, base_middleware)
+
+    # Fresh tool registry — start from base tools + MCP tools
+    registry = dict(tool_registry)
+    for tools in mcp_by_agent.values():
+        for t in tools:
+            registry[t.name] = t
+
+    mcp_main = mcp_by_agent.pop("main", [])
+
+    subs = load_subagents(
+        SUBAGENTS_CONFIG,
+        tool_registry=registry,
+        prompt_refs=prompt_refs,
+    )
+
+    # Inject MCP tools into subagents by name
+    for sa in subs:
+        if sa_tools := mcp_by_agent.get(sa["name"], []):
+            sa.setdefault("tools", []).extend(sa_tools)
+
+    return dict(
+        name="EvoScientist",
+        model=chat_model,
+        tools=BASE_TOOLS + mcp_main,
+        backend=base_backend,
+        subagents=subs,
+        middleware=base_middleware,
+        system_prompt=SYSTEM_PROMPT,
+    )
+
+
 prompt_refs = {
     "RESEARCHER_INSTRUCTIONS": RESEARCHER_INSTRUCTIONS.format(date=current_date),
 }
 
-subagents = load_subagents(
-    SUBAGENTS_CONFIG,
-    tool_registry=tool_registry,
-    prompt_refs=prompt_refs,
-)
+base_middleware = [
+    create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
+    create_skills_middleware(backend),
+]
+
+# Default agent (no checkpointer) — used by langgraph dev / LangSmith / notebooks.
+# Lazily constructed on first access so MCP tools are included without
+# spawning subprocesses at import time.
+_EvoScientist_agent = None
 
-# Shared kwargs for agent creation
-_AGENT_KWARGS = dict(
-    name="EvoScientist",
-    model=chat_model,
-    tools=[think_tool, skill_manager],
-    backend=backend,
-    subagents=subagents,
-    middleware=[
-        create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
-        create_skills_middleware(SKILLS_DIR, user_skills_dir=USER_SKILLS_DIR),
-    ],
-    system_prompt=SYSTEM_PROMPT,
-)
 
-# Default agent (no checkpointer) — used by langgraph dev / LangSmith / notebooks
-EvoScientist_agent = create_deep_agent(**_AGENT_KWARGS).with_config({"recursion_limit": 500})
+def _get_default_agent():
+    """Build the default agent (with MCP, no checkpointer) on first access."""
+    global _EvoScientist_agent
+    if _EvoScientist_agent is None:
+        kwargs = load_mcp_and_build_kwargs(backend, base_middleware)
+        _EvoScientist_agent = create_deep_agent(**kwargs).with_config(
+            {"recursion_limit": 500}
+        )
+    return _EvoScientist_agent
+
 
+def __getattr__(name: str):
+    if name == "EvoScientist_agent":
+        return _get_default_agent()
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
-def create_cli_agent(workspace_dir: str | None = None):
-    """Create agent with InMemorySaver checkpointer for CLI multi-turn support.
+
+def create_cli_agent(workspace_dir: str | None = None, checkpointer=None):
+    """Create agent with checkpointer for CLI multi-turn support.
 
     Args:
         workspace_dir: Optional per-session workspace directory. If provided,
             creates a fresh backend rooted at this path. If None, uses the
             module-level default backend (./workspace).
+        checkpointer: Optional LangGraph checkpointer. If None, falls back
+            to ``InMemorySaver`` (non-persistent).
     """
-    from langgraph.checkpoint.memory import InMemorySaver  # type: ignore[import-untyped]
+    if checkpointer is None:
+        from langgraph.checkpoint.memory import InMemorySaver  # type: ignore[import-untyped]
+        checkpointer = InMemorySaver()
 
     if workspace_dir:
+        set_active_workspace(workspace_dir)
         ws_backend = CustomSandboxBackend(
             root_dir=workspace_dir,
             virtual_mode=True,
@@ -175,19 +248,18 @@ def create_cli_agent(workspace_dir: str | None = None):
                 "/memory/": mem_backend,
             },
         )
-        mw = [
-            create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
-            create_skills_middleware(SKILLS_DIR, user_skills_dir=USER_SKILLS_DIR),
-        ]
-        kwargs = dict(
-            _AGENT_KWARGS,
-            backend=be,
-            middleware=mw,
-        )
     else:
-        kwargs = dict(_AGENT_KWARGS)
+        be = backend
+
+    mw = [
+        create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
+        create_skills_middleware(be),
+    ]
+
+    # Re-load MCP tools from current config (picks up /mcp add changes)
+    kwargs = load_mcp_and_build_kwargs(be, mw)
 
     return create_deep_agent(
         **kwargs,
-        checkpointer=InMemorySaver(),
+        checkpointer=checkpointer,
     ).with_config({"recursion_limit": 500})

evoscientist-0.0.1.dev6/EvoScientist/__init__.py

@@ -0,0 +1,64 @@
+"""EvoScientist Agent - AI-powered research and code execution.
+
+This package exposes a convenience API at the package root while keeping
+imports lazy, so lightweight modules (for example config helpers) can be used
+without importing heavy runtime dependencies.
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+
+
+_EXPORTS: dict[str, tuple[str, str]] = {
+    # Agent graph (lazy to avoid expensive initialization at import time)
+    "EvoScientist_agent": (".EvoScientist", "EvoScientist_agent"),
+    "create_cli_agent": (".EvoScientist", "create_cli_agent"),
+    # Backends
+    "CustomSandboxBackend": (".backends", "CustomSandboxBackend"),
+    "ReadOnlyFilesystemBackend": (".backends", "ReadOnlyFilesystemBackend"),
+    # Configuration
+    "EvoScientistConfig": (".config", "EvoScientistConfig"),
+    "load_config": (".config", "load_config"),
+    "save_config": (".config", "save_config"),
+    "get_effective_config": (".config", "get_effective_config"),
+    "get_config_path": (".config", "get_config_path"),
+    # LLM
+    "get_chat_model": (".llm", "get_chat_model"),
+    "MODELS": (".llm", "MODELS"),
+    "list_models": (".llm", "list_models"),
+    "DEFAULT_MODEL": (".llm", "DEFAULT_MODEL"),
+    # Middleware
+    "create_skills_middleware": (".middleware", "create_skills_middleware"),
+    # Prompts
+    "get_system_prompt": (".prompts", "get_system_prompt"),
+    "RESEARCHER_INSTRUCTIONS": (".prompts", "RESEARCHER_INSTRUCTIONS"),
+    # Tools
+    "tavily_search": (".tools", "tavily_search"),
+    "think_tool": (".tools", "think_tool"),
+    # Sessions
+    "get_checkpointer": (".sessions", "get_checkpointer"),
+    "generate_thread_id": (".sessions", "generate_thread_id"),
+    "list_threads": (".sessions", "list_threads"),
+    "delete_thread": (".sessions", "delete_thread"),
+}
+
+
+def __getattr__(name: str):
+    target = _EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    module_name, attr_name = target
+    module = import_module(module_name, package=__name__)
+    value = getattr(module, attr_name)
+    # Cache after first load to avoid repeated import lookups.
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_EXPORTS))
+
+
+__all__ = list(_EXPORTS)

{evoscientist-0.0.1.dev4 → evoscientist-0.0.1.dev6}/EvoScientist/backends.py

@@ -2,16 +2,16 @@
 
 import os
 import re
-import subprocess
+import uuid
 from pathlib import Path
 
-from deepagents.backends import FilesystemBackend
+from deepagents.backends import FilesystemBackend, LocalShellBackend
 from deepagents.backends.filesystem import WriteResult, EditResult
 from deepagents.backends.protocol import (
+    BackendProtocol,
     ExecuteResponse,
     FileDownloadResponse,
     FileUploadResponse,
-    SandboxBackendProtocol,
 )
 
 # System path prefixes that should never appear in virtual paths.
@@ -132,7 +132,7 @@ class ReadOnlyFilesystemBackend(FilesystemBackend):
         )
 
 
-class MergedReadOnlyBackend:
+class MergedReadOnlyBackend(BackendProtocol):
     """Read-only backend that merges two directories.
 
     Reads from *primary* first (user skills in workspace/skills/),
@@ -205,27 +205,7 @@ class MergedReadOnlyBackend:
             error="This directory is read-only. Edit operations are not permitted here."
         )
 
-    # -- async variants (required by middleware) --
-
-    async def aread(self, file_path: str, offset: int = 0, limit: int = 2000) -> str:
-        return self.read(file_path, offset, limit)
-
-    async def als_info(self, path: str = "/") -> list:
-        return self.ls_info(path)
-
-    async def agrep_raw(self, pattern: str, path: str | None = None, glob: str | None = None) -> list:
-        return self.grep_raw(pattern, path, glob)
-
-    async def aglob_info(self, pattern: str, path: str = "/") -> list:
-        return self.glob_info(pattern, path)
-
-    async def awrite(self, file_path: str, content: str) -> WriteResult:
-        return self.write(file_path, content)
-
-    async def aedit(self, file_path: str, old_string: str, new_string: str, replace_all: bool = False) -> EditResult:
-        return self.edit(file_path, old_string, new_string, replace_all)
-
-    # -- download / upload (required by BackendProtocol) --
+    # -- download / upload --
 
     def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
         """Download files, trying primary then secondary."""
@@ -237,38 +217,34 @@ class MergedReadOnlyBackend:
             responses.append(resp)
         return responses
 
-    async def adownload_files(self, paths: list[str]) -> list[FileDownloadResponse]:
-        return self.download_files(paths)
-
     def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
         return [
             FileUploadResponse(path=path, error="permission_denied")
             for path, _ in files
         ]
 
-    async def aupload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
-        return self.upload_files(files)
-
 
-class CustomSandboxBackend(FilesystemBackend, SandboxBackendProtocol):
+class CustomSandboxBackend(LocalShellBackend):
     """
-    Custom sandbox backend - inherits FilesystemBackend and implements execute method.
+    Custom sandbox backend - inherits LocalShellBackend with added safety.
 
     Features:
     - Inherits all file operations (ls, read, write, edit, grep, glob)
-    - Adds shell command execution capability
-    - Command validation prevents directory traversal and dangerous operations
-    - Runs commands in specified working directory
+    - Inherits shell command execution with output truncation and timeout
+    - Adds command validation to prevent directory traversal and dangerous operations
+    - Adds path sanitization to auto-correct common LLM path mistakes
     - Compatible with LangGraph checkpointer (no thread locks)
     """
 
     def __init__(
         self,
         root_dir: str = ".",
+        *,
         virtual_mode: bool = True,
-        working_dir: str | None = None,
         timeout: int = 300,
-        shell: str = "/bin/bash",
+        max_output_bytes: int = 100_000,
+        env: dict[str, str] | None = None,
+        inherit_env: bool = True,
     ):
         """
         Initialize custom sandbox backend.
@@ -276,19 +252,23 @@ class CustomSandboxBackend(FilesystemBackend, SandboxBackendProtocol):
         Args:
             root_dir: File system root directory
             virtual_mode: Whether to enable virtual path mode
-            working_dir: Working directory for command execution (defaults to root_dir)
             timeout: Command execution timeout in seconds
-            shell: Shell program to use
+            max_output_bytes: Max output size before truncation (default 100KB)
+            env: Extra environment variables for subprocess
+            inherit_env: Whether to inherit parent process env (default True)
         """
-        super().__init__(root_dir=root_dir, virtual_mode=virtual_mode)
-
-        self.working_dir = working_dir or root_dir
-        self.timeout = timeout
-        self.shell = shell
-        self.virtual_mode = virtual_mode
-
+        super().__init__(
+            root_dir=root_dir,
+            virtual_mode=virtual_mode,
+            timeout=timeout,
+            max_output_bytes=max_output_bytes,
+            env=env,
+            inherit_env=inherit_env,
+        )
+        # Override parent's "local-" prefix with our own
+        self._sandbox_id = f"evosci-{uuid.uuid4().hex[:8]}"
         # Ensure working directory exists
-        os.makedirs(self.working_dir, exist_ok=True)
+        os.makedirs(str(self.cwd), exist_ok=True)
 
     def _resolve_path(self, key: str) -> Path:
         """Resolve path with sanitization to prevent nested directories.
@@ -331,62 +311,20 @@ class CustomSandboxBackend(FilesystemBackend, SandboxBackendProtocol):
         - Access to paths outside workspace
         - Dangerous system commands
 
-        Args:
-            command: Command string to execute
-
-        Returns:
-            ExecuteResponse containing output, exit_code, and truncated flag
+        Then delegates to LocalShellBackend.execute() for actual execution.
         """
-        try:
-            # Validate command safety
-            error = validate_command(command)
-            if error:
-                return ExecuteResponse(
-                    output=error,
-                    exit_code=1,
-                    truncated=False,
-                )
-
-            # Convert virtual paths to relative paths
-            if self.virtual_mode:
-                command = convert_virtual_paths_in_command(command=command)
-
-            result = subprocess.run(
-                command,
-                shell=True,
-                executable=self.shell,
-                cwd=self.working_dir,
-                capture_output=True,
-                text=True,
-                timeout=self.timeout,
-            )
-
-            output = ""
-            if result.stdout:
-                output += result.stdout
-            if result.stderr:
-                output += result.stderr
-
+        # Validate command safety
+        error = validate_command(command)
+        if error:
             return ExecuteResponse(
-                output=output,
-                exit_code=result.returncode,
+                output=error,
+                exit_code=1,
                 truncated=False,
             )
 
-        except subprocess.TimeoutExpired:
-            return ExecuteResponse(
-                output=f"Command timed out after {self.timeout} seconds",
-                exit_code=-1,
-                truncated=False,
-            )
-        except Exception as e:
-            return ExecuteResponse(
-                output=f"Error executing command: {str(e)}",
-                exit_code=-1,
-                truncated=False,
-            )
+        # Convert virtual paths to relative paths
+        if self.virtual_mode:
+            command = convert_virtual_paths_in_command(command=command)
 
-    async def aexecute(self, command: str) -> ExecuteResponse:
-        """Async version of execute (runs sync version in thread)."""
-        import asyncio
-        return await asyncio.to_thread(self.execute, command)
+        # Delegate to parent for subprocess execution
+        return super().execute(command)

evoscientist-0.0.1.dev6/EvoScientist/channels/__init__.py

@@ -0,0 +1,9 @@
+"""Communication channels for EvoScientist.
+
+This module provides an extensible interface for different messaging channels
+(iMessage, WeChat, etc.) to communicate with the EvoScientist agent.
+"""
+
+from .base import Channel, IncomingMessage, OutgoingMessage
+
+__all__ = ["Channel", "IncomingMessage", "OutgoingMessage"]

evoscientist-0.0.1.dev6/EvoScientist/channels/base.py

@@ -0,0 +1,110 @@
+"""Abstract base class for communication channels.
+
+This module defines the Channel interface that all messaging channels
+(iMessage, WeChat, etc.) must implement.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import AsyncIterator
+
+
+@dataclass
+class IncomingMessage:
+    """Represents a message received from a channel."""
+
+    sender: str  # Phone number, email, or unique identifier
+    content: str  # Message text content
+    timestamp: datetime  # When the message was sent
+    message_id: str  # Unique identifier for the message
+    metadata: dict = field(default_factory=dict)  # Channel-specific metadata
+
+
+@dataclass
+class OutgoingMessage:
+    """Represents a message to be sent through a channel."""
+
+    recipient: str  # Phone number, email, or unique identifier
+    content: str  # Message text content
+    reply_to: str | None = None  # Optional message ID being replied to
+    metadata: dict = field(default_factory=dict)  # Channel-specific metadata
+
+
+class Channel(ABC):
+    """Abstract base class for messaging channels.
+
+    Subclasses must implement:
+    - start(): Initialize the channel (connect, authenticate, etc.)
+    - stop(): Clean up resources
+    - receive(): Async iterator yielding incoming messages
+    - send(): Send a message through the channel
+    """
+
+    @abstractmethod
+    async def start(self) -> None:
+        """Initialize and start the channel.
+
+        This method should:
+        - Establish connections
+        - Verify permissions/authentication
+        - Start any background tasks needed
+
+        Raises:
+            ChannelError: If initialization fails
+        """
+        pass
+
+    @abstractmethod
+    async def stop(self) -> None:
+        """Stop the channel and clean up resources.
+
+        This method should:
+        - Close connections
+        - Cancel background tasks
+        - Release any held resources
+        """
+        pass
+
+    @abstractmethod
+    async def receive(self) -> AsyncIterator[IncomingMessage]:
+        """Async iterator that yields incoming messages.
+
+        Yields:
+            IncomingMessage: Each new message received
+
+        Example:
+            async for msg in channel.receive():
+                print(f"From {msg.sender}: {msg.content}")
+        """
+        pass
+
+    @abstractmethod
+    async def send(self, message: OutgoingMessage) -> bool:
+        """Send a message through the channel.
+
+        Args:
+            message: The message to send
+
+        Returns:
+            True if sent successfully, False otherwise
+        """
+        pass
+
+
+class ChannelError(Exception):
+    """Base exception for channel-related errors."""
+
+    pass
+
+
+class ChannelPermissionError(ChannelError):
+    """Raised when the channel lacks required permissions."""
+
+    pass
+
+
+class ChannelConnectionError(ChannelError):
+    """Raised when the channel cannot establish a connection."""
+
+    pass

evoscientist-0.0.1.dev6/EvoScientist/channels/imessage/__init__.py

@@ -0,0 +1,33 @@
+"""iMessage channel implementation for EvoScientist.
+
+Uses imsg CLI via JSON-RPC for real-time message streaming.
+
+Requirements:
+- macOS only
+- imsg CLI: brew install steipete/tap/imsg
+- Full Disk Access permission
+- Messages.app logged into iCloud
+"""
+
+from .channel_rpc import IMessageChannelRpc as IMessageChannel
+from .channel_rpc import IMessageConfig
+from .probe import probe_imessage, ProbeResult
+from .targets import (
+    parse_target,
+    normalize_handle,
+    normalize_e164,
+    IMessageTarget,
+    IMessageService,
+)
+
+__all__ = [
+    "IMessageChannel",
+    "IMessageConfig",
+    "probe_imessage",
+    "ProbeResult",
+    "parse_target",
+    "normalize_handle",
+    "normalize_e164",
+    "IMessageTarget",
+    "IMessageService",
+]