minder-cli 0.2.0__py3-none-any.whl

minder/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import sys
+import warnings
+
+if sys.version_info >= (3, 14):
+    warnings.filterwarnings(
+        "ignore",
+        message=r"Core Pydantic V1 functionality isn't compatible with Python 3\.14 or greater\.",
+        category=UserWarning,
+        module=r"langchain_core\._api\.deprecation",
+    )

minder/api/routers/prompts.py

@@ -0,0 +1,177 @@
+import uuid
+import logging
+from typing import List, Optional
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel, Field
+
+from minder.observability.metrics import record_admin_operation
+from minder.store.interfaces import IOperationalStore
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(
+    prefix="/api/v1/prompts",
+    tags=["prompts"],
+)
+
+
+class PromptCreate(BaseModel):
+    name: str
+    title: str
+    description: str
+    content_template: str
+    arguments: List[str] = Field(default_factory=list)
+
+
+class PromptUpdate(BaseModel):
+    name: Optional[str] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
+    content_template: Optional[str] = None
+    arguments: Optional[List[str]] = None
+
+
+class PromptResponse(BaseModel):
+    id: str
+    name: str
+    title: str
+    description: str
+    content_template: str
+    arguments: List[str]
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+
+def get_store(request: Request) -> IOperationalStore:
+    return request.app.state.store
+
+
+@router.get("", response_model=List[PromptResponse])
+async def list_prompts(store: IOperationalStore = Depends(get_store)):
+    await record_admin_operation(
+        operation="list_prompts", outcome="success", actor_id="system", store=store
+    )
+    try:
+        prompts = await store.list_prompts()
+        return [
+            PromptResponse(
+                id=str(p.id),
+                name=p.name,
+                title=p.title,
+                description=p.description,
+                content_template=p.content_template,
+                arguments=p.arguments,
+                created_at=p.created_at,
+                updated_at=p.updated_at,
+            )
+            for p in prompts
+        ]
+    except Exception as e:
+        logger.exception("Failed to list prompts", exc_info=e)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("", response_model=PromptResponse, status_code=201)
+async def create_prompt(
+    payload: PromptCreate, store: IOperationalStore = Depends(get_store)
+):
+    await record_admin_operation(
+        operation="create_prompt", outcome="success", actor_id="system", store=store
+    )
+    try:
+        prompt = await store.create_prompt(
+            name=payload.name,
+            title=payload.title,
+            description=payload.description,
+            content_template=payload.content_template,
+            arguments=payload.arguments,
+        )
+        return PromptResponse(
+            id=str(prompt.id),
+            name=prompt.name,
+            title=prompt.title,
+            description=prompt.description,
+            content_template=prompt.content_template,
+            arguments=prompt.arguments,
+            created_at=prompt.created_at,
+            updated_at=prompt.updated_at,
+        )
+    except Exception as e:
+        logger.exception("Failed to create prompt", exc_info=e)
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/{prompt_id}", response_model=PromptResponse)
+async def get_prompt(
+    prompt_id: uuid.UUID, store: IOperationalStore = Depends(get_store)
+):
+    await record_admin_operation(
+        operation="get_prompt", outcome="success", actor_id="system", store=store
+    )
+    try:
+        prompt = await store.get_prompt_by_id(prompt_id)
+        if not prompt:
+            raise HTTPException(status_code=404, detail="Prompt not found")
+        return PromptResponse(
+            id=str(prompt.id),
+            name=prompt.name,
+            title=prompt.title,
+            description=prompt.description,
+            content_template=prompt.content_template,
+            arguments=prompt.arguments,
+            created_at=prompt.created_at,
+            updated_at=prompt.updated_at,
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.exception("Failed to get prompt", exc_info=e)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.patch("/{prompt_id}", response_model=PromptResponse)
+@router.put("/{prompt_id}", response_model=PromptResponse)
+async def update_prompt(
+    prompt_id: uuid.UUID,
+    payload: PromptUpdate,
+    store: IOperationalStore = Depends(get_store),
+):
+    await record_admin_operation(
+        operation="update_prompt", outcome="success", actor_id="system", store=store
+    )
+    try:
+        update_data = payload.model_dump(exclude_unset=True)
+        prompt = await store.update_prompt(prompt_id, **update_data)
+        if not prompt:
+            raise HTTPException(status_code=404, detail="Prompt not found")
+        return PromptResponse(
+            id=str(prompt.id),
+            name=prompt.name,
+            title=prompt.title,
+            description=prompt.description,
+            content_template=prompt.content_template,
+            arguments=prompt.arguments,
+            created_at=prompt.created_at,
+            updated_at=prompt.updated_at,
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.exception("Failed to update prompt", exc_info=e)
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.delete("/{prompt_id}", status_code=204)
+async def delete_prompt(
+    prompt_id: uuid.UUID, store: IOperationalStore = Depends(get_store)
+):
+    await record_admin_operation(
+        operation="delete_prompt", outcome="success", actor_id="system", store=store
+    )
+    try:
+        await store.delete_prompt(prompt_id)
+    except Exception as e:
+        logger.exception("Failed to delete prompt", exc_info=e)
+        raise HTTPException(status_code=500, detail=str(e))

minder/application/__init__.py

@@ -0,0 +1 @@
+__all__: list[str] = []

minder/application/admin/__init__.py

@@ -0,0 +1,11 @@
+from minder.application.admin.use_cases import (
+    AdminConsoleUseCases,
+    DASHBOARD_TOOL_SCOPE_OPTIONS,
+    DASHBOARD_TOOL_SCOPE_PRESETS,
+)
+
+__all__ = [
+    "AdminConsoleUseCases",
+    "DASHBOARD_TOOL_SCOPE_OPTIONS",
+    "DASHBOARD_TOOL_SCOPE_PRESETS",
+]

minder/application/admin/dto.py

@@ -0,0 +1,453 @@
+from __future__ import annotations
+
+from typing import Any, Literal, TypedDict
+
+from pydantic import BaseModel, Field
+
+GraphSyncNodeType = Literal[
+    "repository",
+    "service",
+    "module",
+    "file",
+    "function",
+    "class",
+    "interface",
+    "abstract_class",
+    "controller",
+    "route",
+    "todo",
+    "external_service_api",
+    "mq_topic",
+    # v2 — new node types
+    "api_endpoint",
+    "websocket_endpoint",
+    "mq_producer",
+    "mq_consumer",
+]
+
+GraphSyncRelationType = Literal[
+    "contains",
+    "imports",
+    "depends_on",
+    "calls",
+    "implements",
+    "extends",
+    "exposes_route",
+    "uses_external_service",
+    "publishes",
+    "consumes",
+    "tracks",
+    # v2 — new relation types
+    "websocket",
+    "cross_repo_calls",
+    "exposes_websocket",
+]
+
+
+class ClientPayload(TypedDict):
+    id: str
+    name: str
+    slug: str
+    description: str
+    status: str
+    tool_scopes: list[str]
+    repo_scopes: list[str]
+    workflow_scopes: list[str]
+    transport_modes: list[str]
+
+
+class ActivityEventPayload(TypedDict):
+    event_type: str
+    created_at: str
+
+
+class AuditEventPayload(TypedDict):
+    id: str
+    actor_type: str
+    actor_id: str
+    actor_name: str | None  # display_name or slug for context
+    event_type: str
+    resource_type: str
+    resource_id: str
+    resource_name: str | None  # human-readable name for the resource
+    outcome: str
+    created_at: str | None
+
+
+class ClientListPayload(TypedDict):
+    clients: list[ClientPayload]
+
+
+class CreateClientPayload(TypedDict):
+    client: ClientPayload
+    client_api_key: str
+
+
+class ClientDetailPayload(TypedDict):
+    client: ClientPayload
+
+
+class OnboardingPayload(TypedDict):
+    client: ClientPayload
+    templates: dict[str, str]
+
+
+class ClientConnectionTestPayload(TypedDict):
+    ok: bool
+    client: ClientPayload
+    templates: dict[str, str]
+
+
+class ClientKeyPayload(TypedDict):
+    client_api_key: str
+
+
+class RevokeKeysPayload(TypedDict):
+    revoked: bool
+
+
+class AuditListPayload(TypedDict):
+    events: list[AuditEventPayload]
+    total: int
+    limit: int
+    offset: int
+
+
+class SetupResultPayload(TypedDict):
+    api_key: str
+
+
+class AdminLoginPayload(TypedDict):
+    jwt: str
+
+
+class AdminSessionPayload(TypedDict):
+    id: str
+    username: str
+    email: str
+    display_name: str
+    role: str
+
+
+# ---------------------------------------------------------------------------
+# User management
+# ---------------------------------------------------------------------------
+
+
+class UserPayload(TypedDict):
+    id: str
+    username: str
+    email: str
+    display_name: str
+    role: str
+    is_active: bool
+    created_at: str | None
+
+
+class UserListPayload(TypedDict):
+    users: list[UserPayload]
+
+
+class UserDetailPayload(TypedDict):
+    user: UserPayload
+    clients: list[ClientPayload]  # MCP clients created by this user
+
+
+class CreateUserPayload(TypedDict):
+    user: UserPayload
+    api_key: str
+
+
+# ---------------------------------------------------------------------------
+# Workflow management
+# ---------------------------------------------------------------------------
+
+
+class WorkflowStepPayload(TypedDict):
+    name: str
+    description: str
+    gate: str | None
+
+
+class WorkflowPayload(TypedDict):
+    id: str
+    name: str
+    description: str
+    enforcement: str
+    steps: list[WorkflowStepPayload]
+    created_at: str | None
+
+
+class WorkflowListPayload(TypedDict):
+    workflows: list[WorkflowPayload]
+
+
+class WorkflowDetailPayload(TypedDict):
+    workflow: WorkflowPayload
+
+
+# ---------------------------------------------------------------------------
+# Repository management
+# ---------------------------------------------------------------------------
+
+
+class RepositoryPayload(TypedDict):
+    id: str
+    name: str
+    path: str
+    remote_url: str | None
+    default_branch: str | None
+    tracked_branches: list[str]
+    workflow_name: str | None
+    workflow_state: str | None
+    current_step: str | None
+    created_at: str | None
+
+
+class RepositoryBranchPayload(TypedDict):
+    branch: str
+    is_default: bool
+    last_synced: str | None
+    payload_version: str | None
+    source: str | None
+    node_count: int
+    edge_count: int
+    deleted_nodes: int
+    repo_path: str | None
+    diff_base: str | None
+
+
+class RepositoryBranchListPayload(TypedDict):
+    repo_id: str
+    default_branch: str | None
+    tracked_branches: list[RepositoryBranchPayload]
+
+
+class RepositoryBranchLinkPayload(TypedDict):
+    id: str
+    source_repo_id: str
+    source_repo_name: str
+    source_repo_url: str | None
+    source_branch: str
+    target_repo_id: str | None
+    target_repo_name: str
+    target_repo_url: str | None
+    target_branch: str
+    relation: str
+    direction: str
+    confidence: float
+    last_seen_at: str | None
+    source: str | None
+    metadata: dict[str, Any]
+
+
+class RepositoryBranchLinkListPayload(TypedDict):
+    repo_id: str
+    branch: str | None
+    links: list[RepositoryBranchLinkPayload]
+
+
+class RepositoryListPayload(TypedDict):
+    repositories: list[RepositoryPayload]
+
+
+class RepositoryDetailPayload(TypedDict):
+    repository: RepositoryPayload
+
+
+class UpdateRepositoryPayload(TypedDict, total=False):
+    name: str
+    remote_url: str | None
+    default_branch: str | None
+    path: str
+
+
+class DeleteRepositoryPayload(TypedDict):
+    deleted: bool
+
+
+class ClientRepositoryResolveRequest(BaseModel):
+    repo_name: str
+    repo_path: str
+    repo_url: str | None = None
+    default_branch: str | None = None
+
+
+class ClientRepositoryResolvePayload(TypedDict):
+    repository: RepositoryPayload
+    created: bool
+
+
+class GraphSyncNodeRefRequest(BaseModel):
+    node_type: GraphSyncNodeType
+    name: str
+
+
+class GraphSyncNodeRequest(BaseModel):
+    node_type: GraphSyncNodeType
+    name: str
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class GraphSyncEdgeRequest(BaseModel):
+    source: GraphSyncNodeRefRequest
+    target: GraphSyncNodeRefRequest
+    relation: GraphSyncRelationType
+    weight: float = 1.0
+
+
+class GraphSyncBranchLinkRequest(BaseModel):
+    source_branch: str | None = None
+    target_repo_id: str | None = None
+    target_repo_name: str
+    target_repo_url: str | None = None
+    target_branch: str
+    relation: str = "depends_on"
+    direction: Literal["outbound", "inbound", "bidirectional"] = "outbound"
+    confidence: float = 1.0
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class GraphSyncRequest(BaseModel):
+    payload_version: str
+    source: str = "minder-cli"
+    repo_path: str | None = None
+    branch: str | None = None
+    diff_base: str | None = None
+    deleted_files: list[str] = Field(default_factory=list)
+    sync_metadata: dict[str, Any] = Field(default_factory=dict)
+    nodes: list[GraphSyncNodeRequest] = Field(default_factory=list)
+    edges: list[GraphSyncEdgeRequest] = Field(default_factory=list)
+    branch_relationships: list[GraphSyncBranchLinkRequest] = Field(default_factory=list)
+
+
+class UpsertRepositoryBranchLinkRequest(BaseModel):
+    source_branch: str
+    target_repo_id: str | None = None
+    target_repo_name: str | None = None
+    target_repo_url: str | None = None
+    target_branch: str
+    relation: str = "depends_on"
+    direction: Literal["outbound", "inbound", "bidirectional"] = "outbound"
+    confidence: float = 1.0
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class GraphSyncResultPayload(TypedDict):
+    repo_id: str
+    repository_name: str
+    payload_version: str
+    source: str
+    branch: str | None
+    deleted_nodes: int
+    nodes_upserted: int
+    edges_upserted: int
+    accepted_at: str
+
+
+class RepositoryGraphNodePayload(TypedDict):
+    id: str
+    node_type: str
+    name: str
+    metadata: dict[str, Any]
+
+
+class RepositoryGraphScopePayload(TypedDict):
+    repo_id: str
+    repo_name: str
+    repo_path: str | None
+    branch: str | None
+    distance: int
+    via_link: dict[str, Any] | None
+
+
+class RepositoryGraphResultNodePayload(RepositoryGraphNodePayload, total=False):
+    score: int
+    direction: str
+    distance: int
+    repo_id: str
+    repo_name: str
+    branch: str | None
+    landscape_distance: int
+    via_link: dict[str, Any] | None
+
+
+class RepositoryGraphEdgePayload(TypedDict):
+    id: str
+    source_id: str
+    target_id: str
+    relation: str
+    weight: float
+
+
+class RepositoryGraphSummaryPayload(TypedDict):
+    repository: RepositoryPayload
+    graph_available: bool
+    active_branch: str | None
+    branch_state: RepositoryBranchPayload | None
+    branch_links: list[RepositoryBranchLinkPayload]
+    last_sync: dict[str, Any] | None
+    node_count: int
+    counts_by_type: dict[str, int]
+    routes: list[RepositoryGraphNodePayload]
+    todos: list[RepositoryGraphNodePayload]
+    external_services: list[RepositoryGraphNodePayload]
+    dependencies: list[dict[str, Any]]
+
+
+class RepositoryGraphSearchPayload(TypedDict):
+    repository: RepositoryPayload
+    active_branch: str | None
+    query: str
+    filters: dict[str, Any]
+    scope_count: int
+    searched_scopes: list[RepositoryGraphScopePayload]
+    count: int
+    results: list[RepositoryGraphResultNodePayload]
+
+
+class RepositoryGraphImpactPayload(TypedDict):
+    repository: RepositoryPayload
+    active_branch: str | None
+    target: str
+    searched_scopes: list[RepositoryGraphScopePayload]
+    matches: list[RepositoryGraphResultNodePayload]
+    impacted: list[RepositoryGraphResultNodePayload]
+    summary: dict[str, Any]
+
+
+class RepositoryGraphMapPayload(TypedDict):
+    repository: RepositoryPayload
+    graph_available: bool
+    branch: str | None
+    branch_state: RepositoryBranchPayload | None
+    branch_links: list[RepositoryBranchLinkPayload]
+    nodes: list[RepositoryGraphNodePayload]
+    edges: list[RepositoryGraphEdgePayload]
+    summary: dict[str, Any]
+
+
+class RepositoryLandscapeNodePayload(TypedDict):
+    id: str
+    repo_id: str
+    repo_name: str
+    branch: str
+    remote_url: str | None
+    is_default: bool
+    last_synced: str | None
+
+
+class RepositoryLandscapeEdgePayload(TypedDict):
+    id: str
+    source_id: str
+    target_id: str
+    relation: str
+    direction: str
+    confidence: float
+
+
+class RepositoryLandscapePayload(TypedDict):
+    repositories: list[RepositoryPayload]
+    nodes: list[RepositoryLandscapeNodePayload]
+    edges: list[RepositoryLandscapeEdgePayload]
+    summary: dict[str, int]