sourcebot 0.1.0__py3-none-any.whl

sourcebot/context/context_builder.py

@@ -0,0 +1,78 @@
+
+# sourcebot/context/context_builder.py
+from pathlib import Path
+from typing import Optional, List
+from sourcebot.context.identity import get_identity
+from sourcebot.context.skill import SkillLoader, SkillSummary
+from sourcebot.prompt import DECOMPOSER_PROMPT, SUBAGENT_PROMPT
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ContextBuilder:
+    """Build system prompts, including identity, rules, memories, and skills."""
+    def __init__(
+        self, 
+        workspace: Path, 
+        skill_storage,
+        rules_loader,
+    ):
+        self.workspace = workspace
+        self.rules_loader = rules_loader
+        self.skill_loader = SkillLoader(skill_storage)
+    
+
+    def build_chat_prompt(self):
+      parts = [get_identity(str(self.workspace))]
+      return "\n\n---\n\n".join(parts)
+    
+    # identity + rules + skill 
+    def build_system_prompt(self, skill_names: Optional[List[str]] = None) -> str:
+        """Assemble the complete system prompt."""
+
+        parts = [get_identity(str(self.workspace))]
+        # Bootstrap rules
+        rules = self.build_rulse()
+        if rules:
+            parts.append(rules)
+
+        skills_summary = self.build_skills_summary()
+        if skills_summary:
+            parts.append(skills_summary)
+        return "\n\n---\n\n".join(parts)
+
+    def build_subagent_prompt(self, workspace: Optional[Path] = None) -> str:
+        """Build a focused system prompt for the subagent."""
+        from datetime import datetime
+        import time as _time
+        now = datetime.now().strftime("%Y-%m-%d %H:%M (%A)")
+        tz = _time.strftime("%Z") or "UTC"
+
+        return SUBAGENT_PROMPT.format(
+                now = now,
+                tz = tz,
+                workspace = "/workspace"
+        )
+
+
+    def build_skills_summary(self) -> str: 
+        all_skills = self.skill_loader.list_skills(filter_unavailable=False)
+        skills_summary = SkillSummary.generate(all_skills, pretty=True)
+        return f"""# Skills
+The following skills extend your capabilities. To use a skill, get its SKILL.md file using the skill_detail tool.
+Skills with available="false" need dependencies installed first - you can try installing them with apt/brew.
+{skills_summary}"""
+
+    def build_rulse(self, skill_names: Optional[List[str]] = None) -> str:
+        return self.rules_loader.load_common_rules()
+
+    def build_decomposer_prompt(self, skill_names: Optional[List[str]] = None) -> str:
+
+        skills_summary = self.build_skills_summary()
+        rules = self.build_rulse()
+
+        return DECOMPOSER_PROMPT.format(
+                  skills_summary = skills_summary,
+                  rules = rules
+              )
+    

sourcebot/context/identity.py

@@ -0,0 +1,19 @@
+# sourcebot/context/identity.py
+from sourcebot.prompt import IDENTITY_PROMPT
+from datetime import datetime
+import platform
+import time
+
+def get_identity(workspace_path: str) -> str:
+    """Return bot identity/system prompt header."""
+    now = datetime.now().astimezone().strftime("%Y-%m-%d %H:%M (%A)")
+    tz = time.strftime("%Z") or "UTC"
+    system = platform.system()
+    runtime = f"{'macOS' if system == 'Darwin' else system} {platform.machine()}, Python {platform.python_version()}"
+
+    return IDENTITY_PROMPT.format(
+                now = now,
+                tz = tz,
+                runtime = runtime,
+                workspace_path = "/workspace"
+            )

sourcebot/context/message_builder.py

@@ -0,0 +1,154 @@
+# domain/context/message_builder.py
+from pathlib import Path
+from typing import Any, List, Optional, Dict
+import base64
+import mimetypes
+from sourcebot.context import ContextBuilder
+from sourcebot.llm.core.message import Message, ToolCall, ToolResult
+from sourcebot.llm.core.message_converter import dict_to_message
+
+import logging
+logger = logging.getLogger(__name__)
+
+class MessageBuilder:
+    """Build messages for LLM including system, user, and tool messages."""
+
+    def __init__(self, context_builder: ContextBuilder):
+        self.context_builder = context_builder
+
+    def _build_user_content(
+        self,
+        text: str,
+        media: Optional[List[str]] = None
+    ) -> Message:
+
+        metadata: Dict[str, Any] = {}
+        media_list: List[Dict[str, Any]] = []
+
+        if media:
+            for path_str in media:
+                p = Path(path_str)
+                mime, _ = mimetypes.guess_type(str(p))
+
+                if not p.is_file() or not mime or not mime.startswith("image/"):
+                    logger.warning(f"Skipping invalid media: {path_str}")
+                    continue
+
+                b64 = base64.b64encode(p.read_bytes()).decode()
+
+                media_list.append({
+                    "filename": p.name,
+                    "mime": mime,
+                    "base64": b64
+                })
+
+        if media_list:
+            metadata["media"] = media_list
+
+        return Message(
+            role = "user",
+            content = text,
+            metadata = metadata,
+        )
+
+    def build_chat_messages(
+        self,
+        current_message: str,
+        history: List[Any] = None,
+        skill_names: Optional[List[str]] = None,
+        media: Optional[List[str]] = None,
+        channel: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+    ) -> List[Message]:
+
+        messages: List[Message] = []
+
+        chat_prompt = self.context_builder.build_chat_prompt()
+        if channel and conversation_id:
+            chat_prompt += f"\n\n## Current Session\nChannel: {channel}\nConversation ID: {conversation_id}"
+
+        messages.append(Message(role="system", content=chat_prompt))
+
+        if history:
+            for msg in history:
+                if isinstance(msg, Message):
+                    messages.append(msg)
+                else:
+                    messages.append(dict_to_message(msg))  
+
+        user_content = self._build_user_content(current_message, media)
+
+        messages.append(
+            Message(
+                role = user_content.role,
+                content = user_content.content,  
+            )
+        )
+
+        return messages
+    
+        # skills + rules 
+        def build_messages(
+            self,
+            current_message: str,
+            history: List[Dict[str, Any]] = None,
+            skill_names: Optional[List[str]] = None,
+            media: Optional[List[str]] = None,
+            channel: Optional[str] = None,
+            conversation_id: Optional[str] = None,
+        ) -> List[Dict[str, Any]]:
+            messages: List[Message] = []
+
+            system_prompt = self.context_builder.build_system_prompt(skill_names)
+
+            if channel and conversation_id:
+                system_prompt += f"\n\n## Current Session\nChannel: {channel}\nConversation ID: {conversation_id}"
+
+            messages.append(Message(role="system", content=system_prompt))
+
+            user_content = self._build_user_content(current_message, media)
+
+            messages.append(
+                Message(
+                    role = "user",
+                    content = user_content["content"],
+                )
+            )
+
+            return messages
+
+    def add_tool_result(
+        self,
+        messages: List[Message],
+        tool_call_id: str,
+        result: str
+    ) -> List[Message]:
+
+        messages.append(
+            Message(
+                role="tool",
+                tool_results=[
+                    ToolResult(
+                        tool_call_id=tool_call_id,
+                        content=result
+                    )
+                ],
+            )
+        )
+
+        return messages
+    def add_assistant_message(
+        self,
+        messages,
+        content=None,
+        tool_calls=None,
+    ):
+
+        msg = Message(
+            role="assistant",
+            content=content,
+            tool_calls=tool_calls or [],
+        )
+
+        messages.append(msg)
+        return messages

sourcebot/context/skill/__init__.py

@@ -0,0 +1,7 @@
+from .skill_context import strip_frontmatter
+from .skill_loader import SkillLoader
+from .skill_metadata import SkillMetadataParser
+from .skill_requirements import check_requirements, missing_requirements
+from .skill_summary import SkillSummary
+from .skill import Skill
+__all__ = ["strip_frontmatter", "SkillLoader", "SkillMetadataParser", "check_requirements", "missing_requirements", "generate", "Skill",]

sourcebot/context/skill/skill.py

@@ -0,0 +1,11 @@
+# sourcebot/skill/skill.py
+from dataclasses import dataclass
+
+@dataclass
+class Skill:
+    name: str
+    description: str
+    content: str
+    requirements: dict
+    always: bool = False
+    source: str = "root"

sourcebot/context/skill/skill_context.py

@@ -0,0 +1,10 @@
+# sourcebot/skill/skill_context.py
+import re
+
+def strip_frontmatter(content: str) -> str:
+    """Remove YAML frontmatter from markdown content."""
+    if content.startswith("---"):
+        match = re.match(r"^---\s*\n.*?\n---\s*\n", content, re.DOTALL)
+        if match:
+            return content[match.end():].strip()
+    return content

sourcebot/context/skill/skill_loader.py

@@ -0,0 +1,57 @@
+# sourcebot/context/skill/skill_loader.py
+from typing import List, Optional
+from sourcebot.context.skill.skill import Skill
+from sourcebot.context.skill.skill_metadata import SkillMetadataParser
+from sourcebot.context.skill.skill_requirements import check_requirements
+from sourcebot.storage.skill_storage import SkillStorage
+from sourcebot.context.skill.skill_context import strip_frontmatter
+
+class SkillLoader:
+    """Load skills as Skill instances."""
+    def __init__(self, skill_storage: SkillStorage):
+        self.skill_storage = skill_storage
+        self._cache: dict[str, Skill] = {}
+
+    def list_skills(self, filter_unavailable: bool = True) -> List[Skill]:
+        skills: List[Skill] = []
+        for name, path, source in self.skill_storage.list_skill_dirs(source = "all"):
+            content = path.read_text(encoding="utf-8")
+            meta = SkillMetadataParser.parse(content)
+            skill = Skill(
+                name=name,
+                description=meta.get("description", name),
+                content=content,
+                requirements=meta.get("requires", {}),
+                always=meta.get("always", False),
+                source=source
+            )
+            if not filter_unavailable or check_requirements(skill):
+                skills.append(skill)
+                self._cache[name] = skill
+        return skills
+
+    def load_skill(self, name: str) -> Optional[Skill]:
+        if name in self._cache:
+            return self._cache[name]
+        content = self.skill_storage.read_skill(name)
+        if not content:
+            return None
+        meta = SkillMetadataParser.parse(content)
+        skill = Skill(
+            name=name,
+            description=meta.get("description", name),
+            content=content,
+            requirements=meta.get("requires", {}),
+            always=meta.get("always", False),
+            source="root"
+        )
+        self._cache[name] = skill
+        return skill
+
+    def load_skills_for_context(self, skill_names: List[str]) -> str:
+        parts = []
+        for name in skill_names:
+            skill = self.load_skill(name)
+            if skill:
+                parts.append(f"### Skill: {skill.name}\n\n{strip_frontmatter(skill.content)}")
+        return "\n\n---\n\n".join(parts) if parts else ""

sourcebot/context/skill/skill_metadata.py

@@ -0,0 +1,27 @@
+# sourcebot/skill/skill_metadata.py
+import re, json
+from typing import Dict
+
+class SkillMetadataParser:
+    """Parse YAML/JSON frontmatter from skill markdown files."""
+    FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---", re.DOTALL)
+
+    @classmethod
+    def parse(cls, content: str) -> Dict:
+        match = cls.FRONTMATTER_RE.match(content)
+        if not match:
+            return {}
+        front = match.group(1)
+        metadata = {}
+        for line in front.split("\n"):
+            if ":" in line:
+                k, v = line.split(":", 1)
+                metadata[k.strip()] = v.strip().strip('"\'')
+        raw_meta = metadata.get("metadata")
+        if raw_meta:
+            try:
+                data = json.loads(raw_meta)
+                return data.get("sourcebot", data.get("openclaw", {}))
+            except (json.JSONDecodeError, TypeError):
+                return {}
+        return metadata

sourcebot/context/skill/skill_requirements.py

@@ -0,0 +1,25 @@
+# sourcebot/context/skill/skill_requirements.py
+
+import os, shutil
+from sourcebot.context.skill.skill import Skill
+
+def check_requirements(skill: Skill) -> bool:
+    req = skill.requirements or {}
+    for b in req.get("bins", []):
+        if not shutil.which(b):
+            return False
+    for e in req.get("env", []):
+        if not os.environ.get(e):
+            return False
+    return True
+
+def missing_requirements(skill: Skill) -> str:
+    req = skill.requirements or {}
+    missing = []
+    for b in req.get("bins", []):
+        if not shutil.which(b):
+            missing.append(f"CLI:{b}")
+    for e in req.get("env", []):
+        if not os.environ.get(e):
+            missing.append(f"ENV:{e}")
+    return ", ".join(missing)

sourcebot/context/skill/skill_summary.py

@@ -0,0 +1,31 @@
+# sourcebot/context/skill/skill_summary.py
+
+from xml.etree.ElementTree import Element, SubElement, tostring
+from typing import List
+from sourcebot.context.skill.skill import Skill
+from sourcebot.context.skill.skill_requirements import check_requirements, missing_requirements
+
+class SkillSummary:
+    """Generate XML summary of a list of skills."""
+    
+    @staticmethod
+    def generate(skills: List[Skill], pretty: bool = False) -> str:
+        root = Element("skills")
+        for skill in skills:
+            skill_elem = SubElement(root, "skill")
+            available = check_requirements(skill)
+            skill_elem.set("available", str(available).lower())
+            SubElement(skill_elem, "name").text = skill.name
+            SubElement(skill_elem, "description").text = skill.description
+            SubElement(skill_elem, "location").text = skill.source
+            if not available:
+                reqs = missing_requirements(skill)
+                if reqs:
+                    SubElement(skill_elem, "requires").text = reqs
+        xml_bytes = tostring(root, encoding="unicode")
+        if pretty:
+            import xml.dom.minidom
+            dom = xml.dom.minidom.parseString(xml_bytes)
+            return dom.toprettyxml(indent="  ")
+        
+        return xml_bytes

sourcebot/conversation/__init__.py

@@ -0,0 +1,2 @@
+from sourcebot.conversation.service import ConversationService
+__all__ = ["ConversationService"]

sourcebot/conversation/service.py

@@ -0,0 +1,191 @@
+# sourcebot/conversation/service.py
+
+import asyncio
+from typing import Callable, Awaitable
+import logging
+from sourcebot.session.session import Session
+from sourcebot.session.service import SessionService
+from sourcebot.memory.service import MemoryService
+from sourcebot.runtime.agent import Agent
+from sourcebot.bus import InboundMessage, OutboundMessage
+
+logger = logging.getLogger(__name__)
+
+class ConversationService:
+    """
+    Orchestrates a full user conversation turn.
+
+    Responsibilities:
+    - Command routing
+    - Session load/save
+    - Context building
+    - Agent execution
+    - Memory consolidation scheduling
+    """
+
+    def __init__(
+        self,
+        session_service: SessionService,
+        memory_service: MemoryService,
+        agent: Agent,
+        message_builder,
+        bus = None,
+        memory_window: int = 50,
+    ):
+        self.session_service = session_service
+        self.memory_service = memory_service
+        self.agent = agent
+        self.message_builder = message_builder
+        # self.bus = bus
+        self.memory_window = memory_window
+
+        self._consolidating: set[str] = set()
+
+    
+    # Entry point
+    async def handle_message(
+        self,
+        msg: InboundMessage,
+        on_progress: Callable[[str], Awaitable[None]] | None = None,
+    ) -> OutboundMessage | None:
+
+        if self._is_command(msg):
+            return await self._handle_command(msg)
+
+        if msg.channel == "system":
+            return await self._handle_system_message(msg)
+        return await self._handle_conversation(msg, on_progress)
+
+
+    # Conversation flow
+    async def _handle_conversation(
+        self,
+        msg: InboundMessage,
+        on_progress: Callable[[str], Awaitable[None]] | None,
+    ) -> OutboundMessage | None:
+        # Session service
+        session = self.session_service.get_history(msg.session_key)
+        await self._maybe_schedule_consolidation(session)
+        messages = self.message_builder.build_chat_messages(
+            history = session.get_history(max_messages=self.memory_window),
+            current_message = msg.content,
+            media = msg.metadata if msg.metadata else None,
+            channel = msg.channel,
+            conversation_id = msg.conversation_id,
+        )
+        async def _bus_progress(content: str):
+            if not self.bus:
+                return
+            metadata = dict(msg.metadata or {})
+            metadata["_progress"] = True
+            await self.bus.publish_outbound(
+                OutboundMessage(
+                    channel = msg.channel,
+                    conversation_id = msg.conversation_id,
+                    content = content,
+                    metadata = data,
+                )
+            )
+        final_content, _, tools_used = await self.agent.run(messages)
+
+        if final_content is None:
+            final_content = "I've completed processing but have no response."
+
+        self.session_service.append_turn(
+            session.key,
+            user = msg.content,
+            assistant = final_content,
+            tools_used = tools_used,
+        )
+        return OutboundMessage(
+            channel = msg.channel,
+            conversation_id = msg.conversation_id,
+            content = final_content,
+            metadata = msg.metadata or {},
+        )
+
+
+    # System message
+    async def _handle_system_message(
+        self,
+        msg: InboundMessage,
+    ) -> OutboundMessage:
+
+        key = msg.session_key
+        session = self.session_service.get(key)
+
+        messages = self.message_builder.build_messages(
+            history = session.get_history(max_messages = self.memory_window),
+            current_message = msg.content,
+            channel = msg.channel,
+            conversation_id = msg.conversation_id,
+        )
+
+        final_content, _ = await self.agent.run(messages)
+
+        session.add_message("user", f"[System: {msg.sender_id}] {msg.content}")
+        session.add_message("assistant", final_content)
+
+        self.session_service.save(session)
+
+        return OutboundMessage(
+            channel = msg.channel,
+            conversation_id = msg.conversation_id,
+            content = final_content or "Background task completed.",
+        )
+
+
+    # commands
+    def _is_command(self, msg: InboundMessage) -> bool:
+        return msg.content.strip().startswith("/")
+
+    async def _handle_command(self, msg: InboundMessage) -> OutboundMessage:
+
+        cmd = msg.content.strip().lower()
+        session = self.session_service.get_history(msg.session_key)
+
+        if cmd == "/new":
+            archived = session.messages.copy()
+            session.clear()
+            self.session_service.save(session)
+            await self.memory_service.consolidate_archived(
+                session.key, 
+                archived
+            )
+            return OutboundMessage(
+                channel = msg.channel,
+                conversation_id = msg.conversation_id,
+                content = "New session started. Memory consolidation in progress.",
+            )
+
+        if cmd == "/help":
+            return OutboundMessage(
+                channel = msg.channel,
+                conversation_id = msg.conversation_id,
+                content = (
+                    "Available commands:\n"
+                    "/new — Start a new conversation\n"
+                    "/help — Show help"
+                ),
+            )
+        return OutboundMessage(
+            channel = msg.channel,
+            conversation_id = msg.conversation_id,
+            content = "Unknown command.",
+        )
+
+    # Memory consolidation
+    async def _maybe_schedule_consolidation(self, session: Session):
+        if (
+            len(session.messages) <= self.memory_window
+            or session.key in self._consolidating
+        ):
+            return
+        self._consolidating.add(session.key)
+
+        async def _task():
+            try:
+                await self.memory_service.maybe_consolidate(session)
+            finally:
+                self._consolidating.discard(session.key)
+        await _task()

sourcebot/docker_sandbox/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.docker_sandbox.docker_sandbox import DockerSandbox
+
+__all__ = ["DockerSandbox"]