gobby 0.2.5__py3-none-any.whl

gobby/workflows/summary_actions.py

@@ -0,0 +1,344 @@
+"""Summary generation workflow actions.
+
+Extracted from actions.py as part of strangler fig decomposition.
+These functions handle session summary generation, title synthesis, and handoff creation.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Literal
+
+from gobby.workflows.git_utils import get_file_changes, get_git_status
+
+logger = logging.getLogger(__name__)
+
+
+def format_turns_for_llm(turns: list[dict[str, Any]]) -> str:
+    """Format transcript turns for LLM analysis.
+
+    Args:
+        turns: List of transcript turn dicts
+
+    Returns:
+        Formatted string with turn summaries
+    """
+    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')}]")
+            content = " ".join(text_parts)
+
+        formatted.append(f"[Turn {i + 1} - {role}]: {content}")
+
+    return "\n\n".join(formatted)
+
+
+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.
+
+    Args:
+        turns: List of transcript turns
+
+    Returns:
+        Formatted markdown string with todo list, or empty string if not found
+    """
+    for turn in reversed(turns):
+        message = turn.get("message", {})
+        content = message.get("content", [])
+
+        if isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "tool_use":
+                    if block.get("name") == "TodoWrite":
+                        tool_input = block.get("input", {})
+                        todos = tool_input.get("todos", [])
+
+                        if not todos:
+                            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 = "[ ]"
+
+                            lines.append(f"- {checkbox} {content_text}")
+
+                        return "\n".join(lines)
+
+    return ""
+
+
+async def synthesize_title(
+    session_manager: Any,
+    session_id: str,
+    llm_service: Any,
+    transcript_processor: Any,
+    template_engine: Any,
+    template: str | None = None,
+    prompt: str | None = None,
+) -> dict[str, Any] | None:
+    """Synthesize and set a session title.
+
+    Args:
+        session_manager: The session manager instance
+        session_id: Current session ID
+        llm_service: LLM service instance
+        transcript_processor: Transcript processor instance
+        template_engine: Template engine for rendering
+        template: Optional prompt template
+        prompt: Optional user prompt to generate title from (preferred over transcript)
+
+    Returns:
+        Dict with title_synthesized or error
+    """
+    if not llm_service:
+        return {"error": "Missing LLM service"}
+
+    current_session = session_manager.get(session_id)
+    if not current_session:
+        return {"error": "Session not found"}
+
+    try:
+        # If prompt provided directly, use it (preferred path)
+        if prompt:
+            llm_prompt = (
+                "Create a short title (3-5 words) for this coding session based on "
+                "the user's first message. Output ONLY the title, no quotes or explanation.\n\n"
+                f"User message: {prompt}"
+            )
+        else:
+            # Fall back to reading transcript
+            transcript_path = getattr(current_session, "jsonl_path", None)
+            if not transcript_path:
+                return {"error": "No transcript path and no prompt provided"}
+
+            turns = []
+            path = Path(transcript_path)
+            if path.exists():
+                with open(path, encoding="utf-8") as f:
+                    for i, line in enumerate(f):
+                        if i >= 20:
+                            break
+                        if line.strip():
+                            turns.append(json.loads(line))
+
+            if not turns:
+                return {"error": "Empty transcript"}
+
+            formatted_turns = format_turns_for_llm(turns)
+
+            if not template:
+                template = (
+                    "Create a short, concise title (3-5 words) for this coding session "
+                    "based on the transcript.\n\nTranscript:\n{{ transcript }}"
+                )
+
+            llm_prompt = template_engine.render(template, {"transcript": formatted_turns})
+
+        provider = llm_service.get_default_provider()
+        title = await provider.generate_text(llm_prompt)
+
+        # Clean title (remove quotes, etc)
+        title = title.strip().strip('"').strip("'")
+
+        session_manager.update_title(session_id, title)
+        return {"title_synthesized": title}
+
+    except Exception as e:
+        logger.error(f"synthesize_title: Failed: {e}")
+        return {"error": str(e)}
+
+
+async def generate_summary(
+    session_manager: Any,
+    session_id: str,
+    llm_service: Any,
+    transcript_processor: Any,
+    template: str | None = None,
+    previous_summary: str | None = None,
+    mode: Literal["clear", "compact"] = "clear",
+) -> dict[str, Any] | None:
+    """Generate a session summary using LLM and store it in the session record.
+
+    Args:
+        session_manager: The session manager instance
+        session_id: Current session ID
+        llm_service: LLM service instance
+        transcript_processor: Transcript processor instance
+        template: Optional prompt template
+        previous_summary: Previous summary_markdown for cumulative compression (compact mode)
+        mode: "clear" or "compact" - passed to LLM context to control summarization density
+
+    Returns:
+        Dict with summary_generated and summary_length, or error
+
+    Raises:
+        ValueError: If mode is not "clear" or "compact"
+    """
+    # Validate mode parameter
+    valid_modes = {"clear", "compact"}
+    if mode not in valid_modes:
+        raise ValueError(f"Invalid mode '{mode}'. Must be one of: {', '.join(sorted(valid_modes))}")
+
+    if not llm_service or not transcript_processor:
+        logger.warning("generate_summary: Missing LLM service or transcript processor")
+        return {"error": "Missing services"}
+
+    current_session = session_manager.get(session_id)
+    if not current_session:
+        return {"error": "Session not found"}
+
+    transcript_path = getattr(current_session, "jsonl_path", None)
+    if not transcript_path:
+        logger.warning(f"generate_summary: No transcript path for session {session_id}")
+        return {"error": "No transcript path"}
+
+    if not template:
+        template = (
+            "Summarize this session, focusing on what was accomplished, "
+            "key decisions, and what is left to do.\n\n"
+            "Transcript:\n{transcript_summary}"
+        )
+
+    # 1. Process Transcript
+    try:
+        transcript_file = Path(transcript_path)
+        if not transcript_file.exists():
+            logger.warning(f"Transcript file not found: {transcript_path}")
+            return {"error": "Transcript not found"}
+
+        turns = []
+        with open(transcript_file) as f:
+            for line in f:
+                if line.strip():
+                    turns.append(json.loads(line))
+
+        # Turn extraction is deliberately mode-agnostic: we always extract the most
+        # recent turns since the last /clear and let the prompt control summarization
+        # density. The mode parameter is passed to the LLM context where the template
+        # can adjust output format (e.g., compact mode may instruct denser summaries).
+        recent_turns = transcript_processor.extract_turns_since_clear(turns, max_turns=50)
+
+        # Format turns for LLM
+        transcript_summary = format_turns_for_llm(recent_turns)
+    except Exception as e:
+        logger.error(f"Failed to process transcript: {e}")
+        return {"error": str(e)}
+
+    # 2. Gather context variables for template
+    last_messages = transcript_processor.extract_last_messages(recent_turns, num_pairs=2)
+    last_messages_str = format_turns_for_llm(last_messages) if last_messages else ""
+
+    # Get git status and file changes
+    git_status = get_git_status()
+    file_changes = get_file_changes()
+
+    # Extract TodoWrite state from transcript
+    todo_list = extract_todowrite_state(recent_turns)
+
+    # 3. Call LLM
+    try:
+        llm_context = {
+            "turns": recent_turns,
+            "transcript_summary": transcript_summary,
+            "session": current_session,
+            "last_messages": last_messages_str,
+            "git_status": git_status,
+            "file_changes": file_changes,
+            "todo_list": f"## Agent's TODO List\n{todo_list}" if todo_list else "",
+            "previous_summary": previous_summary or "",
+            "mode": mode,
+        }
+        provider = llm_service.get_default_provider()
+        summary_content = await provider.generate_summary(
+            context=llm_context,
+            prompt_template=template,
+        )
+    except Exception as e:
+        logger.error(f"LLM generation failed: {e}")
+        return {"error": f"LLM error: {e}"}
+
+    # 4. Save to session
+    session_manager.update_summary(session_id, summary_markdown=summary_content)
+
+    logger.info(f"Generated summary for session {session_id} (mode={mode})")
+    return {"summary_generated": True, "summary_length": len(summary_content)}
+
+
+async def generate_handoff(
+    session_manager: Any,
+    session_id: str,
+    llm_service: Any,
+    transcript_processor: Any,
+    template: str | None = None,
+    previous_summary: str | None = None,
+    mode: Literal["clear", "compact"] = "clear",
+) -> dict[str, Any] | None:
+    """Generate a handoff record by summarizing the session.
+
+    This is a convenience action that combines generate_summary + mark status.
+
+    Args:
+        session_manager: The session manager instance
+        session_id: Current session ID
+        llm_service: LLM service instance
+        transcript_processor: Transcript processor instance
+        template: Optional prompt template
+        previous_summary: Previous summary for cumulative compression (compact mode)
+        mode: "clear" or "compact"
+
+    Returns:
+        Dict with handoff_created and summary_length, or error
+
+    Raises:
+        ValueError: If mode is not "clear" or "compact" (via generate_summary)
+    """
+    # Reuse generate_summary logic
+    summary_result = await generate_summary(
+        session_manager=session_manager,
+        session_id=session_id,
+        llm_service=llm_service,
+        transcript_processor=transcript_processor,
+        template=template,
+        previous_summary=previous_summary,
+        mode=mode,
+    )
+
+    if summary_result and "error" in summary_result:
+        return summary_result
+
+    # Mark Session Status
+    session_manager.update_status(session_id, "handoff_ready")
+
+    if not summary_result:
+        return {"error": "Failed to generate summary"}
+
+    return {"handoff_created": True, "summary_length": summary_result.get("summary_length", 0)}

gobby/workflows/task_actions.py

@@ -0,0 +1,249 @@
+"""Workflow-Task integration module.
+
+Provides functions for integrating the task system with the workflow engine:
+- persist_decomposed_tasks(): Create tasks from workflow decomposition with ID mapping
+- update_task_from_workflow(): Update task fields from workflow state
+- get_workflow_tasks(): Retrieve tasks for a workflow state
+"""
+
+import logging
+from typing import Any
+
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.tasks import LocalTaskManager, Task
+
+logger = logging.getLogger(__name__)
+
+
+def persist_decomposed_tasks(
+    db: DatabaseProtocol,
+    project_id: str,
+    tasks_data: list[dict[str, Any]],
+    workflow_name: str,
+    parent_task_id: str | None = None,
+    created_in_session_id: str | None = None,
+) -> dict[str, str]:
+    """Persist a list of decomposed tasks to the database with ID mapping.
+
+    Takes task data from workflow decomposition (e.g., from LLM output) and creates
+    persistent tasks in the database. Returns a mapping from original task references
+    (e.g., "1", "task_1") to the generated database IDs.
+
+    Args:
+        db: LocalDatabase instance
+        project_id: Project ID to create tasks in
+        tasks_data: List of task dicts from decomposition, each with:
+            - id (str/int): Original reference ID (optional, uses index if missing)
+            - title or description (str): Task title (required)
+            - verification (str): How to verify completion (optional)
+            - priority (int): Task priority 1-3 (optional, default 2)
+            - labels (list[str]): Task labels (optional)
+        workflow_name: Name of the workflow these tasks belong to
+        parent_task_id: Optional parent task ID for all created tasks
+        created_in_session_id: Optional session ID where task was created
+
+    Returns:
+        Dict mapping original task references to database task UUIDs.
+        Example: {"1": "550e8400-e29b-41d4-a716-446655440000", "2": "6ba7b810-9dad-11d1-80b4-00c04fd430c8"}
+
+    Raises:
+        ValueError: If no tasks provided or tasks_data is invalid
+    """
+    if not tasks_data:
+        raise ValueError("No tasks provided for persistence")
+
+    task_manager = LocalTaskManager(db)
+    id_mapping: dict[str, str] = {}
+
+    for index, task_data in enumerate(tasks_data):
+        # Get original reference ID (could be int from LLM JSON)
+        original_id = str(task_data.get("id", index + 1))
+
+        # Get title - support both 'title' and 'description' keys
+        title = task_data.get("title") or task_data.get("description")
+        if not title:
+            logger.warning(f"Skipping task {original_id}: no title or description")
+            continue
+
+        # Extract other fields
+        verification = task_data.get("verification")
+        priority = task_data.get("priority", 2)
+        labels = task_data.get("labels", [])
+        description = task_data.get("description")
+
+        # Don't use description as both title and description
+        if description == title:
+            description = None
+
+        try:
+            task = task_manager.create_task(
+                project_id=project_id,
+                title=title,
+                description=description,
+                priority=priority,
+                labels=labels,
+                parent_task_id=parent_task_id,
+                created_in_session_id=created_in_session_id,
+                workflow_name=workflow_name,
+                verification=verification,
+                sequence_order=index,
+            )
+            id_mapping[original_id] = task.id
+            logger.debug(f"Created task {task.id} from decomposition ref {original_id}")
+        except Exception as e:
+            logger.error(f"Failed to create task for ref {original_id}: {e}")
+            continue
+
+    logger.info(
+        f"Persisted {len(id_mapping)} tasks for workflow '{workflow_name}' in project {project_id}"
+    )
+    return id_mapping
+
+
+def update_task_from_workflow(
+    db: DatabaseProtocol,
+    task_id: str,
+    status: str | None = None,
+    verification: str | None = None,
+    validation_status: str | None = None,
+    validation_feedback: str | None = None,
+) -> Task | None:
+    """Update a task based on workflow state changes.
+
+    Called when workflow transitions or verifications occur to update the
+    corresponding task record.
+
+    Args:
+        db: LocalDatabase instance
+        task_id: ID of the task to update
+        status: New status ('open', 'in_progress', 'closed')
+        verification: Updated verification instructions/result
+        validation_status: Validation status ('pending', 'valid', 'invalid')
+        validation_feedback: Feedback from validation
+
+    Returns:
+        Updated Task object, or None if task not found
+    """
+    task_manager = LocalTaskManager(db)
+
+    try:
+        # Build update kwargs only for provided values
+        update_kwargs: dict[str, Any] = {}
+        if status is not None:
+            update_kwargs["status"] = status
+        if verification is not None:
+            update_kwargs["verification"] = verification
+        if validation_status is not None:
+            update_kwargs["validation_status"] = validation_status
+        if validation_feedback is not None:
+            update_kwargs["validation_feedback"] = validation_feedback
+
+        if not update_kwargs:
+            # No updates to apply, just return current task
+            return task_manager.get_task(task_id)
+
+        task = task_manager.update_task(task_id, **update_kwargs)
+        logger.debug(f"Updated task {task_id} from workflow: {list(update_kwargs.keys())}")
+        return task
+
+    except ValueError as e:
+        logger.warning(f"Task {task_id} not found for workflow update: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Failed to update task {task_id} from workflow: {e}")
+        return None
+
+
+def get_workflow_tasks(
+    db: DatabaseProtocol,
+    workflow_name: str,
+    project_id: str | None = None,
+    include_closed: bool = False,
+) -> list[Task]:
+    """Retrieve all tasks associated with a workflow state.
+
+    Returns tasks ordered by sequence_order for workflows that use ordered task
+    execution (like plan-to-tasks).
+
+    Args:
+        db: LocalDatabase instance
+        workflow_name: Name of the workflow to get tasks for
+        project_id: Optional project ID filter
+        include_closed: If True, include closed tasks; otherwise only open/in_progress
+
+    Returns:
+        List of Task objects ordered by sequence_order, then created_at
+    """
+    task_manager = LocalTaskManager(db)
+
+    # Determine status filter
+    status = None if include_closed else None  # We'll handle in the method
+
+    tasks = task_manager.list_workflow_tasks(
+        workflow_name=workflow_name,
+        project_id=project_id,
+        status=status,
+    )
+
+    # Filter out closed if not including them
+    if not include_closed:
+        tasks = [t for t in tasks if t.status != "closed"]
+
+    logger.debug(f"Retrieved {len(tasks)} tasks for workflow '{workflow_name}'")
+    return tasks
+
+
+def get_next_workflow_task(
+    db: DatabaseProtocol,
+    workflow_name: str,
+    project_id: str | None = None,
+) -> Task | None:
+    """Get the next task to work on for a workflow.
+
+    Returns the first open task by sequence_order that hasn't been started.
+    Useful for workflows that execute tasks sequentially.
+
+    Args:
+        db: LocalDatabase instance
+        workflow_name: Name of the workflow
+        project_id: Optional project ID filter
+
+    Returns:
+        Next Task to work on, or None if all tasks are complete
+    """
+    task_manager = LocalTaskManager(db)
+
+    tasks = task_manager.list_workflow_tasks(
+        workflow_name=workflow_name,
+        project_id=project_id,
+        status="open",
+        limit=1,
+    )
+
+    if tasks:
+        return tasks[0]
+    return None
+
+
+def mark_workflow_task_complete(
+    db: DatabaseProtocol,
+    task_id: str,
+    verification_result: str | None = None,
+) -> Task | None:
+    """Mark a workflow task as complete with optional verification result.
+
+    Args:
+        db: LocalDatabase instance
+        task_id: ID of the task to complete
+        verification_result: Optional result/notes from verification
+
+    Returns:
+        Updated Task object, or None if task not found
+    """
+    return update_task_from_workflow(
+        db=db,
+        task_id=task_id,
+        status="closed",
+        verification=verification_result,
+        validation_status="valid",
+    )