foundry-mcp 0.7.0__py3-none-any.whl → 0.8.10__py3-none-any.whl

foundry_mcp/tools/unified/task.py

@@ -57,6 +57,19 @@ from foundry_mcp.core.task import (
     update_task_metadata,
     update_task_requirements,
 )
+from foundry_mcp.core.batch_operations import (
+    prepare_batch_context,
+    start_batch,
+    complete_batch,
+    reset_batch,
+    DEFAULT_MAX_TASKS,
+    DEFAULT_TOKEN_BUDGET,
+    STALE_TASK_THRESHOLD_HOURS,
+)
+from foundry_mcp.cli.context import (
+    AutonomousSession,
+    get_context_tracker,
+)
 from foundry_mcp.core.validation import (
     VALID_VERIFICATION_TYPES,
     VERIFICATION_TYPE_MAPPING,
@@ -258,6 +271,303 @@ def _handle_prepare(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
     return _attach_meta(result, request_id=request_id, duration_ms=elapsed_ms)
 
 
+def _handle_prepare_batch(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
+    """
+    Handle prepare-batch action for parallel task execution.
+
+    Returns multiple independent tasks with context for parallel implementation.
+    """
+    request_id = _request_id()
+    action = "prepare-batch"
+    spec_id = payload.get("spec_id")
+    if not isinstance(spec_id, str) or not spec_id.strip():
+        return _validation_error(
+            field="spec_id",
+            action=action,
+            message="Provide a non-empty spec identifier",
+            request_id=request_id,
+        )
+
+    # Optional parameters with defaults
+    max_tasks = payload.get("max_tasks", DEFAULT_MAX_TASKS)
+    if not isinstance(max_tasks, int) or max_tasks < 1:
+        return _validation_error(
+            field="max_tasks",
+            action=action,
+            message="max_tasks must be a positive integer",
+            request_id=request_id,
+            code=ErrorCode.VALIDATION_ERROR,
+        )
+
+    token_budget = payload.get("token_budget", DEFAULT_TOKEN_BUDGET)
+    if not isinstance(token_budget, int) or token_budget < 1000:
+        return _validation_error(
+            field="token_budget",
+            action=action,
+            message="token_budget must be an integer >= 1000",
+            request_id=request_id,
+            code=ErrorCode.VALIDATION_ERROR,
+        )
+
+    workspace = payload.get("workspace")
+    specs_dir = _resolve_specs_dir(config, workspace)
+    if specs_dir is None:
+        return _specs_dir_missing_error(request_id)
+
+    start = time.perf_counter()
+    result, error = prepare_batch_context(
+        spec_id=spec_id.strip(),
+        max_tasks=max_tasks,
+        token_budget=token_budget,
+        specs_dir=specs_dir,
+    )
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    if error:
+        _metrics.counter(_metric(action), labels={"status": "error"})
+        return asdict(
+            error_response(
+                error,
+                error_code=ErrorCode.OPERATION_FAILED,
+                error_type=ErrorType.VALIDATION,
+                request_id=request_id,
+            )
+        )
+
+    _metrics.timer(_metric(action) + ".duration_ms", elapsed_ms)
+    _metrics.counter(_metric(action), labels={"status": "success"})
+
+    # Build response with batch context
+    response = success_response(
+        spec_id=spec_id.strip(),
+        tasks=result.get("tasks", []),
+        task_count=result.get("task_count", 0),
+        spec_complete=result.get("spec_complete", False),
+        all_blocked=result.get("all_blocked", False),
+        stale_tasks=result.get("stale_tasks", []),
+        dependency_graph=result.get("dependency_graph", {}),
+        token_estimate=result.get("token_estimate", 0),
+        request_id=request_id,
+        telemetry={"duration_ms": round(elapsed_ms, 2)},
+    )
+
+    warnings = result.get("warnings", [])
+    return _attach_meta(
+        asdict(response),
+        request_id=request_id,
+        duration_ms=elapsed_ms,
+        warnings=warnings if warnings else None,
+    )
+
+
+def _handle_start_batch(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
+    """
+    Handle start-batch action for atomically starting multiple tasks.
+
+    Validates all tasks can be started before making any changes.
+    """
+    request_id = _request_id()
+    action = "start-batch"
+    spec_id = payload.get("spec_id")
+    if not isinstance(spec_id, str) or not spec_id.strip():
+        return _validation_error(
+            field="spec_id",
+            action=action,
+            message="Provide a non-empty spec identifier",
+            request_id=request_id,
+        )
+
+    task_ids = payload.get("task_ids")
+    if not isinstance(task_ids, list) or not task_ids:
+        return _validation_error(
+            field="task_ids",
+            action=action,
+            message="Provide a non-empty list of task IDs",
+            request_id=request_id,
+        )
+
+    # Validate all task_ids are strings
+    for i, tid in enumerate(task_ids):
+        if not isinstance(tid, str) or not tid.strip():
+            return _validation_error(
+                field=f"task_ids[{i}]",
+                action=action,
+                message="Each task ID must be a non-empty string",
+                request_id=request_id,
+                code=ErrorCode.VALIDATION_ERROR,
+            )
+
+    workspace = payload.get("workspace")
+    specs_dir = _resolve_specs_dir(config, workspace)
+    if specs_dir is None:
+        return _specs_dir_missing_error(request_id)
+
+    start = time.perf_counter()
+    result, error = start_batch(
+        spec_id=spec_id.strip(),
+        task_ids=[tid.strip() for tid in task_ids],
+        specs_dir=specs_dir,
+    )
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    if error:
+        _metrics.counter(_metric(action), labels={"status": "error"})
+        # Include partial results in error response
+        return asdict(
+            error_response(
+                error,
+                error_code=ErrorCode.OPERATION_FAILED,
+                error_type=ErrorType.VALIDATION,
+                request_id=request_id,
+                details=result if result else None,
+            )
+        )
+
+    _metrics.timer(_metric(action) + ".duration_ms", elapsed_ms)
+    _metrics.counter(_metric(action), labels={"status": "success"})
+
+    response = success_response(
+        spec_id=spec_id.strip(),
+        started=result.get("started", []),
+        started_count=result.get("started_count", 0),
+        started_at=result.get("started_at"),
+        request_id=request_id,
+        telemetry={"duration_ms": round(elapsed_ms, 2)},
+    )
+    return _attach_meta(asdict(response), request_id=request_id, duration_ms=elapsed_ms)
+
+
+def _handle_complete_batch(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
+    """Handle complete-batch action for completing multiple tasks with partial failure support."""
+    request_id = _request_id()
+    action = "complete-batch"
+    spec_id = payload.get("spec_id")
+    if not isinstance(spec_id, str) or not spec_id.strip():
+        return _validation_error(field="spec_id", action=action, message="Provide a non-empty spec identifier", request_id=request_id)
+
+    completions = payload.get("completions")
+    if not isinstance(completions, list) or not completions:
+        return _validation_error(field="completions", action=action, message="Provide a non-empty list of completions", request_id=request_id)
+
+    workspace = payload.get("workspace")
+    specs_dir = _resolve_specs_dir(config, workspace)
+    if specs_dir is None:
+        return _specs_dir_missing_error(request_id)
+
+    start = time.perf_counter()
+    result, error = complete_batch(spec_id=spec_id.strip(), completions=completions, specs_dir=specs_dir)
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    if error:
+        _metrics.counter(_metric(action), labels={"status": "error"})
+        return asdict(error_response(error, error_code=ErrorCode.OPERATION_FAILED, error_type=ErrorType.VALIDATION, request_id=request_id, details=result if result else None))
+
+    _metrics.timer(_metric(action) + ".duration_ms", elapsed_ms)
+    _metrics.counter(_metric(action), labels={"status": "success"})
+
+    response = success_response(
+        spec_id=spec_id.strip(),
+        results=result.get("results", {}),
+        completed_count=result.get("completed_count", 0),
+        failed_count=result.get("failed_count", 0),
+        total_processed=result.get("total_processed", 0),
+        request_id=request_id,
+        telemetry={"duration_ms": round(elapsed_ms, 2)},
+    )
+    return _attach_meta(asdict(response), request_id=request_id, duration_ms=elapsed_ms)
+
+
+def _handle_reset_batch(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
+    """
+    Handle reset-batch action for resetting stale or specified in_progress tasks.
+
+    Resets tasks back to pending status and clears started_at timestamp.
+    If task_ids not provided, finds stale tasks automatically based on threshold.
+    """
+    request_id = _request_id()
+    action = "reset-batch"
+    spec_id = payload.get("spec_id")
+    if not isinstance(spec_id, str) or not spec_id.strip():
+        return _validation_error(
+            field="spec_id",
+            action=action,
+            message="Provide a non-empty spec identifier",
+            request_id=request_id,
+        )
+
+    # Optional: specific task IDs to reset
+    task_ids = payload.get("task_ids")
+    if task_ids is not None:
+        if not isinstance(task_ids, list):
+            return _validation_error(
+                field="task_ids",
+                action=action,
+                message="task_ids must be a list of strings",
+                request_id=request_id,
+            )
+        # Validate all task_ids are strings
+        for i, tid in enumerate(task_ids):
+            if not isinstance(tid, str) or not tid.strip():
+                return _validation_error(
+                    field=f"task_ids[{i}]",
+                    action=action,
+                    message="Each task ID must be a non-empty string",
+                    request_id=request_id,
+                    code=ErrorCode.VALIDATION_ERROR,
+                )
+        task_ids = [tid.strip() for tid in task_ids]
+
+    # Optional: threshold in hours for stale detection
+    threshold_hours = payload.get("threshold_hours", STALE_TASK_THRESHOLD_HOURS)
+    if not isinstance(threshold_hours, (int, float)) or threshold_hours <= 0:
+        return _validation_error(
+            field="threshold_hours",
+            action=action,
+            message="threshold_hours must be a positive number",
+            request_id=request_id,
+        )
+
+    workspace = payload.get("workspace")
+    specs_dir = _resolve_specs_dir(config, workspace)
+    if specs_dir is None:
+        return _specs_dir_missing_error(request_id)
+
+    start = time.perf_counter()
+    result, error = reset_batch(
+        spec_id=spec_id.strip(),
+        task_ids=task_ids,
+        threshold_hours=float(threshold_hours),
+        specs_dir=specs_dir,
+    )
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    if error:
+        _metrics.counter(_metric(action), labels={"status": "error"})
+        return asdict(
+            error_response(
+                error,
+                error_code=ErrorCode.OPERATION_FAILED,
+                error_type=ErrorType.VALIDATION,
+                request_id=request_id,
+                details=result if result else None,
+            )
+        )
+
+    _metrics.timer(_metric(action) + ".duration_ms", elapsed_ms)
+    _metrics.counter(_metric(action), labels={"status": "success"})
+
+    response = success_response(
+        spec_id=spec_id.strip(),
+        reset=result.get("reset", []),
+        reset_count=result.get("reset_count", 0),
+        errors=result.get("errors"),
+        message=result.get("message"),
+        request_id=request_id,
+        telemetry={"duration_ms": round(elapsed_ms, 2)},
+    )
+    return _attach_meta(asdict(response), request_id=request_id, duration_ms=elapsed_ms)
+
+
 def _handle_next(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
     request_id = _request_id()
     action = "next"
@@ -1084,6 +1394,35 @@ def _handle_complete(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
     sync_computed_fields(spec_data)
 
     task_data = spec_data.get("hierarchy", {}).get(task_id.strip(), {})
+
+    # Determine if commit is suggested based on git cadence config
+    suggest_commit = False
+    commit_scope: Optional[str] = None
+    commit_message_hint: Optional[str] = None
+
+    if config.git.enabled:
+        cadence = config.git.commit_cadence
+        hierarchy = spec_data.get("hierarchy", {})
+
+        if cadence == "task":
+            suggest_commit = True
+            commit_scope = "task"
+            commit_message_hint = f"task: {task_data.get('title', task_id.strip())}"
+        elif cadence == "phase":
+            # Check if parent phase just completed
+            parent_id = task_data.get("parent")
+            if parent_id:
+                parent_data = hierarchy.get(parent_id, {})
+                # Only suggest commit if parent is a phase and is now completed
+                if (
+                    parent_data.get("type") == "phase"
+                    and parent_data.get("status") == "completed"
+                ):
+                    suggest_commit = True
+                    commit_scope = "phase"
+                    commit_message_hint = (
+                        f"phase: {parent_data.get('title', parent_id)}"
+                    )
     add_journal_entry(
         spec_data,
         title=f"Task Completed: {task_data.get('title', task_id.strip())}",
@@ -1116,6 +1455,9 @@ def _handle_complete(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
             "total_tasks": progress.get("total_tasks", 0),
             "percentage": progress.get("percentage", 0),
         },
+        suggest_commit=suggest_commit,
+        commit_scope=commit_scope,
+        commit_message_hint=commit_message_hint,
         request_id=request_id,
         telemetry={"duration_ms": round(elapsed_ms, 2)},
     )
@@ -1433,6 +1775,12 @@ def _handle_add(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
     action = "add"
     spec_id = payload.get("spec_id")
     parent = payload.get("parent")
+    phase_id = payload.get("phase_id")  # Alias for parent
+
+    # Use phase_id as parent if parent not provided
+    if parent is None and phase_id is not None:
+        parent = phase_id
+
     title = payload.get("title")
     description = payload.get("description")
     task_type = payload.get("task_type", "task")
@@ -1440,6 +1788,11 @@ def _handle_add(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
     position = payload.get("position")
     file_path = payload.get("file_path")
 
+    # Research-specific parameters
+    research_type = payload.get("research_type")
+    blocking_mode = payload.get("blocking_mode")
+    query = payload.get("query")
+
     if not isinstance(spec_id, str) or not spec_id.strip():
         return _validation_error(
             field="spec_id",
@@ -1502,6 +1855,49 @@ def _handle_add(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
             code=ErrorCode.INVALID_FORMAT,
         )
 
+    # Validate research-specific parameters when task_type is "research"
+    if task_type == "research":
+        from foundry_mcp.core.validation import VALID_RESEARCH_TYPES, RESEARCH_BLOCKING_MODES
+
+        if research_type is not None and not isinstance(research_type, str):
+            return _validation_error(
+                field="research_type",
+                action=action,
+                message="research_type must be a string",
+                request_id=request_id,
+                code=ErrorCode.INVALID_FORMAT,
+            )
+        if research_type and research_type not in VALID_RESEARCH_TYPES:
+            return _validation_error(
+                field="research_type",
+                action=action,
+                message=f"Must be one of: {', '.join(sorted(VALID_RESEARCH_TYPES))}",
+                request_id=request_id,
+            )
+        if blocking_mode is not None and not isinstance(blocking_mode, str):
+            return _validation_error(
+                field="blocking_mode",
+                action=action,
+                message="blocking_mode must be a string",
+                request_id=request_id,
+                code=ErrorCode.INVALID_FORMAT,
+            )
+        if blocking_mode and blocking_mode not in RESEARCH_BLOCKING_MODES:
+            return _validation_error(
+                field="blocking_mode",
+                action=action,
+                message=f"Must be one of: {', '.join(sorted(RESEARCH_BLOCKING_MODES))}",
+                request_id=request_id,
+            )
+        if query is not None and not isinstance(query, str):
+            return _validation_error(
+                field="query",
+                action=action,
+                message="query must be a string",
+                request_id=request_id,
+                code=ErrorCode.INVALID_FORMAT,
+            )
+
     dry_run = payload.get("dry_run", False)
     if dry_run is not None and not isinstance(dry_run, bool):
         return _validation_error(
@@ -1542,16 +1938,22 @@ def _handle_add(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
             )
 
         elapsed_ms = (time.perf_counter() - start) * 1000
+        dry_run_data: Dict[str, Any] = {
+            "spec_id": spec_id.strip(),
+            "parent": parent.strip(),
+            "title": title.strip(),
+            "task_type": task_type,
+            "position": position,
+            "file_path": file_path.strip() if file_path else None,
+            "dry_run": True,
+        }
+        # Include research parameters in dry_run response
+        if task_type == "research":
+            dry_run_data["research_type"] = research_type
+            dry_run_data["blocking_mode"] = blocking_mode
+            dry_run_data["query"] = query
         response = success_response(
-            data={
-                "spec_id": spec_id.strip(),
-                "parent": parent.strip(),
-                "title": title.strip(),
-                "task_type": task_type,
-                "position": position,
-                "file_path": file_path.strip() if file_path else None,
-                "dry_run": True,
-            },
+            data=dry_run_data,
             request_id=request_id,
             telemetry={"duration_ms": round(elapsed_ms, 2)},
         )
@@ -1571,6 +1973,10 @@ def _handle_add(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
         position=position,
         file_path=file_path,
         specs_dir=specs_dir,
+        # Research-specific parameters
+        research_type=research_type,
+        blocking_mode=blocking_mode,
+        query=query,
     )
     elapsed_ms = (time.perf_counter() - start) * 1000
 
@@ -3087,12 +3493,114 @@ def _handle_fix_verification_types(
     return asdict(response)
 
 
+def _handle_session_config(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
+    """
+    Handle session-config action: get/set autonomous mode preferences.
+
+    This action manages the ephemeral autonomous session state, allowing
+    agents to enable/disable autonomous mode and track task completion
+    during autonomous execution.
+
+    Parameters:
+        get: If true, just return current session config without changes
+        auto_mode: Set autonomous mode enabled (true) or disabled (false)
+
+    Returns:
+        Current session configuration including autonomous state
+    """
+    from datetime import datetime, timezone
+
+    request_id = _request_id()
+    action = "session-config"
+    start = time.perf_counter()
+
+    # Get parameters
+    get_only = payload.get("get", False)
+    auto_mode = payload.get("auto_mode")
+
+    # Get the context tracker and session
+    tracker = get_context_tracker()
+    session = tracker.get_or_create_session()
+
+    # Initialize autonomous if not present
+    if session.autonomous is None:
+        session.autonomous = AutonomousSession()
+
+    # If just getting, return current state
+    if get_only:
+        elapsed_ms = (time.perf_counter() - start) * 1000
+        response = success_response(
+            session_id=session.session_id,
+            autonomous=session.autonomous.to_dict(),
+            message="Current session configuration",
+            request_id=request_id,
+            telemetry={"duration_ms": round(elapsed_ms, 2)},
+        )
+        _metrics.counter(_metric(action), labels={"status": "success", "operation": "get"})
+        return asdict(response)
+
+    # Handle auto_mode setting
+    if auto_mode is not None:
+        if not isinstance(auto_mode, bool):
+            return _validation_error(
+                field="auto_mode",
+                action=action,
+                message="auto_mode must be a boolean (true/false)",
+                request_id=request_id,
+            )
+
+        previous_enabled = session.autonomous.enabled
+        session.autonomous.enabled = auto_mode
+
+        if auto_mode and not previous_enabled:
+            # Starting autonomous mode
+            session.autonomous.started_at = (
+                datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+            )
+            session.autonomous.tasks_completed = 0
+            session.autonomous.pause_reason = None
+        elif not auto_mode and previous_enabled:
+            # Stopping autonomous mode
+            session.autonomous.pause_reason = "user"
+
+    elapsed_ms = (time.perf_counter() - start) * 1000
+    response = success_response(
+        session_id=session.session_id,
+        autonomous=session.autonomous.to_dict(),
+        message="Autonomous mode enabled" if session.autonomous.enabled else "Autonomous mode disabled",
+        request_id=request_id,
+        telemetry={"duration_ms": round(elapsed_ms, 2)},
+    )
+    _metrics.counter(_metric(action), labels={"status": "success", "operation": "set"})
+    return asdict(response)
+
+
 _ACTION_DEFINITIONS = [
     ActionDefinition(
         name="prepare",
         handler=_handle_prepare,
         summary="Prepare next actionable task context",
     ),
+    ActionDefinition(
+        name="prepare-batch",
+        handler=_handle_prepare_batch,
+        summary="Prepare multiple independent tasks for parallel execution",
+    ),
+    ActionDefinition(
+        name="start-batch",
+        handler=_handle_start_batch,
+        summary="Atomically start multiple tasks as in_progress",
+    ),
+    ActionDefinition(
+        name="complete-batch",
+        handler=_handle_complete_batch,
+        summary="Complete multiple tasks with partial failure support",
+    ),
+    ActionDefinition(
+        name="reset-batch",
+        handler=_handle_reset_batch,
+        summary="Reset stale or specified in_progress tasks to pending",
+    ),
     ActionDefinition(
         name="next", handler=_handle_next, summary="Return the next actionable task"
     ),
@@ -3182,6 +3690,11 @@ _ACTION_DEFINITIONS = [
         handler=_handle_hierarchy,
         summary="Return paginated hierarchy slices",
     ),
+    ActionDefinition(
+        name="session-config",
+        handler=_handle_session_config,
+        summary="Get/set autonomous session configuration",
+    ),
 ]
 
 _TASK_ROUTER = ActionRouter(tool_name="task", actions=_ACTION_DEFINITIONS)
@@ -3260,6 +3773,9 @@ def register_unified_task_tool(mcp: FastMCP, config: ServerConfig) -> None:
         category: Optional[str] = None,
         parent_filter: Optional[str] = None,
         update_metadata: Optional[Dict[str, Any]] = None,
+        # session-config specific parameters
+        get: bool = False,
+        auto_mode: Optional[bool] = None,
     ) -> dict:
         payload = {
             "spec_id": spec_id,
@@ -3306,6 +3822,9 @@ def register_unified_task_tool(mcp: FastMCP, config: ServerConfig) -> None:
             "category": category,
             "parent_filter": parent_filter,
             "update_metadata": update_metadata,
+            # session-config specific
+            "get": get,
+            "auto_mode": auto_mode,
         }
         return _dispatch_task_action(action=action, payload=payload, config=config)
 

{foundry_mcp-0.7.0.dist-info → foundry_mcp-0.8.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foundry-mcp
-Version: 0.7.0
+Version: 0.8.10
 Summary: MCP server for SDD toolkit spec management
 Project-URL: Homepage, https://github.com/tylerburleigh/foundry-mcp
 Project-URL: Repository, https://github.com/tylerburleigh/foundry-mcp
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0.0
 Requires-Dist: fastmcp>=0.1.0
+Requires-Dist: filelock>=3.20.1
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: tomli>=2.0.0; python_version < '3.11'
 Provides-Extra: dashboard