ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/adapters/cli/cli_observer.py

@@ -0,0 +1,268 @@
+import asyncio
+import logging
+import select
+import sys
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Set
+
+from ciris_engine.logic.adapters.base_observer import BaseObserver
+from ciris_engine.logic.buses import BusManager
+from ciris_engine.logic.secrets.service import SecretsService
+from ciris_engine.protocols.services.lifecycle.time import TimeServiceProtocol
+from ciris_engine.schemas.runtime.messages import IncomingMessage
+from ciris_engine.schemas.types import JSONDict
+
+logger = logging.getLogger(__name__)
+
+PASSIVE_CONTEXT_LIMIT = 10
+
+
+class CLIObserver(BaseObserver[IncomingMessage]):
+    """
+    Observer that converts CLI input events into observation payloads.
+    Includes adaptive filtering for message prioritization.
+    """
+
+    def __init__(
+        self,
+        on_observe: Callable[[JSONDict], Awaitable[None]],
+        memory_service: Optional[Any] = None,
+        agent_id: Optional[str] = None,
+        bus_manager: Optional[BusManager] = None,
+        filter_service: Optional[Any] = None,
+        secrets_service: Optional[SecretsService] = None,
+        time_service: Optional[TimeServiceProtocol] = None,
+        *,
+        interactive: bool = True,
+        config: Optional[Any] = None,
+    ) -> None:
+        super().__init__(
+            on_observe,
+            bus_manager=bus_manager,
+            memory_service=memory_service,
+            agent_id=agent_id,
+            filter_service=filter_service,
+            secrets_service=secrets_service,
+            time_service=time_service,
+            origin_service="cli",
+        )
+        self.interactive = interactive
+        self.config = config
+        self._input_task: Optional[asyncio.Task[Any]] = None
+        self._buffered_input_task: Optional[asyncio.Task[Any]] = None
+        self._stop_event = asyncio.Event()
+        self._buffered_input: List[str] = []
+        self._input_ready = asyncio.Event()
+        self._check_for_piped_input()
+
+    def _check_for_piped_input(self) -> None:
+        """Check if there's piped input available and buffer it."""
+        try:
+            # Always respect the interactive setting passed in from configuration
+            # Only check for piped input if we might need to buffer it
+
+            # Check if stdin has data available (non-blocking)
+            if sys.stdin.isatty():
+                # Interactive terminal - no piped input
+                logger.debug("CLI running in interactive terminal")
+                return
+
+            # stdin is not a tty - could be piped input or running in certain environments
+            logger.info("stdin is not a tty - checking for piped input")
+
+            # Only try to read if we're actually in a pipe/redirect situation
+            # and there's data immediately available
+            import os
+
+            if hasattr(sys.stdin, "fileno"):
+                # Use os.fstat to check if stdin is a pipe or regular file
+                stat_info = os.fstat(sys.stdin.fileno())
+                import stat
+
+                # Only read if it's a pipe or regular file with content
+                if stat.S_ISFIFO(stat_info.st_mode) or (stat.S_ISREG(stat_info.st_mode) and stat_info.st_size > 0):
+                    logger.info("Detected piped/redirected input, buffering...")
+
+                    # Read all available lines from stdin
+                    while True:
+                        # Use select to check if data is available with a short timeout
+                        ready, _, _ = select.select([sys.stdin], [], [], 0.1)
+                        if ready:
+                            line = sys.stdin.readline()
+                            if line:
+                                line = line.rstrip("\n")
+                                if line:  # Ignore empty lines
+                                    self._buffered_input.append(line)
+                                    logger.debug(f"Buffered input: {line}")
+                            else:
+                                # EOF reached
+                                break
+                        else:
+                            # No more data available
+                            break
+
+                    if self._buffered_input:
+                        logger.info(f"Buffered {len(self._buffered_input)} input lines")
+                        # Only switch to non-interactive if we actually have piped input
+                        # AND interactive mode wasn't explicitly requested
+                        if self.interactive:
+                            logger.info("Keeping interactive mode as explicitly requested despite piped input")
+                        else:
+                            logger.info("Non-interactive mode confirmed due to piped input")
+                    else:
+                        # No input buffered
+                        logger.info("No piped input detected, keeping configured interactive mode")
+                else:
+                    # Not a pipe or file, keep configured mode
+                    logger.debug("stdin is not a pipe or file, keeping configured interactive mode")
+
+        except Exception as e:
+            logger.warning(f"Error checking for piped input: {e}")
+            # On error, keep configured interactive mode
+            logger.debug("Keeping configured interactive mode after error")
+
+    async def start(self) -> None:
+        """Start the observer and optional input loop."""
+        logger.info("CLIObserver started")
+
+        # Process any buffered input first
+        if self._buffered_input:
+            logger.info(f"Processing {len(self._buffered_input)} buffered input lines")
+            self._buffered_input_task = asyncio.create_task(self._process_buffered_input())
+
+        # Start interactive input loop if needed
+        if self.interactive and self._input_task is None:
+            self._input_task = asyncio.create_task(self._input_loop())
+
+    async def _process_buffered_input(self) -> None:
+        """Process buffered input lines with a delay to ensure system is ready."""
+        # Wait longer to ensure the system completes wakeup and is in WORK state
+        logger.info("Waiting for system to be ready...")
+        await asyncio.sleep(5.0)
+
+        for line in self._buffered_input:
+            logger.info(f"Processing buffered input: {line}")
+
+            # Get channel ID from config or default to "cli"
+            channel_id = "cli"
+            if self.config and hasattr(self.config, "get_home_channel_id"):
+                channel_id = self.config.get_home_channel_id()
+
+            msg = IncomingMessage(
+                message_id=f"cli_buffered_{asyncio.get_event_loop().time()}",
+                content=line,
+                author_id="local_user",
+                author_name="User",
+                channel_id=channel_id,
+            )
+
+            await self.handle_incoming_message(msg)
+
+            # Small delay between messages to avoid overwhelming the system
+            await asyncio.sleep(0.5)
+
+        logger.info("Finished processing buffered input")
+
+        # If not interactive, signal stop after processing
+        if not self.interactive:
+            logger.info("Non-interactive mode, signaling stop")
+            self._stop_event.set()
+
+    async def stop(self) -> None:
+        """Stop the observer and background input loop."""
+        if self._input_task:
+            self._stop_event.set()
+            try:
+                await asyncio.wait_for(self._input_task, timeout=1.0)
+            except asyncio.TimeoutError:
+                logger.warning("Input task did not complete within timeout, cancelling")
+                self._input_task.cancel()
+                try:
+                    await self._input_task
+                except asyncio.CancelledError:
+                    pass  # NOSONAR - Expected when we cancelled the task ourselves in stop()
+            self._input_task = None
+            self._stop_event.clear()
+        logger.info("CLIObserver stopped")
+
+    async def _input_loop(self) -> None:
+        """Read lines from stdin and handle them as messages."""
+        try:
+            while not self._stop_event.is_set():
+                try:
+                    line = await asyncio.to_thread(input, ">>> ")
+                except (EOFError, KeyboardInterrupt):
+                    logger.info("Input terminated (EOF or interrupt), stopping input loop")
+                    self._stop_event.set()
+                    break
+                except asyncio.CancelledError:
+                    logger.debug("Input loop cancelled")
+                    raise
+
+                if not line:
+                    continue
+                if line.lower() in {"exit", "quit", "bye"}:
+                    self._stop_event.set()
+                    break
+
+                # Get channel ID from config or default to "cli"
+                channel_id = "cli"
+                if self.config and hasattr(self.config, "get_home_channel_id"):
+                    channel_id = self.config.get_home_channel_id()
+
+                msg = IncomingMessage(
+                    message_id=f"cli_{asyncio.get_event_loop().time()}",
+                    content=line,
+                    author_id="local_user",
+                    author_name="User",
+                    channel_id=channel_id,
+                )
+                await self.handle_incoming_message(msg)
+        except (EOFError, KeyboardInterrupt):
+            logger.info("Input loop terminated (EOF or interrupt)")
+            self._stop_event.set()
+        except asyncio.CancelledError:
+            logger.debug("Input loop task cancelled")
+            raise
+
+    async def _get_recall_ids(self, msg: IncomingMessage) -> Set[str]:
+        import socket
+
+        return {f"channel/{socket.gethostname()}"}
+
+    def _is_cli_channel(self, channel_id: Optional[str]) -> bool:
+        """Check if a channel ID belongs to this CLI observer instance."""
+        if not channel_id:
+            return False
+
+        if channel_id == "cli":
+            return True
+
+        # Check if it starts with "cli_" (buffered input format)
+        if channel_id.startswith("cli_"):
+            return True
+
+        if self.config and hasattr(self.config, "get_home_channel_id"):
+            config_channel = self.config.get_home_channel_id()
+            if config_channel and channel_id == config_channel:
+                return True
+
+        import socket
+
+        hostname_channel = socket.gethostname()
+        if channel_id == hostname_channel or channel_id == f"channel/{hostname_channel}":
+            return True
+
+        import getpass
+
+        user_hostname = f"{getpass.getuser()}@{socket.gethostname()}"
+        if channel_id == user_hostname:
+            return True
+
+        return False
+
+    async def _should_process_message(self, msg: IncomingMessage) -> bool:
+        """Check if CLI observer should process this message."""
+        return self._is_cli_channel(msg.channel_id)
+
+    # Remove the custom _handle_priority_observation and _handle_passive_observation
+    # since they just check _is_cli_channel which is now done in _should_process_message

ciris_engine/logic/adapters/cli/cli_tools.py

@@ -0,0 +1,427 @@
+import asyncio
+import os
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+import aiofiles
+
+from ciris_engine.logic import persistence
+from ciris_engine.logic.services.base_service import BaseService
+from ciris_engine.logic.utils.jsondict_helpers import get_str
+from ciris_engine.protocols.services import ToolService
+from ciris_engine.protocols.services.lifecycle.time import TimeServiceProtocol
+from ciris_engine.schemas.adapters.cli_tools import (
+    ListFilesParams,
+    ListFilesResult,
+    ReadFileParams,
+    ReadFileResult,
+    SearchMatch,
+    SearchTextParams,
+    SearchTextResult,
+    ShellCommandParams,
+    ShellCommandResult,
+    WriteFileParams,
+    WriteFileResult,
+)
+from ciris_engine.schemas.adapters.tools import ToolExecutionResult, ToolExecutionStatus, ToolInfo, ToolParameterSchema
+from ciris_engine.schemas.runtime.enums import ServiceType
+from ciris_engine.schemas.services.core import ServiceCapabilities, ServiceStatus
+from ciris_engine.schemas.telemetry.core import ServiceCorrelation, ServiceCorrelationStatus
+from ciris_engine.schemas.types import JSONDict
+
+
+class CLIToolService(BaseService, ToolService):
+    """Simple ToolService providing local filesystem browsing."""
+
+    def __init__(self, time_service: TimeServiceProtocol) -> None:
+        # Initialize BaseService with proper arguments
+        super().__init__(time_service=time_service, service_name="CLIToolService")
+        # ToolService is a Protocol, no need to call its __init__
+        self._results: Dict[str, ToolExecutionResult] = {}
+        self._tools = {
+            "list_files": self._list_files,
+            "read_file": self._read_file,
+            "write_file": self._write_file,
+            "shell_command": self._shell_command,
+            "search_text": self._search_text,
+        }
+        # Track tool executions
+        self._tool_executions = 0
+        self._tool_failures = 0
+
+    async def start(self) -> None:
+        """Start the CLI tool service."""
+        await BaseService.start(self)
+
+    async def stop(self) -> None:
+        """Stop the CLI tool service."""
+        await BaseService.stop(self)
+
+    async def execute_tool(self, tool_name: str, parameters: JSONDict) -> ToolExecutionResult:
+        # Track request for telemetry
+        self._track_request()
+        self._tool_executions += 1
+
+        correlation_id = get_str(parameters, "correlation_id", str(uuid.uuid4()))
+        now = datetime.now(timezone.utc)
+        corr = ServiceCorrelation(
+            correlation_id=correlation_id,
+            service_type="cli",
+            handler_name="CLIToolService",
+            action_type=tool_name,
+            created_at=now,
+            updated_at=now,
+            timestamp=now,
+            status=ServiceCorrelationStatus.PENDING,
+        )
+        persistence.add_correlation(corr)
+
+        # Assert time_service is available
+        assert self._time_service is not None
+        start_time = self._time_service.timestamp()
+
+        # Declare result type explicitly to allow mixed types (str error, float execution_time_ms)
+        result: JSONDict
+        success: bool
+        error_msg: Optional[str]
+
+        if tool_name not in self._tools:
+            # Unknown tool - track as failure
+            # Note: _tool_executions already incremented above
+            self._tool_failures += 1
+            result = {"error": f"Unknown tool: {tool_name}"}
+            success = False
+            error_msg = f"Unknown tool: {tool_name}"
+        else:
+            try:
+                result = await self._tools[tool_name](parameters)
+                # FAIL FAST: Result MUST be a dict (until we have proper typed tool results)
+                if not isinstance(result, dict):
+                    raise TypeError(
+                        f"Tool {tool_name} returned non-dict result: {type(result).__name__}. "
+                        "Tools MUST return typed dict results!"
+                    )
+                success = result.get("error") is None
+                error_value = result.get("error")
+                error_msg = str(error_value) if error_value is not None else None
+            except Exception as e:
+                # Track error for telemetry
+                self._track_error(e)
+                self._tool_failures += 1
+                result = {"error": str(e)}
+                success = False
+                error_msg = str(e)
+
+        execution_time_ms = (self._time_service.timestamp() - start_time) * 1000  # milliseconds
+
+        # Add execution time to result data
+        if result is None:
+            result = {}
+        if isinstance(result, dict):
+            result["_execution_time_ms"] = execution_time_ms
+
+        tool_result = ToolExecutionResult(
+            tool_name=tool_name,
+            status=ToolExecutionStatus.COMPLETED if success else ToolExecutionStatus.FAILED,
+            success=success,
+            data=result,
+            error=error_msg,
+            correlation_id=correlation_id,
+        )
+
+        if correlation_id:
+            self._results[correlation_id] = tool_result
+            # Update the correlation we created earlier
+            corr.status = ServiceCorrelationStatus.COMPLETED
+            corr.updated_at = datetime.now(timezone.utc)
+            persistence.update_correlation(correlation_id, corr, self._time_service)
+        return tool_result
+
+    async def _list_files(self, params: JSONDict) -> JSONDict:
+        """List files using typed parameters."""
+        # Parse parameters
+        list_params = ListFilesParams.model_validate(params)
+
+        try:
+            files = sorted(os.listdir(list_params.path))
+            result = ListFilesResult(files=files, path=list_params.path)
+            return result.model_dump()
+        except Exception as e:
+            result = ListFilesResult(files=[], path=list_params.path, error=str(e))
+            return result.model_dump()
+
+    async def _read_file(self, params: JSONDict) -> JSONDict:
+        """Read file contents using typed parameters."""
+        try:
+            # Parse and validate parameters
+            read_params = ReadFileParams.model_validate(params)
+
+            async with aiofiles.open(read_params.path, "r") as f:
+                content = await f.read()
+                result = ReadFileResult(content=content, path=read_params.path)
+                return result.model_dump()
+        except ValueError:
+            # Parameter validation error
+            result = ReadFileResult(error="path parameter required")
+            return result.model_dump()
+        except Exception as e:
+            result = ReadFileResult(error=str(e))
+            return result.model_dump()
+
+    async def _write_file(self, params: JSONDict) -> JSONDict:
+        """Write file using typed parameters."""
+        try:
+            # Parse and validate parameters
+            write_params = WriteFileParams.model_validate(params)
+
+            await asyncio.to_thread(self._write_file_sync, write_params.path, write_params.content)
+            result = WriteFileResult(status="written", path=write_params.path)
+            return result.model_dump()
+        except ValueError:
+            # Parameter validation error
+            result = WriteFileResult(error="path parameter required")
+            return result.model_dump()
+        except Exception as e:
+            result = WriteFileResult(error=str(e))
+            return result.model_dump()
+
+    def _write_file_sync(self, path: str, content: str) -> None:
+        with open(path, "w") as f:
+            f.write(content)
+
+    async def _shell_command(self, params: JSONDict) -> JSONDict:
+        """Execute shell command using typed parameters."""
+        try:
+            # Parse and validate parameters
+            shell_params = ShellCommandParams.model_validate(params)
+
+            proc = await asyncio.create_subprocess_shell(
+                shell_params.command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await proc.communicate()
+
+            result = ShellCommandResult(stdout=stdout.decode(), stderr=stderr.decode(), returncode=proc.returncode)
+            return result.model_dump()
+        except ValueError:
+            # Parameter validation error
+            result = ShellCommandResult(error="command parameter required")
+            return result.model_dump()
+        except Exception as e:
+            result = ShellCommandResult(error=str(e))
+            return result.model_dump()
+
+    async def _search_text(self, params: JSONDict) -> JSONDict:
+        """Search text in file using typed parameters."""
+        try:
+            # Parse and validate parameters
+            search_params = SearchTextParams.model_validate(params)
+
+            matches: List[SearchMatch] = []
+            lines = await asyncio.to_thread(self._read_lines_sync, search_params.path)
+            for idx, line in enumerate(lines, 1):
+                if search_params.pattern in line:
+                    matches.append(SearchMatch(line=idx, text=line.strip()))
+
+            result = SearchTextResult(matches=matches)
+            return result.model_dump()
+        except ValueError:
+            # Parameter validation error
+            result = SearchTextResult(error="pattern and path required")
+            return result.model_dump()
+        except Exception as e:
+            result = SearchTextResult(error=str(e))
+            return result.model_dump()
+
+    def _read_lines_sync(self, path: str) -> List[str]:
+        with open(path, "r") as f:
+            return f.readlines()
+
+    async def get_available_tools(self) -> List[str]:
+        return list(self._tools.keys())
+
+    async def get_tool_result(self, correlation_id: str, timeout: float = 30.0) -> Optional[ToolExecutionResult]:
+        for _ in range(int(timeout * 10)):
+            if correlation_id in self._results:
+                return self._results.pop(correlation_id)
+            await asyncio.sleep(0.1)
+        return None
+
+    async def validate_parameters(self, tool_name: str, parameters: JSONDict) -> bool:
+        return tool_name in self._tools
+
+    async def list_tools(self) -> List[str]:
+        """List available tools - required by ToolServiceProtocol."""
+        return list(self._tools.keys())
+
+    async def get_tool_schema(self, tool_name: str) -> Optional[ToolParameterSchema]:
+        """Get parameter schema for a specific tool - required by ToolServiceProtocol."""
+        # Define schemas for each tool
+        schemas = {
+            "list_files": ToolParameterSchema(
+                type="object",
+                properties={
+                    "path": {"type": "string", "description": "Directory path to list files from", "default": "."}
+                },
+                required=[],
+            ),
+            "read_file": ToolParameterSchema(
+                type="object",
+                properties={"path": {"type": "string", "description": "File path to read"}},
+                required=["path"],
+            ),
+            "write_file": ToolParameterSchema(
+                type="object",
+                properties={
+                    "path": {"type": "string", "description": "File path to write"},
+                    "content": {"type": "string", "description": "Content to write to file"},
+                },
+                required=["path", "content"],
+            ),
+            "shell_command": ToolParameterSchema(
+                type="object",
+                properties={"command": {"type": "string", "description": "Shell command to execute"}},
+                required=["command"],
+            ),
+            "search_text": ToolParameterSchema(
+                type="object",
+                properties={
+                    "path": {"type": "string", "description": "Directory path to search in"},
+                    "pattern": {"type": "string", "description": "Text pattern to search for"},
+                },
+                required=["path", "pattern"],
+            ),
+        }
+        return schemas.get(tool_name)
+
+    async def get_tool_info(self, tool_name: str) -> Optional[ToolInfo]:
+        """Get detailed information about a specific tool."""
+        if tool_name not in self._tools:
+            return None
+
+        # Tool information for each built-in tool
+        tool_infos = {
+            "list_files": ToolInfo(
+                name="list_files",
+                description="List files in a directory",
+                parameters=ToolParameterSchema(
+                    type="object",
+                    properties={
+                        "path": {"type": "string", "description": "Directory path to list files from", "default": "."}
+                    },
+                    required=[],
+                ),
+                category="filesystem",
+                cost=0.0,
+                when_to_use="Use when you need to see what files are in a directory",
+            ),
+            "read_file": ToolInfo(
+                name="read_file",
+                description="Read the contents of a file",
+                parameters=ToolParameterSchema(
+                    type="object",
+                    properties={"path": {"type": "string", "description": "File path to read"}},
+                    required=["path"],
+                ),
+                category="filesystem",
+                cost=0.0,
+                when_to_use="Use when you need to read file contents",
+            ),
+            "write_file": ToolInfo(
+                name="write_file",
+                description="Write content to a file",
+                parameters=ToolParameterSchema(
+                    type="object",
+                    properties={
+                        "path": {"type": "string", "description": "File path to write"},
+                        "content": {"type": "string", "description": "Content to write to file"},
+                    },
+                    required=["path", "content"],
+                ),
+                category="filesystem",
+                cost=0.0,
+                when_to_use="Use when you need to create or modify a file",
+            ),
+            "shell_command": ToolInfo(
+                name="shell_command",
+                description="Execute a shell command",
+                parameters=ToolParameterSchema(
+                    type="object",
+                    properties={"command": {"type": "string", "description": "Shell command to execute"}},
+                    required=["command"],
+                ),
+                category="system",
+                cost=0.0,
+                when_to_use="Use when you need to run system commands",
+            ),
+            "search_text": ToolInfo(
+                name="search_text",
+                description="Search for text patterns in files",
+                parameters=ToolParameterSchema(
+                    type="object",
+                    properties={
+                        "path": {"type": "string", "description": "Directory path to search in"},
+                        "pattern": {"type": "string", "description": "Text pattern to search for"},
+                    },
+                    required=["path", "pattern"],
+                ),
+                category="filesystem",
+                cost=0.0,
+                when_to_use="Use when you need to find specific text in files",
+            ),
+        }
+
+        return tool_infos.get(tool_name)
+
+    async def get_all_tool_info(self) -> List[ToolInfo]:
+        """Get detailed information about all available tools."""
+        tool_infos = []
+        for tool_name in self._tools.keys():
+            tool_info = await self.get_tool_info(tool_name)
+            if tool_info:
+                tool_infos.append(tool_info)
+        return tool_infos
+
+    async def is_healthy(self) -> bool:
+        """Check if the service is healthy."""
+        return True
+
+    def get_service_type(self) -> ServiceType:
+        """Get the type of this service."""
+        return ServiceType.ADAPTER
+
+    def get_capabilities(self) -> ServiceCapabilities:
+        """Get service capabilities."""
+        return ServiceCapabilities(
+            service_name="CLIToolService",
+            actions=["execute_tool", "get_available_tools", "get_tool_schema", "get_tool_result"],
+            version="1.0.0",
+            dependencies=[],
+            metadata=None,
+        )
+
+    def _collect_custom_metrics(self) -> Dict[str, float]:
+        """Collect CLI tool service specific metrics."""
+        return {
+            "tools_count": float(len(self._tools)),
+            "tool_executions_total": float(self._tool_executions),
+            "tool_failures_total": float(self._tool_failures),
+            "tool_success_rate": float(self._tool_executions - self._tool_failures) / max(1, self._tool_executions),
+            "results_cached": float(len(self._results)),
+        }
+
+    def _get_actions(self) -> List[str]:
+        """Get the list of actions this service supports."""
+        return [
+            "execute_tool",
+            "get_available_tools",
+            "get_tool_result",
+            "validate_parameters",
+            "get_tool_info",
+            "get_all_tool_info",
+        ]
+
+    def _check_dependencies(self) -> bool:
+        """Check if all dependencies are satisfied."""
+        # CLIToolService has no hard dependencies
+        return True