minder-cli 0.4.4__tar.gz → 0.4.6__tar.gz

{minder_cli-0.4.4 → minder_cli-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minder-cli
-Version: 0.4.4
+Version: 0.4.6
 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.4.4 → minder_cli-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "minder-cli"
-version = "0.4.4"
+version = "0.4.6"
 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.4.4 → minder_cli-0.4.6}/src/minder/application/admin/dto.py

@@ -72,6 +72,7 @@ class AuditEventPayload(TypedDict):
     resource_name: str | None  # human-readable name for the resource
     outcome: str
     created_at: str | None
+    audit_metadata: dict | None
 
 
 class ClientListPayload(TypedDict):
@@ -129,6 +130,28 @@ class AdminSessionPayload(TypedDict):
     role: str
 
 
+class SessionPayload(TypedDict):
+    id: str
+    user_id: str | None
+    client_id: str | None
+    name: str | None
+    repo_id: str | None
+    project_context: dict[str, Any]
+    active_skills: dict[str, Any]
+    state: dict[str, Any]
+    ttl: int
+    created_at: str
+    last_active: str
+
+
+class SessionListPayload(TypedDict):
+    sessions: list[SessionPayload]
+
+
+class SessionDetailPayload(TypedDict):
+    session: SessionPayload
+
+
 # ---------------------------------------------------------------------------
 # User management
 # ---------------------------------------------------------------------------
@@ -198,6 +221,7 @@ class RepositoryPayload(TypedDict):
     remote_url: str | None
     default_branch: str | None
     tracked_branches: list[str]
+    workflow_id: str | None
     workflow_name: str | None
     workflow_state: str | None
     current_step: str | None
@@ -260,6 +284,7 @@ class UpdateRepositoryPayload(TypedDict, total=False):
     remote_url: str | None
     default_branch: str | None
     path: str
+    workflow_id: str | None
 
 
 class DeleteRepositoryPayload(TypedDict):

{minder_cli-0.4.4 → minder_cli-0.4.6}/src/minder/application/admin/use_cases.py

@@ -6,6 +6,7 @@ from collections import Counter
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
+
 from urllib.parse import urlsplit
 
 from minder.application.admin.dto import (
@@ -49,13 +50,19 @@ from minder.application.admin.dto import (
     WorkflowListPayload,
     WorkflowPayload,
     WorkflowStepPayload,
+    SessionPayload,
+    SessionListPayload,
+    SessionDetailPayload,
 )
 from minder.auth.service import AuthService
 from minder.config import MinderConfig
+from minder.observability.audit import AuditEmitter
 from minder.store.interfaces import IGraphRepository, IOperationalStore
 from minder.tools.graph import GraphTools
 from minder.tools.registry import SCOPEABLE_TOOLS
 
+_UNSET: Any = object()  # sentinel for optional update fields
+
 DASHBOARD_TOOL_SCOPE_OPTIONS = [tool.name for tool in SCOPEABLE_TOOLS]
 
 DASHBOARD_TOOL_SCOPE_PRESETS: dict[str, list[str]] = {
@@ -96,6 +103,7 @@ class AdminConsoleUseCases:
         self._config = config
         self._graph_store = graph_store
         self._graph_tools = GraphTools(graph_store, store)
+        self._audit = AuditEmitter(store)
 
     async def has_admin_users(self) -> bool:
         return await self._auth_service.has_admin_users()
@@ -413,6 +421,7 @@ class AdminConsoleUseCases:
             "resource_name": None,
             "outcome": event.outcome,
             "created_at": event.created_at.isoformat() if event.created_at else None,
+            "audit_metadata": getattr(event, "audit_metadata", None),
         }
 
     async def serialize_audit_event_enriched(self, event: Any) -> AuditEventPayload:
@@ -481,6 +490,17 @@ class AdminConsoleUseCases:
             role=role,
             password=password,
         )
+        await self._audit.emit(
+            actor_type="admin",
+            actor_id=str(user.id),  # in this context, the new user IS the actor if it's initial setup?
+            # actually, if an admin creates a user, we should know WHO did it.
+            # but create_user use case doesn't take actor_id yet.
+            event_type="user.created",
+            resource_type="user",
+            resource_id=str(user.id),
+            outcome="success",
+            metadata={"username": username, "role": role},
+        )
         return {"user": self.serialize_user(user), "api_key": api_key}
 
     async def get_user_detail(self, user_id: uuid.UUID) -> UserDetailPayload:
@@ -514,6 +534,16 @@ class AdminConsoleUseCases:
         updated = await self._store.update_user(user_id, **kwargs)
         if updated is None:
             raise LookupError(f"User {user_id} not found")
+
+        await self._audit.emit(
+            actor_type="admin",
+            actor_id=str(user_id),  # same issue: no actor_id passed to use case
+            event_type="user.updated",
+            resource_type="user",
+            resource_id=str(user_id),
+            outcome="success",
+            metadata={"fields_changed": list(kwargs.keys())},
+        )
         return await self.get_user_detail(user_id)
 
     async def deactivate_user(self, user_id: uuid.UUID) -> UserDetailPayload:
@@ -623,6 +653,78 @@ class AdminConsoleUseCases:
             ),
         }
 
+    # ------------------------------------------------------------------
+    # Session management
+    # ------------------------------------------------------------------
+
+    async def list_sessions(self) -> SessionListPayload:
+        sessions = await self._store.list_sessions()
+        return {"sessions": [self.serialize_session(s) for s in sessions]}
+
+    async def get_session_detail(self, session_id: uuid.UUID) -> SessionDetailPayload:
+        session = await self._store.get_session_by_id(session_id)
+        if session is None:
+            raise LookupError(f"Session {session_id} not found")
+        return {"session": self.serialize_session(session)}
+
+    async def update_session(
+        self,
+        session_id: uuid.UUID,
+        *,
+        state: dict[str, Any] | None = None,
+        active_skills: dict[str, Any] | None = None,
+        project_context: dict[str, Any] | None = None,
+    ) -> SessionPayload:
+        existing = await self._store.get_session_by_id(session_id)
+        if existing is None:
+            raise LookupError(f"Session {session_id} not found")
+        updates: dict[str, Any] = {}
+        if state is not None:
+            updates["state"] = state
+        if active_skills is not None:
+            updates["active_skills"] = active_skills
+        if project_context is not None:
+            updates["project_context"] = project_context
+        if not updates:
+            return self.serialize_session(existing)
+        from datetime import UTC, datetime
+        updates["last_active"] = datetime.now(UTC)
+        updated = await self._store.update_session(session_id, **updates)
+        if updated is None:
+            raise LookupError(f"Session {session_id} not found")
+        return self.serialize_session(updated)
+
+    async def delete_session(self, session_id: uuid.UUID) -> dict[str, bool]:
+        existing = await self._store.get_session_by_id(session_id)
+        if existing is None:
+            raise LookupError(f"Session {session_id} not found")
+        await self._store.delete_session(session_id)
+        return {"deleted": True}
+
+    @staticmethod
+    def serialize_session(session: Any) -> SessionPayload:
+        return {
+            "id": str(session.id),
+            "user_id": str(session.user_id) if session.user_id else None,
+            "client_id": str(session.client_id) if session.client_id else None,
+            "name": session.name,
+            "repo_id": str(session.repo_id) if session.repo_id else None,
+            "project_context": dict(getattr(session, "project_context", {}) or {}),
+            "active_skills": dict(getattr(session, "active_skills", {}) or {}),
+            "state": dict(getattr(session, "state", {}) or {}),
+            "ttl": int(getattr(session, "ttl", 86400) or 86400),
+            "created_at": (
+                session.created_at.isoformat()
+                if getattr(session, "created_at", None)
+                else ""
+            ),
+            "last_active": (
+                session.last_active.isoformat()
+                if getattr(session, "last_active", None)
+                else ""
+            ),
+        }
+
     # ------------------------------------------------------------------
     # Repository management
     # ------------------------------------------------------------------
@@ -661,6 +763,7 @@ class AdminConsoleUseCases:
         remote_url: str | None = None,
         default_branch: str | None = None,
         path: str | None = None,
+        workflow_id: Any = _UNSET,
     ) -> RepositoryDetailPayload:
         repository = await self._store.get_repository_by_id(repo_id)
         if repository is None:
@@ -687,6 +790,15 @@ class AdminConsoleUseCases:
             if not normalized_path:
                 raise ValueError("Repository path is required")
             updates["state_path"] = normalized_path
+        if workflow_id is not _UNSET:
+            if workflow_id is None or str(workflow_id).strip() == "":
+                updates["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)
 
         updated = await self._store.update_repository(repo_id, **updates)
         if updated is None:
@@ -772,6 +884,7 @@ class AdminConsoleUseCases:
         tracked: list[str] = (
             list(raw_branches) if isinstance(raw_branches, list) else []
         )
+        raw_workflow_id = getattr(repo, "workflow_id", None)
         return {
             "id": str(repo.id),
             "name": getattr(repo, "repo_name", getattr(repo, "name", "")),
@@ -779,6 +892,7 @@ class AdminConsoleUseCases:
             "remote_url": _normalize_repository_remote(getattr(repo, "repo_url", None)),
             "default_branch": getattr(repo, "default_branch", None),
             "tracked_branches": tracked,
+            "workflow_id": str(raw_workflow_id) if raw_workflow_id else None,
             "workflow_name": getattr(state, "workflow_name", None) if state else None,
             "workflow_state": getattr(state, "state", None) if state else None,
             "current_step": getattr(state, "current_step", None) if state else None,

{minder_cli-0.4.4 → minder_cli-0.4.6}/src/minder/bootstrap/providers.py

@@ -87,6 +87,18 @@ def build_graph_store(config: MinderConfig) -> IGraphRepository | None:
         if provider == "mongodb":
             provider = "sqlite"
 
+    if provider == "mongodb":
+        from minder.store.mongodb.client import MongoClient
+        from minder.store.mongodb.graph_store import MongoGraphStore
+
+        client = MongoClient(
+            uri=config.mongodb.uri,
+            database=config.mongodb.database,
+            min_pool_size=config.mongodb.min_pool_size,
+            max_pool_size=config.mongodb.max_pool_size,
+        )
+        return MongoGraphStore(client)  # type: ignore[return-value]
+
     if provider in ("sqlite", "postgresql"):
         from minder.store.graph import KnowledgeGraphStore
 
@@ -105,5 +117,5 @@ def build_graph_store(config: MinderConfig) -> IGraphRepository | None:
 
     raise ValueError(
         f"Unsupported graph_store.provider '{provider}'. "
-        "Supported: 'auto', 'sqlite', 'postgresql'."
+        "Supported: 'auto', 'mongodb', 'sqlite', 'postgresql'."
     )

{minder_cli-0.4.4 → minder_cli-0.4.6}/src/minder/bootstrap/transport.py

@@ -274,6 +274,12 @@ def build_transport(
             open_files=open_files,
         )
 
+    async def minder_session_summarize(
+        *, user=None, session_id: str
+    ) -> dict[str, Any]:  # noqa: ANN001
+        del user
+        return await session_tools.minder_session_summarize(uuid.UUID(session_id))
+
     async def minder_session_cleanup(
         *,
         user=None,
@@ -368,6 +374,22 @@ def build_transport(
         del user
         return await memory_tools.minder_memory_list()
 
+    async def minder_memory_update(
+        *,
+        user=None,
+        memory_id: str,
+        title: str | None = None,
+        content: str | None = None,
+        tags: list[str] | None = None,
+    ) -> dict[str, Any]:  # noqa: ANN001
+        del user
+        return await memory_tools.minder_memory_update(
+            memory_id,
+            title=title,
+            content=content,
+            tags=tags,
+        )
+
     async def minder_memory_delete(
         *, user=None, skill_id: str
     ) -> dict[str, bool]:  # noqa: ANN001
@@ -456,6 +478,7 @@ def build_transport(
         artifact_types: list[str] | None = None,
         provenance: str | None = None,
         quality_score: float | None = None,
+        deprecated: bool | None = None,
     ) -> dict[str, Any]:  # noqa: ANN001
         del user
         return await skill_tools.minder_skill_update(
@@ -468,6 +491,7 @@ def build_transport(
             artifact_types=artifact_types,
             provenance=provenance,
             quality_score=quality_score,
+            deprecated=deprecated,
         )
 
     async def minder_skill_delete(
@@ -669,6 +693,12 @@ def build_transport(
         require_auth=True,
         description=TOOL_DESCRIPTIONS["minder_session_context"],
     )
+    transport.register_tool(
+        "minder_session_summarize",
+        minder_session_summarize,
+        require_auth=True,
+        description=TOOL_DESCRIPTIONS["minder_session_summarize"],
+    )
     transport.register_tool(
         "minder_session_cleanup",
         minder_session_cleanup,
@@ -717,6 +747,12 @@ def build_transport(
         require_auth=True,
         description=TOOL_DESCRIPTIONS["minder_memory_list"],
     )
+    transport.register_tool(
+        "minder_memory_update",
+        minder_memory_update,
+        require_auth=True,
+        description=TOOL_DESCRIPTIONS["minder_memory_update"],
+    )
     transport.register_tool(
         "minder_memory_delete",
         minder_memory_delete,

{minder_cli-0.4.4 → minder_cli-0.4.6}/src/minder/config.py

@@ -46,7 +46,7 @@ class LLMConfig(BaseModel):
     litert_model_path: str = "~/.minder/models/gemma-4-E2B-it.litertlm"
     litert_backend: str = "auto"  # "auto" (GPU on Mac, CPU elsewhere) | "cpu" | "gpu"
     litert_cache_dir: str = "~/.minder/cache/litert"
-    context_length: int = 32768
+    context_length: int = 16384
     temperature: float = 0.1
     openai_api_key: Optional[str] = None
     openai_model: str = "gpt-4o-mini"
@@ -67,16 +67,17 @@ class RelationalStoreConfig(BaseModel):
 
 class GraphStoreConfig(BaseModel):
     enabled: bool = True
-    provider: str = "auto"  # "auto" | "sqlite" | "postgresql"
-    db_path: str = "~/.minder/data/graph.db"  # used by sqlite
-    uri: str = "postgresql+asyncpg://localhost/minder_graph"  # used by postgresql
+    provider: str = "auto"  # "auto" | "mongodb" | "sqlite" | "postgresql"
+    # auto: mirrors relational_store.provider (mongodb → mongodb, sqlite → sqlite, postgresql → postgresql)
+    db_path: str = "~/.minder/data/graph.db"  # sqlite only
+    uri: str = "postgresql+asyncpg://localhost/minder_graph"  # postgresql only
 
 
 class MongoDBConfig(BaseModel):
     uri: str = "mongodb://localhost:27017"
     database: str = "minder"
-    min_pool_size: int = 5
-    max_pool_size: int = 50
+    min_pool_size: int = 2
+    max_pool_size: int = 10
 
 
 class RedisConfig(BaseModel):

minder_cli-0.4.6/src/minder/context_compactor.py

@@ -0,0 +1,197 @@
+"""
+Compacts chat history to fit within the LLM context window.
+
+Strategy (HistoryCompactor):
+- Always keep the `keep_recent` most recent messages verbatim (recency bias).
+- If older messages still fit in the remaining budget, keep them all.
+- Otherwise drop oldest messages and prepend a single notice message so the
+  LLM knows part of the history was omitted.
+
+No LLM call is made here — this is a pure sliding-window approach so it adds
+zero latency on every query.
+
+P7-T06 — SummarizingCompactor extends the base with an optional LLM
+summarization step: dropped messages are condensed into a single summary
+message instead of a terse omission notice.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Approximate chars-per-token for chat content (UTF-8 prose / code mix).
+_CHARS_PER_TOKEN = 3
+
+
+class HistoryCompactor:
+    """Trims chat_history to fit within a fraction of the LLM context window."""
+
+    def __init__(
+        self,
+        *,
+        keep_recent: int = 6,
+        history_budget_ratio: float = 0.40,
+    ) -> None:
+        # keep_recent: number of latest messages always preserved verbatim.
+        # history_budget_ratio: fraction of context_length tokens available for history.
+        self._keep_recent = keep_recent
+        self._history_budget_ratio = history_budget_ratio
+
+    def compact(
+        self,
+        history: list[dict[str, Any]],
+        *,
+        context_length: int,
+    ) -> list[dict[str, Any]]:
+        """Return a (possibly shorter) history list that fits within the budget.
+
+        If messages are dropped a synthetic notice is prepended so the model
+        knows earlier context exists but was truncated.
+        """
+        if not history:
+            return []
+
+        budget_chars = int(context_length * self._history_budget_ratio) * _CHARS_PER_TOKEN
+        total_chars = sum(len(str(m.get("content", ""))) for m in history)
+
+        if total_chars <= budget_chars:
+            return history
+
+        # Split into recent (always kept) and older (candidates for dropping).
+        if len(history) > self._keep_recent:
+            recent = history[-self._keep_recent :]
+            older = history[: -self._keep_recent]
+        else:
+            recent = list(history)
+            older = []
+
+        recent_chars = sum(len(str(m.get("content", ""))) for m in recent)
+
+        # If even the recent slice alone exceeds the budget, truncate from the
+        # oldest message in that slice (keeping tail content within each message).
+        if recent_chars > budget_chars:
+            recent = self._fit_to_budget(recent, budget_chars)
+            dropped_count = len(history) - len(recent)
+            logger.warning(
+                "chat_history compacted: dropped %d messages (context_length=%d)",
+                dropped_count,
+                context_length,
+            )
+            if dropped_count > 0:
+                return [_notice(dropped_count)] + recent
+            return recent
+
+        # Fit as many older messages as possible within leftover budget.
+        older_budget = budget_chars - recent_chars
+        kept_older = self._fit_to_budget(older, older_budget)
+        dropped_count = len(older) - len(kept_older)
+
+        if dropped_count > 0:
+            logger.info(
+                "chat_history compacted: dropped %d older messages (context_length=%d)",
+                dropped_count,
+                context_length,
+            )
+            return [_notice(dropped_count)] + kept_older + recent
+
+        return kept_older + recent
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _fit_to_budget(
+        messages: list[dict[str, Any]],
+        budget_chars: int,
+    ) -> list[dict[str, Any]]:
+        """Return the maximal tail of *messages* whose total chars ≤ budget_chars."""
+        kept: list[dict[str, Any]] = []
+        remaining = budget_chars
+        for msg in reversed(messages):
+            content = str(msg.get("content", ""))
+            if remaining <= 0:
+                break
+            if len(content) > remaining:
+                # Truncate the message to fit, keeping the tail (most recent content).
+                truncated = {**msg, "content": "…" + content[-(remaining - 1) :]}
+                kept.insert(0, truncated)
+                remaining = 0
+            else:
+                kept.insert(0, msg)
+                remaining -= len(content)
+        return kept
+
+
+def _notice(dropped_count: int) -> dict[str, Any]:
+    return {
+        "role": "user",
+        "content": (
+            f"[{dropped_count} earlier message(s) omitted — context window limit reached]"
+        ),
+    }
+
+
+class SummarizingCompactor(HistoryCompactor):
+    """P7-T06 — Compactor that replaces omission notices with LLM summaries.
+
+    The `summarizer` callable receives the list of dropped messages and
+    returns a short summary string.  If the callable raises or returns an
+    empty string, the base-class omission notice is used as a fallback.
+
+    Because summarization adds latency, only activate this when an LLM is
+    available and the history budget is genuinely exceeded.
+    """
+
+    def __init__(
+        self,
+        summarizer: Callable[[list[dict[str, Any]]], str],
+        *,
+        keep_recent: int = 6,
+        history_budget_ratio: float = 0.40,
+    ) -> None:
+        super().__init__(
+            keep_recent=keep_recent,
+            history_budget_ratio=history_budget_ratio,
+        )
+        self._summarizer = summarizer
+
+    def compact(
+        self,
+        history: list[dict[str, Any]],
+        *,
+        context_length: int,
+    ) -> list[dict[str, Any]]:
+        budget_chars = int(context_length * self._history_budget_ratio) * _CHARS_PER_TOKEN
+        total_chars = sum(len(str(m.get("content", ""))) for m in history)
+
+        if total_chars <= budget_chars:
+            return history
+
+        if len(history) > self._keep_recent:
+            recent = history[-self._keep_recent :]
+            dropped = history[: -self._keep_recent]
+        else:
+            return super().compact(history, context_length=context_length)
+
+        summary_message = self._summarize(dropped)
+        recent_chars = sum(len(str(m.get("content", ""))) for m in recent)
+        summary_chars = len(str(summary_message.get("content", "")))
+
+        if recent_chars + summary_chars <= budget_chars:
+            return [summary_message] + recent
+
+        return super().compact(history, context_length=context_length)
+
+    def _summarize(self, dropped: list[dict[str, Any]]) -> dict[str, Any]:
+        try:
+            text = self._summarizer(dropped)
+            if text and text.strip():
+                return {"role": "user", "content": f"[Earlier context summary: {text.strip()}]"}
+        except Exception as exc:
+            logger.debug("SummarizingCompactor summarizer failed: %s", exc)
+        return _notice(len(dropped))

{minder_cli-0.4.4 → minder_cli-0.4.6}/src/minder/graph/executor.py

@@ -4,12 +4,14 @@ from dataclasses import dataclass, field
 
 from minder.graph.edges import determine_next_edge
 from minder.graph.nodes import (
+    ClarificationNode,
     EvaluatorNode,
     GuardNode,
     LLMNode,
     PlanningNode,
     ReasoningNode,
     RerankerNode,
+    ReflectionNode,
     RetrieverNode,
     VerificationNode,
     WorkflowPlannerNode,
@@ -22,6 +24,7 @@ from minder.graph.state import GraphState
 class GraphNodes:
     workflow_planner: WorkflowPlannerNode
     planning: PlanningNode
+    clarification: ClarificationNode
     retriever: RetrieverNode
     reasoning: ReasoningNode
     llm: LLMNode
@@ -29,6 +32,7 @@ class GraphNodes:
     verification: VerificationNode
     evaluator: EvaluatorNode
     reranker: RerankerNode | None = field(default=None)
+    reflection: ReflectionNode | None = field(default=None)
 
 
 class InternalGraphExecutor:
@@ -41,6 +45,9 @@ class InternalGraphExecutor:
         state.metadata["orchestration_runtime"] = "internal"
         state = await self._nodes.workflow_planner.run(state)
         state = self._nodes.planning.run(state)
+        state = self._nodes.clarification.run(state)
+        if state.metadata.get("needs_clarification"):
+            return state
         state = await self._nodes.retriever.run(state)
         if self._nodes.reranker is not None:
             state = await self._nodes.reranker.run(state)
@@ -88,6 +95,10 @@ class InternalGraphExecutor:
 
         state = self._nodes.evaluator.run(state)
         state.metadata["edge"] = determine_next_edge(state)
+
+        if self._nodes.reflection is not None:
+            state = await self._nodes.reflection.run(state)
+
         return state