@purpleraven/hits 0.2.0

package/hits_core/collector/__init__.py

@@ -0,0 +1,18 @@
+"""Work log collectors for various sources."""
+
+from .base import BaseCollector, CollectorEvent
+from .git_collector import GitCollector
+from .shell_collector import ShellCollector
+from .hits_action_collector import HitsActionCollector
+from .ai_session_collector import AISessionCollector
+from .daemon import CollectorDaemon
+
+__all__ = [
+    "BaseCollector",
+    "CollectorEvent",
+    "GitCollector",
+    "ShellCollector",
+    "HitsActionCollector",
+    "AISessionCollector",
+    "CollectorDaemon",
+]

package/hits_core/collector/ai_session_collector.py

@@ -0,0 +1,118 @@
+"""AI session collector - monitors AI interaction sessions."""
+
+import asyncio
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Callable
+import getpass
+
+from .base import BaseCollector, CollectorEvent
+from ..models.work_log import WorkLogSource, WorkLogResultType
+
+
+class AISessionCollector(BaseCollector):
+    SESSION_DIR = Path.home() / ".hits" / "sessions"
+    
+    def __init__(
+        self,
+        callback: Optional[Callable[[CollectorEvent], None]] = None,
+        poll_interval: int = 30,
+    ):
+        super().__init__(callback)
+        self.poll_interval = poll_interval
+        self._task: Optional[asyncio.Task] = None
+        self._username = getpass.getuser()
+        self._processed_files: set[str] = set()
+    
+    @property
+    def source(self) -> WorkLogSource:
+        return WorkLogSource.AI_SESSION
+    
+    @classmethod
+    def get_session_file(cls, session_id: str) -> Path:
+        cls.SESSION_DIR.mkdir(parents=True, exist_ok=True)
+        return cls.SESSION_DIR / f"{session_id}.json"
+    
+    @classmethod
+    def write_session_summary(
+        cls,
+        session_id: str,
+        ai_type: str,
+        prompt: str,
+        summary: str,
+        files_modified: Optional[list[str]] = None,
+        commands_run: Optional[list[str]] = None,
+    ) -> None:
+        data = {
+            "session_id": session_id,
+            "ai_type": ai_type,
+            "prompt": prompt,
+            "summary": summary,
+            "files_modified": files_modified or [],
+            "commands_run": commands_run or [],
+            "timestamp": datetime.now().isoformat(),
+        }
+        
+        path = cls.get_session_file(session_id)
+        cls.SESSION_DIR.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+    
+    async def collect(self) -> list[CollectorEvent]:
+        events = []
+        
+        if not self.SESSION_DIR.exists():
+            return events
+        
+        for session_file in self.SESSION_DIR.glob("*.json"):
+            if str(session_file) in self._processed_files:
+                continue
+            
+            try:
+                with open(session_file, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                
+                event = CollectorEvent(
+                    source=self.source,
+                    performed_by=f"{data.get('ai_type', 'unknown')} ({self._username})",
+                    performed_at=datetime.fromisoformat(data["timestamp"]),
+                    request_text=data.get("prompt", "")[:200],
+                    context=data.get("summary", "")[:500],
+                    result_type=WorkLogResultType.AI_RESPONSE,
+                    result_ref=data.get("session_id", "")[:20],
+                    result_data={
+                        "files_modified": data.get("files_modified", []),
+                        "commands_run": data.get("commands_run", []),
+                    },
+                    tags=[data.get("ai_type", "ai")],
+                )
+                events.append(event)
+                self._emit(event)
+                self._processed_files.add(str(session_file))
+            except Exception:
+                pass
+        
+        return events
+    
+    async def start(self) -> None:
+        self._running = True
+        self._task = asyncio.create_task(self._poll_loop())
+    
+    async def stop(self) -> None:
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            self._task = None
+    
+    async def _poll_loop(self) -> None:
+        while self._running:
+            try:
+                await self.collect()
+            except Exception:
+                pass
+            await asyncio.sleep(self.poll_interval)

package/hits_core/collector/base.py

@@ -0,0 +1,73 @@
+"""Base collector interface and common utilities."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional, Callable, Any
+import uuid
+
+from ..models.work_log import WorkLog, WorkLogSource
+
+
+@dataclass
+class CollectorEvent:
+    source: WorkLogSource
+    performed_by: str
+    performed_at: datetime
+    request_text: Optional[str] = None
+    result_type: str = "none"
+    result_ref: Optional[str] = None
+    result_data: Optional[dict] = None
+    context: Optional[str] = None
+    tags: Optional[list[str]] = None
+    project_path: Optional[str] = None
+    node_id: Optional[str] = None
+    category: Optional[str] = None
+    
+    def to_work_log(self) -> WorkLog:
+        return WorkLog(
+            id=str(uuid.uuid4()),
+            source=self.source,
+            request_text=self.request_text,
+            request_by=None,
+            performed_by=self.performed_by,
+            performed_at=self.performed_at,
+            result_type=self.result_type,
+            result_ref=self.result_ref,
+            result_data=self.result_data,
+            context=self.context,
+            tags=self.tags or [],
+            project_path=self.project_path,
+            node_id=self.node_id,
+            category=self.category,
+        )
+
+
+class BaseCollector(ABC):
+    def __init__(self, callback: Optional[Callable[[CollectorEvent], None]] = None):
+        self.callback = callback
+        self._running = False
+    
+    @property
+    @abstractmethod
+    def source(self) -> WorkLogSource:
+        pass
+    
+    @abstractmethod
+    async def collect(self) -> list[CollectorEvent]:
+        pass
+    
+    @abstractmethod
+    async def start(self) -> None:
+        pass
+    
+    @abstractmethod
+    async def stop(self) -> None:
+        pass
+    
+    def _emit(self, event: CollectorEvent) -> None:
+        if self.callback:
+            self.callback(event)
+    
+    def is_running(self) -> bool:
+        return self._running

package/hits_core/collector/daemon.py

@@ -0,0 +1,94 @@
+"""Collector daemon - manages all collectors and stores events."""
+
+import asyncio
+from typing import Optional, Callable, Any
+from pathlib import Path
+
+from .base import BaseCollector, CollectorEvent
+from .git_collector import GitCollector
+from .shell_collector import ShellCollector
+from .hits_action_collector import HitsActionCollector
+from .ai_session_collector import AISessionCollector
+from ..storage.base import BaseStorage
+from ..storage.file_store import FileStorage
+
+
+class CollectorDaemon:
+    def __init__(
+        self,
+        storage: Optional[BaseStorage] = None,
+        project_paths: Optional[list[str]] = None,
+        on_event: Optional[Callable[[CollectorEvent], None]] = None,
+    ):
+        self.storage = storage or FileStorage()
+        self.project_paths = project_paths or []
+        self.on_event = on_event
+        
+        self._collectors: list[BaseCollector] = []
+        self._hits_collector: Optional[HitsActionCollector] = None
+        self._running = False
+    
+    def _handle_event(self, event: CollectorEvent) -> None:
+        asyncio.create_task(self._save_event(event))
+        
+        if self.on_event:
+            self.on_event(event)
+    
+    async def _save_event(self, event: CollectorEvent) -> None:
+        try:
+            work_log = event.to_work_log()
+            await self.storage.save_work_log(work_log)
+        except Exception:
+            pass
+    
+    def setup(self) -> None:
+        for path in self.project_paths:
+            if Path(path).exists():
+                git_collector = GitCollector(
+                    project_path=path,
+                    callback=self._handle_event,
+                )
+                self._collectors.append(git_collector)
+        
+        shell_collector = ShellCollector(callback=self._handle_event)
+        self._collectors.append(shell_collector)
+        
+        ai_collector = AISessionCollector(callback=self._handle_event)
+        self._collectors.append(ai_collector)
+        
+        self._hits_collector = HitsActionCollector(callback=self._handle_event)
+        self._collectors.append(self._hits_collector)
+    
+    async def start(self) -> None:
+        if self._running:
+            return
+        
+        self._running = True
+        
+        for collector in self._collectors:
+            try:
+                await collector.start()
+            except Exception:
+                pass
+    
+    async def stop(self) -> None:
+        self._running = False
+        
+        for collector in self._collectors:
+            try:
+                await collector.stop()
+            except Exception:
+                pass
+    
+    def get_hits_collector(self) -> Optional[HitsActionCollector]:
+        return self._hits_collector
+    
+    def is_running(self) -> bool:
+        return self._running
+    
+    def get_collector_stats(self) -> dict:
+        return {
+            "total_collectors": len(self._collectors),
+            "running_collectors": sum(1 for c in self._collectors if c.is_running()),
+            "collector_types": [c.__class__.__name__ for c in self._collectors],
+        }

package/hits_core/collector/git_collector.py

@@ -0,0 +1,177 @@
+"""Git commit collector."""
+
+import asyncio
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Callable
+
+from .base import BaseCollector, CollectorEvent
+from ..models.work_log import WorkLogSource, WorkLogResultType
+
+
+class GitCollector(BaseCollector):
+    def __init__(
+        self,
+        project_path: str,
+        callback: Optional[Callable[[CollectorEvent], None]] = None,
+        poll_interval: int = 300,
+    ):
+        super().__init__(callback)
+        self.project_path = Path(project_path)
+        self.poll_interval = poll_interval
+        self._last_commit_hash: Optional[str] = None
+        self._task: Optional[asyncio.Task] = None
+    
+    @property
+    def source(self) -> WorkLogSource:
+        return WorkLogSource.GIT
+    
+    def _run_git(self, *args: str) -> Optional[str]:
+        try:
+            result = subprocess.run(
+                ["git"] + list(args),
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except Exception:
+            pass
+        return None
+    
+    def _get_current_user(self) -> str:
+        name = self._run_git("config", "user.name") or "unknown"
+        email = self._run_git("config", "user.email") or ""
+        if email:
+            return f"{name} <{email}>"
+        return name
+    
+    def _get_last_commit_hash(self) -> Optional[str]:
+        return self._run_git("rev-parse", "HEAD")
+    
+    def _parse_commits(self, since_hash: Optional[str] = None) -> list[dict]:
+        format_str = "%H|%an|%ae|%at|%s"
+        cmd = ["log", f"--format={format_str}"]
+        
+        if since_hash:
+            cmd.append(f"{since_hash}..HEAD")
+        else:
+            cmd.extend(["-n", "50"])
+        
+        output = self._run_git(*cmd)
+        if not output:
+            return []
+        
+        commits = []
+        for line in output.split("\n"):
+            if not line.strip():
+                continue
+            parts = line.split("|", 4)
+            if len(parts) == 5:
+                commits.append({
+                    "hash": parts[0],
+                    "author": parts[1],
+                    "email": parts[2],
+                    "timestamp": int(parts[3]),
+                    "message": parts[4],
+                })
+        return commits
+    
+    def _get_changed_files(self, commit_hash: str) -> list[str]:
+        output = self._run_git("diff-tree", "--no-commit-id", "--name-only", "-r", commit_hash)
+        if output:
+            return output.split("\n")
+        return []
+    
+    async def collect(self) -> list[CollectorEvent]:
+        events = []
+        
+        current_hash = self._get_last_commit_hash()
+        if not current_hash:
+            return events
+        
+        commits = self._parse_commits(self._last_commit_hash)
+        
+        for commit in commits:
+            files = self._get_changed_files(commit["hash"])
+            author = f"{commit['author']} <{commit['email']}>"
+            
+            event = CollectorEvent(
+                source=self.source,
+                performed_by=author,
+                performed_at=datetime.fromtimestamp(commit["timestamp"]),
+                request_text=commit["message"],
+                result_type=WorkLogResultType.COMMIT,
+                result_ref=commit["hash"][:8],
+                result_data={
+                    "full_hash": commit["hash"],
+                    "files": files[:20],
+                    "file_count": len(files),
+                },
+                tags=self._extract_tags(commit["message"], files),
+                project_path=str(self.project_path),
+            )
+            events.append(event)
+            self._emit(event)
+        
+        if commits:
+            self._last_commit_hash = current_hash
+        
+        return events
+    
+    def _extract_tags(self, message: str, files: list[str]) -> list[str]:
+        tags = []
+        
+        keywords = {
+            "fix": "bug",
+            "bug": "bug",
+            "feat": "feature",
+            "feature": "feature",
+            "add": "feature",
+            "refactor": "refactor",
+            "test": "test",
+            "doc": "docs",
+            "docs": "docs",
+            "style": "style",
+            "chore": "chore",
+            "perf": "performance",
+            "ci": "ci",
+        }
+        
+        msg_lower = message.lower()
+        for keyword, tag in keywords.items():
+            if keyword in msg_lower:
+                tags.append(tag)
+        
+        for file in files[:5]:
+            parts = file.split("/")
+            if len(parts) > 1:
+                tags.append(parts[0])
+        
+        return list(set(tags))[:5]
+    
+    async def start(self) -> None:
+        self._running = True
+        self._last_commit_hash = self._get_last_commit_hash()
+        self._task = asyncio.create_task(self._poll_loop())
+    
+    async def stop(self) -> None:
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            self._task = None
+    
+    async def _poll_loop(self) -> None:
+        while self._running:
+            try:
+                await self.collect()
+            except Exception:
+                pass
+            await asyncio.sleep(self.poll_interval)

package/hits_core/collector/hits_action_collector.py

@@ -0,0 +1,110 @@
+"""HITS internal action collector - records actions taken within HITS UI."""
+
+from datetime import datetime
+from typing import Optional, Callable, Any
+import getpass
+
+from .base import BaseCollector, CollectorEvent
+from ..models.work_log import WorkLogSource, WorkLogResultType
+
+
+class HitsActionCollector(BaseCollector):
+    def __init__(
+        self,
+        callback: Optional[Callable[[CollectorEvent], None]] = None,
+        username: Optional[str] = None,
+    ):
+        super().__init__(callback)
+        self._username = username or getpass.getuser()
+    
+    @property
+    def source(self) -> WorkLogSource:
+        return WorkLogSource.LINK_CLICK
+    
+    async def collect(self) -> list[CollectorEvent]:
+        return []
+    
+    async def start(self) -> None:
+        self._running = True
+    
+    async def stop(self) -> None:
+        self._running = False
+    
+    def record_link_click(
+        self,
+        url: str,
+        title: Optional[str] = None,
+        category: Optional[str] = None,
+        node_id: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+    ) -> CollectorEvent:
+        event = CollectorEvent(
+            source=WorkLogSource.LINK_CLICK,
+            performed_by=self._username,
+            performed_at=datetime.now(),
+            request_text=title,
+            result_type=WorkLogResultType.URL,
+            result_ref=url[:100],
+            result_data={"url": url, "title": title},
+            tags=tags or [],
+            category=category,
+            node_id=node_id,
+        )
+        self._emit(event)
+        return event
+    
+    def record_shell_exec(
+        self,
+        command: str,
+        category: Optional[str] = None,
+        node_id: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+    ) -> CollectorEvent:
+        event = CollectorEvent(
+            source=WorkLogSource.SHELL_EXEC,
+            performed_by=self._username,
+            performed_at=datetime.now(),
+            request_text=command[:200],
+            result_type=WorkLogResultType.COMMAND,
+            result_ref=command[:50],
+            result_data={"command": command},
+            tags=tags or [],
+            category=category,
+            node_id=node_id,
+        )
+        self._emit(event)
+        return event
+    
+    def record_manual_entry(
+        self,
+        text: str,
+        context: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+    ) -> CollectorEvent:
+        event = CollectorEvent(
+            source=WorkLogSource.MANUAL,
+            performed_by=self._username,
+            performed_at=datetime.now(),
+            request_text=text,
+            context=context,
+            tags=tags or [],
+        )
+        self._emit(event)
+        return event
+    
+    def record_navigation(
+        self,
+        from_view: str,
+        to_view: str,
+        query: Optional[str] = None,
+    ) -> CollectorEvent:
+        event = CollectorEvent(
+            source=WorkLogSource.MANUAL,
+            performed_by=self._username,
+            performed_at=datetime.now(),
+            request_text=f"Navigate: {from_view} → {to_view}",
+            result_data={"from": from_view, "to": to_view, "query": query},
+            tags=["navigation"],
+        )
+        self._emit(event)
+        return event