EvoScientist 0.0.1.dev5__tar.gz → 0.0.1.dev7__tar.gz

{evoscientist-0.0.1.dev5 → evoscientist-0.0.1.dev7}/EvoScientist/EvoScientist.py

@@ -26,7 +26,7 @@ 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
-from .tools import tavily_search, think_tool, skill_manager, view_image
+from .tools import tavily_search, think_tool, skill_manager
 from .paths import (
     ensure_dirs,
     default_workspace_dir,
@@ -115,11 +115,10 @@ backend = CompositeBackend(
 tool_registry = {
     "think_tool": think_tool,
     "tavily_search": tavily_search,
-    "view_image": view_image,
 }
 
 # Base tools that every agent variant gets (before MCP)
-BASE_TOOLS = [think_tool, skill_manager, view_image]
+BASE_TOOLS = [think_tool, skill_manager]
 
 
 def _build_base_kwargs(base_backend, base_middleware):
@@ -190,21 +189,41 @@ base_middleware = [
 ]
 
 # Default agent (no checkpointer) — used by langgraph dev / LangSmith / notebooks.
-# Built WITHOUT MCP at import time to avoid spawning subprocesses on every import.
-# MCP tools are loaded on-demand in create_cli_agent().
-_AGENT_KWARGS = _build_base_kwargs(backend, base_middleware)
-EvoScientist_agent = create_deep_agent(**_AGENT_KWARGS).with_config({"recursion_limit": 500})
+# Lazily constructed on first access so MCP tools are included without
+# spawning subprocesses at import time.
+_EvoScientist_agent = None
+
+
+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)
@@ -242,5 +261,5 @@ def create_cli_agent(workspace_dir: str | None = None):
 
     return create_deep_agent(
         **kwargs,
-        checkpointer=InMemorySaver(),
+        checkpointer=checkpointer,
     ).with_config({"recursion_limit": 500})

{evoscientist-0.0.1.dev5 → evoscientist-0.0.1.dev7}/EvoScientist/__init__.py

@@ -36,7 +36,11 @@ _EXPORTS: dict[str, tuple[str, str]] = {
     # Tools
     "tavily_search": (".tools", "tavily_search"),
     "think_tool": (".tools", "think_tool"),
-    "view_image": (".tools", "view_image"),
+    # Sessions
+    "get_checkpointer": (".sessions", "get_checkpointer"),
+    "generate_thread_id": (".sessions", "generate_thread_id"),
+    "list_threads": (".sessions", "list_threads"),
+    "delete_thread": (".sessions", "delete_thread"),
 }
 
 

{evoscientist-0.0.1.dev5 → evoscientist-0.0.1.dev7}/EvoScientist/backends.py

@@ -2,18 +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.
@@ -226,25 +224,24 @@ class MergedReadOnlyBackend(BackendProtocol):
         ]
 
 
-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,
@@ -255,35 +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)
-
+        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]}"
-        self.working_dir = working_dir or root_dir
-        self.timeout = timeout
-        self.shell = shell
-        self.virtual_mode = virtual_mode
-        self._max_output_bytes = max_output_bytes
-
-        # Build subprocess environment
-        if inherit_env:
-            self._env = {**os.environ, **(env or {})}
-        else:
-            self._env = dict(env) if env else {}
-
         # Ensure working directory exists
-        os.makedirs(self.working_dir, exist_ok=True)
-
-    @property
-    def id(self) -> str:
-        """Unique identifier for the sandbox backend instance."""
-        return self._sandbox_id
+        os.makedirs(str(self.cwd), exist_ok=True)
 
     def _resolve_path(self, key: str) -> Path:
         """Resolve path with sanitization to prevent nested directories.
@@ -326,74 +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,
-                env=self._env,
-            )
-
-            output_parts = []
-            if result.stdout:
-                output_parts.append(result.stdout)
-            if result.stderr:
-                stderr_lines = result.stderr.strip().split("\n")
-                output_parts.extend(f"[stderr] {line}" for line in stderr_lines)
-            output = "\n".join(output_parts) if output_parts else ""
-
-            if result.returncode != 0:
-                output = f"{output.rstrip()}\n\nExit code: {result.returncode}"
-
-            truncated = False
-            if len(output) > self._max_output_bytes:
-                output = output[:self._max_output_bytes]
-                output += f"\n\n... Output truncated at {self._max_output_bytes} bytes."
-                truncated = True
-
-            return ExecuteResponse(
-                output=output,
-                exit_code=result.returncode,
-                truncated=truncated,
-            )
-
-        except subprocess.TimeoutExpired:
+        # Validate command safety
+        error = validate_command(command)
+        if error:
             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,
+                output=error,
+                exit_code=1,
                 truncated=False,
             )
 
-    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)
+        # Convert virtual paths to relative paths
+        if self.virtual_mode:
+            command = convert_virtual_paths_in_command(command=command)
+
+        # Delegate to parent for subprocess execution
+        return super().execute(command)

{evoscientist-0.0.1.dev5 → evoscientist-0.0.1.dev7}/EvoScientist/channels/imessage/serve.py

@@ -25,11 +25,6 @@ from typing import Callable
 from . import IMessageChannel, IMessageConfig
 from ..base import OutgoingMessage
 
-logging.basicConfig(
-    level=logging.DEBUG,
-    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-    datefmt="%H:%M:%S",
-)
 logger = logging.getLogger(__name__)
 
 
@@ -223,7 +218,7 @@ class IMessageServer:
                 await self.channel.send(OutgoingMessage(
                     recipient=sender,
                     content=response,
-                    metadata=metadata,
+                    metadata=metadata or {},
                 ))
                 if self._on_activity:
                     try:
@@ -387,7 +382,7 @@ async def async_main():
     config = IMessageConfig(
         cli_path=args.cli_path,
         db_path=args.db_path,
-        allowed_senders=set(args.allowed_senders) if args.allowed_senders else None,
+        allowed_senders=list(args.allowed_senders) if args.allowed_senders else [],
         include_attachments=args.attachments,
     )
 
@@ -421,6 +416,11 @@ async def async_main():
 
 def main():
     """Entry point."""
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+    )
     asyncio.run(async_main())
 
 

evoscientist-0.0.1.dev7/EvoScientist/cli/__init__.py

@@ -0,0 +1,26 @@
+"""EvoScientist CLI package."""
+
+# Backward-compat re-exports (tests import these from EvoScientist.cli)
+from ..stream.state import (  # noqa: F401
+    SubAgentState,
+    StreamState,
+    _parse_todo_items,
+    _build_todo_stats,
+)
+from .channel import ChannelMessage, _ChannelState  # noqa: F401
+from .agent import _deduplicate_run_name  # noqa: F401
+
+from ._app import app  # noqa: F401
+from . import commands  # noqa: F401 — registers @app.command decorators
+
+
+def main():
+    """CLI entry point."""
+    import warnings
+
+    warnings.filterwarnings("ignore", message=".*not known to support tools.*")
+    warnings.filterwarnings("ignore", message=".*type is unknown and inference may fail.*")
+    from .commands import _configure_logging
+
+    _configure_logging()
+    app()

evoscientist-0.0.1.dev7/EvoScientist/cli/_app.py

@@ -0,0 +1,47 @@
+"""Typer application objects — no intra-package imports to avoid circular deps."""
+
+import typer  # type: ignore[import-untyped]
+
+app = typer.Typer(
+    no_args_is_help=False,
+    add_completion=False,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+# Config subcommand group
+config_app = typer.Typer(help="Configuration management commands", invoke_without_command=True)
+app.add_typer(config_app, name="config")
+
+# MCP subcommand group
+_MCP_HELP = """\
+Configure and manage MCP servers
+
+Examples:
+  # Add a local MCP server (stdio auto-detected):
+  EvoSci mcp add local-server python -- /path/to/server.py
+
+  # Add an npx-based server:
+  EvoSci mcp add sequential-thinking npx -- -y @modelcontextprotocol/server-sequential-thinking
+
+  # Add an HTTP server (http auto-detected from URL):
+  EvoSci mcp add docs-langchain https://docs.langchain.com/mcp
+
+  # Add a stdio server with env vars (hardcoded):
+  EvoSci mcp add my-server node --env API_KEY=xxx -- server.js
+
+  # Add a server with runtime env ref (resolved from .env at startup):
+  EvoSci mcp add brave-search npx --env-ref BRAVE_API_KEY -- -y @modelcontextprotocol/server-brave-search
+
+  # Expose to a specific sub-agent (e.g. research-agent):
+  EvoSci mcp add brave-search npx --env-ref BRAVE_API_KEY -e research-agent -- -y @modelcontextprotocol/server-brave-search
+
+  # Expose to multiple agents:
+  EvoSci mcp add local-server python -e main,research-agent,code-agent -- /path/to/server.py
+
+  # Explicit transport override:
+  EvoSci mcp add my-sse https://example.com/sse --transport sse
+
+Sub-agents (-e): planner-agent | research-agent | code-agent | debug-agent | data-analysis-agent | writing-agent
+"""
+mcp_app = typer.Typer(help=_MCP_HELP, invoke_without_command=True)
+app.add_typer(mcp_app, name="mcp")

evoscientist-0.0.1.dev7/EvoScientist/cli/agent.py

@@ -0,0 +1,60 @@
+"""Agent loading and workspace helpers."""
+
+import os
+from datetime import datetime
+from pathlib import Path
+
+from ..paths import new_run_dir, RUNS_DIR
+
+
+def _shorten_path(path: str) -> str:
+    """Shorten absolute path to relative path from current directory."""
+    if not path:
+        return path
+    try:
+        cwd = os.getcwd()
+        if path.startswith(cwd):
+            rel = path[len(cwd):].lstrip(os.sep)
+            return os.path.join(os.path.basename(cwd), rel) if rel else os.path.basename(cwd)
+        return path
+    except Exception:
+        return path
+
+
+def _deduplicate_run_name(name: str, runs_dir: Path = RUNS_DIR) -> str:
+    """Return *name* if available, otherwise *name_1*, *name_2*, etc."""
+    if not (runs_dir / name).exists():
+        return name
+    i = 1
+    while (runs_dir / f"{name}_{i}").exists():
+        i += 1
+    return f"{name}_{i}"
+
+
+def _create_session_workspace(name: str | None = None) -> str:
+    """Create a per-session workspace directory and return its path.
+
+    Args:
+        name: Optional human-friendly run name.  Duplicates are resolved
+              by appending ``_1``, ``_2``, etc.  Falls back to a timestamp
+              if *name* is None.
+    """
+    if name:
+        session_id = _deduplicate_run_name(name)
+    else:
+        session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+    workspace_dir = str(new_run_dir(session_id))
+    os.makedirs(workspace_dir, exist_ok=True)
+    return workspace_dir
+
+
+def _load_agent(workspace_dir: str | None = None, checkpointer=None):
+    """Load the CLI agent with optional persistent checkpointer.
+
+    Args:
+        workspace_dir: Optional per-session workspace directory.
+        checkpointer: Optional LangGraph checkpointer (e.g. ``AsyncSqliteSaver``).
+            Falls back to ``InMemorySaver`` when ``None``.
+    """
+    from ..EvoScientist import create_cli_agent
+    return create_cli_agent(workspace_dir=workspace_dir, checkpointer=checkpointer)