htmlgraph 0.20.0__tar.gz → 0.20.2__tar.gz

{htmlgraph-0.20.0 → htmlgraph-0.20.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgraph
-Version: 0.20.0
+Version: 0.20.2
 Summary: HTML is All You Need - Graph database on web standards
 Project-URL: Homepage, https://github.com/Shakes-tzd/htmlgraph
 Project-URL: Documentation, https://github.com/Shakes-tzd/htmlgraph#readme

{htmlgraph-0.20.0 → htmlgraph-0.20.2}/packages/gemini-extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "htmlgraph",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "description": "HtmlGraph session tracking and documentation for Gemini CLI. Ensures proper activity attribution, feature awareness, and continuous work tracking.",
   "author": "Shakes",
   "license": "MIT",

{htmlgraph-0.20.0 → htmlgraph-0.20.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "htmlgraph"
-version = "0.20.0"
+version = "0.20.2"
 description = "HTML is All You Need - Graph database on web standards"
 authors = [{name = "Shakes", email = "shakestzd@gmail.com"}]
 readme = "README.md"

{htmlgraph-0.20.0 → htmlgraph-0.20.2}/src/python/htmlgraph/__init__.py

@@ -84,7 +84,7 @@ from htmlgraph.types import (
 )
 from htmlgraph.work_type_utils import infer_work_type, infer_work_type_from_id
 
-__version__ = "0.20.0"
+__version__ = "0.20.2"
 __all__ = [
     # Exceptions
     "HtmlGraphError",

{htmlgraph-0.20.0 → htmlgraph-0.20.2}/src/python/htmlgraph/hooks/post_tool_use_failure.py

@@ -29,19 +29,63 @@ def run(hook_input: dict[str, Any]) -> dict[str, Any]:
 
     Args:
         hook_input: Hook input containing:
-            - tool/name: Tool name that failed
-            - error: Error message
+            - name: Tool name that failed
+            - result: Tool result (may contain error field)
             - session_id: Current session ID
 
     Returns:
         Standard hook response: {"continue": True}
     """
     try:
-        # Extract error information
-        tool_name = hook_input.get("tool") or hook_input.get("name", "unknown")
-        error_msg = hook_input.get("error", "No error message")
+        # DEBUG: Log raw hook input to understand structure
+        debug_log = Path(".htmlgraph/hook-debug.jsonl")
+        debug_log.parent.mkdir(parents=True, exist_ok=True)
+        with open(debug_log, "a") as f:
+            f.write(
+                json.dumps(
+                    {
+                        "raw_input": hook_input,
+                        "keys": list(hook_input.keys()),
+                        "ts": datetime.now().isoformat(),
+                    }
+                )
+                + "\n"
+            )
+
+        # Extract error information from PostToolUse hook format
+        # Official PostToolUse uses: tool_name, tool_response
+        # Custom hooks may use: name, result
+        tool_name = hook_input.get("tool_name") or hook_input.get("name", "unknown")
         session_id = hook_input.get("session_id", "unknown")
 
+        # Error message can be in different places depending on tool
+        error_msg = "No error message"
+
+        # Check tool_response field first (official PostToolUse format)
+        # Then check result field (custom hook format)
+        result = hook_input.get("tool_response") or hook_input.get("result", {})
+        if isinstance(result, dict):
+            if "error" in result:
+                error_msg = result["error"]
+            elif "message" in result:
+                error_msg = result["message"]
+        elif isinstance(result, str):
+            # Sometimes the error is directly in the result as a string
+            error_msg = result
+
+        # Fallback: check top-level error field
+        if error_msg == "No error message" and "error" in hook_input:
+            error_msg = hook_input["error"]
+
+        # Last resort: stringify the result if it contains error indicators
+        if error_msg == "No error message" and result:
+            result_str = str(result).lower()
+            if any(
+                indicator in result_str
+                for indicator in ["error", "failed", "exception"]
+            ):
+                error_msg = str(result)[:500]  # Truncate to 500 chars
+
         # Track error in file-based storage
         error_log = Path(".htmlgraph/errors.jsonl")
         error_log.parent.mkdir(parents=True, exist_ok=True)

{htmlgraph-0.20.0 → htmlgraph-0.20.2}/src/python/htmlgraph/hooks/posttooluse.py

@@ -119,6 +119,8 @@ async def run_error_tracking(hook_input: dict[str, Any]) -> dict[str, Any]:
     """
     Track errors to .htmlgraph/errors.jsonl and auto-create debug spikes.
 
+    Only tracks ACTUAL errors, not responses containing the word "error".
+
     Args:
         hook_input: Hook input with tool execution details
 
@@ -128,23 +130,26 @@ async def run_error_tracking(hook_input: dict[str, Any]) -> dict[str, Any]:
     try:
         loop = asyncio.get_event_loop()
 
-        # Check if this is an error (check for error field or non-zero exit code)
+        # Check if this is an ACTUAL error
         has_error = False
-        tool_response = hook_input.get("result", {}) or hook_input.get(
-            "tool_response", {}
-        )
+        tool_response = hook_input.get("tool_response") or hook_input.get("result", {})
+
+        if isinstance(tool_response, dict):
+            # Bash: non-empty stderr indicates error
+            stderr = tool_response.get("stderr", "")
+            if stderr and isinstance(stderr, str) and stderr.strip():
+                has_error = True
 
-        # Check for explicit error field
-        if "error" in tool_response or hook_input.get("error"):
-            has_error = True
+            # Explicit error field with content
+            error_field = tool_response.get("error")
+            if error_field and str(error_field).strip():
+                has_error = True
 
-        # Check for error indicators in response text
-        response_text = str(tool_response).lower()
-        error_indicators = ["error", "failed", "exception", "traceback", "errno"]
-        if any(indicator in response_text for indicator in error_indicators):
-            has_error = True
+            # success=false flag
+            if tool_response.get("success") is False:
+                has_error = True
 
-        # Only track if there's an error
+        # Only track if there's an actual error
         if has_error:
             return await loop.run_in_executor(
                 None,
@@ -162,6 +167,9 @@ async def suggest_debugging_resources(hook_input: dict[str, Any]) -> dict[str, A
     """
     Suggest debugging resources based on tool results.
 
+    Only triggers on ACTUAL errors, not on responses that happen to contain
+    the word "error" in their content.
+
     Args:
         hook_input: Hook input with tool execution details
 
@@ -176,11 +184,24 @@ async def suggest_debugging_resources(hook_input: dict[str, Any]) -> dict[str, A
 
         suggestions = []
 
-        # Check for error indicators in response
-        response_text = str(tool_response).lower()
-        error_indicators = ["error", "failed", "exception", "traceback", "errno"]
+        # Check for ACTUAL errors (not just text containing "error")
+        has_actual_error = False
+
+        if isinstance(tool_response, dict):
+            # Bash: non-empty stderr indicates error
+            stderr = tool_response.get("stderr", "")
+            if stderr and isinstance(stderr, str) and stderr.strip():
+                has_actual_error = True
+
+            # Explicit error field
+            if tool_response.get("error"):
+                has_actual_error = True
+
+            # success=false flag
+            if tool_response.get("success") is False:
+                has_actual_error = True
 
-        if any(indicator in response_text for indicator in error_indicators):
+        if has_actual_error:
             suggestions.append("⚠️ Error detected in tool response")
             suggestions.append("Debugging resources:")
             suggestions.append("  📚 DEBUGGING.md - Systematic debugging guide")

{htmlgraph-0.20.0 → htmlgraph-0.20.2}/tests/python/test_post_tool_use_failure.py

@@ -23,8 +23,8 @@ def mock_htmlgraph_dir(tmp_path, monkeypatch):
 def test_error_logging(mock_htmlgraph_dir):
     """Test that errors are logged to file."""
     hook_input = {
-        "tool": "Bash",
-        "error": "Command failed with exit code 1",
+        "name": "Bash",
+        "result": {"error": "Command failed with exit code 1"},
         "session_id": "test-session",
     }
 
@@ -44,10 +44,10 @@ def test_error_logging(mock_htmlgraph_dir):
 
 
 def test_error_logging_with_name_field(mock_htmlgraph_dir):
-    """Test that errors are logged when using 'name' field instead of 'tool'."""
+    """Test that errors are logged when using PostToolUse format with result.error."""
     hook_input = {
         "name": "Read",
-        "error": "File not found",
+        "result": {"error": "File not found"},
         "session_id": "test-session-2",
     }
 
@@ -245,8 +245,8 @@ def test_hook_never_blocks(mock_htmlgraph_dir):
         f.write("invalid json\n")
 
     hook_input = {
-        "tool": "Bash",
-        "error": "test error",
+        "name": "Bash",
+        "result": {"error": "test error"},
         "session_id": "test",
     }
 
@@ -271,8 +271,8 @@ def test_integration_with_auto_spike_creation(mock_htmlgraph_dir):
         mock_sdk_class.return_value = mock_sdk
 
         hook_input = {
-            "tool": "Edit",
-            "error": "Pattern matching failed",
+            "name": "Edit",
+            "result": {"error": "Pattern matching failed"},
             "session_id": "integration-test",
         }
 
@@ -291,8 +291,8 @@ def test_error_log_creates_directory(tmp_path, monkeypatch):
     monkeypatch.chdir(tmp_path)
 
     hook_input = {
-        "tool": "Test",
-        "error": "test error",
+        "name": "Test",
+        "result": {"error": "test error"},
         "session_id": "test",
     }