claude-mpm 5.4.21__py3-none-any.whl → 5.4.59__py3-none-any.whl

claude_mpm/dashboard-svelte/node_modules/katex/src/metrics/extract_ttfs.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+
+from fontTools.ttLib import TTFont
+import sys
+import json
+
+# map of characters to extract
+metrics_to_extract = {
+    # Font name
+    "AMS-Regular": {
+        u"\u21e2": None,  # \dashrightarrow
+        u"\u21e0": None,  # \dashleftarrow
+    },
+    "Main-Regular": {
+        # Skew and italic metrics can't be easily parsed from the TTF. Instead,
+        # we map each character to a "base character", which is a character
+        # from the same font with correct italic and skew metrics. A character
+        # maps to None if it doesn't have a base.
+
+        #u"\u2209": None,  # \notin
+        #u"\u2260": None,  # \neq
+        u"\u2245": None,  # \cong
+        u"\u2026": None,  # \ldots
+        u"\u22ef": None,  # \cdots
+        u"\u22f1": None,  # \ddots
+        u"\u22ee": None,  # \vdots
+        u"\u22ee": None,  # \vdots
+        u"\u22a8": None,  # \models
+        u"\u22c8": None,  # \bowtie
+        u"\u2250": None,  # \doteq
+        u"\u23b0": None,  # \lmoustache
+        u"\u23b1": None,  # \rmoustache
+        u"\u27ee": None,  # \lgroup
+        u"\u27ef": None,  # \rgroup
+        u"\u27f5": None,  # \longleftarrow
+        u"\u27f8": None,  # \Longleftarrow
+        u"\u27f6": None,  # \longrightarrow
+        u"\u27f9": None,  # \Longrightarrow
+        u"\u27f7": None,  # \longleftrightarrow
+        u"\u27fa": None,  # \Longleftrightarrow
+        u"\u21a6": None,  # \mapsto
+        u"\u27fc": None,  # \longmapsto
+        u"\u21a9": None,  # \hookleftarrow
+        u"\u21aa": None,  # \hookrightarrow
+        u"\u21cc": None,  # \rightleftharpoons
+    },
+    "Main-Bold": {
+        u"\u2245": None,  # \cong
+    },
+    "Size1-Regular": {
+        u"\u222c": u"\u222b",  # \iint, based on \int
+        u"\u222d": u"\u222b",  # \iiint, based on \int
+    },
+    "Size2-Regular": {
+        u"\u222c": u"\u222b",  # \iint, based on \int
+        u"\u222d": u"\u222b",  # \iiint, based on \int
+    },
+}
+
+
+def main():
+    start_json = json.load(sys.stdin)
+
+    for font in start_json:
+        fontInfo = TTFont("../../fonts/KaTeX_" + font + ".ttf")
+        glyf = fontInfo["glyf"]
+        widths = fontInfo.getGlyphSet()
+        unitsPerEm = float(fontInfo["head"].unitsPerEm)
+
+        # We keep ALL Unicode cmaps, not just fontInfo["cmap"].getcmap(3, 1).
+        # This is playing it extra safe, since it reports inconsistencies.
+        # Platform 0 is Unicode, platform 3 is Windows. For platform 3,
+        # encoding 1 is UCS-2 and encoding 10 is UCS-4.
+        cmap = [t.cmap for t in fontInfo["cmap"].tables
+                if (t.platformID == 0)
+                or (t.platformID == 3 and t.platEncID in (1, 10))]
+
+        chars = metrics_to_extract.get(font, {})
+        chars[u"\u0020"] = None  # space
+        chars[u"\u00a0"] = None  # nbsp
+
+        for char, base_char in chars.items():
+            code = ord(char)
+            names = set(t.get(code) for t in cmap)
+            if not names:
+                sys.stderr.write(
+                    "Codepoint {} of font {} maps to no name\n"
+                    .format(code, font))
+                continue
+            if len(names) != 1:
+                sys.stderr.write(
+                    "Codepoint {} of font {} maps to multiple names: {}\n"
+                    .format(code, font, ", ".join(sorted(names))))
+                continue
+            name = names.pop()
+
+            height = depth = italic = skew = width = 0
+            glyph = glyf[name]
+            if glyph.numberOfContours:
+                height = glyph.yMax / unitsPerEm
+                depth = -glyph.yMin / unitsPerEm
+            width = widths[name].width / unitsPerEm
+            if base_char:
+                base_char_str = str(ord(base_char))
+                base_metrics = start_json[font][base_char_str]
+                italic = base_metrics["italic"]
+                skew = base_metrics["skew"]
+                width = base_metrics["width"]
+
+            start_json[font][str(code)] = {
+                "height": height,
+                "depth": depth,
+                "italic": italic,
+                "skew": skew,
+                "width": width
+            }
+
+    sys.stdout.write(
+        json.dumps(start_json, separators=(',', ':'), sort_keys=True))
+
+if __name__ == "__main__":
+    main()

claude_mpm/dashboard-svelte/node_modules/katex/src/metrics/format_json.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+import sys
+import json
+
+props = ['depth', 'height', 'italic', 'skew']
+
+if len(sys.argv) > 1:
+    if sys.argv[1] == '--width':
+        props.append('width')
+
+data = json.load(sys.stdin)
+sys.stdout.write(
+  "// This file is GENERATED by buildMetrics.sh. DO NOT MODIFY.\n")
+sep = "export default {\n    "
+for font in sorted(data):
+    sys.stdout.write(sep + json.dumps(font))
+    sep = ": {\n        "
+    for glyph in sorted(data[font], key=int):
+        sys.stdout.write(sep + json.dumps(glyph) + ": ")
+
+        values = [value if value != 0.0 else 0 for value in
+                  [data[font][glyph][key] for key in props]]
+
+        sys.stdout.write(json.dumps(values))
+        sep = ",\n        "
+    sep = ",\n    },\n    "
+sys.stdout.write(",\n    },\n};\n")

claude_mpm/dashboard-svelte/node_modules/katex/src/metrics/parse_tfm.py

@@ -0,0 +1,211 @@
+class CharInfoWord(object):
+    def __init__(self, word):
+        b1, b2, b3, b4 = (word >> 24,
+                          (word & 0xff0000) >> 16,
+                          (word & 0xff00) >> 8,
+                          word & 0xff)
+
+        self.width_index = b1
+        self.height_index = b2 >> 4
+        self.depth_index = b2 & 0x0f
+        self.italic_index = (b3 & 0b11111100) >> 2
+        self.tag = b3 & 0b11
+        self.remainder = b4
+
+    def has_ligkern(self):
+        return self.tag == 1
+
+    def ligkern_start(self):
+        return self.remainder
+
+
+class LigKernProgram(object):
+    def __init__(self, program):
+        self.program = program
+
+    def execute(self, start, next_char):
+        curr_instruction = start
+        while True:
+            instruction = self.program[curr_instruction]
+            (skip, inst_next_char, op, remainder) = instruction
+
+            if inst_next_char == next_char:
+                if op < 128:
+                    # Don't worry about ligatures for now, we only need kerns
+                    return None
+                else:
+                    return 256 * (op - 128) + remainder
+            elif skip >= 128:
+                return None
+            else:
+                curr_instruction += 1 + skip
+
+
+class TfmCharMetrics(object):
+    def __init__(self, width, height, depth, italic, kern_table):
+        self.width = width
+        self.height = height
+        self.depth = depth
+        self.italic_correction = italic
+        self.kern_table = kern_table
+
+
+class TfmFile(object):
+    def __init__(self, start_char, end_char, char_info, width_table,
+                 height_table, depth_table, italic_table, ligkern_table,
+                 kern_table):
+        self.start_char = start_char
+        self.end_char = end_char
+        self.char_info = char_info
+        self.width_table = width_table
+        self.height_table = height_table
+        self.depth_table = depth_table
+        self.italic_table = italic_table
+        self.ligkern_program = LigKernProgram(ligkern_table)
+        self.kern_table = kern_table
+
+    def get_char_metrics(self, char_num, fix_rsfs=False):
+        """Return glyph metrics for a unicode code point.
+
+        Arguments:
+            char_num: a unicode code point
+            fix_rsfs: adjust for rsfs10.tfm's different indexing system
+        """
+        if char_num < self.start_char or char_num > self.end_char:
+            raise RuntimeError("Invalid character number")
+
+        if fix_rsfs:
+            # all of the char_nums contained start from zero in rsfs10.tfm
+            info = self.char_info[char_num - self.start_char]
+        else:
+            info = self.char_info[char_num + self.start_char]
+
+        char_kern_table = {}
+        if info.has_ligkern():
+            for char in range(self.start_char, self.end_char + 1):
+                kern = self.ligkern_program.execute(info.ligkern_start(), char)
+                if kern:
+                    char_kern_table[char] = self.kern_table[kern]
+
+        return TfmCharMetrics(
+            self.width_table[info.width_index],
+            self.height_table[info.height_index],
+            self.depth_table[info.depth_index],
+            self.italic_table[info.italic_index],
+            char_kern_table)
+
+
+class TfmReader(object):
+    def __init__(self, f):
+        self.f = f
+
+    def read_byte(self):
+        return ord(self.f.read(1))
+
+    def read_halfword(self):
+        b1 = self.read_byte()
+        b2 = self.read_byte()
+        return (b1 << 8) | b2
+
+    def read_word(self):
+        b1 = self.read_byte()
+        b2 = self.read_byte()
+        b3 = self.read_byte()
+        b4 = self.read_byte()
+        return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4
+
+    def read_fixword(self):
+        word = self.read_word()
+
+        neg = False
+        if word & 0x80000000:
+            neg = True
+            word = (-word & 0xffffffff)
+
+        return (-1 if neg else 1) * word / float(1 << 20)
+
+    def read_bcpl(self, length):
+        str_length = self.read_byte()
+        data = self.f.read(length - 1)
+        return data[:str_length]
+
+
+def read_tfm_file(file_name):
+    with open(file_name, 'rb') as f:
+        reader = TfmReader(f)
+
+        # file_size
+        reader.read_halfword()
+        header_size = reader.read_halfword()
+
+        start_char = reader.read_halfword()
+        end_char = reader.read_halfword()
+
+        width_table_size = reader.read_halfword()
+        height_table_size = reader.read_halfword()
+        depth_table_size = reader.read_halfword()
+        italic_table_size = reader.read_halfword()
+
+        ligkern_table_size = reader.read_halfword()
+        kern_table_size = reader.read_halfword()
+
+        # extensible_table_size
+        reader.read_halfword()
+        # parameter_table_size
+        reader.read_halfword()
+
+        # checksum
+        reader.read_word()
+        # design_size
+        reader.read_fixword()
+
+        if header_size > 2:
+            # coding_scheme
+            reader.read_bcpl(40)
+
+        if header_size > 12:
+            # font_family
+            reader.read_bcpl(20)
+
+        for i in range(header_size - 17):
+            reader.read_word()
+
+        char_info = []
+        for i in range(start_char, end_char + 1):
+            char_info.append(CharInfoWord(reader.read_word()))
+
+        width_table = []
+        for i in range(width_table_size):
+            width_table.append(reader.read_fixword())
+
+        height_table = []
+        for i in range(height_table_size):
+            height_table.append(reader.read_fixword())
+
+        depth_table = []
+        for i in range(depth_table_size):
+            depth_table.append(reader.read_fixword())
+
+        italic_table = []
+        for i in range(italic_table_size):
+            italic_table.append(reader.read_fixword())
+
+        ligkern_table = []
+        for i in range(ligkern_table_size):
+            skip = reader.read_byte()
+            next_char = reader.read_byte()
+            op = reader.read_byte()
+            remainder = reader.read_byte()
+
+            ligkern_table.append((skip, next_char, op, remainder))
+
+        kern_table = []
+        for i in range(kern_table_size):
+            kern_table.append(reader.read_fixword())
+
+        # There is more information, like the ligkern, kern, extensible, and
+        # param table, but we don't need these for now
+
+        return TfmFile(start_char, end_char, char_info, width_table,
+                       height_table, depth_table, italic_table,
+                       ligkern_table, kern_table)

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -394,6 +394,8 @@ class ClaudeHookHandler:
         Returns:
             Modified input for PreToolUse events (v2.0.30+), None otherwise
         """
+        import time
+
         # Try multiple field names for compatibility
         hook_type = (
             event.get("hook_event_name")
@@ -425,15 +427,40 @@ class ClaudeHookHandler:
         # Call appropriate handler if exists
         handler = event_handlers.get(hook_type)
         if handler:
+            # Track execution timing for hook emission
+            start_time = time.time()
+            success = False
+            error_message = None
+            result = None
+
             try:
                 # Handlers can optionally return modified input
                 result = handler(event)
+                success = True
                 # Only PreToolUse handlers should return modified input
                 if hook_type == "PreToolUse" and result is not None:
-                    return result
+                    return_value = result
+                else:
+                    return_value = None
             except Exception as e:
+                error_message = str(e)
+                return_value = None
                 if DEBUG:
                     print(f"Error handling {hook_type}: {e}", file=sys.stderr)
+            finally:
+                # Calculate duration
+                duration_ms = int((time.time() - start_time) * 1000)
+
+                # Emit hook execution event
+                self._emit_hook_execution_event(
+                    hook_type=hook_type,
+                    event=event,
+                    success=success,
+                    duration_ms=duration_ms,
+                    error_message=error_message,
+                )
+
+            return return_value
 
         return None
 
@@ -478,6 +505,127 @@ class ClaudeHookHandler:
         """Generate event key through duplicate detector (backward compatibility)."""
         return self.duplicate_detector.generate_event_key(event)
 
+    def _emit_hook_execution_event(
+        self,
+        hook_type: str,
+        event: dict,
+        success: bool,
+        duration_ms: int,
+        error_message: Optional[str] = None,
+    ):
+        """Emit a structured JSON event for hook execution.
+
+        This emits a normalized event following the claude_event schema to provide
+        visibility into hook processing, timing, and success/failure status.
+
+        Args:
+            hook_type: The type of hook that executed (e.g., "UserPromptSubmit", "PreToolUse")
+            event: The original hook event data
+            success: Whether the hook executed successfully
+            duration_ms: How long the hook took to execute in milliseconds
+            error_message: Optional error message if the hook failed
+        """
+        # Generate a human-readable summary based on hook type
+        summary = self._generate_hook_summary(hook_type, event, success)
+
+        # Extract common fields
+        session_id = event.get("session_id", "")
+        working_dir = event.get("cwd", "")
+
+        # Build hook execution data
+        hook_data = {
+            "hook_name": hook_type,
+            "hook_type": hook_type,
+            "session_id": session_id,
+            "working_directory": working_dir,
+            "success": success,
+            "duration_ms": duration_ms,
+            "result_summary": summary,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        }
+
+        # Add error information if present
+        if error_message:
+            hook_data["error_message"] = error_message
+
+        # Add hook-specific context
+        if hook_type == "PreToolUse":
+            hook_data["tool_name"] = event.get("tool_name", "")
+        elif hook_type == "PostToolUse":
+            hook_data["tool_name"] = event.get("tool_name", "")
+            hook_data["exit_code"] = event.get("exit_code", 0)
+        elif hook_type == "UserPromptSubmit":
+            prompt = event.get("prompt", "")
+            hook_data["prompt_preview"] = prompt[:100] if len(prompt) > 100 else prompt
+            hook_data["prompt_length"] = len(prompt)
+        elif hook_type == "SubagentStop":
+            hook_data["agent_type"] = event.get("agent_type", "unknown")
+            hook_data["reason"] = event.get("reason", "unknown")
+
+        # Emit through connection manager with proper structure
+        # This uses the existing event infrastructure
+        self._emit_socketio_event("", "hook_execution", hook_data)
+
+        if DEBUG:
+            print(
+                f"📊 Hook execution event: {hook_type} - {duration_ms}ms - {'✅' if success else '❌'}",
+                file=sys.stderr,
+            )
+
+    def _generate_hook_summary(self, hook_type: str, event: dict, success: bool) -> str:
+        """Generate a human-readable summary of what the hook did.
+
+        Args:
+            hook_type: The type of hook
+            event: The hook event data
+            success: Whether the hook executed successfully
+
+        Returns:
+            A brief description of what happened
+        """
+        if not success:
+            return f"Hook {hook_type} failed during processing"
+
+        # Generate hook-specific summaries
+        if hook_type == "UserPromptSubmit":
+            prompt = event.get("prompt", "")
+            if prompt.startswith("/"):
+                return f"Processed command: {prompt.split()[0]}"
+            return f"Processed user prompt ({len(prompt)} chars)"
+
+        if hook_type == "PreToolUse":
+            tool_name = event.get("tool_name", "unknown")
+            return f"Pre-processing tool call: {tool_name}"
+
+        if hook_type == "PostToolUse":
+            tool_name = event.get("tool_name", "unknown")
+            exit_code = event.get("exit_code", 0)
+            status = "success" if exit_code == 0 else "failed"
+            return f"Completed tool call: {tool_name} ({status})"
+
+        if hook_type == "SubagentStop":
+            agent_type = event.get("agent_type", "unknown")
+            reason = event.get("reason", "unknown")
+            return f"Subagent {agent_type} stopped: {reason}"
+
+        if hook_type == "SessionStart":
+            return "New session started"
+
+        if hook_type == "Stop":
+            reason = event.get("reason", "unknown")
+            return f"Session stopped: {reason}"
+
+        if hook_type == "Notification":
+            notification_type = event.get("notification_type", "unknown")
+            return f"Notification received: {notification_type}"
+
+        if hook_type == "AssistantResponse":
+            response_len = len(event.get("response", ""))
+            return f"Assistant response generated ({response_len} chars)"
+
+        # Default summary
+        return f"Hook {hook_type} processed successfully"
+
     def __del__(self):
         """Cleanup on handler destruction."""
         # Clean up connection manager if it exists

claude_mpm/hooks/claude_hooks/services/connection_manager.py

@@ -58,7 +58,7 @@ except ImportError:
                 (),
                 {
                     "to_dict": lambda: {
-                        "event": "claude_event",
+                        "event": "mpm_event",
                         "type": event_data.get("type", "unknown"),
                         "subtype": event_data.get("subtype", "generic"),
                         "timestamp": event_data.get(
@@ -119,13 +119,33 @@ class ConnectionManagerService:
         tool_call_id = data.get("tool_call_id")
 
         # Create event data for normalization
+        # Extract session_id (try both camelCase and snake_case)
+        session_id = data.get("session_id") or data.get("sessionId")
+
+        # Extract working directory for project identification
+        # Try multiple field names for maximum compatibility
+        cwd = (
+            data.get("cwd")
+            or data.get("working_directory")
+            or data.get("workingDirectory")
+        )
+
+        # For hook_execution events, extract the actual hook type from data
+        # Otherwise use "hook" as the type
+        if event == "hook_execution":
+            hook_type = data.get("hook_type", "unknown")
+            event_type = hook_type
+        else:
+            event_type = "hook"
+
         raw_event = {
-            "type": "hook",
-            "subtype": event,  # e.g., "user_prompt", "pre_tool", "subagent_stop"
+            "type": event_type,  # Use actual hook type for hook_execution, "hook" otherwise
+            "subtype": event,  # e.g., "user_prompt", "pre_tool", "subagent_stop", "execution"
             "timestamp": datetime.now(timezone.utc).isoformat(),
             "data": data,
-            "source": "claude_hooks",  # Identify the source
-            "session_id": data.get("sessionId"),  # Include session if available
+            "source": "mpm_hook",  # Identify the source as mpm_hook
+            "session_id": session_id,  # Include session if available (supports both naming conventions)
+            "cwd": cwd,  # Add working directory at top level for easy frontend access
             "correlation_id": tool_call_id,  # Set from tool_call_id for event correlation
         }
 
@@ -154,7 +174,7 @@ class ConnectionManagerService:
         if self.connection_pool:
             try:
                 # Emit to Socket.IO server directly
-                self.connection_pool.emit("claude_event", claude_event_data)
+                self.connection_pool.emit("mpm_event", claude_event_data)
                 if DEBUG:
                     print(f"✅ Emitted via connection pool: {event}", file=sys.stderr)
                 return  # Success - no need for fallback

claude_mpm/hooks/kuzu_memory_hook.py

@@ -13,9 +13,9 @@ for structured memory storage with semantic search capabilities.
 DESIGN DECISIONS:
 - Priority 10 for early execution to enrich prompts before other hooks
 - Uses subprocess to call kuzu-memory directly for maximum compatibility
-- Graceful degradation if kuzu-memory is not in PATH (though it's now required)
+- Graceful degradation if kuzu-memory is not installed
 - Automatic extraction and storage of important information
-- kuzu-memory>=1.1.5 is now a REQUIRED dependency (moved from optional in v4.8.6)
+- kuzu-memory is an OPTIONAL dependency (install with: pip install claude-mpm[memory])
 """
 
 import json
@@ -51,9 +51,9 @@ class KuzuMemoryHook(SubmitHook):
         self.enabled = self.kuzu_memory_cmd is not None
 
         if not self.enabled:
-            logger.warning(
-                "Kuzu-memory not found in PATH. As of v4.8.6, it's a required dependency. "
-                "Install with: pip install kuzu-memory>=1.1.5 or pipx install kuzu-memory"
+            logger.debug(
+                "Kuzu-memory not found. Graph-based memory disabled. "
+                "To enable: pip install claude-mpm[memory] (requires cmake)"
             )
         else:
             logger.info(f"Kuzu-memory integration enabled: {self.kuzu_memory_cmd}")