codemaster-cli 2.2.0__py3-none-any.whl

vibe/core/session/session_logger.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+import getpass
+import json
+import os
+from pathlib import Path
+import subprocess
+from typing import TYPE_CHECKING, Any
+
+from anyio import NamedTemporaryFile, Path as AsyncPath
+
+from vibe.core.types import AgentStats, LLMMessage, Role, SessionMetadata
+from vibe.core.utils import is_windows, utc_now
+
+if TYPE_CHECKING:
+    from vibe.core.agents.models import AgentProfile
+    from vibe.core.config import SessionLoggingConfig, VibeConfig
+    from vibe.core.tools.manager import ToolManager
+
+
+METADATA_FILENAME = "meta.json"
+MESSAGES_FILENAME = "messages.jsonl"
+
+
+class SessionLogger:
+    def __init__(self, session_config: SessionLoggingConfig, session_id: str) -> None:
+        self.session_config = session_config
+        self.enabled = session_config.enabled
+
+        if not self.enabled:
+            self.save_dir: Path | None = None
+            self.session_prefix: str | None = None
+            self.session_id: str = "disabled"
+            self.session_start_time: str = "N/A"
+            self.session_dir: Path | None = None
+            self.session_metadata: SessionMetadata | None = None
+            return
+
+        self.save_dir = Path(session_config.save_dir)
+        self.session_prefix = session_config.session_prefix
+        self.session_id = session_id
+        self.session_start_time = utc_now().isoformat()
+
+        self.save_dir.mkdir(parents=True, exist_ok=True)
+        self.session_dir = self.save_folder
+        self.session_metadata = self._initialize_session_metadata()
+
+    @property
+    def save_folder(self) -> Path:
+        if self.save_dir is None or self.session_prefix is None:
+            raise RuntimeError(
+                "Cannot get session save folder when logging is disabled"
+            )
+
+        timestamp = utc_now().strftime("%Y%m%d_%H%M%S")
+        folder_name = f"{self.session_prefix}_{timestamp}_{self.session_id[:8]}"
+        return self.save_dir / folder_name
+
+    @property
+    def metadata_filepath(self) -> Path:
+        if self.session_dir is None:
+            raise RuntimeError(
+                "Cannot get session metadata filepath when logging is disabled"
+            )
+        return self.session_dir / METADATA_FILENAME
+
+    @property
+    def messages_filepath(self) -> Path:
+        if self.session_dir is None:
+            raise RuntimeError(
+                "Cannot get session messages filepath when logging is disabled"
+            )
+        return self.session_dir / MESSAGES_FILENAME
+
+    @property
+    def git_commit(self) -> str | None:
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "HEAD"],
+                capture_output=True,
+                stdin=subprocess.DEVNULL if is_windows() else None,
+                text=True,
+                timeout=5.0,
+            )
+            if result.returncode == 0 and result.stdout:
+                return result.stdout.strip()
+        except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+            pass
+        return None
+
+    @property
+    def git_branch(self) -> str | None:
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                capture_output=True,
+                stdin=subprocess.DEVNULL if is_windows() else None,
+                text=True,
+                timeout=5.0,
+            )
+            if result.returncode == 0 and result.stdout:
+                return result.stdout.strip()
+        except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+            pass
+        return None
+
+    @property
+    def username(self) -> str:
+        try:
+            return getpass.getuser()
+        except Exception:
+            return "unknown"
+
+    def _initialize_session_metadata(self) -> SessionMetadata:
+        git_commit = self.git_commit
+        git_branch = self.git_branch
+        user_name = self.username
+
+        return SessionMetadata(
+            session_id=self.session_id,
+            start_time=self.session_start_time,
+            end_time=None,
+            git_commit=git_commit,
+            git_branch=git_branch,
+            username=user_name,
+            environment={"working_directory": str(Path.cwd())},
+        )
+
+    def _get_title(self, messages: list[LLMMessage]) -> str:
+        first_user_message = None
+        for message in messages:
+            if message.role == Role.user:
+                first_user_message = message
+                break
+
+        if first_user_message is None:
+            title = "Untitled session"
+        else:
+            MAX_TITLE_LENGTH = 50
+            text = str(first_user_message.content)
+            title = text[:MAX_TITLE_LENGTH]
+            if len(text) > MAX_TITLE_LENGTH:
+                title += "…"
+
+        return title
+
+    @staticmethod
+    async def persist_metadata(metadata: Any, session_dir: Path) -> None:
+        temp_metadata_filepath = None
+        metadata_filepath = session_dir / METADATA_FILENAME
+        try:
+            async with NamedTemporaryFile(
+                mode="w",
+                suffix=".json.tmp",
+                dir=str(session_dir),
+                delete=False,
+                encoding="utf-8",
+            ) as f:
+                temp_metadata_filepath = Path(str(f.name))
+                await f.write(json.dumps(metadata, indent=2, ensure_ascii=False))
+                await f.flush()
+                os.fsync(f.wrapped.fileno())
+
+            os.replace(temp_metadata_filepath, str(metadata_filepath))
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to persist session metadata to {metadata_filepath}: {e}"
+            ) from e
+        finally:
+            if (
+                temp_metadata_filepath
+                and temp_metadata_filepath.exists()
+                and temp_metadata_filepath.is_file()
+            ):
+                temp_metadata_filepath.unlink()
+
+    @staticmethod
+    async def persist_messages(messages: list[dict], session_dir: Path) -> None:
+        messages_filepath = session_dir / "messages.jsonl"
+        try:
+            if not messages_filepath.exists():
+                messages_filepath.touch()
+
+            async with await AsyncPath(messages_filepath).open(
+                "a", encoding="utf-8"
+            ) as f:
+                for message in messages:
+                    await f.write(json.dumps(message, ensure_ascii=False) + "\n")
+                    await f.flush()
+                    os.fsync(f.wrapped.fileno())
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to persist session messages to {messages_filepath}: {e}"
+            ) from e
+
+    async def save_interaction(
+        self,
+        messages: list[LLMMessage],
+        stats: AgentStats,
+        base_config: VibeConfig,
+        tool_manager: ToolManager,
+        agent_profile: AgentProfile,
+    ) -> None:
+        if not self.enabled or self.session_dir is None:
+            return
+
+        if self.session_metadata is None:
+            return
+
+        # If the session directory does not exist, create it
+        try:
+            self.session_dir.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            raise RuntimeError(
+                f"Failed to create session directory at {self.session_dir}: {type(e).__name__}: {e}"
+            ) from e
+
+        # Read old metadata and get total_messages
+        try:
+            if self.metadata_filepath.exists():
+                async with await AsyncPath(self.metadata_filepath).open(
+                    encoding="utf-8", errors="ignore"
+                ) as f:
+                    old_metadata = json.loads(await f.read())
+                    old_total_messages = old_metadata["total_messages"]
+            else:
+                old_total_messages = 0
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to read session metadata at {self.metadata_filepath}: {e}"
+            ) from e
+
+        try:
+            non_system_messages = [m for m in messages if m.role != Role.system]
+            # Append new messages
+            new_messages = non_system_messages[old_total_messages:]
+
+            if len(new_messages) == 0:
+                return
+
+            messages_data = [m.model_dump(exclude_none=True) for m in new_messages]
+            await SessionLogger.persist_messages(messages_data, self.session_dir)
+
+            # If message update succeeded, write metadata
+            tools_available = [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": tool_class.get_name(),
+                        "description": tool_class.description,
+                        "parameters": tool_class.get_parameters(),
+                    },
+                }
+                for tool_class in tool_manager.available_tools.values()
+            ]
+
+            title = self._get_title(messages)
+            system_prompt = (
+                messages[0].model_dump()
+                if len(messages) > 0 and messages[0].role == Role.system
+                else None
+            )
+            total_messages = len(non_system_messages)
+
+            metadata_dump = {
+                **self.session_metadata.model_dump(),
+                "end_time": utc_now().isoformat(),
+                "stats": stats.model_dump(),
+                "title": title,
+                "total_messages": total_messages,
+                "tools_available": tools_available,
+                "config": base_config.model_dump(mode="json"),
+                "agent_profile": {
+                    "name": agent_profile.name,
+                    "overrides": agent_profile.overrides,
+                },
+                "system_prompt": system_prompt,
+            }
+
+            await SessionLogger.persist_metadata(metadata_dump, self.session_dir)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to save session to {self.session_dir}: {e}"
+            ) from e
+        finally:
+            self.cleanup_tmp_files()
+
+    def reset_session(self, session_id: str) -> None:
+        """Clear existing session info and setup a new session"""
+        if not self.enabled:
+            return
+
+        self.session_id = session_id
+        self.session_start_time = utc_now().isoformat()
+        self.session_dir = self.save_folder
+        self.session_metadata = self._initialize_session_metadata()
+
+    def cleanup_tmp_files(self) -> None:
+        """Delete temporary files created more than 5 minutes ago"""
+        if not self.enabled or not self.save_dir:
+            return
+
+        now = utc_now()
+        ago = now - timedelta(minutes=5)
+
+        tmp_files = self.save_dir.glob("**/*.json.tmp")  # Recursive search
+
+        for file_path in tmp_files:
+            if file_path.is_file():
+                try:
+                    file_mtime = datetime.fromtimestamp(
+                        file_path.stat().st_mtime, tz=UTC
+                    )
+                    if file_mtime < ago:
+                        file_path.unlink()
+                except Exception:
+                    continue

vibe/core/session/session_migration.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+from vibe.core.config import SessionLoggingConfig
+from vibe.core.session.session_logger import SessionLogger
+
+
+def migrate_sessions_entrypoint(session_config: SessionLoggingConfig) -> int:
+    return asyncio.run(migrate_sessions(session_config))
+
+
+async def migrate_sessions(session_config: SessionLoggingConfig) -> int:
+    """Helper for migrating session data from singular JSON files to the format introduced in Vibe 2.0 with per-session folders with split metadata and message files."""
+    save_dir = session_config.save_dir
+    if not save_dir or not session_config.enabled:
+        return 0
+
+    successful_migrations = 0
+    session_files = list(Path(save_dir).glob(f"{session_config.session_prefix}_*.json"))
+    for session_file in session_files:
+        try:
+            with open(session_file) as f:
+                session_data = f.read()
+            session_json = json.loads(session_data)
+            metadata = session_json["metadata"]
+            messages = session_json["messages"]
+
+            session_dir = Path(save_dir) / session_file.stem
+            session_dir.mkdir()
+
+            await SessionLogger.persist_metadata(metadata, session_dir)
+            await SessionLogger.persist_messages(messages, session_dir)
+            session_file.unlink()
+            successful_migrations += 1
+        except Exception:
+            continue
+
+    return successful_migrations

vibe/core/skills/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from vibe.core.skills.manager import SkillManager
+from vibe.core.skills.models import SkillInfo, SkillMetadata
+from vibe.core.skills.parser import SkillParseError
+
+__all__ = ["SkillInfo", "SkillManager", "SkillMetadata", "SkillParseError"]

vibe/core/skills/manager.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from logging import getLogger
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from vibe.core.paths.config_paths import resolve_local_skills_dirs
+from vibe.core.paths.global_paths import GLOBAL_SKILLS_DIR
+from vibe.core.skills.models import SkillInfo, SkillMetadata
+from vibe.core.skills.parser import SkillParseError, parse_frontmatter
+from vibe.core.utils import name_matches
+
+if TYPE_CHECKING:
+    from vibe.core.config import VibeConfig
+
+logger = getLogger("vibe")
+
+
+class SkillManager:
+    def __init__(self, config_getter: Callable[[], VibeConfig]) -> None:
+        self._config_getter = config_getter
+        self._search_paths = self._compute_search_paths(self._config)
+        self._available: dict[str, SkillInfo] = self._discover_skills()
+
+        if self._available:
+            logger.info(
+                "Discovered %d skill(s) from %d search path(s)",
+                len(self._available),
+                len(self._search_paths),
+            )
+
+    @property
+    def _config(self) -> VibeConfig:
+        return self._config_getter()
+
+    @property
+    def available_skills(self) -> dict[str, SkillInfo]:
+        if self._config.enabled_skills:
+            return {
+                name: info
+                for name, info in self._available.items()
+                if name_matches(name, self._config.enabled_skills)
+            }
+        if self._config.disabled_skills:
+            return {
+                name: info
+                for name, info in self._available.items()
+                if not name_matches(name, self._config.disabled_skills)
+            }
+        return dict(self._available)
+
+    @staticmethod
+    def _compute_search_paths(config: VibeConfig) -> list[Path]:
+        paths: list[Path] = []
+
+        for path in config.skill_paths:
+            if path.is_dir():
+                paths.append(path)
+
+        paths.extend(resolve_local_skills_dirs(Path.cwd()))
+
+        if GLOBAL_SKILLS_DIR.path.is_dir():
+            paths.append(GLOBAL_SKILLS_DIR.path)
+
+        unique: list[Path] = []
+        for p in paths:
+            rp = p.resolve()
+            if rp not in unique:
+                unique.append(rp)
+
+        return unique
+
+    def _discover_skills(self) -> dict[str, SkillInfo]:
+        skills: dict[str, SkillInfo] = {}
+        for base in self._search_paths:
+            if not base.is_dir():
+                continue
+            for name, info in self._discover_skills_in_dir(base).items():
+                if name not in skills:
+                    skills[name] = info
+                else:
+                    logger.debug(
+                        "Skipping duplicate skill '%s' at %s (already loaded from %s)",
+                        name,
+                        info.skill_path,
+                        skills[name].skill_path,
+                    )
+        return skills
+
+    def _discover_skills_in_dir(self, base: Path) -> dict[str, SkillInfo]:
+        skills: dict[str, SkillInfo] = {}
+        for skill_dir in base.iterdir():
+            if not skill_dir.is_dir():
+                continue
+            skill_file = skill_dir / "SKILL.md"
+            if not skill_file.is_file():
+                continue
+            if (skill_info := self._try_load_skill(skill_file)) is not None:
+                skills[skill_info.name] = skill_info
+        return skills
+
+    def _try_load_skill(self, skill_file: Path) -> SkillInfo | None:
+        try:
+            skill_info = self._parse_skill_file(skill_file)
+        except Exception as e:
+            logger.warning("Failed to parse skill at %s: %s", skill_file, e)
+            return None
+        return skill_info
+
+    def _parse_skill_file(self, skill_path: Path) -> SkillInfo:
+        try:
+            content = skill_path.read_text(encoding="utf-8")
+        except OSError as e:
+            raise SkillParseError(f"Cannot read file: {e}") from e
+
+        frontmatter, _ = parse_frontmatter(content)
+        metadata = SkillMetadata.model_validate(frontmatter)
+
+        skill_name_from_dir = skill_path.parent.name
+        if metadata.name != skill_name_from_dir:
+            logger.warning(
+                "Skill name '%s' doesn't match directory name '%s' at %s",
+                metadata.name,
+                skill_name_from_dir,
+                skill_path,
+            )
+
+        return SkillInfo.from_metadata(metadata, skill_path)
+
+    def get_skill(self, name: str) -> SkillInfo | None:
+        return self.available_skills.get(name)

vibe/core/skills/models.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class SkillMetadata(BaseModel):
+    model_config = {"populate_by_name": True}
+
+    name: str = Field(
+        ...,
+        min_length=1,
+        max_length=64,
+        pattern=r"^[a-z0-9]+(-[a-z0-9]+)*$",
+        description="Skill identifier. Lowercase letters, numbers, and hyphens only.",
+    )
+    description: str = Field(
+        ...,
+        min_length=1,
+        max_length=1024,
+        description="What this skill does and when to use it.",
+    )
+    license: str | None = Field(
+        default=None, description="License name or reference to a bundled license file."
+    )
+    compatibility: str | None = Field(
+        default=None,
+        max_length=500,
+        description="Environment requirements (intended product, system packages, etc.).",
+    )
+    metadata: dict[str, str] = Field(
+        default_factory=dict,
+        description="Arbitrary key-value mapping for additional metadata.",
+    )
+    allowed_tools: list[str] = Field(
+        default_factory=list,
+        validation_alias="allowed-tools",
+        description="Space-delimited list of pre-approved tools (experimental).",
+    )
+    user_invocable: bool = Field(
+        default=True,
+        validation_alias="user-invocable",
+        description="Controls whether the skill appears in the slash command menu.",
+    )
+
+    @field_validator("allowed_tools", mode="before")
+    @classmethod
+    def parse_allowed_tools(cls, v: str | list[str] | None) -> list[str]:
+        if v is None:
+            return []
+        if isinstance(v, str):
+            return v.split()
+        return list(v)
+
+    @field_validator("metadata", mode="before")
+    @classmethod
+    def normalize_metadata(cls, v: dict[str, Any] | None) -> dict[str, str]:
+        if v is None:
+            return {}
+        return {str(k): str(val) for k, val in v.items()}
+
+
+class SkillInfo(BaseModel):
+    name: str
+    description: str
+    license: str | None = None
+    compatibility: str | None = None
+    metadata: dict[str, str] = Field(default_factory=dict)
+    allowed_tools: list[str] = Field(default_factory=list)
+    user_invocable: bool = True
+    skill_path: Path
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    @property
+    def skill_dir(self) -> Path:
+        return self.skill_path.parent.resolve()
+
+    @classmethod
+    def from_metadata(cls, meta: SkillMetadata, skill_path: Path) -> SkillInfo:
+        return cls(
+            name=meta.name,
+            description=meta.description,
+            license=meta.license,
+            compatibility=meta.compatibility,
+            metadata=meta.metadata,
+            allowed_tools=meta.allowed_tools,
+            user_invocable=meta.user_invocable,
+            skill_path=skill_path.resolve(),
+        )

vibe/core/skills/parser.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import yaml
+
+
+class SkillParseError(Exception):
+    def __init__(self, reason: str) -> None:
+        super().__init__(reason)
+        self.reason = reason
+
+
+FM_BOUNDARY = re.compile(r"^-{3,}\s*$", re.MULTILINE)
+
+
+def parse_frontmatter(content: str) -> tuple[dict[str, Any], str]:
+    splits = FM_BOUNDARY.split(content, 2)
+    if len(splits) < 3 or splits[0].strip():  # noqa: PLR2004
+        raise SkillParseError(
+            "Missing or invalid YAML frontmatter (metadata section must start and end with ---)"
+        )
+
+    yaml_content = splits[1]
+    markdown_body = splits[2]
+
+    try:
+        frontmatter = yaml.safe_load(yaml_content)
+    except yaml.YAMLError as e:
+        raise SkillParseError(f"Invalid YAML frontmatter: {e}") from e
+
+    if frontmatter is None:
+        frontmatter = {}
+
+    if not isinstance(frontmatter, dict):
+        raise SkillParseError("YAML frontmatter must be a mapping/dictionary")
+
+    return frontmatter, markdown_body