claude-mpm 5.4.41__py3-none-any.whl → 5.6.23__py3-none-any.whl

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/experimental/cli_enhancements.py

@@ -58,8 +58,9 @@ class CLIContext:
             else "%(message)s"
         )
 
+        # MUST use stderr to avoid corrupting hook JSON output
         logging.basicConfig(
-            level=level, format=format_str, handlers=[logging.StreamHandler(sys.stdout)]
+            level=level, format=format_str, handlers=[logging.StreamHandler(sys.stderr)]
         )
         self.debug = debug
 

claude_mpm/hooks/claude_hooks/INTEGRATION_EXAMPLE.md

@@ -0,0 +1,243 @@
+# Auto-Pause Handler Integration Example
+
+This document shows how to integrate the `AutoPauseHandler` with the existing `response_tracking.py` hook handler.
+
+## Integration Steps
+
+### 1. Initialize Handler in ResponseTrackingManager
+
+Add to `response_tracking.py` around line 30:
+
+```python
+from claude_mpm.hooks.claude_hooks.auto_pause_handler import AutoPauseHandler
+
+class ResponseTrackingManager:
+    """Manager for response tracking functionality."""
+
+    def __init__(self):
+        self.response_tracker: Optional[Any] = None
+        self.response_tracking_enabled = False
+        self.track_all_interactions = False
+
+        # Initialize auto-pause handler
+        self.auto_pause_handler: Optional[AutoPauseHandler] = None
+        self._initialize_auto_pause()
+
+        if RESPONSE_TRACKING_AVAILABLE:
+            self._initialize_response_tracking()
+
+    def _initialize_auto_pause(self):
+        """Initialize auto-pause handler for context management."""
+        try:
+            self.auto_pause_handler = AutoPauseHandler()
+
+            if DEBUG:
+                status = self.auto_pause_handler.get_status()
+                print(
+                    f"✅ Auto-pause handler initialized: "
+                    f"{status['context_percentage']}% context used",
+                    file=sys.stderr
+                )
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Failed to initialize auto-pause handler: {e}", file=sys.stderr)
+            # Don't fail - auto-pause is optional
+```
+
+### 2. Monitor Token Usage in track_stop_response()
+
+Add to `track_stop_response()` method around line 327 (after capturing usage data):
+
+```python
+def track_stop_response(
+    self, event: dict, session_id: str, metadata: dict, pending_prompts: dict
+):
+    """Track response for stop events.
+
+    Captures Claude API stop_reason and usage data for context management.
+    """
+    if not (self.response_tracking_enabled and self.response_tracker):
+        return
+
+    try:
+        # ... existing code ...
+
+        # Capture Claude API usage data if available
+        if "usage" in event:
+            usage_data = event["usage"]
+            metadata["usage"] = {
+                "input_tokens": usage_data.get("input_tokens", 0),
+                "output_tokens": usage_data.get("output_tokens", 0),
+                "cache_creation_input_tokens": usage_data.get(
+                    "cache_creation_input_tokens", 0
+                ),
+                "cache_read_input_tokens": usage_data.get(
+                    "cache_read_input_tokens", 0
+                ),
+            }
+
+            # ===== NEW: Auto-pause integration =====
+            if self.auto_pause_handler:
+                threshold_crossed = self.auto_pause_handler.on_usage_update(
+                    metadata["usage"]
+                )
+
+                if threshold_crossed:
+                    warning = self.auto_pause_handler.emit_threshold_warning(
+                        threshold_crossed
+                    )
+                    print(f"\n⚠️  {warning}", file=sys.stderr)
+            # ===== END NEW =====
+
+            if DEBUG:
+                total_tokens = usage_data.get(
+                    "input_tokens", 0
+                ) + usage_data.get("output_tokens", 0)
+                print(
+                    f"  - Captured usage: {total_tokens} total tokens",
+                    file=sys.stderr,
+                )
+
+        # ... rest of existing code ...
+```
+
+### 3. Record Actions During Pause Mode
+
+Add to tool call tracking (in the main hook handler where tools are processed):
+
+```python
+# When a tool is called
+if self.auto_pause_handler and self.auto_pause_handler.is_pause_active():
+    self.auto_pause_handler.on_tool_call(tool_name, tool_args)
+```
+
+Add to assistant response tracking:
+
+```python
+# When assistant responds
+if self.auto_pause_handler and self.auto_pause_handler.is_pause_active():
+    # Summarize response to avoid storing full content
+    summary = response[:200] + "..." if len(response) > 200 else response
+    self.auto_pause_handler.on_assistant_response(summary)
+```
+
+### 4. Finalize Session on End
+
+Add to session cleanup/end handler:
+
+```python
+def on_session_end(self):
+    """Handle session end."""
+    if self.auto_pause_handler:
+        session_file = self.auto_pause_handler.on_session_end()
+
+        if session_file and DEBUG:
+            print(f"✅ Session finalized: {session_file}", file=sys.stderr)
+```
+
+## Testing the Integration
+
+### Test 1: Verify Initialization
+
+```bash
+export CLAUDE_MPM_HOOK_DEBUG=true
+# Run Claude Code - check stderr for initialization message:
+# "✅ Auto-pause handler initialized: 0.0% context used"
+```
+
+### Test 2: Simulate Threshold Crossing
+
+You can test manually by modifying the context usage state file:
+
+```bash
+# View current state
+cat .claude-mpm/state/context-usage.json
+
+# Or check status programmatically
+python -c "
+from claude_mpm.hooks.claude_hooks.auto_pause_handler import AutoPauseHandler
+handler = AutoPauseHandler()
+print(handler.get_status())
+"
+```
+
+### Test 3: Verify Action Recording
+
+After auto-pause is triggered:
+
+```bash
+# Check for active pause file
+ls -la .claude-mpm/sessions/ACTIVE-PAUSE.jsonl
+
+# View recorded actions
+cat .claude-mpm/sessions/ACTIVE-PAUSE.jsonl | jq .
+```
+
+### Test 4: Finalize and Check Output
+
+```bash
+# After session ends, check for finalized session files
+ls -la .claude-mpm/sessions/session-*.json
+ls -la .claude-mpm/sessions/session-*.yaml
+ls -la .claude-mpm/sessions/session-*.md
+```
+
+## Expected Behavior
+
+1. **At 70% context usage**: Caution warning emitted
+2. **At 85% context usage**: Warning emitted
+3. **At 90% context usage**:
+   - Auto-pause triggered
+   - `ACTIVE-PAUSE.jsonl` created
+   - Actions recorded incrementally
+4. **At 95% context usage**: Critical warning emitted
+5. **On session end**:
+   - Pause finalized
+   - Session files created (JSON, YAML, MD)
+   - `ACTIVE-PAUSE.jsonl` archived
+
+## Debug Output Examples
+
+```
+✅ Auto-pause handler initialized: 0.0% context used
+  - Captured usage: 15234 total tokens
+Context threshold crossed: caution (72.3%)
+⚠️  Context usage at 70%. Consider wrapping up current work. (72.3%)
+  - Captured usage: 32451 total tokens
+Context threshold crossed: warning (86.7%)
+⚠️  Context usage at 85%. Session nearing capacity. (86.7%)
+  - Captured usage: 45678 total tokens
+Context threshold crossed: auto_pause (91.2%)
+✅ Auto-pause triggered: session-20260106-143022 (91.2% context used)
+⚠️  Context usage at 90%. Auto-pause activated. Actions are being recorded for session continuity. (91.2%)
+Recorded tool call during pause: Read
+Recorded assistant response during pause (length: 245)
+✅ Session finalized: session-20260106-143022.json
+```
+
+## Error Handling
+
+The integration is designed to be resilient:
+
+- Auto-pause failures don't break the main hook flow
+- All errors are logged to stderr in DEBUG mode
+- Missing dependencies are handled gracefully
+- Invalid state files trigger default initialization
+
+## Monitoring
+
+Check auto-pause status programmatically:
+
+```python
+from claude_mpm.hooks.claude_hooks.auto_pause_handler import AutoPauseHandler
+
+handler = AutoPauseHandler()
+status = handler.get_status()
+
+print(f"Context: {status['context_percentage']}%")
+print(f"Threshold: {status['threshold_reached']}")
+print(f"Pause active: {status['pause_active']}")
+
+if status.get('pause_details'):
+    print(f"Actions recorded: {status['pause_details']['action_count']}")
+```