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

gobby/utils/status.py

@@ -84,6 +84,11 @@ def fetch_rich_status(http_port: int, timeout: float = 2.0) -> dict[str, Any]:
         if skills_data:
             status_kwargs["skills_total"] = skills_data.get("total", 0)
 
+        # Artifacts
+        artifacts_data = data.get("artifacts", {})
+        if artifacts_data and artifacts_data.get("count", 0) > 0:
+            status_kwargs["artifacts_count"] = artifacts_data.get("count", 0)
+
     except (httpx.ConnectError, httpx.TimeoutException):
         # Daemon not responding - return empty
         pass
@@ -124,6 +129,8 @@ def format_status_message(
     memories_avg_importance: float | None = None,
     # Skills
     skills_total: int | None = None,
+    # Artifacts
+    artifacts_count: int | None = None,
     **kwargs: Any,
 ) -> str:
     """
@@ -254,6 +261,12 @@ def format_status_message(
         lines.append(f"  {mem_str}")
         lines.append("")
 
+    # Artifacts section (only show if we have data)
+    if artifacts_count is not None:
+        lines.append("Artifacts:")
+        lines.append(f"  Captured: {artifacts_count}")
+        lines.append("")
+
     # Paths section (only when running)
     if running and (pid_file or log_files):
         lines.append("Paths:")

gobby/workflows/actions.py

@@ -32,6 +32,7 @@ from gobby.workflows.enforcement import (
     handle_require_commit_before_stop,
     handle_require_task_complete,
     handle_require_task_review_or_close_before_stop,
+    handle_track_schema_lookup,
     handle_validate_session_task_scope,
 )
 from gobby.workflows.llm_actions import handle_call_llm
@@ -100,7 +101,10 @@ class ActionContext:
     memory_sync_manager: Any | None = None
     task_sync_manager: Any | None = None
     session_task_manager: Any | None = None
+    skill_manager: Any | None = None
     event_data: dict[str, Any] | None = None  # Hook event data (e.g., prompt_text)
+    pipeline_executor: Any | None = None  # PipelineExecutor
+    workflow_loader: Any | None = None  # WorkflowLoader
 
 
 class ActionHandler(Protocol):
@@ -130,6 +134,9 @@ class ActionExecutor:
         progress_tracker: Any | None = None,
         stuck_detector: Any | None = None,
         websocket_server: Any | None = None,
+        skill_manager: Any | None = None,
+        pipeline_executor: Any | None = None,
+        workflow_loader: Any | None = None,
     ):
         self.db = db
         self.session_manager = session_manager
@@ -147,6 +154,9 @@ class ActionExecutor:
         self.progress_tracker = progress_tracker
         self.stuck_detector = stuck_detector
         self.websocket_server = websocket_server
+        self.skill_manager = skill_manager
+        self.pipeline_executor = pipeline_executor
+        self.workflow_loader = workflow_loader
         self._handlers: dict[str, ActionHandler] = {}
 
         self._register_defaults()
@@ -253,6 +263,9 @@ class ActionExecutor:
         # --- Autonomous execution actions (closures for progress_tracker/stuck_detector) ---
         self._register_autonomous_actions()
 
+        # --- Pipeline actions (closures for pipeline_executor/workflow_loader) ---
+        self._register_pipeline_actions()
+
     def _register_task_enforcement_actions(self) -> None:
         """Register task enforcement actions with task_manager closure."""
         tm = self.task_manager
@@ -283,6 +296,9 @@ class ActionExecutor:
         async def capture_baseline(context: ActionContext, **kw: Any) -> dict[str, Any] | None:
             return await handle_capture_baseline_dirty_files(context, task_manager=tm, **kw)
 
+        async def track_schema(context: ActionContext, **kw: Any) -> dict[str, Any] | None:
+            return await handle_track_schema_lookup(context, task_manager=tm, **kw)
+
         self.register("block_tools", block_tools)
         self.register("require_active_task", require_active)
         self.register("require_task_complete", require_complete)
@@ -290,6 +306,7 @@ class ActionExecutor:
         self.register("require_task_review_or_close_before_stop", require_review)
         self.register("validate_session_task_scope", validate_scope)
         self.register("capture_baseline_dirty_files", capture_baseline)
+        self.register("track_schema_lookup", track_schema)
 
     def _register_webhook_action(self) -> None:
         """Register webhook action with config closure."""
@@ -380,6 +397,69 @@ class ActionExecutor:
         self.register("record_task_selection", record_sel)
         self.register("get_progress_summary", get_summary)
 
+    def _register_pipeline_actions(self) -> None:
+        """Register pipeline actions with pipeline_executor/workflow_loader closures."""
+        executor = self
+
+        async def run_pipeline(context: ActionContext, **kw: Any) -> dict[str, Any] | None:
+            from gobby.workflows.pipeline_state import ApprovalRequired
+
+            name = kw.get("name")
+            inputs = kw.get("inputs") or {}
+            await_completion = kw.get("await_completion", False)
+
+            if not name:
+                return {"error": "Pipeline name is required"}
+
+            if executor.workflow_loader is None:
+                return {"error": "Workflow loader not configured"}
+
+            if executor.pipeline_executor is None:
+                return {"error": "Pipeline executor not configured"}
+
+            # Load the pipeline
+            pipeline = executor.workflow_loader.load_pipeline(name)
+            if pipeline is None:
+                return {"error": f"Pipeline '{name}' not found"}
+
+            # Render template variables in inputs
+            rendered_inputs = {}
+            variables = context.state.variables if context.state else {}
+            for key, value in inputs.items():
+                if isinstance(value, str):
+                    rendered_inputs[key] = context.template_engine.render(value, variables)
+                else:
+                    rendered_inputs[key] = value
+
+            try:
+                # Execute the pipeline
+                execution = await executor.pipeline_executor.execute(
+                    pipeline=pipeline,
+                    inputs=rendered_inputs,
+                    project_id=variables.get("project_id", ""),
+                )
+
+                return {
+                    "status": execution.status.value,
+                    "execution_id": execution.id,
+                    "pipeline_name": execution.pipeline_name,
+                }
+
+            except ApprovalRequired as e:
+                # Store pending pipeline in state if await_completion is True
+                if await_completion:
+                    context.state.variables["pending_pipeline"] = e.execution_id
+
+                return {
+                    "status": "waiting_approval",
+                    "execution_id": e.execution_id,
+                    "step_id": e.step_id,
+                    "token": e.token,
+                    "message": e.message,
+                }
+
+        self.register("run_pipeline", run_pipeline)
+
     async def execute(
         self, action_type: str, context: ActionContext, **kwargs: Any
     ) -> dict[str, Any] | None:

gobby/workflows/context_actions.py

@@ -25,20 +25,35 @@ def inject_context(
     session_id: str,
     state: Any,
     template_engine: Any,
-    source: str | None = None,
+    source: str | list[str] | None = None,
     template: str | None = None,
     require: bool = False,
+    skill_manager: Any | None = None,
+    filter: str | None = None,
+    session_task_manager: Any | None = None,
+    memory_manager: Any | None = None,
+    prompt_text: str | None = None,
+    limit: int = 5,
+    min_importance: float = 0.3,
 ) -> dict[str, Any] | None:
-    """Inject context from a source.
+    """Inject context from a source or multiple sources.
 
     Args:
         session_manager: The session manager instance
         session_id: Current session ID
         state: WorkflowState instance
         template_engine: Template engine for rendering
-        source: Source type (previous_session_summary, handoff, artifacts, etc.)
+        source: Source type(s). Can be a string or list of strings.
+                Supported: previous_session_summary, handoff, artifacts, skills, task_context, memories, etc.
         template: Optional template for rendering
         require: If True, block session when no content found (default: False)
+        skill_manager: HookSkillManager instance (required for source='skills')
+        filter: Optional filter for skills source ('always_apply' to only include always-apply skills)
+        session_task_manager: SessionTaskManager instance (required for source='task_context')
+        memory_manager: MemoryManager instance (required for source='memories')
+        prompt_text: User prompt text for memory recall (required for source='memories')
+        limit: Max memories to retrieve (default: 5, used with source='memories')
+        min_importance: Minimum importance threshold (default: 0.3, used with source='memories')
 
     Returns:
         Dict with inject_context key, blocking decision, or None
@@ -60,6 +75,57 @@ def inject_context(
         logger.warning("inject_context: session_id is empty or None")
         return None
 
+    # Handle list of sources - recursively call for each source and combine
+    if isinstance(source, list):
+        combined_content: list[str] = []
+        for single_source in source:
+            result = inject_context(
+                session_manager=session_manager,
+                session_id=session_id,
+                state=state,
+                template_engine=template_engine,
+                source=single_source,
+                template=None,  # Don't render template for individual sources
+                require=False,  # Don't block for individual sources
+                skill_manager=skill_manager,
+                filter=filter,
+                session_task_manager=session_task_manager,
+                memory_manager=memory_manager,
+                prompt_text=prompt_text,
+                limit=limit,
+                min_importance=min_importance,
+            )
+            if result and result.get("inject_context"):
+                combined_content.append(result["inject_context"])
+
+        if combined_content:
+            content = "\n\n".join(combined_content)
+            if template:
+                # Build source_contents mapping for individual source access
+                source_contents: dict[str, str] = {}
+                for i, single_source in enumerate(source):
+                    if i < len(combined_content):
+                        source_contents[single_source] = combined_content[i]
+                render_context: dict[str, Any] = {
+                    "session": session_manager.get(session_id),
+                    "state": state,
+                    "artifacts": state.artifacts if state else {},
+                    "observations": state.observations if state else {},
+                    "combined_content": content,
+                    "source_contents": source_contents,
+                }
+                content = template_engine.render(template, render_context)
+            state.context_injected = True
+            return {"inject_context": content}
+
+        # No content from any source - block if required
+        if require:
+            reason = f"Required handoff context not found (sources={source})"
+            logger.warning(f"inject_context: {reason}")
+            return {"decision": "block", "reason": reason}
+
+        return None
+
     # Debug logging for troubleshooting
     logger.debug(
         f"inject_context called: source={source!r}, "
@@ -77,7 +143,7 @@ def inject_context(
     if not source and template:
         # Render static template directly
         logger.debug("inject_context: entering template-only path")
-        render_context: dict[str, Any] = {
+        render_context = {
             "session": session_manager.get(session_id),
             "state": state,
             "artifacts": state.artifacts if state else {},
@@ -152,6 +218,69 @@ def inject_context(
                 f"Loaded compact_markdown ({len(content)} chars) from current session {session_id}"
             )
 
+    elif source == "skills":
+        # Inject skill context from skill_manager
+        if skill_manager is None:
+            logger.debug("inject_context: skills source requires skill_manager")
+            return None
+
+        skills = skill_manager.discover_core_skills()
+
+        # Apply filter if specified
+        if filter == "always_apply":
+            skills = [s for s in skills if s.is_always_apply()]
+
+        if skills:
+            content = _format_skills(skills)
+            logger.debug(f"Formatted {len(skills)} skills for injection")
+
+    elif source == "task_context":
+        # Inject current task context from session_task_manager
+        if session_task_manager is None:
+            logger.debug("inject_context: task_context source requires session_task_manager")
+            return None
+
+        session_tasks = session_task_manager.get_session_tasks(session_id)
+
+        # Filter for "worked_on" tasks (the active task)
+        worked_on_tasks = [t for t in session_tasks if t.get("action") == "worked_on"]
+
+        if worked_on_tasks:
+            content = _format_task_context(worked_on_tasks)
+            logger.debug(f"Formatted {len(worked_on_tasks)} active tasks for injection")
+
+    elif source == "memories":
+        # Inject relevant memories from memory_manager
+        if memory_manager is None:
+            logger.debug("inject_context: memories source requires memory_manager")
+            return None
+
+        if not memory_manager.config.enabled:
+            logger.debug("inject_context: memory manager is disabled")
+            return None
+
+        # Get project_id from session
+        project_id = None
+        session = session_manager.get(session_id)
+        if session:
+            project_id = getattr(session, "project_id", None)
+
+        try:
+            memories = memory_manager.recall(
+                query=prompt_text or "",
+                project_id=project_id,
+                limit=limit,
+                min_importance=min_importance,
+                use_semantic=True,
+            )
+
+            if memories:
+                content = _format_memories(memories)
+                logger.debug(f"Formatted {len(memories)} memories for injection")
+        except Exception as e:
+            logger.error(f"inject_context: memory recall failed: {e}")
+            return None
+
     if content:
         if template:
             render_context = {
@@ -173,6 +302,12 @@ def inject_context(
             elif source == "compact_handoff":
                 # Pass content to template (like /clear does with summary)
                 render_context["handoff"] = content
+            elif source == "skills":
+                render_context["skills_list"] = content
+            elif source == "task_context":
+                render_context["task_context"] = content
+            elif source == "memories":
+                render_context["memories_list"] = content
 
             content = template_engine.render(template, render_context)
 
@@ -308,16 +443,8 @@ def extract_handoff_context(
         except Exception as wt_err:
             logger.debug(f"Failed to get worktree context: {wt_err}")
 
-        # Add active skills from HookSkillManager
-        try:
-            from gobby.hooks.skill_manager import HookSkillManager
-
-            skill_manager = HookSkillManager()
-            core_skills = skill_manager.discover_core_skills()
-            always_apply_skills = [s.name for s in core_skills if s.is_always_apply()]
-            handoff_ctx.active_skills = always_apply_skills
-        except Exception as skill_err:
-            logger.debug(f"Failed to get active skills: {skill_err}")
+        # Note: active_skills population removed - redundant with _build_skill_injection_context()
+        # which already handles skill restoration on session start
 
         # Format as markdown (like /clear stores formatted summary)
         markdown = format_handoff_as_markdown(handoff_ctx)
@@ -335,6 +462,87 @@ def extract_handoff_context(
         return {"error": str(e)}
 
 
+def _format_memories(memories: list[Any]) -> str:
+    """Format memory objects as markdown for injection.
+
+    Args:
+        memories: List of Memory objects
+
+    Returns:
+        Formatted markdown string with memory content
+    """
+    lines = ["## Relevant Memories"]
+    for memory in memories:
+        content = getattr(memory, "content", str(memory))
+        memory_type = getattr(memory, "memory_type", None)
+        importance = getattr(memory, "importance", None)
+
+        if memory_type:
+            lines.append(f"- [{memory_type}] {content}")
+        else:
+            lines.append(f"- {content}")
+
+        if importance and importance >= 0.8:
+            lines[-1] += " *(high importance)*"
+
+    return "\n".join(lines)
+
+
+def _format_task_context(task_entries: list[dict[str, Any]]) -> str:
+    """Format task entries as markdown for injection.
+
+    Args:
+        task_entries: List of dicts with 'task' key containing Task objects
+
+    Returns:
+        Formatted markdown string with task info
+    """
+    lines = ["## Active Task"]
+    for entry in task_entries:
+        task = entry.get("task")
+        if task is None:
+            continue
+
+        seq_num = getattr(task, "seq_num", None)
+        title = getattr(task, "title", "Untitled")
+        status = getattr(task, "status", "unknown")
+        description = getattr(task, "description", "")
+        validation = getattr(task, "validation_criteria", "")
+
+        # Format task reference
+        ref = f"#{seq_num}" if seq_num else task.id[:8] if hasattr(task, "id") else "unknown"
+        lines.append(f"**{ref}**: {title}")
+        lines.append(f"Status: {status}")
+
+        if description:
+            lines.append(f"\n{description}")
+
+        if validation:
+            lines.append(f"\n**Validation Criteria**: {validation}")
+
+    return "\n".join(lines)
+
+
+def _format_skills(skills: list[Any]) -> str:
+    """Format a list of ParsedSkill objects as markdown for injection.
+
+    Args:
+        skills: List of ParsedSkill objects
+
+    Returns:
+        Formatted markdown string with skill names and descriptions
+    """
+    lines = ["## Available Skills"]
+    for skill in skills:
+        name = getattr(skill, "name", "unknown")
+        description = getattr(skill, "description", "")
+        if description:
+            lines.append(f"- **{name}**: {description}")
+        else:
+            lines.append(f"- **{name}**")
+    return "\n".join(lines)
+
+
 def recommend_skills_for_task(task: dict[str, Any] | None) -> list[str]:
     """Recommend relevant skills based on task category.
 
@@ -414,16 +622,37 @@ def format_handoff_as_markdown(ctx: Any, prompt_template: str | None = None) ->
     if ctx.git_status:
         sections.append(f"### Uncommitted Changes\n```\n{ctx.git_status}\n```")
 
-    # Files modified section
-    if ctx.files_modified:
-        lines = ["### Files Being Modified"]
+    # Files modified section - only show files still dirty (not yet committed)
+    if ctx.files_modified and ctx.git_status:
+        # Filter to files that appear in git status (still uncommitted)
+        # Normalize paths: files_modified may have absolute paths, git_status has relative
+        cwd = Path.cwd()
+        dirty_files = []
         for f in ctx.files_modified:
-            lines.append(f"- {f}")
-        sections.append("\n".join(lines))
-
-    # Initial goal section
+            # Try to make path relative to cwd for comparison
+            try:
+                rel_path = Path(f).relative_to(cwd)
+                rel_str = str(rel_path)
+            except ValueError:
+                # Path not relative to cwd, use as-is
+                rel_str = f
+            # Check if relative path appears in git status
+            if rel_str in ctx.git_status:
+                dirty_files.append(rel_str)
+        if dirty_files:
+            lines = ["### Files Being Modified"]
+            for f in dirty_files:
+                lines.append(f"- {f}")
+            sections.append("\n".join(lines))
+
+    # Initial goal section - only if task is still active (not closed/completed)
     if ctx.initial_goal:
-        sections.append(f"### Original Goal\n{ctx.initial_goal}")
+        task_status = None
+        if ctx.active_gobby_task:
+            task_status = ctx.active_gobby_task.get("status")
+        # Only include if no task or task is still open/in_progress
+        if task_status in (None, "open", "in_progress"):
+            sections.append(f"### Original Goal\n{ctx.initial_goal}")
 
     # Recent activity section
     if ctx.recent_activity:
@@ -432,11 +661,8 @@ def format_handoff_as_markdown(ctx: Any, prompt_template: str | None = None) ->
             lines.append(f"- {activity}")
         sections.append("\n".join(lines))
 
-    # Active skills section
-    if hasattr(ctx, "active_skills") and ctx.active_skills:
-        lines = ["### Active Skills"]
-        lines.append(f"Skills available: {', '.join(ctx.active_skills)}")
-        sections.append("\n".join(lines))
+    # Note: Active Skills section removed - redundant with _build_skill_injection_context()
+    # which already handles skill restoration on session start
 
     return "\n\n".join(sections)
 
@@ -447,6 +673,11 @@ def format_handoff_as_markdown(ctx: Any, prompt_template: str | None = None) ->
 
 async def handle_inject_context(context: ActionContext, **kwargs: Any) -> dict[str, Any] | None:
     """ActionHandler wrapper for inject_context."""
+    # Get prompt_text from event_data if not explicitly passed
+    prompt_text = kwargs.get("prompt_text")
+    if prompt_text is None and context.event_data:
+        prompt_text = context.event_data.get("prompt_text")
+
     return await asyncio.to_thread(
         inject_context,
         session_manager=context.session_manager,
@@ -456,6 +687,13 @@ async def handle_inject_context(context: ActionContext, **kwargs: Any) -> dict[s
         source=kwargs.get("source"),
         template=kwargs.get("template"),
         require=kwargs.get("require", False),
+        skill_manager=context.skill_manager,
+        filter=kwargs.get("filter"),
+        session_task_manager=context.session_task_manager,
+        memory_manager=context.memory_manager,
+        prompt_text=prompt_text,
+        limit=kwargs.get("limit", 5),
+        min_importance=kwargs.get("min_importance", 0.3),
     )
 
 

gobby/workflows/definitions.py

@@ -30,7 +30,11 @@ class PrematureStopHandler(BaseModel):
     """Handler for when an agent attempts to stop before task completion."""
 
     action: Literal["guide_continuation", "block", "warn"] = "guide_continuation"
-    message: str = "Task has incomplete subtasks. Use suggest_next_task() to continue."
+    message: str = (
+        "Task has incomplete subtasks. Options: "
+        "1) Continue: use suggest_next_task() to find the next task. "
+        "2) Stop anyway: use `/g workflows deactivate` to end the workflow first."
+    )
     condition: str | None = None  # Optional condition to check (e.g., task_tree_complete)
 
 
@@ -88,6 +92,120 @@ class WorkflowDefinition(BaseModel):
         return None
 
 
+# --- Pipeline Definition Models (YAML) ---
+
+
+class WebhookEndpoint(BaseModel):
+    """Configuration for a webhook endpoint."""
+
+    url: str
+    method: str = "POST"
+    headers: dict[str, str] = Field(default_factory=dict)
+
+
+class WebhookConfig(BaseModel):
+    """Webhook configuration for pipeline events."""
+
+    on_approval_pending: WebhookEndpoint | None = None
+    on_complete: WebhookEndpoint | None = None
+    on_failure: WebhookEndpoint | None = None
+
+
+class PipelineApproval(BaseModel):
+    """Approval gate configuration for a pipeline step."""
+
+    required: bool = False
+    message: str | None = None
+    timeout_seconds: int | None = None
+
+
+class PipelineStep(BaseModel):
+    """A single step in a pipeline workflow.
+
+    Steps must have exactly one execution type: exec, prompt, or invoke_pipeline.
+    """
+
+    id: str
+
+    # Execution types (mutually exclusive - exactly one required)
+    exec: str | None = None  # Shell command to run
+    prompt: str | None = None  # LLM prompt template
+    invoke_pipeline: str | None = None  # Name of pipeline to invoke
+
+    # Optional fields
+    condition: str | None = None  # Condition for step execution
+    approval: PipelineApproval | None = None  # Approval gate
+    tools: list[str] = Field(default_factory=list)  # Tool restrictions for prompt steps
+    input: str | None = None  # Explicit input reference (e.g., $prev_step.output)
+
+    def model_post_init(self, __context: Any) -> None:
+        """Validate that exactly one execution type is specified."""
+        exec_types = [self.exec, self.prompt, self.invoke_pipeline]
+        specified = [t for t in exec_types if t is not None]
+
+        if len(specified) == 0:
+            raise ValueError(
+                "PipelineStep requires at least one execution type: exec, prompt, or invoke_pipeline"
+            )
+        if len(specified) > 1:
+            raise ValueError(
+                "PipelineStep exec, prompt, and invoke_pipeline are mutually exclusive - only one allowed"
+            )
+
+
+class PipelineDefinition(BaseModel):
+    """Definition for a pipeline workflow with typed data flow between steps.
+
+    Pipelines execute steps sequentially with explicit data flow via $step.output references.
+    """
+
+    name: str
+    description: str | None = None
+    version: str = "1.0"
+    type: Literal["pipeline"] = "pipeline"
+
+    @field_validator("version", mode="before")
+    @classmethod
+    def coerce_version_to_string(cls, v: Any) -> str:
+        """Accept numeric versions (1.0, 2) and coerce to string."""
+        return str(v) if v is not None else "1.0"
+
+    # Input/output schema
+    inputs: dict[str, Any] = Field(default_factory=dict)
+    outputs: dict[str, Any] = Field(default_factory=dict)
+
+    # Pipeline steps
+    steps: list[PipelineStep] = Field(default_factory=list)
+
+    # Webhook notifications
+    webhooks: WebhookConfig | None = None
+
+    # Expose as MCP tool
+    expose_as_tool: bool = False
+
+    @field_validator("steps", mode="after")
+    @classmethod
+    def validate_steps(cls, v: list[PipelineStep]) -> list[PipelineStep]:
+        """Validate pipeline steps."""
+        if len(v) == 0:
+            raise ValueError("Pipeline requires at least one step")
+
+        # Check for duplicate step IDs
+        ids = [step.id for step in v]
+        if len(ids) != len(set(ids)):
+            duplicates = [id for id in ids if ids.count(id) > 1]
+            raise ValueError(f"Pipeline step IDs must be unique. Duplicates: {set(duplicates)}")
+
+        return v
+
+    def get_step(self, step_id: str) -> PipelineStep | None:
+        """Get a step by its ID."""
+        for step in self.steps:
+            if step.id == step_id:
+                return step
+        return None
+
+
 # --- Workflow State Models (Runtime) ---