raise-cli 2.2.1__py3-none-any.whl

raise_cli/mcp/models.py

@@ -0,0 +1,43 @@
+"""MCP infrastructure models — independent of domain adapters.
+
+These models belong to the MCP infrastructure layer. Domain adapters
+(PM, Docs) have their own models in ``raise_cli.adapters.models``.
+
+Architecture: ADR-042, E338 (AR-C1)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class McpToolResult(BaseModel):
+    """Parsed result from an MCP tool call."""
+
+    text: str = ""
+    data: dict[str, Any] = Field(default_factory=dict)
+    is_error: bool = False
+    error_message: str = ""
+
+
+class McpToolInfo(BaseModel):
+    """Tool metadata from server discovery."""
+
+    name: str
+    description: str = ""
+
+
+class McpHealthResult(BaseModel):
+    """Health check result for an MCP server.
+
+    Independent of AdapterHealth (domain layer). Adapters convert
+    McpHealthResult → AdapterHealth when needed.
+    """
+
+    server_name: str = Field(..., description="MCP server identifier")
+    healthy: bool = Field(..., description="Whether server responded")
+    message: str = Field(default="", description="Status or error message")
+    latency_ms: int | None = Field(default=None, description="Response latency in ms")
+    tool_count: int = Field(default=0, description="Number of tools discovered")

raise_cli/mcp/registry.py

@@ -0,0 +1,77 @@
+"""MCP server registry — discovers servers from .raise/mcp/*.yaml.
+
+Scans the MCP config directory for YAML files, parses each as
+``McpServerConfig``, and returns a name → config mapping.
+
+Architecture: ADR-042, E338
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import yaml
+from pydantic import ValidationError
+
+from raise_cli.mcp.schema import McpServerConfig
+
+logger = logging.getLogger(__name__)
+
+
+def discover_mcp_servers(
+    mcp_dir: Path | None = None,
+) -> dict[str, McpServerConfig]:
+    """Discover MCP servers registered in .raise/mcp/*.yaml.
+
+    Scans ``mcp_dir`` (default: ``.raise/mcp/``) for ``*.yaml`` files,
+    parses each as ``McpServerConfig``, and returns a name → config mapping.
+
+    Args:
+        mcp_dir: Directory to scan. Defaults to ``.raise/mcp/``.
+
+    Returns:
+        Mapping of server name to parsed config.
+    """
+    if mcp_dir is None:
+        mcp_dir = Path.cwd() / ".raise" / "mcp"
+
+    if not mcp_dir.is_dir():
+        return {}
+
+    result: dict[str, McpServerConfig] = {}
+
+    for yaml_path in sorted(mcp_dir.glob("*.yaml")):
+        if yaml_path.name == "catalog.yaml":
+            continue
+
+        try:
+            raw = yaml.safe_load(yaml_path.read_text(encoding="utf-8"))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Skipping %s: YAML parse error: %s", yaml_path.name, exc)
+            continue
+
+        if not isinstance(raw, dict):
+            logger.warning("Skipping %s: YAML content is not a mapping", yaml_path.name)
+            continue
+
+        try:
+            config = McpServerConfig.model_validate(raw)
+        except ValidationError as exc:
+            logger.warning(
+                "Skipping %s: schema validation error: %s", yaml_path.name, exc
+            )
+            continue
+
+        name = config.name
+        if name in result:
+            logger.warning(
+                "Skipping %s: server name '%s' already defined by another YAML file",
+                yaml_path.name,
+                name,
+            )
+            continue
+
+        result[name] = config
+
+    return result

raise_cli/mcp/schema.py

@@ -0,0 +1,41 @@
+"""MCP server configuration schema.
+
+Defines the YAML config format for ``.raise/mcp/*.yaml`` and the shared
+``ServerConnection`` model used by both MCP registry and declarative adapters.
+
+Architecture: ADR-042, E338 (AR-C2)
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class ServerConnection(BaseModel):
+    """MCP server connection configuration.
+
+    Shared between MCP registry (``McpServerConfig``) and declarative
+    adapters (``DeclarativeAdapterConfig``). Eliminates duplication (AR-C2).
+    """
+
+    command: str = Field(..., description="Server command (e.g. 'uvx', 'npx')")
+    args: list[str] = Field(
+        default_factory=list, description="Server command arguments"
+    )
+    env: list[str] | None = Field(
+        default=None,
+        description="Env var names to pass to server subprocess",
+    )
+
+
+class McpServerConfig(BaseModel):
+    """Root config model for a generic MCP server.
+
+    Parsed from ``.raise/mcp/<name>.yaml``. Not tied to any domain protocol.
+    """
+
+    name: str = Field(..., description="Server name (used in rai mcp commands)")
+    description: str | None = Field(
+        default=None, description="Human-readable description"
+    )
+    server: ServerConnection

raise_cli/memory/__init__.py

@@ -0,0 +1,58 @@
+"""Memory module for Rai's persistent memory.
+
+This module provides infrastructure for loading, querying, and managing
+Rai's accumulated memories stored in JSONL format.
+
+For queries, use the Graph from raise_cli.context:
+- CLI: `raise context query "keywords" --types pattern,calibration,session`
+- Programmatic: `QueryEngine` from `raise_cli.context.query`
+
+The JSONL files (.raise/rai/memory/*.jsonl) remain the source of truth.
+The unified graph consolidates memory with governance, skills, and work items.
+"""
+
+from __future__ import annotations
+
+from raise_cli.memory.migration import (
+    MigrationResult,
+    migrate_to_personal,
+    needs_migration,
+)
+from raise_cli.memory.models import (
+    MemoryConcept,
+    MemoryConceptType,
+    MemoryRelationship,
+    MemoryRelationshipType,
+    MemoryScope,
+    PatternSubType,
+)
+from raise_cli.memory.writer import (
+    PatternInput,
+    ReinforceResult,
+    SessionInput,
+    WriteResult,
+    append_pattern,
+    append_session,
+    get_memory_dir_for_scope,
+    reinforce_pattern,
+)
+
+__all__ = [
+    "MemoryConcept",
+    "MemoryConceptType",
+    "MemoryRelationship",
+    "MemoryRelationshipType",
+    "MemoryScope",
+    "MigrationResult",
+    "PatternInput",
+    "PatternSubType",
+    "ReinforceResult",
+    "SessionInput",
+    "WriteResult",
+    "append_pattern",
+    "append_session",
+    "get_memory_dir_for_scope",
+    "migrate_to_personal",
+    "needs_migration",
+    "reinforce_pattern",
+]

raise_cli/memory/loader.py

@@ -0,0 +1,247 @@
+"""JSONL loader for memory concepts.
+
+This module provides functions to load memory concepts from JSONL files
+in the .raise/rai/memory/ directory.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import date
+from pathlib import Path
+from typing import Any
+
+from raise_cli.memory.models import (
+    MemoryConcept,
+    MemoryConceptType,
+    MemoryLoadResult,
+    MemoryScope,
+)
+
+
+def parse_date(date_str: str) -> date:
+    """Parse a date string in YYYY-MM-DD format.
+
+    Args:
+        date_str: Date string to parse.
+
+    Returns:
+        Parsed date object.
+
+    Raises:
+        ValueError: If date string is invalid.
+    """
+    return date.fromisoformat(date_str)
+
+
+def load_pattern(
+    data: dict[str, Any], scope: MemoryScope = MemoryScope.PROJECT
+) -> MemoryConcept:
+    """Load a pattern concept from JSONL data.
+
+    Args:
+        data: Dictionary from JSONL line.
+        scope: Memory scope (global, project, or personal).
+
+    Returns:
+        MemoryConcept for the pattern.
+    """
+    # Handle schema variations: 'content' or 'pattern' field
+    content = data.get("content") or data.get("pattern", "")
+    # Handle date field variations: 'created' or 'date'
+    date_str = data.get("created") or data.get("date", "")
+
+    metadata: dict[str, Any] = {
+        "sub_type": data.get("type", "unknown"),
+        "learned_from": data.get("learned_from"),
+        "scope": scope.value,
+    }
+
+    # Surface base/version for pattern versioning (F14.6)
+    if data.get("base") is not None:
+        metadata["base"] = data["base"]
+    if data.get("version") is not None:
+        metadata["version"] = data["version"]
+
+    return MemoryConcept(
+        id=data["id"],
+        type=MemoryConceptType.PATTERN,
+        content=content,
+        context=data.get("context", []),
+        created=parse_date(date_str),
+        metadata=metadata,
+    )
+
+
+def load_calibration(
+    data: dict[str, Any], scope: MemoryScope = MemoryScope.PROJECT
+) -> MemoryConcept:
+    """Load a calibration concept from JSONL data.
+
+    Args:
+        data: Dictionary from JSONL line.
+        scope: Memory scope (global, project, or personal).
+
+    Returns:
+        MemoryConcept for the calibration.
+    """
+    # Handle schema variations for name and story fields
+    name = data.get("name") or data.get("feature_name", "unknown")
+    # Backward compat: try "story" (new), then "feature" (old data)
+    story = data.get("story") or data.get("feature") or data.get("story_id", "unknown")
+    # Handle date field variations: 'created' or 'date'
+    date_str = data.get("created") or data.get("date", "")
+    # Handle velocity field variations: 'ratio' or 'velocity'
+    velocity = data.get("ratio") or data.get("velocity")
+
+    # Build content summary from calibration data
+    content_parts = [f"{name} ({story})"]
+    if data.get("actual_min"):
+        content_parts.append(f"actual: {data['actual_min']}min")
+    if velocity:
+        content_parts.append(f"velocity: {velocity}x")
+    content = " - ".join(content_parts)
+
+    # Build context from story and size
+    context = [story, data["size"].lower()]
+    if data.get("kata_cycle"):
+        context.append("kata-cycle")
+
+    return MemoryConcept(
+        id=data.get("id") or data.get("story_id", "unknown"),
+        type=MemoryConceptType.CALIBRATION,
+        content=content,
+        context=context,
+        created=parse_date(date_str),
+        metadata={
+            "story": story,
+            "name": name,
+            "size": data["size"],
+            "sp": data.get("sp"),
+            "estimated_min": data.get("estimated_min"),
+            "actual_min": data.get("actual_min"),
+            "ratio": velocity,
+            "kata_cycle": data.get("kata_cycle", False),
+            "notes": data.get("notes"),
+            "scope": scope.value,
+        },
+    )
+
+
+def load_session(
+    data: dict[str, Any], scope: MemoryScope = MemoryScope.PROJECT
+) -> MemoryConcept:
+    """Load a session concept from JSONL data.
+
+    Args:
+        data: Dictionary from JSONL line.
+        scope: Memory scope (global, project, or personal).
+
+    Returns:
+        MemoryConcept for the session.
+    """
+    # Handle schema variations: 'topic' or 'summary'
+    topic = data.get("topic") or data.get("summary", "unknown")
+
+    # Build content from topic and outcomes
+    outcomes_str = ", ".join(data.get("outcomes", [])[:3])
+    content = f"{topic}: {outcomes_str}"
+
+    # Build context from type and outcomes keywords
+    context = [data["type"]]
+    # Extract keywords from topic
+    topic_words = topic.lower().split()
+    context.extend([w for w in topic_words if len(w) > 3][:3])
+
+    return MemoryConcept(
+        id=data["id"],
+        type=MemoryConceptType.SESSION,
+        content=content,
+        context=context,
+        created=parse_date(data["date"]),
+        metadata={
+            "session_type": data["type"],
+            "topic": topic,
+            "outcomes": data.get("outcomes", []),
+            "log_path": data.get("log_path"),
+            "scope": scope.value,
+        },
+    )
+
+
+def load_jsonl_file(
+    file_path: Path,
+    concept_type: MemoryConceptType,
+    scope: MemoryScope = MemoryScope.PROJECT,
+) -> tuple[list[MemoryConcept], list[str]]:
+    """Load concepts from a single JSONL file.
+
+    Args:
+        file_path: Path to the JSONL file.
+        concept_type: Type of concepts in the file.
+        scope: Memory scope to assign to loaded concepts.
+
+    Returns:
+        Tuple of (concepts list, errors list).
+    """
+    concepts: list[MemoryConcept] = []
+    errors: list[str] = []
+
+    if not file_path.exists():
+        return concepts, errors
+
+    loader_map = {
+        MemoryConceptType.PATTERN: load_pattern,
+        MemoryConceptType.CALIBRATION: load_calibration,
+        MemoryConceptType.SESSION: load_session,
+    }
+    loader = loader_map[concept_type]
+
+    with file_path.open("r", encoding="utf-8") as f:
+        for line_num, line in enumerate(f, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                data = json.loads(line)
+                concept = loader(data, scope=scope)
+                concepts.append(concept)
+            except (json.JSONDecodeError, KeyError, ValueError) as e:
+                errors.append(f"{file_path.name}:{line_num}: {e}")
+
+    return concepts, errors
+
+
+def load_memory_from_directory(memory_dir: Path) -> MemoryLoadResult:
+    """Load all memory concepts from a .raise/rai/memory/ directory.
+
+    Args:
+        memory_dir: Path to the memory directory.
+
+    Returns:
+        MemoryLoadResult with all loaded concepts.
+    """
+    all_concepts: list[MemoryConcept] = []
+    all_errors: list[str] = []
+    files_processed = 0
+
+    # Define files and their types
+    file_mappings = [
+        (memory_dir / "patterns.jsonl", MemoryConceptType.PATTERN),
+        (memory_dir / "calibration.jsonl", MemoryConceptType.CALIBRATION),
+        (memory_dir / "sessions" / "index.jsonl", MemoryConceptType.SESSION),
+    ]
+
+    for file_path, concept_type in file_mappings:
+        if file_path.exists():
+            concepts, errors = load_jsonl_file(file_path, concept_type)
+            all_concepts.extend(concepts)
+            all_errors.extend(errors)
+            files_processed += 1
+
+    return MemoryLoadResult(
+        concepts=all_concepts,
+        total=len(all_concepts),
+        files_processed=files_processed,
+        errors=all_errors,
+    )