gobby 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

gobby/workflows/state_actions.py

@@ -4,8 +4,12 @@ Extracted from actions.py as part of strangler fig decomposition.
 These functions handle workflow state persistence and variable management.
 """
 
+import asyncio
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.workflows.actions import ActionContext
 
 logger = logging.getLogger(__name__)
 
@@ -121,3 +125,58 @@ def mark_loop_complete(state: Any) -> dict[str, Any]:
         state.variables = {}
     state.variables["stop_reason"] = "completed"
     return {"loop_marked_complete": True}
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+
+async def handle_load_workflow_state(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for load_workflow_state."""
+    return await asyncio.to_thread(
+        load_workflow_state, context.db, context.session_id, context.state
+    )
+
+
+async def handle_save_workflow_state(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for save_workflow_state."""
+    return await asyncio.to_thread(save_workflow_state, context.db, context.state)
+
+
+async def handle_set_variable(context: "ActionContext", **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for set_variable.
+
+    Values containing Jinja2 templates ({{ ... }}) are rendered before setting.
+    """
+    value = kwargs.get("value")
+
+    # Render template if value contains Jinja2 syntax
+    if isinstance(value, str) and "{{" in value:
+        template_context = {
+            "variables": context.state.variables or {},
+            "state": context.state,
+        }
+        if context.template_engine:
+            value = context.template_engine.render(value, template_context)
+        else:
+            logger.warning("handle_set_variable: template_engine is None, skipping template render")
+
+    return set_variable(context.state, kwargs.get("name"), value)
+
+
+async def handle_increment_variable(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for increment_variable."""
+    return increment_variable(context.state, kwargs.get("name"), kwargs.get("amount", 1))
+
+
+async def handle_mark_loop_complete(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for mark_loop_complete."""
+    return mark_loop_complete(context.state)

gobby/workflows/stop_signal_actions.py

@@ -161,3 +161,58 @@ def clear_stop_signal(
 
     cleared = stop_registry.clear(session_id)
     return {"success": True, "cleared": cleared}
+
+
+# --- ActionHandler factory functions ---
+# These create ActionHandler-compatible wrappers that close over the stop_registry.
+# The ActionExecutor calls these factories in _register_defaults() to create handlers
+# that have access to the executor's stop_registry instance.
+
+
+def make_handle_check_stop_signal(
+    stop_registry: "StopRegistry | None",
+) -> Any:
+    """Factory that creates a check_stop_signal handler with access to stop_registry."""
+
+    async def handler(context: "Any", **kwargs: Any) -> dict[str, Any] | None:
+        """ActionHandler for check_stop_signal."""
+        return check_stop_signal(
+            stop_registry=stop_registry,
+            session_id=context.session_id,
+            state=context.state,
+            acknowledge=kwargs.get("acknowledge", False),
+        )
+
+    return handler
+
+
+def make_handle_request_stop(
+    stop_registry: "StopRegistry | None",
+) -> Any:
+    """Factory that creates a request_stop handler with access to stop_registry."""
+
+    async def handler(context: "Any", **kwargs: Any) -> dict[str, Any] | None:
+        """ActionHandler for request_stop."""
+        return request_stop(
+            stop_registry=stop_registry,
+            session_id=kwargs.get("session_id", context.session_id),
+            source=kwargs.get("source", "workflow"),
+            reason=kwargs.get("reason"),
+        )
+
+    return handler
+
+
+def make_handle_clear_stop_signal(
+    stop_registry: "StopRegistry | None",
+) -> Any:
+    """Factory that creates a clear_stop_signal handler with access to stop_registry."""
+
+    async def handler(context: "Any", **kwargs: Any) -> dict[str, Any] | None:
+        """ActionHandler for clear_stop_signal."""
+        return clear_stop_signal(
+            stop_registry=stop_registry,
+            session_id=kwargs.get("session_id", context.session_id),
+        )
+
+    return handler

gobby/workflows/summary_actions.py

@@ -9,16 +9,22 @@ from __future__ import annotations
 import json
 import logging
 from pathlib import Path
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from gobby.workflows.git_utils import get_file_changes, get_git_status
 
+if TYPE_CHECKING:
+    from gobby.workflows.actions import ActionContext
+
 logger = logging.getLogger(__name__)
 
 
 def format_turns_for_llm(turns: list[dict[str, Any]]) -> str:
     """Format transcript turns for LLM analysis.
 
+    Handles both Claude Code format (nested message.role/content) and
+    Gemini CLI format (flat type/role/content).
+
     Args:
         turns: List of transcript turn dicts
 
@@ -27,51 +33,108 @@ def format_turns_for_llm(turns: list[dict[str, Any]]) -> str:
     """
     formatted: list[str] = []
     for i, turn in enumerate(turns):
-        message = turn.get("message", {})
-        role = message.get("role", "unknown")
-        content = message.get("content", "")
-
-        # Assistant messages have content as array of blocks
-        if isinstance(content, list):
-            text_parts: list[str] = []
-            for block in content:
-                if isinstance(block, dict):
-                    if block.get("type") == "text":
-                        text_parts.append(block.get("text", ""))
-                    elif block.get("type") == "thinking":
-                        text_parts.append(f"[Thinking: {block.get('thinking', '')}]")
-                    elif block.get("type") == "tool_use":
-                        text_parts.append(f"[Tool: {block.get('name', 'unknown')}]")
-                    elif block.get("type") == "tool_result":
-                        result_content = block.get("content", "")
-                        # Extract text from list of content blocks if needed
-                        if isinstance(result_content, list):
-                            extracted = []
-                            for item in result_content:
-                                if isinstance(item, dict):
-                                    extracted.append(
-                                        item.get("text", "") or item.get("content", "")
-                                    )
-                                else:
-                                    extracted.append(str(item))
-                            result_content = " ".join(extracted)
-                        content_str = str(result_content)
-                        preview = content_str[:100]
-                        suffix = "..." if len(content_str) > 100 else ""
-                        text_parts.append(f"[Result: {preview}{suffix}]")
-            content = " ".join(text_parts)
+        # Detect format: Gemini CLI uses "type" field, Claude uses nested "message"
+        event_type = turn.get("type")
+
+        if event_type:
+            # Gemini CLI format: flat structure with type field
+            role, content = _format_gemini_turn(turn, event_type)
+            if role is None:
+                continue  # Skip non-displayable events
+        else:
+            # Claude Code format: nested message structure
+            role, content = _format_claude_turn(turn)
 
         formatted.append(f"[Turn {i + 1} - {role}]: {content}")
 
     return "\n\n".join(formatted)
 
 
+def _format_gemini_turn(turn: dict[str, Any], event_type: str) -> tuple[str | None, str]:
+    """Format a Gemini CLI turn.
+
+    Returns:
+        Tuple of (role, formatted_content) or (None, "") if should skip
+    """
+    if event_type == "message":
+        role = turn.get("role", "unknown")
+        if role == "model":
+            role = "assistant"
+        content = turn.get("content", "")
+        if isinstance(content, list):
+            content = " ".join(str(part) for part in content)
+        return role, str(content)
+
+    elif event_type == "tool_use":
+        tool_name = turn.get("tool_name") or turn.get("function_name", "unknown")
+        params = turn.get("parameters") or turn.get("args", {})
+        param_preview = str(params)[:100] if params else ""
+        return "assistant", f"[Tool: {tool_name}] {param_preview}"
+
+    elif event_type == "tool_result":
+        tool_name = turn.get("tool_name", "")
+        output = turn.get("output") or turn.get("result", "")
+        output_str = str(output)
+        preview = output_str[:100]
+        suffix = "..." if len(output_str) > 100 else ""
+        return "tool", f"[Result{' from ' + tool_name if tool_name else ''}]: {preview}{suffix}"
+
+    elif event_type in ("init", "result"):
+        # Skip initialization and final result events
+        return None, ""
+
+    else:
+        # Unknown type, try to extract something
+        content = turn.get("content", turn.get("message", ""))
+        return "unknown", str(content)[:200]
+
+
+def _format_claude_turn(turn: dict[str, Any]) -> tuple[str, str]:
+    """Format a Claude Code turn with nested message structure."""
+    message = turn.get("message", {})
+    role = message.get("role", "unknown")
+    content = message.get("content", "")
+
+    # Assistant messages have content as array of blocks
+    if isinstance(content, list):
+        text_parts: list[str] = []
+        for block in content:
+            if isinstance(block, dict):
+                if block.get("type") == "text":
+                    text_parts.append(block.get("text", ""))
+                elif block.get("type") == "thinking":
+                    text_parts.append(f"[Thinking: {block.get('thinking', '')}]")
+                elif block.get("type") == "tool_use":
+                    text_parts.append(f"[Tool: {block.get('name', 'unknown')}]")
+                elif block.get("type") == "tool_result":
+                    result_content = block.get("content", "")
+                    # Extract text from list of content blocks if needed
+                    if isinstance(result_content, list):
+                        extracted = []
+                        for item in result_content:
+                            if isinstance(item, dict):
+                                extracted.append(item.get("text", "") or item.get("content", ""))
+                            else:
+                                extracted.append(str(item))
+                        result_content = " ".join(extracted)
+                    content_str = str(result_content)
+                    preview = content_str[:100]
+                    suffix = "..." if len(content_str) > 100 else ""
+                    text_parts.append(f"[Result: {preview}{suffix}]")
+        content = " ".join(text_parts)
+
+    return role, str(content)
+
+
 def extract_todowrite_state(turns: list[dict[str, Any]]) -> str:
     """Extract the last TodoWrite tool call's todos list from transcript.
 
     Scans turns in reverse to find the most recent TodoWrite tool call
     and formats it as a markdown checklist.
 
+    Handles both Claude Code format (nested message.content) and
+    Gemini CLI format (flat type/tool_name/parameters).
+
     Args:
         turns: List of transcript turns
 
@@ -79,6 +142,16 @@ def extract_todowrite_state(turns: list[dict[str, Any]]) -> str:
         Formatted markdown string with todo list, or empty string if not found
     """
     for turn in reversed(turns):
+        # Check Gemini CLI format: flat structure with type="tool_use"
+        event_type = turn.get("type")
+        if event_type == "tool_use":
+            tool_name = turn.get("tool_name") or turn.get("function_name", "")
+            if tool_name == "TodoWrite":
+                tool_input = turn.get("parameters") or turn.get("args") or turn.get("input", {})
+                todos = tool_input.get("todos", [])
+                return _format_todos(todos)
+
+        # Check Claude Code format: nested message.content
         message = turn.get("message", {})
         content = message.get("content", [])
 
@@ -88,29 +161,32 @@ def extract_todowrite_state(turns: list[dict[str, Any]]) -> str:
                     if block.get("name") == "TodoWrite":
                         tool_input = block.get("input", {})
                         todos = tool_input.get("todos", [])
+                        return _format_todos(todos)
 
-                        if not todos:
-                            return ""
+    return ""
 
-                        # Format as markdown checklist
-                        lines: list[str] = []
-                        for todo in todos:
-                            content_text = todo.get("content", "")
-                            status = todo.get("status", "pending")
 
-                            # Map status to checkbox style
-                            if status == "completed":
-                                checkbox = "[x]"
-                            elif status == "in_progress":
-                                checkbox = "[>]"
-                            else:
-                                checkbox = "[ ]"
+def _format_todos(todos: list[dict[str, Any]]) -> str:
+    """Format todos list as markdown checklist."""
+    if not todos:
+        return ""
 
-                            lines.append(f"- {checkbox} {content_text}")
+    lines: list[str] = []
+    for todo in todos:
+        content_text = todo.get("content", "")
+        status = todo.get("status", "pending")
 
-                        return "\n".join(lines)
+        # Map status to checkbox style
+        if status == "completed":
+            checkbox = "[x]"
+        elif status == "in_progress":
+            checkbox = "[>]"
+        else:
+            checkbox = "[ ]"
 
-    return ""
+        lines.append(f"- {checkbox} {content_text}")
+
+    return "\n".join(lines)
 
 
 async def synthesize_title(
@@ -359,3 +435,93 @@ async def generate_handoff(
         return {"error": "Failed to generate summary"}
 
     return {"handoff_created": True, "summary_length": summary_result.get("summary_length", 0)}
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+
+async def handle_synthesize_title(context: ActionContext, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for synthesize_title."""
+    # Extract prompt from event data (UserPromptSubmit hook)
+    prompt = None
+    if context.event_data:
+        prompt = context.event_data.get("prompt")
+
+    return await synthesize_title(
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        llm_service=context.llm_service,
+        transcript_processor=context.transcript_processor,
+        template_engine=context.template_engine,
+        template=kwargs.get("template"),
+        prompt=prompt,
+    )
+
+
+async def handle_generate_summary(context: ActionContext, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for generate_summary."""
+    return await generate_summary(
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        llm_service=context.llm_service,
+        transcript_processor=context.transcript_processor,
+        template=kwargs.get("template"),
+        mode=kwargs.get("mode", "clear"),
+        previous_summary=kwargs.get("previous_summary"),
+    )
+
+
+async def handle_generate_handoff(context: ActionContext, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for generate_handoff.
+
+    Handles mode detection from event_data and previous summary fetching for compact mode.
+    Also supports loading templates from prompts collection via 'prompt' parameter.
+    """
+    # Detect mode from kwargs or event data
+    mode = kwargs.get("mode", "clear")
+
+    # Check if this is a compact event based on event_data
+    COMPACT_EVENT_TYPES = {"pre_compact", "compact"}
+    if context.event_data:
+        raw_event_type = context.event_data.get("event_type") or ""
+        normalized_event_type = str(raw_event_type).strip().lower()
+        if normalized_event_type in COMPACT_EVENT_TYPES:
+            mode = "compact"
+
+    # For compact mode, fetch previous summary for cumulative compression
+    previous_summary = None
+    if mode == "compact":
+        current_session = context.session_manager.get(context.session_id)
+        if current_session:
+            previous_summary = getattr(current_session, "summary_markdown", None)
+            if previous_summary:
+                logger.debug(
+                    f"Compact mode: using previous summary ({len(previous_summary)} chars) "
+                    f"for cumulative compression"
+                )
+
+    # Load template from prompts collection if 'prompt' parameter provided
+    template = kwargs.get("template")
+    prompt_path = kwargs.get("prompt")
+    if prompt_path and not template:
+        try:
+            from gobby.prompts.loader import PromptLoader
+
+            loader = PromptLoader()
+            prompt_template = loader.load(prompt_path)
+            template = prompt_template.content
+            logger.debug(f"Loaded prompt template from: {prompt_path}")
+        except Exception as e:
+            logger.warning(f"Failed to load prompt from {prompt_path}: {e}")
+            # Fall back to inline template or default
+
+    return await generate_handoff(
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        llm_service=context.llm_service,
+        transcript_processor=context.transcript_processor,
+        template=template,
+        previous_summary=previous_summary,
+        mode=mode,
+    )