codevira 1.6.0__py3-none-any.whl

mcp_server/tools/learning.py

@@ -0,0 +1,238 @@
+"""
+Learning tools — MCP tools for Codevira's adaptive memory system.
+
+These tools expose the feedback loop to AI agents:
+  - get_decision_confidence: How confident is the system about decisions in an area?
+  - get_preferences: What coding style does the developer prefer?
+  - get_learned_rules: Auto-generated rules from observed patterns
+  - get_project_maturity: Overall project intelligence score
+  - get_session_context: Single "catch me up" call for cross-tool continuity
+"""
+from __future__ import annotations
+
+import json
+import logging
+from mcp_server.paths import get_data_dir
+from indexer.sqlite_graph import SQLiteGraph
+
+logger = logging.getLogger(__name__)
+
+
+def _get_db() -> SQLiteGraph:
+    return SQLiteGraph(get_data_dir() / "graph" / "graph.db")
+
+
+def get_decision_confidence(file_path: str | None = None, pattern: str | None = None) -> dict:
+    """Get confidence scores for decisions about a file or pattern."""
+    db = _get_db()
+    try:
+        confidence = db.get_decision_confidence(file_path=file_path, pattern=pattern)
+        label = file_path or pattern or "project-wide"
+        return {
+            "scope": label,
+            **confidence,
+            "interpretation": _interpret_confidence(confidence["confidence"]),
+        }
+    finally:
+        db.close()
+
+
+def get_preferences(category: str | None = None) -> dict:
+    """Get learned developer preferences."""
+    db = _get_db()
+    try:
+        prefs = db.get_preferences(category=category, min_frequency=1)
+        return {
+            "preferences": prefs,
+            "total": len(prefs),
+            "hint": "Apply these preferences when writing code to match the developer's style."
+                    if prefs else "No preferences learned yet. They build up over sessions.",
+        }
+    finally:
+        db.close()
+
+
+def get_learned_rules(file_path: str | None = None, category: str | None = None) -> dict:
+    """Get auto-generated rules from observed patterns."""
+    db = _get_db()
+    try:
+        rules = db.get_learned_rules(category=category, file_pattern=file_path, min_confidence=0.3)
+        return {
+            "rules": [
+                {
+                    "rule": r["rule_text"],
+                    "confidence": r["confidence"],
+                    "category": r["category"],
+                    "applies_to": r.get("file_pattern"),
+                }
+                for r in rules
+            ],
+            "total": len(rules),
+            "hint": "These rules were learned from past sessions. Higher confidence = more reliable."
+                    if rules else "No rules learned yet. They emerge after multiple sessions.",
+        }
+    finally:
+        db.close()
+
+
+def get_project_maturity() -> dict:
+    """Get overall project intelligence and maturity metrics."""
+    db = _get_db()
+    try:
+        maturity = db.get_project_maturity()
+        score = _compute_maturity_score(maturity)
+        return {
+            **maturity,
+            "maturity_score": score,
+            "maturity_level": _maturity_level(score),
+            "hint": _maturity_hint(score),
+        }
+    finally:
+        db.close()
+
+
+def get_session_context() -> dict:
+    """
+    Single 'catch me up' call for cross-tool continuity.
+    Returns everything a new agent session needs to understand the current state:
+    current roadmap phase, open changesets, recent decisions with confidence, and recent sessions.
+    """
+    db = _get_db()
+    try:
+        # Recent sessions
+        recent_sessions = db.get_recent_sessions(limit=3)
+
+        # Recent decisions with confidence
+        recent_decisions = db.get_recent_decisions(limit=5)
+
+        # Confidence overview
+        confidence = db.get_decision_confidence()
+
+        # Preferences summary (top 5 by frequency)
+        prefs = db.get_preferences(min_frequency=2)[:5]
+
+        # Learned rules (high confidence only)
+        rules = db.get_learned_rules(min_confidence=0.6)[:5]
+
+        context = {
+            "recent_sessions": [
+                {
+                    "session_id": s["session_id"],
+                    "summary": s.get("summary"),
+                    "phase": s.get("phase"),
+                }
+                for s in recent_sessions
+            ],
+            "recent_decisions": [
+                {
+                    "decision": d["decision"],
+                    "file_path": d.get("file_path"),
+                    "phase": d.get("phase"),
+                }
+                for d in recent_decisions
+            ],
+            "overall_confidence": confidence,
+            "top_preferences": [
+                {"category": p["category"], "signal": p["signal"], "frequency": p["frequency"]}
+                for p in prefs
+            ],
+            "top_rules": [
+                {"rule": r["rule_text"], "confidence": r["confidence"]}
+                for r in rules
+            ],
+        }
+
+        # Add roadmap context if available
+        try:
+            from mcp_server.tools.roadmap import get_roadmap
+            roadmap = get_roadmap()
+            context["roadmap"] = {
+                "current_phase": roadmap.get("current_phase", {}).get("name"),
+                "next_action": roadmap.get("current_phase", {}).get("next_action"),
+                "status": roadmap.get("current_phase", {}).get("status"),
+            }
+        except Exception as e:
+            logger.warning("Could not load roadmap context: %s", e)
+            context["roadmap"] = None
+
+        # Add open changesets if any
+        try:
+            from mcp_server.tools.changesets import list_open_changesets
+            changesets = list_open_changesets()
+            context["open_changesets"] = changesets.get("changesets", [])
+        except Exception as e:
+            logger.warning("Could not load changesets context: %s", e)
+            context["open_changesets"] = []
+
+        # v1.5: Add global intelligence stats
+        try:
+            from mcp_server.global_sync import get_global_stats
+            context["global_intelligence"] = get_global_stats()
+        except Exception as e:
+            logger.warning("Could not load global intelligence: %s", e)
+            context["global_intelligence"] = None
+
+        # v1.6: Add indexing progress if background init is running
+        try:
+            from mcp_server.auto_init import get_init_progress
+            prog = get_init_progress()
+            if prog["status"] not in ("ready", "not_started"):
+                context["indexing_progress"] = prog
+        except Exception:
+            pass
+
+        return context
+    finally:
+        db.close()
+
+
+def _interpret_confidence(score: float) -> str:
+    if score >= 0.8:
+        return "High confidence — consistent successful patterns in this area."
+    elif score >= 0.5:
+        return "Moderate confidence — some patterns established but results are mixed."
+    elif score > 0:
+        return "Low confidence — limited history or frequent corrections. Proceed carefully."
+    return "No data — this is new territory. Decisions here will build the baseline."
+
+
+def _compute_maturity_score(maturity: dict) -> float:
+    """Compute a 0-100 maturity score from multiple signals."""
+    score = 0.0
+
+    # Sessions (max 20 points)
+    score += min(maturity["session_count"] * 2, 20)
+
+    # Coverage (max 30 points)
+    score += maturity["coverage"] * 30
+
+    # Confidence (max 25 points)
+    score += maturity["overall_confidence"] * 25
+
+    # Learned rules (max 15 points)
+    score += min(maturity["learned_rules"] * 3, 15)
+
+    # Preferences (max 10 points)
+    score += min(maturity["preference_signals"] * 2, 10)
+
+    return round(min(score, 100), 1)
+
+
+def _maturity_level(score: float) -> str:
+    if score >= 80:
+        return "Expert — agents have rich context and high confidence."
+    elif score >= 50:
+        return "Intermediate — good coverage, patterns emerging."
+    elif score >= 20:
+        return "Growing — some sessions logged, building baseline."
+    return "New — fresh project, minimal agent memory."
+
+
+def _maturity_hint(score: float) -> str:
+    if score >= 80:
+        return "Project memory is mature. Agents should rely on learned patterns and confidence scores."
+    elif score >= 50:
+        return "Good progress. Continue using Codevira — confidence and rules will keep improving."
+    elif score >= 20:
+        return "Still building memory. Run more agent sessions and outcomes will start influencing confidence."
+    return "This is a fresh start. Every session logs decisions that future agents will learn from."

mcp_server/tools/playbook.py

@@ -0,0 +1,89 @@
+"""
+MCP tool for retrieving curated rule playbooks by task type.
+Serves the right 2-3 rule files for a given task — not all of them.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from mcp_server.paths import get_package_data_dir
+
+
+def _rules_dir() -> Path:
+    return get_package_data_dir() / "rules"
+
+# Task type → relevant rule files (ordered by importance)
+# These map common development tasks to the rule files that govern them.
+PLAYBOOKS: dict[str, list[str]] = {
+    "add_tool": [
+        "coding-standards.md",
+        "testing-standards.md",
+    ],
+    "add_service": [
+        "coding-standards.md",
+        "resilience-observability.md",
+    ],
+    "add_schema": [
+        "coding-standards.md",
+        "persistence.md",
+    ],
+    "debug_pipeline": [
+        "resilience-observability.md",
+        "coding-standards.md",
+    ],
+    "commit": [
+        "git_commits.md",
+        "git-cicd-governance.md",
+    ],
+    "write_test": [
+        "testing-standards.md",
+        "smoke-testing.md",
+    ],
+}
+
+
+def get_playbook(task_type: str) -> dict:
+    """
+    Return curated rule content for a specific task type.
+    Serves only the relevant 2-3 rule files, not all of them.
+
+    Args:
+        task_type: One of add_route | add_service | add_schema |
+                   debug_pipeline | commit | write_test
+
+    Returns:
+        Dict with task_type, rules (list of {file, content}), token_note.
+    """
+    task_type = task_type.lower().strip()
+
+    if task_type not in PLAYBOOKS:
+        return {
+            "found": False,
+            "task_type": task_type,
+            "available_task_types": sorted(PLAYBOOKS.keys()),
+            "hint": "Use get_node() for file-specific rules embedded in the context graph.",
+        }
+
+    rule_files = PLAYBOOKS[task_type]
+    rules = []
+
+    for filename in rule_files:
+        path = _rules_dir() / filename
+        if path.exists():
+            rules.append({
+                "file": filename,
+                "content": path.read_text().strip(),
+            })
+        else:
+            rules.append({
+                "file": filename,
+                "content": f"[File not found: {path}]",
+            })
+
+    return {
+        "found": True,
+        "task_type": task_type,
+        "rules": rules,
+        "note": f"Serving {len(rules)} rule files for '{task_type}'. "
+                f"File-specific rules are in get_node() → rules field.",
+    }