mrstack 1.1.0__py3-none-any.whl

mrstack/_overlay/jarvis/pattern_learner.py

@@ -0,0 +1,255 @@
+"""Pattern learner — logs interactions and extracts usage patterns.
+
+Records every bot interaction to interactions.jsonl, then provides
+pattern extraction for coaching and preemptive action triggers.
+"""
+
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Optional
+
+import structlog
+
+from .persona import ContextState
+
+logger = structlog.get_logger()
+
+# Request type classification patterns
+_TYPE_PATTERNS: list[tuple[str, list[re.Pattern[str]]]] = [
+    (
+        "debug",
+        [
+            re.compile(r"(에러|error|bug|fix|왜.*안|traceback|오류|디버그)", re.I),
+            re.compile(r"(안\s*[되됨]|문제|crash|fail)", re.I),
+        ],
+    ),
+    (
+        "feature",
+        [
+            re.compile(r"(만들어|추가|구현|implement|add|create|build)", re.I),
+            re.compile(r"(기능|feature|새로)", re.I),
+        ],
+    ),
+    (
+        "question",
+        [
+            re.compile(r"(뭐야|무엇|어떻게|왜|what|how|why|explain|설명)", re.I),
+            re.compile(r"\?$"),
+        ],
+    ),
+    (
+        "brainstorm",
+        [
+            re.compile(r"(아이디어|설계|design|plan|구조|architecture|방법)", re.I),
+            re.compile(r"(어떤.*좋|제안|suggest|recommend)", re.I),
+        ],
+    ),
+]
+
+DEFAULT_TYPE = "admin"
+
+
+class PatternLearner:
+    """Logs interactions and extracts behavioral patterns."""
+
+    def __init__(self, memory_base: str | Path) -> None:
+        self.memory_base = Path(memory_base)
+        self.patterns_dir = self.memory_base / "patterns"
+        self.patterns_dir.mkdir(parents=True, exist_ok=True)
+        self.interactions_path = self.patterns_dir / "interactions.jsonl"
+        self.routines_path = self.patterns_dir / "routines.json"
+
+    def log_interaction(
+        self,
+        user_id: int,
+        prompt: str,
+        response: str,
+        duration_ms: int,
+        tools_used: list[str] | None = None,
+        state: ContextState | None = None,
+    ) -> None:
+        """Append an interaction record to interactions.jsonl."""
+        now = datetime.now()
+        record = {
+            "ts": now.isoformat(),
+            "dow": now.strftime("%a").lower(),
+            "hour": now.hour,
+            "user_id": user_id,
+            "state": state.value if state else "UNKNOWN",
+            "request_type": self._classify_request(prompt),
+            "prompt_length": len(prompt),
+            "response_length": len(response),
+            "duration_ms": duration_ms,
+            "tools_used": tools_used or [],
+        }
+        try:
+            with open(self.interactions_path, "a", encoding="utf-8") as f:
+                f.write(json.dumps(record, ensure_ascii=False) + "\n")
+        except Exception:
+            logger.exception("Failed to log interaction")
+
+    def _classify_request(self, prompt: str) -> str:
+        """Classify a user prompt into a request type."""
+        for rtype, patterns in _TYPE_PATTERNS:
+            for pat in patterns:
+                if pat.search(prompt):
+                    return rtype
+        return DEFAULT_TYPE
+
+    def extract_patterns(self, days: int = 7) -> dict[str, Any]:
+        """Extract usage patterns from recent interactions.
+
+        Returns:
+            Dict with hourly_counts, peak_hours, request_types, avg_duration.
+        """
+        cutoff = datetime.now() - timedelta(days=days)
+        records = self._load_records(cutoff)
+
+        if not records:
+            return {
+                "hourly_counts": {},
+                "peak_hours": [],
+                "request_types": {},
+                "avg_duration": 0,
+                "total": 0,
+            }
+
+        hourly: Counter[int] = Counter()
+        types: Counter[str] = Counter()
+        durations: list[int] = []
+
+        for rec in records:
+            hourly[rec.get("hour", 0)] += 1
+            types[rec.get("request_type", DEFAULT_TYPE)] += 1
+            if "duration_ms" in rec:
+                durations.append(rec["duration_ms"])
+
+        sorted_hours = sorted(hourly.items(), key=lambda x: x[1], reverse=True)
+        peak_hours = [h for h, _ in sorted_hours[:4]]
+
+        return {
+            "hourly_counts": dict(hourly),
+            "peak_hours": peak_hours,
+            "request_types": dict(types),
+            "avg_duration": int(sum(durations) / len(durations)) if durations else 0,
+            "total": len(records),
+        }
+
+    def update_routines(self, days: int = 14) -> None:
+        """Analyze interactions and auto-generate routines.json.
+
+        Detects recurring (day_of_week, hour, request_type) combos.
+        Called by memory-sync or a dedicated scheduled job.
+        """
+        records = self._load_records(
+            cutoff=datetime.now() - timedelta(days=days)
+        )
+        if len(records) < 20:
+            return  # Not enough data
+
+        # Count (dow, hour, type) triples
+        combos: Counter[tuple[str, int, str]] = Counter()
+        dow_hour_total: Counter[tuple[str, int]] = Counter()
+
+        for rec in records:
+            dow = rec.get("dow", "")
+            hour = rec.get("hour", 0)
+            rtype = rec.get("request_type", DEFAULT_TYPE)
+            combos[(dow, hour, rtype)] += 1
+            dow_hour_total[(dow, hour)] += 1
+
+        # How many unique weeks in the data?
+        weeks = max(1, days // 7)
+
+        routines = []
+        for (dow, hour, rtype), count in combos.most_common(20):
+            # confidence = occurrences / weeks (capped at 1.0)
+            confidence = round(min(count / weeks, 1.0), 2)
+            if confidence < 0.5:
+                continue
+            routines.append({
+                "pattern": f"{dow} {hour}:00",
+                "request_type": rtype,
+                "confidence": confidence,
+                "count": count,
+            })
+
+        if not routines:
+            return
+
+        try:
+            self.routines_path.write_text(
+                json.dumps({"routines": routines, "updated": datetime.now().isoformat()},
+                           ensure_ascii=False, indent=2),
+                encoding="utf-8",
+            )
+            logger.info("Routines updated", count=len(routines))
+        except Exception:
+            logger.exception("Failed to write routines.json")
+
+    def check_preemptive(
+        self, state: ContextState, hour: int
+    ) -> Optional[dict[str, Any]]:
+        """Check if a preemptive action should trigger based on learned routines.
+
+        Returns matching routine dict if confidence > 0.7, else None.
+        """
+        if not self.routines_path.exists():
+            return None
+
+        try:
+            data = json.loads(self.routines_path.read_text(encoding="utf-8"))
+        except Exception:
+            return None
+
+        dow = datetime.now().strftime("%a").lower()
+
+        for routine in data.get("routines", []):
+            confidence = routine.get("confidence", 0)
+            if confidence < 0.7:
+                continue
+            pattern = routine.get("pattern", "")
+            # Simple matching: check if day-of-week or hour appears in pattern
+            if dow in pattern.lower() or str(hour) in pattern:
+                return routine
+
+        return None
+
+    def _load_records(
+        self, cutoff: Optional[datetime] = None
+    ) -> list[dict[str, Any]]:
+        """Load interaction records, optionally filtering by cutoff date."""
+        if not self.interactions_path.exists():
+            return []
+
+        records: list[dict[str, Any]] = []
+        try:
+            with open(self.interactions_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        rec = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if cutoff:
+                        ts = rec.get("ts", "")
+                        try:
+                            if datetime.fromisoformat(ts) < cutoff:
+                                continue
+                        except ValueError:
+                            continue
+                    records.append(rec)
+        except Exception:
+            logger.exception("Failed to load interaction records")
+
+        return records
+
+    def get_today_records(self) -> list[dict[str, Any]]:
+        """Get all interaction records from today."""
+        today_start = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+        return self._load_records(cutoff=today_start)

mrstack/_overlay/jarvis/persona.py

@@ -0,0 +1,84 @@
+"""Persona layer — context-aware tone and style for Jarvis messages.
+
+Maps (ContextState, hour, activity_duration) to a prompt prefix
+that shapes Claude's response tone.
+"""
+
+from enum import Enum
+
+
+class ContextState(str, Enum):
+    CODING = "CODING"
+    BROWSING = "BROWSING"
+    MEETING = "MEETING"
+    COMMUNICATION = "COMMUNICATION"
+    BREAK = "BREAK"
+    DEEP_WORK = "DEEP_WORK"
+    AWAY = "AWAY"
+
+
+class PersonaLayer:
+    """Builds a system prompt prefix based on current context."""
+
+    @staticmethod
+    def build_prompt_prefix(
+        state: ContextState,
+        hour: int,
+        activity_duration_min: int = 0,
+    ) -> str:
+        """Return a tone instruction string for Claude.
+
+        Args:
+            state: Current detected user state.
+            hour: Current hour (0-23).
+            activity_duration_min: Minutes spent in current state.
+
+        Returns:
+            A short instruction string to prepend to Claude prompts.
+        """
+        parts: list[str] = ["[Jarvis]"]
+
+        # Late night concern (22:00+)
+        if hour >= 22:
+            parts.append(
+                "사용자가 야간에 작업 중입니다. "
+                "걱정하는 톤으로, 마무리를 권유하세요. 간결하게."
+            )
+            return " ".join(parts)
+
+        # State-specific tone rules
+        if state == ContextState.DEEP_WORK:
+            parts.append(
+                "사용자가 딥워크 중입니다. "
+                "최소한의 응답만 하세요. 불필요한 말 금지."
+            )
+        elif state == ContextState.CODING:
+            parts.append(
+                "사용자가 코딩 중입니다. "
+                "기술적이고 간결하게 응답하세요. 파일명:라인 형식 선호."
+            )
+            if activity_duration_min >= 180:
+                parts.append(
+                    f"({activity_duration_min}분째 코딩 중 — 휴식 권유 한마디 추가)"
+                )
+        elif state == ContextState.BREAK:
+            parts.append(
+                "사용자가 휴식에서 돌아왔습니다. "
+                "따뜻하고 간결하게 응답하세요."
+            )
+        elif state == ContextState.MEETING:
+            parts.append(
+                "사용자가 미팅 중이거나 직후입니다. "
+                "단답형으로 핵심만 전달하세요."
+            )
+        elif state == ContextState.BROWSING:
+            parts.append("사용자가 브라우징 중입니다. 간결하게 응답하세요.")
+        elif state == ContextState.COMMUNICATION:
+            parts.append("사용자가 커뮤니케이션 중입니다. 간결하게 응답하세요.")
+        elif state == ContextState.AWAY:
+            parts.append(
+                "사용자가 자리를 비운 상태입니다. "
+                "돌아오면 알아볼 수 있게 핵심 요약으로 응답하세요."
+            )
+
+        return " ".join(parts)

mrstack/_overlay/jarvis/platform.py

@@ -0,0 +1,182 @@
+"""Platform abstraction layer for Jarvis context engine.
+
+Detects the current platform and provides cross-platform alternatives
+for system monitoring APIs (active app, battery, CPU, etc.).
+
+Usage:
+    from .platform import PLATFORM, can, collect_battery, collect_cpu_load
+
+    if can("active_app"):
+        app = collect_active_app()
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+import structlog
+
+logger = structlog.get_logger()
+
+# ── Platform detection ─────────────────────────────────
+PLATFORM: str = sys.platform  # 'darwin', 'linux', 'win32'
+IS_MACOS = PLATFORM == "darwin"
+IS_LINUX = PLATFORM == "linux"
+IS_WINDOWS = PLATFORM == "win32"
+
+
+@dataclass
+class PlatformFeatures:
+    """Which features are available on this platform."""
+
+    active_app: bool = False
+    battery: bool = False
+    cpu_load: bool = True  # psutil works everywhere
+    chrome_tabs: bool = False
+    sleep_prevent: bool = False
+    keychain: bool = True  # keyring library is cross-platform
+
+
+# Build feature map at import time
+def _detect_features() -> PlatformFeatures:
+    f = PlatformFeatures()
+    if IS_MACOS:
+        f.active_app = shutil.which("osascript") is not None
+        f.battery = shutil.which("pmset") is not None
+        f.chrome_tabs = f.active_app
+        f.sleep_prevent = shutil.which("caffeinate") is not None
+    elif IS_LINUX:
+        # xdotool or xprop can detect active window on X11
+        f.active_app = shutil.which("xdotool") is not None
+        f.battery = _has_psutil_battery()
+    elif IS_WINDOWS:
+        f.battery = _has_psutil_battery()
+    return f
+
+
+def _has_psutil_battery() -> bool:
+    try:
+        import psutil
+
+        return psutil.sensors_battery() is not None
+    except Exception:
+        return False
+
+
+FEATURES = _detect_features()
+
+
+def can(feature: str) -> bool:
+    """Check if a feature is available on this platform."""
+    return getattr(FEATURES, feature, False)
+
+
+# ── Cross-platform collectors ──────────────────────────
+
+
+def collect_active_app() -> str:
+    """Return the name of the frontmost application."""
+    if IS_MACOS:
+        return _run_cmd([
+            "osascript", "-e",
+            'tell app "System Events" to get name of first process '
+            "whose frontmost is true",
+        ])
+    if IS_LINUX:
+        # xdotool approach
+        wid = _run_cmd(["xdotool", "getactivewindow"])
+        if wid:
+            name = _run_cmd(["xdotool", "getactivewindow", "getwindowclassname"])
+            return name
+    # Windows / unsupported
+    return ""
+
+
+def collect_battery() -> tuple[int, bool]:
+    """Return (battery_percent, is_charging).
+
+    Returns (100, True) if battery info is unavailable.
+    """
+    if IS_MACOS:
+        import re
+
+        out = _run_cmd(["pmset", "-g", "batt"])
+        if out:
+            m = re.search(r"(\d+)%", out)
+            pct = int(m.group(1)) if m else 100
+            charging = "charging" in out.lower() or "charged" in out.lower()
+            return pct, charging
+
+    # Cross-platform fallback via psutil
+    try:
+        import psutil
+
+        batt = psutil.sensors_battery()
+        if batt:
+            return int(batt.percent), batt.power_plugged or False
+    except Exception:
+        pass
+
+    return 100, True
+
+
+def collect_cpu_load() -> float:
+    """Return 1-minute load average (or CPU percent on Windows)."""
+    if IS_MACOS:
+        import re
+
+        out = _run_cmd(["sysctl", "-n", "vm.loadavg"])
+        if out:
+            m = re.search(r"[\d.]+", out)
+            if m:
+                try:
+                    return float(m.group())
+                except ValueError:
+                    pass
+
+    # Cross-platform via psutil
+    try:
+        import psutil
+
+        if hasattr(psutil, "getloadavg"):
+            return psutil.getloadavg()[0]
+        return psutil.cpu_percent(interval=1) / 100.0
+    except Exception:
+        pass
+
+    return 0.0
+
+
+def collect_chrome_tabs() -> List[str]:
+    """Return list of Chrome tab titles (macOS only)."""
+    if IS_MACOS:
+        out = _run_cmd([
+            "osascript", "-e",
+            'tell application "Google Chrome" to get title of active tab '
+            "of front window",
+        ])
+        if out:
+            return [out]
+    return []
+
+
+def collect_git_info(working_directory: str) -> tuple[str, bool]:
+    """Return (branch_name, is_dirty)."""
+    branch = _run_cmd(["git", "-C", working_directory, "branch", "--show-current"])
+    dirty_out = _run_cmd(["git", "-C", working_directory, "status", "--short"])
+    return branch, bool(dirty_out)
+
+
+# ── Helper ─────────────────────────────────────────────
+def _run_cmd(cmd: list[str], timeout: int = 5) -> str:
+    try:
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=timeout,
+        )
+        return result.stdout.strip() if result.returncode == 0 else ""
+    except Exception:
+        return ""

mrstack/_overlay/knowledge/__init__.py

@@ -0,0 +1,6 @@
+"""Knowledge module — memory indexing and knowledge base management."""
+
+from .manager import KnowledgeItem, KnowledgeManager
+from .memory_index import MemoryIndex
+
+__all__ = ["MemoryIndex", "KnowledgeManager", "KnowledgeItem"]