sourcebot 0.1.0__py3-none-any.whl

sourcebot/session/__init__.py

@@ -0,0 +1,4 @@
+from sourcebot.session.jsonl_repository import JsonlSessionRepository
+from sourcebot.session.service import SessionService
+from sourcebot.session.session import Session
+__all__ = ["JsonlSessionRepository", "Session"]

sourcebot/session/jsonl_repository.py

@@ -0,0 +1,142 @@
+# sourcebot/session/jsonl_repository.py
+
+import json
+import shutil
+from pathlib import Path
+from typing import Any
+from datetime import datetime
+
+from sourcebot.session.session import Session
+from sourcebot.session.repository import SessionRepository
+from sourcebot.llm.core.message import Message
+
+
+class JsonlSessionRepository(SessionRepository):
+
+    def __init__(self, workspace: Path):
+        self.workspace = workspace
+        self.sessions_dir = self.workspace / "sessions"
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+
+        self.legacy_sessions_dir = Path.home() / ".etherealbot" / "sessions"
+        self._cache: dict[str, Session] = {}
+
+    # -------------------------
+
+    def _safe_filename(self, key: str) -> str:
+        return key.replace(":", "_").replace("/", "_")
+
+    def _get_session_path(self, key: str) -> Path:
+        safe_key = self._safe_filename(key)
+        return self.sessions_dir / f"{safe_key}.jsonl"
+
+    def _get_legacy_session_path(self, key: str) -> Path:
+        safe_key = self._safe_filename(key)
+        return self.legacy_sessions_dir / f"{safe_key}.jsonl"
+
+    # -------------------------
+
+    def get_or_create(self, key: str) -> Session:
+        if key in self._cache:
+            return self._cache[key]
+
+        session = self._load(key)
+        if session is None:
+            session = Session(key=key)
+
+        self._cache[key] = session
+        return session
+
+    # -------------------------
+
+    def _load(self, key: str) -> Session | None:
+        path = self._get_session_path(key)
+
+        if not path.exists():
+            legacy = self._get_legacy_session_path(key)
+            if legacy.exists():
+                path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.move(str(legacy), str(path))
+
+        if not path.exists():
+            return None
+
+        messages = []
+        metadata: dict[str, Any] = {}
+        created_at = None
+        last_consolidated = 0
+
+        with open(path, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+
+                data = json.loads(line)
+
+                if data.get("_type") == "metadata":
+                    metadata = data.get("metadata", {})
+                    created_at = (
+                        datetime.fromisoformat(data["created_at"])
+                        if data.get("created_at")
+                        else None
+                    )
+                    last_consolidated = data.get("last_consolidated", 0)
+                else:
+                    messages.append(Message.from_dict(data))
+
+        return Session(
+            key = key,
+            messages = messages,
+            created_at = created_at or datetime.now(),
+            metadata = metadata,
+            last_consolidated = last_consolidated,
+        )
+
+    # -------------------------
+
+    def save(self, session: Session) -> None:
+        path = self._get_session_path(session.key)
+
+        with open(path, "w", encoding="utf-8") as f:
+            metadata_line = {
+                "_type": "metadata",
+                "key": session.key,
+                "created_at": session.created_at.isoformat(),
+                "updated_at": session.updated_at.isoformat(),
+                "metadata": session.metadata,
+                "last_consolidated": session.last_consolidated,
+            }
+            f.write(json.dumps(metadata_line, ensure_ascii=False) + "\n")
+
+            for msg in session.messages:
+                if hasattr(msg, "to_dict"):
+                    data = msg.to_dict()
+                else:
+                    data = msg  # 兼容旧数据
+                f.write(json.dumps(data, ensure_ascii=False) + "\n")
+
+        self._cache[session.key] = session
+
+    # -------------------------
+
+    def list_sessions(self) -> list[dict]:
+        sessions = []
+
+        for path in self.sessions_dir.glob("*.jsonl"):
+            try:
+                with open(path, encoding="utf-8") as f:
+                    first_line = f.readline().strip()
+                    if first_line:
+                        data = json.loads(first_line)
+                        if data.get("_type") == "metadata":
+                            sessions.append({
+                                "key": data.get("key"),
+                                "created_at": data.get("created_at"),
+                                "updated_at": data.get("updated_at"),
+                                "path": str(path),
+                            })
+            except Exception:
+                continue
+
+        return sorted(sessions, key=lambda x: x.get("updated_at", ""), reverse=True)

sourcebot/session/repository.py

@@ -0,0 +1,19 @@
+# sourcebot/session/repository.py
+
+from abc import ABC, abstractmethod
+from sourcebot.session.session import Session
+
+
+class SessionRepository(ABC):
+
+    @abstractmethod
+    def get_or_create(self, key: str) -> Session:
+        pass
+
+    @abstractmethod
+    def save(self, session: Session) -> None:
+        pass
+
+    @abstractmethod
+    def list_sessions(self) -> list[dict]:
+        pass

sourcebot/session/service.py

@@ -0,0 +1,44 @@
+# sourcebot/session/service.py
+
+from sourcebot.session.repository import SessionRepository
+from typing import Any
+class SessionService:
+
+    def __init__(self, repo: SessionRepository):
+        self.repo = repo
+
+    def append_user_message(self, key: str, content: str):
+        session = self.repo.get_or_create(key)
+        session.add_message("user", content)
+        self.repo.save(session)
+
+    def append_assistant_message(self, key: str, content: str, **kwargs: Any | None):
+        session = self.repo.get_or_create(key)
+        session.add_message("assistant", content, **kwargs)
+        self.repo.save(session)
+    # Session
+    def get_history(self, key: str):
+        session = self.repo.get_or_create(key)
+        return session
+
+    def list_sessions(self):
+        return self.repo.list_sessions()
+
+    def append_turn(
+        self,
+        key: str,
+        user: str,
+        assistant: str,
+        tools_used=None,
+    ):
+        session = self.repo.get_or_create(key)
+        session.add_message("user", user)
+        session.add_message("assistant", assistant, tools_used = tools_used)
+        self.repo.save(session)
+
+    def save(self, session: Any) -> None:
+        
+        return self.repo.save(session)
+
+
+    

sourcebot/session/session.py

@@ -0,0 +1,53 @@
+# sourcebot/session/session.py
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+from sourcebot.llm.core.message import Message
+
+@dataclass
+class Session:
+    key: str
+    messages: list[dict[str, Any]] = field(default_factory=list)
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+    metadata: dict[str, Any] = field(default_factory=dict)
+    last_consolidated: int = 0
+
+    def add_message(self, role: str, content: str, **kwargs: Any) -> None:
+        msg = Message(
+            role = role,
+            content = content,
+            metadata = kwargs
+        )
+        self.messages.append(msg)
+        self.updated_at = datetime.now()
+    
+    def get_history(self, max_messages: int = 500):
+        out = []
+        for m in self.messages[-max_messages:]:
+            entry = {
+                "role": m.role,
+                "content": m.content or "",
+            }
+            if m.tool_calls:
+                entry["tool_calls"] = [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.name,
+                            "arguments": tc.arguments,
+                        },
+                    }
+                    for tc in m.tool_calls
+                ]
+            if m.tool_results:
+                entry["tool_call_id"] = m.tool_results[0].tool_call_id
+            out.append(entry)
+        return out
+
+    def clear(self) -> None:
+        """Clear all messages and reset the session to its initial state."""
+        self.messages = []
+        self.last_consolidated = 0
+        self.updated_at = datetime.now()

sourcebot/storage/__init__.py

@@ -0,0 +1,3 @@
+from sourcebot.storage.skill_storage import SkillStorage
+from sourcebot.storage.rules_loader import RulesLoader
+__all__ = ["SkillStorage", "RulesLoader"]

sourcebot/storage/rules_loader.py

@@ -0,0 +1,72 @@
+# sourcebot/storage/rules_loader.py
+from pathlib import Path
+from typing import List, Optional
+
+# logger = logging.getLogger(__name__)
+
+class RulesLoader:
+    """Load rules files."""
+    def __init__(self, app_root_path: Path):
+        self.rules_path = [app_root_path/"rules"]
+        self.rules_common_path = app_root_path / "rules/common"
+        
+    def load_common_rules(self) -> str:
+        """Load all .md files from rules/common"""
+        parts = []
+        if self.rules_common_path.exists() and self.rules_common_path.is_dir():
+            for file_path in self.rules_common_path.glob("*.md"):
+                if file_path.is_file():
+                    try:
+                        content = file_path.read_text(encoding="utf-8")
+                        parts.append(content)
+                    except Exception as e:
+                        logger.warning(f"Failed to read {file_path}: {e}")
+        return "\n\n".join(parts) if parts else ""
+
+
+    def list_rules_dirs(self) -> List[str]:
+        '''List rules other than common.'''
+        result = set()
+
+        for root in self.rules_path:
+            if not root:
+                continue
+
+            root = Path(root).expanduser()
+
+            if not root.exists():
+                continue
+
+            for d in root.iterdir():
+                if d.is_dir() and d.name != "common":
+                    result.add(d.name)
+
+        return sorted(result)
+    
+
+    def read_rule(self, name: str) -> Optional[str]:
+        """Read by name rules + common."""
+        contents = []
+
+        for root in self.rules_path:
+            root = Path(root).expanduser()
+
+            for rule_name in ["common", name]:
+
+                target_dir = root / rule_name
+
+                if not target_dir.is_dir():
+                    continue
+
+                for md in sorted(target_dir.glob("*.md")):
+                    try:
+                        text = md.read_text("utf-8")
+                        contents.append(f"# {md.stem}\n\n{text}")
+                    except Exception:
+                        pass
+
+        if contents:
+            return "\n\n---\n\n".join(contents)
+
+        return None
+    

sourcebot/storage/skill_storage.py

@@ -0,0 +1,51 @@
+# sourcebot/storage/skill_storage.py
+from pathlib import Path
+from typing import Optional, List, Tuple
+import shutil
+class SkillStorage:
+    """Read skill markdown files from disk."""
+    SKILL_FILE = "SKILL.md"
+
+    def __init__(self, root_skills: Path, builtin_skills: Optional[Path] = None):
+        self.root_skills = root_skills
+        self.builtin_skills = builtin_skills
+
+    def list_skill_dirs(self, source: str) -> List[str]:
+        '''List skills.'''
+        result = []
+        for skills_dir in [self.root_skills, self.builtin_skills]:
+            if skills_dir and skills_dir.exists():
+                for d in skills_dir.iterdir():
+                    if d.is_dir() and (d / self.SKILL_FILE).exists():
+                        result.append((d.name, d / self.SKILL_FILE, source))
+        return result
+
+    def list_skill_name(self, source: str) -> List[str]:
+        '''List skills name.'''
+        result = []
+        for skills_dir in [self.root_skills, self.builtin_skills]:
+            if skills_dir and skills_dir.exists():
+                for d in skills_dir.iterdir():
+                    if d.is_dir() and (d / self.SKILL_FILE).exists():
+                        result.append(d.name)
+        return result
+
+    def read_skill(self, name: str) -> Optional[str]:
+        """Read by name skill."""
+        for skills_dir in [self.root_skills, self.builtin_skills]:
+            if skills_dir and skills_dir.exists():
+                f = skills_dir / name / self.SKILL_FILE
+                if f.exists():
+                    return f.read_text(encoding="utf-8")
+        return None
+
+    def inject_skill(self, name: str, workspace: Path):
+        """Inject skills into the workspace's skills directory"""
+        skill_dir = self.root_skills / name
+        if not skill_dir.exists():
+            return
+        target = workspace / "skills" / name
+
+        target.parent.mkdir(parents=True, exist_ok=True)
+
+        shutil.copytree(skill_dir, target, dirs_exist_ok=True)

sourcebot/tools/__init__.py

@@ -0,0 +1,7 @@
+from sourcebot.tools.shell import ShellTool
+from sourcebot.tools.registry import ToolRegistry
+from sourcebot.tools.skill_list import SkillListTool
+from sourcebot.tools.skill_detail import SkillDetailTool
+from sourcebot.tools.rule_list import RuleListTool
+from sourcebot.tools.rule_detail import RuleDetailTool
+__all__ = ["ShellTool", "ToolRegistry", "SkillListTool", "SkillDetailTool", "RuleListTool", "RuleDetailTool"]

sourcebot/tools/base.py

@@ -0,0 +1,182 @@
+# sourcebot/tools/base.py
+"""Base class for agent tools."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Tool(ABC):
+    """
+    Abstract base class for agent tools.
+
+    Tools are capabilities that the agent can use to interact with
+    the environment, such as reading files, executing commands, etc.
+    """
+
+    _TYPE_MAP = {
+        "string": str,
+        "integer": int,
+        "number": (int, float),
+        "boolean": bool,
+        "array": list,
+        "object": dict,
+    }
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Tool name used in function calls."""
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Description of what the tool does."""
+        pass
+
+    @property
+    @abstractmethod
+    def parameters(self) -> dict[str, Any]:
+        """JSON Schema for tool parameters."""
+        pass
+
+    @abstractmethod
+    async def execute(self, **kwargs: Any) -> str:
+        """
+        Execute the tool with given parameters.
+
+        Args:
+            **kwargs: Tool-specific parameters.
+
+        Returns:
+            String result of the tool execution.
+        """
+        pass
+
+    def cast_params(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Apply safe schema-driven casts before validation."""
+        schema = self.parameters or {}
+        if schema.get("type", "object") != "object":
+            return params
+
+        return self._cast_object(params, schema)
+
+    def _cast_object(self, obj: Any, schema: dict[str, Any]) -> dict[str, Any]:
+        """Cast an object (dict) according to schema."""
+        if not isinstance(obj, dict):
+            return obj
+
+        props = schema.get("properties", {})
+        result = {}
+
+        for key, value in obj.items():
+            if key in props:
+                result[key] = self._cast_value(value, props[key])
+            else:
+                result[key] = value
+
+        return result
+
+    def _cast_value(self, val: Any, schema: dict[str, Any]) -> Any:
+        """Cast a single value according to schema."""
+        target_type = schema.get("type")
+
+        if target_type == "boolean" and isinstance(val, bool):
+            return val
+        if target_type == "integer" and isinstance(val, int) and not isinstance(val, bool):
+            return val
+        if target_type in self._TYPE_MAP and target_type not in ("boolean", "integer", "array", "object"):
+            expected = self._TYPE_MAP[target_type]
+            if isinstance(val, expected):
+                return val
+
+        if target_type == "integer" and isinstance(val, str):
+            try:
+                return int(val)
+            except ValueError:
+                return val
+
+        if target_type == "number" and isinstance(val, str):
+            try:
+                return float(val)
+            except ValueError:
+                return val
+
+        if target_type == "string":
+            return val if val is None else str(val)
+
+        if target_type == "boolean" and isinstance(val, str):
+            val_lower = val.lower()
+            if val_lower in ("true", "1", "yes"):
+                return True
+            if val_lower in ("false", "0", "no"):
+                return False
+            return val
+
+        if target_type == "array" and isinstance(val, list):
+            item_schema = schema.get("items")
+            return [self._cast_value(item, item_schema) for item in val] if item_schema else val
+
+        if target_type == "object" and isinstance(val, dict):
+            return self._cast_object(val, schema)
+
+        return val
+
+    def validate_params(self, params: dict[str, Any]) -> list[str]:
+        """Validate tool parameters against JSON schema. Returns error list (empty if valid)."""
+        if not isinstance(params, dict):
+            return [f"parameters must be an object, got {type(params).__name__}"]
+        schema = self.parameters or {}
+        if schema.get("type", "object") != "object":
+            raise ValueError(f"Schema must be object type, got {schema.get('type')!r}")
+        return self._validate(params, {**schema, "type": "object"}, "")
+
+    def _validate(self, val: Any, schema: dict[str, Any], path: str) -> list[str]:
+        t, label = schema.get("type"), path or "parameter"
+        if t == "integer" and (not isinstance(val, int) or isinstance(val, bool)):
+            return [f"{label} should be integer"]
+        if t == "number" and (
+            not isinstance(val, self._TYPE_MAP[t]) or isinstance(val, bool)
+        ):
+            return [f"{label} should be number"]
+        if t in self._TYPE_MAP and t not in ("integer", "number") and not isinstance(val, self._TYPE_MAP[t]):
+            return [f"{label} should be {t}"]
+
+        errors = []
+        if "enum" in schema and val not in schema["enum"]:
+            errors.append(f"{label} must be one of {schema['enum']}")
+        if t in ("integer", "number"):
+            if "minimum" in schema and val < schema["minimum"]:
+                errors.append(f"{label} must be >= {schema['minimum']}")
+            if "maximum" in schema and val > schema["maximum"]:
+                errors.append(f"{label} must be <= {schema['maximum']}")
+        if t == "string":
+            if "minLength" in schema and len(val) < schema["minLength"]:
+                errors.append(f"{label} must be at least {schema['minLength']} chars")
+            if "maxLength" in schema and len(val) > schema["maxLength"]:
+                errors.append(f"{label} must be at most {schema['maxLength']} chars")
+        if t == "object":
+            props = schema.get("properties", {})
+            for k in schema.get("required", []):
+                if k not in val:
+                    errors.append(f"missing required {path + '.' + k if path else k}")
+            for k, v in val.items():
+                if k in props:
+                    errors.extend(self._validate(v, props[k], path + "." + k if path else k))
+        if t == "array" and "items" in schema:
+            for i, item in enumerate(val):
+                errors.extend(
+                    self._validate(item, schema["items"], f"{path}[{i}]" if path else f"[{i}]")
+                )
+        return errors
+
+    def to_schema(self) -> dict[str, Any]:
+        """Convert tool to OpenAI function schema format."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }

sourcebot/tools/registry.py

@@ -0,0 +1,81 @@
+# sourcebot/tools/registry.py
+"""Tool registry for dynamic tool management."""
+from typing import Any
+from sourcebot.tools.base import Tool
+
+class ToolRegistry:
+    """
+    Agent tool registry.
+    
+    Allows dynamic registration and execution of tools.
+    """
+
+    def __init__(self):
+        self._tools: dict[str, Tool] = {}
+
+    def register(self, tool: Tool) -> None:
+        """Register a tool."""
+        self._tools[tool.name] = tool
+
+    def unregister(self, name: str) -> None:
+        """Unregister a tool by name."""
+        self._tools.pop(name, None)
+
+    def get(self, name: str) -> Tool | None:
+        """Get a tool by name."""
+        return self._tools.get(name)
+
+    def has(self, name: str) -> bool:
+        """Check if a tool is registered."""
+        return name in self._tools
+
+    def get_definitions(self) -> list[dict[str, Any]]:
+        """Get OpenAI format definitions for all tools."""
+        return [tool.to_schema() for tool in self._tools.values()]
+
+    async def execute(self, name: str, params: dict[str, Any]) -> str:
+        """
+        Execute a tool by name with the given parameters.
+        
+        Args:
+            name: Tool name.
+            params: Tool parameters.
+        
+        Returns:
+            Tool execution result (as string).
+        
+        Raises:
+            KeyError: If the specified tool is not found.
+        """
+        tool = self._tools.get(name)
+
+        if not tool:
+            return f"Error: Tool '{name}' not found"
+
+        try:
+            errors = tool.validate_params(params)
+
+            if errors:
+                return f"Error: Invalid parameters for tool '{name}': " + "; ".join(errors)
+
+            tool_call = {
+                "tool_name": name,
+                "tool_input": params,
+            }
+
+            result = await tool.execute(**params)
+
+            return result
+        except Exception as e:
+            return f"Error executing {name}: {str(e)}"
+
+    @property
+    def tool_names(self) -> list[str]:
+        """Get list of registered tool names."""
+        return list(self._tools.keys())
+
+    def __len__(self) -> int:
+        return len(self._tools)
+
+    def __contains__(self, name: str) -> bool:
+        return name in self._tools