@purpleraven/hits 0.2.0

package/hits_core/collector/shell_collector.py

@@ -0,0 +1,178 @@
+"""Shell history collector."""
+
+import asyncio
+import os
+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 ShellCollector(BaseCollector):
+    HISTORY_FILES = {
+        "bash": ".bash_history",
+        "zsh": ".zhistfile",
+        "fish": ".local/share/fish/fish_history",
+    }
+    
+    DEFAULT_IGNORE_PATTERNS = [
+        "ls", "cd", "pwd", "echo", "cat", "clear",
+        "exit", "history", "which", "type",
+    ]
+    
+    def __init__(
+        self,
+        callback: Optional[Callable[[CollectorEvent], None]] = None,
+        poll_interval: int = 60,
+        shell: str = "bash",
+        ignore_patterns: Optional[list[str]] = None,
+    ):
+        super().__init__(callback)
+        self.poll_interval = poll_interval
+        self.shell = shell
+        self.ignore_patterns = ignore_patterns or self.DEFAULT_IGNORE_PATTERNS
+        self._last_position: int = 0
+        self._task: Optional[asyncio.Task] = None
+        self._username = getpass.getuser()
+    
+    @property
+    def source(self) -> WorkLogSource:
+        return WorkLogSource.SHELL
+    
+    def _get_history_path(self) -> Optional[Path]:
+        home = Path.home()
+        
+        if self.shell == "bash":
+            histfile = os.environ.get("HISTFILE", str(home / ".bash_history"))
+        elif self.shell == "zsh":
+            histfile = os.environ.get("HISTFILE", str(home / ".zsh_history"))
+        elif self.shell == "fish":
+            histfile = str(home / ".local/share/fish/fish_history")
+        else:
+            return None
+        
+        path = Path(histfile)
+        return path if path.exists() else None
+    
+    def _should_ignore(self, command: str) -> bool:
+        cmd_first = command.strip().split()[0] if command.strip() else ""
+        return cmd_first in self.ignore_patterns
+    
+    def _parse_command(self, line: str) -> Optional[dict]:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            return None
+        
+        if self.shell == "zsh" and line.startswith(":"):
+            parts = line.split(";", 1)
+            if len(parts) == 2:
+                return {"command": parts[1].strip(), "raw": line}
+        
+        return {"command": line, "raw": line}
+    
+    async def collect(self) -> list[CollectorEvent]:
+        events = []
+        
+        history_path = self._get_history_path()
+        if not history_path:
+            return events
+        
+        try:
+            with open(history_path, "r", encoding="utf-8", errors="ignore") as f:
+                f.seek(self._last_position)
+                new_lines = f.readlines()
+                self._last_position = f.tell()
+        except Exception:
+            return events
+        
+        now = datetime.now()
+        
+        for line in new_lines:
+            parsed = self._parse_command(line)
+            if not parsed:
+                continue
+            
+            command = parsed["command"]
+            if self._should_ignore(command):
+                continue
+            
+            event = CollectorEvent(
+                source=self.source,
+                performed_by=self._username,
+                performed_at=now,
+                request_text=command[:200],
+                result_type=WorkLogResultType.COMMAND,
+                result_ref=command[:50],
+                result_data={"raw": parsed["raw"]},
+                tags=self._extract_tags(command),
+            )
+            events.append(event)
+            self._emit(event)
+        
+        return events
+    
+    def _extract_tags(self, command: str) -> list[str]:
+        tags = []
+        
+        tool_tags = {
+            "git": "git",
+            "docker": "docker",
+            "kubectl": "kubernetes",
+            "npm": "npm",
+            "yarn": "npm",
+            "pip": "python",
+            "python": "python",
+            "pytest": "test",
+            "mvn": "java",
+            "gradle": "java",
+            "cargo": "rust",
+            "go": "go",
+            "make": "build",
+            "ssh": "ssh",
+            "scp": "ssh",
+            "rsync": "sync",
+            "curl": "http",
+            "wget": "http",
+        }
+        
+        cmd_lower = command.lower()
+        for tool, tag in tool_tags.items():
+            if cmd_lower.startswith(tool + " ") or cmd_lower.startswith(tool + "\t"):
+                tags.append(tag)
+                break
+        
+        return tags
+    
+    async def start(self) -> None:
+        self._running = True
+        history_path = self._get_history_path()
+        if history_path:
+            try:
+                with open(history_path, "r") as f:
+                    f.seek(0, 2)
+                    self._last_position = f.tell()
+            except Exception:
+                pass
+        
+        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/main.py

@@ -0,0 +1,36 @@
+"""HITS web server entry point.
+
+Usage:
+    python -m hits_core.main [--port PORT] [--dev]
+"""
+
+import argparse
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser(description="HITS Web Server")
+    parser.add_argument("--port", type=int, default=8765, help="Server port (default: 8765)")
+    parser.add_argument("--dev", action="store_true", help="Development mode")
+    args = parser.parse_args()
+
+    import uvicorn
+    from hits_core.api.server import APIServer
+
+    server = APIServer(port=args.port, dev_mode=args.dev)
+    app = server.create_app()
+
+    print(f"HITS Web Server starting on http://127.0.0.1:{args.port}")
+    if args.dev:
+        print("Development mode: CSP relaxed, CORS enabled for Vite")
+
+    uvicorn.run(
+        app,
+        host="127.0.0.1",
+        port=args.port,
+        log_level="info" if args.dev else "warning",
+    )
+
+
+if __name__ == "__main__":
+    main()

package/hits_core/mcp/__init__.py

@@ -0,0 +1,20 @@
+"""HITS MCP Server - Model Context Protocol interface.
+
+Enables AI tools (Claude, OpenCode, Cursor, etc.) to interact with HITS
+directly through MCP, without needing the HTTP API server running.
+
+Usage in opencode.json or Claude MCP config:
+  {
+    "hits": {
+      "type": "local",
+      "command": ["python", "-m", "hits_core.mcp.server"]
+    }
+  }
+
+Tools provided:
+  - hits_record_work: Record a work log for the current project
+  - hits_get_handover: Get handover summary for a project
+  - hits_search_works: Search previous work logs
+  - hits_list_projects: List all projects with activity
+  - hits_get_recent: Get recent work logs for a project
+"""

package/hits_core/mcp/server.py

@@ -0,0 +1,429 @@
+"""HITS MCP Server implementation using stdio transport.
+
+This module provides a standalone MCP server that exposes HITS functionality
+as MCP tools. It auto-detects the current project from CWD.
+
+Run with: python -m hits_core.mcp.server
+"""
+
+import asyncio
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional
+from uuid import uuid4
+
+# Ensure project root is in path
+_project_root = str(Path(__file__).parent.parent.parent)
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+from hits_core.storage.file_store import FileStorage
+from hits_core.models.work_log import WorkLog, WorkLogSource, WorkLogResultType
+from hits_core.service.handover_service import HandoverService
+
+
+def _detect_project_path() -> str:
+    """Auto-detect project path from CWD, walking up to find git root."""
+    cwd = Path.cwd().resolve()
+    current = cwd
+
+    for _ in range(10):  # Max 10 levels up
+        if (current / ".git").exists():
+            return str(current)
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+
+    return str(cwd)
+
+
+def _json_rpc_response(id_val: Any, result: dict = None, error: dict = None) -> str:
+    """Build a JSON-RPC 2.0 response."""
+    resp = {"jsonrpc": "2.0", "id": id_val}
+    if error:
+        resp["error"] = error
+    else:
+        resp["result"] = result or {}
+    return json.dumps(resp, ensure_ascii=False)
+
+
+def _tool_result(text: str) -> list[dict]:
+    """Build MCP tool result content."""
+    return [{"type": "text", "text": text}]
+
+
+class HITSMCPServer:
+    """MCP Server for HITS - runs over stdio."""
+
+    TOOLS = [
+        {
+            "name": "hits_record_work",
+            "description": (
+                "Record a work log for the current project. "
+                "Call this when ending a session or completing a task. "
+                "The project_path is auto-detected from CWD but can be overridden."
+            ),
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "request_text": {
+                        "type": "string",
+                        "description": "Summary of what was done (1-2 sentences)",
+                    },
+                    "context": {
+                        "type": "string",
+                        "description": "Detailed context, decisions made, important notes",
+                    },
+                    "performed_by": {
+                        "type": "string",
+                        "description": "AI tool name: 'claude', 'opencode', 'cursor', etc.",
+                    },
+                    "tags": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Tags: ['feature', 'bugfix', 'refactor', etc.]",
+                    },
+                    "files_modified": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of files that were modified",
+                    },
+                    "commands_run": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Commands that were run",
+                    },
+                    "project_path": {
+                        "type": "string",
+                        "description": "Override auto-detected project path",
+                    },
+                },
+                "required": ["request_text", "performed_by"],
+            },
+        },
+        {
+            "name": "hits_get_handover",
+            "description": (
+                "Get a handover summary for a project. "
+                "Call this when starting a new session to understand what "
+                "previous AI sessions (Claude, OpenCode, etc.) have done. "
+                "Returns project-scoped context including recent work, key decisions, "
+                "pending items, files modified, and session history."
+            ),
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "project_path": {
+                        "type": "string",
+                        "description": "Project path (default: auto-detect from CWD)",
+                    },
+                    "format": {
+                        "type": "string",
+                        "enum": ["text", "dict"],
+                        "description": "Output format (default: 'text')",
+                    },
+                },
+            },
+        },
+        {
+            "name": "hits_search_works",
+            "description": (
+                "Search previous work logs by keyword, scoped to a project. "
+                "Use this to find specific past work or decisions."
+            ),
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search keyword",
+                    },
+                    "project_path": {
+                        "type": "string",
+                        "description": "Scope to project (default: auto-detect from CWD)",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Max results (default: 10)",
+                    },
+                },
+                "required": ["query"],
+            },
+        },
+        {
+            "name": "hits_list_projects",
+            "description": (
+                "List all projects that have recorded work logs. "
+                "Use this to discover which projects have accumulated context."
+            ),
+            "inputSchema": {
+                "type": "object",
+                "properties": {},
+            },
+        },
+        {
+            "name": "hits_get_recent",
+            "description": (
+                "Get recent work logs for a project. "
+                "Lighter than full handover - returns raw log entries."
+            ),
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "project_path": {
+                        "type": "string",
+                        "description": "Project path (default: auto-detect from CWD)",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Number of recent logs (default: 10)",
+                    },
+                    "performed_by": {
+                        "type": "string",
+                        "description": "Filter by AI tool name",
+                    },
+                },
+            },
+        },
+    ]
+
+    SERVER_INFO = {
+        "name": "hits-mcp",
+        "version": "0.1.0",
+    }
+
+    CAPABILITIES = {
+        "tools": {"listChanged": False},
+    }
+
+    def __init__(self, data_path: Optional[str] = None):
+        # Use centralized ~/.hits/data/ by default (same as FileStorage)
+        self.storage = FileStorage(base_path=data_path)
+        self.handover_service = HandoverService(storage=self.storage)
+
+    async def handle_initialize(self, params: dict, id_val: Any) -> str:
+        result = {
+            "protocolVersion": "2024-11-05",
+            "capabilities": self.CAPABILITIES,
+            "serverInfo": self.SERVER_INFO,
+        }
+        return _json_rpc_response(id_val, result=result)
+
+    async def handle_tools_list(self, params: dict, id_val: Any) -> str:
+        return _json_rpc_response(id_val, result={"tools": self.TOOLS})
+
+    async def handle_tools_call(self, params: dict, id_val: Any) -> str:
+        tool_name = params.get("name", "")
+        arguments = params.get("arguments", {})
+
+        try:
+            if tool_name == "hits_record_work":
+                result = await self._tool_record_work(arguments)
+            elif tool_name == "hits_get_handover":
+                result = await self._tool_get_handover(arguments)
+            elif tool_name == "hits_search_works":
+                result = await self._tool_search_works(arguments)
+            elif tool_name == "hits_list_projects":
+                result = await self._tool_list_projects(arguments)
+            elif tool_name == "hits_get_recent":
+                result = await self._tool_get_recent(arguments)
+            else:
+                return _json_rpc_response(
+                    id_val,
+                    error={"code": -32601, "message": f"Unknown tool: {tool_name}"},
+                )
+
+            return _json_rpc_response(
+                id_val,
+                result={"content": result},
+            )
+
+        except Exception as e:
+            return _json_rpc_response(
+                id_val,
+                result={
+                    "content": _tool_result(f"Error: {str(e)}"),
+                    "isError": True,
+                },
+            )
+
+    async def _tool_record_work(self, args: dict) -> list[dict]:
+        project_path = args.get("project_path") or _detect_project_path()
+        performed_by = args.get("performed_by", "unknown")
+
+        log = WorkLog(
+            id=str(uuid4())[:8],
+            source=WorkLogSource.AI_SESSION,
+            performed_by=performed_by,
+            request_text=args.get("request_text"),
+            context=args.get("context"),
+            tags=args.get("tags", []),
+            project_path=str(Path(project_path).resolve()),
+            result_type=WorkLogResultType.AI_RESPONSE,
+            result_data={
+                "files_modified": args.get("files_modified", []),
+                "commands_run": args.get("commands_run", []),
+            },
+        )
+
+        success = await self.storage.save_work_log(log)
+
+        if success:
+            return _tool_result(
+                f"✅ 작업 기록 완료\n"
+                f"  ID: {log.id}\n"
+                f"  프로젝트: {project_path}\n"
+                f"  수행자: {performed_by}\n"
+                f"  요약: {log.request_text}"
+            )
+        else:
+            return _tool_result("❌ 작업 기록 실패")
+
+    async def _tool_get_handover(self, args: dict) -> list[dict]:
+        project_path = args.get("project_path") or _detect_project_path()
+        project_path = str(Path(project_path).resolve())
+        fmt = args.get("format", "text")
+
+        summary = await self.handover_service.get_handover(project_path)
+
+        if fmt == "text":
+            return _tool_result(summary.to_text())
+        else:
+            return _tool_result(json.dumps(summary.to_dict(), indent=2, ensure_ascii=False))
+
+    async def _tool_search_works(self, args: dict) -> list[dict]:
+        query = args.get("query", "")
+        project_path = args.get("project_path") or _detect_project_path()
+        project_path = str(Path(project_path).resolve())
+        limit = args.get("limit", 10)
+
+        logs = await self.storage.search_work_logs(
+            query=query,
+            project_path=project_path,
+            limit=limit,
+        )
+
+        if not logs:
+            return _tool_result(f"검색 결과 없음: '{query}' (프로젝트: {project_path})")
+
+        lines = [f"검색 결과: '{query}' ({len(logs)}건)\n"]
+        for log in logs:
+            ts = log.performed_at.strftime("%Y-%m-%d %H:%M")
+            lines.append(f"[{ts}] ({log.performed_by}) {log.request_text or log.context}")
+            if log.tags:
+                lines.append(f"  tags: {', '.join(log.tags)}")
+
+        return _tool_result("\n".join(lines))
+
+    async def _tool_list_projects(self, args: dict) -> list[dict]:
+        projects = await self.handover_service.list_projects()
+
+        if not projects:
+            return _tool_result("기록된 프로젝트가 없습니다.")
+
+        lines = [f"프로젝트 목록 ({len(projects)}개)\n"]
+        for p in projects:
+            name = Path(p["project_path"]).name
+            logs = p.get("total_logs", 0)
+            last = p.get("last_activity", "N/A")
+            performers = ", ".join(p.get("performers", {}).keys())
+            lines.append(f"  {name}: {logs}건 (마지막: {last}) [{performers}]")
+
+        return _tool_result("\n".join(lines))
+
+    async def _tool_get_recent(self, args: dict) -> list[dict]:
+        project_path = args.get("project_path") or _detect_project_path()
+        project_path = str(Path(project_path).resolve())
+        limit = args.get("limit", 10)
+        performed_by = args.get("performed_by")
+
+        logs = await self.storage.list_work_logs(
+            project_path=project_path,
+            performed_by=performed_by,
+            limit=limit,
+        )
+
+        if not logs:
+            return _tool_result(f"최근 작업 없음 (프로젝트: {project_path})")
+
+        lines = [f"최근 작업 ({len(logs)}건)\n"]
+        for log in logs:
+            ts = log.performed_at.strftime("%m/%d %H:%M")
+            lines.append(f"[{ts}] ({log.performed_by}) {log.request_text or log.context}")
+
+        return _tool_result("\n".join(lines))
+
+    async def handle_request(self, request: dict) -> Optional[str]:
+        """Handle a single JSON-RPC request."""
+        method = request.get("method", "")
+        id_val = request.get("id")
+        params = request.get("params", {})
+
+        if method == "initialize":
+            return await self.handle_initialize(params, id_val)
+        elif method == "notifications/initialized":
+            # Client acknowledges initialization - no response needed
+            return None
+        elif method == "tools/list":
+            return await self.handle_tools_list(params, id_val)
+        elif method == "tools/call":
+            return await self.handle_tools_call(params, id_val)
+        elif method == "ping":
+            return _json_rpc_response(id_val, result={})
+        else:
+            return _json_rpc_response(
+                id_val,
+                error={"code": -32601, "message": f"Method not found: {method}"},
+            )
+
+    async def run(self):
+        """Run the MCP server over stdio."""
+        reader = asyncio.StreamReader()
+        protocol = asyncio.StreamReaderProtocol(reader)
+        await asyncio.get_event_loop().connect_read_pipe(
+            lambda: protocol, sys.stdin
+        )
+
+        writer_transport, writer_protocol = await asyncio.get_event_loop().connect_write_pipe(
+            asyncio.streams.FlowControlMixin, sys.stdout
+        )
+        writer = asyncio.StreamWriter(writer_transport, writer_protocol, reader, asyncio.get_event_loop())
+
+        while True:
+            try:
+                line = await reader.readline()
+                if not line:
+                    break
+
+                line = line.decode("utf-8").strip()
+                if not line:
+                    continue
+
+                try:
+                    request = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+
+                response = await self.handle_request(request)
+                if response is not None:
+                    writer.write((response + "\n").encode("utf-8"))
+                    await writer.drain()
+
+            except Exception:
+                break
+
+
+def main():
+    """Entry point for running as MCP server."""
+    # HITS_DATA_PATH env var can override, otherwise uses ~/.hits/data/
+    data_path = os.environ.get("HITS_DATA_PATH")
+    server = HITSMCPServer(data_path=data_path)
+    asyncio.run(server.run())
+
+
+if __name__ == "__main__":
+    main()

package/hits_core/models/__init__.py

@@ -0,0 +1,18 @@
+"""Data models for knowledge tree structure."""
+
+from .tree import KnowledgeTree
+from .node import Node, NodeType, NodeLayer
+from .workflow import Workflow, WorkflowStep
+from .work_log import WorkLog, WorkLogSource, WorkLogResultType
+
+__all__ = [
+    "KnowledgeTree",
+    "Node",
+    "NodeType",
+    "NodeLayer",
+    "Workflow",
+    "WorkflowStep",
+    "WorkLog",
+    "WorkLogSource",
+    "WorkLogResultType",
+]