@rulemetric/proxy 0.2.2

package/Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.12-slim
+
+# Install mitmproxy (pinned version for supply chain safety)
+RUN pip install --no-cache-dir mitmproxy==11.0.2
+
+# Copy addon scripts
+WORKDIR /app
+COPY addon/ ./addon/
+
+# mitmproxy generates CA certs on first run — persist them via volume
+VOLUME /root/.mitmproxy
+
+# Proxy listens on 8787
+EXPOSE 8787
+
+# Environment (override at runtime)
+ENV RULEMETRIC_API_URL=http://host.docker.internal:3000
+ENV RULEMETRIC_PROJECT_PATH=""
+ENV RULEMETRIC_API_KEY=""
+ENV RULEMETRIC_ACCESS_TOKEN=""
+
+# Only intercept known LLM provider domains (not all HTTPS traffic)
+ENTRYPOINT ["mitmdump", \
+  "--listen-host", "0.0.0.0", \
+  "--listen-port", "8787", \
+  "--set", "console_eventlog_verbosity=info", \
+  "--allow-hosts", "api.anthropic.com|api.openai.com|generativelanguage.googleapis.com|bedrock-runtime.*.amazonaws.com", \
+  "-s", "/app/addon/rulemetric_addon.py"]

package/addon/context_classifier.py

@@ -0,0 +1,375 @@
+"""Classify context items from an LLM API request snapshot.
+
+Walks system prompt, messages_raw, and tools to produce a typed inventory
+of every piece of injected context (CLAUDE.md, skills, memory, hooks, etc.).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from typing import Any
+
+
+def _hash(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def _estimate_tokens(text: str) -> int:
+    return max(1, len(text) // 4)
+
+
+# ---------------------------------------------------------------------------
+# Pattern matchers for system-reminder classification
+# ---------------------------------------------------------------------------
+
+# CLAUDE.md files: "Contents of /path/to/CLAUDE.md"
+_CLAUDE_MD_RE = re.compile(
+    r"Contents of (.*?CLAUDE\.md)\s.*?instructions",
+    re.IGNORECASE | re.DOTALL,
+)
+
+# Memory files: "Contents of /...memory/MEMORY.md" or individual memory files
+_MEMORY_RE = re.compile(
+    r"Contents of (.*?/memory/\S+)",
+    re.IGNORECASE,
+)
+
+# Skill catalog: block that lists available skills with "- skill-name: description"
+_SKILL_CATALOG_RE = re.compile(
+    r"following skills are available.*?:\s*\n",
+    re.IGNORECASE | re.DOTALL,
+)
+
+# Individual skill entry in catalog: "- name: description"
+_SKILL_ENTRY_RE = re.compile(r"^- ([\w:.-]+): .+", re.MULTILINE)
+
+# Git status block
+_GIT_STATUS_RE = re.compile(r"gitStatus:", re.IGNORECASE)
+
+# Deferred tools listing
+_DEFERRED_TOOLS_RE = re.compile(
+    r"<available-deferred-tools>",
+    re.IGNORECASE,
+)
+
+# Date change reminder
+_DATE_CHANGE_RE = re.compile(
+    r"The date has changed\. Today.s date is now",
+    re.IGNORECASE,
+)
+
+# Task tools reminder
+_TASK_REMINDER_RE = re.compile(
+    r"task tools haven.t been used recently",
+    re.IGNORECASE,
+)
+
+# currentDate block
+_CURRENT_DATE_RE = re.compile(r"# currentDate", re.IGNORECASE)
+
+# Skill tool use: assistant calls Skill tool
+_SKILL_TOOL_USE_RE = re.compile(r'"name"\s*:\s*"Skill"', re.IGNORECASE)
+
+
+def classify_system_reminder(text: str) -> dict[str, Any]:
+    """Classify a single <system-reminder> block by content pattern."""
+    item: dict[str, Any] = {
+        "type": "system_reminder",
+        "name": "unknown_reminder",
+        "content_hash": _hash(text),
+        "char_count": len(text),
+        "estimated_tokens": _estimate_tokens(text),
+    }
+
+    # CLAUDE.md
+    m = _CLAUDE_MD_RE.search(text)
+    if m:
+        item["type"] = "claude_md"
+        item["name"] = m.group(1).strip()
+        return item
+
+    # Memory
+    m = _MEMORY_RE.search(text)
+    if m:
+        item["type"] = "memory"
+        item["name"] = m.group(1).strip()
+        return item
+
+    # Skill catalog
+    if _SKILL_CATALOG_RE.search(text):
+        item["type"] = "skill_catalog"
+        item["name"] = "available_skills"
+        # Extract individual skill names
+        entries = _SKILL_ENTRY_RE.findall(text)
+        if entries:
+            item["skill_names"] = entries
+        return item
+
+    # Git status
+    if _GIT_STATUS_RE.search(text):
+        item["type"] = "git_context"
+        item["name"] = "git_status"
+        return item
+
+    # Date change
+    if _DATE_CHANGE_RE.search(text):
+        item["type"] = "hook_output"
+        item["name"] = "date_change"
+        return item
+
+    # Task reminder
+    if _TASK_REMINDER_RE.search(text):
+        item["type"] = "hook_output"
+        item["name"] = "task_reminder"
+        return item
+
+    # currentDate
+    if _CURRENT_DATE_RE.search(text):
+        item["type"] = "hook_output"
+        item["name"] = "current_date"
+        return item
+
+    return item
+
+
+def classify_deferred_tools(text: str) -> dict[str, Any] | None:
+    """Check if text contains <available-deferred-tools> and classify it."""
+    if "<available-deferred-tools>" not in text:
+        return None
+    return {
+        "type": "deferred_tools",
+        "name": "available_deferred_tools",
+        "content_hash": _hash(text),
+        "char_count": len(text),
+        "estimated_tokens": _estimate_tokens(text),
+    }
+
+
+def extract_skill_loads(messages_raw: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Find Skill tool_use calls and their results in messages_raw.
+
+    Returns context items for each loaded skill, with the triggering user prompt.
+    """
+    items: list[dict[str, Any]] = []
+
+    for i, msg in enumerate(messages_raw):
+        role = msg.get("role", "")
+        content = msg.get("content")
+
+        if role != "assistant" or not isinstance(content, list):
+            continue
+
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            if block.get("type") != "tool_use" or block.get("name") != "Skill":
+                continue
+
+            tool_use_id = block.get("id", "")
+            skill_input = block.get("input", {})
+            skill_name = skill_input.get("skill", "unknown")
+
+            # Find the triggering user prompt: walk backwards from this message
+            triggered_by = ""
+            for j in range(i - 1, -1, -1):
+                prev = messages_raw[j]
+                if prev.get("role") != "user":
+                    continue
+                prev_content = prev.get("content", "")
+                if isinstance(prev_content, str):
+                    triggered_by = prev_content[:500]
+                    break
+                if isinstance(prev_content, list):
+                    # Skip tool_result blocks, find actual user text
+                    has_tool_result = any(
+                        isinstance(b, dict) and b.get("type") == "tool_result"
+                        for b in prev_content
+                    )
+                    if has_tool_result:
+                        continue
+                    texts = [
+                        b.get("text", "")
+                        for b in prev_content
+                        if isinstance(b, dict) and b.get("type") == "text"
+                    ]
+                    if texts:
+                        triggered_by = "\n".join(texts)[:500]
+                        break
+                break
+
+            # Find the tool_result and accompanying skill body text
+            skill_content = ""
+            for j in range(i + 1, len(messages_raw)):
+                next_msg = messages_raw[j]
+                if next_msg.get("role") != "user":
+                    continue
+                next_content = next_msg.get("content")
+                if not isinstance(next_content, list):
+                    continue
+                found_tool_result = False
+                skill_body_parts: list[str] = []
+                for nb in next_content:
+                    if not isinstance(nb, dict):
+                        continue
+                    if nb.get("type") == "tool_result" and nb.get("tool_use_id") == tool_use_id:
+                        found_tool_result = True
+                    elif nb.get("type") == "text" and found_tool_result:
+                        # Text blocks after the tool_result contain the loaded skill body
+                        skill_body_parts.append(nb.get("text", ""))
+                if found_tool_result:
+                    # Prefer skill body text over tool_result launch message
+                    if skill_body_parts:
+                        skill_content = "\n".join(skill_body_parts)
+                    else:
+                        # Fallback: extract from tool_result content itself
+                        for nb in next_content:
+                            if not isinstance(nb, dict):
+                                continue
+                            if nb.get("type") == "tool_result" and nb.get("tool_use_id") == tool_use_id:
+                                tr_content = nb.get("content", "")
+                                if isinstance(tr_content, str):
+                                    skill_content = tr_content
+                                elif isinstance(tr_content, list):
+                                    parts = [
+                                        b.get("text", "")
+                                        for b in tr_content
+                                        if isinstance(b, dict) and b.get("type") == "text"
+                                    ]
+                                    skill_content = "\n".join(parts)
+                                break
+                    break
+                break
+
+            item: dict[str, Any] = {
+                "type": "skill_loaded",
+                "name": skill_name,
+                "content_hash": _hash(skill_content) if skill_content else "",
+                "char_count": len(skill_content),
+                "estimated_tokens": _estimate_tokens(skill_content) if skill_content else 0,
+                "message_index": i,
+            }
+            if triggered_by:
+                item["triggered_by"] = triggered_by
+
+            items.append(item)
+
+    return items
+
+
+def extract_user_prompt(messages_raw: list[dict[str, Any]]) -> dict[str, Any] | None:
+    """Extract the last actual user prompt (not a tool_result) from messages_raw."""
+    for msg in reversed(messages_raw):
+        if msg.get("role") != "user":
+            continue
+
+        content = msg.get("content", "")
+
+        # String content = direct user message
+        if isinstance(content, str):
+            return {
+                "type": "user_prompt",
+                "name": "user_input",
+                "content_hash": _hash(content),
+                "char_count": len(content),
+                "estimated_tokens": _estimate_tokens(content),
+                "preview": content[:200],
+            }
+
+        # Array content — skip if it's only tool_results
+        if isinstance(content, list):
+            has_tool_result = any(
+                isinstance(b, dict) and b.get("type") == "tool_result"
+                for b in content
+            )
+            if has_tool_result:
+                continue
+
+            texts = [
+                b.get("text", "")
+                for b in content
+                if isinstance(b, dict) and b.get("type") == "text"
+            ]
+            if texts:
+                full = "\n".join(texts)
+                return {
+                    "type": "user_prompt",
+                    "name": "user_input",
+                    "content_hash": _hash(full),
+                    "char_count": len(full),
+                    "estimated_tokens": _estimate_tokens(full),
+                    "preview": full[:200],
+                }
+
+    return None
+
+
+def classify_context(snapshot: dict[str, Any]) -> list[dict[str, Any]]:
+    """Produce a full context inventory from a parsed snapshot.
+
+    Args:
+        snapshot: A snapshot dict with system_prompt, messages, messages_raw,
+                  tools, and injected_instructions fields.
+
+    Returns:
+        List of context item dicts, each with at minimum:
+          type, name, content_hash, char_count, estimated_tokens
+    """
+    items: list[dict[str, Any]] = []
+
+    # 1. System prompt (core LLM instructions)
+    system_prompt = snapshot.get("system_prompt", "")
+    if system_prompt:
+        items.append({
+            "type": "system_prompt",
+            "name": "core_system_prompt",
+            "content_hash": _hash(system_prompt),
+            "char_count": len(system_prompt),
+            "estimated_tokens": _estimate_tokens(system_prompt),
+        })
+
+    # 2. Classify each system-reminder block
+    #    Store instruction_index so the UI can look up the full content
+    #    from injected_instructions without duplicating it here.
+    for idx, reminder_text in enumerate(snapshot.get("injected_instructions", [])):
+        item = classify_system_reminder(reminder_text)
+        item["instruction_index"] = idx
+        items.append(item)
+
+    # 3. Deferred tools blocks (in messages, outside system-reminders)
+    for msg in snapshot.get("messages", []):
+        content = msg.get("content", "")
+        if "<available-deferred-tools>" in content:
+            dt_item = classify_deferred_tools(content)
+            if dt_item:
+                items.append(dt_item)
+
+    # 4. Skill tool_use loads from messages_raw
+    messages_raw = snapshot.get("messages_raw", [])
+    skill_items = extract_skill_loads(messages_raw)
+    items.extend(skill_items)
+
+    # 5. Tool definitions summary
+    tools = snapshot.get("tools", [])
+    if tools:
+        tool_names = [t.get("name", "") for t in tools if isinstance(t, dict)]
+        tool_blob = ",".join(sorted(tool_names))
+        items.append({
+            "type": "tool_definitions",
+            "name": "available_tools",
+            "content_hash": _hash(tool_blob),
+            "char_count": sum(
+                len(str(t)) for t in tools
+            ),
+            "estimated_tokens": sum(
+                _estimate_tokens(str(t)) for t in tools
+            ),
+            "tool_names": tool_names,
+        })
+
+    # 6. Last user prompt
+    user_prompt = extract_user_prompt(messages_raw)
+    if user_prompt:
+        items.append(user_prompt)
+
+    return items