minder-cli 0.5.2__tar.gz → 0.5.3__tar.gz

{minder_cli-0.5.2 → minder_cli-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minder-cli
-Version: 0.5.2
+Version: 0.5.3
 Summary: Minder CLI is the command-line interface for the Minder self-hosted MCP platform.
 Project-URL: Homepage, https://github.com/hiimtrung/minder
 Project-URL: Repository, https://github.com/hiimtrung/minder

{minder_cli-0.5.2 → minder_cli-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "minder-cli"
-version = "0.5.2"
+version = "0.5.3"
 description = "Minder CLI is the command-line interface for the Minder self-hosted MCP platform."
 readme = "README.md"
 requires-python = ">=3.14"

{minder_cli-0.5.2 → minder_cli-0.5.3}/src/minder/application/admin/dto.py

@@ -479,3 +479,27 @@ class RepositoryLandscapePayload(TypedDict):
     nodes: list[RepositoryLandscapeNodePayload]
     edges: list[RepositoryLandscapeEdgePayload]
     summary: dict[str, int]
+
+
+
+class AgentPayload(TypedDict):
+    id: str
+    name: str
+    title: str
+    description: str
+    system_prompt: str
+    tools: list[str]
+    workflow_steps: list[str]
+    artifact_types: list[str]
+    tags: list[str]
+    is_default: bool
+    created_at: str | None
+    updated_at: str | None
+
+
+class AgentListPayload(TypedDict):
+    agents: list[AgentPayload]
+
+
+class AgentDetailPayload(TypedDict):
+    agent: AgentPayload

{minder_cli-0.5.2 → minder_cli-0.5.3}/src/minder/application/admin/use_cases.py

@@ -13,6 +13,9 @@ from minder.application.admin.dto import (
     ActivityEventPayload,
     AdminLoginPayload,
     AdminSessionPayload,
+    AgentDetailPayload,
+    AgentListPayload,
+    AgentPayload,
     AuditEventPayload,
     AuditListPayload,
     ClientConnectionTestPayload,
@@ -651,6 +654,116 @@ class AdminConsoleUseCases:
             ),
         }
 
+    # ------------------------------------------------------------------
+    # SubAgent management
+    # ------------------------------------------------------------------
+
+    async def list_agents(self) -> AgentListPayload:
+        agents = await self._store.list_agents()
+        return {"agents": [self.serialize_agent(a) for a in agents]}
+
+    async def get_agent_detail(self, agent_id: uuid.UUID) -> AgentDetailPayload:
+        agent = await self._store.get_agent_by_id(agent_id)
+        if agent is None:
+            raise LookupError(f"Agent {agent_id} not found")
+        return {"agent": self.serialize_agent(agent)}
+
+    async def create_agent(
+        self,
+        *,
+        name: str,
+        title: str = "",
+        description: str = "",
+        system_prompt: str = "",
+        tools: list[str] | None = None,
+        workflow_steps: list[str] | None = None,
+        artifact_types: list[str] | None = None,
+        tags: list[str] | None = None,
+        is_default: bool = False,
+    ) -> AgentDetailPayload:
+        agent = await self._store.create_agent(
+            name=name,
+            title=title,
+            description=description,
+            system_prompt=system_prompt,
+            tools=tools or [],
+            workflow_steps=workflow_steps or [],
+            artifact_types=artifact_types or [],
+            tags=tags or [],
+            is_default=is_default,
+        )
+        return {"agent": self.serialize_agent(agent)}
+
+    async def update_agent(
+        self,
+        agent_id: uuid.UUID,
+        *,
+        name: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        system_prompt: str | None = None,
+        tools: list[str] | None = None,
+        workflow_steps: list[str] | None = None,
+        artifact_types: list[str] | None = None,
+        tags: list[str] | None = None,
+        is_default: bool | None = None,
+    ) -> AgentDetailPayload:
+        kwargs: dict[str, Any] = {}
+        if name is not None:
+            kwargs["name"] = name
+        if title is not None:
+            kwargs["title"] = title
+        if description is not None:
+            kwargs["description"] = description
+        if system_prompt is not None:
+            kwargs["system_prompt"] = system_prompt
+        if tools is not None:
+            kwargs["tools"] = tools
+        if workflow_steps is not None:
+            kwargs["workflow_steps"] = workflow_steps
+        if artifact_types is not None:
+            kwargs["artifact_types"] = artifact_types
+        if tags is not None:
+            kwargs["tags"] = tags
+        if is_default is not None:
+            kwargs["is_default"] = is_default
+        updated = await self._store.update_agent(agent_id, **kwargs)
+        if updated is None:
+            raise LookupError(f"Agent {agent_id} not found")
+        return {"agent": self.serialize_agent(updated)}
+
+    async def delete_agent(self, agent_id: uuid.UUID) -> dict[str, bool]:
+        existing = await self._store.get_agent_by_id(agent_id)
+        if existing is None:
+            raise LookupError(f"Agent {agent_id} not found")
+        await self._store.delete_agent(agent_id)
+        return {"deleted": True}
+
+    @staticmethod
+    def serialize_agent(agent: Any) -> AgentPayload:
+        return {
+            "id": str(agent.id),
+            "name": getattr(agent, "name", ""),
+            "title": getattr(agent, "title", ""),
+            "description": getattr(agent, "description", ""),
+            "system_prompt": getattr(agent, "system_prompt", ""),
+            "tools": list(getattr(agent, "tools", []) or []),
+            "workflow_steps": list(getattr(agent, "workflow_steps", []) or []),
+            "artifact_types": list(getattr(agent, "artifact_types", []) or []),
+            "tags": list(getattr(agent, "tags", []) or []),
+            "is_default": bool(getattr(agent, "is_default", False)),
+            "created_at": (
+                agent.created_at.isoformat()
+                if getattr(agent, "created_at", None)
+                else None
+            ),
+            "updated_at": (
+                agent.updated_at.isoformat()
+                if getattr(agent, "updated_at", None)
+                else None
+            ),
+        }
+
     # ------------------------------------------------------------------
     # Session management
     # ------------------------------------------------------------------
@@ -788,19 +901,43 @@ class AdminConsoleUseCases:
             if not normalized_path:
                 raise ValueError("Repository path is required")
             updates["state_path"] = normalized_path
+        new_workflow_id: uuid.UUID | None = _UNSET  # type: ignore[assignment]
         if workflow_id is not _UNSET:
             if workflow_id is None or str(workflow_id).strip() == "":
                 updates["workflow_id"] = None
+                new_workflow_id = None
             else:
                 wf_id = uuid.UUID(str(workflow_id))
                 workflow = await self._store.get_workflow_by_id(wf_id)
                 if workflow is None:
                     raise LookupError(f"Workflow {wf_id} not found")
                 updates["workflow_id"] = str(wf_id)
+                new_workflow_id = wf_id
 
         updated = await self._store.update_repository(repo_id, **updates)
         if updated is None:
             raise LookupError("Repository not found")
+
+        # Create workflow_state when a workflow is first assigned to a repo
+        if new_workflow_id is not _UNSET and new_workflow_id is not None:  # type: ignore[comparison-overlap]
+            existing_state = await self._store.get_workflow_state_by_repo(repo_id)
+            if existing_state is None:
+                workflow_obj = await self._store.get_workflow_by_id(new_workflow_id)
+                steps = list(getattr(workflow_obj, "steps", []) or []) if workflow_obj else []
+                step_names = [
+                    s["name"] for s in steps if isinstance(s, dict) and "name" in s
+                ]
+                first_step = step_names[0] if step_names else ""
+                second_step = step_names[1] if len(step_names) > 1 else None
+                await self._store.create_workflow_state(
+                    repo_id=repo_id,
+                    current_step=first_step,
+                    completed_steps=[],
+                    blocked_by=[],
+                    artifacts={},
+                    next_step=second_step,
+                )
+
         return await self.get_repository_detail(repo_id)
 
     async def delete_repository(self, repo_id: uuid.UUID) -> DeleteRepositoryPayload:

{minder_cli-0.5.2 → minder_cli-0.5.3}/src/minder/presentation/http/admin/api.py

@@ -520,6 +520,98 @@ def build_admin_api_routes(context: AdminRouteContext) -> list[BaseRoute]:
 
         return JSONResponse({"error": "Method not allowed"}, status_code=405)
 
+    # ------------------------------------------------------------------
+    # SubAgent management
+    # ------------------------------------------------------------------
+
+    async def admin_agents(request):
+        try:
+            await context.admin_user_from_request(request)
+        except PermissionError:
+            return JSONResponse({"error": "Admin role required"}, status_code=403)
+        except Exception as exc:
+            return JSONResponse({"error": str(exc)}, status_code=401)
+
+        if request.method == "GET":
+            return JSONResponse(await context.use_cases.list_agents())
+
+        if request.method == "POST":
+            try:
+                payload = await request.json()
+            except Exception:
+                return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+            name = str(payload.get("name", "")).strip()
+            if not name:
+                return JSONResponse({"error": "name is required"}, status_code=400)
+            try:
+                return JSONResponse(
+                    await context.use_cases.create_agent(
+                        name=name,
+                        title=str(payload.get("title", "")),
+                        description=str(payload.get("description", "")),
+                        system_prompt=str(payload.get("system_prompt", "")),
+                        tools=payload.get("tools") or [],
+                        workflow_steps=payload.get("workflow_steps") or [],
+                        artifact_types=payload.get("artifact_types") or [],
+                        tags=payload.get("tags") or [],
+                        is_default=bool(payload.get("is_default", False)),
+                    ),
+                    status_code=201,
+                )
+            except Exception as exc:
+                return JSONResponse({"error": str(exc)}, status_code=400)
+
+        return JSONResponse({"error": "Method not allowed"}, status_code=405)
+
+    async def agent_detail(request):
+        try:
+            await context.admin_user_from_request(request)
+        except PermissionError:
+            return JSONResponse({"error": "Admin role required"}, status_code=403)
+        except Exception as exc:
+            return JSONResponse({"error": str(exc)}, status_code=401)
+
+        agent_id = uuid.UUID(str(request.path_params["agent_id"]))
+
+        if request.method == "GET":
+            try:
+                return JSONResponse(await context.use_cases.get_agent_detail(agent_id))
+            except LookupError:
+                return JSONResponse({"error": "Agent not found"}, status_code=404)
+
+        if request.method == "PATCH":
+            try:
+                payload = await request.json()
+            except Exception:
+                return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+            try:
+                return JSONResponse(
+                    await context.use_cases.update_agent(
+                        agent_id,
+                        name=payload.get("name"),
+                        title=payload.get("title"),
+                        description=payload.get("description"),
+                        system_prompt=payload.get("system_prompt"),
+                        tools=payload.get("tools"),
+                        workflow_steps=payload.get("workflow_steps"),
+                        artifact_types=payload.get("artifact_types"),
+                        tags=payload.get("tags"),
+                        is_default=payload.get("is_default"),
+                    )
+                )
+            except LookupError:
+                return JSONResponse({"error": "Agent not found"}, status_code=404)
+            except Exception as exc:
+                return JSONResponse({"error": str(exc)}, status_code=400)
+
+        if request.method == "DELETE":
+            try:
+                return JSONResponse(await context.use_cases.delete_agent(agent_id))
+            except LookupError:
+                return JSONResponse({"error": "Agent not found"}, status_code=404)
+
+        return JSONResponse({"error": "Method not allowed"}, status_code=405)
+
     # ------------------------------------------------------------------
     # Workflow management
     # ------------------------------------------------------------------
@@ -1331,6 +1423,13 @@ def build_admin_api_routes(context: AdminRouteContext) -> list[BaseRoute]:
             user_detail,
             methods=["GET", "PATCH", "DELETE"],
         ),
+        # SubAgent management
+        Route("/v1/admin/agents", admin_agents, methods=["GET", "POST"]),
+        Route(
+            "/v1/admin/agents/{agent_id:uuid}",
+            agent_detail,
+            methods=["GET", "PATCH", "DELETE"],
+        ),
         # Workflow management
         Route("/v1/admin/workflows", admin_workflows, methods=["GET", "POST"]),
         Route(