@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/cdh/session_store.py

@@ -1,221 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-import uuid
-from datetime import datetime, timezone
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Optional
-
-logger = logging.getLogger("cdh.session_store")
-
-
-@dataclass
-class SessionData:
-    id: str = field(default_factory=lambda: str(uuid.uuid4()))
-    name: str = "Untitled"
-    mode: str = "build"
-    project: str = ""
-    model: str = ""
-    provider: str = ""
-    messages: list[dict] = field(default_factory=list)
-    lifecycle_state: dict = field(default_factory=dict)
-    created_at: Optional[str] = None
-    updated_at: Optional[str] = None
-    todos: list[dict] = field(default_factory=list)
-
-    def to_dict(self) -> dict:
-        return {
-            "id": self.id,
-            "name": self.name,
-            "mode": self.mode,
-            "project": self.project,
-            "model": self.model,
-            "provider": self.provider,
-            "messages": self.messages,
-            "lifecycle_state": self.lifecycle_state,
-            "created_at": self.created_at,
-            "updated_at": self.updated_at,
-            "todos": self.todos,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> SessionData:
-        legacy_todos: list[dict] = []
-        legacy_todos.extend(data.get("tasks") or [])
-        legacy_todos.extend(data.get("todos") or [])
-        return cls(
-            id=data.get("id", str(uuid.uuid4())),
-            name=data.get("name", "Untitled"),
-            mode=data.get("mode", "build"),
-            project=data.get("project", ""),
-            model=data.get("model", ""),
-            provider=data.get("provider", ""),
-            messages=data.get("messages", []),
-            lifecycle_state=data.get("lifecycle_state", {}),
-            created_at=data.get("created_at"),
-            updated_at=data.get("updated_at"),
-            todos=legacy_todos,
-        )
-
-
-class AgentSession:
-    def __init__(self, session_id: Optional[str] = None, storage_path: Optional[Path] = None):
-        self.storage_path = storage_path or self._default_storage_path()
-        self._data: SessionData = SessionData()
-        if session_id:
-            self._data.id = session_id
-
-    def _default_storage_path(self) -> Path:
-        cdh_sessions = Path.home() / ".cdh" / "sessions"
-        onecode_sessions = Path.home() / ".onecode" / "sessions"
-        marker = cdh_sessions / ".migrated_from_onecode"
-        if not marker.exists() and onecode_sessions.exists():
-            try:
-                cdh_sessions.mkdir(parents=True, exist_ok=True)
-                for f in list(onecode_sessions.glob("*.json"))[:250]:
-                    dst = cdh_sessions / f.name
-                    if not dst.exists():
-                        import shutil
-                        shutil.move(str(f), str(dst))
-                marker.write_text("migrated", encoding="utf-8")
-            except Exception as e:
-                logger.warning("Failed to migrate onecode sessions to cdh: %s", e)
-        return cdh_sessions
-
-    @property
-    def id(self) -> str:
-        return self._data.id
-
-    @property
-    def name(self) -> str:
-        return self._data.name
-
-    @name.setter
-    def name(self, value: str) -> None:
-        self._data.name = value
-
-    @property
-    def messages(self) -> list[dict]:
-        return self._data.messages
-
-    @messages.setter
-    def messages(self, value: list[dict]) -> None:
-        self._data.messages = value
-
-    @property
-    def lifecycle_state(self) -> dict:
-        return self._data.lifecycle_state
-
-    @property
-    def todos(self) -> list[dict]:
-        return self._data.todos
-
-    @todos.setter
-    def todos(self, value: list[dict]) -> None:
-        self._data.todos = value
-
-    @property
-    def mode(self) -> str:
-        return self._data.mode
-
-    @mode.setter
-    def mode(self, value: str) -> None:
-        self._data.mode = value
-
-    @property
-    def project(self) -> str:
-        return self._data.project
-
-    @project.setter
-    def project(self, value: str) -> None:
-        self._data.project = value
-
-    @property
-    def model(self) -> str:
-        return self._data.model
-
-    @model.setter
-    def model(self, value: str) -> None:
-        self._data.model = value
-
-    @property
-    def provider(self) -> str:
-        return self._data.provider
-
-    @provider.setter
-    def provider(self, value: str) -> None:
-        self._data.provider = value
-
-    def add_message(self, role: str, content: str) -> None:
-        self._data.messages.append({"role": role, "content": content})
-        self._touch()
-
-    def compact_messages(self, summary: str) -> None:
-        if len(self._data.messages) <= 2:
-            return
-        system_msgs = [m for m in self._data.messages if m.get("role") == "system"]
-        self._data.messages = system_msgs + [
-            {"role": "system", "content": f"[Previous context summarized]\n{summary}"}
-        ]
-        self._touch()
-
-    def update_state(self, key: str, value: Any) -> None:
-        self._data.lifecycle_state[key] = value
-        self._touch()
-
-    def get_state(self, key: str, default: Any = None) -> Any:
-        return self._data.lifecycle_state.get(key, default)
-
-    def save(self) -> None:
-        self.storage_path.mkdir(parents=True, exist_ok=True)
-        file_path = self.storage_path / f"{self._data.id}.json"
-        self._data.updated_at = datetime.now(timezone.utc).isoformat()
-        file_path.write_text(json.dumps(self._data.to_dict(), indent=2, ensure_ascii=False), encoding="utf-8")
-
-    def load(self) -> bool:
-        file_path = self.storage_path / f"{self._data.id}.json"
-        if not file_path.exists():
-            return False
-        try:
-            data = json.loads(file_path.read_text(encoding="utf-8"))
-            self._data = SessionData.from_dict(data)
-            return True
-        except Exception as e:
-            logger.warning("Failed to load session %s: %s", self._data.id, e)
-            return False
-
-    def delete(self) -> None:
-        file_path = self.storage_path / f"{self._data.id}.json"
-        if file_path.exists():
-            file_path.unlink()
-
-    def _touch(self) -> None:
-        self._data.updated_at = datetime.now(timezone.utc).isoformat()
-
-    @classmethod
-    def list_sessions(cls, storage_path: Optional[Path] = None) -> list[SessionData]:
-        path = storage_path or cls()._default_storage_path()
-        if not path.exists():
-            return []
-        sessions = []
-        for f in path.glob("*.json"):
-            try:
-                data = json.loads(f.read_text(encoding="utf-8"))
-                sessions.append(SessionData.from_dict(data))
-            except Exception:
-                continue
-        return sorted(sessions, key=lambda s: s.updated_at or "", reverse=True)
-
-    @classmethod
-    def delete_by_id(cls, session_id: str, storage_path: Optional[Path] = None) -> bool:
-        path = storage_path or cls()._default_storage_path()
-        file_path = path / f"{session_id}.json"
-        if file_path.exists():
-            file_path.unlink()
-            return True
-        return False
-
-    def to_dict(self) -> dict:
-        return self._data.to_dict()

package/cdh/state_schema.py

@@ -1,127 +0,0 @@
-from __future__ import annotations
-
-import re
-from datetime import datetime
-from typing import Any
-
-try:
-    import jsonschema
-
-    HAS_JSONSCHEMA = True
-except ImportError:
-    jsonschema = None
-    HAS_JSONSCHEMA = False
-
-
-ISO_DATE_TIME = r"^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$"
-PHASES = ["init", "understand", "plan", "verify", "deliver"]
-
-SCHEMA: dict[str, Any] = {
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "type": "object",
-    "required": [
-        "state_version", "schema_version", "current_phase", "completed_phases",
-        "gate_results", "fingerprint", "task_registry",
-    ],
-    "properties": {
-        "state_version": {"type": "integer"},
-        "schema_version": {"type": "string"},
-        "current_phase": {"type": "string", "enum": PHASES},
-        "completed_phases": {
-            "type": "array", "items": {"type": "string", "enum": PHASES},
-        },
-        "gate_results": {
-            "type": "object",
-            "additionalProperties": {
-                "type": "object",
-                "required": ["status", "summary", "recorded_at"],
-                "properties": {
-                    "status": {"type": "string", "enum": ["passed", "failed", "skipped"]},
-                    "summary": {"type": "string"},
-                    "recorded_at": {"type": "string", "format": "date-time"},
-                },
-            },
-        },
-        "fingerprint": {"type": "string"},
-        "task_registry": {
-            "type": "array",
-            "items": {
-                "type": "object",
-                "required": ["fingerprint", "intent", "status", "created_at", "updated_at"],
-                "properties": {
-                    "fingerprint": {"type": "string", "minLength": 24, "maxLength": 24},
-                    "intent": {"type": "string"},
-                    "status": {"type": "string", "enum": ["pending", "in_progress", "completed", "failed"]},
-                    "created_at": {"type": "string", "format": "date-time"},
-                    "updated_at": {"type": "string", "format": "date-time"},
-                    "result": {"type": "string"},
-                },
-            },
-        },
-    },
-}
-
-
-def _date_time(value: Any) -> bool:
-    if not isinstance(value, str) or not re.fullmatch(ISO_DATE_TIME, value):
-        return False
-    try:
-        datetime.fromisoformat(value.replace("Z", "+00:00"))
-        return True
-    except ValueError:
-        return False
-
-
-def _type_matches(value: Any, expected: str) -> bool:
-    checks = {
-        "string": lambda: isinstance(value, str),
-        "integer": lambda: isinstance(value, int) and not isinstance(value, bool),
-        "array": lambda: isinstance(value, list),
-        "object": lambda: isinstance(value, dict),
-        "boolean": lambda: isinstance(value, bool),
-    }
-    return checks.get(expected, lambda: True)()
-
-
-def _minimal_validate(value: Any, schema: dict[str, Any], path: str = "$", errors: list[str] | None = None) -> list[str]:
-    errors = [] if errors is None else errors
-    expected = schema.get("type")
-    if expected and not _type_matches(value, expected):
-        errors.append(f"{path}: expected {expected}")
-        return errors
-    if "enum" in schema and value not in schema["enum"]:
-        errors.append(f"{path}: must be one of {schema['enum']}")
-    if isinstance(value, str):
-        if "minLength" in schema and len(value) < schema["minLength"]:
-            errors.append(f"{path}: shorter than minLength")
-        if "maxLength" in schema and len(value) > schema["maxLength"]:
-            errors.append(f"{path}: longer than maxLength")
-        if "pattern" in schema and not re.search(schema["pattern"], value):
-            errors.append(f"{path}: does not match pattern")
-        if schema.get("format") == "date-time" and not _date_time(value):
-            errors.append(f"{path}: invalid date-time")
-    if isinstance(value, dict):
-        for name in schema.get("required", []):
-            if name not in value:
-                errors.append(f"{path}: missing required property '{name}'")
-        for name, child in schema.get("properties", {}).items():
-            if name in value:
-                _minimal_validate(value[name], child, f"{path}.{name}", errors)
-        additional = schema.get("additionalProperties")
-        if isinstance(additional, dict):
-            for name, item in value.items():
-                if name not in schema.get("properties", {}):
-                    _minimal_validate(item, additional, f"{path}.{name}", errors)
-    if isinstance(value, list) and "items" in schema:
-        for index, item in enumerate(value):
-            _minimal_validate(item, schema["items"], f"{path}[{index}]", errors)
-    return errors
-
-
-def validate_state(state: Any) -> tuple[bool, list[str]]:
-    if HAS_JSONSCHEMA:
-        validator = jsonschema.Draft202012Validator(SCHEMA)
-        errors = sorted(validator.iter_errors(state), key=lambda error: list(error.path))
-        return not errors, [f"{'/'.join(map(str, error.path)) or '$'}: {error.message}" for error in errors]
-    errors = _minimal_validate(state, SCHEMA)
-    return not errors, errors

package/cdh/tools/__init__.py

@@ -1,57 +0,0 @@
-import shutil
-from pathlib import Path
-
-
-_TOOL_FILES = [
-    "generate_shared.py",
-    "contract_diff.py",
-    "deploy_stack.py",
-]
-
-
-def install_tools(project_root: Path) -> list[str]:
-    source_dir = Path(__file__).parent
-    target_dir = project_root / "aidlc" / "tools"
-    target_dir.mkdir(parents=True, exist_ok=True)
-
-    generators_source = source_dir.parent / "generators"
-    generators_target = target_dir.parent / "generators"
-    if generators_source.is_dir():
-        shutil.copytree(
-            generators_source,
-            generators_target,
-            dirs_exist_ok=True,
-            ignore=shutil.ignore_patterns("__pycache__", "*.pyc"),
-        )
-
-    installed = []
-    for tf in _TOOL_FILES:
-        src = source_dir / tf
-        if not src.exists():
-            continue
-        dst = target_dir / tf
-        shutil.copy2(src, dst)
-        dst.chmod(0o755)
-        installed.append(tf)
-    return installed
-
-
-def tools_status(project_root: Path) -> dict[str, str]:
-    tools_dir = project_root / "aidlc" / "tools"
-    result = {}
-    for tf in _TOOL_FILES:
-        f = tools_dir / tf
-        if not f.exists():
-            result[tf] = "missing"
-        else:
-            content = f.read_text(encoding="utf-8")
-            if "not yet implemented" in content:
-                result[tf] = "stub"
-            else:
-                result[tf] = "installed"
-    return result
-
-
-def update_tools(project_root: Path) -> list[str]:
-    installed = install_tools(project_root)
-    return installed