deepy-cli 0.1.1__py3-none-any.whl

deepy/sessions/manager.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import os
+import signal
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from deepy.config import Settings, load_settings
+from deepy.llm.provider import ProviderBundle
+from deepy.llm.runner import RunSummary, run_prompt_once
+from deepy.utils import json as json_utils
+
+from .jsonl import DeepyJsonlSession, list_session_entries, project_sessions_dir
+
+
+@dataclass(frozen=True)
+class InterruptSummary:
+    session_id: str
+    killed_pids: list[int]
+    failed_pids: list[int]
+
+
+@dataclass
+class DeepySessionManager:
+    project_root: Path
+    settings: Settings | None = None
+    provider: ProviderBundle | None = None
+    deepy_home: Path | None = None
+    active_session_id: str | None = None
+    _interrupted_sessions: set[str] = field(default_factory=set, init=False, repr=False)
+
+    async def handle_user_prompt(
+        self,
+        prompt: str,
+        *,
+        session_id: str | None = None,
+        **run_kwargs: Any,
+    ) -> RunSummary:
+        target_session = session_id or self.active_session_id
+        if target_session:
+            return await self.reply_session(target_session, prompt, **run_kwargs)
+        return await self.create_session(prompt, **run_kwargs)
+
+    async def create_session(self, prompt: str, **run_kwargs: Any) -> RunSummary:
+        summary = await self._run(prompt, session_id=None, **run_kwargs)
+        self.active_session_id = summary.session_id
+        return summary
+
+    async def reply_session(
+        self,
+        session_id: str,
+        prompt: str,
+        **run_kwargs: Any,
+    ) -> RunSummary:
+        self.activate_session(session_id)
+        return await self._run(prompt, session_id=session_id, **run_kwargs)
+
+    def activate_session(self, session_id: str) -> None:
+        if not session_id:
+            raise ValueError("session_id is required.")
+        self.active_session_id = session_id
+
+    async def append_sdk_items(self, session_id: str, items: list[dict[str, Any]]) -> None:
+        session = DeepyJsonlSession.open(
+            self.project_root,
+            session_id,
+            deepy_home=self.deepy_home,
+        )
+        await session.add_items(items)
+
+    async def compact_session(self, session_id: str) -> None:
+        session = DeepyJsonlSession.open(
+            self.project_root,
+            session_id,
+            deepy_home=self.deepy_home,
+        )
+        items = await session.get_items()
+        if not items:
+            return
+        await session.clear_session()
+        await session.add_items(
+            [
+                {
+                    "role": "system",
+                    "content": (
+                        "Earlier conversation history was compacted by Deepy. "
+                        f"Compacted item count: {len(items)}."
+                    ),
+                }
+            ]
+        )
+
+    def interrupt_active_session(self) -> InterruptSummary | None:
+        if not self.active_session_id:
+            return None
+        return self.interrupt_session(self.active_session_id)
+
+    def interrupt_session(self, session_id: str) -> InterruptSummary:
+        self._interrupted_sessions.add(session_id)
+        processes = _session_processes(self.project_root, session_id, self.deepy_home)
+        killed_pids, failed_pids = _kill_processes(processes)
+        _clear_session_processes(self.project_root, session_id, self.deepy_home)
+        return InterruptSummary(
+            session_id=session_id,
+            killed_pids=killed_pids,
+            failed_pids=failed_pids,
+        )
+
+    async def _run(
+        self,
+        prompt: str,
+        *,
+        session_id: str | None,
+        **run_kwargs: Any,
+    ) -> RunSummary:
+        effective_session_id = session_id
+
+        def should_interrupt() -> bool:
+            return bool(effective_session_id and effective_session_id in self._interrupted_sessions)
+
+        summary = await run_prompt_once(
+            prompt,
+            project_root=self.project_root,
+            settings=self.settings or load_settings(),
+            provider=self.provider,
+            session_id=effective_session_id,
+            should_interrupt=should_interrupt if effective_session_id else None,
+            **run_kwargs,
+        )
+        if effective_session_id is None:
+            effective_session_id = summary.session_id
+        if summary.interrupted:
+            self._interrupted_sessions.discard(effective_session_id)
+        self.active_session_id = summary.session_id
+        return summary
+
+
+def _session_processes(
+    project_root: Path,
+    session_id: str,
+    deepy_home: Path | None,
+) -> dict[str, dict[str, str]]:
+    for entry in list_session_entries(project_root, deepy_home=deepy_home):
+        if entry.id == session_id and isinstance(entry.processes, dict):
+            return entry.processes
+    return {}
+
+
+def _kill_processes(processes: dict[str, dict[str, str]]) -> tuple[list[int], list[int]]:
+    killed_pids: list[int] = []
+    failed_pids: list[int] = []
+    for raw_pid in processes:
+        try:
+            pid = int(raw_pid)
+        except ValueError:
+            continue
+        if _kill_process_group(pid) or _kill_process(pid):
+            killed_pids.append(pid)
+        else:
+            failed_pids.append(pid)
+    return killed_pids, failed_pids
+
+
+def _kill_process_group(pid: int) -> bool:
+    try:
+        os.killpg(pid, signal.SIGKILL)
+    except OSError:
+        return False
+    return True
+
+
+def _kill_process(pid: int) -> bool:
+    try:
+        os.kill(pid, signal.SIGKILL)
+    except OSError:
+        return False
+    return True
+
+
+def _clear_session_processes(
+    project_root: Path,
+    session_id: str,
+    deepy_home: Path | None,
+) -> None:
+    index_path = project_sessions_dir(project_root, deepy_home) / "sessions-index.json"
+    if not index_path.is_file():
+        return
+    try:
+        raw = json_utils.loads(index_path.read_text(encoding="utf-8") or "{}")
+    except Exception:
+        return
+    changed = False
+    entries = raw.get("sessions")
+    if not isinstance(entries, list):
+        return
+    for entry in entries:
+        if isinstance(entry, dict) and entry.get("id") == session_id:
+            entry["processes"] = None
+            changed = True
+    if changed:
+        index_path.write_text(json_utils.dumps_pretty(raw) + "\n", encoding="utf-8")

deepy/skills.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+SKILL_MATCH_STOPWORDS = {
+    "a",
+    "an",
+    "and",
+    "for",
+    "from",
+    "in",
+    "of",
+    "on",
+    "or",
+    "the",
+    "to",
+    "use",
+    "with",
+}
+
+
+@dataclass(frozen=True)
+class SkillInfo:
+    name: str
+    path: Path
+    description: str = ""
+    scope: str = "user"
+    is_loaded: bool = False
+
+
+def discover_skills(project_root: Path, *, home: Path | None = None) -> list[SkillInfo]:
+    home_dir = home or Path.home()
+    roots = [
+        ("user", home_dir / ".agents" / "skills"),
+        ("project", project_root / ".deepy" / "skills"),
+    ]
+    by_name: dict[str, SkillInfo] = {}
+    for scope, root in roots:
+        for skill in _discover_skills_root(root, scope=scope):
+            by_name[_normalize_name(skill.name)] = skill
+    return sorted(by_name.values(), key=lambda item: item.name)
+
+
+def find_skill(project_root: Path, name: str, *, home: Path | None = None) -> SkillInfo | None:
+    normalized = _normalize_name(name)
+    for skill in discover_skills(project_root, home=home):
+        if _normalize_name(skill.name) == normalized:
+            return skill
+    return None
+
+
+def match_skills_for_prompt(
+    skills: Iterable[SkillInfo],
+    prompt: str,
+    *,
+    max_matches: int = 3,
+) -> list[SkillInfo]:
+    normalized_prompt = _normalize_match_text(prompt)
+    if not normalized_prompt:
+        return []
+    scored: list[tuple[int, str, SkillInfo]] = []
+    for skill in skills:
+        score = _skill_match_score(skill, normalized_prompt)
+        if score > 0:
+            scored.append((score, skill.name, skill))
+    scored.sort(key=lambda item: (-item[0], item[1]))
+    return [skill for _score, _name, skill in scored[:max_matches]]
+
+
+def read_skill_body(skill: SkillInfo) -> str:
+    text = skill.path.read_text(encoding="utf-8", errors="replace")
+    _frontmatter, body = _split_frontmatter(text)
+    return body.strip()
+
+
+def format_skills_for_prompt(skills: Iterable[SkillInfo]) -> str:
+    return _format_skills(skills, include_paths=True)
+
+
+def format_skills_for_terminal(skills: Iterable[SkillInfo]) -> str:
+    return _format_skills(skills, include_paths=False)
+
+
+def format_loaded_skills_for_prompt(skills: Iterable[SkillInfo]) -> str:
+    blocks: list[str] = []
+    for skill in sorted(skills, key=lambda item: item.name):
+        body = read_skill_body(skill)
+        if body:
+            blocks.append(f"<skill name=\"{skill.name}\">\n{body}\n</skill>")
+    return "\n\n".join(blocks) if blocks else "No skills loaded."
+
+
+def _format_skills(skills: Iterable[SkillInfo], *, include_paths: bool) -> str:
+    grouped: dict[str, list[SkillInfo]] = {"project": [], "user": []}
+    for skill in skills:
+        grouped.setdefault(skill.scope, []).append(skill)
+
+    lines: list[str] = []
+    for scope in ("project", "user"):
+        items = grouped.get(scope) or []
+        if not items:
+            continue
+        lines.append(f"{scope.title()} skills:")
+        for skill in sorted(items, key=lambda item: item.name):
+            description = f" - {skill.description}" if skill.description else ""
+            path = f" ({skill.path})" if include_paths else ""
+            lines.append(f"- {skill.name}{description}{path}")
+    return "\n".join(lines) if lines else "No skills found."
+
+
+def _discover_skills_root(root: Path, *, scope: str) -> list[SkillInfo]:
+    if not root.is_dir():
+        return []
+    skills: list[SkillInfo] = []
+    for entry in sorted(root.iterdir(), key=lambda item: item.name):
+        skill_path = entry / "SKILL.md"
+        if not entry.is_dir() or not skill_path.is_file():
+            continue
+        skill = read_skill_info(skill_path, default_name=entry.name, scope=scope)
+        if skill is not None:
+            skills.append(skill)
+    return skills
+
+
+def read_skill_info(
+    path: Path,
+    *,
+    default_name: str | None = None,
+    scope: str = "user",
+) -> SkillInfo | None:
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return None
+    frontmatter, body = _split_frontmatter(text)
+    name = _clean_scalar(frontmatter.get("name")) or default_name or path.parent.name
+    description = _clean_scalar(frontmatter.get("description")) or _first_body_line(body)
+    return SkillInfo(name=name, description=description, path=path, scope=scope)
+
+
+def _split_frontmatter(text: str) -> tuple[dict[str, str], str]:
+    lines = text.splitlines()
+    if not lines or lines[0].strip() != "---":
+        return {}, text
+    for index, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            return _parse_simple_yaml(lines[1:index]), "\n".join(lines[index + 1 :])
+    return {}, text
+
+
+def _parse_simple_yaml(lines: list[str]) -> dict[str, str]:
+    data: dict[str, str] = {}
+    for line in lines:
+        if ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        key = key.strip()
+        if key:
+            data[key] = value.strip().strip('"').strip("'")
+    return data
+
+
+def _first_body_line(body: str) -> str:
+    for line in body.splitlines():
+        stripped = line.strip()
+        if stripped:
+            return stripped.lstrip("#").strip()
+    return ""
+
+
+def _clean_scalar(value: str | None) -> str:
+    return value.strip() if isinstance(value, str) and value.strip() else ""
+
+
+def _normalize_name(name: str) -> str:
+    return name.strip().lower()
+
+
+def _skill_match_score(skill: SkillInfo, normalized_prompt: str) -> int:
+    name = _normalize_match_text(skill.name)
+    if name and name in normalized_prompt:
+        return 100 + len(name)
+    score = 0
+    for token in _match_tokens(f"{skill.name} {skill.description}"):
+        if f" {token} " in f" {normalized_prompt} ":
+            score += 1
+    return score
+
+
+def _match_tokens(value: str) -> set[str]:
+    return {
+        token
+        for token in _normalize_match_text(value).split()
+        if len(token) >= 3 and token not in SKILL_MATCH_STOPWORDS
+    }
+
+
+def _normalize_match_text(value: str) -> str:
+    chars = [char.lower() if char.isalnum() else " " for char in value]
+    return " ".join("".join(chars).split())

deepy/status.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from deepy.config import Settings
+from deepy.prompts.runtime_context import build_runtime_context
+from deepy.sessions import list_session_entries
+from deepy.skills import discover_skills
+
+
+@dataclass(frozen=True)
+class StatusReport:
+    project_root: Path
+    model: str
+    api_key_configured: bool
+    context_window_tokens: int
+    compact_threshold_tokens: int
+    session_count: int
+    skill_count: int
+    runtime_context: str
+
+
+def build_status_report(project_root: Path, settings: Settings) -> StatusReport:
+    root = project_root.resolve()
+    return StatusReport(
+        project_root=root,
+        model=settings.model.name,
+        api_key_configured=bool(settings.model.api_key),
+        context_window_tokens=settings.context.window_tokens,
+        compact_threshold_tokens=settings.context.resolved_compact_threshold,
+        session_count=len(list_session_entries(root)),
+        skill_count=len(discover_skills(root)),
+        runtime_context=build_runtime_context(root),
+    )
+
+
+def format_status_report(report: StatusReport) -> str:
+    return "\n".join(
+        [
+            f"Project: {report.project_root}",
+            f"Model: {report.model}",
+            f"API key: {'configured' if report.api_key_configured else 'missing'}",
+            f"Context: {report.context_window_tokens} tokens",
+            f"Compact threshold: {report.compact_threshold_tokens} tokens",
+            f"Sessions: {report.session_count}",
+            f"Skills: {report.skill_count}",
+            "",
+            report.runtime_context,
+        ]
+    )
+
+
+def status_report_to_dict(report: StatusReport) -> dict[str, Any]:
+    return {
+        "project_root": str(report.project_root),
+        "model": report.model,
+        "api_key_configured": report.api_key_configured,
+        "context_window_tokens": report.context_window_tokens,
+        "compact_threshold_tokens": report.compact_threshold_tokens,
+        "session_count": report.session_count,
+        "skill_count": report.skill_count,
+        "runtime_context": report.runtime_context,
+    }

deepy/tools/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .builtin import ToolRuntime
+from .result import ToolResult
+
+__all__ = ["ToolResult", "ToolRuntime"]