@purpleraven/hits 0.2.0

package/hits_core/models/node.py

@@ -0,0 +1,56 @@
+"""Node entity model for knowledge tree."""
+
+from enum import Enum
+from typing import Optional
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class NodeLayer(str, Enum):
+    WHY = "why"
+    HOW = "how"
+    WHAT = "what"
+
+
+class NodeType(str, Enum):
+    STANDARD = "standard"
+    NEGATIVE_PATH = "negative_path"
+    DECISION = "decision"
+    ACTION = "action"
+
+
+class Node(BaseModel):
+    id: str = Field(..., description="Unique node identifier")
+    layer: NodeLayer = Field(..., description="Tree layer (why/how/what)")
+    title: str = Field(..., description="Node display title")
+    description: Optional[str] = Field(default=None, description="Detailed description")
+    node_type: NodeType = Field(default=NodeType.STANDARD, description="Node type")
+    
+    parent_id: Optional[str] = Field(default=None, description="Parent node ID")
+    children_ids: list[str] = Field(default_factory=list, description="Child node IDs")
+    
+    action: Optional[str] = Field(default=None, description="Executable action (URL, command, etc.)")
+    action_type: Optional[str] = Field(default=None, description="Action type: url, shell, app")
+    
+    metadata: dict = Field(default_factory=dict, description="Additional metadata")
+    tokens_saved: int = Field(default=0, description="Estimated tokens saved by compression")
+    
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)
+    
+    class Config:
+        use_enum_values = True
+    
+    def is_root(self) -> bool:
+        return self.parent_id is None
+    
+    def is_negative_path(self) -> bool:
+        return self.node_type == NodeType.NEGATIVE_PATH
+    
+    def add_child(self, child_id: str) -> None:
+        if child_id not in self.children_ids:
+            self.children_ids.append(child_id)
+    
+    def remove_child(self, child_id: str) -> None:
+        if child_id in self.children_ids:
+            self.children_ids.remove(child_id)

package/hits_core/models/tree.py

@@ -0,0 +1,68 @@
+"""Knowledge tree structure with Why-How-What hierarchy."""
+
+from typing import Optional
+from datetime import datetime
+from pydantic import BaseModel, Field
+from .node import Node, NodeLayer
+
+
+class KnowledgeTree(BaseModel):
+    id: str = Field(..., description="Tree unique identifier")
+    name: str = Field(..., description="Tree name")
+    description: Optional[str] = Field(default=None, description="Tree description")
+    
+    root_ids: list[str] = Field(default_factory=list, description="Root node IDs (WHY layer)")
+    nodes: dict[str, Node] = Field(default_factory=dict, description="All nodes by ID")
+    
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)
+    
+    def add_node(self, node: Node) -> None:
+        self.nodes[node.id] = node
+        if node.is_root() and node.id not in self.root_ids:
+            self.root_ids.append(node.id)
+        elif node.parent_id and node.parent_id in self.nodes:
+            self.nodes[node.parent_id].add_child(node.id)
+    
+    def remove_node(self, node_id: str) -> Optional[Node]:
+        if node_id not in self.nodes:
+            return None
+        
+        node = self.nodes.pop(node_id)
+        
+        if node_id in self.root_ids:
+            self.root_ids.remove(node_id)
+        
+        if node.parent_id and node.parent_id in self.nodes:
+            self.nodes[node.parent_id].remove_child(node_id)
+        
+        for child_id in node.children_ids[:]:
+            self.remove_node(child_id)
+        
+        return node
+    
+    def get_node(self, node_id: str) -> Optional[Node]:
+        return self.nodes.get(node_id)
+    
+    def get_children(self, node_id: str) -> list[Node]:
+        node = self.get_node(node_id)
+        if not node:
+            return []
+        return [self.nodes[cid] for cid in node.children_ids if cid in self.nodes]
+    
+    def get_path(self, node_id: str) -> list[Node]:
+        path = []
+        current = self.get_node(node_id)
+        while current:
+            path.insert(0, current)
+            current = self.get_node(current.parent_id) if current.parent_id else None
+        return path
+    
+    def get_nodes_by_layer(self, layer: NodeLayer) -> list[Node]:
+        return [n for n in self.nodes.values() if n.layer == layer]
+    
+    def get_negative_paths(self) -> list[Node]:
+        return [n for n in self.nodes.values() if n.is_negative_path()]
+    
+    def total_tokens_saved(self) -> int:
+        return sum(n.tokens_saved for n in self.nodes.values())

package/hits_core/models/work_log.py

@@ -0,0 +1,64 @@
+"""Work log model for recording user activities."""
+
+from enum import Enum
+from typing import Optional
+from datetime import datetime
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class WorkLogSource(str, Enum):
+    GIT = "git"
+    SHELL = "shell"
+    LINK_CLICK = "link_click"
+    SHELL_EXEC = "shell_exec"
+    AI_SESSION = "ai_session"
+    MANUAL = "manual"
+    BROWSER_HISTORY = "browser_history"
+
+
+class WorkLogResultType(str, Enum):
+    COMMIT = "commit"
+    PR = "pr"
+    FILE = "file"
+    URL = "url"
+    COMMAND = "command"
+    NONE = "none"
+    AI_RESPONSE = "ai_response"
+
+
+class WorkLog(BaseModel):
+    model_config = ConfigDict(use_enum_values=True)
+    
+    id: str = Field(..., description="Unique log identifier")
+    
+    source: WorkLogSource = Field(..., description="Where this log came from")
+    
+    request_text: Optional[str] = Field(default=None, description="Original request/prompt")
+    request_by: Optional[str] = Field(default=None, description="Who made the request")
+    
+    performed_by: str = Field(..., description="Who/what performed the action")
+    performed_at: datetime = Field(default_factory=datetime.now)
+    
+    result_type: WorkLogResultType = Field(default=WorkLogResultType.NONE)
+    result_ref: Optional[str] = Field(default=None, description="Reference to result (commit hash, URL, etc)")
+    result_data: Optional[dict] = Field(default=None, description="Additional result metadata")
+    
+    context: Optional[str] = Field(default=None, description="Why this action was taken")
+    tags: list[str] = Field(default_factory=list, description="Tags for search")
+    
+    project_path: Optional[str] = Field(default=None, description="Project directory if applicable")
+    
+    node_id: Optional[str] = Field(default=None, description="Linked knowledge node ID")
+    category: Optional[str] = Field(default=None, description="Category name from HITS UI")
+    
+    created_at: datetime = Field(default_factory=datetime.now)
+    
+    def has_result(self) -> bool:
+        return self.result_type != WorkLogResultType.NONE and self.result_ref is not None
+    
+    def get_summary(self) -> str:
+        if self.request_text:
+            return self.request_text[:100]
+        if self.result_ref:
+            return f"[{self.result_type}] {self.result_ref[:50]}"
+        return f"[{self.source}] {self.performed_by}"

package/hits_core/models/workflow.py

@@ -0,0 +1,92 @@
+"""Workflow model for causal relationships between nodes."""
+
+from enum import Enum
+from typing import Optional
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class StepType(str, Enum):
+    TRIGGER = "trigger"
+    DECISION = "decision"
+    ACTION = "action"
+    OUTCOME = "outcome"
+    FAILURE = "failure"
+
+
+class WorkflowStep(BaseModel):
+    id: str = Field(..., description="Step unique identifier")
+    name: str = Field(..., description="Step name")
+    step_type: StepType = Field(default=StepType.ACTION, description="Step type")
+    node_id: Optional[str] = Field(default=None, description="Linked knowledge node ID")
+    description: Optional[str] = Field(default=None, description="Step description")
+    
+    next_steps: list[str] = Field(default_factory=list, description="Next step IDs")
+    condition: Optional[str] = Field(default=None, description="Condition for branching")
+    
+    estimated_tokens: int = Field(default=0, description="Estimated tokens for this step")
+    
+    class Config:
+        use_enum_values = True
+
+
+class Workflow(BaseModel):
+    id: str = Field(..., description="Workflow unique identifier")
+    name: str = Field(..., description="Workflow name")
+    description: Optional[str] = Field(default=None, description="Workflow description")
+    
+    entry_step_id: Optional[str] = Field(default=None, description="Entry point step ID")
+    steps: dict[str, WorkflowStep] = Field(default_factory=dict, description="All steps by ID")
+    
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)
+    
+    def add_step(self, step: WorkflowStep, is_entry: bool = False) -> None:
+        self.steps[step.id] = step
+        if is_entry or not self.entry_step_id:
+            self.entry_step_id = step.id
+    
+    def remove_step(self, step_id: str) -> Optional[WorkflowStep]:
+        if step_id not in self.steps:
+            return None
+        
+        step = self.steps.pop(step_id)
+        
+        if self.entry_step_id == step_id:
+            self.entry_step_id = None
+        
+        for s in self.steps.values():
+            if step_id in s.next_steps:
+                s.next_steps.remove(step_id)
+        
+        return step
+    
+    def get_step(self, step_id: str) -> Optional[WorkflowStep]:
+        return self.steps.get(step_id)
+    
+    def get_next_steps(self, step_id: str) -> list[WorkflowStep]:
+        step = self.get_step(step_id)
+        if not step:
+            return []
+        return [self.steps[sid] for sid in step.next_steps if sid in self.steps]
+    
+    def get_execution_order(self) -> list[WorkflowStep]:
+        if not self.entry_step_id:
+            return []
+        
+        visited = set()
+        order = []
+        
+        def dfs(step_id: str):
+            if step_id in visited or step_id not in self.steps:
+                return
+            visited.add(step_id)
+            order.append(self.steps[step_id])
+            for next_id in self.steps[step_id].next_steps:
+                dfs(next_id)
+        
+        dfs(self.entry_step_id)
+        return order
+    
+    def total_estimated_tokens(self) -> int:
+        return sum(s.estimated_tokens for s in self.steps.values())

package/hits_core/platform/__init__.py

@@ -0,0 +1,5 @@
+"""Platform utilities package."""
+
+from .actions import PlatformAction, is_wsl, get_platform_info
+
+__all__ = ["PlatformAction", "is_wsl", "get_platform_info"]

package/hits_core/platform/actions.py

@@ -0,0 +1,225 @@
+"""Cross-platform utilities without GUI dependencies."""
+
+import os
+import subprocess
+import sys
+import webbrowser
+from typing import Optional, Tuple
+
+
+def is_wsl() -> bool:
+    """Detect if running under Windows Subsystem for Linux."""
+    if sys.platform != "linux":
+        return False
+    
+    try:
+        with open("/proc/version", "r") as f:
+            version = f.read().lower()
+            return "microsoft" in version or "wsl" in version
+    except Exception:
+        return False
+
+
+def detect_terminal_emulator() -> Optional[str]:
+    """Detect available terminal emulator on Linux."""
+    terminals = [
+        ("wt", "wt.exe"),  # Windows Terminal via WSL
+        ("gnome-terminal", "gnome-terminal"),
+        ("konsole", "konsole"),
+        ("xfce4-terminal", "xfce4-terminal"),
+        ("xterm", "xterm"),
+        ("alacritty", "alacritty"),
+        ("kitty", "kitty"),
+        ("terminator", "terminator"),
+        ("urxvt", "urxvt"),
+    ]
+    
+    for name, cmd in terminals:
+        if cmd == "wt.exe" and is_wsl():
+            try:
+                subprocess.run(["which", "wt.exe"], capture_output=True, check=True)
+                return "wt"
+            except Exception:
+                continue
+        
+        try:
+            subprocess.run(["which", cmd], capture_output=True, check=True)
+            return name
+        except Exception:
+            continue
+    
+    return None
+
+
+def get_wsl_windows_path(linux_path: str) -> str:
+    """Convert Linux path to Windows path for WSL."""
+    if not is_wsl():
+        return linux_path
+    
+    try:
+        result = subprocess.run(
+            ["wslpath", "-w", linux_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout.strip()
+    except Exception:
+        return linux_path
+
+
+class PlatformAction:
+    _is_wsl = is_wsl()
+    _terminal_cache: Optional[str] = None
+    
+    @classmethod
+    def _get_terminal(cls) -> Optional[str]:
+        if cls._terminal_cache is None:
+            cls._terminal_cache = detect_terminal_emulator()
+        return cls._terminal_cache
+    
+    @staticmethod
+    def open_url(url: str) -> bool:
+        """Open URL in default browser - works on all platforms."""
+        try:
+            if is_wsl():
+                try:
+                    win_url = get_wsl_windows_path(url) if url.startswith("/") else url
+                    subprocess.run(["cmd.exe", "/c", "start", win_url], check=True)
+                    return True
+                except Exception:
+                    pass
+            
+            webbrowser.open(url)
+            return True
+        except Exception:
+            return False
+    
+    @classmethod
+    def run_shell(cls, command: str, terminal: bool = True) -> bool:
+        """Execute shell command, optionally in a new terminal."""
+        try:
+            if not terminal:
+                subprocess.Popen(command, shell=True)
+                return True
+            
+            if sys.platform == "win32":
+                return cls._run_shell_windows(command)
+            elif sys.platform == "darwin":
+                return cls._run_shell_macos(command)
+            else:
+                return cls._run_shell_linux(command)
+        except Exception:
+            return False
+    
+    @classmethod
+    def _run_shell_windows(cls, command: str) -> bool:
+        """Run shell command on Windows."""
+        term = os.environ.get("TERM_PROGRAM", "")
+        
+        if term == "vscode" or "WT_SESSION" in os.environ:
+            subprocess.Popen(["wt", "cmd", "/k", command])
+        else:
+            subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", command])
+        return True
+    
+    @classmethod
+    def _run_shell_macos(cls, command: str) -> bool:
+        """Run shell command on macOS."""
+        script = f'tell application "Terminal" to do script "{command}"'
+        subprocess.Popen(["osascript", "-e", script])
+        return True
+    
+    @classmethod
+    def _run_shell_linux(cls, command: str) -> bool:
+        """Run shell command on Linux (including WSL)."""
+        if cls._is_wsl:
+            try:
+                subprocess.run(["which", "wt.exe"], capture_output=True, check=True)
+                subprocess.Popen([
+                    "wt.exe", "-d", ".",
+                    "bash", "-c", f"{command}; echo; read -p 'Press Enter to close...'"
+                ])
+                return True
+            except Exception:
+                pass
+        
+        terminal = cls._get_terminal()
+        
+        if terminal == "gnome-terminal":
+            subprocess.Popen([
+                "gnome-terminal", "--", "bash", "-c",
+                f"{command}; echo; read -p 'Press Enter to close...'"
+            ])
+        elif terminal == "konsole":
+            subprocess.Popen([
+                "konsole", "-e", "bash", "-c",
+                f"{command}; echo; read -p 'Press Enter to close...'"
+            ])
+        elif terminal == "xfce4-terminal":
+            subprocess.Popen([
+                "xfce4-terminal", "-e", f"bash -c '{command}; echo; read -p \"Press Enter to close...\"'"
+            ])
+        elif terminal == "alacritty":
+            subprocess.Popen([
+                "alacritty", "-e", "bash", "-c",
+                f"{command}; echo; read -p 'Press Enter to close...'"
+            ])
+        elif terminal == "kitty":
+            subprocess.Popen([
+                "kitty", "bash", "-c",
+                f"{command}; echo; read -p 'Press Enter to close...'"
+            ])
+        elif terminal in ("xterm", "urxvt"):
+            subprocess.Popen([
+                terminal, "-e", "bash", "-c",
+                f"{command}; echo; read -p 'Press Enter to close...'"
+            ])
+        else:
+            subprocess.Popen([
+                "x-terminal-emulator", "-e", "bash", "-c",
+                f"{command}; echo; read -p 'Press Enter to close...'"
+            ])
+        
+        return True
+    
+    @classmethod
+    def launch_app(cls, app_path: str) -> bool:
+        """Launch an application."""
+        try:
+            if sys.platform == "win32":
+                subprocess.Popen(["cmd", "/c", "start", "", app_path], shell=True)
+            elif sys.platform == "darwin":
+                subprocess.Popen(["open", app_path])
+            elif cls._is_wsl:
+                win_path = get_wsl_windows_path(app_path)
+                subprocess.Popen(["cmd.exe", "/c", "start", "", win_path])
+            else:
+                subprocess.Popen([app_path])
+            return True
+        except Exception:
+            return False
+    
+    @staticmethod
+    def execute(action_type: str, action: str) -> bool:
+        """Execute action based on type."""
+        action_type = action_type.lower().strip()
+        
+        if action_type == "url":
+            return PlatformAction.open_url(action)
+        elif action_type == "shell":
+            return PlatformAction.run_shell(action)
+        elif action_type == "app":
+            return PlatformAction.launch_app(action)
+        else:
+            return False
+
+
+def get_platform_info() -> dict:
+    """Get current platform information."""
+    return {
+        "system": sys.platform,
+        "is_wsl": is_wsl(),
+        "terminal": detect_terminal_emulator(),
+        "python": sys.version,
+    }

package/hits_core/service/__init__.py

@@ -0,0 +1,6 @@
+"""Business services for tree and workflow management."""
+
+from .tree_service import TreeService
+from .knowledge_service import KnowledgeService, KnowledgeNode, KnowledgeCategory
+
+__all__ = ["TreeService", "KnowledgeService", "KnowledgeNode", "KnowledgeCategory"]