@scemoon/cdh 1.0.6 → 1.0.8

package/cdh/cdh_session_aggregator.py

@@ -1,258 +0,0 @@
-"""cdh platform session aggregator — cross-engine session registry.
-
-Maintains a session registry at ~/.cdh/sessions/sessions.db (SQLite).
-Provides a cross-engine view across all registered engines.
-Engines register sessions via the aggregator API.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import sqlite3
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Optional
-
-logger = logging.getLogger("cdh.session")
-
-CDH_SESSIONS_DIR = Path.home() / ".cdh" / "sessions"
-
-
-class CdhSessionAggregator:
-    def __init__(self, sessions_dir: Path | None = None):
-        self.sessions_dir = sessions_dir or CDH_SESSIONS_DIR
-        self.sessions_dir.mkdir(parents=True, exist_ok=True)
-        self.db_path = self.sessions_dir / "sessions.db"
-        self._init_db()
-
-    def _init_db(self) -> None:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.execute(
-                """
-                CREATE TABLE IF NOT EXISTS sessions (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    engine TEXT NOT NULL,
-                    engine_session_id TEXT NOT NULL,
-                    project_name TEXT DEFAULT '',
-                    agent TEXT NOT NULL,
-                    title TEXT NOT NULL,
-                    protocol TEXT DEFAULT 'acp',
-                    prompt_count INTEGER DEFAULT 0,
-                    created_at TEXT NOT NULL,
-                    last_used TEXT NOT NULL,
-                    meta_json TEXT DEFAULT '{}',
-                    UNIQUE(engine, engine_session_id)
-                )
-                """
-            )
-            conn.commit()
-            conn.close()
-        except sqlite3.Error as e:
-            logger.error("Failed to init session db: %s", e)
-
-    def register(
-        self,
-        engine: str,
-        engine_session_id: str,
-        agent: str,
-        title: str,
-        project_name: str = "",
-        protocol: str = "acp",
-        meta: dict[str, Any] | None = None,
-    ) -> Optional[int]:
-        now = datetime.now(timezone.utc).isoformat()
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.execute(
-                """
-                INSERT OR REPLACE INTO sessions
-                    (engine, engine_session_id, project_name, agent, title, protocol,
-                     prompt_count, created_at, last_used, meta_json)
-                VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?)
-                """,
-                (
-                    engine,
-                    engine_session_id,
-                    project_name,
-                    agent,
-                    title,
-                    protocol,
-                    now,
-                    now,
-                    json.dumps(meta or {}),
-                ),
-            )
-            conn.commit()
-            cursor = conn.execute("SELECT last_insert_rowid()")
-            row_id = cursor.fetchone()[0]
-            conn.close()
-            return row_id
-        except sqlite3.Error as e:
-            logger.error("Failed to register session: %s", e)
-            return None
-
-    def update_last_used(self, engine: str, engine_session_id: str) -> bool:
-        now = datetime.now(timezone.utc).isoformat()
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.execute(
-                "UPDATE sessions SET last_used = ? WHERE engine = ? AND engine_session_id = ?",
-                (now, engine, engine_session_id),
-            )
-            conn.commit()
-            conn.close()
-            return True
-        except sqlite3.Error:
-            return False
-
-    def increment_prompt_count(self, engine: str, engine_session_id: str) -> bool:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.execute(
-                "UPDATE sessions SET prompt_count = prompt_count + 1 WHERE engine = ? AND engine_session_id = ?",
-                (engine, engine_session_id),
-            )
-            conn.commit()
-            conn.close()
-            return True
-        except sqlite3.Error:
-            return False
-
-    def get(self, session_id: int) -> Optional[dict]:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.row_factory = sqlite3.Row
-            cursor = conn.execute("SELECT * FROM sessions WHERE id = ?", (session_id,))
-            row = cursor.fetchone()
-            conn.close()
-            return dict(row) if row else None
-        except sqlite3.Error:
-            return None
-
-    def get_by_engine_id(self, engine: str, engine_session_id: str) -> Optional[dict]:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.row_factory = sqlite3.Row
-            cursor = conn.execute(
-                "SELECT * FROM sessions WHERE engine = ? AND engine_session_id = ?",
-                (engine, engine_session_id),
-            )
-            row = cursor.fetchone()
-            conn.close()
-            return dict(row) if row else None
-        except sqlite3.Error:
-            return None
-
-    def get_recent(self, max_results: int = 100) -> list[dict]:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.row_factory = sqlite3.Row
-            cursor = conn.execute(
-                "SELECT * FROM sessions ORDER BY last_used DESC LIMIT ?",
-                (max_results,),
-            )
-            rows = cursor.fetchall()
-            conn.close()
-            return [dict(r) for r in rows]
-        except sqlite3.Error:
-            return []
-
-    def get_by_engine(self, engine: str, max_results: int = 100) -> list[dict]:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.row_factory = sqlite3.Row
-            cursor = conn.execute(
-                "SELECT * FROM sessions WHERE engine = ? ORDER BY last_used DESC LIMIT ?",
-                (engine, max_results),
-            )
-            rows = cursor.fetchall()
-            conn.close()
-            return [dict(r) for r in rows]
-        except sqlite3.Error:
-            return []
-
-    def get_by_project(self, project_name: str, max_results: int = 100) -> list[dict]:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.row_factory = sqlite3.Row
-            cursor = conn.execute(
-                "SELECT * FROM sessions WHERE project_name = ? ORDER BY last_used DESC LIMIT ?",
-                (project_name, max_results),
-            )
-            rows = cursor.fetchall()
-            conn.close()
-            return [dict(r) for r in rows]
-        except sqlite3.Error:
-            return []
-
-    def delete(self, session_id: int) -> bool:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            conn.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
-            conn.commit()
-            conn.close()
-            return True
-        except sqlite3.Error:
-            return False
-
-    def count(self) -> int:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            cursor = conn.execute("SELECT COUNT(*) FROM sessions")
-            count = cursor.fetchone()[0]
-            conn.close()
-            return count
-        except sqlite3.Error:
-            return 0
-
-    def list_engines(self) -> list[str]:
-        try:
-            conn = sqlite3.connect(str(self.db_path))
-            cursor = conn.execute("SELECT DISTINCT engine FROM sessions ORDER BY engine")
-            rows = cursor.fetchall()
-            conn.close()
-            return [r[0] for r in rows]
-        except sqlite3.Error:
-            return []
-
-    def import_from_tui_db(self, tui_db_path: Path) -> int:
-        """Import sessions from a tui.db into the aggregator.
-
-        Returns the number of sessions imported.
-        """
-        if not tui_db_path.exists():
-            logger.info("No tui.db found at %s", tui_db_path)
-            return 0
-
-        imported = 0
-        try:
-            tui_conn = sqlite3.connect(str(tui_db_path))
-            tui_conn.row_factory = sqlite3.Row
-            cursor = tui_conn.execute(
-                "SELECT * FROM sessions ORDER BY id"
-            )
-            rows = cursor.fetchall()
-            tui_conn.close()
-
-            for row in rows:
-                sess = dict(row)
-                engine = sess.get("agent_identity", "tui").lower()
-                engine_session_id = sess.get("agent_session_id", str(sess["id"]))
-                if self.get_by_engine_id(engine, engine_session_id) is None:
-                    self.register(
-                        engine=engine,
-                        engine_session_id=engine_session_id,
-                        agent=sess.get("agent", engine),
-                        title=sess.get("title", f"Session {sess['id']}"),
-                        protocol=sess.get("protocol", "acp"),
-                        meta={"imported_from": str(tui_db_path), "original_id": sess["id"]},
-                    )
-                    imported += 1
-
-            logger.info("Imported %d sessions from %s", imported, tui_db_path)
-        except sqlite3.Error as e:
-            logger.error("Failed to import from tui.db: %s", e)
-
-        return imported

package/cdh/cdh_skill_manager.py

@@ -1,105 +0,0 @@
-"""cdh platform skill manager — operates ~/.cdh/skills/<name>/.
-
-This is the cdh platform equivalent of onecode.skills.manager.SkillManager,
-but operates strictly on ~/.cdh/skills/ (cdh platform shared pool).
-Engines (onecode/opencode/claude) do NOT read this directory directly;
-cdh injects platform skills into engines at runtime via prompt or env var.
-"""
-
-from __future__ import annotations
-
-import shutil
-from pathlib import Path
-from typing import Optional
-
-import yaml
-
-
-CDH_PLATFORM_SKILLS_DIR = Path.home() / ".cdh" / "skills"
-
-
-class CdhSkillManager:
-    def __init__(self, skills_dir: Path | None = None):
-        self.skills_dir = skills_dir or CDH_PLATFORM_SKILLS_DIR
-        self.skills_dir.mkdir(parents=True, exist_ok=True)
-        self._skills: dict[str, dict] = {}
-
-    def install(self, path: Path) -> Optional[str]:
-        """Install a skill from source path into the cdh platform skill pool.
-
-        Copies the entire skill directory to ~/.cdh/skills/<name>/,
-        and writes .installed_version with the source's metadata.version.
-        Returns error message or None on success.
-        """
-        skill_yaml = path / "skill.yaml"
-        if not skill_yaml.exists():
-            return "skill.yaml not found in source"
-
-        data = yaml.safe_load(skill_yaml.read_text())
-        name = data.get("name", path.name)
-        target = self.skills_dir / name
-        target.mkdir(parents=True, exist_ok=True)
-
-        for src in path.iterdir():
-            if src.name.startswith("."):
-                continue
-            dst = target / src.name
-            if src.is_dir():
-                shutil.copytree(src, dst, dirs_exist_ok=True)
-            else:
-                shutil.copy2(src, dst)
-
-        # Write version marker
-        version = data.get("metadata", {}).get("version", "4.0.0")
-        version_file = target / ".installed_version"
-        version_file.write_text(version + "\n", encoding="utf-8")
-
-        self._skills[name] = data
-        return None
-
-    def list(self) -> list[dict]:
-        result = []
-        for d in self.skills_dir.iterdir():
-            if d.is_dir():
-                config_path = d / "skill.yaml"
-                if config_path.exists():
-                    data = yaml.safe_load(config_path.read_text()) or {}
-                    data["name"] = data.get("name", d.name)
-                    data["enabled"] = data.get("enabled", True)
-                    result.append(data)
-        return result
-
-    def enable(self, name: str, enabled: bool = True):
-        config_path = self.skills_dir / name / "skill.yaml"
-        if config_path.exists():
-            data = yaml.safe_load(config_path.read_text()) or {}
-            data["enabled"] = enabled
-            config_path.write_text(yaml.dump(data, default_flow_style=False))
-
-    def get_installed_version(self, name: str) -> Optional[str]:
-        version_file = self.skills_dir / name / ".installed_version"
-        if version_file.exists():
-            return version_file.read_text(encoding="utf-8").strip()
-        return None
-
-    def remove(self, name: str) -> Optional[str]:
-        skill_path = self.skills_dir / name
-        if not skill_path.exists():
-            return f"Skill '{name}' not found"
-        if not skill_path.is_dir():
-            return f"'{name}' is not a skill directory"
-        shutil.rmtree(skill_path)
-        self._skills.pop(name, None)
-        return None
-
-    def get(self, name: str) -> Optional[dict]:
-        if name in self._skills:
-            return self._skills[name]
-        skill_path = self.skills_dir / name / "skill.yaml"
-        if skill_path.exists():
-            data = yaml.safe_load(skill_path.read_text()) or {}
-            data["name"] = data.get("name", name)
-            data["enabled"] = data.get("enabled", True)
-            self._skills[name] = data
-            return data
-        return None