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

gobby/tasks/commits.py

@@ -487,30 +487,49 @@ def extract_mentioned_symbols(task: dict[str, Any]) -> list[str]:
 
 
 # Task ID patterns to search for in commit messages
-# Supports #N format (e.g., #1, #47) - human-friendly task references
+# Uses {project}-#N format to avoid GitHub auto-linking and match CLI display format
+# Patterns capture both project name and task number for validation
 TASK_ID_PATTERNS = [
-    # [#N] - bracket format
-    r"\[#(\d+)\]",
-    # #N: - hash-colon format (at start of line or after space)
-    r"(?:^|\s)#(\d+):",
-    # Implements/Fixes/Closes/Refs #N (supports multiple: #1, #2, #3)
-    r"(?:implements|fixes|closes|refs)\s+#(\d+)",
-    # Standalone #N after whitespace (with word boundary to avoid false positives)
-    r"(?:^|\s)#(\d+)\b(?![\d.])",
+    # [project-#N] - bracket format (primary)
+    r"\[(\w+)-#(\d+)\]",
+    # project-#N - standalone format (word boundary before, after digits)
+    r"(?:^|\s)(\w+)-#(\d+)\b",
+    # Implements/Fixes/Closes/Refs project-#N
+    r"(?:implements|fixes|closes|refs)\s+(\w+)-#(\d+)",
 ]
 
 
-def extract_task_ids_from_message(message: str) -> list[str]:
+def get_current_project_name() -> str | None:
+    """Get current project name from context.
+
+    Returns:
+        Project name or None if not in a project.
+    """
+    from gobby.utils.project_context import get_project_context
+
+    ctx = get_project_context()
+    if ctx and ctx.get("name"):
+        name: str = ctx["name"]
+        return name
+    return None
+
+
+def extract_task_ids_from_message(
+    message: str,
+    project_name: str | None = None,
+) -> list[str]:
     """Extract task IDs from a commit message.
 
     Supports patterns:
-    - [#N] - bracket format
-    - #N: - hash-colon format (at start of message)
-    - Implements/Fixes/Closes/Refs #N
-    - Multiple references: #1, #2, #3
+    - [project-#N] - bracket format (primary)
+    - project-#N - standalone format
+    - Implements/Fixes/Closes/Refs project-#N
 
     Args:
         message: Commit message to parse.
+        project_name: Optional project name to filter matches. If provided,
+            only returns task IDs from commits referencing this project.
+            If None, returns all task IDs found regardless of project.
 
     Returns:
         List of unique task references found (e.g., ["#1", "#42"]).
@@ -520,8 +539,13 @@ def extract_task_ids_from_message(message: str) -> list[str]:
     for pattern in TASK_ID_PATTERNS:
         matches = re.findall(pattern, message, re.IGNORECASE | re.MULTILINE)
         for match in matches:
+            # match is a tuple: (project, task_number)
+            found_project, task_num = match
+            # Filter by project name if specified
+            if project_name and found_project.lower() != project_name.lower():
+                continue
             # Format as #N
-            task_id = f"#{match}"
+            task_id = f"#{task_num}"
             task_ids.add(task_id)
 
     return list(task_ids)
@@ -547,6 +571,7 @@ def auto_link_commits(
     task_id: str | None = None,
     since: str | None = None,
     cwd: str | Path | None = None,
+    project_name: str | None = None,
 ) -> AutoLinkResult:
     """Auto-detect and link commits that mention task IDs.
 
@@ -558,12 +583,18 @@ def auto_link_commits(
         task_id: Optional specific task ID to filter for.
         since: Optional git --since parameter (e.g., "1 week ago", "2024-01-01").
         cwd: Working directory for git commands.
+        project_name: Optional project name to filter commits. If not provided,
+            auto-detects from current project context.
 
     Returns:
         AutoLinkResult with details of linked and skipped commits.
     """
     working_dir = Path(cwd) if cwd else Path.cwd()
 
+    # Get project name for filtering (auto-detect if not provided)
+    if project_name is None:
+        project_name = get_current_project_name()
+
     # Build git log command
     # Format: "sha|message" for easy parsing
     git_cmd = ["git", "log", "--pretty=format:%h|%s"]
@@ -590,8 +621,8 @@ def auto_link_commits(
 
         commit_sha, message = parts
 
-        # Extract task IDs from message
-        found_task_ids = extract_task_ids_from_message(message)
+        # Extract task IDs from message (filtered by project name)
+        found_task_ids = extract_task_ids_from_message(message, project_name)
 
         if not found_task_ids:
             continue

gobby/workflows/actions.py

@@ -101,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):
@@ -131,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
@@ -148,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()
@@ -254,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
@@ -385,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)
 
@@ -327,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.
 
@@ -409,7 +625,20 @@ def format_handoff_as_markdown(ctx: Any, prompt_template: str | None = None) ->
     # 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)
-        dirty_files = [f for f in ctx.files_modified if f in ctx.git_status]
+        # Normalize paths: files_modified may have absolute paths, git_status has relative
+        cwd = Path.cwd()
+        dirty_files = []
+        for f in ctx.files_modified:
+            # 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:
@@ -444,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,
@@ -453,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) ---