claude-comms 1.0.46 → 2.0.1

package/.claude/hooks/comms/register_subagent.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">=3.8"
-# dependencies = [
-#     "requests",
-# ]
-# ///
-
-import json
-import sys
-import requests
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-
-def main():
-    try:
-        # Read JSON input from stdin
-        input_data = json.load(sys.stdin)
-        
-        session_id = input_data.get('session_id', 'unknown')
-        
-        # Check if this is a Task tool use and register the subagent
-        tool_name = input_data.get('tool_name', '')
-        tool_input = input_data.get('tool_input', {})
-        
-        if tool_name == 'Task':
-            description = tool_input.get('description', '')
-            subagent_type = tool_input.get('subagent_type', '')
-            initial_prompt = tool_input.get('prompt', '')
-            
-            # Extract nickname from description (part before colon)
-            if ':' in description:
-                nickname = description.split(':')[0].strip()
-                
-                # Register the subagent with the server
-                try:
-                    response = requests.post(
-                        f'{get_server_url()}/subagents/register',
-                        json={
-                            'session_id': session_id,
-                            'name': nickname,
-                            'subagent_type': subagent_type
-                        },
-                        timeout=2
-                    )
-                    if response.status_code == 200:
-                        print(f"Registered subagent: {nickname} ({subagent_type})", file=sys.stderr)
-                        
-                        # Now update with initial prompt using PATCH endpoint
-                        if initial_prompt:
-                            prompt_response = requests.patch(
-                                f'{get_server_url()}/subagents/{session_id}/{nickname}',
-                                json={'initial_prompt': initial_prompt},
-                                timeout=2
-                            )
-                            if prompt_response.status_code == 200:
-                                print(f"Stored initial prompt for subagent: {nickname}", file=sys.stderr)
-                except Exception as e:
-                    # Silently fail if server is not available
-                    pass
-        
-        sys.exit(0)
-        
-    except json.JSONDecodeError:
-        # Gracefully handle JSON decode errors
-        sys.exit(0)
-    except Exception:
-        # Handle any other errors gracefully
-        sys.exit(0)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/comms/send_message.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-
-import json
-import sys
-import requests
-import argparse
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-def send_message(sender_name, message):
-    """
-    Send a message from a subagent to all other subagents.
-    
-    Args:
-        sender_name: The name/nickname of the sending subagent
-        message: The message to send (can be string or dict)
-    
-    Returns:
-        True if message was sent successfully, False otherwise
-    """
-    try:
-        # Parse message if it's a JSON string
-        if isinstance(message, str):
-            try:
-                message = json.loads(message)
-            except json.JSONDecodeError:
-                # Keep as string if not valid JSON
-                pass
-        
-        response = requests.post(
-            f'{get_server_url()}/subagents/message',
-            json={
-                'sender': sender_name,
-                'message': message
-            },
-            timeout=5
-        )
-        
-        if response.status_code == 200:
-            return True
-        else:
-            print(f"Error: Server returned status {response.status_code}", file=sys.stderr)
-            return False
-            
-    except requests.exceptions.ConnectionError:
-        print(f"Error: Could not connect to observability server at {get_server_url()}", file=sys.stderr)
-        return False
-    except requests.exceptions.Timeout:
-        print("Error: Request timed out", file=sys.stderr)
-        return False
-    except Exception as e:
-        print(f"Error: {str(e)}", file=sys.stderr)
-        return False
-
-def main():
-    parser = argparse.ArgumentParser(description='Send a message from a subagent')
-    parser.add_argument('--sender', required=True, help='Sender subagent name/nickname')
-    parser.add_argument('--message', required=True, help='Message to send (string or JSON)')
-    parser.add_argument('--type', help='Message type (optional)')
-    parser.add_argument('--data', help='Additional data (JSON format)')
-    
-    args = parser.parse_args()
-    
-    # Build message structure if type is provided
-    if args.type:
-        message = {
-            'type': args.type,
-            'content': args.message
-        }
-        if args.data:
-            try:
-                message['data'] = json.loads(args.data)
-            except json.JSONDecodeError:
-                message['data'] = args.data
-    else:
-        message = args.message
-    
-    success = send_message(args.sender, message)
-    
-    if success:
-        print("Message sent successfully")
-    else:
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/comms/update_subagent_completion.py

@@ -1,126 +0,0 @@
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">=3.8"
-# dependencies = [
-#     "requests",
-# ]
-# ///
-
-import json
-import sys
-import requests
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-
-def main():
-    try:
-        # Read JSON input from stdin
-        input_data = json.load(sys.stdin)
-        
-        session_id = input_data.get('session_id', 'unknown')
-        
-        # Check if this is a Task tool use completion
-        tool_name = input_data.get('tool_name', '')
-        tool_input = input_data.get('tool_input', {})
-        tool_response = input_data.get('tool_response', {})
-        
-        if tool_name == 'Task':
-            description = tool_input.get('description', '')
-            
-            # Extract agent name from description (part before colon)
-            if ':' in description:
-                agent_name = description.split(':')[0].strip()
-                
-                # Extract completion metadata from tool_response
-                completion_metadata = {}
-                
-                # Get duration, tokens, and tool use count from tool_response
-                if 'totalDurationMs' in tool_response:
-                    completion_metadata['total_duration_ms'] = tool_response['totalDurationMs']
-                
-                if 'totalTokens' in tool_response:
-                    completion_metadata['total_tokens'] = tool_response['totalTokens']
-                
-                if 'totalToolUseCount' in tool_response:
-                    completion_metadata['total_tool_use_count'] = tool_response['totalToolUseCount']
-                
-                # Get usage details if available
-                usage = tool_response.get('usage', {})
-                if usage:
-                    if 'input_tokens' in usage:
-                        completion_metadata['input_tokens'] = usage['input_tokens']
-                    
-                    if 'output_tokens' in usage:
-                        completion_metadata['output_tokens'] = usage['output_tokens']
-                    
-                    if 'cache_creation_input_tokens' in usage:
-                        completion_metadata['cache_creation_input_tokens'] = usage['cache_creation_input_tokens']
-                    
-                    if 'cache_read_input_tokens' in usage:
-                        completion_metadata['cache_read_input_tokens'] = usage['cache_read_input_tokens']
-                
-                # Extract the agent's final response content
-                # The response content is typically in the main tool_response as text
-                final_response = ''
-                if 'content' in tool_response:
-                    # If content is a list (standard Claude format)
-                    if isinstance(tool_response['content'], list):
-                        text_blocks = [block.get('text', '') for block in tool_response['content'] if block.get('type') == 'text']
-                        final_response = '\n'.join(text_blocks)
-                    # If content is a string
-                    elif isinstance(tool_response['content'], str):
-                        final_response = tool_response['content']
-                elif 'text' in tool_response:
-                    # Alternative field name
-                    final_response = tool_response['text']
-                elif 'response' in tool_response:
-                    # Another possible field name
-                    final_response = tool_response['response']
-                
-                # Extract tool calls if available
-                tool_calls_data = []
-                if 'tool_calls' in tool_response:
-                    tool_calls_data = tool_response['tool_calls']
-                elif 'toolCalls' in tool_response:
-                    tool_calls_data = tool_response['toolCalls']
-                
-                # Update subagent completion status
-                try:
-                    response = requests.post(
-                        f'{get_server_url()}/subagents/update-completion',
-                        json={
-                            'session_id': session_id,
-                            'name': agent_name,
-                            'status': 'completed',
-                            'completed_at': None,  # Will be set to current time by server
-                            'completion_metadata': completion_metadata,
-                            'final_response': final_response,
-                            'tool_calls': tool_calls_data
-                        },
-                        timeout=2
-                    )
-                    if response.status_code == 200:
-                        print(f"Updated completion for subagent: {agent_name}", file=sys.stderr)
-                    elif response.status_code == 404:
-                        # Agent not found, silently ignore (might be a direct Task not created by subagent)
-                        pass
-                    else:
-                        # Other error, log but don't fail
-                        print(f"Failed to update completion for {agent_name}: {response.status_code}", file=sys.stderr)
-                except Exception as e:
-                    # Silently fail if server is not available
-                    pass
-        
-        sys.exit(0)
-        
-    except json.JSONDecodeError:
-        # Gracefully handle JSON decode errors
-        sys.exit(0)
-    except Exception:
-        # Handle any other errors gracefully
-        sys.exit(0)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/context/session_id.py

@@ -1,35 +0,0 @@
-#!/usr/bin/env python3
-# UserPromptSubmit hook to inject context into the conversation
-
-import json
-import sys
-# NOTE: this ONLY works for userPromptSubmit hook, no other hooks are supported.
-def main():
-    try:
-        # Read JSON input from stdin
-        input_data = json.load(sys.stdin)
-        
-        # Extract the user's prompt
-
-        session_id = input_data.get('session_id', 'unknown')
-        
-        # Create additional context that will be injected
-        additional_context = "Your session_id is: {session_id}"
-        
-
-        output = {
-            "hookSpecificOutput": {
-                "hookEventName": "UserPromptSubmit",
-                "additionalContext": additional_context
-            }
-        }
-        print(json.dumps(output))
-        sys.exit(0)
-        
-    except Exception as e:
-        # On error, show to user but don't block
-        print(f"Error in UserPromptSubmit hook: {e}", file=sys.stderr)
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/observability/send_event.py

@@ -1,110 +0,0 @@
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">=3.8"
-# ///
-
-"""
-Multi-Agent Observability Hook Script
-Sends Claude Code hook events to the observability server.
-"""
-
-import json
-import sys
-import os
-import argparse
-import urllib.request
-import urllib.error
-from datetime import datetime
-
-# Add parent directory to path for imports
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-def send_event_to_server(event_data, server_url=None):
-    """Send event data to the observability server."""
-    if server_url is None:
-        server_url = f'{get_server_url()}/events'
-    
-    try:
-        # Prepare the request
-        req = urllib.request.Request(
-            server_url,
-            data=json.dumps(event_data).encode('utf-8'),
-            headers={
-                'Content-Type': 'application/json',
-                'User-Agent': 'Claude-Code-Hook/1.0'
-            }
-        )
-        
-        # Send the request
-        with urllib.request.urlopen(req, timeout=5) as response:
-            if response.status == 200:
-                return True
-            else:
-                print(f"Server returned status: {response.status}", file=sys.stderr)
-                return False
-                
-    except urllib.error.URLError as e:
-        print(f"Failed to send event: {e}", file=sys.stderr)
-        return False
-    except Exception as e:
-        print(f"Unexpected error: {e}", file=sys.stderr)
-        return False
-
-def main():
-    # Parse command line arguments
-    parser = argparse.ArgumentParser(description='Send Claude Code hook events to observability server')
-    parser.add_argument('--source-app', required=True, help='Source application name')
-    parser.add_argument('--event-type', required=True, help='Hook event type (PreToolUse, PostToolUse, etc.)')
-    parser.add_argument('--add-chat', action='store_true', help='Include chat transcript if available')
-    parser.add_argument('--summarize', action='store_true', help='Generate AI summary of the event')
-    
-    args = parser.parse_args()
-    
-    try:
-        # Read hook data from stdin
-        input_data = json.load(sys.stdin)
-    except json.JSONDecodeError as e:
-        print(f"Failed to parse JSON input: {e}", file=sys.stderr)
-        sys.exit(1)
-    
-    # Prepare event data for server
-    event_data = {
-        'source_app': args.source_app,
-        'session_id': input_data.get('session_id', 'unknown'),
-        'hook_event_type': args.event_type,
-        'payload': input_data,
-        'timestamp': int(datetime.now().timestamp() * 1000)
-    }
-    
-    # Handle --add-chat option
-    if args.add_chat and 'transcript_path' in input_data:
-        transcript_path = input_data['transcript_path']
-        if os.path.exists(transcript_path):
-            # Read .jsonl file and convert to JSON array
-            chat_data = []
-            try:
-                with open(transcript_path, 'r') as f:
-                    for line in f:
-                        line = line.strip()
-                        if line:
-                            try:
-                                chat_data.append(json.loads(line))
-                            except json.JSONDecodeError:
-                                pass  # Skip invalid lines
-                
-                # Add chat to event data
-                event_data['chat'] = chat_data
-            except Exception as e:
-                print(f"Failed to read transcript: {e}", file=sys.stderr)
-    
-    
-    # Send to server
-    server_url = f'{get_server_url()}/events'
-    success = send_event_to_server(event_data, server_url)
-    
-    # Always exit with 0 to not block Claude Code operations
-    sys.exit(0)
-
-if __name__ == '__main__':
-    main()

package/.claude/hooks/session-data/get_session_data.py

@@ -1,261 +0,0 @@
-#!/usr/bin/env python3
-"""
-Session Data Fetching Script - Token-based pagination for introspect API
-
-Usage:
-    python get_session_data.py --session-id <session_id> [--page <page_number>]
-
-Author: RafaelQuantum
-Date: 2025-08-20
-"""
-
-import json
-import sys
-import argparse
-import requests
-import time
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from utils.server_config import get_server_url
-
-# Maximum tokens per page (easily configurable)
-MAX_TOKENS_PER_PAGE = 6000
-
-try:
-    import tiktoken
-except ImportError:
-    print("Error: tiktoken not installed. Run: pip install tiktoken", file=sys.stderr)
-    sys.exit(1)
-
-
-def count_tokens(json_object, encoding):
-    """
-    Count tokens for a JSON object.
-    Converts object to JSON string and counts tokens.
-    """
-    json_str = json.dumps(json_object, separators=(',', ':'))
-    return len(encoding.encode(json_str))
-
-
-def paginate_timeline(timeline, page, max_tokens=MAX_TOKENS_PER_PAGE):
-    """
-    Paginate timeline messages into chunks that fit within max_tokens.
-    Returns the messages for the requested page or None if out of range.
-    Uses tiktoken for accurate token counting, including JSON structure overhead.
-    """
-    if not timeline:
-        return timeline if page == 1 else None
-    
-    # Get the encoding for token counting (cl100k_base for GPT-3.5/4)
-    try:
-        encoding = tiktoken.get_encoding("cl100k_base")
-    except Exception as e:
-        print(f"Error initializing tiktoken: {e}", file=sys.stderr)
-        # Fallback to character-based if tiktoken fails
-        return paginate_timeline_fallback(timeline, page)
-    
-    # Calculate overhead for the JSON structure
-    # {"sessionId": "...", "timeline": [...], "page": N}
-    session_id = "8d90abf7-bd33-4367-985c-b5acb886a63a"  # Example ID for overhead calculation
-    overhead_json = {
-        "sessionId": session_id,
-        "timeline": [],
-        "page": 1
-    }
-    overhead_tokens = len(encoding.encode(json.dumps(overhead_json, separators=(',', ':'))))
-    
-    pages = []
-    current_page = []
-    current_tokens = overhead_tokens  # Start with JSON structure overhead
-    
-    for message in timeline:
-        message_tokens = count_tokens(message, encoding)
-        # Add tokens for comma separator if not first message
-        separator_tokens = 1 if current_page else 0
-        
-        # Check if adding this message would exceed the limit
-        total_with_message = current_tokens + separator_tokens + message_tokens
-        
-        if total_with_message > max_tokens:
-            if current_page:
-                # Save current page and start new one
-                pages.append(current_page)
-                current_page = [message]
-                current_tokens = overhead_tokens + message_tokens
-            else:
-                # Single message exceeds limit, but we need to include it
-                current_page = [message]
-                current_tokens = overhead_tokens + message_tokens
-        else:
-            # Add to current page (within limit)
-            current_page.append(message)
-            current_tokens = total_with_message
-    
-    # Add the last page if it has content
-    if current_page:
-        pages.append(current_page)
-    
-    # Return requested page or None if out of range
-    if page > 0 and page <= len(pages):
-        return pages[page - 1]
-    else:
-        return None
-
-
-def get_total_pages(timeline, max_tokens=MAX_TOKENS_PER_PAGE):
-    """
-    Calculate total number of pages by checking when paginate returns None.
-    """
-    if not timeline:
-        return 1
-    
-    page = 1
-    while paginate_timeline(timeline, page, max_tokens) is not None:
-        page += 1
-    
-    return page - 1
-
-
-def paginate_timeline_fallback(timeline, page, max_chars=30000):
-    """
-    Fallback character-based pagination if tiktoken is unavailable.
-    """
-    if not timeline:
-        return timeline if page == 1 else None
-    
-    pages = []
-    current_page = []
-    current_size = 100
-    
-    for message in timeline:
-        message_json = json.dumps(message, indent=2)
-        message_size = len(message_json) + 5
-        
-        if current_size + message_size > max_chars and current_page:
-            pages.append(current_page)
-            current_page = [message]
-            current_size = 100 + message_size
-        else:
-            current_page.append(message)
-            current_size += message_size
-    
-    if current_page:
-        pages.append(current_page)
-    
-    if page > 0 and page <= len(pages):
-        return pages[page - 1]
-    else:
-        return None
-
-
-def main():
-    """Main entry point - fetch and return paginated JSON."""
-    parser = argparse.ArgumentParser(
-        description='Fetch session data from Claude Code observability API with pagination'
-    )
-    
-    parser.add_argument(
-        '--session-id',
-        required=True,
-        help='Session ID to fetch data for'
-    )
-    
-    parser.add_argument(
-        '--page',
-        type=int,
-        default=1,
-        help='Page number to fetch (default: 1)'
-    )
-    
-    parser.add_argument(
-        '--total-pages',
-        action='store_true',
-        help='Return only the total number of pages instead of page data'
-    )
-    
-    args = parser.parse_args()
-    
-    # Wait 100ms per page before hitting the DB (as requested)
-    if args.page > 1:
-        time.sleep(args.page * 0.1)
-    
-    try:
-        # Fetch the data from API
-        api_base = get_server_url()
-        url = f"{api_base}/api/sessions/{args.session_id}/introspect"
-        response = requests.get(url, timeout=10)
-        
-        if response.status_code == 200:
-            data = response.json()
-            
-            # If --total-pages flag is set, return only the total page count
-            if args.total_pages:
-                if 'timeline' in data and data['timeline']:
-                    total = get_total_pages(data['timeline'])
-                    print(total)
-                else:
-                    print(1)
-                sys.exit(0)
-            
-            # Handle pagination if timeline exists
-            if 'timeline' in data and data['timeline']:
-                paginated_timeline = paginate_timeline(data['timeline'], args.page)
-                
-                if paginated_timeline is None:
-                    # Page out of range
-                    print("//end")
-                    sys.exit(0)
-                else:
-                    # Return paginated data
-                    paginated_data = {
-                        'sessionId': data.get('sessionId'),
-                        'timeline': paginated_timeline,
-                        'page': args.page
-                    }
-                    print(json.dumps(paginated_data, indent=2))
-                    sys.exit(0)
-            else:
-                # No timeline or empty timeline
-                if args.page == 1:
-                    print(json.dumps(data, indent=2))
-                else:
-                    print("//end")
-                sys.exit(0)
-        else:
-            # Error case
-            error_data = {
-                'error': f'API returned status {response.status_code}',
-                'status_code': response.status_code,
-                'session_id': args.session_id
-            }
-            print(json.dumps(error_data, indent=2), file=sys.stderr)
-            sys.exit(1)
-            
-    except requests.exceptions.ConnectionError:
-        api_base = get_server_url()
-        error_data = {
-            'error': f'Could not connect to API server at {api_base}',
-            'status_code': 0
-        }
-        print(json.dumps(error_data, indent=2), file=sys.stderr)
-        sys.exit(1)
-    
-    except requests.exceptions.Timeout:
-        error_data = {
-            'error': 'Request timeout',
-            'status_code': 0
-        }
-        print(json.dumps(error_data, indent=2), file=sys.stderr)
-        sys.exit(1)
-    
-    except Exception as e:
-        error_data = {
-            'error': f'Unexpected error: {str(e)}',
-            'status_code': 0
-        }
-        print(json.dumps(error_data, indent=2), file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    main()