mrstack 1.1.0__py3-none-any.whl

mrstack/_overlay/jarvis/__init__.py

@@ -0,0 +1,77 @@
+"""Jarvis mode — proactive context-aware AI partner.
+
+JarvisEngine is the facade that composes:
+- ContextEngine: system state polling + trigger evaluation
+- PatternLearner: interaction logging + pattern extraction
+- DailyCoach: productivity coaching reports
+- PersonaLayer: context-aware tone injection
+"""
+
+from pathlib import Path
+from typing import List, Optional
+
+import structlog
+
+from ..events.bus import EventBus
+from .coach import DailyCoach
+from .context_engine import ContextEngine
+from .pattern_learner import PatternLearner
+from .persona import ContextState, PersonaLayer
+
+logger = structlog.get_logger()
+
+__all__ = [
+    "JarvisEngine",
+    "ContextState",
+    "PersonaLayer",
+    "PatternLearner",
+    "DailyCoach",
+    "ContextEngine",
+]
+
+
+class JarvisEngine:
+    """Facade combining all Jarvis sub-modules."""
+
+    def __init__(
+        self,
+        event_bus: EventBus,
+        target_chat_ids: List[int],
+        working_directory: str = "",
+        memory_base: str = "",
+    ) -> None:
+        if not working_directory:
+            working_directory = str(Path.home())
+        if not memory_base:
+            memory_base = str(Path.home() / "claude-telegram" / "memory")
+        self.pattern_learner = PatternLearner(memory_base)
+        self.context_engine = ContextEngine(
+            event_bus=event_bus,
+            target_chat_ids=target_chat_ids,
+            working_directory=working_directory,
+            pattern_learner=self.pattern_learner,
+        )
+        self.coach = DailyCoach(memory_base)
+        self.persona = PersonaLayer()
+
+    @property
+    def enabled(self) -> bool:
+        return self.context_engine.enabled
+
+    @property
+    def current_state(self) -> ContextState:
+        return self.context_engine.current_state
+
+    def toggle(self) -> bool:
+        """Toggle Jarvis on/off. Returns new state."""
+        return self.context_engine.toggle()
+
+    async def start(self) -> None:
+        """Start the context engine polling loop."""
+        await self.context_engine.start()
+        logger.info("Jarvis engine started")
+
+    async def stop(self) -> None:
+        """Stop the context engine polling loop."""
+        await self.context_engine.stop()
+        logger.info("Jarvis engine stopped")

mrstack/_overlay/jarvis/coach.py

@@ -0,0 +1,122 @@
+"""Daily coach — generates productivity coaching reports from interaction data.
+
+Uses interactions.jsonl to analyze the day's work patterns
+and produce a direct, actionable coaching report.
+"""
+
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import structlog
+
+from .pattern_learner import PatternLearner
+
+logger = structlog.get_logger()
+
+
+class DailyCoach:
+    """Generates daily coaching reports from interaction logs."""
+
+    def __init__(self, memory_base: str | Path) -> None:
+        self.memory_base = Path(memory_base)
+        self.pattern_learner = PatternLearner(memory_base)
+
+    def calculate_metrics(
+        self, records: list[dict[str, Any]]
+    ) -> dict[str, Any]:
+        """Calculate productivity metrics from interaction records.
+
+        Returns:
+            Dict with total, success_rate, context_switches, debug_ratio, peak_hour.
+        """
+        if not records:
+            return {
+                "total": 0,
+                "avg_duration_ms": 0,
+                "context_switches": 0,
+                "debug_ratio": 0.0,
+                "peak_hour": None,
+                "request_types": {},
+                "hourly_distribution": {},
+                "states": {},
+            }
+
+        types: Counter[str] = Counter()
+        hours: Counter[int] = Counter()
+        states: Counter[str] = Counter()
+        durations: list[int] = []
+        context_switches = 0
+        prev_state = None
+
+        for rec in records:
+            rtype = rec.get("request_type", "admin")
+            types[rtype] += 1
+            hours[rec.get("hour", 0)] += 1
+            state = rec.get("state", "UNKNOWN")
+            states[state] += 1
+            if "duration_ms" in rec:
+                durations.append(rec["duration_ms"])
+            if prev_state and state != prev_state:
+                context_switches += 1
+            prev_state = state
+
+        total = len(records)
+        debug_count = types.get("debug", 0)
+        peak_hour = hours.most_common(1)[0][0] if hours else None
+
+        return {
+            "total": total,
+            "avg_duration_ms": int(sum(durations) / len(durations)) if durations else 0,
+            "context_switches": context_switches,
+            "debug_ratio": round(debug_count / total, 2) if total else 0.0,
+            "peak_hour": peak_hour,
+            "request_types": dict(types),
+            "hourly_distribution": dict(hours),
+            "states": dict(states),
+        }
+
+    def generate_report(self, date: datetime | None = None) -> str:
+        """Generate a coaching report prompt for Claude to process.
+
+        Args:
+            date: Target date (defaults to today).
+
+        Returns:
+            A prompt string that Claude should process to produce the coaching report.
+        """
+        if date is None:
+            date = datetime.now()
+
+        records = self.pattern_learner.get_today_records()
+        metrics = self.calculate_metrics(records)
+
+        # Also get weekly patterns for trend analysis
+        weekly = self.pattern_learner.extract_patterns(days=7)
+
+        date_str = date.strftime("%Y-%m-%d")
+
+        prompt = (
+            f"[Daily Coach] {date_str} 코칭 리포트를 작성해주세요.\n\n"
+            f"오늘의 데이터:\n"
+            f"- 총 요청: {metrics['total']}회\n"
+            f"- 평균 응답 시간: {metrics['avg_duration_ms']}ms\n"
+            f"- 컨텍스트 전환: {metrics['context_switches']}회\n"
+            f"- 디버깅 비율: {metrics['debug_ratio']:.0%}\n"
+            f"- 피크 시간: {metrics['peak_hour']}시\n"
+            f"- 요청 유형: {metrics['request_types']}\n"
+            f"- 시간대별 분포: {metrics['hourly_distribution']}\n"
+            f"- 상태 분포: {metrics['states']}\n\n"
+            f"주간 패턴 (7일):\n"
+            f"- 총 요청: {weekly['total']}회\n"
+            f"- 피크 시간대: {weekly['peak_hours']}\n"
+            f"- 요청 유형 분포: {weekly['request_types']}\n\n"
+            f"다음 형식으로 직설적인 코칭 리포트를 작성하세요:\n"
+            f"1. 생산성 점수 (1-10)\n"
+            f"2. 잘한 점 (bullet 2-3개)\n"
+            f"3. 개선 포인트 (구체적 제안 포함, bullet 2-3개)\n"
+            f"4. 이번 주 트렌드 (패턴 분석)\n\n"
+            f"직설적이되 건설적으로. 아첨 금지. 한국어로 작성."
+        )
+        return prompt

mrstack/_overlay/jarvis/context_engine.py

@@ -0,0 +1,463 @@
+"""Context engine — polls system state, detects context, evaluates triggers.
+
+Mirrors ClipboardMonitor's asyncio.Task pattern:
+- 5-minute polling via subprocess calls (osascript, pmset, sysctl, git, etc.)
+- State classification (CODING, BROWSING, MEETING, ...)
+- Rule-based trigger evaluation with cooldowns
+- Publishes ScheduledEvent to EventBus on trigger fire
+"""
+
+import asyncio
+import re
+import subprocess
+import time
+from collections import deque
+from typing import Any, Deque, Dict, List, Optional, Tuple
+
+import structlog
+
+from ..events.bus import EventBus
+from ..events.types import ScheduledEvent
+from .persona import ContextState, PersonaLayer
+
+logger = structlog.get_logger()
+
+POLL_INTERVAL = 300  # 5 minutes
+MAX_API_CALLS_PER_HOUR = 10
+
+# App name -> state mapping
+_APP_STATE_MAP: Dict[str, ContextState] = {
+    "code": ContextState.CODING,
+    "terminal": ContextState.CODING,
+    "iterm": ContextState.CODING,
+    "warp": ContextState.CODING,
+    "xcode": ContextState.CODING,
+    "cursor": ContextState.CODING,
+    "chrome": ContextState.BROWSING,
+    "safari": ContextState.BROWSING,
+    "firefox": ContextState.BROWSING,
+    "arc": ContextState.BROWSING,
+    "zoom": ContextState.MEETING,
+    "meet": ContextState.MEETING,
+    "teams": ContextState.MEETING,
+    "facetime": ContextState.MEETING,
+    "slack": ContextState.COMMUNICATION,
+    "discord": ContextState.COMMUNICATION,
+    "messages": ContextState.COMMUNICATION,
+    "telegram": ContextState.COMMUNICATION,
+    "kakaotalk": ContextState.COMMUNICATION,
+    "mail": ContextState.COMMUNICATION,
+}
+
+# Trigger cooldowns (seconds)
+_TRIGGER_COOLDOWNS: Dict[str, int] = {
+    "battery_warning": 1800,        # 30 min
+    "meeting_prep": 3600,           # 1 hour
+    "return_from_away": 1800,       # 30 min
+    "long_coding_session": 3600,    # 1 hour
+    "context_switch_overload": 1800, # 30 min
+    "terminal_error": 600,          # 10 min
+    "stuck_detection": 3600,        # 1 hour
+    "preemptive_routine": 7200,     # 2 hours
+}
+
+
+class ContextSnapshot:
+    """A single point-in-time system state snapshot."""
+
+    def __init__(
+        self,
+        active_app: str = "",
+        battery_pct: int = 100,
+        battery_charging: bool = True,
+        cpu_load: float = 0.0,
+        git_branch: str = "",
+        git_dirty: bool = False,
+        recent_commands: List[str] | None = None,
+        chrome_tabs: List[str] | None = None,
+        timestamp: float = 0.0,
+    ) -> None:
+        self.active_app = active_app
+        self.battery_pct = battery_pct
+        self.battery_charging = battery_charging
+        self.cpu_load = cpu_load
+        self.git_branch = git_branch
+        self.git_dirty = git_dirty
+        self.recent_commands = recent_commands or []
+        self.chrome_tabs = chrome_tabs or []
+        self.timestamp = timestamp or time.time()
+
+
+class ContextEngine:
+    """Polls system state, classifies context, evaluates triggers."""
+
+    def __init__(
+        self,
+        event_bus: EventBus,
+        target_chat_ids: List[int],
+        working_directory: str = "",
+        pattern_learner: Any = None,
+    ) -> None:
+        self.event_bus = event_bus
+        self.target_chat_ids = target_chat_ids
+        self.working_directory = working_directory
+        self._pattern_learner = pattern_learner
+
+        self._running = False
+        self._enabled = True  # Always-on when engine is started
+        self._task: Optional[asyncio.Task[None]] = None
+
+        # State tracking
+        self._current_state = ContextState.AWAY
+        self._state_start_time: float = time.time()
+        self._history: Deque[ContextSnapshot] = deque(maxlen=12)  # 1 hour
+        self._api_calls_this_hour: int = 0
+        self._hour_reset_time: float = time.time()
+
+        # Trigger cooldowns
+        self._last_trigger_times: Dict[str, float] = {}
+
+        # State transition tracking for triggers
+        self._app_switch_times: List[float] = []
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled
+
+    @property
+    def current_state(self) -> ContextState:
+        return self._current_state
+
+    @property
+    def state_duration_min(self) -> int:
+        return int((time.time() - self._state_start_time) / 60)
+
+    def toggle(self) -> bool:
+        """Toggle context engine. Returns new state."""
+        self._enabled = not self._enabled
+        if self._enabled:
+            logger.info("Jarvis context engine enabled")
+        else:
+            logger.info("Jarvis context engine disabled")
+        return self._enabled
+
+    def set_enabled(self, state: bool) -> None:
+        self._enabled = state
+
+    async def start(self) -> None:
+        """Start the polling loop."""
+        if self._running:
+            return
+        self._running = True
+        self._task = asyncio.create_task(self._poll_loop())
+        logger.info("Context engine started (active)")
+
+    async def stop(self) -> None:
+        """Stop the polling loop."""
+        if not self._running:
+            return
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+        logger.info("Context engine stopped")
+
+    async def _poll_loop(self) -> None:
+        """Main polling loop."""
+        while self._running:
+            try:
+                if self._enabled:
+                    await self._tick()
+                await asyncio.sleep(POLL_INTERVAL)
+            except asyncio.CancelledError:
+                break
+            except Exception:
+                logger.exception("Context engine poll error")
+                await asyncio.sleep(POLL_INTERVAL * 2)
+
+    async def _tick(self) -> None:
+        """Single poll cycle: collect -> detect state -> evaluate triggers."""
+        # Reset hourly API counter
+        now = time.time()
+        if now - self._hour_reset_time >= 3600:
+            self._api_calls_this_hour = 0
+            self._hour_reset_time = now
+
+        snap = await self._collect_snapshot()
+        self._history.append(snap)
+
+        new_state = self._detect_state(snap)
+
+        # Track state transitions
+        if new_state != self._current_state:
+            self._app_switch_times.append(now)
+            # Clean old switch times (keep last 10 min)
+            self._app_switch_times = [
+                t for t in self._app_switch_times if now - t < 600
+            ]
+            prev_state = self._current_state
+            self._current_state = new_state
+            self._state_start_time = now
+            logger.info(
+                "State transition",
+                from_state=prev_state.value,
+                to_state=new_state.value,
+                app=snap.active_app,
+            )
+
+        # Evaluate triggers
+        triggers = self._evaluate_triggers(snap)
+        for trigger_id, prompt in triggers:
+            if self._api_calls_this_hour >= MAX_API_CALLS_PER_HOUR:
+                logger.warning("Jarvis hourly API limit reached, skipping trigger")
+                break
+
+            # Add persona prefix
+            from datetime import datetime
+
+            hour = datetime.now().hour
+            prefix = PersonaLayer.build_prompt_prefix(
+                self._current_state, hour, self.state_duration_min
+            )
+            full_prompt = f"{prefix}\n\n{prompt}"
+
+            event = ScheduledEvent(
+                job_id=f"jarvis-{trigger_id}",
+                job_name=f"jarvis-{trigger_id}",
+                prompt=full_prompt,
+                working_directory=self.working_directory,
+                target_chat_ids=self.target_chat_ids,
+                source="jarvis",
+            )
+            await self.event_bus.publish(event)
+            self._api_calls_this_hour += 1
+            self._last_trigger_times[trigger_id] = now
+            logger.info("Jarvis trigger fired", trigger=trigger_id)
+
+    async def _collect_snapshot(self) -> ContextSnapshot:
+        """Collect system state via parallel subprocess calls."""
+        loop = asyncio.get_event_loop()
+
+        async def _run(cmd: List[str], timeout: int = 5) -> str:
+            try:
+                result = await loop.run_in_executor(
+                    None,
+                    lambda: subprocess.run(
+                        cmd, capture_output=True, text=True, timeout=timeout
+                    ),
+                )
+                return result.stdout.strip() if result.returncode == 0 else ""
+            except Exception:
+                return ""
+
+        # Run all collectors in parallel
+        results = await asyncio.gather(
+            _run([
+                "osascript", "-e",
+                'tell app "System Events" to get name of first process '
+                "whose frontmost is true",
+            ]),
+            _run(["pmset", "-g", "batt"]),
+            _run(["sysctl", "-n", "vm.loadavg"]),
+            _run([
+                "git", "-C", self.working_directory,
+                "branch", "--show-current",
+            ]),
+            _run([
+                "git", "-C", self.working_directory,
+                "status", "--short",
+            ]),
+            _run([
+                "osascript", "-e",
+                'tell application "Google Chrome" to get title of active tab '
+                "of front window",
+            ]),
+            return_exceptions=True,
+        )
+
+        # Parse results
+        active_app = results[0] if isinstance(results[0], str) else ""
+
+        battery_pct = 100
+        battery_charging = True
+        batt_str = results[1] if isinstance(results[1], str) else ""
+        batt_match = re.search(r"(\d+)%", batt_str)
+        if batt_match:
+            battery_pct = int(batt_match.group(1))
+        battery_charging = "charging" in batt_str.lower() or "charged" in batt_str.lower()
+
+        cpu_load = 0.0
+        load_str = results[2] if isinstance(results[2], str) else ""
+        load_match = re.search(r"[\d.]+", load_str)
+        if load_match:
+            try:
+                cpu_load = float(load_match.group())
+            except ValueError:
+                pass
+
+        git_branch = results[3] if isinstance(results[3], str) else ""
+        git_dirty = bool(results[4]) if isinstance(results[4], str) else False
+
+        chrome_tab = results[5] if isinstance(results[5], str) else ""
+        chrome_tabs = [chrome_tab] if chrome_tab else []
+
+        return ContextSnapshot(
+            active_app=active_app,
+            battery_pct=battery_pct,
+            battery_charging=battery_charging,
+            cpu_load=cpu_load,
+            git_branch=git_branch,
+            git_dirty=git_dirty,
+            chrome_tabs=chrome_tabs,
+        )
+
+    def _detect_state(self, snap: ContextSnapshot) -> ContextState:
+        """Classify current state from snapshot."""
+        app_lower = snap.active_app.lower()
+
+        # Check app-based state
+        for app_key, state in _APP_STATE_MAP.items():
+            if app_key in app_lower:
+                # Promote to DEEP_WORK if same coding app for 2+ hours
+                if (
+                    state == ContextState.CODING
+                    and self._current_state == ContextState.CODING
+                    and self.state_duration_min >= 120
+                ):
+                    return ContextState.DEEP_WORK
+                return state
+
+        # No active app or unknown -> check if AWAY
+        if not app_lower or app_lower in ("loginwindow", "screensaver"):
+            return ContextState.AWAY
+
+        # Default: keep current state
+        return self._current_state
+
+    def _evaluate_triggers(
+        self, snap: ContextSnapshot
+    ) -> List[Tuple[str, str]]:
+        """Evaluate trigger rules against current snapshot.
+
+        Returns list of (trigger_id, prompt) for triggers that should fire.
+        DEEP_WORK state only allows battery + meeting triggers.
+        """
+        now = time.time()
+        triggers: List[Tuple[str, str]] = []
+
+        def _cooled(trigger_id: str) -> bool:
+            last = self._last_trigger_times.get(trigger_id, 0)
+            cooldown = _TRIGGER_COOLDOWNS.get(trigger_id, 600)
+            return (now - last) >= cooldown
+
+        is_deep = self._current_state == ContextState.DEEP_WORK
+
+        # 1. Battery warning (< 20%, not charging)
+        if (
+            snap.battery_pct < 20
+            and not snap.battery_charging
+            and _cooled("battery_warning")
+        ):
+            triggers.append((
+                "battery_warning",
+                f"배터리가 {snap.battery_pct}%입니다. "
+                f"충전기를 연결하거나 작업을 저장하세요.",
+            ))
+
+        # 2. Meeting prep (check via calendar — simplified: just notify)
+        # This would ideally check Google Calendar MCP, but for now
+        # we skip this trigger (calendar-check job already handles it)
+
+        # Deep work gate: remaining triggers are suppressed
+        if is_deep:
+            return triggers
+
+        # 3. Return from AWAY
+        if (
+            len(self._history) >= 2
+            and self._history[-2].active_app.lower() in ("loginwindow", "screensaver", "")
+            and snap.active_app
+            and snap.active_app.lower() not in ("loginwindow", "screensaver", "")
+            and _cooled("return_from_away")
+        ):
+            triggers.append((
+                "return_from_away",
+                f"돌아오셨네요. "
+                f"마지막 작업: {snap.git_branch or '알 수 없음'} 브랜치"
+                f"{' (변경사항 있음)' if snap.git_dirty else ''}",
+            ))
+
+        # 4. Long coding session (3+ hours)
+        if (
+            self._current_state in (ContextState.CODING, ContextState.DEEP_WORK)
+            and self.state_duration_min >= 180
+            and _cooled("long_coding_session")
+        ):
+            triggers.append((
+                "long_coding_session",
+                f"{self.state_duration_min}분째 코딩 중입니다. "
+                f"잠깐 쉬어가시죠. 스트레칭이나 물 한잔 어떠세요?",
+            ))
+
+        # 5. Context switch overload (5+ switches in 10 min)
+        recent_switches = [
+            t for t in self._app_switch_times if now - t < 600
+        ]
+        if len(recent_switches) >= 5 and _cooled("context_switch_overload"):
+            triggers.append((
+                "context_switch_overload",
+                f"최근 10분간 앱 전환이 {len(recent_switches)}회입니다. "
+                f"컨텍스트 전환이 잦으면 집중이 어렵습니다. "
+                f"하나의 작업에 집중해보시겠어요?",
+            ))
+
+        # 6. Terminal error detection (check recent commands for error patterns)
+        for cmd in snap.recent_commands[-3:]:
+            if re.search(r"(error|fail|panic|traceback)", cmd, re.I):
+                if _cooled("terminal_error"):
+                    triggers.append((
+                        "terminal_error",
+                        f"터미널에서 에러가 감지되었습니다: {cmd[:200]}. "
+                        f"도움이 필요하신가요?",
+                    ))
+                break
+
+        # 7. Stuck detection (same branch, dirty, 30+ min in CODING)
+        if (
+            self._current_state == ContextState.CODING
+            and self.state_duration_min >= 30
+            and snap.git_dirty
+            and _cooled("stuck_detection")
+        ):
+            # Check if git status hasn't changed (still dirty, same branch)
+            if len(self._history) >= 6:
+                old_snap = self._history[-6]
+                if (
+                    old_snap.git_branch == snap.git_branch
+                    and old_snap.git_dirty
+                ):
+                    triggers.append((
+                        "stuck_detection",
+                        f"30분 이상 같은 브랜치({snap.git_branch})에서 "
+                        f"커밋 없이 작업 중입니다. 막히신 부분이 있나요?",
+                    ))
+
+        # 8. Preemptive routine (learned pattern)
+        if self._pattern_learner and _cooled("preemptive_routine"):
+            from datetime import datetime as _dt
+
+            routine = self._pattern_learner.check_preemptive(
+                self._current_state, _dt.now().hour
+            )
+            if routine:
+                rtype = routine.get("request_type", "")
+                triggers.append((
+                    "preemptive_routine",
+                    f"이 시간대에 보통 '{rtype}' 유형의 작업을 하시더라고요. "
+                    f"미리 준비할 게 있을까요?",
+                ))
+
+        return triggers