atlas-chat 0.1.0__py3-none-any.whl

atlas/infrastructure/events/cli_event_publisher.py

@@ -0,0 +1,140 @@
+"""CLI event publisher for headless/non-interactive use."""
+
+import logging
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CLICollectedResult:
+    """Structured result from a collected CLI chat session."""
+
+    message: str = ""
+    tool_calls: List[Dict[str, Any]] = field(default_factory=list)
+    files: Dict[str, Any] = field(default_factory=dict)
+    canvas_content: Optional[str] = None
+    raw_events: List[Dict[str, Any]] = field(default_factory=list)
+
+
+class CLIEventPublisher:
+    """
+    Event publisher for CLI / headless usage.
+
+    Two modes:
+    - streaming: prints token text to stdout, tool/status info to stderr
+    - collecting: buffers all events, returns structured result
+    """
+
+    def __init__(self, streaming: bool = True, quiet: bool = False):
+        self.streaming = streaming
+        self.quiet = quiet
+        self._collected = CLICollectedResult()
+
+    def get_result(self) -> CLICollectedResult:
+        """Return the collected result (useful in collecting mode)."""
+        return self._collected
+
+    async def publish_chat_response(
+        self,
+        message: str,
+        has_pending_tools: bool = False,
+    ) -> None:
+        self._collected.message += message
+        if self.streaming:
+            sys.stdout.write(message)
+            sys.stdout.flush()
+
+    async def publish_response_complete(self) -> None:
+        if self.streaming:
+            # Ensure final newline
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+
+    async def publish_agent_update(
+        self,
+        update_type: str,
+        **kwargs: Any,
+    ) -> None:
+        event = {"type": "agent_update", "update_type": update_type, **kwargs}
+        self._collected.raw_events.append(event)
+        if self.streaming and not self.quiet:
+            _print_status(f"[agent] {update_type}")
+
+    async def publish_tool_start(
+        self,
+        tool_name: str,
+        **kwargs: Any,
+    ) -> None:
+        self._collected.tool_calls.append({"tool": tool_name, "status": "started"})
+        if self.streaming and not self.quiet:
+            _print_status(f"[tool] {tool_name} ...")
+
+    async def publish_tool_complete(
+        self,
+        tool_name: str,
+        result: Any,
+        **kwargs: Any,
+    ) -> None:
+        # Update last matching tool call
+        for tc in reversed(self._collected.tool_calls):
+            if tc["tool"] == tool_name and tc["status"] == "started":
+                tc["status"] = "complete"
+                tc["result"] = result
+                break
+        if self.streaming and not self.quiet:
+            _print_status(f"[tool] {tool_name} done")
+
+    async def publish_files_update(
+        self,
+        files: Dict[str, Any],
+    ) -> None:
+        self._collected.files.update(files)
+        if self.streaming and not self.quiet:
+            _print_status(f"[files] {len(files)} file(s)")
+
+    async def publish_canvas_content(
+        self,
+        content: str,
+        content_type: str = "text/html",
+        **kwargs: Any,
+    ) -> None:
+        self._collected.canvas_content = content
+
+    async def send_json(self, data: Dict[str, Any]) -> None:
+        self._collected.raw_events.append(data)
+        if self.streaming and not self.quiet:
+            msg_type = data.get("type", "")
+            if msg_type == "tool_start":
+                tool_name = data.get("tool_name", "unknown")
+                args = data.get("arguments", {})
+                _print_status(f"[tool] {tool_name} called with: {args}")
+            elif msg_type == "tool_complete":
+                tool_name = data.get("tool_name", "unknown")
+                success = data.get("success", False)
+                result = data.get("result", "")
+                status = "ok" if success else "error"
+                _print_status(f"[tool] {tool_name} {status}: {result}")
+
+    async def publish_elicitation_request(
+        self,
+        elicitation_id: str,
+        tool_call_id: str,
+        tool_name: str,
+        message: str,
+        response_schema: Dict[str, Any],
+    ) -> None:
+        # CLI cannot handle interactive elicitation; log and skip
+        logger.warning(
+            "Elicitation requested by tool %s but CLI mode cannot respond interactively",
+            tool_name,
+        )
+        if self.streaming and not self.quiet:
+            _print_status(f"[elicitation] {tool_name}: {message} (skipped, non-interactive)")
+
+
+def _print_status(text: str) -> None:
+    """Print status/tool info to stderr so stdout stays clean for LLM output."""
+    print(text, file=sys.stderr, flush=True)

atlas/infrastructure/events/websocket_publisher.py

@@ -0,0 +1,140 @@
+"""WebSocket-based event publisher implementation."""
+
+import logging
+from typing import Any, Dict, Optional
+
+from atlas.application.chat.utilities import event_notifier
+from atlas.interfaces.transport import ChatConnectionProtocol
+
+logger = logging.getLogger(__name__)
+
+
+class WebSocketEventPublisher:
+    """
+    WebSocket implementation of EventPublisher.
+
+    Wraps event_notifier and ChatConnectionProtocol to publish
+    events to connected WebSocket clients.
+    """
+
+    def __init__(self, connection: Optional[ChatConnectionProtocol] = None):
+        """
+        Initialize WebSocket event publisher.
+
+        Args:
+            connection: WebSocket connection for sending messages
+        """
+        self.connection = connection
+
+    async def publish_chat_response(
+        self,
+        message: str,
+        has_pending_tools: bool = False,
+    ) -> None:
+        """Publish a chat response message."""
+        if self.connection:
+            await event_notifier.notify_chat_response(
+                message=message,
+                has_pending_tools=has_pending_tools,
+                update_callback=self.connection.send_json,
+            )
+
+    async def publish_response_complete(self) -> None:
+        """Signal that the response is complete."""
+        if self.connection:
+            await event_notifier.notify_response_complete(
+                self.connection.send_json
+            )
+
+    async def publish_agent_update(
+        self,
+        update_type: str,
+        **kwargs: Any
+    ) -> None:
+        """Publish an agent-specific update."""
+        if self.connection:
+            await event_notifier.notify_agent_update(
+                update_type=update_type,
+                connection=self.connection,
+                **kwargs
+            )
+
+    async def publish_tool_start(
+        self,
+        tool_name: str,
+        **kwargs: Any
+    ) -> None:
+        """Publish notification that a tool is starting."""
+        if self.connection:
+            await event_notifier.notify_agent_update(
+                update_type="tool_start",
+                connection=self.connection,
+                tool=tool_name,
+                **kwargs
+            )
+
+    async def publish_tool_complete(
+        self,
+        tool_name: str,
+        result: Any,
+        **kwargs: Any
+    ) -> None:
+        """Publish notification that a tool has completed."""
+        if self.connection:
+            await event_notifier.notify_agent_update(
+                update_type="tool_complete",
+                connection=self.connection,
+                tool=tool_name,
+                result=result,
+                **kwargs
+            )
+
+    async def publish_files_update(
+        self,
+        files: Dict[str, Any]
+    ) -> None:
+        """Publish update about session files."""
+        if self.connection:
+            await self.connection.send_json({
+                "type": "files_update",
+                "files": files
+            })
+
+    async def publish_canvas_content(
+        self,
+        content: str,
+        content_type: str = "text/html",
+        **kwargs: Any
+    ) -> None:
+        """Publish content for canvas display."""
+        if self.connection:
+            await self.connection.send_json({
+                "type": "canvas_content",
+                "content": content,
+                "content_type": content_type,
+                **kwargs
+            })
+
+    async def send_json(self, data: Dict[str, Any]) -> None:
+        """Send raw JSON message."""
+        if self.connection:
+            await self.connection.send_json(data)
+
+    async def publish_elicitation_request(
+        self,
+        elicitation_id: str,
+        tool_call_id: str,
+        tool_name: str,
+        message: str,
+        response_schema: Dict[str, Any]
+    ) -> None:
+        """Publish an elicitation request to the user."""
+        if self.connection:
+            await self.connection.send_json({
+                "type": "elicitation_request",
+                "elicitation_id": elicitation_id,
+                "tool_call_id": tool_call_id,
+                "tool_name": tool_name,
+                "message": message,
+                "response_schema": response_schema
+            })

atlas/infrastructure/sessions/in_memory_repository.py

@@ -0,0 +1,56 @@
+"""In-memory session repository implementation."""
+
+import logging
+from typing import Dict, Optional
+from uuid import UUID
+
+from atlas.domain.errors import SessionNotFoundError
+from atlas.domain.sessions.models import Session
+
+logger = logging.getLogger(__name__)
+
+
+class InMemorySessionRepository:
+    """
+    In-memory implementation of SessionRepository.
+
+    Stores sessions in a dictionary. Suitable for single-instance deployments
+    or testing. For distributed systems, use Redis or database-backed implementation.
+    """
+
+    def __init__(self):
+        """Initialize empty session storage."""
+        self._sessions: Dict[UUID, Session] = {}
+
+    async def get(self, session_id: UUID) -> Optional[Session]:
+        """Retrieve a session by ID."""
+        return self._sessions.get(session_id)
+
+    async def create(self, session: Session) -> Session:
+        """Create and store a new session."""
+        self._sessions[session.id] = session
+        logger.info(f"Created session {session.id} for user {session.user_email}")
+        return session
+
+    async def update(self, session: Session) -> Session:
+        """Update an existing session."""
+        if session.id not in self._sessions:
+            raise SessionNotFoundError(
+                f"Session {session.id} not found",
+                code="SESSION_NOT_FOUND"
+            )
+        self._sessions[session.id] = session
+        return session
+
+    async def delete(self, session_id: UUID) -> bool:
+        """Delete a session."""
+        if session_id in self._sessions:
+            self._sessions[session_id].active = False
+            logger.info(f"Deleted session {session_id}")
+            del self._sessions[session_id]
+            return True
+        return False
+
+    async def exists(self, session_id: UUID) -> bool:
+        """Check if a session exists."""
+        return session_id in self._sessions

atlas/infrastructure/transport/__init__.py

@@ -0,0 +1,7 @@
+"""Transport adapters."""
+
+from .websocket_connection_adapter import WebSocketConnectionAdapter
+
+__all__ = [
+    "WebSocketConnectionAdapter",
+]

atlas/infrastructure/transport/websocket_connection_adapter.py

@@ -0,0 +1,33 @@
+"""WebSocket connection adapter implementing ChatConnectionProtocol."""
+
+from typing import Any, Dict, Optional
+
+from fastapi import WebSocket
+
+
+class WebSocketConnectionAdapter:
+    """
+    Adapter that wraps FastAPI WebSocket to implement ChatConnectionProtocol.
+    This isolates the application layer from FastAPI-specific types.
+    """
+
+    def __init__(self, websocket: WebSocket, user_email: Optional[str] = None):
+        """Initialize with FastAPI WebSocket and associated user."""
+        self.websocket = websocket
+        self.user_email = user_email
+
+    async def send_json(self, data: Dict[str, Any]) -> None:
+        """Send JSON data to the client."""
+        await self.websocket.send_json(data)
+
+    async def receive_json(self) -> Dict[str, Any]:
+        """Receive JSON data from the client."""
+        return await self.websocket.receive_json()
+
+    async def accept(self) -> None:
+        """Accept the connection."""
+        await self.websocket.accept()
+
+    async def close(self) -> None:
+        """Close the connection."""
+        await self.websocket.close()

atlas/init_cli.py

@@ -0,0 +1,226 @@
+"""
+Atlas Init CLI - Set up configuration files for Atlas.
+
+Usage:
+    atlas-init                    # Interactive setup in current directory
+    atlas-init --target ./myapp   # Setup in specific directory
+    atlas-init --minimal          # Create minimal .env only
+    atlas-init --force            # Overwrite existing files without prompting
+"""
+
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+
+def get_package_root() -> Path:
+    """Get the root directory of the atlas package."""
+    return Path(__file__).resolve().parent.parent
+
+
+def get_config_defaults_dir() -> Path:
+    """Get the path to config/defaults in the package."""
+    return get_package_root() / "config" / "defaults"
+
+
+def get_env_example_path() -> Path:
+    """Get the path to .env.example in the package."""
+    return get_package_root() / ".env.example"
+
+
+def prompt_yes_no(message: str, default: bool = False) -> bool:
+    """Prompt user for yes/no confirmation."""
+    suffix = " [Y/n]: " if default else " [y/N]: "
+    while True:
+        response = input(message + suffix).strip().lower()
+        if response == "":
+            return default
+        if response in ("y", "yes"):
+            return True
+        if response in ("n", "no"):
+            return False
+        print("Please enter 'y' or 'n'")
+
+
+def copy_with_prompt(src: Path, dst: Path, force: bool = False) -> bool:
+    """Copy a file, prompting if destination exists."""
+    if dst.exists() and not force:
+        if not prompt_yes_no(f"  {dst} already exists. Overwrite?"):
+            print(f"  Skipping {dst.name}")
+            return False
+
+    if src.is_dir():
+        if dst.exists():
+            shutil.rmtree(dst)
+        shutil.copytree(src, dst)
+    else:
+        shutil.copy2(src, dst)
+
+    print(f"  Created {dst}")
+    return True
+
+
+def create_minimal_env(target_dir: Path, force: bool = False) -> bool:
+    """Create a minimal .env file with just API key placeholders."""
+    env_path = target_dir / ".env"
+
+    if env_path.exists() and not force:
+        if not prompt_yes_no(f"  {env_path} already exists. Overwrite?"):
+            print(f"  Skipping {env_path.name}")
+            return False
+
+    minimal_env = """\
+# Atlas Configuration
+# See https://github.com/sandialabs/atlas-ui-3 for full documentation
+
+# =============================================================================
+# LLM API Keys (set at least one)
+# =============================================================================
+OPENAI_API_KEY=your-openai-api-key-here
+ANTHROPIC_API_KEY=your-anthropic-api-key-here
+# GOOGLE_API_KEY=your-google-api-key-here
+
+# =============================================================================
+# Server Settings
+# =============================================================================
+PORT=8000
+DEBUG_MODE=true
+
+# =============================================================================
+# Optional: Custom config location
+# Uncomment and set if you have custom config files
+# =============================================================================
+# APP_CONFIG_OVERRIDES=./config
+
+# =============================================================================
+# Optional: RAG Configuration
+# =============================================================================
+# FEATURE_RAG_ENABLED=false
+# ATLAS_RAG_URL=https://your-rag-api.example.com
+# ATLAS_RAG_BEARER_TOKEN=your-api-key-here
+"""
+
+    env_path.write_text(minimal_env)
+    print(f"  Created {env_path}")
+    return True
+
+
+def run_init(args: argparse.Namespace) -> int:
+    """Run the atlas-init command."""
+    target_dir = Path(args.target).resolve()
+
+    # Ensure target directory exists
+    if not target_dir.exists():
+        if not args.force:
+            if not prompt_yes_no(f"Directory {target_dir} does not exist. Create it?", default=True):
+                print("Aborted.")
+                return 1
+        target_dir.mkdir(parents=True, exist_ok=True)
+        print(f"Created directory: {target_dir}")
+
+    print(f"\nSetting up Atlas configuration in: {target_dir}\n")
+
+    config_defaults = get_config_defaults_dir()
+    env_example = get_env_example_path()
+
+    if args.minimal:
+        # Minimal mode: just create a simple .env
+        print("Creating minimal configuration...")
+        create_minimal_env(target_dir, force=args.force)
+    else:
+        # Full mode: copy config and .env
+        print("Copying configuration files...")
+
+        # Copy config/defaults to target/config
+        if config_defaults.exists():
+            target_config = target_dir / "config"
+            copy_with_prompt(config_defaults, target_config, force=args.force)
+        else:
+            print(f"  Warning: Config defaults not found at {config_defaults}")
+
+        # Copy .env.example to .env
+        if env_example.exists():
+            target_env = target_dir / ".env"
+            if copy_with_prompt(env_example, target_env, force=args.force):
+                print("\n  Remember to edit .env and add your API keys!")
+        else:
+            # Fall back to creating minimal env
+            print("  .env.example not found, creating minimal .env...")
+            create_minimal_env(target_dir, force=args.force)
+
+    print("\n" + "=" * 60)
+    print("Setup complete!")
+    print("=" * 60)
+    print("\nNext steps:")
+    print(f"  1. Edit {target_dir / '.env'} and add your API keys")
+    print("  2. Run: atlas-chat 'Hello, world!'")
+    print("  3. Or start the server: atlas-server")
+
+    if not args.minimal:
+        print(f"\nConfig files are in: {target_dir / 'config'}")
+        print("  - llmconfig.yml: LLM model configurations")
+        print("  - mcp.json: MCP tool server configurations")
+
+    print()
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build argument parser for atlas-init CLI."""
+    parser = argparse.ArgumentParser(
+        prog="atlas-init",
+        description="Set up Atlas configuration files in your project directory.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  atlas-init                    Set up config in current directory
+  atlas-init --target ./myapp   Set up config in ./myapp
+  atlas-init --minimal          Create only a minimal .env file
+  atlas-init --force            Overwrite existing files without prompting
+
+After running atlas-init, edit the .env file to add your API keys.
+""",
+    )
+    parser.add_argument(
+        "--target",
+        "-t",
+        default=".",
+        help="Target directory for configuration files (default: current directory).",
+    )
+    parser.add_argument(
+        "--minimal",
+        "-m",
+        action="store_true",
+        help="Create only a minimal .env file (no config folder).",
+    )
+    parser.add_argument(
+        "--force",
+        "-f",
+        action="store_true",
+        help="Overwrite existing files without prompting.",
+    )
+    parser.add_argument(
+        "--version",
+        action="store_true",
+        help="Print version and exit.",
+    )
+    return parser
+
+
+def main() -> None:
+    """Main entry point for atlas-init CLI."""
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.version:
+        from atlas.version import VERSION
+
+        print(f"atlas-init version {VERSION}")
+        sys.exit(0)
+
+    sys.exit(run_init(args))
+
+
+if __name__ == "__main__":
+    main()

atlas/interfaces/__init__.py

@@ -0,0 +1,15 @@
+"""Interfaces layer - protocols and contracts."""
+
+from .llm import LLMProtocol, LLMResponse
+from .rag import RAGClientProtocol
+from .tools import ToolManagerProtocol, ToolProtocol
+from .transport import ChatConnectionProtocol
+
+__all__ = [
+    "LLMProtocol",
+    "LLMResponse",
+    "RAGClientProtocol",
+    "ToolProtocol",
+    "ToolManagerProtocol",
+    "ChatConnectionProtocol",
+]